树形dp

acwing 1072.树的最长路径

https://www.acwing.com/problem/content/1074/

如何在一颗有边权的树上求树的直径？方法是：任取树上一点，求出距离该点距离的最大值和次大值，相加即是路径， 遍历所有点，求出最长的路径。

如何在一颗没有边权的树上求树的直径？方法是：任取树上的一个点$a$, 找到离该点最远的一个点$u$，那么$u$一定是某一条直径的端点，从$u$开始找到离$u$最远的点$v$，那么$u-v$就是树的一条直径。将所有的直径取最大值，就是树的最长路径。（本题的做法是在有边权的树上求树的直径）

核心在于为什么$u$一定是某一条直径的端点。

 

证明：

（1）当$au$和$bc$不相交时：假设$a$为树上的任意一点，$u$为离$a$最远的一点并且$u$不是某一直径的端点，$bc$为树上的一条直径。因为是一颗树，所以是连通的，所以$au$和$bc$中间有两个点相连。因为$u$是离$a$最远的一个点，所以①>=②+③，所以①+②>=③，所以存在一一条路径$bu$比当前的直径$bc$更长，矛盾。所以$u$一定是某一直径的端点。

（2）当$au$和$bc$相交时：因为$u$是离$a$最远的一点，所以④>=③，那么①+④>=①+③, 与$bc$是直径矛盾，所以$u$一定是某一直径的端点。

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

using namespace std;

const int N = 10010, M = 2 * N;
int e[M], ne[M], h[M], w[M], idx;
int ans;

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

int dfs(int u, int father)
{
    int dist = 0; // 表示从当前点往下走的最大长度
    int d1 = 0, d2 = 0;

    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (j == father) continue;
        int d = dfs(j, u) + w[i];
        dist = max(dist, d);

        if (d >= d1) d2 = d1, d1 = d;
        else if (d > d2) d2 = d;
    }

    ans = max(ans, d1 + d2);

    return dist;
}



int main(){
    int n;
    cin >> n;
    memset(h, -1, sizeof h);
    for(int i = 0 ; i < n - 1 ; i ++)
    {
        int a, b, c;
        cin >> a >> b >> c;
        add(a, b, c), add(b, a, c);
    }
    
    dfs(1, -1);
    
    cout << ans << endl;
    
    return 0;
}

 

 

acwing 1073.树的中心

https://www.acwing.com/problem/content/1075/

对于一颗树，要求中心。需要求出每个点向下的最长路径和向上的最长路径。向下的最长路径只需用$dfs$预处理一遍就可以得出。但是对于向上的最长路径情况有些不同，例如对于$j$向上的最长路径来说，是要分三种情况的：

①$j$向上的最长路径是$u$向下的最长路径 + $s$。

②$j$向上的最长路径是$u$向下的次长路径 + $s$。

③$j$向上的最长路径是$u$向上的最长路径 + $s$。

对于①和②，情况是互斥的。当$u$向下的最长路径是经过j的，我们就只能使用$u$向下的次长路径，反之我们使用$u$向下的最长路径。

所以结论是在$dfs$时，需要用一个数组记录最长路径是由哪个节点转移。如果是$j$节点转移过来，就比较$u$向下的次长路径和$u$向上的最长路径的大小。如果不是$j$节点转移过来，就比较$u$向下的最长路径和$u$向上的最长路径大小。

还需要注意的是：叶子节点没有向下的路径，根节点没有向上的路径。

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

using namespace std;

const int N = 10010, INF = 0x3f3f3f3f;
int d1[N], d2[N], up[N], p[N];
int e[2 * N], ne[2 * N], h[N], w[2 * N], idx;
bool is_leaf[N];
int 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 fa)
{
    d1[u] = d2[u] = -INF;
    for(int i = h[u] ; ~i ; i = ne[i])
    {
        int j = e[i];
        if(j == fa)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;
        is_leaf[u] = true;
    }
    return d1[u];
}

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

int main(){
    cin >> n;
    memset(h, -1, sizeof h);
    for(int i = 0 ; i < n - 1 ; i ++)
    {
        int a, b, c;
        cin >> 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(is_leaf[i])res = min(res, up[i]);//叶子没有向下的路径
        else res = min(res, max(up[i], d1[i]));
        
    cout << res << endl;
    return 0;
}

 

acwing 1075.数字转换

https://www.acwing.com/problem/content/1077/

题意：一个数$x$和其约数之和（不包括自身）的$y$可以相互转移，求转移最多次数。就是求树的直径。

①如何建树：分析可知，每一个数的约数之和是不变的。所以每个数有且仅有一个约数之和，那么我们可以将每个数的约数之和$y$当做父节点，$x$当做子节点，这样就能建出树。

②如何处理约数之和：朴素的做法是遍历每一个数，求其约数相加，时间复杂度是$O(n\sqrt {n})$。不是很理想。事实上我们可以枚举一个数是哪些数的约数，这样能将时间复杂度降到$O(nlogn)$。

③可以知道，所有的合数最后一定会指向一个质数，而所有的质数最后都会指向$1$，所以建出来树是以$1$为根节点，只需从根节点开始$dfs$就可以。

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

using namespace std;

const int N = 50010;
int n;
int e[2 * N], ne[2 * N], h[N], idx;
int sum[N];
bool st[N];
int ans;

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

int dfs(int u)//因为建出的数是单向向下的树，不会死循环
{
    int d1 = 0, d2 = 0;
    for(int i = h[u] ; ~i ; i = ne[i])
    {
        int j = e[i];
        int d = dfs(j) + 1;
        if(d > d1)d2 = d1, d1 = d;
        else if(d > d2)d2 = d;
        
        ans = max(ans, d1 + d2);
    }
    return d1;
}

int main(){
    cin >> n;
    for(int i = 1 ; i <= n ; i ++)
        for(int j = 2 ; j <= n / i ; j ++)//因为约数不包括自身，所以j从2开始枚举
            sum[i * j] += i;
    
    memset(h, -1, sizeof h);
    for(int i = 2 ; i <= n ; i ++)//因为sum[1] = 0, 不能有0->1，题目要求
        if(sum[i] < i)
            add(sum[i], i);
            
    dfs(1);
    
    cout << ans << endl;
    return 0;
}

 

 

acwing 285.没有上司的舞会

https://www.acwing.com/problem/content/287

题意：每条边上至多选择一个点，求最大权值。

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

const int N = 6e3+10;
using namespace std;
int n ;
int happy[N];
int f[N][2];
int has_father[N];
int e[N],ne[N],idx,h[N];

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

void dfs(int u){
    f[u][1] = happy[u];
    
    for(int i = h[u]; i != -1 ; i = ne[i]){
        int j = e[i];
        dfs(j);
        
        f[u][1] += f[j][0];
        f[u][0] += max(f[j][1] , f[j][0]);
    }
}


int main(){
    cin>>n;
    memset(h, -1, sizeof h);
    for(int i = 1 ; i <= n ; i ++)//这里从1开始因为节点的标号是从1开始而不是从0开始
        cin >> happy[i];
    for(int i = 0 ; i < n - 1 ; i ++)
    {
        int a, b;
        cin >> a >> b;
        has_father[a] = 1;
        add(b, a);
    }
    int root = 1;
    while(has_father[root])root ++;
    dfs(root);
    cout << max(f[root][0], f[root][1]) << endl;
    return 0;
}

 

 

acwing 323.战略游戏

https://www.acwing.com/problem/content/325/

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>

using namespace std;

const int N = 1510;
int e[N * 2], ne[N * 2 ], h[N], idx;
int f[N][2], st[N];
int n;
int root;

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

void dfs(int u)
{
    f[u][1] = 1;
    f[u][0] = 0;
    for(int i = h[u] ; ~i ; i = ne[i])
    {
        int j = e[i];
        dfs(j);
        
        f[u][1] += min(f[j][0], f[j][1]);
        f[u][0] += f[j][1];
    }
}

int main(){
    while(cin >> n)
    {
        memset(st, 0, sizeof st);
        memset(h, -1, sizeof h);
        idx = 0;
        for(int i = 0 ; i < n ; i ++)
        {
            int id, cnt;
            scanf("%d:(%d)", &id, &cnt);
            while(cnt --)
            {
                int x;
                cin >> x;
                add(id, x);
                st[x] = true;
            }
        }
        
        root = 0;
        while(st[root])root ++;
        
        dfs(root);
        
        cout << min(f[root][1], f[root][0]) << endl;
        
    }
    return 0;
}

 

 

acwing 1077.皇宫守卫

https://www.acwing.com/problem/content/1079/

 

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

using namespace std;

const int N = 1510;
int e[N], ne[N], h[N], idx;
int w[N];
bool st[N];
int f[N][3];
int n;

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

void dfs(int u)
{
    f[u][2] = w[u];
    f[u][0] = 0;
    for(int i = h[u] ; ~i ; i = ne[i])
    {
        int j = e[i];
        dfs(j);
        
        f[u][2] += min(min(f[j][0], f[j][1]), f[j][2]);
        f[u][0] += min(f[j][1], f[j][2]);
    }
    
    f[u][1] = 1e9;
    for(int i = h[u] ; ~i ; i = ne[i])
    {
        int j = e[i];
        
        f[u][1] = min(f[u][1], f[j][2] + f[u][0] - min(f[j][1], f[j][2]));
    }
}

int main(){
    cin >> n;
    memset(h, -1, sizeof h);
    for(int i = 1 ; i <= n ; i ++)
    {
        int id, cost, cnt;
        cin >> id >> cost >> cnt;
        w[id] = cost;
        while(cnt --)
        {
            int x;
            cin >> x;
            add(id, x);
            st[x] = true;
        }
    }
    
    int root = 1;
    while(st[root])root ++;
    
    dfs(root);
    
    cout << min(f[root][1], f[root][2]) << endl;
    return 0;
}