DP_树形 DP_树的中心

原题链接：树的中心

做法：
a、大致想法是进行两遍dfs，找到每个节点的向下的最长路径 di 和向上的最长路径 ui ，然后枚举每一个点，再找到min(max( di , ui ))

b、补充细节：
1）根据树的直径求法，向下求的时候会有一个最大值和次大值，例如节点 i 的 d1i , d2i，当更新 i 的某个子节点 j 的 uj 时候，一般情况是 w(i,j) + d1i ，但是如果能过达到 d1i 的路径经过 j 点，那么就要w(i,j) + d2i ，所以需要一个节点记录 d1 由谁更新而来。
2）因为边权有负数，所以初值是-INF，但是要注意叶节点的特殊性，对于叶节点 i ，d1i , d2i均为0，并且在枚举的时候只比较 ui 。

代码：

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

using namespace std;

const int N=10010,INF=0x3f3f3f3f;

int e[N*2],idx,ne[N*2],h[N];
int d1[N],d2[N],up[N],p[N];
int n,w[N*2];
bool leaf[N];

void add(int a,int b,int c){
    e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}

int dfs_d(int u,int father){
    d1[u]=d2[u]=-INF;
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];
        if(j==father) continue;
        int d=dfs_d(j,u)+w[i];
        if(d>d1[u]){
            d2[u]=d1[u],d1[u]=d;
            p[u]=j;
        }
        else if(d>d2[u]){
            d2[u]=d;
        }
    }
    if(d1[u]==-INF){
        d1[u]=d2[u]=0;
        leaf[u]=true;
    }
    return d1[u];
}

void dfs_u(int u,int father){
    for(int i=h[u];i!=-1;i=ne[i]){
        int j=e[i];
        if(j==father) continue;
        
        if(p[u]!=j){
            up[j]=max(up[u],d1[u])+w[i];
        }
        else{
            up[j]=max(up[u],d2[u])+w[i];
        }
        dfs_u(j,u);
    }
}

int main(){
    cin>>n;
    int a,b,c;
    memset(h,-1,sizeof(h));
    memset(leaf,false,sizeof(leaf));
    for(int i=1;i<=n;i++){
        scanf("%d%d%d",&a,&b,&c);
        add(a,b,c);
        add(b,a,c);
    }
    
    dfs_d(1,-1);
    dfs_u(1,-1);
    
    int res=d1[1];
    for(int i=2;i<=n;i++){
        if(leaf[i]) res=min(res,up[i]);
        else res=min(res,max(up[i],d1[i]));
    }
    cout<<res<<endl;
    return 0;
}