湫湫系列故事——设计风景线 【并查集判定环】+【求无环非连通图的树的直径】

　随着杭州西湖的知名度的进一步提升，园林规划专家湫湫希望设计出一条新的经典观光线路，根据老板马小腾的指示，新的风景线最好能建成环形，如果没有条件建成环形，那就建的越长越好。
　　现在已经勘探确定了n个位置可以用来建设，在它们之间也勘探确定了m条可以设计的路线以及他们的长度。请问是否能够建成环形的风景线？如果不能，风景线最长能够达到多少？
　　其中，可以兴建的路线均是双向的，他们之间的长度均大于0。
Input
　　测试数据有多组，每组测试数据的第一行有两个数字n, m，其含义参见题目描述；
　　接下去m行，每行3个数字u v w，分别代表这条线路的起点，终点和长度。

　　 TechnicalSpecificationTechnicalSpecification
　　1. n<=100000
　　2. m <= 1000000
　　3. 1<= u, v <= n
　　4. w <= 1000
Output
　　对于每组测试数据，如果能够建成环形（并不需要连接上去全部的风景点），那么输出YES，否则输出最长的长度，每组数据输出一行。
Sample Input
3 3
1 2 1
2 3 1
3 1 1
Sample Output
YES

本题呢，考察了两个知识点，一个是并查集可以用来判定一个无向图是否成环，第二个，是考察树的直径概念；不是很难；
（一开始看输入量贼多，赶紧用了输入挂，ac之后换为普通输入，居然时间还短了。(⊙﹏⊙)b 不晓得为什么【难道我用的假输入挂】）
一开始，爆内存 了。然后优化了一下才AC，代码中有错误提示；
看代码

    #include<stdio.h>
    #include <iostream>
    #include<string.h>
    #include<algorithm>
    #include<math.h>
    #include<map>
    #include<queue>
    #define LL long long
    using namespace std;
    const int MAXN =100000+100;
    const int inf =0x3f3f3f3f;
    inline int read(){
        int x=0,f=1;char ch=getchar();
        while(ch>'9'||ch<'0') {if(ch=='-') f=-1;ch=getchar();}
        while(ch>='0'&&ch<='9')  {x=x*10+ch-'0';ch=getchar();}
        return x*f;
    }
    /*-----------------------------*/
    struct Edge {
        int from,to,val,next;
    } edge[1000000+100];
    int n,m;
    int head[MAXN],edgenum;
    int par[MAXN];
    bool arr[MAXN];// 记录点是不是用过。
    void init(){
        memset(head,-1,sizeof(head));
        edgenum=0;
        for(int i=0;i<=n;i++) par[i]=i;
        memset(arr,false,sizeof(arr));
    }
    void addedge(int a,int b,int c){
        Edge e={a,b,c,head[a]};
        edge[edgenum]=e;head[a]=edgenum++;
    }

    int Find(int x){
        int r=x;
        if(x==par[x]) return x;
        while(r!=par[r]) r=par[r];
        int j=x;
        while(j!=r){
            int k=par[j];
            par[j]=r;
            j=k;
        }
        return r;
    }
    int flag=0;// 这样判定就不用再开一个边数组专门在判断一下，而且再开边数组的话，还爆内存；
    void join(int x,int y){
        x=Find(x);
        y=Find(y);
        if(x!=y) par[x]=y;
        else flag=1;
    }

    void getmap(){
        int a,b,c;
        flag=0;
       for(int i=0;i<m;i++){
        a=read();b=read();c=read();
        if(flag) continue;// 读入的时候直接判定是不是成环；
        addedge(a,b,c);
        addedge(b,a,c);
        join(a,b);
       }
    }

    int st,ans;
    int max_ans; //最大的树的直径
    int dis[MAXN],vis[MAXN];
    void spfa(int s){
        queue<int>Q;
        memset(vis,0,sizeof(vis));
        memset(dis,0,sizeof(dis));
        vis[s]=1;ans=0;Q.push(s);
        while(!Q.empty()){
            int now=Q.front();Q.pop();arr[now]=true;
            for(int i=head[now];i!=-1;i=edge[i].next){
                Edge e=edge[i];
                if(!vis[e.to]&&dis[e.to]<dis[now]+e.val){
                    dis[e.to]=dis[now]+e.val;
                    if(dis[e.to]>ans) {ans=dis[e.to];st=e.to;}
                    vis[e.to]=1;
                    Q.push(e.to);
                }
            }
        }
    }
    void solve(){
        if(flag) puts("YES");
        else {
        /* 这种情况下，就是可能为无环的非连通图。即就可以将其分为多个无环的树，
        分别求一下直径，求最大即可；可以用一个数组记录点是不是用过。*/
            for(int i=1;i<=n;i++){
            if(!arr[i]){
                spfa(i);
                spfa(st);
                max_ans=max(max_ans,ans);
                }
            }
            printf("%d\n",max_ans);
        }
    }
    int main()
    {
       while(~scanf("%d%d",&n,&m)){
        max_ans=0;
        init();
        getmap();
        solve();
       }
        return 0;
    }