Question

我正在从LeetCode.com解决a question。问题是这样的：

你是一名职业强盗，计划在街上抢劫房屋。每个房子都有一定数量的钱存在，阻止你抢劫他们的唯一限制是相邻的房屋有连接的安全系统，如果两个相邻的房子在同一个晚上被打破，它将自动联系警察。
给出一个代表每个房子的金额的非负整数列表，确定今晚可以抢劫的最高金额，而不会警告警察。

在考虑了一段时间之后，我可以提出以下关系，这是正确的：

dp[i] = max(dp[i-2]+nums[i], dp[i-1]);

但是，我无法初始化dp[]数组。在解决方案中，它已经初始化为：

dp[0]=nums[0];
dp[1]=max(nums[0],nums[1]);

这不正确吗？因为如果nums[0]>nums[1]，那么它是否意味着抢劫同一个房子（因为我们将dp[0]和dp[1]初始化为相同的值？）即使我们假设nums[1]>nums[0] ，nums[0]和nums[1]不是连续的房子吗？

完整代码（如果需要）如下：

class Solution {
public:
    int rob(vector<int>& nums) {
        if(nums.empty())
            return 0;

        vector<int> 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(nums[i]+dp[i-2], dp[i-1]);
        }

        return dp[nums.size()-1];
    }
};

Answer 1

在解决方案中考虑dp[i]为＆＃34;您可以从i+1房屋抢劫的最高金额，而不会警告警方＆＃34;并将每个i视为一个单独的案例。如果有一所房子（i == 0），那么你只能偷走那一所房子。如果有两个房屋（i == 1），那么您可以偷取的最多房屋是房屋中的最大房屋（nums[0]或nums[1]）。我这样做的方式是：

int n = nums.size();
int dp[n+1]; // max $ you can rob from i houses with altering police
dp[0] = 0; // no houses, no money
dp[1] = nums[0];
for (int i = 2; i <= n; ++i) {
  dp[i] = max(dp[i - 1], nums[i - 1] + dp[i - 2]);
}
return dp[n];

返回您可以从i个房屋（不是i+1）窃取的最高金额，我认为这更容易理解。

Answer 2

如果我理解正确，您的问题会缩减为：Because if nums[0]>nums[1], then doesn't it imply robbing the same house (because we initialize both dp[0] and dp[1] to the same value?)。

答案是否定的，并不意味着抢劫同一所房子。它意味着不抢劫房子1，因为房子0被抢劫了。房子0被抢劫，因为它包含更多的钱，你必须选择抢劫房子0或房子1（钱少）。

DP阵列初始化的原因

2 个答案: