LeetCode|动态规划|139. 单词拆分、198. 打家劫舍、213. 打家劫舍 II

目录

一、139. 单词拆分

1.题目描述

2.解题思路

3.代码实现

二、198. 打家劫舍

1.题目描述

2.解题思路

3.代码实现

三、213. 打家劫舍 II

1.题目描述

2.解题思路

3.代码实现

---

 

一、139. 单词拆分

1.题目描述

给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。

注意：不要求字典中出现的单词全部都使用，并且字典中的单词可以重复使用。

示例 1：

输入: s = "leetcode", wordDict = ["leet", "code"]
输出: true
解释: 返回 true 因为 "leetcode" 可以由 "leet" 和 "code" 拼接成。

示例 2：

输入: s = "applepenapple", wordDict = ["apple", "pen"]
输出: true
解释: 返回 true 因为 "applepenapple" 可以由 "apple" "pen" "apple" 拼接成。
     注意，你可以重复使用字典中的单词。

2.解题思路

• 抽象为完全背包问题：字符串s是背包，单词就是物品
• 这里对物品的顺序有要求，是排列问题，先遍历背包，再遍历物品
• dp数组含义：重量为j（也就是取字符串前j个字符）的背包，能否由字典中的单词组成
• 递推公式：dp[j]为true的条件是：dp[i]是true并且 (i,j)之间的字符也是存在于字典中

3.代码实现

class Solution {
public:
    bool wordBreak(string s, vector<string>& wordDict) {
        unordered_set<string> uset(wordDict.begin(),wordDict.end());
        vector<bool> dp(s.size() + 1,false);
        dp[0] = true;
        
        for(int j = 1;j <= s.size();j++){
            for(int i = 0;i < j ;i++){
                string str = s.substr(i,j - i);
                if(dp[i] && uset.find(str) != uset.end()){
                    dp[j] = true;
                }
            }
        }
        return dp[s.size()];
    }
};

二、198. 打家劫舍

1.题目描述

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

示例 1：

输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 2：

输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
     偷窃到的最高金额 = 2 + 9 + 1 = 12 。

2.解题思路

• dp数组含义：考虑下标i（包括下标i）以内的房屋，能最多偷dp[i]的金额
• dp[i]依赖于dp[i-1]和dp[i-2]。因为题目给的条件时相邻的两个不能偷，
• 所以,①如果确定偷了下标为i的房间，那么只能偷i-2之前的房子，此时最大金额是 nums[i] + dp[i-2]
• ②如果不偷下标为i的房间，说明前一个房间被偷了，那么所能偷的最大金额就是dp[i-1]

3.代码实现

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.size() == 1)
            return nums[0];
        //确定dp数组含义：偷下标为i(包括i)之前的房屋，所能偷到最大金额为dp[i]
        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];
    }
};

三、213. 打家劫舍 II

1.题目描述

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。

示例 1：

输入：nums = [2,3,2]
输出：3
解释：你不能先偷窃 1 号房屋（金额 = 2），然后偷窃 3 号房屋（金额 = 2）, 因为他们是相邻的。

示例 2：

输入：nums = [1,2,3,1]
输出：4
解释：你可以先偷窃 1 号房屋（金额 = 1），然后偷窃 3 号房屋（金额 = 3）。
     偷窃到的最高金额 = 1 + 3 = 4 。

示例 3：

输入：nums = [1,2,3]
输出：3

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 1000

2.解题思路

• 环状改为线性，分成三种情况
      1.既不考虑首元素，也不考虑尾元素
      2.考虑首元素，不考虑尾元素
      3.不考虑首元素，考虑尾元素
• 情况2和3是包含了情况1的，因此我们只需要得到max（情况1的最大值，情况2的最大值）

3.代码实现

class Solution {
public:
    //环状改为线性，分成三种情况
    //1.既不考虑首元素，也不考虑尾元素
    //2.考虑首元素，不考虑尾元素
    //3.不考虑首元素，考虑尾元素
    //情况2和3是包含了情况1的，因此我们只需要得到max（情况1的最大值，情况2的最大值）
    int robRange(const vector<int>& nums,int begin,int end){
        if(begin == end)    return nums[begin];
        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-1],dp[i - 2] + nums[i]);
        }
        return dp[end];
    }
    int rob(vector<int>& nums) {
        if(nums.size() == 1)    return nums[0];
        int result1 = robRange(nums,0,nums.size() - 2);
        int result2 = robRange(nums,1,nums.size() - 1);
        return max(result1,result2);
    }
};