pku1947 Rebuilding Roads

http://poj.org/problem?id=1947

DP，树状DP

一棵节点为N的树，去掉最少的边，满足剩下树中，有一棵树的节点数为P

还要用分组背包优化，分组背包自己想的思路，写的比较难看。。。

dp[i][j]：表示以节点i为根的树，如果想要保证有j个节点，至少要去掉的边数

对于每组dp[i]，只能选一种j，如果不选这一组，也要多消耗1的费用

叶子节点初始化：dp[i] = {0, 1, 正无穷, 正无穷.......}；

之后看了一下背包九讲：

还可以把每个节点看成一个物品，那就成了背包九讲中的“泛化物品”背包，之前没理解泛化的意思，现在有了一个大概的理解了

安背包九讲的定义，这题可以简述成：有依赖的泛化物品背包问题吧。。。

#include <stdio.h>
#include <vector>
#define N 156

using namespace std;

int n, p, mark[N];
vector<int> a[N], dp[N];
const int inf = 1234;

int min(int x, int y)
{
    return x<y? x: y;
}

int inf_limit(int x)
{
    return x>inf? inf: x;
}

vector<int> pack(vector<int> b, vector<int> c)
{
    int i, j;
    vector<int> r;
    for(i=0; i<=p; i++) 
    {
        r.push_back(inf);
    }

    for(i=0; i<=p; i++)
    {
        for(j=0; j<=p && i+j<=p; j++)
        {
            r[i+j] = min(r[i+j], inf_limit(c[i]+b[j]));
        }
    }
    return r;
}

void f(int x, vector<int> b)
{
    int i, j;
    vector<int> c;
    for(i=0; i<=p; i++)
    {
        c.push_back(inf);
        dp[x].push_back(inf);
    } 
    if(b.size() == 0)
    {
        dp[x][0] = 1;
        dp[x][1] = 0;
        return;
    }
    c = dp[b[0]];
    for(i=1; i<b.size(); i++)
    {
        j = b[i];
        c = pack(c, dp[j]);
    }
    dp[x][0] = 1;
    for(i=1; i<=p; i++)
    {
        dp[x][i] = c[i-1];
    }
}

void dfs(int x)
{
    int i, j;
    vector<int> b;
    for(i=0; i<a[x].size(); i++)
    {
        j = a[x][i];
        if(mark[j] == 0)
        {
            b.push_back(j);
            mark[j] = 1;
            dfs(j);
        }
    }
    f(x, b);
    return;
}

int main()
{
    int i, j, x, y, root;
    int result;
    scanf("%d%d", &n, &p);
    for(i=1; i<=n; i++)
    {
        mark[i] = 1;
        a[i].clear();
        dp[i].clear();
    }
    for(i=1; i<=n-1; i++)
    {
        scanf("%d%d", &x, &y);
        a[x].push_back(y);
        mark[y] = 0;
    }
    for(i=1; i<=n; i++)
    {
        if(mark[i] == 1)
        {
            root = i;
        }
    }
    dfs(root);
    result = dp[root][p];
    for(i=1; i<=n; i++)
    {
        result = min(result, dp[i][p]+1);
    }
    printf("%d\n", result);
    return 0;
}