洛谷——P2515 [HAOI2010]软件安装

https://www.luogu.org/problem/show?pid=2515#sub

题目描述

现在我们的手头有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：

5

f[u][i]表示安装u占用i的内存能得到的最大价值

 #include <algorithm>
 #include <cstdio>

 using namespace std;

 const int N();
 const int M();
 int n,m,w[N],v[N],f[N][M];

 int hed[N],had[N],sumedge;
 struct Edge
 {
     int v,next;
     Edge(int v=,int next=):
         v(v),next(next){}
 }edge[M<<];
 void ins(int u,int v,int *head)
 {
     edge[++sumedge]=Edge(v,head[u]);
     head[u]=sumedge;
 }

 int tim,dfn[N],low[N];
 int Stack[N],instack[N],top;
 int sumcol,col[N],cval[N],cw[N];
 void DFS(int now)
 {
     dfn[now]=low[now]=++tim;
     Stack[++top]=now; instack[now]=;
     for(int i=hed[now];i;i=edge[i].next)
     {
         int v=edge[i].v;
         if(!dfn[v]) DFS(v),low[now]=min(low[now],low[v]);
         else if(instack[v]) low[now]=min(low[now],dfn[v]);
     }
     if(low[now]==dfn[now])
     {
         col[now]=++sumcol;
         cw[sumcol]+=w[now];
         cval[sumcol]+=v[now];
         for(;now!=Stack[top];top--)
         {
             col[Stack[top]]=sumcol;
             cw[sumcol]+=w[Stack[top]];
             cval[sumcol]+=v[Stack[top]];
             instack[Stack[top]]=;
         }
         instack[now]=;top--;
     }
 }

 int dad[N],root;
 void Get_tree()
 {
     for(int i=;i<=n;i++)
         for(int j=hed[i];j;j=edge[j].next)
         {
             if(col[i]==col[edge[j].v]) continue;
             dad[col[edge[j].v]]=col[i];
             ins(col[i],col[edge[j].v],had);
         }
 }
 void DP(int x)
 {
     for(int i=had[x];i;i=edge[i].next)
     {
         DP(edge[i].v);
         for(int j=m-cw[x];j>=;j--)
           for(int k=;k<=j;k++)
             f[x][j]=max(f[x][j],f[x][k]+f[edge[i].v][j-k]);
     }
     for(int i=m;i>=;i--)
     {
         if(i>=cw[x]) f[x][i]=f[x][i-cw[x]]+cval[x];
         else f[x][i]=;
     }
 }

 int main()
 {
 //    freopen("install.in","r",stdin);
 //    freopen("install.out","w",stdout);
     scanf("%d%d",&n,&m);
     for(int i=;i<=n;i++) scanf("%d",w+i);
     for(int i=;i<=n;i++) scanf("%d",v+i);
     for(int i=,x;i<=n;i++)
     {
         scanf("%d",&x);
         if(x) ins(x,i,hed);
     }
     for(int i=;i<=n;i++)
         if(!dfn[i]) DFS(i);
     Get_tree();
     for(int i=;i<=sumcol;i++)
         if(!dad[i])
         {
             dad[i]=;
             ins(sumcol+,i,had);
         }
     DP(sumcol+);
     printf("%d",f[sumcol+][m]);
     return ;
 }