无数次转的母函数

自己理解：对于（#式）  (1+x+x^2+x^3+x^4+x^5+....)*(1+x^2+x^4+x^6+x^8+x^10+....)*(1+x^3+x^6+x^9+x^12....).....

第一个for给c1 和 c2 赋值 ， 把上面#式的第一个括号(1+x+x^2+x^3+x^4+x^5+....)的系数给放在c1中，

从而再次计算从 # 的 第二个括号开始 ， 所以 i 就是代表的# 式第几个括号，

而 用程序模拟手工计算 ， 就是 先计算第一个括号 与 第二个括号 计算 ， 把结果放到c2中，

在把结果与第三个括号计算 ， 把结果放到c2中 ， 在和第四个括号计算，........

所以j 就是指的 已经计算出 的 各项的系数 ，比如第一次之后 1+x+x^2+x^3+x^4+x^5+... ， j=0指向1 ，

j=2 指向x ， .... ， 而 k 就是指 将要计算的那个括号中的项 ， 因为第i个括号 ， 中的指数为0 ， i ， 2i....所以 k要 + i ；

而结果 c2[j+k] += c1[j]; 就是把 以计算出的 j项的系数 和 现在正在计算的括号的k项相乘 ， 所以指数为j+k ， 所以结果放到c2[j+k] 中 ， 这就是这几个for的作用！

最后刷新下结果 ， 下一组数据计算！

c1[n]保存着Xn项前的系数，也就是n个(a1,...,an)组合数

点击(此处)折叠或打开

1. /*//整数拆分模板
   
2. #include <iostream>
   
3. using namespace std;
   
4. const int lmax=10000;
   
5. //c1是用来存放展开式的系数的，而c2则是用来计算时保存的，
   
6. //他是用下标来控制每一项的位置，比如 c2[3] 就是 x^3 的系数。
   
7. //用c1保存，然后在计算时用c2来保存变化的值。
   
8. int c1[lmax+1],c2[lmax+1];
   
9. int main()
   
10. {
    
11.             int n, i, j, k;
    
12.            // 计算的方法还是模拟手动运算，一个括号一个括号的计算，
    
13.            // 从前往后
    
14.            while ( cin>>n)
    
15. 
    
16.           {
    
17.                      //对于 1+x+x^2+x^3+ 他们所有的系数都是 1
    
18.                      // 而 c2全部被初始化为0是因为以后要用到 c2[i]+= x ;
    
19.                      for ( i=0; i<=n; i++)
    
20. 
    
21.                      {
    
22.                                 c1[i]=1;
    
23.                                 c2[i]=0;
    
24.                      }
    
25.                       //第一层循环是一共有 n 个小括号，而刚才已经算过一个了
    
26.                       //所以是从2 到 n
    
27.                      for (i=2; i<=n; i++)
    
28. 
    
29.                    {
    
30.                                  // 第二层循环是把每一个小括号里面的每一项，都要与前一个
    
31.                                  //小括号里面的每一项计算。
    
32.                                 for ( j=0; j<=n; j++)
    
33.                                  //第三层小括号是要控制每一项里面 X 增加的比例
    
34.                                  // 这就是为什么要用 k+= i;
    
35.                                          for( k=0; k+j<=n; k+=i )
    
36. 
    
37.                                         {
    
38.                                                  // 合并同类项，他们的系数要加在一起，所以是加法，呵呵。
    
39.                                                  // 刚开始看的时候就卡在这里了。
    
40.                                                  c2[ j+k]+= c1[ j];
    
41.                                          }
    
42.                                // 刷新一下数据，继续下一次计算，就是下一个括号里面的每一项。
    
43.                               for ( j=0; j<=n; j++)
    
44. 
    
45.                               {
    
46.                                           c1[j]= c2[j];
    
47.                                           c2[j]= 0 ;
    
48.                               }
    
49.                    }
    
50.                     cout<<c1[n]<<endl;
    
51.         }
    
52.          return 0;
    
53. }
    
54. 这句 c2[j+k]+= c1[j];的理解还要自己好好的体会体会啊！
    
55. */