hdu 2196(树上点分治）

题意：

　　n个节点无根树，求从每个节点出发的最长链

解决：

　　最长链有两种可能：1、以自身为根的子树上，从根到叶子节点的某条链。 2、 从自己出发，向上到父节点，加上父节点的最长链。

　　但是第二种情况有很多问题，首先，如果父节点的最长链是通过要求节点的话，我们就要用到父节点的次长链。并且还要判断，我们需要用的这条最长链，或者次长链，跟父节点向上到父节点的最长链的比较。

　　所以先dfs一遍处理出每个点以自身为根的子树上的最长链，次长链，以及最长链对应经过哪一个子节点。

　　再dfs一次维护出每个结点向上到父节点所能走出的最长链。

　　最终答案就是max (子树上最长链， 向上到父节点的最长链）

#include <cstdio>
#include <cstring>
#include <algorithm>

const int MAXN = 100010;

struct DPNode{
    long long first, second, fa;
    int v1;
}dp[10010];

struct Edge{
    int u, v, next;
       long long cost;
    Edge(){}
    Edge(int u, int v, long long cost, int next)
    {
        this->u = u;
        this->v = v;
        this->cost = cost;
        this->next = next;
    }
}edge[MAXN<<1];
int head[MAXN];
int tot;
int n;
bool vis[MAXN];

void addEdge(int u, int v, long long cost)
{
    edge[++tot] = Edge(u, v, cost, head[u]);
    head[u] = tot;
}

void init()
{
    tot = 1;
    memset(head, 0, sizeof head);
}

void dfs1(int u)
{
    vis[u] = true;
    dp[u].first = dp[u].second = dp[u].v1 = 0 ;
    for (int i = head[u]; i > 0; i = edge[i].next) {
        int v = edge[i].v;
        long long cost = edge[i].cost;
        if (vis[v] == false) {
            dfs1(v);
            if (dp[v].first + cost > dp[u].first) {
                dp[u].second = dp[u].first;
                dp[u].first = dp[v].first + cost;

                dp[u].v1 = v;
            }
            else if (dp[v].first + cost > dp[u].second) {
                dp[u].second = dp[v].first;
            }
        }
    }
}

void dfs2(int u)
{
    vis[u] = true;
    for (int i = head[u]; i > 0; i = edge[i].next) {
        int v = edge[i].v;
        long long cost = edge[i].cost;
        if (vis[v] == false) {
            //printf("u = %d, v = %d:
", u, v);
            if (dp[u].v1 == v) {
                dp[v].fa = cost + std::max(dp[u].fa, dp[u].second);
            }
            else {
                dp[v].fa = cost + std::max(dp[u].fa, dp[u].first);
            }
            //printf("fa = %d
", dp[v].fa);
            dfs2(v);
        }
    }
}

int main()
{
    while (~scanf("%d", &n)) {
        init();
        for (int i = 2; i <= n; ++ i) {
            int v;
            long long cost;
            scanf("%d%lld", &v, &cost);
            addEdge(i, v, cost);
            addEdge(v, i, cost);
        }
        memset(vis, false, sizeof vis);
        dfs1(1);
        memset(vis, false, sizeof vis);
//        dp[1].fa = 0;
        dfs2(1);
        for (int i = 1; i <= n; ++ i) {
            //printf("i = %d, first = %lld, second = %lld, v1 = %d fa = %lld
", i, dp[i].first, dp[i].second, dp[i].v1, dp[i].fa);
            printf("%lld
", std::max(dp[i].fa, dp[i].first));
        }
    }
}