zoj 3820 求三遍树的中心

最新推荐文章于 2024-07-25 14:00:47 发布
最新推荐文章于 2024-07-25 14:00:47 发布
阅读量3.1k 收藏
点赞数
分类专栏： 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/inf_force/article/details/47704595
版权

题意：给一颗节点数>=2的树，在树上标记两个点，使得所有点到离它最近的点的最大距离最小。

这题需要了解树的直径以及树的中心这两个概念
树的中心是树上所有点到这个点的最大距离最小
树的直径是树的最长链
我的做法是，先找到树的中心，如果中心有两个（树的中心一定不会大于2个），就劈成两个子树，求两个子树的中心
如果树的中心有一个，就劈开直径上一条边，拆成两颗子树，求这两棵子树的中心。
代码复用性比较挫。。一份个代码写了6遍。。
代码：

//author: CHC
//First Edit Time:  2015-08-15 09:45
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <set>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <algorithm>
#include <limits>
using namespace std;
typedef long long LL;
const int MAXN=200000+1000;
const int INF = numeric_limits<int>::max();
const LL LL_INF= numeric_limits<LL>::max();
struct Edge {
    int to,next;
    Edge(){}
    Edge(int _to,int _next):to(_to),next(_next){}
}e[MAXN*2];
int head[MAXN],tot;
void init(){
    memset(head,-1,sizeof(head));
    tot=0;
}
void AddEdge(int u,int v){
    e[tot]=Edge(v,head[u]);
    head[u]=tot++;
    e[tot]=Edge(u,head[v]);
    head[v]=tot++;
}
int dis[MAXN],vis[MAXN],pre[MAXN],du[MAXN];
int mainpath[MAXN];
void bfs(int x,int flag,int y){
    memset(vis,0,sizeof(vis));
    memset(dis,0,sizeof(dis));
    memset(du,0,sizeof(du));
    queue <int> q;
    q.push(x);
    vis[x]=1;
    dis[x]=1;
    pre[x]=x;
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=head[now];~i;i=e[i].next){
            int next=e[i].to;
            if(flag&&next==y)continue;
            if(vis[next])continue;
            du[now]++;du[next]++;
            vis[next]=1;
            dis[next]=dis[now]+1;
            pre[next]=now;
            q.push(next);
        }
    }
}
int vis2[MAXN];
void bfs1(int x){
    memset(vis2,0,sizeof(vis2));
    memset(dis,0,sizeof(dis));
    dis[x]=1;
    queue <int> q;
    q.push(x);
    vis2[x]=1;
    pre[x]=x;
    while(!q.empty()){
        int now=q.front();
        q.pop();
        for(int i=head[now];~i;i=e[i].next){
            int next=e[i].to;
            if(vis[next]&&!vis2[next]){
                //printf("%d --> %d\n",now,next);
                vis2[next]=1;
                dis[next]=dis[now]+1;
                pre[next]=now;
                q.push(next);
            }
        }
    }
}
int hpath[MAXN];
void getmainpath(int x){
    memset(hpath,0,sizeof(hpath));
    mainpath[0]=0;
    while(pre[x]!=x){
        mainpath[++mainpath[0]]=x;
        hpath[x]=1;
        //printf("x:%d\n",x);
        x=pre[x];
    }
        //printf("x:%d\n",x);
    mainpath[++mainpath[0]]=x;
    hpath[x]=1;
}
int main()
{
    int T,n;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        init();
        for(int i=0,x,y;i<n-1;i++){
            scanf("%d%d",&x,&y);
            AddEdge(x,y);
        }
        /*
        if(n==2){
            puts("0 1 2");
            continue;
        }
        else if(n==3){
            puts("1 1 2");
            continue;
        }
        */
        int maxdis=0,maxu;
        bfs(1,0,0);
        int tu=1;
        for(int i=1;i<=n;i++){
            if(du[i]==1){
                tu=i;break;
            }
        }
        bfs1(tu);
        maxdis=0;
        for(int i=1;i<=n;i++){
            if(maxdis<dis[i]){
                maxu=i;maxdis=dis[i];
            }
        }
        //printf("maxdis%d %d\n",maxdis,maxu);
        bfs1(maxu);
        maxdis=0;
        for(int i=1;i<=n;i++){
            if(maxdis<dis[i]){
                maxu=i;maxdis=dis[i];
            }
        }

        getmainpath(maxu);
        int ans1,ans2;
        int dis1,dis2;
        //printf("maxdis%d %d\n",maxdis,maxu);
        //system("pause");
        if(maxdis%2==0){
            int mid=maxdis/2;
            int midl=mid;
            int midr=midl+1;
            int midu,midv;
            //printf("midlr:%d %d %d\n",mid,midl,midr);
            for(int i=1;i<=mainpath[0];i++){
                //printf("%d:%d ",mainpath[i],dis[mainpath[i]]);
                if(dis[mainpath[i]]==midl){
                    midu=mainpath[i];
                }
                if(dis[mainpath[i]]==midr){
                    midv=mainpath[i];
                }
            }
            //printf("miduv:%d %d\n",midu,midv);
            while(midu==midv);
            bfs(midu,1,midv);
            int tu=midu;
            for(int i=1;i<=n;i++){
                if(vis[i]&&du[i]==1){
                    tu=i;break;
                }
            }
            bfs1(tu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(dis[i]>maxdis){
                    maxdis=dis[i];maxu=i;
                }
            }
            bfs1(maxu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(dis[i]>maxdis){
                    maxdis=dis[i];maxu=i;
                }
            }
            getmainpath(maxu);
            for(int i=1;i<=mainpath[0];i++){
                if(dis[mainpath[i]]==maxdis/2+1){
                    ans1=mainpath[i];
                }
            }
            dis1=maxdis/2;
            //printf("ans1:%d\n",ans1);

            bfs(midv,1,midu);
            tu=midv;
            for(int i=1;i<=n;i++){
                if(vis[i]&&du[i]==1){
                    tu=i;break;
                }
            }
            bfs1(tu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(dis[i]>maxdis){
                    maxdis=dis[i];maxu=i;
                }
            }
            bfs1(maxu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(dis[i]>maxdis){
                    maxdis=dis[i];maxu=i;
                }
            }
            getmainpath(maxu);
            for(int i=1;i<=mainpath[0];i++){
                if(dis[mainpath[i]]==maxdis/2+1){
                    ans2=mainpath[i];
                }
            }
            dis2=maxdis/2;
            printf("%d %d %d\n",max(dis1,dis2),ans1,ans2);
        }
        else {
            int mid=maxdis/2+1;
            int midu,midv;
            //printf("mid:%d\n",mid);
            for(int i=1;i<=mainpath[0];i++){
                if(dis[mainpath[i]]==mid){
                    midu=mainpath[i];
                }
            }
            //printf("midu:%d\n",midu);
            midv=midu;
            for(int i=head[midu];~i;i=e[i].next){
                if(hpath[e[i].to]){
                    midv=e[i].to;break;
                }
            }
            while(midu==midv);
            //printf("midu:%d midv:%d\n",midu,midv);
            bfs(midu,1,midv);
            int tu=midu;
            for(int i=1;i<=n;i++){
                if(vis[i]&&du[i]==1){
                    tu=i;break;
                }
            }
            //printf("tu:%d\n",tu);
            bfs1(tu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(maxdis<dis[i]){
                    maxdis=dis[i];
                    maxu=i;
                }
            }
            bfs1(maxu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(maxdis<dis[i]){
                    maxdis=dis[i];
                    maxu=i;
                }
            }
            getmainpath(maxu);
            //printf("maxu:%d %d\n",maxu,maxdis/2+1);
            for(int i=1;i<=mainpath[0];i++){
                //printf("%d:%d ",i,dis[i]);
                if(dis[mainpath[i]]==maxdis/2+1){
                    //printf("here:%d\n",i);
                    ans1=mainpath[i];
                }
            }
            //puts("");
            //printf("ans1:%d\n",ans1);
            dis1=maxdis/2;

            bfs(midv,1,midu);
            tu=midv;
            for(int i=1;i<=n;i++){
                if(vis[i]&&du[i]==1){
                    tu=i;break;
                }
            }
            //printf("tu:%d\n",tu);
            bfs1(tu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(maxdis<dis[i]){
                    maxdis=dis[i];
                    maxu=i;
                }
            }
            bfs1(maxu);
            maxdis=0;
            for(int i=1;i<=n;i++){
                if(maxdis<dis[i]){
                    maxdis=dis[i];
                    maxu=i;
                }
            }
            getmainpath(maxu);
            //printf("maxu:%d\n",maxu);
            for(int i=1;i<=mainpath[0];i++){
                if(dis[mainpath[i]]==maxdis/2+1){
                    ans2=mainpath[i];
                }
            }
            dis2=maxdis/2;
            printf("%d %d %d\n",max(dis1,dis2),ans1,ans2);
        }
    }
    return 0;
}
/*
8
1 2
1 3
1 4
2 7
2 8
3 5
5 6

10
1 2
2 3
3 10
1 4
4 5
1 8
8 9
1 6
6 7

13
1 2
2 3
3 10
1 4
4 5
1 8
8 9
1 6
6 7
10 11
11 12
12 13

11
1 2
2 3
3 4
4 5
5 6
6 7
7 8
6 9
9 10
10 11
*/
CHCXCHC
关注
专栏目录
树的中心
weixin_38168139的博客
08-06 1133
一、简介 　　树的中心是指：一个结点，对于每一个点的距离的最大值最小 二、解决 　　1.Dfs1：标记以结点u为树根的子树链的最大值d1[u]，次大值d2[u]，以及来源的结点编号c1[u],c2[u] 　　2.Dfs2：找到链接结点u没有经过u子树的链的最大值fd[u] 　　　　如果这个点是前一个节点选中的最大链中的，则这个结点的fd[u]=max(fd[fa[u]],d...
ZOJ Problem Set - 3820 Building Fire Stations 【树的直径 + 操作 】
大神养成中.....
10-13 2258
题目：ZOJ Problem Set - 3820 Building Fire Stations  题意：给出n个点，n-1条边的一棵树，然后要在两个点上建立两个消防站，让所有点的到消防站最大距离的点的这个距离最小。 分析：首先先求这个树的直径，然后在树的直径的中点处把树分成两棵树，然后在把两棵树分别取中点的最大值就是ans值。 这个题目数据有点水了感觉。。。 AC代码：
ZOJ 3820 Building Fire Stations
banshen0201的博客
04-07 92
题意： 一棵树中，选取两点，使得(其他点到这两点的距离的最小值)的最大值最小 思路： 考虑只选取一点的情况，那么显然选取直径的中点即为答案。 首先考虑选取的两点肯定在直径上，因为假如不在直径上，那么把点往直径上移动，不会使得答案变得更劣。 再考虑选取两点，假如我们将树按照树的直径的中点分成两段，那么肯定是一边放一点。 因为假如两个点都在一边的话，答案肯定是\(\frac{len}{2}\...
C++树形结构（3 树的中心、重心）
最新发布
Archie28的博客
07-25 1433
树的中心与重心
zoj 3820(2014牡丹江现场赛B题)
weixin_33985507的博客
10-17 92
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5374 思路：题目的意思是求树上的两点，使得树上其余的点到其中一个点的最长距离最小。可以想到这题与树直径有关，我们可以这样做，首先求出树的直径，然后取出树的中点以及与该中点相邻，并且是直径上的一个点，这样就把这棵树划分为两颗子树，然后分别求出这两棵树的直径，最...
zoj 3820 Building Fire Stations(二分+bfs)
不慌不忙、不急不躁
10-13 1631
题目链接：zoj 3820 Building Fire Stations 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。 解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。 判断函数里面做了3次bfs，但是每次bfs节点
ZOJ1055-Oh_Those_Achin_Feet.rar_BFS最短路径_ZOJ1055_bfs求最短路径_zoj
09-24
标题中的"ZOJ1055-Oh_Those_Achin_Feet.rar"是指ZOJ（Zhejiang Online Judge）平台上的一道编程题目，编号为1055，题目名为"Oh, Those Achin Feet"。这是一道与图论相关的算法问题，主要涉及的是BFS（Breadth First ...
zoj 1002_zoj1002_
09-29
【标题】"ZOJ 1002" 是一个在线编程竞赛题目，源自ZOJ（Zhejiang Online Judge），这是一个面向ACM/ICPC（国际大学生程序设计竞赛）的在线评测系统。题目编号1002，通常表示该题是ZOJ平台上的一个问题，可能涉及算法...
ZOJ 3820 Building Fire Stations 求中点+树的直径+BFS
whatbeg
11-27 596
题意：给一棵树，要求找出两个点，使得所有点到这两个点中距离与自己较近的一个点的距离的最大值（所有点的结果取最大的值，即最远距离）最小。 意思应该都能明白。 解法：考虑将这棵树摆直如下： 那么我们可以把最中间的那条直径边删掉，然后在分成的两颗子树内求一个直径中心点，那么这两个点就可以作为答案。 反正当时就觉得这样是正确的， 但是不能证明。 于是，几个bfs就可以搞定了。 当时写TLE了，
zoj1383_zoj1383_
09-30
标题“zoj1383_zoj1383_”和描述中的“一个非常非常非常非常实用的zoj结题代码”暗示我们这可能是一个关于ZOJ（在线判题系统Zhejiang Online Judge）的编程挑战解决方案。ZOJ是一个为编程爱好者提供在线编程练习和...
ZOJ 3820 (树的直径 + 二分)
Tongqi
10-26 622
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=5374 题意：给一颗树， 每条边的权值都是1， 问选取两个点， 使得树上所有点到最近的一个点的距离的最大值最小是多少 思路：最大值最小，应该是用二分，而出于贪心，这两个点应该是在树的直径上，那么便对称式的二分距离树径端点距离为X的点，看是否能满足条件 ...
zoj 3820 Building Fire Stations(树上乱搞)
ok_again的专栏
10-13 1679
做同步赛的时候想偏了，状态总是时好时坏，这状态去区域赛果断得GG了。 题目大意：给一棵树，让求出树上两个点，使得别的点到两个点较近的点的距离最大值最小。 赛后用O(n)的算法搞了搞，其实这道题不算难。逗逼的没A。。 其实这两个点一定是树直径上的两个点，如果能想到这个就很好搞了，只需要求出树的直径，然后从中间位置把树拆成两颗子树，然后分别求出子树的中心就好了。 证明如下，假如我们已经求出树上
ZOJ3820 Building Fire Stations（贪心）
06-05 1206
ZOJ3820 Building Fire Stations（贪心） ZOJ3820 题目大意：  给定一棵树，希望选取两个结点做消防站，使得其余的节点到达消防站的距离最大值最小。 解题思路：  二分长度，判断是否可行。  判断长度L过程中，任选一个点作为根节点，利用bfs找出最远的点，然后选择相隔L的节点作为第一个消防站，然后再以这个节点为根结点进行遍历，同样也是找出最远
ZOJ-3820 Building Fire Stations 题解
diyaochang9767的博客
12-11 132
题目大意： 　　一棵树，在其中找两个点，使得其他点到这两个的距离的较小值的最大值的最小值及其方案。 思路： 　　首先显然一棵树的直径的中点到其他点的距离的最大值必定比其他点的小。 　　那么感性思考一下就将一棵树的直径平分成两段，在找分成的两棵树的直径的中点。 　　PS：dfs貌似要爆栈，用非递归或bfs。 代码： 1 #include<cstdio> ...
zoj 1700 二叉搜索树
05-20
这道题目是一道经典的二叉搜索树问题，需要用到二叉搜索树的性质来解决。 首先，我们可以将问题转化为求解 $n$ 个节点构成的二叉搜索树的数量。假设 $F(n)$ 表示 $n$ 个节点构成的二叉搜索树的数量，那么对于任意一个节点 $i$，它可以作为树的根节点，将这个二叉搜索树分成左右两棵子树，左子树有 $i-1$ 个节点，右子树有 $n-i$ 个节点。因此，我们可以得到以下递归式： $$F(n) = \sum_{i=1}^{n} F(i-1) \times F(n-i)$$ 边界条件为 $F(0) = 1$，因为空树也是一棵二叉搜索树。 接下来，我们可以使用动态规划的方式来求解 $F(n)$。具体思路是从 $F(0)$ 开始，逐步计算出 $F(1), F(2), \cdots, F(n)$。在计算 $F(n)$ 时，需要依赖已经计算出来的 $F(0), F(1), \cdots, F(n-1)$。最终的答案即为 $F(n)$。 时间复杂度为 $O(n^2)$，空间复杂度为 $O(n)$。代码如下：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值