poj 1947 Rebuilding Roads 树形动态规划，由左向右合并子树

　　对于一颗以 rt 为根的树，其有 I 个子节点分别为 S1，S2，。。。，SI ，则

　　状态

　　　　dp（i,j）表示前 1，2，,,,，I  子树，组合而成一棵 包含 J个节点的 子树的最小花费

　　　　sum（Si） 表示 以 Si 节点为根的子树，节点数量

　　　　Cut （Si, K） 表示 子树 Si 中取得 一棵包含 根Si 的子树 且节点数量为 K 的最小花费

　　

　　则状态转移方程：

　　　　

　　其中 x <= Sum（Si）， 且  

　　注意到， 其实我们已经把  子树S1，S2，，S(i-1) 合并到了 dp（I-1）里头去了。这样就简化了枚举计算。

　　另外，还可以注意到

　　　　

　　所以我们可以递归从 子节点往 上处理。

　　

　　另外，在编码时要注意，叶子节点处理，以及 若当前子树 取0 则 花费为1，因为与父节点相连的边需要舍弃。

　　更要注意的是， 在合并过程中需要 将中间结果 保存在辅助 数组 F[] 中， 不能直接覆盖 dp[] ， 以为在计算过程需要反复用到，

　　否则会出错， 笔者在这里 WA了半天

 

给出一组 关于这个Bug 的测试数据

12 7

1 2

1 3

1 4

2 5

3 6

3 7

4 8

4 9

5 10

10 11

10 12

正确结果为 1 

解题代码

// Code by yefeng1627
// Time: 2013-1-17
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<algorithm>
#include<iostream>
#include<vector>
using namespace std;

const int inf = 0x3f3f3f3f;
const int N = 155;
vector< int > Q[N];

struct node
{
    int dp[N], sum;
}T[N];

int n, P, ans;

void Input()
{
    for(int i = 0; i <= n; i++) Q[i].clear();
    int x, y;
    for(int i = 1; i < n; i++)
    {
        scanf("%d%d", &x,&y);
        Q[x].push_back(y);
    }
}

// dp(i,j) 表示当前以rt为根，前i个子树组合一颗含j个节点的最小花费
void dfs( int rt ) // cost 为由父节点到当前子树的路径长度
{
    //初始化dp方程,皆为无穷大    
    memset( T[rt].dp, 0, sizeof( T[rt].dp ) );

    T[rt].sum = 1; //当前子树，节点数量总和
    // Dp方程初始化
    //首先处理其子树,得到子树的 cut,与 sum 信息
    for(int i = 0; i < Q[rt].size(); i++)
    {
        int v = Q[rt][i];    
        dfs( v );
        T[rt].sum += T[v].sum;    
    }
    //处理当前以rt为根树，子节点组合情况

    int tot = 1;
    T[rt].dp[0] = 1; //子树上全部截掉时,从根节点处破坏路径,花费1
    for(int i = 1; i <= Q[rt].size(); i++)
    {
        // dp[i][j],表示前 i棵子树,构成一棵节点数量为J的子树(包括根节点)的最小花费
        int v = Q[rt][i-1];    
    
        int f[N];
        for(int j = 0; j <= tot; j++) f[j] = T[rt].dp[j];
        // 枚举组合子树节点数量 J , j至少为1,因为包含根节点rt    
        for(int j = 1; j <= tot; j++)
        {
            //处理第v棵子树,枚举此子树贡献节点数量x, 且x <= T[v].sum, j-x >= 1
        
            int tmp = inf;    
            for(int x = 0; (x <= T[v].sum ) && (j-x>=1) ; x++ ) 
                tmp = min( tmp, T[rt].dp[j-x] + T[v].dp[x] );
            // take into considerations
            f[j] = min( T[rt].dp[j] + 1, tmp );    
        }        
        for(int j = tot+1; j <= tot+T[v].sum; j++)
            T[rt].dp[j] = T[v].dp[j-tot];
        // assention  dp[] has change....    
        for(int j = 0; j <= tot; j++) T[rt].dp[j] = f[j];    
        tot += T[v].sum;    
    
    }
    if( tot >= P )        
        ans = min( ans, T[rt].dp[P] + 1 );
}
int main()
{
    while( scanf("%d%d",&n,&P) != EOF)
    {
        Input();
        
        ans = inf;
        dfs(1);    
        ans = min( ans, T[1].dp[P] );    
        printf("%d\n", ans );
    }
    return 0;
}