总计为A的N个整数的不同组的数量

Question

I want to calculate the number of different ordered groups of N integers so that the elements of each group sums up to A

For instance: if N = 3 and A = 3 the result should be 10:
1 = [3, 0, 0]
2 = [2, 1, 0]
3 = [1, 2, 0]
4 = [0, 3, 0]
5 = [2, 0, 1]
6 = [1, 1, 1]
7 = [0, 2, 1]
8 = [1, 0, 2]
9 = [0, 1, 2]
10 = [0, 0, 3]

the way I did it was by brute-force:

public static int calc(int a, int n){
    if (n <= 1 || a == 0) return 1;

    int sum = 0;
    for (int i=0; i<=n; i++)
        sum += calc(a - i, n - 1);

    return sum;
}

i suspect that there can be a better way (some mathematical calculation that I missing..) is there?

EDIT In the original question i forgot to take into consideration the order

Answer 1

This is combinatorial composition of A into N parts (including zero parts). Number of compositions for pair (A, N) is equal to C(A + N - 1, A), where C() is combination number aka binomial coefficient. See the same formula here and here

Answer 2

Imagine big segment of length A . And imagine N-1 ordered separators, dividing the segment into parts. Hence, each part is a summand while entire segment is a sum.

Ergo, all you need is just to provide algorithm to enumerate separators location.

First separator you can put into any of N+1 positions P_0={0,1,...N}

Second separator can go into any of P_1={P_0,...N}

And so on.

You can use recursion to implement this.

Answer 3

I am sure there is a mathematical calculation to answer this, but since this is a programming Q&A, I'll tell you how to make your program give the answer faster: you can use memoization .

Currently, your program re-calculates the answer to calc(a, n) every time. However, the answer can be calculated once, because it does not change in subsequent invocations. Add a 2D array for the result of calc(a,n) , initialize with -1 , and use it to look up results before calculating them to save a lot of time re-calculating the same numbers over and over:

private static int[][] memo = new int[30][30];
static {
    for(int i = 0 ; i != 30 ; i++)
        for(int j = 0 ; j != 30 ; j++)
            memo[i][j] = -1;
}
public static int calc(int a, int n){
    if (n <= 1 || a == 0) return 1;
    if (memo[a][n] > 0) return memo[a][n];
    int sum = 0;
    for (int i=0; i<=n; i++)
        sum += calc(a - i, n - 1);
    return (memo[a][n] = sum);
}

Answer 4

For enumeration: Use the formula given in other solutions above, WAY MORE EFFICIENT. You never want to actually generate a full set of n-integer compositions unless it is required. They carry intractable properties especially if you want to only total them, not generate them. Generating them is another problem...

For generation: Use a loopless algorithm... There are numerous O(1)-per gray code sequence results out there. There are very few variations of restricted integer compositions out there that do not have or can have loopless algorithms. Many algorithms in this class of problems for integer compositions, most of which are very specific but there are plenty modern loopless algorithms which exist for this specific problem. Super efficient. Brute force is never the way to go with this problem unless you got a lot of parallel computing at your disposal. Google or Google Scholar is at your disposal! :D

Hope this helps!

Answer 5

I found another solution, just with recursion and without separators:

public class App201210121604 {

public static Vector<int[]> split(int sum, int count) {

    if( sum < 0 ) {
        throw new IllegalArgumentException("Negative sum is not allowed");
    }

    Vector<int[]> ans = new Vector<int[]>();

    // "reserved" end of recursion
    if( count <= 0 ) {
        // nothing to do
    }

    // end of recursion
    else if( count == 1 ) {
        ans.add(new int[] {sum});
    }

    // body of recursion
    else {
        // for each first summand from 0 to summ
        for(int i=0; i<=sum; ++i) {

            // do a recursion to get the "tail"
            for(int[] tail : split(sum-i, count-1)) {

                int[] group = new int[count];
                group[0] = i;
                System.arraycopy(tail, 0, group, 1, count-1);

                ans.add(group);
            }
        }
    }

    return ans;
}

public static void main(String[] args) {

    Vector<int[]> ans = split(8, 4);

    for(int[] group : ans) {
        for(int i=0; i<group.length; ++i) {
            if( i>0 ) System.out.print("+");
            System.out.print(group[i]);
        }
        System.out.println("");
    }
}

}