题意大概就是给你一大堆的城市，左边的数表示这个城市缺什么物资，右边的数表示那个物资从哪个城市往里运，两个城市之间需要链接道路，问不交叉的情况下，最多能连多少条。这道题原本应该是一个最长公共子序列，但是无奈他给的数据范围太大，LCS的做法明显不满足，所以首先我们可以把右边的数映射到左边来，这样就转化成求最长不下降子序列的问题，对于最长不下降子序列，有一种DP+二分的求法，可以在nlogn的情况下完美解决。

思路大概就是dp数组记录的是到当前长度的最靠前的元素，每遇到一个新元素，在dp数组中二分查找到小于它的最大元素的位置，在那里更新到它的最长不下降子序列，这个算法牛逼就牛逼在二分那一步了，否则也不会做到nlogn的时间复杂度

view code
 1 #include <cstdio>
 2 #include <cstring>
 3 const int maxn = 500100;
 4 int dp[maxn], a[maxn], n;
 5 int lis(){
 6     dp[1] = a[1]; 
 7     int len = 1;
 8     for (int i = 2; i <= n; i++){
 9         int l = 1, r = len;
10         while (l <= r){
11             int m = (l + r) >> 1;
12             if (a[i] > dp[m]) l = m + 1;
13             else r = m - 1;
14         }
15         dp[l] = a[i];
16         if (l > len) len = l;
17     }
18     return len;
19 }
20 int main(){
21     int p = 1;
22     while (~scanf("%d", &n)){
23         for (int i = 0; i < n; i++){
24             int x, y;
25             scanf("%d%d", &x, &y);
26             a[x] = y;
27         }
28         memset(dp, 0, sizeof(dp));
29         int ans = lis();
30         printf("Case %d:\nMy king, at most %d road", p++, ans);
31         if (ans > 1) printf("s");
32         printf(" can be built.\n\n");
33     }
34     return 0;
35 

1003是喜闻乐见的最大连续子串和，经典的动态规划题目，经典归经典，我确实是刚刚做……在这道题中，我们需要保证的是在计算过程之中，计算的和是一直增加的，如果碰到了让和减少的元素，直接把和更新为0，并且更新临时首指针，每找到一个更优的解，把真正的首指针和尾指针更新，整个过程中一直保证的是和是递增的。注意我说的是非全负的情况。

view code
 1 #include <cstdio>
 2 int sum, s, t, ss, maxn, a[100100];
 3 bool f;
 4 int main(){
 5     int t, n, p;
 6     scanf("%d", &p);
 7     for (int k = 1; k <= p; k++){
 8         scanf("%d", &n);
 9         f = 0, maxn = -9999999; sum = 0;
10         for (int i = 1; i <= n; i++){
11             scanf("%d", &a[i]);
12             if (a[i] >= 0) f = 1;
13         }
14         if (!f){
15             for (int i = 1; i <= n; i++)
16               if (a[i] > maxn){
17                   maxn = a[i];
18                   s = i;
19               }
20             printf("Case %d:\n%d %d %d\n", k, maxn, s, s);
21         }
22         else{
23             s = 1; t = 1; ss = 0;
24             for (int i = 1; i <= n; i++){
25                 sum += a[i];
26                 if (sum < 0){
27                     ss = i;
28                     sum = 0;
29                 }
30                 else if (sum > maxn){
31                     maxn = sum;
32                     s = ss + 1;
33                     t = i;
34                 }
35             }
36             printf("Case %d:\n%d %d %d\n", k, maxn, s, t);
37         }
38         if (k < p) printf("\n");
39     }
40     return 0;
41 

这道题厉害了，要求在n个数里面求m个最大子段和，要求最终的和最大，其实就是计算m次，因为这此不用记录区间的首尾元素，所以其实比上一道题好写一些。

view code
 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 using namespace std;
 5 const int maxn = 1000100;
 6 int n, m, ans, a[maxn], f[maxn], g[maxn];
 7 int main(){
 8     while (~scanf("%d%d", &m, &n)){
 9         for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
10         memset(f, 0, sizeof(f));
11         memset(g, 0, sizeof(g));
12         for (int i = 1; i <= m; i++){
13             ans = -100 * maxn;
14             for (int j = i; j <= n; j++){
15                 f[j] = max(f[j - 1], g[j - 1]) + a[j];
16                 g[j - 1] = ans;
17                 ans = max(ans, f[j]);
18             }
19         }
20         printf("%d\n", ans);
21     }
22     return 0;
23 

题目大意就是给你一个字符串，和字符串中每一个字母删除或者添加所需要付出的代价，问把它变成一个回文字串所需要的最少的代价。

首先明确一个问题，如果我们在字符串中某一个位置删除一个字符，那么一定能找到一个等价的添加的方法，所以可以把删除和添加统一到一起，然后这道题的状态就简单了。

dp[i][j]表示的是区间[i, j]内形成回文串所需要的最少的代价，这样我们就可以由一个单位字符向外扩展，状态转移方程就应该是dp[j][i] = min(dp[j + 1][i] + cost[s[j] - 'a'], dp[j][i - 1] + cost[s[i] - 'a'])，另外如果区间的首尾字符都是一样的话，那么首尾字符全都删去还是一个回文串，这样一来再把两个代价做一个比较就可以了吧。

当然，其实最初的想法是扩展出来四个状态，就是首删除，首添加，尾删除，尾添加，由此扩展开来求一个最小值，不过看了一下解题报告，再加上和学长们YY一会儿，发现了可以统一的问题，就想出来了。

view code
 1 #include <cstdio>
 2 #include <cstring>
 3 #include <algorithm>
 4 using namespace std;
 5 int dp[2010][2010], x, y, cost[30];
 6 char s[2010];
 7 int n, m;
 8 int main(){
 9     while (~scanf("%d%d", &n, &m)){
10         scanf("%s", s);
11         memset(dp, 0, sizeof(dp));
12         char ss[2];
13         for (int i = 0; i < n; i++){
14             int x, y;
15             scanf("%s%d%d", ss, &x, &y);
16             cost[ss[0] - 'a'] = min(x, y);
17         }
18         for (int i = 1; i < m; i++)
19           for (int j = i - 1; j >= 0; j--){
20               dp[j][i] = min(dp[j + 1][i] + cost[s[j] - 'a'], dp[j][i - 1] + cost[s[i] - 'a']);
21               if (s[i] == s[j])
22                 dp[j][i] = min(dp[j][i], dp[j + 1][i - 1]);
23           }
24         printf("%d\n", dp[0][m - 1]);
25     }
26     return 0;
27 

这道题的最终结果还是求助得来的，天，又是求助……只求做一道会一道吧。

状态dp[i][j]表示当用了前i个物品，平衡度为j的挂法的数量，题里面要求的应该是求所有g个物品挂上去以后，平衡度为0的挂法吧，好吧，暂时先不管它，极端情况就是所有的物品都挂在最远端，那极端情况就应该是25*20*15=7500，按照题意，应该就是左边7500，右边7500，范围应该是[-7500..7500]，移植到C语言里面就是[1..15000]，所求的就是dp[g][7500]。

如果第i个物品挂在某一个挂钩上，一定在挂上前i-1个物品的所产生的某平衡度的基础上产生了一个新的平衡度，不同的挂钩平衡度不同，第i个物品挂在每一个挂钩上面所产生的新平衡度的挂法都要加上前i-1个物品所产生的旧平衡度的挂法，方程有点儿麻烦，先不列了，放在下面的代码中好了……

特别鸣谢：翔哥zzxyyx_1

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 using namespace std;
 4 int main()
 5 {
 6     int c, g, w[21], z[21], i, j, dp[21][15005], k;
 7     cin >> c >> g;
 8     for (i = 1; i <= c; i++) cin >> z[i];
 9     for (i = 1; i <= g; i++) cin >> w[i];
10     dp[0][7500] = 1;
11     for (i = 1; i <= g; i++)
12     {
13         for (j = -7500; j <= 7500; j++)
14         {
15             if(dp[i - 1][j + 7500] != 0)
16             for (k = 1; k <= c; k++)
17             {
18                 dp[i][j + z[k] * w[i] + 7500] += dp[i - 1][j + 7500];
19             }
20         }
21     }
22     cout << dp[g][7500] << endl;
23     return 0;
24 }
25

额……这道题貌似也不怎么强大，但是着实让我纠结，所以我又开始求助了，然后求助成功，解题，然后贴上来，以免以后忘记……

题目大意是这样的，给一段时间N，给M个时间段，给开始时间和结束时间，每个时间段有一个效率，每次用完某一时间段的效率必须休息R小时，求最高的效率。

好吧，存储结构没有异议，一个量，三个参数，果断的结构体存储啊，方便得体，多好啊……

刚 开始我果断的打算把它当成一个01背包来做，但是果断的错了，被我自己否决了（还好没写……）我的想法是直接把每一段的结束时间减去开始时间，然后成为一个消耗时间段，然后抽象……N代表背包总容量，M代表物品个数，消耗时间段代表着物品占用的空间，效率就是物品价值，一个华丽丽的01背包解决……当然这 个错了，原因是既然给了每个时间段的开始时间和结束时间，还有休息时间，那如果重叠了怎么算……然后就果断的否决了。

实际上正确的状态是当 选用第i个时间段为结尾的时候，所获得的最大效率，当然得把时间段的先后先排个序，按照开始时刻排序，这样比较有爱……这样的话当处理第i个时间段也就是 f[i]的时候，之前需要计算的都在第i段的前面。当处理到第i段的时候，前面必然有一个j，使得以j为结尾的时候，所得效率最大，从而保证到第j段的最 大效率加上第i段的效率最大，j可以是i前面的任意一段时间，反正保证了最大就行。初始化的时候要有这么一句：f[i]=in[i].ef，这样就是防止 有前面所有段全都不用这种情况。方程是这样的：f[i]=max(f[j]+in[i].ef，f[i])，in[i].ef是第i段时间中的效率。

但是一定要注意一点，选用的时间区间除了端点以外是不能重合的，还得记得把休息时间加上……

特别鸣谢：翔哥zzxyyx_1