Day48 | 198.打家劫舍, 213.打家劫舍II, 337.打家劫舍III(树形DP)

Day48 | 198.打家劫舍, 213.打家劫舍II, 337.打家劫舍III(树形DP)

打家劫舍

LeetCode题目:https://leetcode.cn/problems/house-robber/

  打家劫舍问题的初始问题,很明显,当存在i个房子的时候,打家劫舍的最大收益应该是多少?谈到最大收益,可以判断应该需要使用max来进行处理。同时,打家劫舍要求至少间隔一间房屋,所以递推公式需要考虑当前位置的临近位置,和间隔位置两种情况。因此可以看做是max(间隔房间 + 当前房间收益, 临近房间最大收益),共同来决定最大的收益。

  因此,由以上推理,至少需要初始化两个值才能完成上述状态转移,其中最开始位置一定是当前房屋的收益。而存在两个房间的时候应该是收益最大值。

  代码如下:

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size() == 1) return nums[0];
        vector<int> dp(nums.size(), 0);
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for (int i = 2; i < nums.size(); i++) {         
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[nums.size() - 1];
    }
};

打家劫舍II

LeetCode题目:https://leetcode.cn/problems/house-robber-ii/

  与问题1不同点在于,当存在环形的时候,开头的元素和末尾的元素是临近关系的。这就意味着会出现三种情况:(1)开头和末尾的元素都不需要。(2)需要开头的元素。(3)需要末尾的元素。其中(1)情况可以在2/3情况中包含计算。

  因此,其实可以抽象看成,如果情况2,那就默认去掉末尾元素进行最大值计算。如果情况3,那就去掉开头元素进行最大值计算。最后再对两者进行比较,即可得到最后的结果。

  最终代码如下:

class Solution {
public:
    int rangeRob(vector<int>& nums, int begin, int end) {
        vector<int> dp(nums.size(), 0);
        dp[begin] = nums[begin];
        dp[begin + 1] = max(nums[begin], nums[begin + 1]);
        for (int i = begin + 2; i < end; i++) {        
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[end-1];
    }
    int rob(vector<int>& nums) {
        if(nums.size() == 1) return nums[0];
        if(nums.size() == 2) return max(nums[0], nums[1]);
        int robFront = rangeRob(nums, 1, nums.size());
        int robBack = rangeRob(nums, 0, nums.size() - 1);
        return max(robFront, robBack);
    }
};

打家劫舍III

LeetCode题目:https://leetcode.cn/problems/house-robber-iii/

  该问题主要注重于对树形DP的理解,所谓树形DP,需要在二叉树上进行遍历并同时用返回值来保存状态的转移过程。因此核心在于对返回值的处理上,如何使返回值即表示当前节点的状态,又可以保存节点的值。可以参考DAY37 968.监控二叉树。

  同时,要求得最大收益,因此每次遍历后要对遍历结果对比再进行返回,因此递归要采用后序遍历的方法,来进行递归以收集信息。此外,对于每个返回的值,因为打家劫舍要存在间隔,所以应该分为没有取当前节点的值,和取了当前节点的值两个情况来进行处理。因此,每次递归需要返回两个状态值,使用当前和没有使用当前,即val1 = root->val + leftDp[0] + rightDp[0],val2 = max(leftDp[0],leftDp[1]) + max(rightDp[0],rightDp[1]),最后返回(val1,val2)

  如此,每次递归的流程便确定下来。最终代码如下:

class Solution {
public:
    vector<int> robTree (TreeNode* root) {
        if (root == NULL) return {0, 0};
        vector<int> leftDp = robTree(root->left);
        vector<int> rightDp = robTree(root->right);
        int val1 = root->val + leftDp[0] + rightDp[0];
        int val2 = max(leftDp[0], leftDp[1]) + max(rightDp[0], rightDp[1]);
        return {val2, val1};
    }
    int rob(TreeNode* root) {
        vector<int> result = robTree(root);
        
        return max(result[0], result[1]);
    }
};

  除了dp思路以外,也可以使用常规的递归模式进行处理,同时为了优化一些已知点的最大收益不被反复计算,应该设定map进行映射,以便于对节点是否被计算进行查询,如果已经被计算则直接返回值(理解上其实和状态转移差不多)

class Solution {
public:
    unordered_map<TreeNode*, int> robMap;
    int rob(TreeNode* root) {
        if(root == NULL) return 0;
        if(root->left == NULL && root->right == NULL) return root->val;
        if(robMap.find(root) != robMap.end()) return robMap[root];
        /* 计算当前节点 */
        int val1 = root->val;
        if(root->left) val1 += rob(root->left->left) + rob(root->left->right);
        if(root->right) val1 += rob(root->right->left) + rob(root->right->right);
        /* 不计算当前节点 */
        int val2 = rob(root->left) + rob(root->right);
        robMap[root] = max(val1, val2);
        return robMap[root];
    }
};

你可能感兴趣的:(数据结构,leetcode,算法,动态规划)