算法训练Day48: 198.打家劫舍 213.打家劫舍II 337.打家劫舍III
文章目录
- 打家劫舍
-
- 题解
- [打家劫舍 II](https://leetcode.cn/problems/house-robber-ii/description/)
-
- 题解
- [组合总和 Ⅳ](https://leetcode.cn/problems/combination-sum-iv/description/)
-
- 题解
打家劫舍
| Category | Difficulty | Likes | Dislikes | ContestSlug | ProblemIndex | Score |
|---|---|---|---|---|---|---|
| algorithms | Medium (54.29%) | 2556 | 0 | - | - | 0 |
数组 | 动态规划
你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 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 。
提示：
1 <= nums.length <= 1000 <= nums[i] <= 400
Discussion | Solution
题解
// @lc code=start
class Solution {
public:
int rob(vector& nums) {
if(nums.size() == 0) return 0;
if(nums.size() == 1) return nums[0];
vector dp(nums.size());
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
| Category | Difficulty | Likes | Dislikes | ContestSlug | ProblemIndex | Score |
|---|---|---|---|---|---|---|
| algorithms | Medium (44.12%) | 1353 | 0 | - | - | 0 |
你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，今晚能够偷窃到的最高金额。
示例 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 <= 1000 <= nums[i] <= 1000
Discussion | Solution
题解
// @lc code=start
class Solution {
public:
int rob(vector& nums) {
if(nums.size() == 0) return 0;
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);
}
int robRange(vector& nums, int start, int end) {
if(end == start) return nums[start];
vector dp(nums.size());
dp[start] = nums[start];
dp[start + 1] = max(nums[start],nums[start+1]);
for(int i = start + 2;i <= end;i++) {
dp[i] = max(dp[i-2] + nums[i],dp[i-1]);
}
return dp[end];
}
};
组合总和 Ⅳ
| Category | Difficulty | Likes | Dislikes | ContestSlug | ProblemIndex | Score |
|---|---|---|---|---|---|---|
| algorithms | Medium (52.90%) | 798 | 0 | - | - | 0 |
给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。
题目数据保证答案符合 32 位整数范围。
示例 1：
输入：nums = [1,2,3], target = 4
输出：7
解释：
所有可能的组合为：
(1, 1, 1, 1)
(1, 1, 2)
(1, 2, 1)
(1, 3)
(2, 1, 1)
(2, 2)
(3, 1)
请注意，顺序不同的序列被视作不同的组合。
示例 2：
输入：nums = [9], target = 3
输出：0
提示：
1 <= nums.length <= 2001 <= nums[i] <= 1000nums中的所有元素 互不相同1 <= target <= 1000
**进阶：**如果给定的数组中含有负数会发生什么？问题会产生何种变化？如果允许负数出现，需要向题目中添加哪些限制条件？
Discussion | Solution
题解
class Solution {
public:
int rob(TreeNode* root) {
vector result = robTree(root);
return max(result[0], result[1]);
}
// 长度为2的数组，0：不偷，1：偷
vector robTree(TreeNode* cur) {
if (cur == NULL) return vector{0, 0};
vector left = robTree(cur->left);
vector right = robTree(cur->right);
// 偷cur，那么就不能偷左右节点。
int val1 = cur->val + left[0] + right[0];
// 不偷cur，那么可以偷也可以不偷左右节点，则取较大的情况
int val2 = max(left[0], left[1]) + max(right[0], right[1]);
return {val2, val1};
}
};