树形DP

前言

        顾名思义树上的DP

        树是一种数据结构

        DP (动态规划) 是一种算法

三分学，七分练

        P2052

        P2052 [NOI2011] 道路修建 - 洛谷

        题意：给一棵树，计算n-1条边，每条边两边节点相减的绝对值乘边权。

        思路：用DFS统计以一边把树分成两部分后两边节点数存入DP后计算（DP相当于记忆化）

        代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
vector<pair<int ,int>> g[N];//补充一
int dp[N];
long long n,sum=0;
void dfs(int u,int fa){
    dp[u]=1;                                      
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i].first;  //补充二
        int w=g[u][i].second;    //v是子节点，w是边权
        if(v==fa) continue;      //避免找到父节点
        dfs(v,u);
        dp[u]+=dp[v];
        sum+=abs(n-dp[v]-dp[v])*w;    //计算存入sum
    }
}
int main(){
    cin>>n;
    for(int i=1;i<n;i++){
        int a,b,c;       //补充三
        cin>>a>>b>>c;
        g[a].push_back({b,c});
        g[b].push_back({a,c});
    }
    dfs(1,0);
    cout<<sum;
    return 0;
}

        P3478

         P3478 [POI 2008] STA-Station - 洛谷

        题意：一棵树，问你以哪个结点为根时深度之和最大。

        思路：先用DFS1来统计以1为根时深度之和，再用DFS2进行换根（不重新计算）来计算以v为根时的深度之和。

        代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e6+10;
vector<int> g[N];
int size[N];
int h[N];
long long dp[N];
int n,maxd=1,a,b;
long long sum,maxx;
void dfs(int u,int fa){
    h[u]=h[fa]+1;
    sum+=h[u];
    size[u]=1;
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==fa){
            continue;
        }
        dfs(v,u);
        size[u]+=size[v];
    }
}
void dfs2(int u,int fa){                    //换根
    for(int i=0;i<g[u].size();i++){
        int v=g[u][i];
        if(v==fa){
            continue;
        }
        dp[v]=dp[u]-size[v]+n-size[v];  //转移方程
        if(dp[v]>maxx){                //更新
            maxd=v;
            maxx=dp[v];
        }
        dfs2(v,u);
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        scanf("%d%d",&a,&b);
        g[a].push_back(b);
        g[b].push_back(a);
    }
    h[0]=-1;        //使节点1的深度为0
    dfs(1,0);
    dp[1]=sum;      //初始化以1为根时的深度之和
    dfs2(1,0);
    printf("%d",maxd);
    return 0;
}

       P15801

        P15801 [GESP202603 六级] 完全二叉树 - 洛谷

        题意：一棵树内有多少完全二叉树。

        思路：用DFS将子树信息存进dp来判断大的子树。

        代码如下：

#include<bits/stdc++.h>
using namespace std;
const int N=1e5+10;
struct node{        
    int l,r;        //存节点的左右子节点
};
node a[N];
int dp[N],h[N];   //DP【0】啥也不是  DP【1】完全二叉树  DP【2】满二叉树（一定是完全二叉树）
int ans,n;
void dfs(int u,int depth){
    h[u]=depth;
    if(a[u].l>0){                        //左边有树
        dfs(a[u].l,depth+1);
        h[u]=max(h[u],h[a[u].l]);
    }
    if(a[u].r>0){                        //右边有树
        dfs(a[u].r,depth+1);
        h[u]=max(h[u],h[a[u].r]);
    }
    if(a[u].l==0 && a[u].r==0){                        //没有左右子树,为满二叉树
        dp[u]=2;
    } else if(a[u].r==0 && h[a[u].l]==depth+1){
        dp[u]=1;
    } else if(h[a[u].l]==h[a[u].r]){
        if(dp[a[u].l]==2 && dp[a[u].r]==2){
            dp[u]=2;
        } else if(dp[a[u].l]==2 && dp[a[u].r]==1){
            dp[u]=1;
        }
    }else if(h[a[u].l]==h[a[u].r]+1){
        if((dp[a[u].l]==1 || dp[a[u].l]==2) && dp[a[u].r]==2){
           dp[u]=1;
        }
    }
    ans+=(dp[u]>0);
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        cin>>a[i].l>>a[i].r;
    }
    dfs(1,0);
    cout<<ans;
    return 0;
}

补充（见代码）：

        补充一：vector数组g[i]为节点（vector数组可以理解成无限的数组）（pair可以理解成结构体）

        补充二：pair的调用

        补充三：存边——a,b是节点c是边权