hdu 4514 湫湫系列故事――设计风景线（求树的直径）

随着杭州西湖的知名度的进一步提升，园林规划专家湫湫希望设计出一条新的经典观光线路，根据老板马小腾的指示，新的风景线最好能建成环形，如果没有条件建成环形，那就建的越长越好。 
　　现在已经勘探确定了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

求树的直径，用再次bfs。证明见：树的直径（最长路） 的详细证明（转）

首先先判环，如果有环直接输出YES，用并查集就好。如果没有环，那么就是一棵树，然后最长的就是树的直径，这个题注意少开内存，容易超内存，

还有用C++交用的少一些，我用G++交的卡在32764K，限制是32768K。。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <string>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <cstring>
#include <set>
#include <queue>
#include <algorithm>
#include <vector>
#include <map>
#include <cctype>
#include <cmath>
#include <stack>
//#include <tr1/unordered_map>
#define freopenr freopen("in.txt", "r", stdin)
#define freopenw freopen("out.txt", "w", stdout)
using namespace std;
//using namespace std :: tr1;
 
typedef long long LL;
typedef pair<int, int> P;
const int INF = 0x3f3f3f3f;
const double inf = 0x3f3f3f3f3f3f;
const LL LNF = 0x3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double eps = 1e-8;
const int maxn = 1e5 + 5;
const LL mod = 10000000000007;
const int N = 1e6 + 5;
const int dr[] = {-1, 0, 1, 0, 1, 1, -1, -1};
const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1};
const char *Hex[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"};
inline LL gcd(LL a, LL b){  return b == 0 ? a : gcd(b, a%b); }
int n, m;
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
inline int Min(int a, int b){ return a < b ? a : b; }
inline int Max(int a, int b){ return a > b ? a : b; }
inline LL Min(LL a, LL b){ return a < b ? a : b; }
inline LL Max(LL a, LL b){ return a > b ? a : b; }
inline bool is_in(int r, int c){
    return r >= 0 && r < n && c >= 0 && c < m;
}
vector<P> G[maxn];
int p[maxn], dp[maxn];
bool vis[maxn], viss[maxn];
 
int Find(int x){ return x == p[x] ? x : p[x] = Find(p[x]);  }
 
int bfs(int root){
    memset(vis, false, sizeof vis);
    memset(dp, 0, sizeof dp);
    queue<int> q;
    q.push(root);
    vis[root] = viss[root] = true;
    int ans = root, maxx = 0;
 
    while(!q.empty()){
        int u = q.front();  q.pop();
        for(int i = 0; i < G[u].size(); ++i){
            P p = G[u][i];
            int v = p.first;
            int w = p.second;
            if(vis[v])  continue;
            vis[v] = viss[v] = true;
            dp[v] = dp[u] + w;
            if(maxx < dp[v]){
                maxx = dp[v];
                ans = v;
            }
            q.push(v);
        }
    }
    return ans;
}
 
int solve(int root){
    int u = bfs(root);
    int v = bfs(u);
    return dp[v];
}
 
int main(){
    while(scanf("%d %d", &n, &m) == 2){
        int u, v, c;
        for(int i = 1; i <= n; ++i)  G[i].clear(), p[i] = i;
        bool ok = false;
        for(int i = 0; i < m; ++i){
            scanf("%d %d %d", &u, &v, &c);
            int x = Find(u);
            int y = Find(v);
            if(x != y)  p[y] = x;
            else ok = true;
            G[u].push_back(P(v, c));
            G[v].push_back(P(u, c));
        }
        if(ok){  puts("YES");  continue; }
 
        memset(viss, false, sizeof viss);
        int ans = 0;
        for(int i = 1; i <= n; ++i)
            if(!viss[i])  ans = Max(ans , solve(i));
        printf("%d
", ans);
    }
    return 0;
}

如果没想到上面的方法，用dp也是可以做的。

树的直径是其子树直径的最大值，也是叶子节点中的距离的最大值。

dp[i]表示子树i 的高度

枚举所有的节点u，找出以u为中间节点的距离的最大值。

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#include<vector>
using namespace std;
struct node
{
    int v,w;
    node(int _v, int _w) : v(_v), w(_w) {}
};
vector<node> e[100001];
int n,m,fa[100001],dp[100001],ans;
int find(int x)
{
    if(x!=fa[x])
        fa[x]=find(fa[x]);
    return fa[x];
}
void dfs(int u,int father)
{
    int maxx=0;
    for(int i=0;i<e[u].size();i++)
    {
        int v=e[u][i].v;
        int w=e[u][i].w;
        if(v==father)
            continue;
        dfs(v,u);
        ans=max(ans,dp[v]+maxx+w);
        maxx=max(maxx,dp[v]+w);
    }
    dp[u]=maxx;
}
void slove()
{
    for(int i=1;i<=n;i++)
    {
        if(dp[i]==-1)
            dfs(i,-1);
    }
    printf("%d
",ans);
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        bool flag=false;
        ans=0;
        for(int i=1;i<=n;i++)
            fa[i]=i,dp[i]=-1,e[i].clear();
        for(int i=1;i<=m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            e[x].push_back(node(y,z));
            e[y].push_back(node(x,z));
            if(flag)
                continue;
            int fx,fy;
            fx=find(x),fy=find(y);
            if(fx!=fy)
            {
                fa[fx]=fy;
            }
            else
            {
                flag=true;
                continue;
            }
        }
        if(flag)
        {
            printf("YES
");
            continue;
        }
        slove();
    }
    return 0;
}