[HAOI2010]软件安装

题目描述

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

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

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

输入输出格式

输入格式：

第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 ）

输出格式：

一个整数，代表最大价值

输入输出样例

输入样例#1：

3 10

5 5 6

2 3 4

0 1 1

输出样例#1：

被看错题和脑抽卡了一晚上......

就是个有依赖的树形背包，但是没看到间接依赖也不能对答案造成贡献，以为像是没有上司的舞会那样的dp。

先将原图缩点，要选的话至少要选一个强连通分量，否则不能对答案造成贡献，缩完点之后就是个DAG了，直接跑树形背包就完了。（我居然连树形背包的板子都不记得了）

#include<bits/stdc++.h>

using namespace std;

int read(){

    int x=0,w=1;char ch=getchar();

    while(ch>'9'||ch<'0'){if(ch=='-')w=-1;ch=getchar();}

    while(ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();

    return x*w;

}

const int N=110,M=510;

int n,m,cnt,top,visnum,num,ans;

int w[N],c[N],d[N],sumw[N],sumc[N],head[N];

int dfn[N],low[N],s[N],in[N],belong[N],du[N];

int dp[N][M];

struct node{

    int to,next;

}edge[2*N];

void add(int x,int y){

    cnt++;edge[cnt].to=y;edge[cnt].next=head[x];head[x]=cnt;

}

queue<int>q;

void tarjan(int k){

    dfn[k]=low[k]=++visnum;

    s[++top]=k;in[k]=1;

    for(int i=head[k];i;i=edge[i].next){

        int v=edge[i].to;

        if(!dfn[v]){

            tarjan(v);low[k]=min(low[k],low[v]);

        }

        else if(in[v])low[k]=min(low[k],dfn[v]);

    }

    if(dfn[k]==low[k]){

        num++;int v=0;

        while(v!=k){

            v=s[top--];in[v]=0;

            belong[v]=num;sumw[num]+=w[v];sumc[num]+=c[v];

        }

    }

}

void DP(int k){

    for(int i=head[k];i;i=edge[i].next){

        int v=edge[i].to;DP(v);

        for(int j=m;j>=0;j--)

            for(int l=j;l>=0;l--)

                dp[k][j]=max(dp[k][j],dp[k][j-l]+dp[v][l]);

    }

    for(int i=m;i>=0;i--)

        if(i>=sumw[k])

            dp[k][i]=dp[k][i-sumw[k]]+sumc[k];

        else dp[k][i]=0;

}

int main(){

    n=read();m=read();

    for(int i=1;i<=n;i++)w[i]=read();

    for(int i=1;i<=n;i++)c[i]=read();

    for(int i=1;i<=n;i++){

        d[i]=read();if(d[i])add(d[i],i);

    }

    for(int i=1;i<=n;i++)

        if(!dfn[i])tarjan(i);

    cnt=top=0;memset(head,0,sizeof(head));

    for(int i=1;i<=n;i++){

        if(!d[i]||belong[i]==belong[d[i]])continue;

        add(belong[d[i]],belong[i]);du[belong[i]]++;

    }

    for(int i=1;i<=num;i++)if(!du[i])add(0,i);

    DP(0);for(int i=0;i<=m;i++)ans=max(ans,max(dp[0][i],dp[0][i]));

    printf("%d",ans);return 0;

}