洛谷——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(119);
const int M(555);
int n,m,w[N],v[N],f[N][M];

int hed[N],had[N],sumedge;
struct Edge
{
    int v,next;
    Edge(int v=0,int next=0):
        v(v),next(next){}
}edge[M<<1];
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]=1;
    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]]=0;
        }
        instack[now]=0;top--;
    }
}

int dad[N],root;
void Get_tree()
{
    for(int i=1;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>=0;j--)
          for(int k=0;k<=j;k++)
            f[x][j]=max(f[x][j],f[x][k]+f[edge[i].v][j-k]);
    }
    for(int i=m;i>=0;i--)
    {
        if(i>=cw[x]) f[x][i]=f[x][i-cw[x]]+cval[x];
        else f[x][i]=0;
    }
}

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