代码随想录day48

最新推荐文章于 2026-01-05 22:36:07 发布

原创最新推荐文章于 2026-01-05 22:36:07 发布 · 570 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #leetcode #数据结构

文章介绍了四个与打家劫舍问题相关的类Solution实现，涉及动态规划（如dp数组）和递归策略（如对二叉树的处理），展示了在不同场景下求解此类问题的方法。

打家劫舍1

class Solution {
public:
    int rob(vector<int>& nums) 
    {
        int n=nums.size();
        if (nums.size() == 0) return 0;
        if (nums.size() == 1) return nums[0];
        
        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];
    }
};

打家劫舍2

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

        dp2[0]=nums[1];
        dp2[1]=max(nums[1],nums[2]);
        for(int i=2;i<n-1;i++)
        {
            dp2[i]=max(dp2[i-1],dp2[i-2]+nums[i+1]);
        }
        return max(dp1[n-2],dp2[n-2]);
    }
};

打家劫舍3

class Solution {
public:
    int rob(TreeNode* root) {
        vector<int> result = robtree(root);
        return max(result[0],result[1]);
    }
    vector<int>robtree(TreeNode* root)
    {
        if(root==NULL) return {0,0};
        vector<int> left = robtree(root->left);
        vector<int> right = robtree(root->right);
        int v1=root->val+left[0]+right[0];
        int v2=max(left[0],left[1])+max(right[0],right[1]);
        return {v2,v1};
    }
};

打家劫舍4

class Solution {
public:
    int minCapability(vector<int>& nums, int k) 
    {
        //最大最小二分
        vector<int>nums1(nums.begin(),nums.end());
        sort(nums1.begin(),nums1.end());
        int l=nums1[0],r=nums1.back();
        int n=nums.size();
        int dp[n+2];
        while(l<r)
        {
            int m=(l+r)/2;
            memset(dp, 0, sizeof(dp));
            for (int i = 2; i <= n+1; ++ i) 
            {
                if (nums[i-2] <= m) 
                {  
                    dp[i] = max(dp[i-1], dp[i-2] + 1);
                } 
                else 
                {
                    dp[i] = dp[i-1];
                }
            }
            if(dp[n+1]>=k) 
            { 
                r = m;
            } 
            //要求的最大值 太小 偷的次数需要很小  但是最少为k  所以 要求的最大值 变大一点
            else { 
                l= m + 1;
            }
        }
        return r;
    }
};