基环树一统天下千秋万代

基环树，又称环套树，顾名思义，为树上多一条边，\(n\)个节点\(n\)条边。

\(First\)无论啥题，你基环树总得找环，不找环你玩啥呢……

我找到了三种方法找环，各有千秋，注释中有，就直接放上来了

//https://www.cnblogs.com/akura/p/10838613.html
#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int f=1,w=0;char x=0;
    while(x<'0'||x>'9') {if(x=='-') f=-1; x=getchar();}
    while(x!=EOF&&x>='0'&&x<='9') {w=(w<<3)+(w<<1)+(x^48);x=getchar();}
    return w*f;
}
const int N=200010;
int n,num_edge,Cnt,Top,Time;
int head[N<<2],Cir[N],Dag[N],boki[N],Vis[N];
struct Edge{int next,to,dis;} edge[N<<2];
inline void Add(int from,int to,int dis)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].dis=dis;
    edge[num_edge].to=to;
    head[from]=num_edge;
}
inline void Bfs_Find_Cir()//Bfs找环还是少用，它忽略了原本的树形结构，仅能找到环上的点（或者说环边不太好找）
{
    queue<int> q;
    for(int i=1;i<=n;i++) if(Dag[i]==1) q.push(i);
    while(!q.empty())
    {
        int x=q.front();q.pop();
        for(int i=head[x];i;i=edge[i].next)
        {
            Dag[edge[i].to]--;
            if(Dag[edge[i].to]==1) q.push(i);
        }
    }
    for(int i=1;i<=n;i++) if(Dag[i]==2) Cir[++Cnt]=i,boki[i]=1;
}
int Ink[N],Stk[N];
inline void Dfs_For_Cir_Stk(int pos,int fth)//这是用栈实现的Dfs，但是重点是弹出操作，避免将非环点放入(针对有向图)
{
    Vis[pos]=1,Stk[++Top]=pos;Ink[pos]=1;
    for(int i=head[pos];i;i=edge[i].next)
        if(edge[i].to!=fth)
            if(Vis[edge[i].to])
            {
                if(Ink[edge[i].to])
                {
                    for(int Now=Stk[Top];Now!=edge[i].to;Now=Stk[--Top])
                        Cir[++Cnt]=Now,Ink[Now]=0;
                    Cir[++Cnt]=edge[i].to;
                }
            }
            else Dfs_For_Cir_Stk(edge[i].to,pos);
    Ink[pos]=0,--Top;
}
int Dfn[N],fa[N];
inline void Dfs_For_Cir_Dfn(int pos,int fth)//这是用时间戳实现的Dfs（个人感觉这个更好一些，重点是用Dfn防止找两遍）
{
    Dfn[pos]=++Time;fa[pos]=fth;
    for(int i=head[pos];i;i=edge[i].next)
        if(edge[i].to!=fth)
            if(Dfn[edge[i].to])
            {
                if(Dfn[edge[i].to]>Dfn[pos])
                {
                    for(int Now=edge[i].to;Now!=pos;Now=fa[Now])
                        Cir[++Cnt]=Now;
                    Cir[++Cnt]=pos;
                }
            }
            else Dfs_For_Cir_Dfn(edge[i].to,pos);
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("A.in","r",stdin);
    //freopen("B.in","r",stdin);
#endif
    n=read();
    for(int i=1,u,v,d;i<=n;i++)
    {
        u=read(),v=read(),d=read();
        Add(u,v,d),Add(v,u,d);Dag[v]++,Dag[u]++;
    }
    Bfs_Find_Cir(); for(int i=1;i<=Cnt;i++) printf("%d",Cir[i]);
}

例题：\(IOI2008Island\)

思路很好想，找环，断环为链，单调队列维护最大值。

实现细节有点繁琐，还有一个双倍经验（\(IOI\)的是基环树森林，此题是基环树）

#include<bits/stdc++.h>
using namespace std;
#define int long long
inline int read()
{
    int f=1,w=0;char x=0;
    while(x<'0'||x>'9') {if(x=='-') f=-1; x=getchar();}
    while(x!=EOF&&x>='0'&&x<='9') {w=(w<<3)+(w<<1)+(x^48);x=getchar();}
    return w*f;
}
const int N=1000010;
int Max1,Max2,Cnt;
int num_edge,n,Tim,ans;
pair<int,int> Cir[N<<1];
int head[N<<1],Dep[N],Used[N];
int Vis[N],Id[N],fa[N],Dfn[N],Sum[N<<1];
struct Edge{int next,to,dis;} edge[N<<1];
inline int C(int i) {return Cir[i].first;}
inline void Add(int from,int to,int dis)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].dis=dis;
    edge[num_edge].to=to;
    head[from]=num_edge;
}
inline void Dfs_For_Cir_Dfn(int pos,int fth,int lid)
{
    Dfn[pos]=++Tim,fa[pos]=fth,Id[pos]=lid;
    for(int i=head[pos];i&&!Cnt;i=edge[i].next)
        if(edge[i].to!=fth)
        {
            if(Dfn[edge[i].to])
            {
                if(Dfn[edge[i].to]>Dfn[pos])
                {
                    for(int Now=edge[i].to;Now!=pos;Now=fa[Now])
                        Cir[++Cnt]=make_pair(Now,edge[Id[Now]].dis),Vis[Now]=1;
                    Cir[++Cnt]=make_pair(pos,edge[i].dis),Vis[pos]=1;return ;
                }
            }
            else Dfs_For_Cir_Dfn(edge[i].to,pos,i);
        }
}
inline void Dfs_For_Dep(int pos,int fth)
{
    Used[pos]=1;
    for(int i=head[pos];i;i=edge[i].next)
        if(edge[i].to!=fth&&!Vis[edge[i].to])
        {
            Dfs_For_Dep(edge[i].to,pos);
            Max1=max(Max1,Dep[pos]+Dep[edge[i].to]+edge[i].dis);
            Dep[pos]=max(Dep[pos],Dep[edge[i].to]+edge[i].dis);
        }
}
main(){
#ifndef ONLINE_JUDGE
    freopen("A.in","r",stdin);
#endif
    n=read();
    for(int i=1,x,d;i<=n;i++)
        x=read(),d=read(),Add(i,x,d),Add(x,i,d);
    for(int i=1;i<=n;i++)
        if(!Used[i])
        {
            deque<int> q;Max1=Max2=0;
            Cnt=0;Dfs_For_Cir_Dfn(i,0,0);
            for(int j=1;j<=Cnt;j++) Dfs_For_Dep(Cir[j].first,0),Cir[j+Cnt]=Cir[j];
            /*有点奇怪的前缀和*/
            for(int j=1;j<=(Cnt<<1);j++) Sum[j]=Sum[j-1]+Cir[j-1].second;
            /*单调队列出一定要注意在队中的到底是什么*/
            for(int j=1;j<=(Cnt<<1);j++)
            {
                while(q.size()&&(j-q.front())>=Cnt) q.pop_front();
                if(q.size()) Max2=max(Max2,Dep[C(j)]+Dep[C(q.front())]+Sum[j]-Sum[q.front()]);
                while(q.size()&&Dep[C(q.back())]-Sum[q.back()]<=Dep[C(j)]-Sum[j]) q.pop_back();
                q.push_back(j);
            }
            ans+=max(Max1,Max2);
        }
    printf("%lld",ans);
}

例题：\(NOI2012\)迷失游乐园

换根\(DP+\)基环树，思路不难，要考虑的东西很多，因为我直接在环上跑编号，所以细节更多。。。

一篇很清晰的题解

#include<bits/stdc++.h>
using namespace std;
inline int read()
{
    int f=1,w=0;char x=0;
    while(x<'0'||x>'9') {if(x=='-') f=-1; x=getchar();}
    while(x!=EOF&&x>='0'&&x<='9') {w=(w<<3)+(w<<1)+(x^48);x=getchar();}
    return w*f;
}
const int N=100010,M=30;
pair<int,int> Cir[N];
int num_edge,n,m,Tim,Cnt;
int Id[N],Dfn[N],Nex[N],Tag[N];
double Up[N],Down[N],ans[N],Dis[M][M],Ans;
int head[N<<1],Son[N],Vis[N],fa[N];
struct Edge{int next,to,dis;} edge[N<<1];
inline void Add(int from,int to,int dis)
{
    edge[++num_edge].next=head[from];
    edge[num_edge].dis=dis;
    edge[num_edge].to=to;
    head[from]=num_edge;
}
inline void Dfs_For_Tree_Down(int pos,int fth)
{
    for(int i=head[pos];i;i=edge[i].next)
        if(edge[i].to!=fth&&!Vis[edge[i].to])
            Dfs_For_Tree_Down(edge[i].to,pos),Son[pos]++;
    for(int i=head[pos];i;i=edge[i].next)
        if(edge[i].to!=fth&&!Vis[edge[i].to])
            Down[pos]+=Down[edge[i].to]+edge[i].dis*1.0;
    if(Son[pos]) Down[pos]=Down[pos]/(Son[pos]*1.0);
}
inline void Dfs_For_Tree_Up(int pos,int fth,double dis)
{
    if(m==n-1)
    {
        if(Son[fth]&&fth!=1)
            Up[pos]=(Up[fth]+Down[fth]*Son[fth]-Down[pos]-dis)/Son[fth]+dis;
        else if(fth==1&&Son[fth]>1)
            Up[pos]=(Up[fth]+Down[fth]*Son[fth]-Down[pos]-dis)/(Son[fth]-1)+dis;
        else if(fth==1&&Son[fth]==1) Up[pos]=dis;
        if(pos!=1) ans[pos]=(Down[pos]*Son[pos]+Up[pos])/(Son[pos]+1);
        else ans[pos]=Down[pos];
    }
    else
    {
        if(Son[fth]&&!Vis[fth])
            Up[pos]=(Up[fth]+Down[fth]*Son[fth]-Down[pos]-dis)/Son[fth]+dis;
        else if(Vis[fth])
            Up[pos]=(Up[fth]*2+Down[fth]*Son[fth]-Down[pos]-dis)/(Son[fth]+1)+dis;
        ans[pos]=(Up[pos]+Down[pos]*Son[pos])/(1+Son[pos]);
    }
    for(int i=head[pos];i;i=edge[i].next)
        if(edge[i].to!=fth&&!Vis[edge[i].to])
           Dfs_For_Tree_Up(edge[i].to,pos,edge[i].dis*1.0);
}
inline void Find_Dia(int pos,int fth,int lid)
{
    Dfn[pos]=++Tim;fa[pos]=fth,Id[pos]=lid;
    for(int i=head[pos];i&&!Cnt;i=edge[i].next)
        if(edge[i].to!=fth)
        {
            if(Dfn[edge[i].to])
            {
                if(Dfn[edge[i].to]>Dfn[pos])
                {
                    for(int Now=edge[i].to;Now!=pos;Now=fa[Now])
                    {
                        Cir[++Cnt]=make_pair(Now,edge[Id[Now]].dis);
                        Vis[Now]=1,Tag[Now]=Cnt;
                    }
                    Cir[++Cnt]=make_pair(pos,edge[i].dis);
                    Vis[pos]=1,Tag[pos]=Cnt;
                }
            }else Find_Dia(edge[i].to,pos,i);
        }
}
inline void Work(int Root)
{
    Find_Dia(Root,0,0);
    for(int i=1;i<=Cnt;i++) Dfs_For_Tree_Down(Cir[i].first,0);
    for(int i=1;i<=Cnt;i++)
    {
        if(i!=1) Dis[i-1][i]=Dis[i][i-1]=Cir[i-1].second*1.0;
        if(i!=Cnt) Dis[i][i+1]=Dis[i+1][i]=Cir[i].second*1.0;
    }
    Dis[1][Cnt]=Dis[Cnt][1]=Cir[Cnt].second*1.0;
    for(int i=1;i<=Cnt;i++)
    {
        int Now=Cir[i].first;double P=1.0;
        for(int j=i+1;j!=i;j++)
        {
            if(j>Cnt) j-=Cnt;if(j==i) break;
            int Pos=Cir[j].first;int w=Dis[j][!(j-1)?Cnt:j-1];
            if(j==(!(i-1)?Cnt:i-1)) Up[Now]+=P*(w+Down[Pos]);
            else Up[Now]+=P*(w*1.0+Down[Pos]*Son[Pos]/(Son[Pos]+1)*1.0);
            P/=Son[Pos]+1;
        }
        P=1.0;
        for(int j=i-1;j!=i;j--)
        {
            if(j<=0) j+=Cnt;if(j==i) break;
            int Pos=Cir[j].first;int w=Dis[j][(j+1)>Cnt?1:j+1];
            if(j==((i+1)>Cnt?1:i+1)) Up[Now]+=P*(w+Down[Pos]);
            else Up[Now]+=P*(w*1.0+Down[Pos]*Son[Pos]/(Son[Pos]+1)*1.0);
            P/=Son[Pos]+1;
        }
        Up[Now]/=2;
    }
    for(int i=1;i<=Cnt;i++)
        for(int j=head[Cir[i].first];j;j=edge[j].next)
            if(!Vis[edge[j].to])
                Dfs_For_Tree_Up(edge[j].to,Cir[i].first,edge[j].dis);
    for(int i=1;i<=Cnt;i++)
    {
        int pos=Cir[i].first;
        ans[pos]=(Up[pos]*2+Down[pos]*Son[pos])/(2+Son[pos]);
    }
}
int main(){
#ifndef ONLINE_JUDGE
    freopen("A.in","r",stdin);
#endif
    n=read(),m=read();
    for(int i=1,u,v,d;i<=m;i++)
        u=read(),v=read(),d=read(),Add(u,v,d),Add(v,u,d);
    if(m==n) Work(1);
    else Dfs_For_Tree_Down(1,0),Dfs_For_Tree_Up(1,0,0);
    for(int i=1;i<=n;i++) Ans+=ans[i];printf("%.5lf",Ans/n*1.0);
}

这是个半成品，后面会补锅（也可能咕咕咕）

原文地址：https://www.cnblogs.com/wo-shi-zhen-de-cai/p/11623537.html

时间： 2024-10-09 15:20:57

基环树一统天下千秋万代的相关文章

[noi2013]快餐店 基环树dp，单调队列维护最大值和次大值

#include<iostream> #include<cstdio> #include<cstring> #include<algorithm> using namespace std; #define N 220000 #define inf 0x3ffffffffffffffLL typedef long long ll; int v[N],e[N],ne[N],nn,w[N]; void add(int x,int y,int z){ ne[++nn

【BZOJ1589】【USACO 2008 Dec Gold】 1.Trick or Treat on the Farm 基环树裸DP、

没测样例一遍A这真是-- 题意:每个点都有且仅有一个出边(可以出现自环),然后这样一个点出发就会走过且一定走过某些点. 问每个点出发都会走过几个点. 首先这是基环树无疑. 然后就是裸DP了. 这个的关键就是找环,仅此. #include <cstdio> #include <cstring> #include <iostream> #include <algorithm> #define N 101000 using namespace std; int n

[HDU 5304] 基环树计数

题意 给定一张 n 个点 m 条边的无向图, 问其有多少个生成基环树. n <= 16 , 无重边, 无自环. 分析 状压DP 处理每个状态对应的环的个数. 枚举所有状态, 缩点后重标号, 使用 Matrix 定理计算答案. 实现 枚举环: f[s][i] 表示从 s 状态中的最小值出发, 终点在 i 的方案数. 边界 f[2 ^ i][i] = 1 . 统计答案的时候, 对于 f[s][i] , 若 s 中的个数大于 2 , 且 i 能到达 s 状态中的最小值, 则 cnt[s] += f[s

【bzoj1040】[ZJOI2008]骑士 并查集+基环树dp

题目描述 Z国的骑士团是一个很有势力的组织,帮会中汇聚了来自各地的精英.他们劫富济贫,惩恶扬善,受到社会各界的赞扬.最近发生了一件可怕的事情,邪恶的Y国发动了一场针对Z国的侵略战争.战火绵延五百里,在和平环境中安逸了数百年的Z国又怎能抵挡的住Y国的军队.于是人们把所有的希望都寄托在了骑士团的身上,就像期待有一个真龙天子的降生,带领正义打败邪恶.骑士团是肯定具有打败邪恶势力的能力的,但是骑士们互相之间往往有一些矛盾.每个骑士都有且仅有一个自己最厌恶的骑士(当然不是他自己),他是绝对不会与自己最厌恶

【基环树/树形DP】BZOJ1040-[ZJOI2008]骑士

[题目大意] 有n个骑士,给出他们的能力值和最痛恨的一位骑士.选出一个骑士军团,使得军团内没有矛盾的两人(不存在一个骑士与他最痛恨的人一同被选入骑士军团的情况),并且,使得这支骑士军团最具有战斗力,求战斗力的最大值. [思路] 首先yy一下,可以知道这是一个基环森林.我们可以用以下方法: 首先在每一棵基环树的环上任意找到一条边(用dfs来实现),记它的两个端点为u和v.然后删掉这条边(我这里用的方法是记录u,v在对方容器中的位置,并在后续操作中忽略这条边).由于u和v不能同时取,在删掉u和v之间

BZOJ 2878 [Noi2012]迷失游乐园 树形期望DP+基环树

题意:链接 方法:树形期望DP+基环树 解析: 首先先看前50%的数据 是一棵树 那么我们可以搞树形DP 然后设几个正常的数组 sum[i]代表i走i的子节点的期望的和. down[i]代表从底下走到i的期望. size[i]代表i的儿子个数 up[i]代表从i往上走的期望 然后就可以推式子了 显而易见地可以推出来up的式子 然后有一些奇怪的关于根节点的特判,注意一下就OK了. 然后后50% 我们发现它是一个基环树? 那么首先可以乱搞出来环上的点,然后记录一下这个环上的点的连接方式,求一下相邻两

BZOJ 1040: [ZJOI2008]骑士（基环树dp）

http://www.lydsy.com/JudgeOnline/problem.php?id=1040 题意: 思路: 这是基环树,因为每个人只会有一个厌恶的人,所以每个节点只会有一个父亲节点,但是根节点也是有父亲节点的,所以在树中肯定是存在一个环的,只要删除该环中的任意一条边,那么就能将该图变成一颗树. 如果是树的话,那就很简单了,d[u][0/1] dp求解即可. 现在假设删除的边是e,两端的节点分别是u,v,首先对u为根的树作一次dp,最后取d[u][0](v取不取都无所谓),不能取d[

BZOJ1040:骑士(基环树DP)

Z国的骑士团是一个很有势力的组织,帮会中汇聚了来自各地的精英.他们劫富济贫,惩恶扬善,受到社会各界的赞扬.最近发生了一件可怕的事情,邪恶的Y国发动了一场针对Z国的侵略战争.战火绵延五百里,在和平环境中安逸了数百年的Z国又怎能抵挡的住Y国的军队.于是人们把所有的希望都寄托在了骑士团的身上,就像期待有一个真龙天子的降生,带领正义打败邪恶.骑士团是肯定具有打败邪恶势力的能力的,但是骑士们互相之间往往有一些矛盾.每个骑士都有且仅有一个自己最厌恶的骑士(当然不是他自己),他是绝对不会与自己最厌恶的人一同出

[bzoj3037/2068]创世纪[Poi2004]SZP_树形dp_并查集_基环树

创世纪 SZP bzoj-3037/2068 Poi-2004 题目大意:给你n个物品,每个物品可以且仅可以控制一个物品.问:选取一些物品,使得对于任意的一个被选取的物品来讲,都存在一个没有被选取的物品,而且选取的个数最大. 注释:$1\le n \le 10^6$. 想法:显然,和骑士类似的,是一个基环树森林.如果A物品可以控制B物品,那就有B物品向A物品连边.对于每一个基环树,如果这个基环树是树的话显然变成树形dp入门题,暴力树形dp即可.然后对于基环树来讲,我们依然记录环上两点,分别以这两