POJ

传送门

有一颗N个结点的树，求需要割掉至少多少条边才能得到一颗恰好有P个结点的树

没做出来，看了大神的解法才懂怎么做的orz

用了dp[root][i]表示用一颗以root为根的树，需要割点多少条边才能得到以root为根的恰好有i个结点的树。这样以来就有子问题，可以进行dp。

最后的答案里，由于在这个过程中，我们默认了root为根，但如果实际它有父亲，得到的dp[root][P]应该再加一

状态转移：dp[root][i] = min(dp[root][i - k] + dp[child][k] - 1，dp[root][i])；

每次在dp时，边界的话是，dp[root][1] = G[root].size();（儿子的数量），此时我们对每个结点的值，已经将它与儿子的边割掉。对于root的第一颗子树，假设子树上有cnt个结点，将子树连接上来，那么这时我们处理的是一颗有cnt+1个结点的树，会得到dp[root][i]({i} ⊆[1,cnt + 1]，当i>cnt+1时，值取INF。在接下来的子树中，就可以利用上前面的子树与根结点构成的树的值。

实际的操作过程中，是先得到一个根结点root，然后将它的一颗颗子树连接上来，并更新值，所以已经得到的树中取i-k个结点的值加上新子树取k个结点的值，最后才应该再减一，表示复原原本两个root与child间的边。

#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;

const int maxn = 155;
vector<int> G[maxn];
int deg[maxn], sum[maxn];
int dp[maxn][maxn];
int N, M;


void dfs(int node) {
    for (int i = 0; i < G[node].size(); i++) {
        int u = G[node][i];
        dfs(u);
        sum[node] += sum[u];
        for (int j = sum[node]; j > 0; j--) {
            for (int s = 1; s < j; s++) {
                dp[node][j] = min(dp[node][j], dp[node][j - s] + dp[u][s] - 1);
            }
        }
    }
}

int main(int argc, const char * argv[]) {
    scanf("%d%d", &N, &M);
    for (int i = 0; i <= N; i++) G[i].clear();
    memset(dp, INF, sizeof(dp));
    for (int i = 1; i < N; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        ++deg[u];
    }
    for (int i = 1; i <= N; i++) {
        dp[i][1] = deg[i];
        sum[i] = 1;
    }
    dfs(1);
    int ans = dp[1][M];
    for (int i = 2; i <= N; i++) {
        ans = min(ans, dp[i][M] + 1);
    }
    printf("%d
", ans);
    return 0;
}