HDU 4169 UVALive 5741 Wealthy Family

树形背包。DP递推的思路很简单....

但是由于节点有15万个，先不论空间复杂度，这样开dp数组 dp[150000+10][300+10]，如果初始化是memset(dp,-1,sizeof dp)，则必然超时。

所以需要一个状态数剪枝。。。即记录这个节点最多组合的数量。

UVALive是不限制内存的，所以dp[150000+10][300+10] 能够AC，HDU 4169 限制了内存大小，需要优化空间复杂度。

内存优化之后的代码，HDU上C++能AC，G++依旧MLE。

#include<cstdio>
#include<cstring>
#include<queue>
#include<algorithm>
using namespace std;

const int maxn=+;
struct Node
{
    int val;
    int fa;
    queue<int *>Q;
    vector<int>f;
}node[maxn];
int n,k,root;
int cnt[maxn];
int ans;

void init()
{
    memset(cnt,,sizeof cnt);
    for(int i=;i<=n;i++)
    {
        while(!node[i].Q.empty()) node[i].Q.pop();
        node[i].f.clear();
    }
}

void read()
{
    for(int i=;i<=n;i++)
    {
        scanf("%d%d",&node[i].fa,&node[i].val);
        if(!node[i].fa) root=i;
        else node[node[i].fa].f.push_back(i);
    }
}

void dfs(int now)
{
    if(!node[now].f.size())
    {
        cnt[now]=;
        int *p=new int[cnt[now]+];
        p[]=; p[]=node[now].val;
        node[node[now].fa].Q.push(p);
        delete[] p;
        return;
    }

    for(int i=;i<node[now].f.size();i++)
    {
        int id=node[now].f[i];
        cnt[now]=cnt[now]+cnt[id];
    }

    cnt[now]=min(k,cnt[now]);

    int *p=new int[cnt[now]+];

    p[]=;
    for(int i=;i<=cnt[now];i++) p[i]=-;

    int id=;
    while(!node[now].Q.empty())
    {
        int *head=node[now].Q.front();
        node[now].Q.pop();

        for(int j=cnt[now];j>=;j--)
            for(int s=;s<=j&&s<=cnt[node[now].f[id]];s++)
                if(head[s]!=-&&p[j-s]!=-)
                    p[j]=max(p[j],head[s]+p[j-s]);
        id++;
    }
    p[]=max(p[],node[now].val);

    node[node[now].fa].Q.push(p);

    if(now==)
    {
        if(cnt[]<k||p[k]==-) ans=-;
        else ans=p[k];
    }

    delete[] p;
    return;
}

void work()
{
    dfs(root);
    if(ans==-) printf("impossible\n");
    else printf("%d\n",ans);
}

int main()
{
    while(~scanf("%d%d",&n,&k))
    {
        init();
        read();
        work();
    }
    return ;
}

二维DP写法。HDU 上MLE的。UvaLive能过的。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int n, k;
int root;
const int maxn =  + ;
struct Edge
{
    int now;
    int next;
}e[maxn];
int head[maxn];
int cnt[maxn];
int val[maxn];
int dp[maxn][ + ];
int q;

void init()
{
    q=;
    for(int i=;i<=n;i++) head[i]=-;
}

void read()
{
    for (int i = ; i <= n; i++)
    {
        int fa;
        scanf("%d%d", &fa, &val[i]);
        if (!fa) root = i;
        else
        {
            e[q].now=i, e[q].next=head[fa];
            head[fa]=q, q=q+;
        }
    }
}

void dfs(int now)
{
    cnt[now]=;
    if (head[now]==-)
    {
        cnt[now]=;
        dp[now][] = val[now];
        return;
    }

    for (int i = head[now]; i!=-; i=e[i].next)
    {
        int id = e[i].now;
        dfs(id);
        cnt[now]=cnt[now]+cnt[id];
    }

    cnt[now]=min(cnt[now],k);

     for(int i=;i<=cnt[now];i++) dp[now][i]=-;
        dp[now][]=;

    for (int i = head[now]; i!=-; i=e[i].next)
    {
        int id = e[i].now;
        for(int j=cnt[now];j>=;j--)
            for(int s=;s<=j&&s<=cnt[id];s++)
                if(dp[id][s]!=-&&dp[now][j-s]!=-)
                    dp[now][j]=max(dp[now][j],dp[id][s]+dp[now][j-s]);
    }
    dp[now][]=max(val[now],dp[now][]);
}

void work()
{
    dfs(root);
    if (cnt[root]<k||dp[root][k] == -) printf("impossible\n");
    else printf("%d\n", dp[root][k]);
}

int main()
{
    while (~scanf("%d%d", &n, &k))
    {
        init();
        read();
        work();
    }
    return ;
}