算法提高——树上DP（树的直径）

前言

树的直径是图论里边非常高的考察点并且是入门树形dp的基础，竞赛的同学务必重视。

一、什么是树的直径？

树上最远两点（叶子结点）的距离。

二、例题

大臣的旅费
很久以前，T王国空前繁荣。

为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。

为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。

同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。

J是T国重要大臣，他巡查于各大城市之间，体察民情。

所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。

他有一个钱袋，用于存放往来城市间的路费。

聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。

J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？

输入格式
输入的第一行包含一个整数 n，表示包括首都在内的T王国的城市数。

城市从 1 开始依次编号，1 号城市为首都。

接下来 n−1 行，描述T国的高速路（T国的高速路一定是 n−1 条）。

每行三个整数 Pi,Qi,Di，表示城市 Pi 和城市 Qi 之间有一条双向高速路，长度为 Di 千米。

输出格式
输出一个整数，表示大臣J最多花费的路费是多少。

数据范围
1≤n≤105,
1≤Pi,Qi≤n,
1≤Di≤1000
输入样例：
5
1 2 2
1 3 1
2 4 5
2 5 4
输出样例：
135

题目链接： 大臣的旅费
题目来源：第四届蓝桥杯省赛C++A组

题目分析： 直接开门见山，看了题意应该知道了这就是求树的直径。求树的直径我们有两种方法。

解法一：遍历两边dfs，第一次随便找一个点任意搜，搜完后取出权值最大的点，此时这个点必然在树的直径上，在从这个点搜权值最大的点，得到答案就是树的直径。

反证法证明：在第一次搜索时，假设树的直径就是c->d线段，我们从a搜到了b点，而且因为整个图联通，所以a点必然存在一条路径可以到达d的，而又因为从a点出发到b点是最大值，因此线段2>=线段3+线段5，根据这个式子我们可以延展一下，因为线段2>=线段3+线段5，所以我们可以推出线段2+线段3>=线段5(这里很好理解对不对，因为线段2>=线段3+线段5 -> 线段2-线段3>=线段5，相减都大于了，那相加就更大了)，因此根据这个结论，我们可以知道c到b的线段是大于c到d的线段的，所以我们就推出来b点出发必然可以到达直径最远的一个点。

题解代码：

#include 
#include 
#include 

using namespace std;

const int N = 100010;

typedef pair<int,int> PII;
typedef long long ll;

vector<PII> v[N];
int dist[N];

void dfs(int u,int f)
{
    for (int i = 0;i < v[u].size(); i ++ )
    {
        int t = v[u][i].first,w = v[u][i].second;
        if(t != f)
        {
            dist[t] = dist[u] + w;
            dfs(t,u);
        }
    }
}

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i < n; i ++ )
    {
        int a,b,c;
        cin >> a >> b >> c;
        v[a].push_back({b,c});
        v[b].push_back({a,c});
    }

    dfs(1,-1);

    int root = 0,maxd = 0;
    for (int i = 1; i <= n; i ++ )
    {
        if(dist[i] > maxd)
        {
            maxd = dist[i];
            root = i;
        }
    }
    memset(dist,0,sizeof dist);
    dfs(root,-1);
    maxd = 0;
    for (int i = 1; i <= n; i ++ )
        if(dist[i] > maxd)
        {
            maxd = dist[i];
        }
    ll res = 0;
    for (int i = 1; i <= maxd; i ++ ) res += i + 10;

    cout<<res<<endl;

    return 0;

}

解法二：我们直接寻找任意一个点，并且从该点出发求出每个点的最大路径值和次大路径值，树的直径就似乎其中一个点的最大路径值+次大路径值。该解法的好处是，即使在出现负权边也能解决，并且此解法也是入门树上dp的基础。

#include 
#include 
#include 

using namespace std;

const int N = 100010;

typedef pair<int,int> PII;
typedef long long ll;

vector<PII> v[N];
int maxd;

int dfs(int u,int f)
{
    int d1 = 0,d2 = 0;
    for (int i = 0;i < v[u].size(); i ++ )
    {
        int t = v[u][i].first,w = v[u][i].second;
        if(t != f)
        {
            int d = dfs(t,u) + w;
            if(d > d1) d2 = d1,d1 = d;
            else if(d > d2) d2 = d;
        }
    }

    maxd = max(d1 + d2,maxd);
    return d1;
}

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i < n; i ++ )
    {
        int a,b,c;
        cin >> a >> b >> c;
        v[a].push_back({b,c});
        v[b].push_back({a,c});
    }

    dfs(1,-1);
    ll res = 0;
    for (int i = 1; i <= maxd; i ++ ) res += i + 10;

    cout<<res<<endl;

    return 0;

}

类似题目推荐：网络延时
题目来源：第四次CCF计算机软件能力认证

三、树上DP

旅游规划
W 市的交通规划出现了重大问题，市政府下定决心在全市各大交通路口安排疏导员来疏导密集的车流。

但由于人员不足，W 市市长决定只在最需要安排人员的路口安排人员。

具体来说，W 市的交通网络十分简单，由 n 个交叉路口和 n−1 条街道构成，交叉路口路口编号依次为 0,1,…,n−1 。

任意一条街道连接两个交叉路口，且任意两个交叉路口间都存在一条路径互相连接。

经过长期调查，结果显示，如果一个交叉路口位于 W 市交通网最长路径上，那么这个路口必定拥挤不堪。

所谓最长路径，定义为某条路径 p=(v1,v2,…,vk)，路径经过的路口各不相同，且城市中不存在长度大于 k 的路径（因此最长路径可能不唯一）。

因此 W 市市长想知道哪些路口位于城市交通网的最长路径上。

输入格式
第一行包含一个整数 n。

之后 n−1 行每行两个整数 u,v，表示编号为 u 和 v 的路口间存在着一条街道。

输出格式
输出包括若干行，每行包括一个整数——某个位于最长路径上的路口编号。

为了确保解唯一，请将所有最长路径上的路口编号按编号顺序由小到大依次输出。

数据范围
1≤n≤2×105
输入样例：
10
0 1
0 2
0 4
0 6
0 7
1 3
2 5
4 8
6 9
输出样例：
0
1
2
3
4
5
6
8
9

思路分析： 观察题意，我们不难发现题目要求的其实就是树的直径，但是和上面题目不一样的是，我们需要把树直径上的所有点都找出来，并且是包括其它直径相等的点也需要找出来。其实思路很简单，既然我们知道了树的直径，那在这些直径上的点，以他们为根结点延伸出去的最长路径和次长路径之和必然等于直径，因此，我们只需要找到每个结点的最长路径和次长路径。

在这里，我们可以用两个数组d1，d2来存放每个点的最长路径和次长路径。但是只是通过我们上面那个题的解法的话，存放的路径就只是以点向下的路径长度，并不包括结点往上的其它路径。假设现在u点，那我们做一次查找树的直径，那记录的只有u点往下的路劲长度，d1[u] = 2,d2[u] = 1,但显然结果不是这样对吧，因为u点往上的路径显然比我们下面两个路径长多了。因此，我们还需在遍历一次dfs，来记录up的值，up数组存放的就是每个点向上的路径的最大值。

还没完，up数组不是那么好处理，我们为了确保时间复杂度在合法范围，对于up数组我们采取自上而下的搜索方法，在遍历时我们每个结点有两种情况，就是当走下去的路径就是当前结点取得最大路劲的情况，因此，此时我们需要比较up的路径和次长路径大小 up[t] = max(up[u],d2[u]) + w,如果不是，那么up就需要与最大路径比较，up[t] = (up[u],d1[u]) + w。而判断是否为最大路径，我们可以用过p数组标记即可。

到此题目解析完毕,时间复杂度O(n)

#include 
#include 
#include 
using namespace std;

const int N = 200010;

vector<int> v[N];
int d1[N],d2[N],up[N],p[N];
int maxd;

int dfs_first(int u,int f)
{
    for (int i = 0; i < v[u].size(); i ++ )
    {
        int t = v[u][i];
        if(t != f)
        {
            int d = dfs_first(t,u);
            if(d > d1[u])
            {
                d2[u] = d1[u],d1[u] = d;
                p[u] = t;                     //存储每个点的最大路径上第一个点的坐标
            }
            else if(d > d2[u]) d2[u] = d;
        }
    }
    maxd = max(d1[u] + d2[u], maxd);
    return d1[u] + 1;
}

void dfs_second(int u,int f)
{
    for (int i = 0; i < v[u].size(); i ++ )
    {
        int t = v[u][i];
        if(t != f)
        {
            up[t] = up[u] + 1;
            if(p[u] == t) up[t] = max(up[t],d2[u] + 1);       //如果此时走的点是最大路径，则更新次大值
            else up[t] = max(up[t],d1[u] + 1);                //否则更新为最大值
            dfs_second(t,u);
        }
    }
}

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i < n; i ++ )
    {
        int a,b;
        cin >> a >> b;
        v[a].push_back(b);
        v[b].push_back(a);
    }
    
    dfs_first(0,-1);
    dfs_second(0,-1);
    
    for (int i = 0 ; i < n; i ++ )
    {
        int d[3] = {d1[i],d2[i],up[i]};
        sort(d,d + 3);
        if(d[2] + d[1] == maxd) cout<<i<<endl;
    }
    
    return 0;
}

总结

树上DP已经是很难的内容了，想要真正掌握还需要勤加练习。