[leetcode 198] House robbery

topic

Link to the topic: https://leetcode.cn/problems/house-robber/

solution

Simply put, adjacent items cannot be taken at the same time.

method one

We use choose[i] to express (must take) the maximum value that can be obtained from the i-th item, and ignore[i] to indicate to give up (must give up) the maximum value that can be obtained from the i-th item.

ignore[i] may be larger than choose[i], because choose[i] must take the i-th item, so it cannot take the i-1-th item, but the i-1-th item may be of great value.

The state transition equation is as follows

$$imust\; be\; taken\{\begin{array}{rlr}& takei-2：& choose[i-2]+nums[i]\\ & radiationi-2：& ignore[i-2]+nums[i]\end{array}$$

$$must\; give\; upi\{\begin{array}{rl}takei-1：& choose[i-1]\\ takei-2：& choose[i-2]\end{array}$$

code show as below

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

Method Two

In fact, the two states mentioned above can be combined, that is, we only use an array dp, and dp[i] represents the maximum value that can be obtained up to the i-th item, and we can choose the i-th item or give it up.

$$dp[i]\{\begin{array}{rlr}& Takei:\_& dp[i-2]+nums[i]\\ & Do\; not\; takei& dp[i-1]\end{array}$$

When i=1, dp[-1] can be treated as 0 to ensure that the result is correct when i=1.

code show as below

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

Topic upgrade (Meituan 23 spring)

After the i-th user is selected, i-2, i-1, i+1, and i+2 cannot be selected. What is the maximum value that can be stolen?

We only use an array dp, dp[i] represents the maximum value that can be obtained up to the i-th item, and we can choose or give up the i-th item.

$$dp\left[i\right]\{\begin{array}{rlr}& Takei:\_& dp[i-3]+nums[i]\\ & Do\; not\; takei& dp[i-1]\end{array}$$

During initialization, the result is guaranteed to be correct when i=1 and i=2.

Topic upgrade (ant 23 spring)

You can steal 2 consecutive households, but you cannot steal 3 consecutive households, but steal at least one of the 3 consecutive households. Ask the maximum value that can be stolen?

We only use an array dp, dp[i] represents the maximum value that can be obtained up to the i-th item, and we can choose or give up the i-th item.

$$dp[i]\{\begin{array}{rlr}& \_011：& dp[i-3]+nums[i-1]+nums[i]\\ & \_101：& dp[i-3]+nums[i-2]+nums\left[i\right]\\ & \_\_\_0：& dp[i-1]\end{array}$$

During initialization, the result is guaranteed to be correct when i=1 and i=2.

==================================================== ==========
The above solution is wrong, because it is uncertain whether dp[i-3] will be taken or not! The first case may lead to 0 1 1, the second case may appear 1 0 1, the combination of the two cases is 0 1 1 1 0 1.

In order to determine the situation of taking or not taking, it is necessary to use two arrays choose and ignore

The state transition equation is as follows

$$choose[i]\{\begin{array}{rlr}& 011：& ignore[i-2]+nums[i-1]+nums[i]\\ & \_01：& ignore[i-1]+nums[i]\end{array}$$

$$ignore[i]\{\begin{array}{rl}\_10：& choose[i-1]\\ \_00：& ignore[i-1]\end{array}$$

============================================================

The above method has no problem when the data are all positive integers, but if there are negative numbers, it is easy for three consecutive households not to steal. So the transfer equation of ignore should be modified.

$$choose[i]\{\begin{array}{rlr}& 011：& ignore[i-2]+nums[i-1]+nums[i]\\ & \_01：& ignore[i-1]+nums[i]\end{array}$$

$$ignore[i]\{\begin{array}{rl}\_10：& choose[i-1]\\ 100：& chosse[i-2]\end{array}$$

The initialization of i=0 and i=1 must follow the transfer equation! If it is out of bounds, it is directly regarded as zero.

ignore[0] = 0; ignore[1] = max(0 ,choose[0]);
choose[0] = nums[0], choose[1] = max(nums[0]+nums[1], ignore[0]+nums[1]);

Topic upgrade (Meituan 23 spring)

To upgrade the topic, you cannot steal 2 consecutive households, but there are k chances of violating this rule. What is the maximum value that can be stolen?

We only use a two-dimensional array dp, dp[k][i] means that there are k opportunities, the maximum value that can be obtained by the i-th item, we can choose the i-th item or give it up, these k opportunities are available or not .

$$dp[k][i]\{\begin{array}{rlr}& Use\; the\; opportunity\; for\; thei\; -th\; item:& dp[k-1][i-1]+nums[i]\\ & Opportunities\; are\; not& dp[k][i-1]\end{array}$$