打家劫舍系列

class Solution {
public:
    int dp[105];
    //dp[i]表示偷取前i个房间获取的最大值
    int rob(vector& nums) {
    //    // dp[i][0];不偷取第i间房，偷取前i-1间房的最大值
    //     //dp[i][1];偷取第i间房，偷取前i间房的最大值
    //     memset(dp,0,sizeof(dp));
    //     dp[0][0]=0;
    //     dp[0][1]=nums[0];
    //     for(int i=1;i

class Solution {
public:
     int dp[105];
    int rob(vector& nums) {
        //考虑0——n-2
         memset(dp,0,sizeof(dp));
          int n=nums.size();
          if(n<=1)
          {
              return nums[0];
          }
         dp[0]=nums[0];
         dp[1]=nums[0];
        
         for(int i=2;i

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector dfs(TreeNode* root)
    {
        vectorres;
        vectors1(2,0);
        vectors2(2,0);
        //val表示偷根节点
        int val=root->val;
        //val0表示不偷根节点
        int val0=0;
     
        if(root->left!=NULL)
        {
             s1=dfs(root->left);
             val0+=max(s1[0],s1[1]);
             val+=s1[1];
        }
        if(root->right!=NULL)
        {
            s2=dfs(root->right);
            val0+=max(s2[0],s2[1]);
            val+=s2[1];
        }
        res.push_back(val);
        res.push_back(val0);
        return res;
    }
    int rob(TreeNode* root) {
        vectorres;
        res= dfs(root);
        return max(res[0],res[1]);
    }
};

 

class Solution {
public:
    int dp[100005];
    int minCapability(vector& nums, int k) {
        int right=*max_element(nums.begin(),nums.end());
          if(nums.size()==1)
            {
                return nums[0];
            }
        int left=0;
        while(left+1mid)
            {
                dp[0]=0;
            }
            else{
                 dp[0]=1;
            }
            if(nums[1]<=mid && dp[0]==0)
            {
                dp[1]=1;
            }
            else{
                dp[1]=dp[0];
            }
            
            for(int i=2;imid)
                {
                    dp[i]=max(dp[i-1],dp[i-2]);
                }
                else{
                    dp[i]=max(dp[i-2]+1,dp[i-1]);
                }
            }
            // int x0=0;//
            // int x1=0;//前i位取得的最大值
            // for(int i=0;imid) x0=x1;
            //    else{
            //        int t=x1;
            //        x1=max(x0+1,t);
            //        x0=t;
            //    }
            // }
            int x1=dp[nums.size()-1];
            if(x1>=k)
            {
                right=mid;
            }
            else{
                left=mid;
            }
        }
        return right;
        // = *max_element(nums.begin(), nums.end());
    }
};