【题解】打家劫舍I II III

打家劫舍I

题目

题目来源：leetcode 198：打家劫舍
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

解题思路

使用动态规划求解，nums[i-1]表示第i家存放的金额，dp[i-1]表示在不触动报警装置的前提下，偷窃前i家得到的最高金额。要计算dp[i]分两种情况：
（1）偷第i+1家，那就不能偷第i家，即dp[i]的取值为nums[i] + dp[i-2]。

（2）不偷第i+1家，那dp[i]的取值为dp[i-1]。

dp[i]的结果取两者的较大值。

如果偷窃前i家的最大金额里没有包含第i家的金额，那dp[i-1] == dp[i-2]（上述第一种情况的取值等效于nums[i] + dp[i-1]），否则dp[i-1] > dp[i-2]。

代码实现（C++）

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

在dp数组中，dp[i]的取值只和dp[i-1]、dp[i-2]有关，因此可使用3个变量cur，cur_1，cur_2分别替换它们，进而优化空间复杂度。

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

打家劫舍II

题目

题目来源：leetcode 213：打家劫舍II
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都围成一圈，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你在不触动警报装置的情况下，能够偷窃到的最高金额。

解题思路

思路和上一题基本类似，差别在于不能同时偷窃第一家和最后一家。因此要使用动态规划遍历两次数组，一次不偷第一家，一次不偷最后一家。分别得到curf和curl，结果取它们的最大值。

代码实现（C++）

class Solution {
public:
    int rob(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return nums[0];
        }
        if (n == 2) {
            return max(nums[0], nums[1]);
        }
        // 不偷第一家
        int curf = max(nums[1], nums[2]);
        int cur_1 = nums[1];
        int cur_2 = 0;
        for (int i = 3; i < n; ++i) {
            cur_2 = cur_1;
            cur_1 = curf;
            curf = max(nums[i] + cur_2, cur_1);
        }
        // 不偷最后一家
        int curl = max(nums[0], nums[1]);
        cur_1 = nums[0];
        cur_2 = 0;
        for (int i = 2; i < n - 1; ++i) {
            cur_2 = cur_1;
            cur_1 = curl;
            curl = max(nums[i] + cur_2, cur_1);
        }
        return max(curf, curl);
    }
};

打家劫舍III

题目

题目来源：leetcode 337：打家劫舍III
在上次打劫完一条街道之后和一圈房屋后，小偷又发现了一个新的可行窃的地区。这个地区只有一个入口，我们称之为“根”。 除了“根”之外，每栋房子有且只有一个“父“房子与之相连。一番侦察之后，聪明的小偷意识到“这个地方的所有房屋的排列类似于一棵二叉树”。 如果两个直接相连的房子在同一天晚上被打劫，房屋将自动报警。
计算在不触动警报的情况下，小偷一晚能够盗取的最高金额。

解题思路

“二叉树”的结构：

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

定义一个类：

class Data {
public:
	int rootVal;
    int leftVal;
    int rightVal;
    Data(int rt = 0, int le = 0, int ri = 0) : rootVal(rt), leftVal(le), rightVal(ri) {}
};

定义一个函数：

Data solve(TreeNode *root);

left为root的左节点，right为root的右节点。函数solve(root)的返回值是一个Data类型的实例，返回值中的rootVal成员变量表示偷窃以root为"根"节点的房屋群落的最大金额，leftval成员变量表示偷窃以left为"根"节点的房屋群落的最大金额，rightVal成员变量表示偷窃以right为"根"节点的房屋群落的最大金额。

solve(root)返回值的rootVal的取值分两种情况：
（1）偷窃root，那么就不能偷窃left和right，返回值的取值为root->val + solve(left).leftVal + solve(left).rightVal + solve(right).leftVal + solve(right).rightVal。

（2）不偷窃root，那么就可以偷窃left和right，返回值的取值为solve(left).rootVal + solve(right).rootVal。
结果是较大值。

solve(root)返回值的leftVal等于solve(left).rootVal，solve(root)返回值的rightVal等于solve(right).rootVal。

代码实现（C++）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    class Data {
    public:
        int rootVal;
        int leftVal;
        int rightVal;
        Data(int rt = 0, int le = 0, int ri = 0) : rootVal(rt), leftVal(le), rightVal(ri) {}
    };
    int rob(TreeNode* root) {
        return solve(root).rootVal;
    }
    Data solve(TreeNode *root) {
        if (!root) {
            return Data();
        }
        Data ld = solve(root->left);
        Data rd = solve(root->right);
        int rootVal1 = 0;
        int rootVal2 = 0;
        int leftVal = ld.rootVal;
        int rightVal = rd.rootVal;
        // 选择root
        rootVal1 = root->val + ld.leftVal + ld.rightVal + rd.leftVal + rd.rightVal;
        // 不选择root
        rootVal2 = ld.rootVal + rd.rootVal;
        return Data(max(rootVal1, rootVal2), leftVal, rightVal);
    }
};