树的重心&&树的直径

树的重心

树的重心定义为：找到一个点,其所有的子树中最大的子树节点数最少,那么这个点就是这棵树的重心,删去重心后，生成的多棵树尽可能平衡.
实际上树的重心在树的点分治中有重要的作用, 可以避免N^2的极端复杂度（从退化链的一端出发），保证NlogN的复杂度, 利用树型dp可以很好地求树的重心.求树的重心

模板：
https://vjudge.net/problem/POJ-3107
//树的重心可能有两个
//做法：从任意点出发，dfs遍历整棵树，在回溯的过程中，维护每个子树的结点个数以及这个结点的最大子树节点个数

#include<iostream>
#include<cstdio>
#include<string.h>
#include<time.h>
#include<algorithm>
using namespace std;
const int manx=5e4+10;
const int INF=1e9;
int head[manx],dp[manx][2],vs[manx];//0表示子树结点个数，1表示最大子树结点个数
int n,cou=0,ans=INF,root1=0,root2=0,flag=0;
struct node
{
    int e,before;
}edge[manx<<1];
void add(int s,int e)
{
    edge[cou]=node{e,head[s]};
    head[s]=cou++;
}
void dfs(int root)
{
    for(int i=head[root];~i;i=edge[i].before)
    {
        int nson=edge[i].e;
        if(!vs[nson])
        {
            vs[nson]=1;
            dfs(nson);
            dp[root][0]+=dp[nson][0];
            dp[root][1]=max(dp[root][1],dp[nson][0]);
        }
    }
    dp[root][0]++;
    dp[root][1]=max(dp[root][1],n-dp[root][0]);
    if(dp[root][1]<ans)
    {
        flag=0;
        ans=dp[root][1];
        root1=root;
    }
    else if(dp[root][1]==ans)
    {
        flag=1;
        root2=root;
    }
}
int main()
{
    int s,e;
    scanf("%d",&n);
    memset(head,-1,sizeof(head));
    memset(dp,0,sizeof(dp));
    memset(vs,0,sizeof(vs));
    for(int i=1;i<n;i++)
    {
        scanf("%d%d",&s,&e);
        add(s,e);
        add(e,s);
    }
    dfs(1);
    if(!flag)
        printf("%d\n",root1);
    else
        printf("%d %d\n",min(root1,root2),max(root1,root2));
}

树的直径

定义:
一棵树的直径就是这棵树上存在的最长路径。
求法1:
两次dfs或bfs。第一次任意选一个点进行dfs(bfs)找到离它最远的点，此点就是最长路的一个端点，再以此点进行dfs（bfs），找到离它最远的点，此点就是最长路的另一个端点，于是就找到了树的直径。树的直径求法及证明
求法2：
设置状态dp[u][2]
dp[u][0]表示距离u的最长距离，dp[u][1]表示距离u的次长距离（与最长距离的节点不在同一颗子树上）然后状态方程为
ans=(ans,dp[u][0]+dp[u][1])ans为树的直径答案树的直径（树形dp）

另外数的直径这里有一个引理，树的所有直径拥有相同的中点
求法二有两种写法，但都在再回溯时维护最长链：
模板：
http://poj.org/problem?id=1985
1、递归出去时维护每个点深度，回溯时维护最大深度

void dfs(int now,int fa)
{
    int flag=0;
    for(int i=head[now];~i;i=edge[i].before)
    {
        int net=edge[i].e;
        if(net==fa)continue;
        flag=1;
        deep[net]=deep[now]+edge[i].len;
        dfs(net,now);
        ans=max(ans,dp[now]+dp[net]-2*deep[now]);
        dp[now]=max(dp[now],dp[net]);
    }
    if(!flag)
    {
        dp[now]=deep[now];
        ans=max(ans,dp[now]);
        return;
    }
}

2、只在回溯时维护最远和次远距离（离当前结点最远/次远的叶子结点）

void dfs(int now,int fa)
{
    for(int i=head[now];~i;i=edge[i].before)
    {
        int net=edge[i].e;
        int nlen=edge[i].len;
        if(net==fa)continue;
        dfs(net,now);
        if(dp[now][0]<dp[net][0]+nlen)
        {
            dp[now][1]=dp[now][0];
            dp[now][0]=dp[net][0]+nlen;
        }
        else if(dp[now][1]<dp[net][0]+nlen)
            dp[now][1]=dp[net][0]+nlen;
    }
    ans=max(ans,dp[now][0]+dp[now][1]);
}

整体代码：

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
const int manx=4e4+10;
const int INF=0x3fffffff;
int n,m,cou,ans;
int deep[manx],dp[manx],head[manx];//dp存最大深度
struct node
{
    int e,len,before;
    node(int a=0,int b=0,int c=0):e(a),len(b),before(c){}
}edge[manx<<1];
void add(int s,int e,int len)
{
    edge[cou]=node(e,len,head[s]);
    head[s]=cou++;
}
void init()
{
    cou=0;
    ans=0;
    memset(head,-1,sizeof(head));
    memset(dp,0,sizeof(dp));
}
void dfs(int now,int fa)
{
    int flag=0;
    for(int i=head[now];~i;i=edge[i].before)
    {
        int net=edge[i].e;
        if(net==fa)continue;
        flag=1;
        deep[net]=deep[now]+edge[i].len;
        dfs(net,now);
        ans=max(ans,dp[now]+dp[net]-2*deep[now]);
        dp[now]=max(dp[now],dp[net]);
    }
    if(!flag)
    {
        dp[now]=deep[now];
        ans=max(ans,dp[now]);
        return;
    }
}
int main()
{
    int a,b,c;
    char d[2];
    init();
    scanf("%d%d",&n,&m);
    for(int i=0;i<m;i++)
    {
        scanf("%d%d%d%s",&a,&b,&c,d);
        add(a,b,c);
        add(b,a,c);
    }
    deep[1]=0;
    dfs(1,0);
    printf("%d\n",ans);
    return 0;
}

例题1：https://codeforces.com/contest/1294/problem/F
两次dfs解法：F. Three Paths on a Tree
例题2：https://www.oj.swust.edu.cn:50443/problem/show/2853(树的直径+贪心)
例题3：树上子链：https://ac.nowcoder.com/acm/contest/4462/B

附：