968.监控二叉树 树上最小支配集

 法一: 动态规划

一个被支配的节点只会有三种状态

        1.它本身有摄像头

        2.他没有摄像头, 但是它的父节点有摄像头

        3.他没有摄像头, 但是它的子节点有摄像头

我们 dfs(node,state) 记录在node节点时(以node为根的子树),状态为state下的所有最小摄像头

// 本身有摄像头就看左右孩子了

dfs(node,1) = min(dfs(node->left,1),dfs(node->left,2),dfs(node->left,3)) +

                      min(dfs(node->right,1),dfs(node->right,2),dfs(node->right,3)) + 1

// 本身没有摄像头, 左右孩子不能是2

dfs(node,2) = min(dfs(node->left,1),dfs(node->left,3)) +

                      min(dfs(node->left,1),dfs(node->left,3))

// 本身没有摄像头, 要靠子节点保障,同样左右孩子不能是2,而且至少有一个1

dfs(node,3) = min(dfs(node->left,1)+dfs(root->right,3), dfs(node->left,3)+dfs(node->right,1), 

                       dfs(node->left,1)+dfs(root->right,1))

边界条件怎么思考呢:

        tmp=dfs(nullptr,state)  state为1,tmp是INT_MAX/2  state为2,3,tmp是0

        因为state不应该是1,也就是叶子节点的不应该是用nullptr保障 ,所以我们把这种情况要筛掉

        而当他是2,3时,也就是说让nullptr的监控让他的父节点或者子节点保障,但是因为nullptr不需要监控,所以返回0就行

 代码如下:

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    //最小支配集 
    int minCameraCover(TreeNode* root) {
        // 首先对于 一个节点,要被覆盖只有三种情况 
        //1. 它本身安装了摄像头                  ->记成蓝色 blue 0
        //2.(他没安装)它的父节点安装了摄像头      ->记成红色 red 1
        //3.(他没安装)它的孩子有一个安装了摄像头  ->记成黄色 yellow 2

        //对于根节点是蓝色 ans = min(l_blue,l_red,l_yellow) + min(r_blue,r_red,r_yellow) + 1
        //对于根节点是红色,子节点不能是红色 ans = min(l_blue,l_yellow) + min(r_blue,r_yellow)
        //对于根节点是黄色,子节点不能是红色 ans = min(l_blue+r_yellow, l_yellow+r_blue, l_blue+r_blue)
        map<pair<TreeNode*,int>,int> memo;
        function<int(TreeNode*,int)> dfs=[&](TreeNode* root,int color)->int{
            if(!root){
                if(color==0) return INT_MAX/2;  //
                else return 0; 
            }
            if(memo.count({root,color})) return memo[{root,color}];
            //null节点不能是蓝色 因为叶子节点不能把希望寄托在null上 把这种情况排除
            //但是null节点可以是红色或者黄色 
            //红色意味着该null也被监视了,虽然没必要,但是也不算错
            //黄色意味着该节点的安全由子节点保证 但是本来这个节点就是null 不用保证其安全
            if(color==0){
                return memo[{root,color}]=min(dfs(root->left,0),min(dfs(root->left,1),dfs(root->left,2))) + min(dfs(root->right,0),min(dfs(root->right,1),dfs(root->right,2))) + 1;
            }else if(color==1){
                return memo[{root,color}]=min(dfs(root->left,0),dfs(root->left,2)) + min(dfs(root->right,0),dfs(root->right,2));
            }else {
                return memo[{root,color}]=min(dfs(root->left,0)+dfs(root->right,2),min(dfs(root->left,2)+dfs(root->right,0),dfs(root->left,0)+dfs(root->right,0)));
            }
        };
        return min(dfs(root,0),dfs(root,2));
    }
};

法二: 贪心

        我们跳出思维定式来看看这个题,怎么 "贪心地" 使得使用最少的节点来支配整个树,显然在一层一层的来看,叶子节点不要放,在叶子节点的父节点放摄像头,然后跳过两个,在这一层放摄像头,然后再跳过两个,在这一层放摄像头,一直这样到根节点. 

        算法的正确可以这样想,叶子节点a一定要被监控,显然放在a的双亲是收益最大的,然后往上找没有监控的节点,用同样的贪心思想

        至于为什么不从根节点往下呢,可以这样想: 叶子节点一定是比根节点要多的,所以应该抓大头

我们把所有节点分成三种情况:

        0. 本身放了摄像头

        1. 本身没有摄像头,但是被子节点监控了

        2. 本身没有摄像头,但是被父节点监控了

这样就是说nullptr往上返回1, (因为显然不会是0,而为了让摄像头最少,又不能是2)

上一层如果收到了下面的两个1,就返回一个2

上一层如果收到了下面的2,就往上返回0 (只要收到一个2)

上一层如果收到了下面的0,就往上返回1 (只要收到一个0)

如果收到了一个0,一个2呢, 显然返回是0, 不如就会有一个节点没有被监控

而最后走到根节点又没有父节点,所有如果根节点返回2, ans是要加1的

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    //最小支配集 
    int minCameraCover(TreeNode* root) { 
        int res=0;
        function<int(TreeNode*)> travel=[&](TreeNode*root)->int{
            if(!root) return 1;
            int left=travel(root->left);
            int right=travel(root->right);
            if(left==1 && right==1) return 2;               //情况1 
            if(left==2 || right==2) { res++; return 0;}     //情况2
            if(left==0 || right==0) return 1;               //情况3  

            return -1;
        };
        if(travel(root)==2) res++;
        return res;
    }
};