[学习笔记] 圆方树

前言

( t NOI) 模拟考到了这东西，因为不会所以就来填坑啦。

好神奇的东西！我好喜欢！这位巨佬讲的很清楚哦。

圆方树的功能就是把我们不清楚的仙人掌问题转化成熟悉的树问题。

这篇文章是写给我自己看的，所以可能和给出的材料有很大的重合（我就是复读了一遍额）

构造

仙人掌的定义：每条边最多属于一个环的无向连通图。

构造原仙人掌的 (G) 的圆方树 (T_G)，定义原仙人掌在圆方树上的点为圆点

考虑对原仙人掌搞一遍 ( t Tarjan)，因为每个环都是一个点双联通分量，考虑点 (i) 连出去的一个点 (j)，如果 (dfn[i]=low[j]) 就说明 (i) 点是环的根，那么我们新建一个方点处理这个环。我们从栈中取出这个环的所有点，然后把方点连向所有环上所有点，注意我们让圆点 (i) 作为这个局部子树的根，那么就能构建出圆方树啦。

圆方树有以下优美的性质：

• 无论如何换根，圆方树形态不变（因为连成的是菊花）

• 圆方树的子树 (=) 原仙人掌的子仙人掌

• 方点不会和方点相连

补充一点我的理解：圆方树其实是方便了我们单独考虑每个环内部的最优解（因为仙人掌的特殊性），再通过树的结构合并这些最优解，更多的还是要看例题啊。

例一

题目描述

来源：( t bzojspace 2125) 最短路，点此看题

给一个 (n) 个点 (m) 条边的仙人掌，(q) 次询问两个点之间的最短路径。

(1leq n,qleq 10000)

解法

首先建出圆方树，但是圆方树上的距离不一定就等于仙人掌上最短路长度。

现在要确定圆方树上的边是什么样子的，如果是圆圆边（连接了两个圆点）那么直接就是原仙人掌上的边权即可，如果是方圆边那么边权设置为环的根到这个圆点的最短距离，如果是圆方边的话边权设置为 (0)

最短距离就考虑圆方树上的 ( t lca)，如果 ( t lca) 是圆点，那么圆方树上路径长度就是最短路长度，因为路过的每个环我们都取的是最短路。如果 ( t lca) 是方点，可以通过倍增找到 ((x,y)) 子树的方向设为 ((p_x,p_y))，那么 (x ightarrow p_x,y ightarrow p_y) 都是最短路径，所以只需要找到环上点 ((p_x,p_y)) 的最短路径就可以了，这个可以通过前缀和和环上总的边长算出来。

时间复杂度 (O(nlog n))，开打！如果没写过可以康康我怎么建圆方树的。

#include <cstdio>
#include <vector>
#include <iostream>
using namespace std;
const int M = 100005;
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,m,q,cnt,tot,f[M],dfn[M],low[M],sum[M];
int Ind,fa[M],res[M],p[M][20],dis[M],dep[M];
struct edge
{
	int v,c,next;
}e[2*M];vector<edge> g[M];
void work(int u,int v,int c)
{
	cnt++;
	int tmp=c,i=v;
	while(i!=fa[u])//一直跳父亲 
	{
		sum[i]=tmp;
		tmp+=res[i];
		i=fa[i];
	}
	sum[cnt]=sum[u];
	i=v;sum[u]=0;
	while(i!=fa[u])
	{
		//环上的最短路 
		int d=min(sum[i],sum[cnt]-sum[i]);
		g[i].push_back(edge{cnt,d,0});
		g[cnt].push_back(edge{i,d,0});
		i=fa[i];
	}
}
void tarjan(int u)
{
	dfn[u]=low[u]=++Ind;
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v,c=e[i].c;
		if(!dfn[v])
		{
			fa[v]=u;//存父亲 
			res[v]=c;//存父边权值 
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(v!=fa[u])
			low[u]=min(low[u],dfn[v]);
		if(low[v]>dfn[u])//如果圆圆点建新边
		{
			g[u].push_back(edge{v,c,0});
			g[v].push_back(edge{u,c,0});
		}
	}
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(fa[v]==u || dfn[v]<=dfn[u]) continue;
		//相当于是找环最底下的那点
		work(u,v,e[i].c); 
	}
}
void dfs(int u,int fa)
{
	p[u][0]=fa;
	dep[u]=dep[fa]+1;
	for(int i=1;i<20;i++)
		p[u][i]=p[p[u][i-1]][i-1];
	for(int i=0;i<g[u].size();i++)
	{
		int v=g[u][i].v,c=g[u][i].c;
		if(v==fa) continue;
		dis[v]=dis[u]+c;
		dfs(v,u);
	}
}
int lca(int u,int v)
{
	if(dep[u]<dep[v]) swap(u,v);
	for(int i=15;i>=0;i--)
		if(dep[p[u][i]]>=dep[v])
			u=p[u][i];
	if(u==v) return u;
	for(int i=15;i>=0;i--)
		if(p[u][i]!=p[v][i])
			u=p[u][i],v=p[v][i];
	return p[u][0];
}
int jump(int x,int y)//找y在x方向的儿子 
{
	for(int i=15;i>=0;i--)
		if(dep[p[x][i]]>dep[y])
			x=p[x][i];
	return x; 
}
int Abs(int x)
{
	return x>0?x:-x;
}
signed main()
{
	n=cnt=read();m=read();q=read();
	for(int i=1;i<=m;i++)
	{
		int u=read(),v=read(),c=read();
		e[++tot]=edge{v,c,f[u]},f[u]=tot;
		e[++tot]=edge{u,c,f[v]},f[v]=tot;
	}
	tarjan(1);
	dfs(1,0);
	for(int i=1;i<=q;i++)
	{
		int u=read(),v=read(),x=lca(u,v);
		int d=dis[u]+dis[v]-2*dis[x];
		if(x<=n)//lca是圆点
			printf("%d
",d);
		else//lca是方点 
		{
			int pu=jump(u,x),pv=jump(v,x);
			d=dis[u]-dis[pu]+dis[v]-dis[pv];
			int tmp=Abs(sum[pu]-sum[pv]);
			printf("%d
",d+min(tmp,sum[x]-tmp)); 
		}
	}
}

例二

题目描述

题目来源：( t BZOJspace 4316) 小 (C) 的独立集。

给定一个 (n) 个点 (m) 条边的仙人掌，问它的最大独立集。

(nleq 50000,mleq60000)

解法

还是先建出圆方树，设 (dp[u][0/1]) 表示点 (u) 不选(/)选的最大独立集个数，圆点就正常树形 (dp) 即可：

[dp[u][0]=sum max(dp[v][0],dp[v][1]) ]

[dp[u][1]=sum dp[v][0]+1 ]

考虑方点应该怎样转移？就考虑按照正常的树形 (dp) 他会对环的根造成什么样的影响，再根据造成的影响去确定方点 (dp) 状态代表的意义，关键还是设置方点的意义。

考虑方点 (x) 和环的根 (u)，(dp[x][0]) 显然会贡献到 (dp[u][1]) 去，而 (dp[u][1]) 代表的是选取 (u) 的状态，那么如果选了 (u) 这个环那么和 (u) 相邻的点都不能选，所以定义 (dp[x][0]) 为不选该环的两个端点并且不存在环上相邻的点的最大独立集。

(dp[x][1]) 会贡献到 (dp[u][0]) 去，那么环上的点可以任意选，所以定义 (dp[x][1]) 为不存在环上相邻的点的最大独立集，注意 (dp[x][0/1]) 都不需要考虑环的根。

不难发现 (dp[x][0/1]) 都可以一次线性 (dp) 求出，时间复杂度 (O(n))

#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
using namespace std;
const int M = 100005;
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,m,tot,Ind,cnt,f[M],low[M],dfn[M],fa[M];
vector<int> g[M];int dp[M][2],tmp[M][2];
struct edge
{
	int v,next;
}e[2*M];
void work(int u,int v)
{
	int i=v;++cnt;
	while(i!=u)
	{
		g[cnt].push_back(i);
		i=fa[i];
	}
	g[u].push_back(cnt);
}
void tarjan(int u)
{
	dfn[u]=low[u]=++Ind;
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(!dfn[v])
		{
			fa[v]=u;
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(v!=fa[u])
			low[u]=min(low[u],dfn[v]);
		if(low[v]>dfn[u])
			g[u].push_back(v);
	}
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(fa[v]==u || dfn[v]<=dfn[u]) continue;
		work(u,v); 
	}
}
void fuck(int u)//方点转移
{
	//处理dp[u][0],表示不能选和根直接相连的点
	int len=g[u].size(),v1=g[u][0];
	tmp[0][0]=dp[v1][0];tmp[0][1]=0;
	for(int i=1;i<len;i++)
	{
		int v=g[u][i];
		tmp[i][0]=max(tmp[i-1][0],tmp[i-1][1])+dp[v][0];
		tmp[i][1]=dp[v][1]+tmp[i-1][0];
	}
	dp[u][0]=tmp[len-1][0];
	//处理dp[u][1]表示不包括根的环最多独立点数
	tmp[0][0]=dp[v1][0];tmp[0][1]=dp[v1][1];
	for(int i=1;i<len;i++)
	{
		int v=g[u][i];
		tmp[i][0]=max(tmp[i-1][0],tmp[i-1][1])+dp[v][0];
		tmp[i][1]=dp[v][1]+tmp[i-1][0];
	}
	dp[u][1]=max(tmp[len-1][0],tmp[len-1][1]);
}
void dfs(int u)
{
	if(u<=n) dp[u][1]=1; 
	for(int i=0;i<g[u].size();i++)
	{
		int v=g[u][i];
		dfs(v);
		if(u<=n)//圆点转移 
		{
			dp[u][1]+=dp[v][0];
			dp[u][0]+=max(dp[v][0],dp[v][1]);
		}
	}
	if(u>n) fuck(u);
}
signed main()
{
	n=cnt=read();m=read();
	for(int i=1;i<=m;i++)
	{
		int u=read(),v=read();
		e[++tot]=edge{v,f[u]},f[u]=tot;
		e[++tot]=edge{u,f[v]},f[v]=tot;
	}
	tarjan(1);
	dfs(1);
	printf("%d
",max(dp[1][0],dp[1][1]));
}

例三

题目描述

点此看题

求一个仙人掌的直径（最远两点的距离）

(1leq nleq 50000,0leq mleq 10000)

解法

先建出圆方树，考虑树上的 (dp) 是定义 (dp[u]) 为 (u) 往下的最长链然后乱转移下就行了。

那么怎么套到圆方树上面去呢？这道题的边权可以像例一那样定义，就可以直接像树那样转移了。主要考虑下方点怎么贡献答案的，其实就是在环上找两点 (i<j) 最大化 (dp[i]+dp[j]+dis(i,j))，可以倍长数组来破环成链，对于每个点 (j) 找到 (iin[j-n/2,j)) 使得 (dp[i]-i) 最大即可，这就是一个单调队列问题，总时间复杂度 (O(n))

这里使用了简便写法，直接把 (dp) 放在建圆方树的时候做了。

#include <cstdio>
#include <iostream>
using namespace std;
const int M = 100005;
int read()
{
	int x=0,f=1;char c;
	while((c=getchar())<'0' || c>'9') {if(c=='-') f=-1;}
	while(c>='0' && c<='9') {x=(x<<3)+(x<<1)+(c^48);c=getchar();}
	return x*f;
}
int n,m,tot,Ind,ans,a[2*M],q[2*M];
int f[M],dfn[M],low[M],fa[M],dp[M];
struct edge
{
	int v,next;
}e[2*M];
void work(int u,int v)
{
	int k=0;a[++k]=u;
	for(int i=v;i!=u;i=fa[i])
		a[++k]=i;
	for(int i=1;i<=k;i++)
		a[k+i]=a[i];
	int l=1,r=0,len=k*2;
	for(int i=1;i<=len;i++)
	{
		while(l<=r && q[l]<i-k/2) l++;
		if(l<=r) ans=max(ans,dp[a[i]]+i+dp[a[q[l]]]-q[l]);
		while(l<=r && dp[a[q[r]]]-q[r]<dp[a[i]]-i) r--;
		q[++r]=i;
	}
	for(int i=2;i<=k;i++)
		dp[u]=max(dp[u],dp[a[i]]+min(i-1,k-i+1));
}
void tarjan(int u)
{
	dfn[u]=low[u]=++Ind;
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(!dfn[v])
		{
			fa[v]=u;
			tarjan(v);
			low[u]=min(low[u],low[v]);
		}
		else if(v!=fa[u])
			low[u]=min(low[u],dfn[v]);
		if(dfn[u]<low[v])
		{
			ans=max(ans,dp[u]+dp[v]+1);
			dp[u]=max(dp[u],dp[v]+1);
		}
	}
	for(int i=f[u];i;i=e[i].next)
	{
		int v=e[i].v;
		if(u==fa[v] || dfn[v]<=dfn[u]) continue;
		work(u,v);
	}
}
signed main()
{
	n=read();m=read();
	for(int i=1;i<=m;i++)
	{
		int k=read(),u=read();
		for(int j=2;j<=k;j++)
		{
			int v=read();
			e[++tot]=edge{u,f[v]},f[v]=tot;
			e[++tot]=edge{v,f[u]},f[u]=tot;
			u=v;
		}
	}
	tarjan(1);
	printf("%d
",ans);
}