树上最远点对的线性时间算法

(同步个人博客 http://sxysxy.org/blogs/40 到csdn

树上最远点对，就是给一棵树，对于树上所有点对(u, v) 中dist(u, v)的最大值。

在hihoCoder上看到了一个很妙的算法 http://hihocoder.com/problemset/problem/1050

首先我们可以很明显想到这样一个方法:对于一个节点来说，如果把它看作是整棵树的树根，从树根向下走两条不相交的路径，能到到的最深的地方(这里以树根深度为0)分别为a, b，那么树上最远点对距离的一个可能取值就是a+b(这个办法泥肯定早都想到了，并且明白，这个结果只是个局部最优解，所以说是可能的取值)。所以得到第一个方法:让每个节点都依次作为树根，进行这样的操作，得到所有局部最优解的最大值便是全局最优解。但是这样做时间复杂度是O(n^2)级别的。对于n = 10^5这样的数据显然是会time limit exceed的。但这是个方向。

现在有这样的一个结论 (截图自hihoCoder:

这样就是，相当于充分利用了子节点的信息来推出本节点的信息。有点记忆化搜索的感觉(或者叫..树上递推?)

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <cstdarg>
#include <vector>
using namespace std;
#define MAXN 100003
struct edge
{
    int from, to;
    void scan()
    {
        scanf("%d %d", &from, &to);
    }
}edges[MAXN<<1];
vector<int> G[MAXN];
typedef pair<int, int> info;
int parent[MAXN];
int deep[MAXN];

void dfs(int u, int f, int d)
{
    parent[u] = f;
    deep[u] = d;
    for(int i = 0; i < G[u].size(); i++)
    {
        int to = G[u][i];
        if(to != f)
            dfs(to, u, d+1);
    }
}

// dfs(u)返回一个二元组(a, b)，表示u可以向下深入的最远距离和次远距离(最远与次远的两条路径不相交)
// 注意a 可以等于b 这里的距离指的是"边数"
int ans = 0;
info dfs(int u)
{
    if(G[u].size() == 0)  //底层节点，边界情况
        return make_pair(0, 0);
    else
    {
        int mx1 = 0, mx2 = 0; 
        for(int i = 0; i < G[u].size(); i++)
        {
            int to = G[u][i];
            info r = dfs(to);
            if(G[u].size() == 1)  //只有一个儿子的特殊情况
            {
                ans = max(ans, r.first+1);
                return make_pair(r.first+1, 0);
            }
            //维护最大次大值
            if(r.first >= mx1)
            {
                mx2 = mx1;
                mx1 = r.first;
            }else if(r.first >= mx2)
            {
                mx2 = r.first;
            }
        }
        ans = max(ans, mx1+mx2+2);  //+2是算上本节点分别到两个子节点的距离
        return make_pair(mx1+1, mx2+1);
    }
}

int main()
{
    int n, m;
    scanf("%d", &n);
            //第一次建图，双向边
    for(int i = 1; i < n; i++)
    {
        edge &e = edges[i];
        e.scan();
        G[e.from].push_back(e.to);
        G[e.to].push_back(e.from);
    }
            //深搜处理，与树链剖分第一次dfs差不多
    dfs(1, 1, 0);

    //重新建图，保证G[u]都是u的子节点
    for(int i = 1; i <= n; i++)G[i].clear();
    for(int i = 1; i < n; i++)
    {
        edge &e = edges[i];
                //不满足就交换
        if(deep[e.from] > deep[e.to])swap(e.from, e.to);
        G[e.from].push_back(e.to); //由每条边上浅的节点指向深的节点
    }

    //第二次深搜
    dfs(1);
    printf("%d\n", ans);
    return 0;
}