骑士

题目：骑士

我们让每个骑士与其厌恶的骑士连一条边，就得到了一个图。这时我们会发现，对于图中的每个联通块，设其节点数为k，则它的边数一定≤k（可能会有重边，所以边数可能不到k），这就意味着每个联通块不是一棵树就是一棵树上任意连一条边。

对于每个联通块

①如果它是一棵树，我们考虑树形dp

dp[i][j]表示以i为根的子树中，i计不计入答案（计入⇒j=1，不计入⇒j=0）的最大战斗力，那么转移方程为 dp[i][0]=∑j∈sonimax{dpj,0,dpj,1}
dp[i][1]=fight[i]+∑j∈sonidp[j][0]
答案为max{dproot,0,dproot,1}
②如果它是一棵树加一条边，我们可以先找到联通块上的唯一的环，任意删去其中的一条边u,v，就得到了一棵树，鉴于u,v间本应有边，所以我们考虑不取u或不取v，最后取max就能知道联通块的答案，即分别以u,v为根做一遍dp，最后最大战斗力为max{dpu,0,dpv,0}

最终答案即为每个联通块的答案之和。（ 注意输入时去掉重边）

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>
#include<map>
using namespace std;
vector<int>G[1000010];
int f[1000010];
bool vis[1000010];
int hte[1000010];
long long dp[1000010][2];
int n;
int u,v;
int dep[1000010];
long long ans;
void dfs(int x,int p)
{
    vis[x]=true;
    for(int i=0;i<G[x].size();i++)
    {
        int y=G[x][i];
        if(y==p)continue;
        if(vis[y])
        {
            if(dep[y]<dep[x])u=x,v=y;
            continue;
        }
        dep[y]=dep[x]+1;
        dfs(y,x);
    }
}
void solve(int x,int p)
{
    dp[x][1]=f[x];
    dp[x][0]=0;
    for(int i=0;i<G[x].size();i++)
    {
        int y=G[x][i];
        if((x==u && y==v) || (x==v && y==u) || y==p)continue;
        solve(y,x);
        dp[x][0]+=max(dp[y][0],dp[y][1]);
        dp[x][1]+=dp[y][0];
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        int x;
        scanf("%d%d",f+i,hte+i);
        if(hte[hte[i]]==i)continue;
        G[hte[i]].push_back(i);
        G[i].push_back(hte[i]);
    }
    for(int i=1;i<=n;i++)
    {
        if(vis[i])continue;
        u=v=0;
        dfs(i,0);
        long long res;
        if(!u && !v)
        {
            solve(i,0);
            res=max(dp[i][0],dp[i][1]); 
        }
        else
        {
            solve(u,0);
            res=dp[u][0];
            solve(v,0);
            res=max(res,dp[v][0]);
        }
        ans+=res;
    }
    printf("%lld",ans);
    return 0;
}