P2515 [HAOI2010] SCC 分解 + 树形 DP

题意

传送门 P2515 [HAOI2010]软件安装

题解

对于每个依赖，从 $D[i]$ 向 $i$ 连一条边，每个节点至多存在一条入边，则得到的
有向图实际上是一个外向树（基环树的一类）森林。分解强连通分量，缩点得到森林，添加超级源点，问题转化为有树形依赖的背包问题，树形 DP 即可。总时间复杂度 $O(n{m}^2)$。

#include <bits/stdc++.h>
using namespace std;
#define pb push_back
const int MAXN = 105, MAXM = 505;
int N, M, W[MAXN], V[MAXN];
vector<int> vs;
vector<int> G[MAXN], rG[MAXN], nG[MAXN];
int _w[MAXN], _v[MAXN];
int idx[MAXN], deg[MAXN], dp[MAXN][MAXM];
bool used[MAXN];

void dfs(int v)
{
    used[v] = 1;
    for (int u : G[v])
        if (!used[u])
            dfs(u);
    vs.pb(v);
}

void rdfs(int v, int k, int &_v, int &_w)
{
    used[v] = 1, idx[v] = k;
    _v += V[v], _w += W[v];
    for (int u : rG[v])
        if (!used[u])
            rdfs(u, k, _v, _w);
}

int find_scc()
{
    memset(used, 0, sizeof(used));
    vs.clear();
    for (int v = 0; v < N; ++v)
        if (!used[v])
            dfs(v);
    memset(used, 0, sizeof(used));
    int k = 0;
    for (int i = (int)vs.size() - 1; i >= 0; --i)
        if (!used[vs[i]])
        {
            rdfs(vs[i], k, _v[k], _w[k]);
            ++k;
        }
    return k;
}

void _max(int &x, int y) { x = max(x, y); }

void get(int v)
{
    dp[v][_w[v]] = _v[v];
    for (int u : nG[v])
        get(u);
    for (int u : nG[v])
    {
        for (int j = M; j >= 0; --j)
            for (int k = 0; j + k <= M; ++k)
                _max(dp[v][j + k], dp[v][j] + dp[u][k]);
    }
    dp[v][0] = 0;
}

int main()
{
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cin >> N >> M;
    for (int i = 0; i < N; ++i)
        cin >> W[i];
    for (int i = 0; i < N; ++i)
        cin >> V[i];
    for (int v = 0; v < N; ++v)
    {
        int p;
        cin >> p;
        --p;
        if (p != -1)
            G[p].pb(v), rG[v].pb(p);
    }
    int n = find_scc();
    for (int v = 0; v < N; ++v)
        for (int u : G[v])
            if (idx[v] != idx[u])
                nG[idx[v]].pb(idx[u]), ++deg[idx[u]];
    for (int v = 0; v < n; ++v)
        if (!deg[v])
            nG[n].pb(v);
    memset(dp, 0xc0, sizeof(dp));
    get(n);
    int res = 0xc0c0c0c0;
    for (int j = 0; j <= M; ++j)
        _max(res, dp[n][j]);
    cout << res << '\n';
    return 0;
}