BZOJ 2427 [HAOI2010]软件安装 Tarjan+树上动态规划

Description

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

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

我们现在知道了软件之间的依赖关系：软件i依赖软件Di。现在请你设计出一种方案，安装价值尽量大的软件。一个软件只能被安装一次，如果一个软件没有依赖则Di=0，这时只要这个软件安装了，它就能正常工作。

---

Input

第1行：N, M （0<=N<=100, 0<=M<=500）
第2行：W1, W2, … Wi, …, Wn （0<=Wi<=M ）
第3行：V1, V2, …, Vi, …, Vn （0<=Vi<=1000 ）
第4行：D1, D2, …, Di, …, Dn （0<=Di<=N, Di≠i ）

---

Output

一个整数，代表最大价值。

---

Sample Input

3 10

5 5 6

2 3 4

0 1 1

---

Sample Output

5

---

HINT

Source

Day2

---

首先显然这个结构不一定是一棵树，甚至不一定是一个连通图，因为可以有些软件不需要依赖其他东西，那么我们在读入的时候，如果有依赖，比如A依赖B，就从B连一条边到A。然后我们进行一次Tarjan缩点，然后再进行一次重新建图，然后在新图上跑背包问题就行了，具体操作我们来看代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
const int MAXN=1000+10;
using namespace std;
struct Line{
    int from,to,nxt;
}line[MAXN*4];
struct Edge{
    int from,to,nxt;
}edge[MAXN*4];
int tail,head[MAXN],_head[MAXN],low[MAXN],dfn[MAXN],q[MAXN],top,timer,scc[MAXN],cnt,cntv[MAXN],cntw[MAXN];
int v[MAXN],w[MAXN],in[MAXN],n,m,f[MAXN][MAXN];
bool inq[MAXN]; 
int readin(){
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9')ch=getchar();
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void add_line(int from,int to){
    tail++;
    line[tail].from=from;
    line[tail].to=to;
    line[tail].nxt=head[from];
    head[from]=tail;
}
void tarjan(int u){
    low[u]=dfn[u]=++timer;
    q[++top]=u;inq[u]=true;
    for(register int i=head[u];i;i=line[i].nxt){
        int v=line[i].to;
        if(!dfn[v]){
            tarjan(v);
            low[u]=min(low[u],low[v]);
        }
        else if(inq[v]) low[u]=min(low[u],dfn[v]);
    }
    if(low[u]==dfn[u]){
        cnt++;
        inq[u]=false;
        scc[u]=cnt;
        cntv[cnt]+=v[u];
        cntw[cnt]+=w[u];
        while(q[top]!=u){
            inq[q[top]]=false;
            scc[q[top]]=cnt;
            cntv[cnt]+=v[q[top]];
            cntw[cnt]+=w[q[top]];
            top--;
        }
        top--;
    }
}
void _add_line(int from,int to){
    tail++;
    in[to]++;
    edge[tail].from=from;
    edge[tail].to=to;
    edge[tail].nxt=_head[from];
    _head[from]=tail;
}
void build(){
    tail=0;
    for(register int i=1;i<=n;i++){
        for(register int j=head[i];j;j=line[j].nxt){
            int v=line[j].to;
            if(scc[i]!=scc[v]) _add_line(scc[i],scc[v]);
        }
    }
}
void dpp(int u){
    for(register int i=_head[u];i;i=edge[i].nxt){
        int v=edge[i].to;
        dpp(v);
        for(register int j=m-cntw[u];j>=0;j--){
            for(register int k=0;k<=j;k++){
                f[u][j]=max(f[u][j],f[u][k]+f[v][j-k]);
            }
        }
    }
    for(register int i=m;i>=0;i--){
        if(i>=cntw[u])f[u][i]=f[u][i-cntw[u]]+cntv[u];
        else f[u][i]=0;
    }
}

int main(){
    //freopen(".txt","r",stdin);
    //freopen(".out","w",stdout);
    n=readin();m=readin();
    for(register int i=1;i<=n;i++)w[i]=readin();
    for(register int i=1;i<=n;i++)v[i]=readin();
    for(register int i=1;i<=n;i++){
        int temp=readin();
        if(temp) add_line(temp,i);
    }
    for(register int i=1;i<=n;i++){
        if(!dfn[i]) tarjan(i);
    }
    build();
    for(register int i=1;i<=cnt;i++){
        if(!in[i]) _add_line(cnt+1,i);
    }
    dpp(cnt+1);
    printf("%d\n",f[cnt+1][m]);
    return 0;
}

---

讲解：

注意到这里的$f$数组是二维的，$f[i][j]$表示给第i个点分派j的储存空间，所能得到的利润最大值，显然最终答案在$f[cnt+1][m]$中，其中cnt为scc的个数，cnt+1是新建了一个节点连向所有单的块

每次往下走，走到一个孩子节点就对孩子节点进行dp操作，现在如果已经处理完了所有孩子节点，回到了当前的节点，那么继续进行下一步背包的枚举操作，具体操作是枚举一个分配给当前节点u的空间j，再枚举一个分配给当前枚举的u的子点的空间k，注意到j是逆序的，而k是顺序的，这个意思就是说我在枚举当前的f[u][k]的时候，其实是上一次的计算，这样一来可以保证后面那个f[u][k]表示的之前的没有枚举到v的时候的最优结构，这一点是非常的巧妙的，然后我们可以发现，虽然这里这样枚举了，但是面临一个问题，就是u的花费和收益我们并没有计算，递归到底层的时候怎么办呢？难道直接回溯上来？肯定要再处理本身啊，因为之前的每一个f[u][any_num]都已经计算了不考虑u的花费和收益的时候的最优值了，那么f[u][any_num-size[u]]也是一个最优值，这个值加上u的收益即可，但是如果我给的空间连u自己都装不下，那么自然这个f值为0

---