bzoj2427 [HAOI2010]软件安装 ( 树形背包 + tarjan )

bzoj2427 [HAOI2010]软件安装

原题地址：http://www.lydsy.com/JudgeOnline/problem.php?id=2427

题意：
现在我们的手头有N个软件，对于一个软件i，它要占用Wi的磁盘空间，它的价值为Vi。我们希望从中选择一些软件安装到一台磁盘容量为M计算机上，使得这些软件的价值尽可能大（即Vi的和最大）。

软件之间存在依赖关系，即软件i只有在安装了软件j（包括软件j的直接或间接依赖）的情况下才能正确工作（软件i依赖软件j)。一个软件最多依赖另外一个软件。如果一个软件不能正常工作，那么它不能发挥作用。

软件i依赖软件Di。一个软件只能被安装一次，如果一个软件没有依赖则Di=0，这时只要这个软件安装了，它就能正常工作。

求软件们能发挥的最大价值。

数据范围
0<=N<=100, 0<=M<=500
0<=Wi<=M
0<=Vi<=1000
0<=Di<=N, Di≠i

题解：
坑点很多，谨慎处置。

首先，尽管一个软件最多依赖另外一个软件，原图也并不是一棵树。可能出现A依赖B，B依赖A这样的情况，就是说，有环。

因此，我们先tarjan缩点，并且新建一个根，把根连向入度为零的点。得到一棵树。

然后我们开始DP，跟分组背包相似，

第一组其实是点u本身，因此先把v[u]加入（之后方便处理这个w[u]的问题）。
然后：
对于点u
for 子树v
for j=m~0容积
for k=0~m 该子树取容积为k
if(j>=k+w[u]) dp[u][j]=max(dp[u][j],dp[v][k]+dp[u][j-k])
要注意这个j和k的枚举顺序，j倒序的意义和一般背包相同，但此时的k必须是正序，为什么呢？

因为 0<=Wi<=M ， 0<=M<=500

若k倒序，当k=0时，若dp[v][0]有值，dp[u][j]=dp[v][k]+dp[u][j-k]=dp[v][0]+dp[u][j]
是在上一次已经更新过的dp[u][j]基础上加，就会多加一次dp[v][0]
而k正序，第一个就处理的是dp[v][0]，k>0之后再更新dp[u][j]也不会用到dp[u][j]。
比如这组数据：

4 10
0 2 4 3
1 3 2 2
2 0 3 0

正确答案是：8
于是乎，dp方程写法为：

for(int i=w[u];i<=m;i++) dp[u][i]=max(v[u],dp[u][i]);
for(int  i=head[u];i;i=nxt[i])
    {
        int vv=to[i]; if(vv==f) continue;

        for(int j=m;j>=0;j--)
        {
            for(int k=0;k<=m;k++)  
            {
                if(j>=k+w[u]) dp[u][j]=max(dp[u][j],dp[vv][k]+dp[u][j-k]);
            }   
        }
    }   
}

当然也可以特判一下k=0：

    for(int i=w[u];i<=m;i++) dp[u][i]=max(v[u],dp[u][i]);
    for(int  i=head[u];i;i=nxt[i])
    {
        int vv=to[i]; if(vv==f) continue;

        for(int j=m;j>=0;j--)
        {
            int pre=dp[u][j];
            for(int k=m;k>=0;k--)  //为什么用pre？ w可为0 ,致使重复加 
            {
                if(j>=k+w[u]) dp[u][j]=max(dp[u][j],dp[vv][k]+((k==0)?pre:dp[u][j-k]));
            }   
        }
    }

代码：

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
const int N=110;
const int M=510;
int n,m,head[N],to[M],nxt[M],num=0,www[N],vvv[N],w[N],v[N],in[N],dp[N][M];
int low[N],dfn[N],inc=0,top=0,stack[N],cnt=0,pl[N],ans=0;
bool ins[N];
vector<pair<int,int> > V;
void build(int u,int v)
{
    V.push_back(make_pair(u,v));
    num++;
    to[num]=v;
    nxt[num]=head[u];
    head[u]=num;
}
void tarjan(int u)
{
    inc++; low[u]=dfn[u]=inc;
    stack[++top]=u; ins[u]=1;
    for(int i=head[u];i;i=nxt[i])
    {
        int v=to[i];
        if(!dfn[v])
        {
            tarjan(v);
            low[u]=min(low[v],low[u]);
        }
        else if(ins[v]) low[u]=min(dfn[v],low[u]);  
    }
    if(low[u]==dfn[u])
    {
        cnt++;
        while(1)
        {
            pl[stack[top]]=cnt;
            ins[stack[top]]=0;
            w[cnt]+=www[stack[top]];
            v[cnt]+=vvv[stack[top]];
            top--;
            if(stack[top+1]==u) break;
        }
    }
}

void dfs(int u,int f)
{
    for(int i=head[u];i;i=nxt[i])
    {
        int vv=to[i]; 
        if(vv==f) continue;
        dfs(vv,u);
    }

    for(int i=w[u];i<=m;i++) dp[u][i]=max(v[u],dp[u][i]);
    for(int  i=head[u];i;i=nxt[i])
    {
        int vv=to[i]; if(vv==f) continue;

        for(int j=m;j>=0;j--)
        {
            for(int k=0;k<=m;k++)  //注意顺序
            {
                if(j>=k+w[u]) dp[u][j]=max(dp[u][j],dp[vv][k]+dp[u][j-k]);
            }   
        }
    }   
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++) scanf("%d",&www[i+1]);
    for(int i=1;i<=n;i++) scanf("%d",&vvv[i+1]);
    cnt=1;
    for(int i=1;i<=n;i++)
    {
        int d;
        scanf("%d",&d);
        if(!d) continue;
        build(d+1,i+1);
    }
    for(int i=2;i<=n+1;i++)
    if(!dfn[i]) tarjan(i);

    memset(head,0,sizeof(head)); num=0;

    int sz=V.size();
    for(int i=0;i<sz;i++)
    {
        int u=V[i].first; int v=V[i].second;
        if(pl[u]!=pl[v]) {build(pl[u],pl[v]);in[pl[v]]++;}
    }
    n=cnt;
    for(int i=2;i<=n;i++)
    if(in[i]==0) build(1,i);
    dfs(1,1);
    printf("%d\n",dp[1][m]);
    return 0;
}