poj 1655 Balancing Act 寻找树的重心

本文探讨了如何通过遍历和计算树的子节点数量来找到树的重心,提供了求解 POJ 1655 题目的详细步骤和代码实现。

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

就是寻找树的重心的果题。

http://poj.org/problem?id=1655

#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

using namespace std;

const int MAXN = 20005;
const int MAXE = 40005;

int N;

struct Edge {
    int to;
    Edge * next;
}*EE,E[MAXE];

struct Gragh{
    Edge * first;
}G[MAXN];

int tot;
int siz[MAXN];//有多少个子节点
int num[MAXN];//子树中最大的
int root;

void init() {
    EE = E;
    memset(E,0,sizeof(E));
    memset(G,0,sizeof(G));
    num[root=0] = N;
}

void addedge(int u,int v) {
    EE->to = v; EE->next = G[u].first; G[u].first = EE++;
    EE->to = u; EE->next = G[v].first; G[v].first = EE++;
}

void dfs(int u,int fa = 0) {
    siz[u] = 1;
    num[u] = 0;
    for(Edge * p = G[u].first ; p ; p = p -> next) {
        if(p->to != fa) {
            dfs(p->to,u);
            siz[u] += siz[p->to];
            num[u] = max(num[u],siz[p->to]);
        }
    }
    num[u] = max(N-siz[u],num[u]);
    if(num[u] < num[root]) root = u;
}

void input() {
    scanf("%d",&N);
    init();
    int u,v;
    for(int i = 1 ; i <= N - 1 ; i++) {
        scanf("%d %d",&u,&v);
        addedge(u,v);
    }
}

void solve() {
    dfs(1);
    printf("%d %d\n",root,num[root]);
}

int main(void) {
    //freopen("a.in","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--) {
        input();
        solve();
    }
    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、付费专栏及课程。

余额充值