DP专题(不定期更新)

1、UVa 11584 Partitioning by Palindromes(字符串区间dp)

　　题意：给出一个字符串，划分为若干字串，保证每个字串都是回文串，同时划分数目最小。

　　思路：dp[i]表示以第i位结尾时最小的划分数目(初始均为0)

　　　　状态转移方程1：(初始均为0)当[j:i]是回文串（0≤j≤i，0≤i<n）:dp[i]=1(j==0);dp[i]=(dp[i]==0?dp[j-1]+1:min(dp[i],dp[j-1]+1))

　　　　状态转移方程2：(初始：dp[i]=i+1)当[j:i]是回文串（0≤j≤i，0≤i<n）:dp[i]=1(j==0);dp[i]=min(dp[i],dp[j-1]+1))

　　　　状态转移方程3：(初始：dp[i]=i+1(1≤i≤n);其他：dp[i]=0)当[j:i]是回文串（1≤j≤i，1≤i≤n）:dp[i]=min(dp[i],dp[j-1]+1))

 #include<iostream>
 #include<memory.h>
 #include<string.h>
 #include<algorithm>
 #include<cstdio>
 using namespace std;
 const int maxn = ;
 char s[maxn];
 int dp[maxn];
 int n;
 bool Judge(int st, int ed)
 {
     for (; st <= ed; st++, ed--)
     {
         if (s[st] != s[ed]) return false;
     }
     return true;
 }
 int main()
 {
     cin >> n;
     while (n--)
     {
         scanf("%s", s);
         memset(dp, , sizeof(dp));
         int sz = strlen(s);
         for (int i = ; i < sz; i++)
         {
             for (int j = ; j <= i; j++)
             {
                 if (Judge(j, i))
                 {
                     if (j == ) dp[i] = ;
                     else dp[i] = dp[i] ==  ? dp[j - ] +  : min(dp[i], dp[j - ] + );
                 }
             }
         }
         cout << dp[sz - ] << endl;
     }
     return ;
 }

2、UVA 10534 Wavio Sequence(dp + LIS)

　　题意：给出一个字符串,求满足这样条件的子序列的最大长度：长度为奇数（假设为2*k+1），同时前k+1个严格递增，后k+1个严格递减。

　　思路：分别从左往右和从右往左分别算出以第i位结尾的最长递增子序列的长度L1、L2，然后得出以第i位为中点的满足条件的子序列的长度：min(L1,L2)*2-1（如果L1、L2包含该位），然后对每一位分别重复上述操作，得出最大长度。

 #include<iostream>
 #include<vector>
 #include<memory.h>
 #include<algorithm>
 using namespace std;
 const int maxn = ;
 int maxl[maxn];
 int maxr[maxn];
 int p[maxn];
 void exchange(int x, int pos, vector<int>&v, char c)
 {
     vector<int>::iterator it;
     it = lower_bound(v.begin(), v.end(), x);
     int p = it - v.begin();
     v[p] = x;
     if (c == 'l')maxl[pos] = p;
     else maxr[pos] = p;
 }
 int main()
 {
     int n;
     while (cin >> n)
     {
         vector<int>minlen;
         for (int i = ; i < n; i++) cin >> p[i];
         minlen.push_back(p[]);
         maxl[] = ;
         for (int i = ; i < n; i++)
         {
             if (p[i] > minlen.back())
             {
                 maxl[i] = minlen.size();
                 minlen.push_back(p[i]);
             }
             else
             {
                 exchange(p[i], i, minlen, 'l');
             }
         }
         minlen.clear();
         minlen.push_back(p[n - ]);
         maxr[n - ] = ;
         for (int i = n - ; i >= ; i--)
         {
             if (p[i] > minlen.back())
             {
                 maxr[i] = minlen.size();
                 minlen.push_back(p[i]);
             }
             else
             {
                 exchange(p[i], i, minlen, 'r');
             }
         }
         int len = ;
         for (int i = ; i < n; i++)
         {
             int tmp = min(maxl[i], maxr[i]) *  + ;
             if (tmp > len) len = tmp;
         }
         cout << len << endl;
     }
     return ;
 }

3、uva 11404 - Palindromic Subsequence(dp)

　　题意：给出一个字符串，求其最长回文子串，并输出该字串。如果有多个，输出字典序最小的那个。

　　思路：如果只求长度：dp[i][j]=dp[i+1][j-1]+2(s[i]==s[j]);dp[i][j]=max(dp[i+1][j],dp[i][j-1])(s[i]!=s[j])

　　　　在此基础上可以用string来保存临时回文子串。

 #include<iostream>
 #include<string>
 #include<memory.h>
 using namespace std;
 const int maxn = ;
 struct node
 {
     int len;
     string str;
 }dp[maxn][maxn];

 int main()
 {
     string s;
     while (cin >> s)
     {
         int len = s.length();
         memset(dp, , sizeof(dp));
         for (int i = ; i < len; i++)
         {
             dp[i][i].len = ;
             dp[i][i].str = s[i];
         }
         for (int i = len - ; i >= ; i--)
         {
             for (int j = i; j < len; j++)
             {

                 if (s[i] == s[j])
                 {
                     if (i == j)
                     {
                         dp[i][j].len = ;
                         dp[i][j].str = s[i];
                     }
                     else
                     {
                         dp[i][j].len = dp[i + ][j - ].len + ;
                         dp[i][j].str = s[i] + dp[i + ][j - ].str + s[j];
                     }
                 }
                 else
                 {
                     if (dp[i + ][j].len > dp[i][j - ].len)
                     {
                         dp[i][j].len = dp[i + ][j].len;
                         dp[i][j].str = dp[i + ][j].str;
                     }
                     else if (dp[i + ][j].len < dp[i][j - ].len)
                     {
                         dp[i][j].len = dp[i][j - ].len;
                         dp[i][j].str = dp[i][j - ].str;
                     }
                     else
                     {
                         dp[i][j].len = dp[i][j - ].len;
                         if (dp[i][j - ].str < dp[i + ][j].str) dp[i][j].str = dp[i][j - ].str;
                         else dp[i][j].str = dp[i + ][j].str;
                     }
                 }
             }
         }
         cout << dp[][len - ].str << endl;
     }
     return ;
 }

4、UVA 11795 - Mega Man's Mission(状态压缩dp)

　　题意：洛克人手里有一把武器，能够杀死部分特定敌人（可以杀死的记为1，无法杀死的记为0），同时，他杀死敌人后，能够使用被杀死的敌人的武器，其武器同样也只能杀死特定的敌人。求能杀死所有敌人的方案数。

　　思路：对于n个敌人，共有2^n-1种状态（用一个int即可表示），可以先求出每种状态下能够杀死的敌人atk[i]（即该状态i下杀死的敌人的武器被获得后能够杀死的敌人），之后，对于i这种状态，如果该状态下能够杀死敌人j,如果i^(1<<j)这种状态(不能杀死j)下能够杀死j(atk[i^(1<<j)]&1<<j),则dp[i]+=dp[i^(1<<j)]。

 #include<iostream>
 #include<cstdio>
 #include<memory.h>
 using namespace std;
 typedef long long ll;
 char s[];
 const int maxn = ( << ) + ;
 int N;
 int w[maxn];//存储洛克人[0]和敌人[1:]的武器
 int atk[maxn];//用来保存每个状态可以杀死的机器人
 ll dp[maxn];// 2 的 16 次方会爆 int。 // 用来统计每种状态的顺序方案种数
 int Exchange()
 {
     int ans = ;
     int sz = strlen(s);
     for (int i = ; i < sz; i++)
     {
         if (s[i] == '') ans = ans | ( << i);//第i+1位如果能被杀掉，则第i+1位为1
     }
     return ans;
 }
 int main()
 {
     int T;
     cin >> T;
     int Case = ;
     while (T--)
     {
         cin >> N;
         for (int i = ; i <= N; i++)
         {
             scanf("%s", s);
             w[i] = Exchange();
             //cout << i << ' ' << w[i] << endl;
         }
         int total = ( << N) - ;//对于N个敌人，一共最多有2^N-1种状态（每个敌人能够杀死或不能杀死）
         for (int st = ; st <= total; st++)
         {//st即为二进制存储的状态
             atk[st] = w[];//初始为洛克人所拿的武器能够杀死的人
             for (int i = ; i <= N; i++)//对于每个敌人
             {
                 int j = i - ;//i其在所存二进制里的位置
                 if (st&( << j))
                 {//如果该状态可以杀死 i，那么该状态也可以杀死i所能干掉的
                     atk[st] = atk[st] | w[i];
                 }
             }
         }
         memset(dp, , sizeof(dp));
         dp[] = ;//一个都不杀死的方案数为1
         for (int st = ; st <= total; st++)
         {
             for (int i = ; i < N; i++)
             {//对于N个敌人
                 if (st &  << i)
                 {//如果该状态能够杀死第i+1个敌人(敌人从1开始编号，但是在二进制存储的杀死状态中存储的位置为i),那么 st 由不能杀死 i 的状态转移过来, 即st^(1<<i)（异或）
                     if (atk[st ^ ( << i)] &  << i)//并且st^(1<<i)这种状态能够杀死该敌人
                     {
                         dp[st] += dp[st ^ ( << i)];
                     }
                 }
             }
         }
         printf("Case %d: %lld\n", Case++, dp[total]);
     }
     return ;
 }

5、UVA 10564 Paths through the Hourglass(dp)

　　题意：有一个漏斗形的图，从某一行只能向左下或右下走，走过的路径上的点数之和要等于S。求路径数，若存在，则输出从第一行最左侧开始，同时所走方向形成的字典序最小的字符串。（由‘L’、‘R’组成）。

　　思路：从下往上dp,dp[i][j][k] 代表从(i, j)点往下走到最后一层和为k的方案数,那么，显然可以得到状态转移：

　　dp[i][j][k] = dp[i + 1][left][k - val] + dp[i + 1][right][k - val], val = (i, j)格上的数字，left是往坐下走的坐标，right往右下走的坐标

 #include<iostream>
 #include<memory.h>
 #include<cstdio>
 using namespace std;
 typedef long long ll;
 int N, S;
 ll dp[][][];
 int m[][];
 void Input()
 {
     for (int i = ; i <= N; i++)
     {
         for (int j = ; j <= N - i+; j++)
         {
             scanf("%d", &m[i][j]);
         }
     }
     for (int i = N+; i <=  * N - ; i++)
     {
         for (int j = ; j <= i - N + ; j++)
         {
             scanf("%d", &m[i][j]);
         }
     }
 }
 void Print()
 {
     int pos;
     for (int i = ; i <= N; i++)
     {
         if (dp[][i][S])
         {
             cout <<i-<< ' ';
             pos = i;
             break;
         }
     }
     int sum = S;
     for (int i = ; i <= N; i++)
     {
             if (dp[i][pos - ][sum - m[i - ][pos]])
             {
                 cout << 'L';
                 sum -= m[i - ][pos];
                 pos--;
             }
             else
             {
                 cout << 'R';
                 sum -= m[i - ][pos];
             }
     }
     for (int j = N+; j <=  * N - ; j++)
     {
         if (dp[j][pos][sum - m[j - ][pos]])
         {
             cout << 'L';
             sum -= m[j - ][pos];
         }
         else
         {
             cout << 'R';
             sum -= m[j - ][pos];
             pos++;
         }
     }
     cout << endl;
 }

 int main()
 {
     while (cin >> N >> S, N !=  || S != )
     {
         Input();
         memset(dp, , sizeof(dp));
         for (int i = ; i <= N; i++) dp[ * N - ][i][m[ * N - ][i]] = ;
         for (int i =  * N - ; i >= N; i--)
         {
             for (int j = ; j <= i - N + ; j++)
             {
                 int v = m[i][j];
                 for (int tv = v; tv <= S; tv++)
                 {
                     dp[i][j][tv] = dp[i + ][j][tv-v] + dp[i + ][j + ][tv-v];
                 }
             }
         }
         for (int i = N - ; i >= ; i--)
         {
             for (int j = ; j <= N - i+; j++)
             {
                 int v = m[i][j];
                 for (int tv = v; tv <= S; tv++)
                 {
                     dp[i][j][tv] = dp[i + ][j][tv-v] + dp[i + ][j - ][tv-v];
                 }
             }
         }
         ll ans = ;
         for (int i = ; i <= N; i++) ans += dp[][i][S];
         if (ans == ) cout << ans << endl << endl;
         else
         {
             printf("%lld\n", ans);
             Print();
         }
     }
     return ;
 }

6、UVA 11552 Fewest Flops

　　题意：给出一个长度能够整除k的字符串，整除后得到的子串中的字符看可以重新组合。求最后得到的新的字符串中满足该条件（字串中每个字符都相同）的子串的最小数目。例如：“abccd”中，这样的数目有4个：“a”,"b","cc","d".

　　思路：DP[i][j]表示前i段，第i段以第j个字符结尾时最小的满足条件的字串数目。

　　　　DP[i][j] = min(DP[i][j],DP[i - 1][l] + cnt - 1)(i-1段以第l个字符结尾时，该字符和第i段第一个字符相同时)

　　　　DP[i][j] = min(DP[i][j],DP[i - 1][l] + cnt)(i-1段以第l个字符结尾时，该字符和第i段第一个字符不同时)

 #include<map>
 #include<string>
 #include<iostream>
 #include<memory.h>
 #include<algorithm>
 using namespace std;
 #define maxn 1020
 int dp[maxn][maxn];
 int main()
 {
     int n;
     cin >> n;
     while (n--)
     {
         int k;
         cin >> k;
         string s;
         cin >> s;
         int l = s.length();
         int tl = l / k;
         map<char, int>m;
         int count = ;
         memset(dp, , sizeof(dp));
         for (int i = ; i < k; i++)
         {
             if (!m[s[i]])
             {
                 m[s[i]] = ;
                 count++;
             }
         }
         for (int i = ; i < k; i++) dp[][i] = count;
         for (int j = ; j<tl; j++)
         {
             m.clear();
             count = ;
             for (int i = ; i < k; i++)
             {
                 if (!m[s[i + j*k]])
                 {
                     m[s[i + j*k]] = ;
                     count++;
                 }
             }
             for (int i = ; i < k; i++) dp[j][i] = l;
             for (int i = ; i < k; i++)
             {
                 for (int l = ; l < k; l++)
                 {
                     if (m[s[l + (j - )*k]] && (count ==  || s[l + (j - )*k] != s[i + j*k]))
                     {//如果j-1段中第l个字母在第j段中出现过，并且第j段中字母种类只有一种或者有多种但最后一个字母不是它
                         dp[j][i] = min(dp[j][i], dp[j - ][l] + count - );
                     }
                     else dp[j][i] = min(dp[j][i], dp[j - ][l] + count);
                 }
             }
         }
         int mincount = l;
         for (int i = ; i < k; i++) mincount = min(mincount, dp[tl - ][i]);
         cout << mincount << endl;
     }
     return ;
 }

7、UVa 11825 Hackers’ Crackdown

　　题意：有一个分布式网络，每台电脑都有若干台和它相邻，同时所有电脑都有N种服务运行。现在有个黑客，他想要发送病毒，一台电脑只能植入一种病毒，只有所有电脑都瘫坏才能瘫坏掉一种服务，求其能够干掉的最多的服务种数。

　　思路：2进制状态压缩保存每台电脑的邻接状态，并用2进制来保存每种状态下能攻陷的电脑。dp[i]表示i状态下能干掉的最多的服务数目。dp[i] = max(dp[i], dp[i^j] + 1)。详细见注释

 //状压DP
 #include<iostream>
 #include<algorithm>
 using namespace std;
 const int maxst = ( << );
 int ini[];
 int cover[maxst];
 int dp[maxst];
 int main()
 {
     int n;
     int Case = ;
     while (~scanf("%d", &n))
     {
         if (n == ) break;
         for (int i = ; i < n; i++)
         {
             ini[i] = |(<<i);//包括自身
             int m;
             scanf("%d", &m);
             for (int j = ; j < m; j++)
             {
                 int k;
                 scanf("%d", &k);
                 ini[i] |= ( << k);//加上邻居
             }
         }
         int total = ( << n) - ;//总状态数
         for (int i = ; i <=total; i++)
         {
             cover[i] = ;
             for (int j = ; j < n; j++)
             {
                 if (i&( << j))//如果该状态能够瘫坏第j台电脑
                 {
                     cover[i] |= ini[j];//那么也能瘫坏其邻接的电脑
                 }
             }
         }
         dp[] = ;
         for (int i = ; i <= total; i++)
         {
             dp[i] = ;
             //枚举子集
             for (int j = i; j > ; j = (j - )&i)
             {
                 if (cover[j] == total)//如果子集的状态下能够干掉所有的电脑
                 {
                     dp[i] = max(dp[i], dp[i^j] + );//那么该状态的能够关闭的服务为max{该状态下能最多关闭的服务数,该状态i和能够干掉所有的电脑的子集的补集所能能关闭的方案数+1（这个1由该子集j提供）}
                 }
             }
         }
         printf("Case %d: %d\n",Case, dp[total]);
         Case++;
     }
     return ;
 }

8、UVA-10635 Prince and Princess

　　题意：求两个序列的公共最长子序列。

　　思路：听说最长公共子序列算法会超时……由于序列每个数都不同，可以转换为求b的最长递增子序列，只需将a数组按顺序从1开始重新编号，建立映射。

 #include<iostream>
 #include<map>
 #include<vector>
 #include<algorithm>
 using namespace std;
 const int maxl =  * ;
 int numa[maxl];
 int numb[maxl];
 map<int, int>m;
 void exchange(int x, vector<int>&v)
 {
     vector<int>::iterator it;
     it = lower_bound(v.begin(), v.end(), x);
     int p = it - v.begin();
     v[p] = x;
 }

 int main()
 {
     int t;
     int Case = ;
     scanf("%d", &t);
     while (t--)
     {
         int n, p, q;
         scanf("%d%d%d", &n, &p, &q);
         for (int i = ; i < p+; i++)
         {
             scanf("%d", &numa[i]);
             m[numa[i]] = i + ;
         }
         for (int i = ; i < q+; i++)
         {
             scanf("%d", &numb[i]);
             if (m[numb[i]]) numb[i] = m[numb[i]];
             else numb[i] = ;
         }
         vector<int>minlen;
         minlen.push_back(numb[]);
         for (int i = ; i < q+; i++)
         {
             if (numb[i] > minlen.back()) minlen.push_back(numb[i]);
             else
             {
                 exchange(numb[i], minlen);
             }
         }
         printf("Case %d: %d\n",Case, minlen.size());
         Case++;
     }
     return ;
 }

9、Uva-10891-Game of Sum

　　题意：A和B两个人，每次可以轮流从一个数组的左端或右端开始拿走若干个数字，直到数组为空，A先手。求最优选择下A能比B最多高出多少。

　　思路：DP，dp[st][ed] = sum[ed] - sum[st - 1] - min(0,L[st][ed - 1],R[st + 1][ed]),L[st][ed] = min(L[st][ed - 1], dp[st][ed]);R[st][ed] = min(R[st + 1][ed], dp[st][ed]).

 #include<cstdio>
 #include<string>
 #include<cstring>
 #include<iostream>
 #include<cmath>
 #include<algorithm>
 using namespace std;
 typedef long long ll;
 const int INF = 0x3f3f3f3f;
 const int maxn = ;
 int n;
 //const int maxV=12;
 int a[maxn + ];
 int dp[maxn + ][maxn + ];
 int L[maxn + ][maxn + ], R[maxn + ][maxn + ];
 int sum[maxn + ];
 int main()
 {
     while (~scanf("%d", &n) && n)
     {
         for (int i = ; i <= n; i++)
             scanf("%d", &a[i]);
         sum[] = ;
         for (int i = ; i <= n; i++)
         {
             dp[i][i] = a[i];//dp[st][ed]表示[st,ed]区间，先手最多得分。
             sum[i] = sum[i - ] + a[i];//L[st,ed]=min{dp[st][k]  } ;(st<=k<=ed)
             L[i][i] = R[i][i] = dp[i][i];//R[st,ed]=min{dp[k][ed]};(st<=k<=ed)
         }
         for (int add = ; add<n; add++)
         {
             for (int st = ; st + add <= n; st++)
             {
                 int ed = st + add;
                 int m = ;              //m表示此阶段的后手最少能拿多少
                 m = min(m, L[st][ed - ]);//表示从右边拿起
                 m = min(m, R[st + ][ed]);//表示从左边拿起
                 dp[st][ed] = sum[ed] - sum[st - ] - m;
                 L[st][ed] = min(L[st][ed - ], dp[st][ed]);
                 R[st][ed] = min(R[st + ][ed], dp[st][ed]);
             }
         }
         printf("%d\n", dp[][n] - (sum[n] - sum[] - dp[][n]));
     }
     return ;
 }

10、Uva 10859 - Placing Lampposts

　　题意：在一张图中，选择结点放置路灯，路灯会照亮连接该结点的路径，问使所有路径都能被照到的最小路灯数目为多少？同时在所有最小的方案中，要保证至少被两盏灯照亮的道路最多。

　　思路：树形DP。优化：x=M*v1+v2，其中M是比"比v2的最大理论值和v2的最小理论值之差"还要大的数。v1表示放置的路灯数目尽可能小，v2表示被一盏灯照亮的路尽可能小。v1=x/M,v2=x%M,v3=m-v2.(被两盏灯照亮的路)。每放一盏灯 + 2000(m)（因为边的最大数量为1000），每增加1条照亮一次的边 + 1.

　　①节点i处不放街灯，那么i是根或者父亲节点放了街灯。所以dp(i,j)=sum{ dp(v,0) | v取遍i的所有儿子节点 }，如果i不是根节点，那么结果+1，因为i和父亲连接的这条边只被一盏灯照亮。

　　②节点i处放街灯，dp(i, j) = sum{ dp(v,1) | v取遍i的所有儿子节点 } +M，如果i不是根节点而且j = 0，那么结果 + 1。

 //树形DP
 //f(i,j)表示第i盏灯的父亲是否点亮所以j=0|1如果父亲放了，那么自己放或者不放都可以那么f(i,j)=max{∑f(ison,0)∑f(ison,1)}，如果父亲没有放置，那么自己必须放那么f(i,0)=∑f(ison,1)但是这个时候要让被灯照亮两次的边尽量多，那么应该让被照亮一次的边尽量的少，那么另m=n×x+yx代表覆盖当前的子树的灯的数量，y代表当前子树中覆盖完成的最少的被照亮一次的边的数量前提是让y的最大值小于n那么这样x就成为了首要重要的权值，y是次要的然后dp方程改一下

 //f(i, 0) = (∑f(ison, 1)) + 1
 //加1是因为自己和自己的父亲又有一条边被照亮一次所以加1，
 //f(i, 1) = max{ (∑f(ison,0)) + 1,∑f(ison,1) }
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<cmath>
 #include<algorithm>
 #include<string>
 #include<vector>
 #include<queue>
 #include<stack>
 #define INF 0x3f3f3f3f
 #define NODENUM 1005
 #define EDGENUM 1005
 #define MAXN 1005
 using namespace std;
 //优化x=M*v1+v2，其中M是比"比v2的最大理论值和v2的最小理论值之差"还要大的数。v1表示放置的路灯数目尽可能小，v2表示被一盏灯照亮的路尽可能小。v1=x/M,v2=x%M,v3=m-v2.(被两盏灯照亮的路)
 int root;
 const int m = ;//即理论的M

 struct EdgeNode
 {
     int to, next;
 } E[ * EDGENUM];
 int edgenum, head[NODENUM], N, T, M;
 bool vis[NODENUM];
 int ans;
 int dp[NODENUM][];//[0]表示不放灯，[1]表示放灯

 void init()
 {
     edgenum = ;//路条数为0
     memset(head, -, sizeof(head));
     memset(vis, , sizeof(vis));
     ans = ;
 }

 void add(int x, int y)
 {
     edgenum++;
     E[edgenum].next = head[x];
     head[x] = edgenum;
     E[edgenum].to = y;
 }

 void dfs(int s)
 {
     vis[s] = ;
     int sum0 = , sum1 = ;

     for (int p = head[s]; p != -; p = E[p].next)
     {
         int v = E[p].to;
         if (!vis[v])
         {
             dfs(v);
             sum0 += dp[v][];
             sum1 += dp[v][];
         }
     }
     if (s == root) dp[s][] = min(sum1 + m, sum0), ans += dp[s][];
     else dp[s][] = min(sum0 + , sum1 + m), dp[s][] = sum1 + m + ;
 }
 //每放一盏灯 + 2000(m)（因为边的最大数量为1000），每增加1条照亮一次的边 + 1.
 //决策一：节点i处不放街灯，那么i是根或者父亲节点放了街灯。所以dp(i,j)=sum{ dp(v,0) | v取遍i的所有儿子节点 }，如果i不是根节点，那么结果+1，因为i和父亲连接的这条边只被一盏灯照亮。
 //决策二：节点i处放街灯，dp(i, j) = sum{ dp(v,1) | v取遍i的所有儿子节点 } +M，如果i不是根节点而且j = 0，那么结果 + 1。
 void build()
 {
     scanf("%d%d", &N, &M);
     for (int i = ; i<M; ++i)
     {
         int a, b;
         scanf("%d%d", &a, &b);
         add(a, b);//无向边
         add(b, a);
     }
 }

 int main()
 {
     scanf("%d", &T);//测试用例
     while (T--)
     {
         init();
         build();
         for (int i = ; i<N; ++i) if (!vis[i]) dfs(root = i);//可能有多颗树
         printf("%d %d %d\n", ans / m, M - ans%m, ans%m);
     }
     return ;
 }

11、uva 10817 Headmaster's Headache ( 状态压缩dp+sstream应用)

　　题意：学校现在招老师，给出原来任职的老师和前来应聘的老师的信息，求在保证每门科目至少有两个老师教的情况下，最小花费是多少。

　　思路：把学科的信息用二进制状态压缩，s1对应还需要一个老师教的科目,s2对应已经足够老师教的科目.状态设为dp[i][s1][s2]：代表到第i个老师为止，校长最少需要花多少钱达到目标。当i < m 时，我们必须选择，状态只能更新为添加老师，当i >= m时， 就可以更新为选或不选老师两种状态。s1：当某个学科还需要1个老师教时，该位记为1，否则记为0；s2:当某个学科已经有足够的老师教时，该位记为1，否则记为0。

 #include<iostream>
 #include<cstring>
 #include<string>
 #include<sstream>
 #include<algorithm>
 using namespace std;
 const int INF = 0x7f7f7f7f, MAXN = ;
 int s, m, n, teach[MAXN], cost[MAXN], dp[MAXN][ << ][ << ];

 int DP(int i, int s1, int s2)//s1对应还需要一个老师教的科目,s2对应已经足够老师教的科目.状态设为dp[i][s1][s2]：代表到第i个老师为止，校长最少需要花多少钱达到目标。当i < m 时，我们必须选择，状态只能更新为添加老师，当i >= m时， 就可以更新为选或不选老师两种状态。
 //s1,s2均为2进制数，每一位表示该课程有无老师
 //s1：当某个学科还需要1个老师教时，该位记为1，否则记为0
 //s2:当某个学科已经有足够的老师教时，该位记为1，否则记为0
 {
     if (i == m + n) return s2 == ( << s) -  ?  : INF;  //每个科目都至少两个老师了，那么就不需要再花钱了
     int &ret = dp[i][s1][s2];//引用
     if (ret >= ) return ret;
     ret = INF;
     if (i >= m) ret = DP(i + , s1, s2);         //不选
     s2 |= (s1 & teach[i]);                       //老师能教，并且差一个老师，那么一并运算，剩下的就是满足条件的科目
     s1 |= teach[i];                              //或上去，没人教的科目肯定变成差一个人教
     ret = min(ret, cost[i] + DP(i + , s1, s2)); //选
     return ret;
 }

 int main()
 {
     while (~scanf("%d%d%d",&s,&m,&n))
     {
         if (s == )break;
         cin.get();
         string ss;
         int x;
         for (int i = ; i < m + n; ++i)
         {
             getline(cin, ss);
             stringstream sss(ss);
             sss >> cost[i];
             teach[i] = ;
             while (sss >> x)
             {
                 teach[i] |=  << (x - );
             }
         }
         memset(dp, -, sizeof dp);
         //for (int i = 0; i < m + n; ++i) cout << cost[i] << ':' << teach[i] << endl;
         cout << DP(, , ) << '\n';
     }
     return ;
 }

12、hdu 1024 Max Sum Plus Plus

　　题意：给n个数，现在需要找到m个区间，使得每个区间内元素的和累加起来最大。

　　思路：dp[i][j]表示前j个数在选取第j个数的前提下分成i段的最大值。dp[i][j]=max(dp[i][j-1]+num[j],max(dp[i-1][k]|(0<k<j))+num[j]);dp[i][j-1]+num[j]表示前j-1个分成i组，j放在其他组里；max(dp[i-1][k]|(0<k<j))+num[j]表示前k个分成i-1组的最大值加上第j个独立成组的大小。

 #include<iostream>
 #include<algorithm>
 using namespace std;
 int n,m;
 const int maxn = ;
 const int INF = 0x7fffffff;

 int num[maxn];
 int dp_now[maxn];
 int max_pre[maxn];
 //dp[i][j]表示前j个数在选取第j个数的前提下分成i段的最大值。
 //dp[i][j]=max(dp[i][j-1]+num[j],max(dp[i-1][k]|(0<k<j))+num[j]);
 //dp[i][j-1]+num[j]表示前j-1个分成i组，j放在其他组里
 //max(dp[i-1][k]|(0<k<j))+num[j]表示前k个分成i-1组的最大值加上第j个独立成组的大小
 int main()
 {
     while (~scanf("%d%d", &m, &n))
     {
         for (int i = ; i <= n; i++) scanf("%d", &num[i]);
         memset(dp_now, , sizeof(dp_now));
         memset(max_pre, , sizeof(max_pre));
         int tmax;
         for (int i = ; i <= m; i++)
         {
             tmax = -INF;
             for (int j = i; j <= n; j++)
             {
                 dp_now[j] = max(dp_now[j - ]+num[j], max_pre[j - ] + num[j]);
                 max_pre[j - ] = tmax;
                 tmax = max(tmax, dp_now[j]);
             }
         }
         printf("%d\n", tmax);
     }
     return ;
 }

13、hdu 1029 Ignatius and the Princess IV

　　题意：给出n个数（n为奇数），输出n个数中至少出现（n+1）/2的数。

　　思路：扫描一边数组即可。

 #include<iostream>
 using namespace std;
 int main()
 {
     int n;
     while (~scanf("%d", &n))
     {
         int cal = ;
         int m;
         int t;
         while (n--)
         {
             scanf("%d", &t);
             if (cal == )
             {
                 m = t;
                 cal++;
             }
             else
             {
                 if(t != m)
                 {
                     cal--;
                 }
                 else cal++;
             }
         }
         printf("%d\n", m);
     }

     return ;
 }

14、hdu 1069 Monkey and Banana

　　题意：给出若干种类型的的砖块，其底面的长宽可由任意两边确定。现在把这些砖块叠放，砖块上方的砖块的底面的长和宽都必须小于该砖块的长与宽，求最大高度。

　　思路：先得到各种砖块各种摆放的方式，然后按底面长和宽从大到小排序。从小的开始dp，如果当前块的长和宽比之前的要大，则累加。

 #include<iostream>
 #include<algorithm>
 using namespace std;
 const int maxn = ;
 struct node
 {
     int l;
     int w;
     int h;
 }blocks[maxn*];
 int dp[maxn * ];//以i为底的最高高度
 bool Cmp(const node&a, const node&b)
 {
     if (a.l == b.l)return a.w > b.w;
     else return a.l > b.l;
 }
 int main()
 {
     int n;
     int Case = ;
     while (~scanf("%d", &n))
     {
         if (n == )break;
         int cnt = ;
         while (n--)
         {
             int xi, yi, zi;
             scanf("%d%d%d", &xi, &yi, &zi);
             blocks[cnt].l = xi, blocks[cnt].w = yi, blocks[cnt].h = zi;
             cnt++;
             blocks[cnt].l = yi, blocks[cnt].w = xi, blocks[cnt].h = zi;
             cnt++;
             blocks[cnt].l = xi, blocks[cnt].w = zi, blocks[cnt].h = yi;
             cnt++;
             blocks[cnt].l = zi, blocks[cnt].w = xi, blocks[cnt].h = yi;
             cnt++;
             blocks[cnt].l = yi, blocks[cnt].w = zi, blocks[cnt].h = xi;
             cnt++;
             blocks[cnt].l = zi, blocks[cnt].w = yi, blocks[cnt].h = xi;
             cnt++;
         }
         sort(blocks, blocks + cnt, Cmp);
         for (int i = ; i < cnt; i++) dp[i] = blocks[i].h;
         for (int i = cnt - ; i >= ; --i)
         {//从小的开始DP
             for (int j = i + ; j < cnt; j++)
             {
                 if (blocks[j].l < blocks[i].l&&blocks[j].w < blocks[i].w)
                 {
                     if (dp[j] + blocks[i].h > dp[i])
                     {
                         dp[i] = dp[j] + blocks[i].h;
                     }
                 }
             }
         }
         int ans = ;
         for (int i = ; i < cnt; i++)
         {
             ans = max(ans, dp[i]);
         }
         printf("Case %d: maximum height = %d\n", Case++, ans);
     }

     return ;
 }

15、hdu 1074 Doing Homework

　　题意：每门功课的作业都有自己的截止日期和做完所需时间。同时，每门功课都有自己学分，如果不能在截止日期前上交作业，每拖一天则多扣一个学分。问最少会扣多少学分。

　　思路：科目最多有15门，枚举每门的完成状态，从小到大枚举，如果当前状态st下,需要完成某项作业j，则考虑其不需完成该作业的状态stt=st^(1<<j),如果加上这门课后其所扣学分更少，则更新，并记录前驱，以便后续输出。

 #include<iostream>
 #include<stack>
 #include<cstdio>
 #include<memory.h>
 using namespace std;
 int n;
 const int maxn = ;
 const int INF = 0x7fffffff;
 struct sbj
 {
     char nm[];//科目名称
     int deadline;//截止日期
     int cost;//完成需花费的时间
 }homework[maxn];
 struct node
 {
     int tm;
     int score;
     int pre;
     int now;
 }dp[ << maxn];
 int main()
 {
     int t;
     scanf("%d", &t);
     while (t--)
     {
         scanf("%d", &n);
         {
             int total = ( << n) - ;
             for (int i = ; i < n; i++)
             {
                 scanf("%s%d%d", homework[i].nm, &homework[i].deadline, &homework[i].cost);
             }
             memset(dp, , sizeof(dp));
             for (int st = ; st <= total; st++)
             {//从小的枚举
                 dp[st].score = INF;
                 for (int j = n - ; j >= ; j--)
                 {//从最后往前枚举
                     if (st&( << j))
                     {
                         int st2 = st ^ ( << j);
                         int t = dp[st2].tm + homework[j].cost - homework[j].deadline;
                         if (t < ) t = ;
                         if (t + dp[st2].score < dp[st].score)
                         {
                             dp[st].score = t + dp[st2].score;
                             dp[st].pre = st2;
                             dp[st].now = j;
                             dp[st].tm = dp[st2].tm + homework[j].cost;
                         }
                     }
                 }
             }
             printf("%d\n", dp[total].score);
             int pre = total;
             stack<int>s;
             while (pre)
             {
                 s.push(dp[pre].now);
                 pre = dp[pre].pre;
             }
             while (!s.empty())
             {
                 printf("%s\n", homework[s.top()].nm);
                 s.pop();
             }
         }
     }
     return ;
 }

16、hdu 1087  Super Jumping! Jumping! Jumping!

　　题意：现在需要从起点到终点踩格子，每次只能向前踩比当前各自大的数字的格子，求所踩格子的数字之和的最大值。

　　思路：dp[i]代表以第i个数结尾的最大上升子序列的和，对于当前的格子i，遍历之前的dp[j]（0<=j<=i）,如果dp[j]+num[i]>dp[i],则更新dp[i]的值。

 #include<iostream>
 using namespace std;
 const int maxn = ;
 int num[maxn];
 int dp[maxn];//dp[i]代表以第i个数结尾的最大上升子序列的和
 int main()
 {
     int n;
     while (~scanf("%d", &n))
     {
         if (n == ) break;
         for (int i = ; i < n; i++) scanf("%d", &num[i]);
         memset(dp, , sizeof(dp));
         dp[] = num[];
         int ans = dp[];
         for (int i = ; i < n; i++)
         {
             dp[i] = num[i];
             for (int j = ; j <= i; j++)
             {
                 if (num[j] < num[i])
                 {
                     if (dp[j] + num[i] > dp[i])
                     {
                         dp[i] = dp[j] + num[i];
                     }
                 }
             }
             if (dp[i] > ans) ans = dp[i];
         }
         printf("%d\n", ans);
     }
     return ;
 }

17、hdu 1114 Piggy-Bank

　　题意：给出空的储钱罐的重量和当前储钱罐的重量，给出n种硬币的重量和面值。求使得储钱罐内的最小的硬币总价值。

　　思路：dp[v] = min(dp[v], dp[v - coins[i].w] + coins[i].p);dp[i]表示硬币总重量为i时，储钱罐内硬币的最低价值。

 #include<iostream>
 #include<algorithm>
 using namespace std;
 const int maxn = ;
 const int maxw = ;
 const int maxp = ;
 const int INF = 0x7fffffff;

 int dp[maxw];
 struct coin
 {
     int p;
     int w;
 }coins[maxn];
 int main()
 {
     int t;
     scanf("%d", &t);
     while (t--)
     {
         int e, f;
         scanf("%d%d", &e, &f);
         int totalw = f - e;//装硬币的重量
         int minwight = maxw;
         int n;
         scanf("%d", &n);
         for (int i = ; i < n; i++)
         {
             scanf("%d%d", &coins[i].p, &coins[i].w);
             if (coins[i].w < minwight) minwight = coins[i].w;
         }
         if (minwight > totalw)
         {
             printf("This is impossible.\n");
             continue;
         }
         for (int i = ; i <= totalw; i++) dp[i] = INF;
         dp[] = ;
         for (int i = ; i < n; i++)
         {
             for (int v = ; v <= totalw; v++)
             {
                 if (v - coins[i].w >= && dp[v - coins[i].w]!=INF)
                 {
                     /*if(dp[v]>=0)dp[v] = min(dp[v], dp[v - coins[i].w] + coins[i].p);
                     else dp[v] = dp[v - coins[i].w] + coins[i].p;*/
                     dp[v] = min(dp[v], dp[v - coins[i].w] + coins[i].p);
                 }
             }
         }
         if(dp[totalw]<INF)printf("The minimum amount of money in the piggy-bank is %d.\n", dp[totalw]);
         else
         {
             printf("This is impossible.\n");
         }
     }
     return ;
 }

18、HDU 1176 免费馅饼

　　题意：天上开始掉馅饼，每秒种只有在移动不超过一米的范围内接住坠落的馅饼。刚开始时站在5的位置，问最后最多能接住多少馅饼。

　　思路：从最大时间往前DP。

 #include<iostream>
 #include<cstdio>
 #include<memory.h>
 #include<algorithm>
 using namespace std;
 int n;
 const int maxn = ;
 const int maxt = ;
 const int INF = 0x7fffffff;
 int dp[maxt][];
 int main()
 {
     while (~scanf("%d", &n))
     {
         if (n == )break;
         memset(dp,, sizeof(dp));
         int maxtt = ;
         for (int i = ; i < n; i++)
         {
             int x, t;
             scanf("%d%d", &x, &t);
             dp[t][x]++;
             if (t > maxtt) maxtt=t;
         }
         for (int i = maxtt-; i >= ; i--)
         {
             for (int st = ; st <= ; st++)
             {
                 if (st == ) dp[i][st] += max(dp[i + ][st], dp[i + ][st + ]);
                 else if(st==)dp[i][st] += max(dp[i + ][st], dp[i + ][st - ]);
                 else dp[i][st] += max(dp[i + ][st - ], max(dp[i + ][st], dp[i + ][st + ]));
             }
         }
         printf("%d\n", dp[][]);
     }
     return ;
 }