hdoj 4514 并查集树的直径（二）

最新推荐文章于 2022-08-19 11:06:59 发布

prenzle

最新推荐文章于 2022-08-19 11:06:59 发布

阅读量597

点赞数

分类专栏： ACM 文章标签：腾讯马拉松并查集

本文链接：https://blog.csdn.net/hello42/article/details/8776950

版权

ACM 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

本文是hdoj 4514问题的解决方案，作者探讨了如何使用一次深度优先搜索（DFS）来找出树的直径，而不是传统的两次DFS方法。虽然这种方法节省了遍历次数，但内存消耗相对较高，且时间复杂度与两次DFS相当。

摘要由CSDN通过智能技术生成

接上一篇 hdoj 4514 并查集树的直径

http://blog.csdn.net/hello42/article/details/8776887

第一种算法采用两次dfs遍历找出最长路径。在琢磨了半天之后觉得一次dfs也能找出最张路径

于是就写了这个算法，不过这个内存多占用了好多，时间貌似和两次dfs的算法一样。囧

一次dfs遍历，就找出最长路径。

采用算法为dfs遍历回朔的过程中不断的计算当前节点中的任意两个孩子节点的最远路径之和

如果的到的新的路径比原有的最长路径大，则更改最长路径为新的路径

如果当前节点的孩子节点只有一个或者没有，直接比用当前节点到最远子孙节点的距离和最长路径比较

在回朔完毕的时候，每个节点上都存放了节点到最远子孙节点的距离。并且得到了最长路径

#include<stdio.h>
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include<string.h>
#pragma comment(linker,"/STACK:102400000,102400000")//设置栈大小
#define MAX 100001
using namespace std;
//自定义结构体Node存放边的尾节点，边的value,首节点到最远子孙节点的距离
typedef struct Node{
    int end,value,max;
}tmpNode;
//已vector 形式存放Node 定义结构体NodeList
typedef vector<Node> NodeList;
NodeList grp[MAX];
//存放孤立节点和叶子节点的结构体
typedef vector<int> LInt;
LInt starts;
int father[MAX],save[MAX],dis[MAX],vist[MAX];
int n,m,maxPath;
//初始化father,save,图；
void init(){
    int i;
    maxPath=0;
    for(i=0;i<=n;i++)
    {
        grp[i].clear();
        father[i]=i;
        save[i]=0;
    }
     //存放孤立点和叶子点的表清空
    starts.clear();
}
//每次遍历之后都需要重置dis vist
void reset(){
    int i;
    for(i=0;i<=n;i++)
        {
           dis[i]=0;
           vist[i]=0;
        }
}
//并查集find操作，查找x的祖先，并使用save数组压缩路径
int find(int x){
    int i=0,j=0;
    while(x!=father[x]){
        save[i++]=father[x];
        x=father[x];
    }
    for(j=0;j<i;j++){
    father[save[j]]=x;
    }
    return x;
}
//dfs遍历图，并计算跟节点到所有点的距离,now存放当前节点
int dfs(Node now){
    int i,j,size;
    Node tmp;
    size=grp[now.end].size();
    for(i=0;i<size;i++){
        tmp=grp[now.end][i];
        if(!vist[tmp.end]){//如果节点end没有被访问过
            vist[tmp.end]=1;//访问end节点
            grp[now.end][i].max=dfs(tmp);//遍历end的所有孩子节点
            vist[tmp.end]=0;//重置end的访问
        }
    }
    //遍历与当前节点直接相连的节点（孩子节点）
    //并更新当前节点的max为到最远叶子的距离
    int m=now.max;
    for(i=0;i<size;i++){
        if(vist[grp[now.end][i].end])continue;
        tmp=grp[now.end][i];
        if(tmp.value+tmp.max>m){
            m=tmp.value+tmp.max;
        }
    }
    now.max=m;
    //printf("now:%d value=%d max=%d\n",now.end,now.value,now.max);
    //遍历求出两两孩子节点距离之和，找出最大距离，如果比已经存在的maxPath大，则更新maxPath
    int e=now.end,tmpPath1=0,tmpPath2=0;
    for(i=0;i<size;i++){
         if(vist[grp[now.end][i].end])continue;
      //  printf("child:%d max=%d " ,grp[now.end][i].end,grp[now.end][i].max);
        tmpPath1=grp[e][i].max+grp[e][i].value;//now节点到到第i个孩子上最远叶子节点的距离
        for(j=i+1;j<size;j++){
            tmpPath2=grp[e][j].max+grp[e][j].value;//now节点到第j个孩子上最远叶子节点的距离
            if(tmpPath1+tmpPath2>maxPath){
                maxPath=tmpPath1+tmpPath2;
            }
        }
    }
    //printf("\n");
    //如果孩子节点个数少于2个，则直接与maxPath比较
    if(tmpPath1>maxPath)maxPath=tmpPath1;
    return now.max;
}
int main(){
    int flage,i,x,y,value,s1,s2;
    Node node;
    while(scanf("%d%d",&n,&m)!=EOF){
            flage=0;//标识是否存在环
            //如果m>=n则肯定存在环，只需继续输入数据
            if(m>=n){flage=1;for(i=0;i<m;i++)scanf("%d%d%d",&x,&y,&value);}
            else{
                init();//初始化所需函数
                for(i=0;i<m;i++){
                    scanf("%d%d%d",&x,&y,&value);
                    if(!flage){
                        s1=find(x);
                        s2=find(y);
                        if(s1==s2)flage=1;//如果s1=s2则存在环
                        else{
                                father[s1]=s2;//并查集union简化操作，此题中可以不用按秩和并
                                node.value=value;
                                node.max=0;//初始化的max都为0
                                node.end=y;
                                grp[x].push_back(node);//存入x到y的边
                                node.end=x;
                                grp[y].push_back(node);//存入y到x的边
                        }
                    }
                }
            }
            if(flage){printf("YES\n");continue;}
            int size,tmp,index,p,tmp1;
            Node root;
            //如果图中在以i为起点边小于等与1，则其为叶子节点或者孤立节点
            for(i=1;i<=n;i++){
                if(grp[i].size()<=1)starts.push_back(i);
            }
            size=starts.size();
            for(i=1;i<=n;i++){
                if(father[i]==i){
                    reset();
                    vist[i]=1;//设置i为被访问
                    root.end=i;
                    root.max=0;
                    root.value=0;
                    dfs(root);//以i为根节点dfs遍历图
            }
        }
            printf("%d\n",maxPath);
    }
}