树的直径 学习笔记1（入门）

 POJ - 2631 Roads in the North：

题目大意：给你一棵树，求这棵树的直径。

树的直径：树中最长的简单路径。

简单路径：路径上各点均不重复。

以下证明内容转自https://www.cnblogs.com/a-clown/p/6131346.html

这里给出树的直径的证明：
　　主要是利用了反证法：
　　假设 s-t这条路径为树的直径，或者称为树上的最长路
　　现有结论，从任意一点u出发搜到的最远的点一定是s、t中的一点，然后再从这个最远点开始搜，就可以搜到另一个最长路的端点，即用两遍广搜就可以找出树的最长路
　　证明：
 　　　　1.设u为s-t路径上的一点，结论显然成立，否则设搜到的最远点为T则   dis(u,T) >dis(u,s)     且  dis(u,T)>dis(u,t)   则最长路不是s-t了，与假设矛盾
 　　　　2.设u不为s-t路径上的点
    　　　　首先明确，假如u走到了s-t路径上的一点，那么接下来的路径肯定都在s-t上了，而且终点为s或t，在1中已经证明过了
    　　　　所以现在又有两种情况了：
   　　 　　　　1：u走到了s-t路径上的某点，假设为X，最后肯定走到某个端点，假设是t ，则路径总长度为dis(u,X)+dis(X,t)
   　　 　　　　2：u走到最远点的路径u-T与s-t无交点，则dis(u-T) >dis(u,X)+dis(X,t);显然，如果这个式子成立，
    　　　　　　则dis(u,T)+dis(s,X)+dis(u,X)>dis(s,X)+dis(X,t)=dis(s,t)最长路不是s-t矛盾
求树的直径用2次bfd和2次dfs都可以。

使用优先队列需要重载结构体（AC）：  

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
struct node
{
    int x, sum;
    bool operator < (const node b)const
    {
        return this->sum > b.sum;
    }
    node(int xi, int sumi){x = xi; sum = sumi;}
};
struct nod
{
    int v, w;
}edge[20005];
vector<int>mp[20005];
priority_queue<struct node>qu;
int vis[20005] = {0};
int main()
{
    int s, u, v, w, len, po = 1, i;
    while(scanf("%d %d %d", &u, &v, &w) != EOF)
    {
        //if(u == -1 && v == -1 && w == -1)break;
        s = u;
        edge[po].v = v, edge[po++].w = w;
        mp[u].push_back(po - 1);
        edge[po].v = u, edge[po++].w = w;
        mp[v].push_back(po - 1);
    }
    qu.push(node(s, 0));
    vis[s] = 1;
    while(!qu.empty())
    {
        node p = qu.top();
        qu.pop();
        u = p.x;
        s = u;
        //cout << p.x << " " << p.sum << endl;
        len = mp[u].size();
        for(i = 0; i < len; i++)
        {
            v = edge[mp[u][i]].v, w = edge[mp[u][i]].w;
            if(!vis[v])qu.push(node(v, p.sum + w)), vis[v] = 1;
        }
    }
    memset(vis, 0, sizeof(vis));
    qu.push(node(s, 0));
    vis[s] = 1;
    while(!qu.empty())
    {
        node p = qu.top();
        qu.pop();
        u = p.x;
        s = p.sum;
        //cout << u << " " << s << endl;
        len = mp[u].size();
        for(i = 0; i < len; i++)
        {
            v = edge[mp[u][i]].v, w = edge[mp[u][i]].w;
            if(!vis[v])qu.push(node(v, p.sum + w)), vis[v] = 1;
        }
    }
    printf("%d\n", s);
}

另一种思路（可以处理负边）（树形DP）：

树的直径必然是树上某一个点开始往下的最长链和次长链之和。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <iostream>
using namespace std;
struct node
{
    int v, w;
}edge[20005];
vector<int>mp[20005];
int dp1[20005] = {0}, dp2[20005] = {0};
int vis[20005] = {0};
void slove(int u)
{
    //if(u == 1)cout << u <<"::"<< endl;
    int len = mp[u].size(), i;
    //if(u == 1)cout << "len = " << len << endl;
    for(i = 0; i < len; i++)
    {
        int v = edge[mp[u][i]].v, w = edge[mp[u][i]].w;
        if(vis[v] != 0)continue;
        vis[v] = 1;
        slove(v);
        if(dp1[u] < dp1[v] + w)dp2[u] = dp1[u], dp1[u] = dp1[v] + w;
        else if(dp1[v] + w > dp2[u])dp2[u] = dp1[v] + w;
        //if(u == 1)cout << v << " " <<dp1[u] << dp2[u] << endl;
    }
    return ;
}
int main()
{
    int s, u, v, w, len, po = 1, i;
    while(scanf("%d %d %d", &u, &v, &w) != EOF)
    {
        //if(u == -1 && v == -1 && w == -1)break;
        s = u;
        edge[po].v = v, edge[po++].w = w;
        mp[u].push_back(po - 1);
        edge[po].v = u, edge[po++].w = w;
        mp[v].push_back(po - 1);
    }
    vis[s] = 1;
    slove(s);
    //for(i = 1; i <= 15; i++)cout << i << " " << dp1[i] << " " << dp2[i] << endl;
    int ans = dp1[1] + dp2[1];
    for(int i = 1; i <= 10000; i++)ans = max(ans, dp1[i] + dp2[i]);
    printf("%d\n", ans);
}