usaco 4.3 Buy Low, Buy Lower 动态规划

典型的动态规划，难点是第二步，cnt[i]表示以a[i]结尾的最长下降序列的种数，则
cnt[i] = count( len[k]+1==len[i]), 1<=k < i ， 其中len[i]表示以a[i]结尾的最长下降子序列长度

 

还有一个问题，如果生成的实际序列值相等，则算作一种，可以通过一下方法处理：
计算出a[i]之后和第一个和a[i]相等的数a[k]，令next[i] = k; 如果没有相等的则next[i] = 0
计数时如果 next[j]!=0 && next[j] < i ，则不累计，因为位于j和i之间的数里存在和a[i]相等的，从而可以以a[next[j]]替换a[j]来得

到相同的序列； 同时，累加的过程是指数级增长的，所以要用高精度

 

1. /*
2. PROG: buylow
3. LANG: C++
4. ID: heben991
5. */
6. #include <iostream>
7. #include <algorithm>
8. using namespace std;
9. 
   
10. 
    
11. const int N = 6000, R = 10000, L = 250;
12. 
    
13. 
    
14. int len[N], a[N], next[N];
15. 
    
16. struct bignum
17. {
18.     int a[L];
19.     int n;
20.     bignum operator = (int b)
21.     {
22.         memset(a,0,sizeof(a));
23.         n = 1;
24.         a[1] = b;
25.     }
26.     bignum operator = (const bignum &b)
27.     {
28.         memset(a,0,sizeof(a));
29.         for(int i = 1; i <= b.n; ++i) a[i] = b.a[i];
30.         n = b.n;
31.     }
32. 
    
33.     void print()
34.     {
35.         int i;
36.         printf("%d", a[n]);
37.         for(i = n-1; i >= 1; --i) printf("%04d", a[i]);
38.     }
39. }cnt[N];
40. 
    
41. bignum operator + (bignum &a, bignum &b)
42. {
43.     bignum c;
44.     int i, len=max(a.n,b.n);
45.     c = 0;
46.     for(i = 1; i <= len; ++i)
47.     {
48.         c.a[i] += a.a[i] + b.a[i];
49.         if(c.a[i] >= R)
50.         {
51.             c.a[i+1] += c.a[i]/R;
52.             c.a[i] -= R;
53.         }
54.     }
55.     if(c.a[len+1]!=0) c.n=len+1;
56.     else c.n=len;
57.     return c;
58. }
59. 
    
60. 
    
61. int main()
62. {
63. 
    
64.     int i, j, k, t, n;
65. 
    
66.     freopen("buylow.in","r",stdin);
67.     freopen("buylow.out","w",stdout);
68. 
    
69.     scanf("%d", &n);
70.     for(i = 1; i <= n; ++i) scanf("%d",a+i);
71.     a[++n] = 0;
72. 
    
73.     for(i = 1; i <= n; ++i)
74.     {
75.         for(j = i+1; j <= n; ++j)
76.         {
77.             if(a[i]==a[j])
78.             {
79.                 next[i] = j;
80.                 break;
81.             }
82.         }
83.     }
84. 
    
85.     for(i = 1; i <= n; ++i)
86.     {
87.         len[i] = 1;
88.         cnt[i] = 1;
89.         for(j = 1; j < i; ++j)
90.         {
91.             if(next[j] && next[j] < i) continue;
92. 
    
93.             if(a[i] < a[j])
94.             {
95.                 if(len[j]+1 > len[i])
96.                 {
97.                     len[i] = len[j]+1;
98.                     cnt[i]=0;
99.                     cnt[i]=cnt[j];
100.                 }
101.                 else if(len[j]+1 == len[i])
102.                 {
103.                     cnt[i]=cnt[i]+cnt[j];
104.                 }
105.             }
106.         }
107.     }
108. 
     
109.     printf("%d ", len[n]-1);
110.     cnt[n].print();
111.     puts("");
112.     return 0;
113. }
114.