poj 1947 Rebuilding Roads

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

给你一棵n个节点的树 问你保存p个节点的子树最少需要切断多少条边

我用邻接表保存树

ans[i][j] 代表了包含i在内的它所要子节点和兄弟子树在内 保存j个点需要最少切断多少边

代码及其注释：

#include<iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
#include<cmath>
#include<stack>
#include<algorithm>
#define LL long long

using namespace std;

const int N=155;
const int M=1000001;
struct node
{
    struct tt *next;
}mem[N];
struct tt
{
    int j;
    struct tt *next;
};
int ans[N][N];
void build(int i,int j)
{
    struct tt *t=new tt;
    t->j=j;
    t->next=mem[i].next;
    mem[i].next=t;
}
void Dele(int n)
{
    struct tt *t;
    for(int i=1;i<=n;++i)
    {
        while(mem[i].next!=NULL)
        {
            t=mem[i].next;
            mem[i].next=t->next;
            delete t;
        }
    }
}
int dp(struct tt *t,int k)
{
    if(t==NULL)//如果为空了
    {
        if(k==0)//保存0个的话反回0
        return 0;
        else
        return M;//否则反回最大
    }
    if(ans[t->j][k]!=-1)
    return ans[t->j][k];
    if(k==0)//保存0 个的话 需要切断所以兄弟节点与负节点的连线
    {
        ans[t->j][k]=1+dp(t->next,k);
        return ans[t->j][k];
    }
    ans[t->j][k]=1+dp(t->next,k);//此节点子树与父节点切断
    for(int i=1;i<=k;++i)
    {
        //递归找最优
        ans[t->j][k]=min(ans[t->j][k],dp(mem[t->j].next,i-1)+dp(t->next,k-i));
    }
    return ans[t->j][k];
}
int main()
{
    int n,k;
    while(scanf("%d %d",&n,&k)!=EOF)
    {
        for(int i=1;i<n;++i)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            build(x,y);
        }
        if(n==1)
        {
            printf("0\n");
            continue;
        }
        int MIN=M;
        memset(ans,-1,sizeof(ans));
        MIN=min(MIN,dp(mem[1].next,k-1));
        for(int i=2;i<=n;++i)
        {
            MIN=min(MIN,1+dp(mem[i].next,k-1));//不一定值保存 1
        }

        printf("%d\n",MIN);
        Dele(n);
    }
}