【[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;
}

转载于:https://www.cnblogs.com/asuldb/p/10207874.html