CodeForce 1153D(树上动态规划+贪心)

题目链接

题意：N个节点的树，有K个叶子节点，需要将1,2,3...K，K个数任意填入K个叶子节点，每个叶子节点填一个数，每个数只能填入一个叶子节点。每个节点上有个一个运算，运算有两种Max和Min。若运算为Max，则该节点的值等于所有儿子节点的最大值；若运算为Min，该节点的值等于所有儿子节点的最小值。问，根节点可能出现的最大值？

题解：关于树的问题，可以考虑树上动态规划的方法。

         我们定义 f(i) 表示：以i为根的子树，在这棵子树的叶子节点上随意填入（1至叶子节点数）的数，节点 i 上可以出现的最大值

         我们定义 son(i) 表示：节点i的子节点；定义son(i)(1)表示某一个子节点（1只是随意的标号）

         我们假设已经求解出所有 f(son(i)) 的值，尝试能否推导出 f(i) 的值

         若节点 i 的操作为Min：

                我们简化问题，假设节点i有两个子节点son(i)(1),son(i)(2)。

                f(son(i)(1))的值设为X，意味着以son(i)(1)为根的子树最优情况下，前X-1小的数都无法达到根节点，也就是说前X-1小的数都是铺垫

                f(son(i)(2))的值设为Y，意味着以son(i)(2)为根的子树最优情况下，前Y-1小的数都无法达到根节点，也就是说前Y-1小的数都是铺垫

                那么对于节点i，我们要最小的值最大，我们就需要尽量多的数来铺垫，那么最优情况下我们可以有X-1+Y-1个数来铺垫，最优解为X-1+Y-1+1

                对于节点i有多个子节点的情况，我们可以用同样的贪心法推导出结果：

                 f(i) = f(son(i)(1)) - 1 + f(son(i)(2)) - 1 +....f(son(i)(s))-1 + 1 (s为节点i的子节点数)

          若节点i的操作为Max：

                 我们同样简化问题，假设节点i有两个子节点son(i)(1),son(i)(2)。

                 f(son(i)(1))的值设为X， f(son(i)(2))的值设为Y。

                 节点i为根的子树，叶子节点数假设为K(i)。

                 根据这些信息，我们思考如何填入数字可以得到最优解。

                 对于子节点son(i)(1)，前 K(son(i)(1))-X 大的数都被拿来铺垫，

                 同理对于子节点son(i)(2)，前前 K(son(i)(2))-Y 大的数都被拿来铺垫。

                 对于节点i，我们要用来铺垫的数尽量少，我们可以构造把最大的一些数放入铺垫消耗最小的子树，这样这个子树得到的值一定时最大的，其他任意子树所填的所有数都比这棵子树小，必然不会得到更大的值，这样就得出节点i的最大值，最优解为：K(i) - min(K(son(i)(1))-X， K(son(i)(2))-Y)。

                 同理，多个子节点的情况也可以用这样贪心的方法求得结果：

                 f(i) = K(i) - min(K(son(i)(1))-f(son(i)(1))， K(son(i)(2))-f(son(i)(2)),......,K(son(i)(s))-f(son(i)(s)))  (s为子节点个数)

 

         根据定义，叶子节点的最优值为1,。我们就可以通过上述方法，从叶子节点开始，推导出根节点的最优值。

 

 总结：树上的动态规划，就是假设在以子节点为根的子树最优解已知的情况下，能否推导出以它们父节点为根的子树的最优解。若能推导出最优解，且可以用可行的方法求得叶子节点的最优解，就能得出整颗树的最优解。树的结构，天然满足无重叠子问题，无后效性等特点，所以树上的问题可以尝试从动态规划的角度来解决。本题我们直接定义题目要求的问题为状态即可求得结果，当然我们也可以定义一些可求解的间接问题，最后再推导出题目问题的解，比如本题我们也可以定义f(i)的意义为：以节点i为根的子树，最优情况下节点i的值为第几大的数（原题求的实际上为第几小的数）。总之，对于树上的问题，我们可以尝试动态规划的方法，求得直接解或间接解，来解决问题。

代码如下：

#include <bits/stdc++.h>
const int nn = 3*110000;
using namespace std;
int n;
int o[nn];
int f[nn];
int dp[nn];
int son[nn];
int leaf[nn];

int main(){
    while(scanf("%d",&n)!=EOF){
        memset(dp,0,sizeof(dp));
        memset(son,0,sizeof(son));
        memset(leaf,0,sizeof(leaf));
        for(int i=1;i<=n;i++){
            scanf("%d",&o[i]);
        }
        for(int i=2;i<=n;i++){
            scanf("%d",&f[i]);
            son[f[i]]++;
        }
        for(int i=1;i<=n;i++){
            if(son[i]==0){
                dp[i]=1;
                leaf[i]=1;
            } else if (o[i]==1){
                dp[i]=9999999;
            }
        }
        for(int i=n;i>=1;i--){
            if(son[i]!=0){
                if(o[i]==0){
                    dp[i]++;
                } else {
                    dp[i]=leaf[i]-dp[i];
                }
            }
            if(i==1){
                break;
            }
            if(o[f[i]]==0){
                dp[f[i]]+=(dp[i]-1);
            } else {
                dp[f[i]]=min(leaf[i]-dp[i],dp[f[i]]);
            }
            leaf[f[i]]+=leaf[i];
        }
        printf("%d\n",dp[1]);
    }
    return 0;
}