基环树和笛卡尔树
基环树
就是比平常的树多一条边，有 \(n\) 条边，也就有一个环在里面。
基本思想就是断环，跑树形 \(dp\)，或者用拓扑排序判环去跑环形 \(dp\)。
树的直径
今天才了解到的，用两遍 \(dfs\) 跑。
首先第一遍找到离根节点最远的节点 \(u_1\)，
然后再从 \(u_1\) 找到离它最远的节点 \(u_2\)，那么树链 \((u_1,u_2)\) 就是树的直径。
在后面很有用。
#3437. [ZJOI2008]骑士
类似于树形 dp 的思路（没有上司的舞会）。
考虑状态转移方程：
\[dp[u][1]=\sum dp[v][0]+a[u]
\]
\[dp[u][0]=\sum \max(dp[v][0],dp[v][1])
\]
其中 \(v\) 表示 \(u\) 的子节点。
然后基环树的思路是先找环，找到环的根之后跑树形 dp。
void dfs(int u)
{
vis[u]=1;
dp[u][0]=0,dp[u][1]=a[u];
for(int i=head[u];i;i=edge[i].next)
{
int v=edge[i].to;
if(v!=root)
{
dfs(v);
dp[u][0]+=max(dp[v][0],dp[v][1]);
dp[u][1]+=dp[v][0];
}
else dp[v][1]=-1145141919;
}
}
void find(int x)
{
vis[x]=1;
root=x;
while(!vis[fa[root]])
{
root=fa[root];
vis[root]=1;
}
dfs(root);
int tmp=max(dp[root][0],dp[root][1]);
vis[root]=1;
root=fa[root];
dfs(root);
ans+=max(tmp,max(dp[root][1],dp[root][0]));
}
#P1203. 「NOIP2018」旅行
P3533 [POI2012] RAN-Rendezvous
妈呀，打了一下午成小孩了。
调了一万次甚至动用科技，最后发现树剖炸了、
题目给出一个基环内向树森林，我们首先预处理出每个点所属环上的根节点 \(cir\) 是谁，再对分别对每棵树进行树剖。
然后通过 \(dfs\) 计算每个环的编号 \(id\) 和长度 \(len\)。
考虑两个点的状态进行分类讨论：
- 两点位于不同的基环树中
通过找环的时候给每个环进行编号，查询两点在环上根节点所属环是否一样进行判断；
- 两点位于同一基环树的同一子树中
意思是两点的 \(cir\) 相同，我们可以直接查询 \(lca(a,b)\) 作为答案；
- 两点位于同一基环树不同子树中
比较两个 \(cir\) 作为相遇点，哪个更符合要求即可。
#include<bits/stdc++.h>
using namespace std;
inline int read()
{
register int s=0,w=1;
register char c=getchar();
while(c<'0'||c>'9') c=getchar();
while(c>='0'&&c<='9')
{
s=(s<<1)+(s<<3)+(c^48);c=getchar();
}return s;
}
int n,m;
const int N=5e5+1;
vector<int>e[N],uu[N];
int indeg[N];
int q[N*2],tt;
int cir[N];
struct HPD{
int siz[N],dep[N],son[N],fa[N];
int id[N],tim=0,top[N];
void dfs1(int u,int fat)
{
siz[u]=1,fa[u]=fat;
if(!indeg[u]) dep[u]=dep[fat]+1;
cir[u]=cir[fat];
for(int v:uu[u])
{
if(v==fat||indeg[v]) continue;
dfs1(v,u);
siz[u]+=siz[v];
if(siz[v]>siz[son[u]]) son[u]=v;
}
}
void dfs2(int u,int t)
{
top[u]=t;
if(son[u]) dfs2(son[u],t);
for(int v:uu[u])
{
if(v==fa[u]||indeg[v]||v==son[u]) continue;
dfs2(v,v);
}
}
int lca(int u,int v)
{
while(top[u]!=top[v])
{
if(dep[top[u]]>=dep[top[v]]) u=fa[top[u]];
else v=fa[top[v]];
}
return dep[u]<dep[v]?u:v;
}
}hpd;
bool vis[N];
int len[N],pos[N];
int id[N],cur;
void dfs(int u,int le)
{
len[u]=le,vis[u]=1,pos[u]=le;
for(int v:e[u])
{
if(vis[v]||!indeg[v]) continue;
id[v]=id[u];
dfs(v,le+1);
len[u]=len[v];
}
}
inline bool cmp(int x1,int y,int x2,int y2)
{
if(max(x1,y)!=max(x2,y2)) return max(x1,y)<max(x2,y2);
if(min(x1,y)!=min(x2,y2)) return min(x1,y)<min(x2,y2);
return x1>=y;
}
int main()
{
n=read(),m=read();
register int v;
for(int i=1;i<=n;i++)
{
v=read();
e[i].push_back(v);
indeg[v]++;
uu[v].push_back(i);
}
for(int i=1;i<=n;i++)
{
if(!indeg[i]) q[++tt]=i;
}
register int now;
while(tt!=0)
{
now=q[tt];tt--;
v=e[now][0];
indeg[v]--;
if(!indeg[v]) q[++tt]=v;
}
for(int i=1;i<=n;i++)
{
if(indeg[i])
{
cir[i]=i;
hpd.dfs1(i,i);
hpd.dfs2(i,i);
if(!vis[i]) id[i]=++cur,dfs(i,1);
}
}
register int a,b;
while(m--)
{
a=read(),b=read();
if(id[cir[a]]!=id[cir[b]])
{
printf("-1 -1\n");continue;
}
// cout<<cir[a]<<" "<<cir[b]<<endl;
if(cir[a]==cir[b])
{
int lc=hpd.lca(a,b);
// cout<<lc<<endl;
printf("%d %d\n",hpd.dep[a]-hpd.dep[lc],hpd.dep[b]-hpd.dep[lc]);
}
else
{
int cira=pos[cir[a]],cirb=pos[cir[b]];
int mod=len[cir[a]];
// cout<<cira<<" "<<cirb<<endl;
int t1=hpd.dep[a]+(cirb-cira+mod)%mod;
int t2=hpd.dep[b]+(cira-cirb+mod)%mod;
if(cmp(hpd.dep[a],t2,t1,hpd.dep[b])) printf("%d %d\n",hpd.dep[a],t2);
else printf("%d %d\n",t1,hpd.dep[b]);
}
}
}
#3441. 创世纪
奇妙贪心？！
- 考虑叶子节点：
它本身不会被选，但是它的父亲要被选。
所以直接打上 \(vis\) 然后跳到父亲的父亲。
如果一个基环树的某个环上节点挂了一棵子树，那么这棵树必然会被本次操作全部分解。
- 考虑环：
上述操作结束之后必然只剩下环（或者不剩）
剩下环的条件是这个基环树本身就是个环（因为这是个基环树森林）
环的贡献是环长除以二 \(len>>1\)。
然后就结束了。
