Java M个自然数组合生成给定数（N）且重复的算法

我正在寻找一种算法，它可以打印出m个自然数的所有组合，这些组合产生一个给定的重复数（N）

假设我们的java函数是：public static String[]foo（6,3），其中6是N，3是M。
答案应该是：

0,0,6
0,1,5
0,2,4
0,3,3
1,1,4
1,2,3
2,2,2

and foo(7,4):
0,0,0,7
0,0,1,6
0,0,2,5
0,0,3,4
0,1,1,5
0,1,2,4
0,1,3,3
1,1,1,4
1,1,2,3
1,2,2,2 (if im not wrong...)

---

提前谢谢你

最简单的方法是生成长度为M的数组和N以内的所有可能的数字组合，并测试每个数组的正确结果。
非常野蛮的武力，但会起作用。你可以从那里建立（消除双倍结果…）

你可能还想看看

这可能是这样的：

import java.util.LinkedList;

public class Tests 
{

    public static void main(String[] aargh)
    {
        LinkedList<int[]> arr = numarrays(7,4);
        for(int i = 0; i< arr.size();i++)
        {
            int[] curr = arr.get(i);
            for(int j = 0; j < curr.length;j++)
            {
                System.out.print(curr[j]+" ,"); 
            }
            System.out.println();
        }
    }

    public static LinkedList<int[]> numarrays(int result, int depth)
    {
        LinkedList<int[]> retVal = new LinkedList<int[]>();

        int[][] val = new int[1][];

        while(next(result,depth,val))
        {
            if(reject(result, val[0])) continue;
            if(!accept(result, val[0])) continue;   
            retVal.add(val[0].clone());
        }

        return retVal;
    }

    private static boolean reject(int max, int[] in) 
    {
        int sum = 0;
        for(int i = 0; i< in.length; i++)
        {
            sum += in[i];
            if(sum > max) return true;
        }

        return false;
    }

    private static boolean accept(int target, int[] in) 
    {
        int sum = 0;
        for(int i = 0; i< in.length; i++)
        {
            sum += in[i];
        }

        if(sum == target) return true;

        return false;
    }

    private static boolean next(int max, int depth, int[][] val) 
    {
        if(val[0] == null)
        {
            val[0] = new int[depth];
            return true;
        }

        return nextrec(max,val[0],0);
    }

    private static boolean nextrec(int max, int[] curr, int i) 
    {
        if(i>=curr.length) return false;

        if(nextrec(curr[i],curr,i+1)) return true;

        if(curr[i]< max)
        {
            curr[i]++;
            zerorec(curr,i+1);
            return true;
        }

        return false;
    }

    private static void zerorec(int[] curr, int i) 
    {
        if(i>=curr.length) return ;
        curr[i] = 0; 
        zerorec(curr,i+1);
    }
}

import java.util.LinkedList；
公开课考试
{
公共静态void main（字符串[]aargh）
{
LinkedList arr=Numarays（7,4）；
对于（int i=0；i最大值）返回true；
}
返回false；
}
私有静态布尔接受（int目标，int[]in）
{
整数和=0；
for（int i=0；i=curr.length）返回false；
if（nextrec（curr[i]，curr，i+1））返回true；
如果（当前[i]=当前长度）返回；
curr[i]=0；
zerorec（当前，i+1）；
}
}

这里是一种递归方法，观察到您从对M个数字的要求开始，这可以分解为M-1数字的更简单问题，直到M=1

public class RecursiveCombinations {

    public static void main(String[] args) {
        solve(4,7,0,"");
    }

private static void solve(int M, int remainingValue, int previousLevel, String solutionSoFar) {
    if (M == 1) {
        System.out.println(solutionSoFar+remainingValue);
        return;
    }
    for (int i = previousLevel; i<=remainingValue/M; i++) {
        String s = solutionSoFar+i+",";
        solve(M-1, remainingValue-i, i, s);
    }
}

---

我相信你们要找的是配分函数。你们必须向我们展示你们的努力。这是规则。添加您尝试过的代码。

0,0,0,7
0,0,1,6
0,0,2,5
0,0,3,4
0,1,1,5
0,1,2,4
0,1,3,3
0,2,2,3
1,1,1,4
1,1,2,3
1,2,2,2