Algorithm 使用递归生成可能的值分配结果

我试图提出一种递归算法，在完全随机的情况下，生成所有可能的子-父赋值可能性

例如，假设我有3个孩子和2个父母，所有的孩子将随机分配给每个父母，结果如下

   Parent 1       Parent 2

   0 Children     3 Children
   1 Children     2 Children
   2 Children     1 Children 
   3 Children     0 Children   

我一直在努力寻找一种方法来递归地提供孩子和父母的数量以及其他变量来跟踪当前状态，但一直找不到任何有效的方法。它需要为任何数量的父母和孩子工作

---

有人有什么想法吗？我正在用Java编写代码，虽然不是代码，而是算法，我需要帮助

假设您有n个孩子和k个父母。然后，以下算法（在伪java中）应该可以工作：

int[] childrensForParent = new int[k];

/**
* Method assigns numberOfChildren children to parents with indices from 
* parentIndex to k-1
*/
void assignChildren(int parentIndex, int numberOfChildren) {
    if(parentIndex==k-1) {
         //All children left go to the last parent in a row
         childrensForParent[parentIndex] = numberOfChildren;
         //Do something with the result
         output(childrensForParent);
         return;
    } 
    for(int childrenCount= 0; childrenCount<=numberOfChildren; childrenCount++) {
        //assign children to current parent
        childrensForParent[parentIndex] = childrenCount;
        //assign children that left to next parents
        assignChildren(parentIndex+1, numberOfChildren-childrenCount);
    }
}

//Method call
assignChildren(0,n);

int[]childrensForParent=newint[k]；
/**
*方法将numberOfChildren分配给索引为
*k-1的父索引
*/
void assignChildren（int parentIndex，int numberOfChildren）{
if（parentIndex==k-1）{
//所有剩余的子项将转到一行中的最后一个父项
childrensForParent[家长索引]=子女人数；
//对结果做点什么
输出（儿童家长）；
回来
} 
对于（int childrenCount=0；childrenCount，这完全是未经测试的，但您可以从以下逻辑/伪代码开始：

// Define your starting objects/data
define a parent object that has a list field of children
define "parents" as an array of parent objects
define "children" as an array of children objects

// Prepare the data
randomize the "children" array via a shuffling algorithm

// Define your recursive method
define recursiveAssignChildren(parents, children):
    if children is empty, exit method
    take the first element of "children" and assign it to a random parent
    define lessChildren as children, excluding the first element that was already assigned to a parent
    call recursiveAssignChildren(parents, lessChildren)

// Call the recursive method to start process
call recursiveAssignChildren(parents, children)

许多问题都是由问题解决者制作的。这可以通过在别人给你讲谜语时制作问题来实现（长句，少信息）.所以，为了揭示这个问题，你会这样想：你没有处理这个问题，因为孩子需要以各种可能的方式分配给父母，你有两个数字n1，n2（孩子的数量，父母的数量）你想用n2加法来加n1，所以如果你有3个孩子需要分配给2个家长，你想用2个加法运算来形成3

   void generateAll(int c, int p, string str)
{
    if (c == 0 && p == 0)
    {
        cout << str << endl;
        return;
    }
    // if there are no parents and c > 0 then no children going to be asigned to any parent
    if (p == 0 && c > 0)
        return;
    // loop throug number of children 
    for (int i = 0; i <= c; i++)
    {
        generateAll(c - i, p - 1, str + "\t"+ toString(i));
    }
}

void generateAll（int c、int p、string str）
{
如果（c==0&&p==0）
{
cout（0）
回来
//循环遍历子对象的数量
对于（inti=0；i），这看起来是创建随机分区（洗牌子分区）的好方法.但它似乎不会产生所有可能的结果。哎呀，这似乎是对问题的误解！你是对的，这个算法只会产生一个结果，而不是所有可能的结果。嗯，我不确定OP想的是什么。也许你的答案会适合他/她的需要。