基环树学习记录

挂个dalao的blog：基环树瞎吹 - QuantAsk的博客 - 洛谷博客

以下均为学习记录：

对于无向图可以通过topsort完成找环，结束拓扑之后入度>=2就是环上的点

(手写队列快一点，l开r闭，l等于r表示队列为空,这里的top需要注意的是，因为已知这个拓扑是对有环树用的，所以写法和树不同。这里只有当入度大于1才进行减操作，因为这个队列维护的都是当前状态下入度为1的顶点集，如果当前点（now）所连接的点y 的入度小于等于1，说明y已在队列中或者是已经通过了top排序在队列外，无论哪种情况y点都不应入队。因此加一判断条件if（in【y】>1） 

void topsort(){
    int l=0,r=0;
    for (int i=1;i<=n;i++) 
      if(in[i]==1) q[++r]=i;
    while(l<r) {
        int now=q[++l];
        for (int i=ls[now];i;i=a[i].next){
            int y=a[i].to;
            if(in[y]>1){
                in[y]--;
                if(in[y]==1) q[++r]=y;
            }
        }
    }
}

2018 TG day2 T1

这是使用上述方法的题

题目大意

一棵树(可能是基环树)，从1出发，每到达一个新的点就记录下编号。求一种走法使得记录下来的编号字典序最小。

---

解题思路

这道题有可能是个基环树 我们先不考虑基环树。我们可以发现每次走字典序小的点就好了。我们可以排序一下就可以做到这点。

之后我们考虑基环树，我们暴力删边将基环树变为一棵普通的树。然后计算答案。

非常重要的代码：

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>
#define N 5010
using namespace std;
struct node{
    int to,next;
}a[2*N];
struct line{
    int x,y;
}l[2*N];
int tot,n,m,t,ls[N],in[N],state[N],w[N],ans[N],x,y,q[N];
bool k[N][N],v[N];
void addl(int x,int y)//加边
{
    a[++tot].to=y;
    a[tot].next=ls[x];
    ls[x]=tot;
    in[y]++;
}
bool topsort(){
    int l=0,r=0;
    for (int i=1;i<=n;i++) 
      if(in[i]==1) q[++r]=i;
    while(l<r) {
        int now=q[++l];
        for (int i=ls[now];i;i=a[i].next){
            int y=a[i].to;
            if(in[y]>1){
                in[y]--;
                if(in[y]==1) q[++r]=y;
            }
        }
    }
    if(r==n) return true;
    return false;
}//拓扑求环
bool cmp(line x,line y)
{return x.y>y.y;}
void dfs(int x)//走一遍
{
    state[++t]=x;
    v[x]=true;
    for(int i=ls[x];i;i=a[i].next)
    {
        int y=a[i].to;
        if(k[x][y]||v[y]) continue;
        dfs(y);
    }
}
void check()//判断是否为更小字典序
{
    int i;
    bool flag=false;
    for(i=1;i<=n;i++)
      if(state[i]<ans[i])
      {flag=true;break;}
      else if(state[i]>ans[i]) return;
    if(!flag) return;
    for(;i<=n;i++)
      ans[i]=state[i];
}
void get_ans(int xs)//暴力删边
{
    int x=xs,b=0,i,last=0;
    do
    {
        w[++b]=x;
        in[x]=1;
        for(i=ls[x];i;i=a[i].next)
        {
            int y=a[i].to;
            if(in[y]>1)
            {x=y;break;}
        }
    }while(i);//记录环的每个点
    w[++b]=xs;
    for(int i=1;i<b;i++)//枚举删除的边
    {
        k[w[i]][w[i+1]]=k[w[i+1]][w[i]]=true;
        memset(v,0,sizeof(v));
        t=0;
        dfs(1);
        check();
        k[w[i]][w[i+1]]=k[w[i+1]][w[i]]=false;
    }
}
int main()
{
    memset(ans,127/3,sizeof(ans));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        l[i]=(line){x,y};
        l[i+m]=(line){y,x};
    }
    sort(l+1,l+1+2*m,cmp);//排序
    tot=1;
    for(int i=1;i<=2*m;i++)//加边
    {addl(l[i].x,l[i].y);}
    if(m==n-1)//普通的树
    {
        dfs(1);
        for(int i=1;i<=n;i++)
            printf("%d ",state[i]);
        return 0;
    }
    topsort();
    for(int i=1;i<=n;i++)
      if(in[i]>1)
      {
          get_ans(i);
          break;
      }
    for(int i=1;i<=n;i++)
      printf("%d ",ans[i]);
}

然后按照神犇的第二种有向图的想法做出了这个基环树DP：

P2607 [ZJOI2008] 骑士

[ZJOI2008] 骑士 - 洛谷

题目描述

Z 国的骑士团是一个很有势力的组织，帮会中汇聚了来自各地的精英。他们劫富济贫，惩恶扬善，受到社会各界的赞扬。

最近发生了一件可怕的事情，邪恶的 Y 国发动了一场针对 Z 国的侵略战争。战火绵延五百里，在和平环境中安逸了数百年的 Z 国又怎能抵挡的住 Y 国的军队。于是人们把所有的希望都寄托在了骑士团的身上，就像期待有一个真龙天子的降生，带领正义打败邪恶。

骑士团是肯定具有打败邪恶势力的能力的，但是骑士们互相之间往往有一些矛盾。每个骑士都有且仅有一个自己最厌恶的骑士（当然不是他自己），他是绝对不会与自己最厌恶的人一同出征的。

战火绵延，人民生灵涂炭，组织起一个骑士军团加入战斗刻不容缓！国王交给了你一个艰巨的任务，从所有的骑士中选出一个骑士军团，使得军团内没有矛盾的两人（不存在一个骑士与他最痛恨的人一同被选入骑士军团的情况），并且，使得这支骑士军团最具有战斗力。

为了描述战斗力，我们将骑士按照 1 至 n 编号，给每名骑士一个战斗力的估计，一个军团的战斗力为所有骑士的战斗力总和。

输入格式

第一行包含一个整数 nn，描述骑士团的人数。

接下来 nn 行，每行两个整数，按顺序描述每一名骑士的战斗力和他最痛恨的骑士。

输出格式

应输出一行，包含一个整数，表示你所选出的骑士军团的战斗力。

输入输出样例

输入 #1复制

3
10 2
20 3
30 1

输出 #1复制

30

#include<cstdio>
#include<iostream>
#include<cstring>
using namespace std;
typedef long long ll;
const int N=1e6+5;
int n;
ll w[N];
struct node{
    int to;
    int nxt;
}edge[N];
int cnt;
int head[N];
ll fa[N];
ll ans;
int mark;
bool used[N];
void add(int from,int to)
{
    edge[cnt].to=to;
    edge[cnt].nxt=head[from];
    head[from]=cnt++;
}
ll dp[N][2];
ll inf=0x3f3f3f3f;
void check(int v)
{
    used[v]= true;
    if(used[fa[v]]){
        mark=v;
        return ;
    }
    else check(fa[v]);
}
void dfs(int v)
{
    dp[v][1]=w[v];
    dp[v][0]=0;
    used[v]= true;
    for(int i=head[v];~i;i=edge[i].nxt)
    {
        int now=edge[i].to;
        if(now!=mark)
        {
            dfs(now);
            dp[v][0]+=max(dp[now][1],dp[now][0]);
            dp[v][1]+=dp[now][0];
        }
        else dp[v][1]=-inf;
    }
}
int main()
{
    memset(head,-1,sizeof(head));
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld%lld",&w[i],&fa[i]);
        add(fa[i],i);
    }
    ll maxm=0;
    for(int i=1;i<=n;i++)
    {
        if(!used[i])
        {
            check(i);
            dfs(mark);
            maxm=max(dp[mark][1],dp[mark][0]);
            mark=fa[mark];
            dfs(mark);
            maxm=max(maxm,max(dp[mark][1],dp[mark][0]));
            ans+=maxm;
        }
    }
    printf("%lld",ans);
    return 0;
}