HUST1380NumberPyramids题解动态规划

 

NumberPyramids

Time Limit: 20 Sec  Memory Limit: 128 MB
Submissions: 91  Solved: 33

Description

 

Suppose that there are N numbers written in a row. A row above this one consists of N-1 numbers, the i-th of which is the sum of the i-th and (i+1)-th elements of the first row. Every next row contains one number less than the previous one and every element is the sum of the two corresponding elements in the row below. The N-th row contains a single number. For example, if the initial numbers are {2,1,2,4}, the whole structure will look like this:

15
6 9
3 3 6
2 1 2 4

We shall refer to such a structure as a number pyramid. Two number pyramids are equal if all the numbers at corresponding positions are equal. Given ints baseLength and top, compute the total number of different number pyramids consisting of positive integers, having baseLength elements in the first row and the value at the top equal to top. Since the number of such pyramids might be enormous, return the result modulo 1,000,000,009.

 

Input

 

Two numbers -- baseLength and top.
baseLengthwill be between 2 and 1,000,000, inclusive.
topwill be between 1 and 1,000,000, inclusive.

 

Output

 

The total number of different number pyramids Constraints

 

Sample Input

3 5
5 16
4 15
15 31556
150 500

Sample Output

2
1
24
74280915
0

HINT

 

1) The following are two possible pyramids with 3 numbers in the base and the number 5 at the top:

2) The only number pyramid with base of size 5 and 16 at the top looks like this:

 

Source

Topcoder SRM

 

 

NumberPyramids  
Used as: Division One - Level Two:

Value	500
Submission Rate	209 / 653 (32.01%)
Success Rate	161 / 209 (77.03%)
High Score	Petr for 475.02 points (6 mins 34 secs)
Average Score	289.10 (for 161 correct submissions)

The first important observation we make is that every unique pyramid corresponds to a unique base row. This follows from the following reasons:-

• If we know every element in the base row, then the rest of the pyramid is uniquely determined since we can compute the entire pyramid from bottom to top. Hence, equal base rows => equal pyramids.
• Moreover, if the base rows are unequal (i.e. there is atleast one unequal element), then clearly the pyramids are unequal. [Since we have atleast one pair of unequal elements]

Therefore, finding the number of different pyramids corresponds to finding the number of distinct base rows of length baseLength so that the top element is top.

Now, we deduce the relation between the top element and the elements in the base row.
Let us denote the jth element (0-based) of row i (row 0 being the topmost row) by x_ij, i.e. x₀₀ = top element.
x₀₀
= x₁₀ + x₁₁
= (x₂₀ + x₂₁) + (x₂₁ + x₂₂)
= x₂₀ + 2*x₂₁ + x₂₂
= (x₃₀ + x₃₁) + 2*(x₃₁ + x₃₂) + (x₃₂ + x₃₃)
= x₃₀ + 3*x₃₁ + 3*x₃₂ + x₃₃
Hey! The coefficients are the same as binomial coeffients. And they must be, since the coefficeints are being computed in the exact same way as the pascals triangle is calculated.

So we have, top = C(r,0)*x_r0 + C(r,1)*x_r1 + C(r,2)*x_r2 + ... + C(r,r)*x_rr
where r can be any row, and C(n, m) denotes the number of ways of selecting m elements from a set of n elements.
For our problem, we have r = baseLength-1, and x_ri ≥ 1.

If we define y_i as (x_ri-1), then we have
top - (∑(C(r,i)) where 0 ≤ i ≤ r) = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,r)*y_r
or, top - 2^r = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,r)*y_r
and, each y_i ≥ 0
The number of distinct base rows is equal to the number of distinct solutions we have for the above equation.

Now, let us define DP[i][j] as 'number of distinct solutions of j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,i)*y_i (where each y_k≥0)'
(We need to return DP[r][top - 2^r]).

We find a way to compute DP[i][j] = (number of distinct solutions of j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,i)*y_i (where each y_k≥0))
Two cases may arise, y_i = 0 and y_i ≥ 1
Case 1: y_i = 0
(number of distinct solutions of j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*y_i where y_i = 0 )
is simply, (number of distinct solutions of j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,i-1)*y_i-1)
= DP[i-1][j]
Case 2: y_i ≥ 1
(number of distinct solutions of j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*y_i where y_i≥1)
= (number of distinct solutions of j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*(y_i+1) where (y_i+1)≥1) ...      [Replacing y_i by (y_i+1) throughout]
= (number of distinct solutions of j-C(r,i) = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*y_i where y_i≥0) ...         [Transposing one C(r,i) from RHS to LHS & using (y_i+1)≥1 implies y_i≥0]
= DP[i][j-C(r,i)]

Since the two cases are mutually exclusive and exhaustive, we have (total number of solutions) = sum of (number of solutions) for each of the individual cases. Hence, we get
DP[i][j] = DP[i-1][j] + DP[i][j-C(r,i)]

One last observation will make our code even simpler. Notice that if we use the final recurrence to compute the values of DP in row-major order, then we never access an element more than width behind, where width is the number or columns in DP. Hence, at any point of time we need to store only the last width elements. This makes it possible for us to use a 1D array, even though the explanation given above is 2D. It does not save us time, it just saves us memory (and labor).

Note that we need to use MOD when we are actually computing the values in the array DP. And also that we must return 0 if (top - 2^r) is negative.

Here is an implementation of the above:-

int count(int baseLength, int top) 
{ 
	int C[21], r = baseLength-1, DP[1000001]; 
	if (r >= 20) return 0; 
	top -= (1<<r); if (top < 0) return 0; 
	// Compute the binomial coeffients 
	memset(C, 0, sizeof(C)); C[0] = 1; 
	for (int i = 1; i <= r; i++)
		for (int j = i; j > 0; j--)
			C[j] += C[j-1]; 
	// Compute DP[i][j] in 1D fashion
	memset(DP, 0, sizeof(DP)); DP[0] = 1; 
	for (int i = 0; i <= r; i++)
		for (int j = C[i]; j <= top; j++)
			DP[j] = (DP[j]+DP[j-C[i]])%MOD;
	return DP[top];
}

The problem of finding the number of distinct solutions of B = A₀*x₀ + A₁*x₁ + A₂*x₂ + ... A_n*x_n, where each A_i and B is known to you, is a pretty standard problem. You should expect to encounter it time and again in coding competitions.

 

 

题意为：

15
6 9
3 3 6
 2 1 2 4

如上所示的数字金字塔，最底层有baseLength<=1,000,000个正整数，数的个数按层递减，每个数都是下方两个数的和，问最底层baseLength个数而最上面的数为top<=1,000,000的数字金字塔方案有多少个。

分析：

首先显然可以知道的是当最底层被确定的话就可以确定一个数字金字塔，也就是每个数字金字塔可以用他的最底层来唯一确定。

那么，求数字金字塔的个数就可以转换为求最底层的baseLength个数的不同组合个数。

现在我们要找的就是顶端元素与底层所有元素之间的关系，令x_ij表示第i行(从0开始)的第j个数(从0开始)，则顶端元素top = x₀₀，那么我们可以推出：

x₀₀
= x₁₀ + x₁₁
= (x₂₀ + x₂₁) + (x₂₁ + x₂₂)
= x₂₀ + 2*x₂₁ + x₂₂
= (x₃₀ + x₃₁) + 2*(x₃₁ + x₃₂) + (x₃₂ + x₃₃)
= x₃₀ + 3*x₃₁ + 3*x₃₂ + x₃₃

观察可发现每项前的系数正是二项式系数，所以我们可以得到：

top = C(r,0)*x_r0 + C(r,1)*x_r1 + C(r,2)*x_r2 + ... + C(r,r)*x_rr，其中r可以是(0..baseLength-1)之间的任意行，且有x_ri ≥ 1，从这里可推出baseLength至多为20。

那么题意转化为：B = A₀*x₀ + A₁*x₁ + A₂*x₂ + ... A_n*x_n，Ai和B已知，求不同解(x_i>=1)的个数。

令y_i = (x_ri-1)，那么有：

top - (∑(C(r,i)),0 ≤ i ≤ r) = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,r)*y_r
即top - 2^r = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,r)*y_r，且(y_i ≥ 0)。

那么可以将上式抽象为背包，容量top - 2^r，有r个物品每个物品的容量为C(r,i)，问使背包放满的方案个数。

显然我们可以令dp[i][j]表示前i个物品放了j容量时的方案个数，即使j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,i)*y_i，且y_k≥0，那么答案就是dp[r][top - 2^r]。

则对于第i个物品，我们有如下决策：

y_i=0，那么 j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*y_i = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... + C(r,i-1)*y_i-1)，所以dp[i][j]方案数=dp[i-1][j]。
yi>=1，那么j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*y_i，且y_i≥1，令y_i+1 = y_i，那么j = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*(y_i+1)，且y_i≥0，即等价于j-C(r,i) = C(r,0)*y₀ + C(r,1)*y₁ + C(r,2)*y₂ + ... C(r,i-1)*y_i-1 + C(r,i)*y_i，且y_i≥0，所以dp[i][j]方案数=dp[i][j-C(r,i)]。

综上有dp[i][j] = dp[i-1][j] + dp[i][j-C(r,i)]，又因为dp[i][j]第一维按行枚举的话可以省略，故空间可降至一维。

这样我们就可以得到经典的背包方程dp[j] = dp[j] + dp[j-C(r,i)]，再处理一下取模MOD即可完美解决。

 

代码：

#include<cstdio> #include<cstring> int d[1000005],c[25],n,m; int DP() { n--; if(n>=20)return 0; m-=(1<<n); if(m<0)return 0; memset(d,0,sizeof(d)); memset(c,0,sizeof(c)); int i,j; c[0]=d[0]=1; for(i=1;i<=n;i++) for(j=i;j>0;j--) c[j]+=c[j-1]; for(i=0;i<=n;i++) for(j=c[i];j<=m;j++) d[j]=(d[j]+d[j-c[i]])%1000000009; return d[m]; } int main() { while(scanf("%d%d",&n,&m)==2) printf("%d/n",DP()); }