Question

The problem:

Larry is very bad at math – he usually uses a calculator, which worked well throughout college. Unforunately, he is now struck in a deserted island with his good buddy Ryan after a snowboarding accident. They’re now trying to spend some time figuring out some good problems, and Ryan will eat Larry if he cannot answer, so his fate is up to you!

It’s a very simple problem – given a number N, how many ways can K numbers less than N add up to N?

For example, for N = 20 and K = 2, there are 21 ways:

0+20
1+19
2+18
3+17
4+16
5+15
...
18+2
19+1
20+0

Input
Each line will contain a pair of numbers N and K. N and K will both be an integer from 1 to 100, inclusive. The input will terminate on 2 0’s.
Output
Since Larry is only interested in the last few digits of the answer, for each pair of numbers N and K, print a single number mod 1,000,000 on a single line.

Sample Input

20 2
20 2
0 0

Sample Output

21
21

The solution code:

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
#define maxn 100

typedef long ss;
ss T[maxn+2][maxn+2];

void Gen() {
    ss i, j;
    for(i = 0; i<= maxn; i++)
        T[1][i] = 1;
    for(i = 2; i<= 100; i++) {
        T[i][0] = 1;
        for(j = 1; j <= 100; j++)
            T[i][j] = (T[i][j-1] + T[i-1][j]) % 1000000;
    }
}

int main() {
    //freopen("in.txt", "r", stdin);
    ss n, m;
    Gen();
    while(cin>>n>>m) {
        if(!n && !m) break;
        cout<<T[m][n]<<endl;
    }
    return 0;
}

How has this calculation been derived?
How has it come T[i][j] = (T[i][j-1] + T[i-1][j]) ?

Answer 1

Note: I only use n and k (lower case) to refer to some anonymous variable. I will always use N and K (upper case) to refer to N and K as defined in the question (sum and the number of portions).

Let C(n, k) be the result of n choose k, then the solution to the problem is C(N + K – 1, K – 1), with the assumption that those K numbers are non-negative (or there will be infinitely many solution even for N = 0 and K = 2).

Since the K numbers are non-negative, and the sum N is fixed, we can think of the problem as: how many ways to divide candy among K people. We can divide the candies, by lying them into a line, and put (K – 1) separator between the candies. The (K – 1) separators will divide the candies up to K portions of candies. Looking at another perspective, it is also like choosing (K – 1) positions among (N + K – 1) positions to put in the separators, then the rest of the positions are candies. So, this explains why the number of ways is N + (K – 1) choose (K – 1).

Then the problem reduce to how to find the least significant digits of C(n, k). (Since maximum of N and K is 100 as defined in maxn, we don’t have to worry if the algorithm goes up to O(n³)).

---

The calculation uses this combinatorial identity C(n, k) = C(n – 1, k) + C(n, k – 1) (Pascal’s rule). The clever thing about the implementation is that it doesn’t store C(n, k) (table of result of combination, which is a jagged array), but it stores C(N, K) instead. The identity is actually present in the T[i][j] = (T[i][j-1] + T[i-1][j]):

• The first dimension is actually K, the number of portions. And the second dimension is the sum N. T[K][N] will directly store the result, and according to the mathematical result derived above, is (least significant digits of) C(N + K – 1, K – 1).

• Re-writing the T[i][j] = (T[i][j-1] + T[i-1][j]) back to equivalent mathematical result:

  C(i + j – 1, i – 1) = C(i + j – 2, i – 1) + C(i + j – 2, i – 2), which is correct according to the identity.

The program will fill the array row by row:

• The row K = 0 is already initialized to 0, using the fact that static array is initialized to 0.
• It fills the row K = 1 with 1 (there is only 1 way to divide N into 1 portion).
• For the rest of the rows, it sets the case N = 0 to 1 (there is only 1 way to divide 0 into K parts – all parts are 0).
• Then the rest are filled with the expression T[i][j] = (T[i][j-1] + T[i-1][j]), which will refer to the previous row, and the previous element of the same row, both of which has been filled up in earlier iterations.