POJ 1947 Rebuilding Roads (树dp + 背包思想)

题目链接：http://poj.org/problem?id=1947

一共有n个节点，要求减去最少的边，行号剩下p个节点。问你去掉的最少边数。

dp[u][j]表示u为子树根，且得到j个节点最少减去的边数。

考虑两种情况，去掉孩子节点v与去不掉。

（1）去掉孩子节点：dp[u][j] = dp[u][j] + 1

（2）不去掉孩子节点：dp[u][j] = min(dp[u][j - k] + dp[v][k])

综上就是dp[u][j] = min(dp[u][j] + 1, min(dp[u][j - k] + dp[v][k]))

 //#pragma comment(linker, "/STACK:102400000, 102400000")
 #include <algorithm>
 #include <iostream>
 #include <cstdlib>
 #include <cstring>
 #include <cstdio>
 #include <vector>
 #include <cmath>
 #include <ctime>
 #include <list>
 #include <set>
 #include <map>
 using namespace std;
 typedef long long LL;
 typedef pair <int, int> P;
 const int N = ;
 int dp[N][N], n, p, inf = 1e8;
 vector <int> edge[N];
 //dp[i][j]表示i为子树根，且得到j个节点最少减去的边数。不考虑父节点

 void dfs(int u, int par) {
     for(int i = ; i <= p; ++i) {
         dp[u][i] = inf;
     }
     dp[u][] = ; //考虑到叶子节点，而非叶子节点在下面的for中会增加
     for(int i = ; i < edge[u].size(); ++i) {
         int v = edge[u][i];
         if(v == par)
             continue;
         dfs(v, u);
         for(int j = p; j >= ; --j) {
         //有点背包的思想，正序的话dp[u][j]可能由dp[v][k]转移而来，在下面会被重复转移。倒序的话保证转移一次。
             int temp = dp[u][j] + ; //去掉v子树
             for(int k = ; k < j; ++k) {
                 temp = min(dp[u][j - k] + dp[v][k], temp);
             }
             dp[u][j] = temp; //最优 跟最短路思想类似
         }
     }
 }

 int main()
 {
     int u, v;
     while(~scanf("%d %d", &n, &p)) {
         for(int i = ; i <= n; ++i) {
             edge[i].clear();
         }
         for(int i = ; i < n; ++i) {
             scanf("%d %d", &u, &v);
             edge[u].push_back(v);
             edge[v].push_back(u);
         }
         dfs(, -);
         int res = dp[][p]; //根节点没有父亲 不需要+1
         for(int i = ; i <= n; ++i) {
             res = min(dp[i][p] + , res); //其他节点有父节点 去除的话所以+1
         }
         printf("%d\n", res);
     }
     return ;
 }

这题感觉好难想，人笨没办法