树形dp介绍及入门

介绍

树型dp一般先算子树然后进行合并，即：先遍历子树，遍历完之后把子树的值合并给父亲

如：给你一棵n个点的树（1号点为根节点），求以点$i$为根的子树的大小

void dfs(i){
    if(i是叶子节点){
        f[i]=1;return;
    }
    for(k是i的儿子){
        dfs(k);
        f[i]+=f[k];
    }
    f[i]+=1;
}
f[i]:以点i为根的子树的点的个数
f[i] = 1+Σf[k](k是i的儿子)

L3-025 那就别担心了

L3-025 那就别担心了 (30 分)

思路：

树形dp，自下而上更新到B点的路径条数，$dp[i]$表示从第$i$个命题到第B个命题有多少种不同的推理路径

代码：

#include <bits/stdc++.h>
using namespace std;

int dp[502];

int N, M, S1, S2, A, B, flag;
vector<int> v[502];

int dfs(int x) {
    if (dp[x] != 0) return dp[x];
    for (int ne : v[x]) {
        if (dp[ne] == 0) dfs(ne);
        dp[x] += dp[ne];
    }
    //如果从A出发到x这一命题，不能继续向下推理到命题B
    if (dp[x] == 0) flag = 1;
    return dp[x];
}

int main() {
    cin >> N >> M;
    for (int i = 0; i < M; ++i) {
        cin >> S1 >> S2;
        v[S1].push_back(S2);
    }
    cin >> A >> B;
    dp[B] = 1;
    dfs(A);
    cout << dp[A] << ' ' << (flag ? "No" : "Yes");
    return 0;
}

树的重心

小G有一个大树

树的重心：

树的重心也叫树的质心。对于一棵树n个节点的无根树，找到一个点，使得把树变成以该点为根的有根树时，$$最大子树的结点数最小$$
换句话说，删除这个点后最大连通块（一定是树）的结点数最小。

树的重心的性质：

• 树中所有点到某个点的距离和中，到重心的距离和是最小的，如果有两个距离和，他们的距离和一样。
• 把两棵树通过一条边相连，新的树的重心在原来两棵树重心的连线上。
• 一棵树添加或者删除一个节点，树的重心最多只移动一条边的位置。
• 一棵树最多有两个重心，且相邻。

思路：

• 深搜从哪一个点开始都可以，因为本题是无向图，对于无向树，直接随便找一个结点作为根，然后把整棵树支起来，就有了根和叶子，即随便一个点都可以作为树的根
• 为了深搜 (vector邻接表存的) 无向图的过程中不走“走回头路”，需要每一次记录前一个结点的编号
• dfs注意每一次都得把自己这个点算上
• 状态转移方程：$F[i]=max(max(tot[k]),n-tot[i]]（k是i的子树）$

void dfs(int u,int pre){
    dp[u]=1;//把自己这个点算上
    int m=0;
    for(int i=0;i<G[u].size();i++){
        if(G[u][i]==pre) continue;
        dfs(G[u][i],u);
        dp[u]+=dp[G[u][i]];
        m=max(m,dp[G[u][i]]);//保证除父节点外最大子树的结点数最小
    }
    m=max(m,n-dp[u]);//保证最大子树的结点数最小
    if(m<ansnum){
        ansnum=m;
        ansx=u;
    }//寻找树的重心
    else if(m==ansnum && ansx>u)ansx=u;
}
ansx=ansnum=0x3f3f3f3f;
dfs(1,0);

最大独立集

没有上司的舞会

思路：

• 因为本题是有向图，在dfs时需要搜索的节点只能是根节点，即没有父亲的节点，否则无法搜索到所有节点
• 用$f[i][0]$表示不选择i点时，i点及其子树能得到的最大快乐指数，$f[i][1]$表示选择i点时，i点及其子树能得到的最大快乐指数
• $f[i][0]=\Sigma (max(f[j][0],f[j][1]))......f[i][1]=H(i)+\Sigma f[j][0](j是i的儿子)$
• 结果为$max(f[root][0],f[root][1])$
• 最大独立子集的定义：对于一个树形结构，所有的孩子和他们的父亲存在排斥，也就是如果选取了某个节点，那么会导致不能选取这个节点的所有孩子节点

void dfs(int root){
    if(!haveson[root]){//叶子
        dp[root][1]=happy[root];
        dp[root][0]=0;
        maxhappy=max(maxhappy,max(dp[root][1],dp[root][0]));
        //叶子节点也要对答案进行更新，否则会炸QAQ
        return;
    }
    for(int i=0;i<G[root].size();i++){
        int to=G[root][i];
        dfs(to);
        dp[root][1]+=dp[to][0];//贪心：所有儿子都不能取 
        dp[root][0]+=max(dp[to][1],dp[to][0]);//贪心：所有儿子可以取也可以不取
    }
    dp[root][1]+=happy[root];
    maxhappy=max(maxhappy,max(dp[root][1],dp[root][0]));
}

树的最小点覆盖

Strategic game

题意：

一城堡的所有的道路形成一个n个节点的树(the roads of which form a tree)，如果在一个节点上放上一个士兵，那么和这个节点相连的边就会被看守住，问把所有边看守住最少需要放多少士兵

思路：

• 本题跟 没有上司的舞会 极像，虽然题目描述是无向图，为了用树形dp，我们将其当做有向图处理，所以必须从根节点开始搜索

• $f[x][1]$以x为根的子树在x上放置（同理$f[x][0]$为不放置）的士兵的最少所需的士兵数目

• $f[x][1]=1+\Sigma min(f[i][0],f[i][1])......f[x][0]=\Sigma f[i][1](i是x的儿子)$

• 结果为$min(f[root][0],f[root][1])$

void dfs(int root){
    if (G[root].size() == 0){//叶子 
        dp[root][1] = 1;
        dp[root][0] = 0;
    }
    for (int i = 0; i < G[root].size(); i++){
        int to = G[root][i];
        dfs(to);
        dp[root][1] += min(dp[to][1], dp[to][0]);
        dp[root][0] += dp[to][1];
    }
    dp[root][1]+=1;
}
for (int i=0;i<n;i++){
    if(!havepar[i]){
        dfs(i);
        Troot = i;
    }
}
printf("%d\n", min(dp[Troot][1], dp[Troot][0]));

例五（树的最小支配集）：

Cell Phone Network

题意：

给你一棵无向树(Exactly N-1 pairs of pastures are adjacent)，问你最少用多少个点可以覆盖掉所有其他的点（一个点被盖，它自己和与它相邻的点都算被覆盖）

思路：

寻找当前点的状态，如果一个树都被覆盖，那么这一个点，肯定要么是自己覆盖的，要么是父亲覆盖的，要么是儿子覆盖的，就找到了三种状态：

$dp[i][0]$：选点$i$，即自己覆盖

$dp[i][1]$：不选点$i$，$i$被其儿子覆盖，即儿子覆盖，那么只要有至少有一个儿子是自己覆盖了的就好了（叶子结点无）

$dp[i][2]$：不选点$i$，$i$被其父亲覆盖，即父亲覆盖（根结点无）

难点： 如果root点有孩子：
$$\begin{gathered} dp[root][1]=min(dp[son][0],dp[son][1])+inc(如果全部满足dp[son][0]>dp[son][1]) \\ inc=min(inc,(dp[son][0]-dp[son][1])))（inc要加只需加一次） \end{gathered}$$

const int INF=0x3f3f3f3f;
int dp[N][3];//0表示该点覆盖 1表示该点儿子覆盖 2表示该点父亲覆盖
void dfs(int root,int pre){
    bool haveson=false;
    bool coverson=false;
    int inc=0x3f3f3f3f;
    for(int i=0;i<G[root].size();i++){
        int to=G[root][i];
        if(to==pre) continue;
        haveson=true;
        dfs(to,root);
        dp[root][0]+=min(dp[to][0],min(dp[to][1],dp[to][2]));//自己覆盖
        if(root==1)//如果root点是根节点
            dp[root][2]=INF;
        else dp[root][2]+=min(dp[to][0],dp[to][1]);//如果root点不是根节点 
        inc=min(inc,dp[to][0]-dp[to][1]);
        if(dp[to][0]<=dp[to][1]){
            coverson=true;
            dp[root][1]+=dp[to][0];
        }
        else dp[root][1]+=dp[to][1];       
    }
    if(!haveson) dp[root][1]=INF;//root是叶子节点
    else if(!coverson) dp[root][1]+=inc;//被迫找一个最优的自己覆盖的儿子
    dp[root][0]+=1;
}
dfs(1,0);
printf("%d\n",min( dp[1][0],min(dp[1][1],dp[1][2])) );