JOJ 1026 The staircases

题目描述：有N块砖头，摆成阶梯状，要求阶梯高度必须严格递增。给定N，求所有不同的摆法总数。

原题目见：http://acm.jlu.edu.cn/joj/showproblem.php?pid=1026

方法一：
N块砖头至少摆出两阶，因此第一阶的砖头数目最大为floor((n-1)/2)。设f(i,j)表示i块砖头
摆成的阶梯中第一阶摆了j块砖头的所有摆法总数。那么，给定砖头总数N，所要求的答案就是
f(N,1)+f(N,2)+...+f(N,floor((n-1)/2))................(*)。
设i块砖头第一阶为j块砖头的某种摆法为j,n1,n2,...,nm。其中ni表示第i+1阶的砖头数。则有
j<n1<n2<...<nm，且有j+n1+n2+...+nm=i，其中1<=j<=floor((i-1)/2),m>=1,将其移项，得：
n1+n2+...+nm=i-j
而这个式子就表示i-j块砖头第一阶为n1块砖头的一种摆法。其中：
j+1<=n1<=floor((i-j-1)/2)，因此i块砖头的问题可以转化为i-j块砖头的问题。于是：
f(i,j)=f(i-j,j+1)+f(i-j,j+2)+...+f(i-j,floor((i-j-1)/2)。
给定N块砖头，所有不同的摆法就是式(*)，在(*)中：
f(N,1)=f(N-1,2)+f(N-1,3)+...+f(N-1,floor((N-1-1)/2);
f(N,2)=f(N-2,3)+f(N-2,4)+...+f(N-2,floor((N-2-1)/2);
......
在上述的分析中，是假定砖头至少要被分成两堆的，对于本来只分为两堆的情形，经状态转化后
就会把它作为0计算，比如：
f(8,3)=f(5,4)=0，但是8可以分为3,5这样的情形的。所以需要把漏掉的这一组解加上去。
代码为：

1. #include <stdio.h>
2. int main() {
3.     double f[501][501]={0},s;
4.     int i,j,k,n;
5.     for(i=3;i<=500;i++)
6.         for(j=1;j<=(i-1)/2;j++)
7.         f[i][j]=1;
8.     for(i=3;i<=500;i++)
9.         for(j=1;j<=(i-1)/2;j++) {
10.         for(k=j+1;k<=(i-j-1)/2;k++)
11.             f[i][j]+=f[i-j][k];
12.     }
13.     while(scanf("%d",&n),n) {
14.         s=0;
15.         for(i=1;i<=(n-1)/2;i++) s+=f[n][i];
16.         printf("%.0f/n",s);
17.     }
18.     return 0;
19. }

解法二：生成函数
题目的实质就是把N分成一些分部量不同的数的和的整数拆分问题。借助于生成函数，对于这个问题，
就是说对于一个数t，1<=t<=N，t或者不出现，或者只出现一次。所以，生成函数为：
G(x)=(1+x)(1+x^2)(1+x^3)...(1+x^n)
那么，G(x)的展开式中x^n的系数就是各个分部量不同的整数拆分问题。其中要减掉1*x^n的这种拆分
情况。也就是最终结果的x^n的系数减1就是本题要求的答案。
代码如下：

1. #include <stdio.h>
3. double ans[510]={1,1};
5. int main() {
6.     int i,j,t=1;
7.     // 1+x^i
8.     for(i=2;i<=500;i++) { 
9.         for(j=t;j>=0;j--) {
10.             if(j>500 || i+j>500) continue;
11.             ans[i+j]+=ans[j];
12.         }
13.         t=i+t;
14.     }
15.     while(scanf("%d",&t),t) {
16.         printf("%.0lf/n",ans[t]-1);
17.     }
18.     return 0;
19. }

上述生成函数的代码可以写的更高效一些：

 

1. #include <stdio.h> 
3. double ans[510]={1,1}; 
5. int main() { 
6.     int i,j; 
7.     // 1+x^i 
8.     for(i=2;i<=500;i++) {  
9.         for(j=500;j>=0;j--) { 
10.             if(i+j<=500) ans[i+j]+=ans[j];
11.         } 
12.     } 
13.     while(scanf("%d",&i),i) { 
14.         printf("%.0lf/n",ans[i]-1); 
15.     } 
16.     return 0; 
17. } 

上面同样是生成函数的思想，但两段实现代码效率差别是非常巨大的，第一段代码提交成绩为0.05秒，第二段

代码为0.00秒。只是一个非常小的改动何以效率差别会如此巨大呢？

仔细分析，原因非常明确。第一段代码中，自己的for循环是这样写的：

1.     for(i=2;i<=500;i++) { 
2.         for(j=t;j>=0;j--) {
3.             if(j>500 || i+j>500) continue;
4.             ans[i+j]+=ans[j];
5.         }
6.         t=i+t;
7.     }

外层for循环表示乘以(1+x^i)，内层for循环用来遍历已经得到的多项式的每一项，里面有个变量t，自己的初衷是用它

来表示当前已经得到的多项式的最高次数。而事实上，乘到1+x^32的时候，最高次数就已经是1+2+3+...+32=528了。

所以，从1+x^32起，即外层循环运行到i为32之后，程序的绝大部分时间都花在了执行内层循环中的那个continue语句

上面，而且那个执行continue语句的条件判断自己写成了那么低效的方式。每次循环，都还要执行一次外层循环中的

毫无意义的t=i+t这一步更新操作。由于自己非常糟糕的代码实现，把一个O(n*n)的算法变成了O(n*n*n)，降到了

和动态规划一样的时间复杂度。