Algorithmusfrage Check-in Tag 48 – dynamische Programmierung | 198. Raub, 213. Raub II, 337. Raub III

198. Raub – LeetCode

Status: AC nach Debug.

Es gibt nichts zu sagen, folgen Sie einfach dem Prozess und analysieren Sie ihn. Code wie folgt anzeigen:

class Solution {
public:
    int rob(vector<int>& nums) {
        /*
        dp[i], 到i号房屋的最大收益
        dp[i] = max(dp[i-2]+nums[i], dp[i-1])
        dp[0] = 0, dp[1] = nums[0]
        for(int i = 2; i < nums.size(); ++i)
        [1, 2, 3, 1] dp[1] = 1 | dp[2] = (0+2, 1) = 2 | dp[3] = (1+3, 2) = 4 | dp[4] = (2+1, 4) = 4
        */
        int len = nums.size();
        if(len == 1) return nums[0];
        vector<int> dp(len+1, 0);
        dp[1] = nums[0];
        for(int i = 2; i <= len; ++i){
            dp[i] = max(dp[i-2]+nums[i-1], dp[i-1]);
        }
        return dp[len];
    }
};

213. Raub II – LeetCode

Status: AC nach Prüfung der Ideen.

Im Vergleich zur vorherigen Frage besteht die Änderung darin, dass es zu einem zyklischen Zustand wird, der in drei Zustände unterteilt ist: 1. Ignorieren von Kopf und Schwanz; 2. Kneifen des Kopfes; 3. Entfernen des Schwanzes. Die Fälle 2 und 3 umfassen den ersten Fall, da der DP-Algorithmus je nach Situation prüft, ob der Anfang (das Ende) hinzugefügt werden soll. Die anderen Teile sind die gleichen wie bei der vorherigen Frage, der Code lautet wie folgt:

class Solution {
public:
    int robRange(vector<int>& nums, int begin, int end){
        if(begin == end) return nums[begin];
        vector<int> dp(nums.size());
        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-2] + nums[i], dp[i-1]);
        }
        return dp[end];
    }

    int rob(vector<int>& nums) {
        int len = nums.size();
        if(len == 1) return nums[0];
        int res1 = robRange(nums, 1, len-1);
        int res2 = robRange(nums, 0, len-2);
        return max(res1, res2);
    }
};

337. Raub III – LeetCode

Status: Nein.

Dynamisches Programmierarray, der maximale Vorteil des Stehlens oder Nichtstehlens des aktuellen Knotens (dp[2]), Binärbaum-Traversal-Methode: nachfolgende Traversierung. Code wie folgt anzeigen:

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> res = robTree(root);
        return max(res[0], res[1]);
    }
    vector<int> robTree(TreeNode* cur){
        // [偷，不偷]
        if(cur == nullptr) return vector<int>{0, 0};
        vector<int> left = robTree(cur->left);
        vector<int> right = robTree(cur->right);
        int val1 = cur->val + left[0] + right[0];
        int val2 = max(left[0], left[1]) + max(right[0], right[1]);
        return {val2, val1};
    }
};