【[ZJOI2008]骑士】

这道题好暴力啊

发现自己刚学\(OI\)的时候对着这道题写了一个大搜索

发现已经看不懂了

果然我现在菜到连一年半前的我都不如了

这其实是一个基环树\(dp\)啦，基环树上的最大点独立集

其实很简单，我们都知道树上的最大点独立集是可以\(O(n)\)做出来的，而基环树和树之间唯一的一个差距就是基环树多了一条边，于是就会导致失去像树那样优美的结构，并不能简单\(dp\)了

我们必须让树回复到优美的状态，于是我们断开环上的一条边，让基环树变成一棵树之后再跑一遍树上的最大点独立集

但是原来断开的那条边所连接的两个点是不能同时被选择的，所以我们可以分别以这两个个点为根，跑两遍最大点独立集，强制另一个点不能被选择就好了

至于如何找到环上的两个点，我是用了最慢的\(tarjan\)找到了边双，也就是环，并查集和\(dfs\)能做到更优

还有两个坑点

1. 图可能不连通

2. 可能有两个人互相仇恨，于是基环树又变成了树，\(tarjan\)没有办法找到环，于是对于这种情况我们得直接跑树上的最大点独立集

代码

#include<iostream>
#include<cstring>
#include<cstdio>
#define LL long long
#define re register
#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))
#define maxn 1000005
#define inf 9999999999
struct E
{
	int v,nxt;
}e[maxn<<1];
int head[maxn],dfn[maxn],low[maxn];
LL dp[maxn][2];
int st[maxn],a[maxn];
int hate[maxn];
int num,n,m,top,mid,co,cnt;
bool F;
LL ans,tot;
int X,Y;
inline void add_edge(int x,int y)
{
	e[++num].v=y;
	e[num].nxt=head[x];
	head[x]=num;
}
inline int read()
{
    char c=getchar();
    int x=0;
    while(c<'0'||c>'9') c=getchar();
    while(c>='0'&&c<='9')
        x=(x<<3)+(x<<1)+c-48,c=getchar();
    return x;
}
void tarjan(int x,int fa)
{
	dp[x][0]=dp[x][1]=0;
	dfn[x]=low[x]=++cnt;
	st[++top]=x;
	for(re int i=head[x];i;i=e[i].nxt)
		if(!dfn[e[i].v]) tarjan(e[i].v,x),low[x]=min(low[x],low[e[i].v]);
			else if(fa!=e[i].v) low[x]=min(low[x],dfn[e[i].v]);
	if(low[x]==dfn[x])
	{
		int sz=0,pre;
		do
		{
			mid=st[top--];
			sz++;
			if(sz==2)
			{
				F=1;
				X=mid,Y=pre;
			}
			pre=mid;
		}while(x!=mid);
	}
}
void dfs(int r,int f,int fa)
{
	dp[r][1]=a[r];
	for(re int i=head[r];i;i=e[i].nxt)
	{
		if(e[i].v==fa) continue;
		if(X==r&&Y==e[i].v) continue;
		if(Y==r&&X==e[i].v) continue;
		dfs(e[i].v,f,r);
		dp[r][0]+=max(dp[e[i].v][0],dp[e[i].v][1]);
		dp[r][1]+=dp[e[i].v][0];
	}
	if(!f&&r==Y) dp[r][1]=-inf;
	if(f&&r==X) dp[r][1]=-inf;
}
void clear(int r,int fa)
{
	dp[r][0]=dp[r][1]=0;
	for(re int i=head[r];i;i=e[i].nxt)
	if(e[i].v!=fa)
	{
		if(X==r&&Y==e[i].v) continue;
		if(Y==r&&X==e[i].v) continue;
		clear(e[i].v,r);
	}
}
void DFS(int r,int fa)
{
	dp[r][1]=a[r];
	for(re int i=head[r];i;i=e[i].nxt)
	if(fa!=e[i].v)
	{
		DFS(e[i].v,r);
		dp[r][0]+=max(dp[e[i].v][1],dp[e[i].v][0]);
		dp[r][1]+=dp[e[i].v][0];
	}
}
int main()
{
	n=read();
	for(re int i=1;i<=n;i++)
	{
		a[i]=read();
		hate[i]=read();
		if(hate[hate[i]]==i) continue;
		else add_edge(hate[i],i),add_edge(i,hate[i]);
	}
	for(re int i=1;i<=n;i++)
	{
		ans=0;
		if(dfn[i]) continue;
		X=0,Y=0;
		tarjan(i,0);
		if(!X&&!Y)
		{
			DFS(i,0);
			tot+=max(dp[i][0],dp[i][1]);
			continue;
		}
		dfs(X,0,0);
		ans=max(dp[X][0],dp[X][1]);
		clear(X,0);
		dfs(Y,1,0);
		ans=max(max(ans,dp[Y][1]),dp[Y][0]);tot+=ans;
	}
	std::cout<<tot;
	return 0;
}