如何找树的重心?
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