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 = 155;
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 = 2; i <= p; ++i) {
        dp[u][i] = inf;
    }
    dp[u][1] = 0; //考虑到叶子节点，而非叶子节点在下面的for中会增加
    for(int i = 0; i < edge[u].size(); ++i) {
        int v = edge[u][i];
        if(v == par)
            continue;
        dfs(v, u);
        for(int j = p; j >= 1; --j) { 
        //有点背包的思想，正序的话dp[u][j]可能由dp[v][k]转移而来，在下面会被重复转移。倒序的话保证转移一次。
            int temp = dp[u][j] + 1; //去掉v子树
            for(int k = 1; 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 = 1; i <= n; ++i) {
            edge[i].clear();
        }
        for(int i = 1; i < n; ++i) {
            scanf("%d %d", &u, &v);
            edge[u].push_back(v);
            edge[v].push_back(u);
        }
        dfs(1, -1);
        int res = dp[1][p]; //根节点没有父亲 不需要+1
        for(int i = 2; i <= n; ++i) {
            res = min(dp[i][p] + 1, res); //其他节点有父节点 去除的话所以+1
        }
        printf("%d
", res);
    }
    return 0;
}

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