POJ 1947 Rebuilding Roads

题目大意：

根据两个点建立一条有向边，最后可形成的是一棵树，希望通过切除一些边，使一棵含有p个节点的子树被独立出来，希望切除的边数最少，输出这个边数

 

这个是第一次自己完完整整做出来的树形Dp题目，没有参考别人的DP思路，虽然自己很快想好了，但是总是无法合适的进行组织，做了很久，但自己做出来的

总是会比取理解别人代码来的效果好很多

用dp[u][j] 记录u号节点这棵子树中含有j个点需要砍去的最少的边数

两次dfs ， 第一次dfs查出对应节点的下方子树中一共有多少个节点，顺便记录一个节点在当前延伸出去了几条边

也就是dp[u][1] ，表示最后u代表的子树下方全部砍去只剩u这一个点

 

第二次dfs中自底向上不断将子树添加进来，根据dp值判断是否适合加入这个子树，如果适合加入，那么因为之前砍去的那条边要加回来，所以

砍去的边要少一

dp[u][j] = min(dp[u][j] , dp[v][k] + dp[u][j-k] - 1) k<j

这里判断dp[u][j] ， 和dp[v][k] + dp[u][j-k] - 1的大小，前一个表示没必要添加v子树，后一个表示添加了v子树效果更好

实际这里的二重循环也是相当于类似背包问题的思想

#include <cstdio>
#include <cstring>
#include <iostream>

using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 205;

int dp[N][N] , sum[N] , first[N] , col[N] , root , k;

struct Edge{
    int y , next;
}e[N];

void add_edge(int x , int y)
{
    e[k].y = y  , e[k].next = first[x];
    first[x] = k++;
}

void dfs1(int u)
{
    sum[u] = 1;
    dp[u][1] = 0;
    for(int i=first[u] ; i!=-1 ; i=e[i].next){
        dp[u][1] ++;
        int v = e[i].y;
        dfs1(v);
        sum[u] += sum[v];
    }
}

void dfs2(int u , int n)
{
    dp[u][sum[u]] = 0;
    for(int i=first[u] ; i!=-1 ; i=e[i].next){
        int v = e[i].y;
        dfs2(v , n);
        //这里j必须递减，因为运算中用到了dp[u][j-k]，如果是递增顺序，那么会提前把要使用的更新了
        for(int j=sum[u] ; j>=2 ; j--){
            for(int k=j-1 ; k>=1 ; k--){
                dp[u][j] = min(dp[u][j] , dp[v][k] + dp[u][j-k] - 1);
            }
        }
    }
}

int main()
{
   // freopen("a.in" , "r" , stdin);
    int n , p , a , b;
    while(scanf("%d%d" , &n , &p) == 2)
    {
        memset(first , -1 , sizeof(first));
        memset(col , 0 , sizeof(col));
        k = 0;
        for(int i=1 ; i<n ; i++){
            scanf("%d%d" , &a , &b);
            add_edge(a , b);
            col[b] = 1;
        }
        for(int i = 1 ; i<=n ; i++)
            if(!col[i]) root = i;

        memset(dp , 0x3f , sizeof(dp));
        dfs1(root);
        dfs2(root , n);

        int minn = INF;
        for(int i=1 ; i<=n ; i++){
            if(i == root) minn = min(minn , dp[i][p]);
            else minn = min(minn , dp[i][p]+1);
        }
        printf("%d\n" , minn);
    }
    return 0;
}