树形问题(笔记)

如何找树的重心?

1. dfs一次, 算出以每个点为跟的子树大小

2. 记录以每个节点为根的最大子树大小

3. 如果以当前节点作为根的最大子树比当前根要优就换

POJ 1655

#include<iostream>
#include<cstring>
#include<algorithm>
#include<vector>
#include<set>
#include<queue>
#include<map>
using namespace std;
typedef long long ll;
int t, n;
int size[20002];
int f[20002];
int rt;
vector<int> edge[20002];
bool vis[20002];
void getroot(int u, int fa){
	size[u] = 1; f[u] = 0;
	vis[u] = 1;
	for(auto v : edge[u]){
		if(v == fa)continue;
		if(vis[v])continue;
		getroot(v, u);
		size[u] += size[v];
		f[u] = max(f[u], size[v]);
	}
	f[u] = max(f[u], n - size[u]);
	if(f[u] < f[rt]) rt = u;
}
void work(){
	rt = 1;
	memset(vis, 0, sizeof(vis));
	memset(edge, 0, sizeof(edge));
	memset(f, 0, sizeof(f));
	memset(size, 0, sizeof(size));
	cin >> n;
	for(int i = 1; i <= n - 1; i++){
		int u, v;
		cin >> u >> v;
		edge[u].push_back(v);
		edge[v].push_back(u);
	}
	getroot(1, 0);
	cout << rt << " " << f[rt] << endl;
}
int main(){
	cin >> t;
	while(t--){
		work(); 
	}
}

树的直径

dfs

1. 从根找深度最深的节点

2.再从最深节点找多一次最深的节点即刻

向下更新

#include<bits/stdc++.h>
const int N=1000010;
using namespace std;
int n,m,head[N],tot,dis[N],cur,mx;
inline int read(){
	int f=1,x=0;char ch;
	do{ch=getchar();if(ch=='-')f=-1;}while(ch<'0'||ch>'9');
	do{x=x*10+ch-'0';ch=getchar();}while(ch>='0'&&ch<='9');
	return f*x;
}
struct Edge{
	int u,v,w,next;
}G[N<<1];
inline void addedge(int u,int v,int w){
	G[++tot].u=u;G[tot].v=v;G[tot].w=w;G[tot].next=head[u];head[u]=tot;
	G[++tot].u=v;G[tot].v=u;G[tot].w=w;G[tot].next=head[v];head[v]=tot;
}
inline void dfs(int u,int fa){
	for(int i=head[u];i;i=G[i].next){
		int v=G[i].v;if(v==fa)continue;
		dis[v]=dis[u]+G[i].w;
		if(dis[v]>mx)cur=v,mx=dis[v];
		dfs(v,u);
	}
}
int main(){
	n=read();
	for(int i=1;i<n;i++){
		int u=read(),v=read(),w=read();
		addedge(u,v,w);
	}
	dfs(1,0);mx=0;memset(dis,0,sizeof(dis));
	dfs(cur,0);
	printf("%d\n",mx); 
}

方法2. 动态规划

回溯更新

#include<bits/stdc++.h>
#define N 10010
using namespace std;
struct Edge{
    int u,v,next,w;
}G[N*2];
int tot=0,head[4*N],dp1[N],dp2[N];
void addedge(int u,int v,int w){
    G[++tot].u=u;G[tot].v=v;G[tot].w=w;G[tot].next=head[u];head[u]=tot;
    G[++tot].u=v;G[tot].v=u;G[tot].w=w;G[tot].next=head[v];head[v]=tot;
}
void read(int &x){
    x=0;int f=1;char ch;
    do{ch=getchar();if (ch=='-')f=-1;}while(ch<'0'||ch>'9');
    do{x=x*10+ch-'0';ch=getchar();}while(ch>='0'&&ch<='9');
    x*=f;
}
int ans=0;
void work(int u,int fa){
    for (int i=head[u];i;i=G[i].next){
        int v=G[i].v,w=G[i].w;
        if (v==fa)continue;
        work(v,u);
        if (dp1[v]+w>dp1[u]){
            dp2[u]=dp1[u];
            dp1[u]=dp1[v]+w;
        }
        else dp2[u]=max(dp2[u],dp1[v]+w);
    }
    ans=max(dp1[u]+dp2[u],ans);
}
int main(){
    int n;read(n);
    for (int i=1;i<n;i++){
        int u,v,w;read(u);read(v);read(w);
        addedge(u,v,w);
    }
    work(1,0);
    printf("%d\n",ans);
    return 0;
}

公共祖先

LCA 

有没有想过为什么我们要这么无聊去找LCA?

现在给你一个问题,让你找一颗树上两颗节点的最短距离, 你可以用dijistra, 或者 spfa来找, 但是这样很愚蠢, 因为不仅没有利用树的特性, 还带来不必要的开销.

树是拥有简单路径这一特性的, 就是说两点之间只有一条路.

那么你会发现两点在树上的最短距离的路径会有两种情况.

u -> lca -> v <--- 最短路径等于 dis[u] - dis[lca] + dis[v] - dis[lca] = dis[u] + dis[v] - 2*dis[lca] 

u -> v -> lca 这里lca必然等于v 所以<----最短路径等于 dis[u] - dis[lca] + dis[v] - dis[lca] = dis[u] + dis[v] - 2*dis[lca]  

lca 之前我们学过用线段树求

现在我们用倍增求.

如果忘记倍增原理, 可以看这个影片

https://www.youtube.com/watch?v=02zM-QoKoPg

总之就是利用二进制的原理, 使得我们总能让两个节点的深度一样.

深度一样之后如何求lca呢?

我们可以留意到一个重点, 就是如果 a 和 b 的深度一样, 在高过lca之后他们的倍增出来的结果都会是一样的, 所以我们从大往小找,一旦一样我们就跳过, 我们很快就可以找到 lca 在 a 和 b 之间的节点, 并且他们的深度一样. 

然后透过二进制机制直接找到lca.

题目: P5908

这里是贴了别人的代码, 要留意的地方只有查分数组那里

#include<cstdio>
#include<iostream>
#include<cmath>
using namespace std;
long long ans=0;
int fa[500010][25],lg[500010],deep[500010],t;
struct node
{
	int from;
	int to;
	int next;
}ed[2*500001];
int v[2*500001],tot=0;
void add(int x,int y)
{
	ed[++tot].from=x;
	ed[tot].to=y;
	ed[tot].next=v[x];
	v[x]=tot;
}
int lca(int x,int y)
{
	if(deep[x]<deep[y])			//假设x深度大于y
		swap(x,y);
	while(deep[x]>deep[y])		//x,y调整到同一深度	
	{
		x=fa[x][lg[deep[x]-deep[y]]-1];
	}
	if(x==y)
		return x;
	for(int k=lg[deep[x]];k>=0;k--)		//x,y一起向上跳
	{
	    if(fa[x][k]!=fa[y][k])
	    {
	    	x=fa[x][k];
			y=fa[y][k];
	    }
	}
    return fa[x][0];
	
}
void dfs(int x,int fath)				
{
	deep[x]=deep[fath]+1;					//处理深度
	fa[x][0]=fath;
	for(int i=1;(1<<i)<=deep[x];i++)
	{
		fa[x][i]=fa[fa[x][i-1]][i-1];
	}
	for(int i=v[x];i;i=ed[i].next)
		if(ed[i].to!=fath)
			dfs(ed[i].to,x);
}
int n,m;
int a,b,c;
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n-1;i++)
	{
		scanf("%d%d",&a,&b);
		add(a,b);
		add(b,a);
	}
	dfs(1,0);
	for(int i=1;i<=n;i++)								//常数优化 
		lg[i]=lg[i-1]+(1<<lg[i-1]==i);
	for(int i=1;i<=m;i++)
	{
		ans=0;
		scanf("%d%d%d",&a,&b,&c);
		int t1=lca(a,b);					//三者分别求LCA
		int t2=lca(a,c);
		int t3=lca(b,c);
		if(t1==t2)
			t=t3;
		else if(t1==t3)
			t=t2;
		else if(t2==t3)
			t=t1;
        //差分
		ans=deep[a]+deep[b]+deep[c]-deep[t1]-deep[t2]-deep[t3];		
		printf("%d %lld\n",t,ans);
	}
	return 0;
} 

P3128

树链剖分

最常见的就是重剖, 我们定义一个重子节点为拥有最多的子树节点.

重链就是连向重子节点的路径.

模板加题目

P2590