Every day a leetcode
题目来源:198. 打家劫舍
解法1:动态规划
确定dp含义
dp[i]: 表示在第 i 号房子之前可偷窃的最高金额。
初始化:
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
转移方程
在第 i 号房子可偷窃的最高金额由两种情况确定:
- 第 i-2 号房子可偷窃的最高金额加上第 i 号房子的存放金额;
- 或者第 i-1 号房子可偷窃的最高金额。
我们两者取其大,得转移方程:dp[i] = max(dp[i-2] + nums[i], dp[i-1])。
最终结果
ans=max(dp[numsSize - 1], dp[numsSize - 2]);
代码:
int max(int a,int b)
{
return a>b?a:b;
}
int rob(int* nums, int numsSize){
if(numsSize == 1) return nums[0];
int dp[numsSize];
memset(dp,0,sizeof(dp));
dp[0]=nums[0];
dp[1]=max(nums[0],nums[1]);
for(int i=2;i<numsSize;i++)
{
dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
}
int ans=max(dp[numsSize-1],dp[numsSize-2]);
return ans;
}
结果:
解法2:动态规划 - C++ version
代码:
// 动态规划
class Solution
{
public:
int rob(vector<int> &nums)
{
// 特判
if (nums.empty())
return 0;
int n = nums.size();
if (n == 1)
return nums[0];
// dp[i]: 偷窃 nums[0,...,i] 能得到的最高金额
vector<int> dp(n, 0);
// 初始化
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
// 状态转移
for (int i = 2; i < n; i++)
{
dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
}
return dp[n - 1];
}
};
结果:
复杂度分析:
时间复杂度:O(n),其中 n 为数组 nums 的长度。
空间复杂度:O(n),其中 n 为数组 nums 的长度。
空间优化:
// 动态规划 - 空间压缩
class Solution
{
public:
int rob(vector<int> &nums)
{
// 特判
if (nums.empty())
return 0;
int n = nums.size();
if (n == 1)
return nums[0];
int pre2 = 0, pre1 = 0, cur;
// 状态转移
for (int i = 0; i < n; i++)
{
cur = max(pre2 + nums[i], pre1);
pre2 = pre1;
pre1 = cur;
}
return cur;
}
};
复杂度分析:
时间复杂度:O(n),其中 n 为数组 nums 的长度。
空间复杂度:O(1)。
解法3:递归 + 记忆化搜索
记忆化搜索 = 递归 + 保存搜索结果。
代码:
// 递归 + 记忆化搜索
class Solution
{
public:
int rob(vector<int> &nums)
{
// 特判
if (nums.empty())
return 0;
int n = nums.size();
if (n == 1)
return nums[0];
int memo[n];
memset(memo, -1, sizeof(memo));
function<int(int)> dfs = [&](int i) -> int
{
if (i < 0)
return 0;
if (memo[i] != -1)
return memo[i];
int res = max(dfs(i - 1), dfs(i - 2) + nums[i]);
memo[i] = res;
return res;
};
return dfs(n - 1);
}
};
结果:
复杂度分析:
时间复杂度:O(n),其中 n 为数组 nums 的长度。
空间复杂度:O(n),其中 n 为数组 nums 的长度。