HAOI2010：软件安装（强连通 + 树形dp）

题目描述

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

思路：容易忽略的情况就是，即使出现环也可以整个环都安装。然后原图如果出现环，这个环必然作为“起点”，且这个环不会延申到其他环里。同样地环要么全部装要么全部不装，于是先强连通缩点加个超级源点重建图，然后进行树形dp，dp[i][j]表示i点开始共j容量得到的最大价值，比较老套的转移了dp[i][j] = max(dp[i][j], dp[j][k] + dp[i][j-k])，i倒着遍历。

# include <bits/stdc++.h>
using namespace std;
const int N = 103;
int v[N], w[N], d[N], V[N], W[N], dp[N][503];
int dep[N], low[N], in[N], stk, cnt, tot, n, m;
int belong[N], st[N*2], in_st[N], G[N][N];
vector<int>g[N], g2[N];
void dfs(int u)
{
    dep[u] = low[u] = ++cnt;
    st[++stk] = u;
    in_st[u] = 1;
    for(int v:g[u])
    {
        if(!dep[v])
        {
            dfs(v);
            low[u] = min(low[u], low[v]);
        }
        else if(in_st[v] && dep[v] < low[u])
            low[u] = dep[v];
    }
    if(low[u] == dep[u])
    {
        ++tot;
        int j;
        do
        {
            j = st[stk--];
            belong[j] = tot;
            in_st[j] = 0;
        }while(j != u);
    }
}
void dfs2(int cur)
{
    for(int i=W[cur]; i<=m; ++i) dp[cur][i] = V[cur];
    for(int to:g2[cur])
    {
        dfs2(to);
        for(int i=m; i>=W[cur]; --i)
            for(int j=0; j+W[cur]<=i; ++j)
                dp[cur][i] = max(dp[cur][i], dp[to][j] + dp[cur][i-j]);
    }
}
int main()
{
    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; i<=n; ++i)
    {
        scanf("%d",&d[i]);
        if(d[i]) g[d[i]].push_back(i);
    }
    for(int i=1; i<=n; ++i)
    {
        if(!dep[i]) dfs(i);
        W[belong[i]] += w[i];
        V[belong[i]] += v[i];
    }
    for(int i=1; i<=n; ++i)
        for(int j:g[i])
            if(belong[i] != belong[j])
                G[belong[i]][belong[j]] = 1, ++in[belong[j]];
    for(int i=1; i<=tot; ++i)
        for(int j=1; j<=tot; ++j)
            if(G[i][j]) g2[i].push_back(j);
    for(int i=1; i<=tot; ++i)
        if(!in[i]) g2[0].push_back(i);
    dfs2(0);
    printf("%d\n",dp[0][m]);
    return 0;
}