树的重心模板(以POJ 1655为例)

本文深入探讨了树的重心算法,通过一个具体题目讲解如何找到树上节点,使得去除该节点后,剩余子树的最大值达到最小。文章提供了完整的代码实现,并引用了树的重心概念的入门资料。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目:点击打开链接
题意:去掉树上的一个节点,看看剩下的子树中最大的是多少,然后在这些最大值中求一个最小值,如果有多个点都是最小值,那么找一个序号最小的节点。输出节点号,和最小值。
分析:树的重心裸题,树的重心入门参考https://blog.youkuaiyun.com/henu_jizhideqingwa/article/details/81670453
代码:

#pragma comment(linker, "/STACK:102400000,102400000")
///#include<unordered_map>
///#include<unordered_set>
#include<algorithm>
#include<iostream>
#include<fstream>
#include<complex>
#include<cstdlib>
#include<cstring>
#include<cassert>
#include<iomanip>
#include<string>
#include<cstdio>
#include<bitset>
#include<vector>
#include<cctype>
#include<cmath>
#include<ctime>
#include<stack>
#include<queue>
#include<deque>
#include<list>
#include<set>
#include<map>
using namespace std;
#define pt(a) cout<<a<<endl
#define debug test
#define mst(ss,b) memset((ss),(b),sizeof(ss))
#define rep(i,a,n) for (int i=a;i<=n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pii pair<int,int>
#define fi first
#define se second
#define ll long long
#define ull unsigned long long
#define pb push_back
#define mp make_pair
#define inf 0x3f3f3f3f
#define eps 1e-10
#define PI acos(-1.0)
const ll mod = 1e9+7;
const int N = 1e6+10;

ll qp(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
int to[4][2]={{-1,0},{1,0},{0,-1},{0,1}};

int t,n,son[N],ans[N],vs[N],id,cnt;
vector<int> g[N];

void dfs(int x) {
    son[x]=1;///自身
    vs[x]=1;
    int mxt=0;///最大子树节点个数
    for(int i=0;i<g[x].size();i++) {
        int v=g[x][i];
        if(vs[v]) continue;
        dfs(v);
        son[x]+=son[v];///son[x]为每个节点子节点的个数
        mxt=max(mxt,son[v]);///比较更大的子树节点个数
    }
    ans[x]=max(mxt,n-son[x]);
}

int main() {
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);

    while(cin>>t) {
        while(t--) {
            cin>>n;
            for(int i=1;i<=n;i++) g[i].clear();
            mst(vs,0);
            mst(son,0);
            mst(ans,0);
            for(int i=1;i<n;i++) {
                int a,b;
                cin>>a>>b;
                g[a].pb(b),g[b].pb(a);
            }
            dfs(1);
            cnt=inf;
            for(int i=1;i<=n;i++) {
                if(ans[i]<cnt) {
                    cnt=ans[i];
                    id=i;
                }
            }
            cout<<id<<" "<<cnt<<endl;
        }
    }
    return 0;
}

 

### POJ 树的重心问题解法 树的重心问题在POJ平台上的经典题目是 **POJ1655**。该问题的核心在于通过深度优先搜索(DFS)计算每个节点的子大小,并进一步确定删除某个节点后,剩余部分的最大子大小。最终目标是找到一个节点,使得删除该节点后,剩余的最大子大小最小。 以下是关于该问题的具体解法和代码实现: #### 问题描述 给定一棵,要求找到树的重心树的重心定义为:删除某个节点后,所有生成的连通分量中,最大连通分量的节点数尽可能小。如果存在多个满足条件的节点,则输出编号最小的节点。 #### 解法思路 1. 使用 DFS 遍历整棵,计算每个节点的子大小 `son[u]`。 2. 在 DFS 过程中,对于每个节点 `u`,记录其所有子的最大节点数 `Max`。 3. 计算当前节点 `u` 的父节点延伸出去的节点数目 `n - son[u]`。 4. 确定当前节点 `u` 删除后,剩余的最大子大小 `tmp = max(Max, n - son[u])`。 5. 更新答案,选择使得 `tmp` 最小的节点作为重心。若 `tmp` 相等,则选择编号较小的节点。 #### 代码实现 以下是一个基于 C++ 的完整实现: ```cpp #include <cstdio> #include <cstring> #include <algorithm> using namespace std; const int N = 20005; int head[N], top = 0; int n; int son[N]; int ans, point; struct Edge { int v, next; } edge[N * 2]; void init() { memset(head, -1, sizeof(head)); top = 0; memset(son, 0, sizeof(son)); ans = n + 1; // 初始化为一个较大值 } void addedge(int u, int v) { edge[top].v = v; edge[top].next = head[u]; head[u] = top++; } void dfs(int u, int fa) { son[u] = 1; int Max = 0; for (int i = head[u]; i != -1; i = edge[i].next) { int v = edge[i].v; if (v == fa) continue; dfs(v, u); son[u] += son[v]; Max = max(Max, son[v]); } int tmp = max(Max, n - son[u]); if (tmp < ans || (tmp == ans && u < point)) { ans = tmp; point = u; } } int main() { int T; scanf("%d", &T); while (T--) { init(); scanf("%d", &n); int u, v; for (int i = 1; i < n; i++) { scanf("%d%d", &u, &v); addedge(u, v); addedge(v, u); } dfs(1, -1); printf("%d %d\n", point, ans); } return 0; } ``` #### 关键点解释 1. **初始化**:使用 `init()` 函数清空全局变量,确保每次测试用独立运行[^3]。 2. **边的存储**:采用邻接表存储的结构,便于快速访问每个节点的子节点。 3. **DFS 遍历**:通过递归方式计算每个节点的子大小,并更新最大子大小。 4. **结果更新**:在遍历过程中,实时更新最优解,确保最终答案满足题意。 #### 时间复杂度 - **DFS 遍历**:每个节点和边仅被访问一次,时间复杂度为 \(O(n)\)。 - **总复杂度**:对于多组测试数据,时间复杂度为 \(O(T \cdot n)\),其中 \(T\) 是测试用数量,\(n\) 是节点数量。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值