Java 生成一个集合到另一个集合的所有可能（无序）赋值的算法

鉴于：

一套颜色独特的蜡笔（尺寸为x）

一群孩子

所有的蜡笔都必须分配给孩子们

一个孩子可能有零到x支蜡笔

每支蜡笔的结尾应该正好有一个孩子。不能将蜡笔分配给2个或更多子级

我如何找到所有可能的作业组合

例如：

class Crayon {
    String color;

    public Crayon(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    @Override
    public String toString() {
        return color;
    }
}


class Child {

    String name;
    Set<Crayon> crayons;

    public Child(String name) {
        this.name = name;
        crayons = new HashSet<Crayon>();
    }

    public void addCrayon(Crayon crayon) {
        crayons.add(crayon);
    }

    public Set<Crayon> getCrayons() {
        return crayons;
    }

    @Override
    public String toString() {
        return "Child [name=" + name + ", crayons=" + crayons + "]";
    }
}

public class DistributeCrayons {

    public static void main(String[] args) {

        Set<Crayon> crayons = new HashSet<>();
        crayons.add(new Crayon("red"));
        crayons.add(new Crayon("blue"));
        crayons.add(new Crayon("green"));
        crayons.add(new Crayon("orange"));
        crayons.add(new Crayon("brown"));
        crayons.add(new Crayon("yellow"));
        crayons.add(new Crayon("purple"));

        Child bob = new Child("bob");
        Child amy = new Child("amy");
        Child tom = new Child("tom");

        for(??) {
            for(??) {
                ??
                    System.out.println(bob +" "+ amy +" "+ tom);
                ??
            }
        }
    }
}

class蜡笔{
字符串颜色；
公共蜡笔（字符串颜色）{
这个颜色=颜色；
}
公共字符串getColor（）{
返回颜色；
}
@凌驾
公共字符串toString（）{
返回颜色；
}
}
班童{
字符串名；
设置蜡笔；
公共子项（字符串名称）{
this.name=名称；
蜡笔=新的HashSet（）；
}
公共空白添加蜡笔（蜡笔蜡笔）{
蜡笔。添加（蜡笔）；
}
公共设置getCrayons（）{
返回蜡笔；
}
@凌驾
公共字符串toString（）{
返回“Child[name=“+name+”，crayons=“+crayons+”]”；
}
}
公共类分发{
公共静态void main（字符串[]args）{
Set crayons=new HashSet（）；
蜡笔。添加（新蜡笔（“红色”））；
蜡笔。添加（新蜡笔（“蓝色”））；
蜡笔。添加（新蜡笔（“绿色”））；
添加（新蜡笔（“橙色”）；
蜡笔。添加（新蜡笔（“棕色”）；
蜡笔。添加（新蜡笔（“黄色”））；
蜡笔。添加（新蜡笔（“紫色”）；
孩子鲍勃=新孩子（“鲍勃”）；
孩子艾米=新孩子（“艾米”）；
儿童汤姆=新生儿童（“汤姆”）；
对于（？？）{
对于（？？）{
??
System.out.println（bob+“”+amy+“”+tom）；
??
}
}
}
}

这将输出所有可能的赋值组合，例如：

孩子[姓名=鲍勃，蜡笔=[绿色，蓝色]]孩子[姓名=艾米，蜡笔=[棕色，红色]]孩子[姓名=汤姆，蜡笔=[黄色，紫色，橙色]]

Child[name=bob，crayons=[]Child[name=amy，crayons=[棕色，红色，蓝色]]Child[name=tom，crayons=[黄色，紫色，橙色，绿色]]

Child[name=bob，crayons=[red]]Child[name=amy，crayons=[brown，green，purple，orange]]Child[name=tom，crayons=[blue，yellow]]

等等

更新

感谢大家的宝贵反馈，并感谢大家提供了一个可行的js解决方案。（很抱歉，由于声誉问题，我无法投票或接受答案）

我现在可以把我的头绕在它周围了，这是我的解决方案版本：

我把蜡笔和孩子们变成了列表而不是集合对于7支蜡笔（红色、蓝色、绿色、橙色、棕色、黄色、紫色）的列表，我的目标是以7个字符的单词的形式为三个孩子bob（id=“b”）、amy（id=“a”）和tom（id=“t”）生成所有作业。例如：“tbbbtat”这样的单词表示tom得到红色、棕色和紫色蜡笔，bob得到蓝色，绿色和橙色的蜡笔，艾米得到黄色的

public class DistributeCrayons {

    public static void main(String[] args) {

        List<Crayon> crayons = new ArrayList<>();
        crayons.add(new Crayon("red"));
        crayons.add(new Crayon("blue"));
        crayons.add(new Crayon("green"));
        crayons.add(new Crayon("orange"));
        crayons.add(new Crayon("brown"));
        crayons.add(new Crayon("yellow"));
        crayons.add(new Crayon("purple"));

        List<Child> children = new ArrayList<>();
        children.add(new Child("b"));
        children.add(new Child("a"));
        children.add(new Child("t"));

        List<String> assignments = null;
        for(int i = 0; i < crayons.size(); i++)
            assignments = addCrayonCombos(assignments, children);

        System.out.println(assignments);

    }

    static List<String> addCrayonCombos(List<String> assignments, List<Child> children) {
        if(assignments == null) {
            assignments = new ArrayList<String>();
            for(Child c: children)
                assignments.add(c.getId());
            return assignments;
        } else {
            List<String> updatedAssignments = new ArrayList<String>();
            for(String assignment: assignments) {
                for(Child c: children)
                    //append next permutations for a new crayon to existing "words"
                    updatedAssignments.add(assignment+c.getId());
            }
            return updatedAssignments;
        }
    }
}

公共类分发副本{
公共静态void main（字符串[]args）{
列表蜡笔=新的ArrayList（）；
蜡笔。添加（新蜡笔（“红色”））；
蜡笔。添加（新蜡笔（“蓝色”））；
蜡笔。添加（新蜡笔（“绿色”））；
添加（新蜡笔（“橙色”）；
蜡笔。添加（新蜡笔（“棕色”）；
蜡笔。添加（新蜡笔（“黄色”））；
蜡笔。添加（新蜡笔（“紫色”）；
List children=new ArrayList（）；
儿童。添加（新儿童（“b”）；
儿童。添加（新儿童（“a”）；
儿童。添加（新儿童（“t”）；
列表分配=空；
对于（int i=0；i

---

这将生成预期的赋值词列表（准确地说是2187个词），因为7个蜡笔中的每一个都有3种可能（即3^7=2187）。

如果我正确理解了你的问题，这将是方式比两个嵌套的

循环更复杂

我将给你一个问题陈述和一些伪代码，也许你可以从中实现它

您有两套：

蜡笔组。我们称之为
C
人们开始行动了。我们称之为
P
以你为例,

C = {"red", "orange", "yellow", "green", "blue", "purple", "brown"}
P = {"bob", "amy", "tom"}

因此，您需要实现一个函数
DistributeCrayons（Set p，Set C）
，该函数找到了在
C
中向
p
中的人分发蜡笔的所有方法，在
p
中，对于任何给定的分发，我们都可以为
p
中的每个人提供零支或更多的蜡笔。如果
P
中至少有一个人在
A
中有一支他们在
B
中没有的蜡笔，那么
A
和
B
两种分布是不同的

我将给出一个递归实现，因为这是最简单的考虑：

DistributeCrayons(Set<People> P, Set<Crayons> C):
    for subset C' of C:
        for person P' in P:
            assign C' to P'

            if (P - P') == {}:
                return assignments
            else:
                DistributeCrayons(C - C', P - P')

DistributeCrayons（集合P，集合C）：
对于C的子集C'：
对于P中的P'人：
将C'分配给P'
如果（P-P'）={}：
返回任务
其他：
分配薪酬（C-C'，P-P'）

其中：

用于C的子集C
遍历所有可能的子集