[ZJOI 2008] 骑士

[题目链接]

https://www.lydsy.com/JudgeOnline/problem.php?id=1040

[算法]

首先 ， 题目中互相讨厌的关系构成了一棵基环森林

用拓扑排序找出环 ， 对于每个环上的点为根节点 ， 做以下DP :

f[u][0]表示以u为根的子树中 ， 不选u ， 最大战斗力是多少 ， f[u][1]表示选u , 最大战斗力是多少

显然 :

f[u][0] = sigma{max{f[v][0] , f[v][1]})

f[u][1] = a[u] + sigma{f[v][0]}

然后在环上再次DP即可

时间复杂度 : O(N)

[代码]

#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000010
typedef long long LL;
const LL inf = 1e18;

struct edge
{
        int to , nxt;
} e[MAXN << ];

int n , tot , cnt;
int head[MAXN] , deg[MAXN] , a[MAXN] , c[MAXN];
LL f[MAXN][] , dp[MAXN][];
bool vis[MAXN];
LL ans , res;

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }
template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }
template <typename T> inline void read(T &x)
{
    T f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}
inline void addedge(int u , int v)
{
        ++tot;
        e[tot] = (edge){v , head[u]};
        head[u] = tot;
}
inline void topsort()
{
        queue< int > q;
        for (int i = ; i <= n; i++)
        {
                if (deg[i] == )
                        q.push(i);
        }
        while (!q.empty())
        {
                int cur = q.front();
                q.pop();
                for (int i = head[cur]; i; i = e[i].nxt)
                {
                        int v = e[i].to;
                        if ((--deg[v]) == )
                                q.push(v);
                }
        }
}
inline void treedp(int u , int fa)
{
        f[u][] = ;
        f[u][] = a[u];
        for (int i = head[u]; i; i = e[i].nxt)
        {
                int v = e[i].to;
                if (v == fa || vis[v]) continue;
                treedp(v , u);
                f[u][] += max(f[v][] , f[v][]);
                f[u][] += f[v][];
        }
}
inline void dfs(int u)
{
        c[++cnt] = u;
        vis[u] = true;
        for (int i = head[u]; i; i = e[i].nxt)
        {
                int v = e[i].to;
                if (!vis[v] && deg[v] > ) dfs(v);
        }
} 

int main()
{

        read(n);
        for (int i = ; i <= n; i++)
        {
                read(a[i]);
                int fa;
                read(fa);
                addedge(i , fa);
                addedge(fa , i);
                ++deg[i]; ++deg[fa];
        }
        topsort();
        for (int u = ; u <= n; u++)
        {
                if (!vis[u] && deg[u] > )
                {
                        cnt = ;
                        dfs(u);
                } else continue;
                for (int i = ; i <= cnt; i++) treedp(c[i] , -);
                ans = max(f[c[]][] , f[c[]][]);
                for (int i = ; i <= cnt; i++) dp[i][] = dp[i][] = -inf;
                dp[][] = f[c[]][];
                for (int i = ; i <= cnt; i++)
                {
                        dp[i][] = dp[i - ][] + f[c[i]][];
                        dp[i][] = max(dp[i - ][] , dp[i - ][]) + f[c[i]][];
                }
                chkmax(ans , max(dp[cnt][] , dp[cnt][]));
                for (int i = ; i <= cnt; i++) dp[i][] = dp[i][] = -inf;
                dp[][] = f[c[]][];
                for (int i = ; i < cnt; i++)
                {
                        dp[i][] = dp[i - ][] + f[c[i]][];
                        dp[i][] = max(dp[i - ][] , dp[i - ][]) + f[c[i]][];
                }
                chkmax(ans , max(dp[cnt - ][] , dp[cnt - ][]) + f[c[cnt]][]);
                res += ans;
        }
        printf("%lld\n" , res);

        return ;

}