树的直径和重心

1|0树的直径

1|1定义，性质：

树的直径：一棵树中长度最大的简单路径
性质：

1.树的直径不一定唯一
2.若有多条直径，所有的直径交于树的中心
3.树上任意点x距离最远的点y一定是树的直径的一个端点

1|2求树的直径

1|0方法1：2遍DFS

1.任找一个点root，DFS找距离root最远的点x

2.以x为根节点，DFS找到距离x最远的点y

则x到y为树的一条直径
ps:边权不能为负
代码实现：

void dfs1(int now,int lon,int fa){
	if(maxn<lon){
		maxn=lon;
		rec=now;
	}
	for(int i=0;i<v[now].size();i++){
		if(v[now][i].to==fa) continue;
		dfs1(v[now][i].to,lon+v[now][i].val,now);
	}
}

void dfs2(int now,int lon,int fa){
	if(ans<lon){
		ans=lon;
	}
	for(int i=0;i<v[now].size();i++){
		if(v[now][i].to==fa) continue;
		dfs2(v[now][i].to,lon+v[now][i].val,now);
	}
}

int main(){
	dfs1(1,0,0);
	dfs2(rec,0,0);
}

1|0方法2：树形DP

设dp[i]和f[i]表示以点i为根节点的子树的最长链和次长链。取max(dp[i]+f[i])为直径长度，如果要求直径上的点可以对于每个节点记录其最长链和次长链的儿子。

代码实现：

#include<bits/stdc++.h>
using namespace std;
int n;
int maxn=0;

struct o{
	int to;
	int val;
};

vector<o> v[500010];
int dp[500010];
int f[500010];

void dfs(int now,int fa){
	//cout<<now<<endl;
	dp[now]=f[now]=0;
	for(int i=0;i<v[now].size();i++){
		if(v[now][i].to==fa) continue;
		dfs(v[now][i].to,now);
		int t=dp[v[now][i].to]+v[now][i].val;
		if(t>dp[now]){
			f[now]=dp[now];
			dp[now]=t;
		}
		else if(t>f[now]){
			f[now]=t;
		}
	}
	maxn=max(maxn,dp[now]+f[now]);
	return;
}

例题1：
CF734E Anton and Tree
先考虑缩点（代码不用真的缩），所以一个点的所有相邻节点和它的颜色不一样。

这时你考虑从一个节点开始染色，答案就是把它作为根树的深度。那么树的深度怎样才能最小呢？显然让树的中心做根，此时深度为树的直径长度的一半。

考虑不缩点，其实你发现对于一条边，只有它连接的时候两端颜色不一样缩点算直径时才会贡献1的长度，所以可以直接枚举每一条边，两端颜色不一样边权为1，否则为零，就可以直接计算了。

#include<bits/stdc++.h>
using namespace std;
int n;
int col[200010];

struct o{
	int to;
	int val;
};
int maxn=-1;
vector<o> v[200010];
int dp[200010];
int f[200010];

void dfs(int now,int fa){
	dp[now]=f[now]=0;
	for(int i=0;i<v[now].size();i++){
		if(v[now][i].to==fa) continue;
		dfs(v[now][i].to,now);
		int t=dp[v[now][i].to]+v[now][i].val;
		if(t>dp[now]){
			f[now]=dp[now];
			dp[now]=t;
		}
		else if(t>f[now]){
			f[now]=t;
		}
	}
	maxn=max(maxn,dp[now]+f[now]);
	return;
}

int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>col[i];
	}
	for(int i=1;i<n;i++){
		int a,b;
		cin>>a>>b;
		if(col[a]==col[b]){
			v[a].push_back((o){b,0});
			v[b].push_back((o){a,0});
		}
		else{
			v[a].push_back((o){b,1});
			v[b].push_back((o){a,1});
		}
	}
	dfs(1,0);
	cout<<(maxn+1)/2;
	return 0;
}

例题2：
POJ-1849 Two
你考虑如果我们找到一条主路径，使得所有不在主路径上的点都在主路径上的分支里，主路径就可以直走一次。

所以最初的思路是先从起点s走到直径。但是你考虑一件事：如果走到直径上往一边走，去另外一边还是要走回去。

可是我们有两条路径，直接到直径上分开走就行了，答案是：总长度 * 2-直径长度

#include<cstdio>
#include<vector>
#include<iostream>
using namespace std;
int n,s;
int tot;

struct node{
	int to;
	int val;
};

vector<node> v[100001];
int dp[100001],f[100001];

void dfs(int now,int fa){
	for(int i=0;i<v[now].size();i++){
		if(v[now][i].to==fa) continue;
		dfs(v[now][i].to,now);
		if(dp[v[now][i].to]+v[now][i].val>dp[now]){
			f[now]=dp[now];
			dp[now]=(dp[v[now][i].to]+v[now][i].val);
		}
		else if(dp[v[now][i].to]+v[now][i].val>f[now]){
			f[now]=(dp[v[now][i].to]+v[now][i].val);
		}
	}
}

int main(){
	cin>>n>>s;
	for(int i=1;i<n;i++){
		int u,vv,w;
		cin>>u>>vv>>w;
		v[u].push_back({vv,w});
		v[vv].push_back({u,w});
		tot+=w;
	}
	dfs(1,0);
	int maxn=-1;
	for(int i=1;i<=n;i++){
		maxn=max(maxn,dp[i]+f[i]);
	}
	cout<<2*tot-maxn;
	return 0;
}

例题3：
P3629 [APIO2010] 巡逻
首先，显然不加边时每条边需要经过2次，一次过去，一次回来

然后，加1条边时，形成1个环，环上每条边只需要经过1次，相比没加之前每条边要少1次，显然我们只需要让环上的边最多，也就是找直径，最后计算答案先2* (n-1)是不加边的路径数，减去直径上的边数，最后不要忘了加上1，也就是加的那一条边，轻松拿到三十分

代码实现：

#include<bits/stdc++.h>
using namespace std;
int n,k;
int maxn=0;

struct o{
	int to;
	int val;
};

vector<o> v[500010];
int dp[500010];
int f[500010];
int cur[500010];
int cnt=0;

void dfs(int now,int fa){
	//cout<<now<<endl;
	dp[now]=f[now]=0;
	for(int i=0;i<v[now].size();i++){
		if(v[now][i].to==fa) continue;
		dfs(v[now][i].to,now);
		int t=dp[v[now][i].to]+v[now][i].val;
		if(t>dp[now]){
			f[now]=dp[now];
			dp[now]=t;
		}
		else if(t>f[now]){
			f[now]=t;
		}
	}
	maxn=max(maxn,dp[now]+f[now]);
	return;
}

int main(){
	cin>>n>>k;
	for(int i=1;i<n;i++){
		int u,vv,w=1;
		cin>>u>>vv;
		v[u].push_back((o){vv,w});
		v[vv].push_back((o){u,w});
	}
	dfs(1,0);
	if(k==1){
		cout<<2*(n-1)-maxn+1;
	}
	return 0;
}

再考虑K=2，还要加一条边，那是次长的那一条吗？不一定，因为如果两条中边有交集，手推发现交集那部分边又要走两遍了，因此我们可以把第一边扫过的边的边权改成-1，这样就可以加上重复的边数

代码实现：

#include<bits/stdc++.h>
using namespace std;
template<typename type>
void read(type &x){
    type f=1;x=0;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    x*=f;
}
const int N=1e5+7;
struct node{
    int to,w,next;
}e[N*2];
int head[N],cnt;
void add(int a,int b,int c){
    e[++cnt].to=b;
    e[cnt].next=head[a];
    head[a]=cnt;
    e[cnt].w=1;
}
int dis[N],vis[N],l1,l2,n,k,point,f[N],d[N],v[N];
int ans=0;
void bfs(int x,int ck){
    memset(dis,0,sizeof(dis));
    memset(vis,0,sizeof(vis));
    queue<int >q;
    q.push(x);
    vis[x]=1;
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=head[now];i;i=e[i].next){
            int y=e[i].to;
            if(!vis[y]){
                vis[y]=1;
                dis[y]=dis[now]+e[i].w;
                q.push(y);
                if(ck)f[y]=now;
            }
        }
    }
    for(int i=1;i<=n;i++){
        if(ans<dis[i])ans=dis[i],point=i;
    }
}
void change(int a){
    while(f[a]){
        int fa=f[a];
        for(int i=head[fa];i;i=e[i].next){
                if(e[i].to==a){
                   e[i].w=-1;
                   break; 
                }
        }
        for(int i=head[a];i;i=e[i].next){
            if(e[i].to==fa){
                e[i].w=-1;
                break;
            }
        }
        a=fa;
    }
}
void dp(int x){
    v[x]=1;
    for(int i=head[x];i;i=e[i].next){
        int y=e[i].to;
        if(v[y])continue;
        dp(y);
        ans=max(ans,dis[x]+dis[y]+e[i].w);
        dis[x]=max(dis[x],dis[y]+e[i].w);
    }

}

int main(){
   read(n);read(k);
    for(int i=1;i<n;i++){
        int a,b;
       	read(a);read(b);
        add(a,b,1);
        add(b,a,1);
    }
    if(k==1){
        bfs(1,0);
        bfs(point,0);
        printf("%d",2*n-dis[point]-1);
    }
	else{
        bfs(1,0);
        bfs(point,1);
        l1=dis[point];
        change(point);
        memset(dis,0,sizeof(dis));
        memset(vis,0,sizeof(vis));
        ans=0;
        dp(1);
        printf("%d",2*n-ans-l1);
    }
    return 0;
}

2|0树的重心：

2|1定义和性质：

树的重心：以树的重心x为根节点时，任何一棵子树的大小不超过n/2，则称x为树的重心。
性质：

1.所有点到树的重心的距离之和最小
2.树的重心至多有两个，且两个重心一定相邻
3.添加一个叶子结点，树的重心至多偏移一个点
其实第二条性质还有一半，下面有道题就要用。

2|2求法：

很简单，直接dfs维护每个节点的最大子树大小，小于等于n/2就是重心（但不要忘啦，“最大子树大小”是把当前节点提成根以后计算，所以父亲也是“子树”）
例题：
CF1406C Link Cut Centroids
这题结论题，先说结论：如果一棵树有两个重心，那么这两个重心的子树大小必然均为n/2。
怎么来的，很简单。第二条性质告诉我们，两个重心一定相邻。那么反证法：
如果一个重心的最大子树大小小于n/2，那么另一个重心的子树大小和一定大于n/2，因为相邻，所以得出这个重心的最大子树应该是另一个重心，大小大于n/2,不符合重心的定义。
有了这一个结论，剩下的就很简单了：

1.原树只有一个重心，随便删一条边再加上
2.有两个重心，在一个重心的子树里找一个叶子结点，删掉它与父亲连接的边，转而连向另一个重心。

#include<bits/stdc++.h>
using namespace std;
int T;
int n;
vector<int> v[100001];
int siz[100001];
int maxn[100001];
int x,y;
int ans[10];
int cnt;
bool ok;
int from,to;

void dfs(int now,int fa){
	//cout<<now<<endl;
	for(int i=0;i<v[now].size();i++){
		if(v[now][i]==fa) continue;
		dfs(v[now][i],now);
		siz[now]+=siz[v[now][i]];
		if(siz[v[now][i]]>maxn[now]){
			maxn[now]=siz[v[now][i]];
		}
	}
	//if(now==3) cout<<"yes"<<endl;
	maxn[now]=max(maxn[now],n-siz[now]);
}

void dfss(int now,int fa){
	//cout<<now<<" "<<fa<<endl;
	if(ok) return;
	bool nxt=false;
	for(int i=0;i<v[now].size();i++){
		if(v[now][i]==fa) continue;
		nxt=true;
		dfss(v[now][i],now);
	}
	if(!nxt){
		from=fa;
		to=now;
		ok=true;
	}
}

int main(){
	cin>>T;
	while(T--){
		ok=false;
		cnt=0;
		for(int i=1;i<=n;i++) v[i].clear();
		cin>>n;
		for(int i=1;i<n;i++){
			cin>>x>>y;
			v[x].push_back(y);
			v[y].push_back(x);
		}
		for(int i=1;i<=n;i++){
			siz[i]=1;
			maxn[i]=0;
		}
		dfs(1,0);
		for(int i=1;i<=n;i++){
			if(maxn[i]<=(n/2)) ans[++cnt]=i;
		}
		if(cnt==1){
			cout<<1<<" "<<v[1][0]<<endl;
			cout<<1<<" "<<v[1][0]<<endl;
			continue;
		}
		else{
			//cout<<ans[1]<<" "<<ans[2]<<endl;
			dfss(ans[1],ans[2]);
			cout<<from<<" "<<to<<endl;
			cout<<to<<" "<<ans[2]<<endl; 
		}
	}
}

__EOF__

本文作者：星河倒注
本文链接：https://www.cnblogs.com/wangwenhan/p/17584845.html
关于博主：评论和私信会在第一时间回复。或者直接私信我。
版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
声援博主：如果您觉得文章对您有帮助，可以点击文章右下角【推荐】一下。您的鼓励是博主的最大动力！

posted @ 2023-07-27 14:29 星河倒注阅读(28) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· HDU 5834 Magic boy Bi Luo with his excited tree

· 点分治入门

· 算法笔记 - 树的直径

· 树的直径、重心、中心

· 树的直径，树的重心

阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· .NET10 - 预览版1新功能体验（一）

公告

树的直径和重心

发表于 2023-07-27 14:29阅读：28评论：0推荐：0

树

关注

跳至底部

昵称：星河倒注
园龄： 1年7个月
粉丝： 10
关注： 10

+加关注

wangwenhan

树的直径和重心

1|0树的直径

1|1定义，性质：

1|2求树的直径

1|0方法1：2遍DFS

1|0方法2：树形DP

2|0树的重心：

2|1定义和性质：

2|2求法：

公告

星河倒注

树的直径和重心

搜索

常用链接

随笔分类 (61)

随笔档案 (95)

相册 (1)

阅读排行榜

评论排行榜

推荐排行榜

最新评论