hdu 4514(树的直径+并查集)

湫湫系列故事——设计风景线

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 3930    Accepted Submission(s): 700

Problem Description

　　随着杭州西湖的知名度的进一步提升，园林规划专家湫湫希望设计出一条新的经典观光线路，根据老板马小腾的指示，新的风景线最好能建成环形，如果没有条件建成环形，那就建的越长越好。
　　现在已经勘探确定了n个位置可以用来建设，在它们之间也勘探确定了m条可以设计的路线以及他们的长度。请问是否能够建成环形的风景线？如果不能，风景线最长能够达到多少？
　　其中，可以兴建的路线均是双向的，他们之间的长度均大于0。

 

 

Input

　　测试数据有多组，每组测试数据的第一行有两个数字n, m，其含义参见题目描述；
　　接下去m行，每行3个数字u v w，分别代表这条线路的起点，终点和长度。

　　 [Technical Specification]
　　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

 

 

Source

2013腾讯编程马拉松初赛第二场（3月22日）

 

课程设计浪费了我一个星期，一个星期没打代码了。。

这个题的话无疑就是并查集判环+树的直径。

1.首先,利用并查集判环，如果没有环，那么肯定就是 一棵树（森林）了。

2.树的直径的解法就是以任意一个点进行搜索，然后得到距离它最远的那个叶子结点，那么这个点必定是直径的"一端",证明过程的话我就不写了，然后以找到的这个点进行广搜，得到离这个叶子结点最远的那点肯定就是树的另一端。两点距离即为直径。

而这个题我先是以1点进行广搜，然后得到某个点之后再进行第二次搜索。结果太天真了，这个题的 连通分量没有说只有一个啊！！所以我们应该对每个连通分量进行广搜。

给一组测试用例：

4 2

2 3 1

2 4 1

ans:2

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
const int N = 100005;
const int M = 2000005;
int father[N];
struct Edge
{
    int v,w,next;
} edge[M];
int head[N];
int n,m,tot;
void addEdge(int u,int v,int w,int &k)
{
    edge[k].v = v,edge[k].w = w,edge[k].next = head[u],head[u] = k++;
}
int _find(int x)
{
    if(x!=father[x]) father[x] = _find(father[x]);
    return father[x];
}
void init()
{
    tot = 0;
    for(int i=1; i<=n; i++)
    {
        father[i] = i;
        head[i] = -1;
    }
}
int dis[N];
bool vis[N];
bool used[N];
void bfs(int s)
{
    memset(vis,false,sizeof(vis));
    queue<int>q;
    q.push(s);
    vis[s] = true;
    while(!q.empty())
    {
        int u = q.front();
        q.pop();
        for(int k = head[u]; k!=-1; k=edge[k].next)
        {
            int w = edge[k].w,v = edge[k].v;
            if(!vis[v])
            {
                used[v] = true;
                vis[v] = true;
                q.push(v);
                dis[v] = max(dis[v],dis[u]+w);
            }
        }
    }

}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0)
        {
            printf("0\n");
            continue;
        }
        init();
        bool flag = false;
        for(int i=1; i<=m; i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addEdge(u,v,w,tot);
            addEdge(v,u,w,tot);
            if(!flag)
            {
                int ru = _find(u);
                int rv = _find(v);
                if(ru==rv) flag = true;
                else father[ru] = rv;
            }
        }
        if(flag)
        {
            printf("YES\n");
            continue;
        }
        memset(used,false,sizeof(used));
        int res = 0;
        for(int i=1; i<=n; i++)
        {
            if(used[i]) continue;
            int s=i,t;
            used[s] = true;
            memset(dis,0,sizeof(dis));
            bfs(s);
            int len = 0;
            for(int i=1; i<=n; i++)
            {
                if(dis[i]>len)
                {
                    len = dis[i];
                    t = i;
                }
            }
            memset(dis,0,sizeof(dis));
            bfs(t);
            int MAX = 0;
            for(int i=1; i<=n; i++)
            {
                MAX = max(dis[i],MAX);
            }
            res = max(res,MAX);

        }
        printf("%d\n",res);
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/liyinggang/p/5616453.html