动态规划题目合集

1.乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
题目链接

1.1题解

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        vector<int> max_dp(nums.size(),0);
        vector<int> min_dp(nums.size(),0);
        max_dp[0]=nums[0];
        min_dp[0]=nums[0];

        for(int i=1;i<nums.size();i++)
        {
            int max=nums[i]*max_dp[i-1];
            int min=nums[i]*min_dp[i-1];

            max_dp[i]=fmax(max,fmax(min,nums[i]));//取最大值
            min_dp[i]=fmin(max,fmin(min,nums[i]));//取最小值
        }

        int max=nums[0];
        for(auto &e:max_dp)
        {
            max=fmax(max,e);
        }
        return max;
    }
};

2.空间优化

由上述分析可知，当前状态至于前面的状态有关，因此可以定义两个变量将最大值和最小值保存起来即可

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int max=nums[0];
        int min=nums[0];

        for(int i=1;i<nums.size();i++)
        {
            int _max=nums[i]*nums[i-1];//当前值*最大值
            int _min=nums[i]*min;//当前值*最小值

            min=fmin(_min,fmin(_max,nums[i]));//将最小值保存起来
            nums[i]=fmax(_max,fmax(nums[i],_min));//将最大值保存起来
            max=fmax(max,nums[i]);//获取最大值
        }
        return max;
    }
};

2.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
题目链接

2.1题解

class Solution {
public:
    int rob(vector<int>& nums) {
      if(nums.size()==1)
      return nums[0];
      if(nums.size()==2)
      return fmax(nums[0],nums[1]);

      vector<int> sum(nums.size(),0);
      sum[0]=nums[0];
      sum[1]=fmax(nums[0],nums[1]);

    //偷昨天的今天不能偷、偷前天的今天可以偷
    //比较两个值之间的大小，选择较大的
      for(int i=2;i<nums.size();i++)
      {
          sum[i]=fmax(sum[i-1],sum[i-2]+nums[i]);
      }

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

2.2空间优化

由于第i天的金额，只与前两天的金额有关系，因此可以定义两个变量进行保存

class Solution {
public:
    int rob(vector<int>& nums) {
      if(nums.size()==1)
      return nums[0];
      if(nums.size()==2)
      return fmax(nums[0],nums[1]);

      int day1=nums[0];
      int day2=fmax(nums[0],nums[1]);
      int sum=day2;

      for(int i=2;i<nums.size();i++)
      {
          sum=fmax(day1+nums[i],day2);
          day1=day2;
          day2=sum;
      }
      return sum;
    }
};

2.3直接在原始空间上进行操作

class Solution {
public:
    int rob(vector<int>& nums) {
      if(nums.size()==1)
      return nums[0];
      if(nums.size()==2)
      return fmax(nums[0],nums[1]);

      nums[1]=fmax(nums[0],nums[1]);
      for(int i=2;i<nums.size();i++)
      {
          nums[i]=fmax(nums[i-1],nums[i-2]+nums[i]);
      }
      return nums[nums.size()-1];
    }
};

3.删除并获得整数

给你一个整数数组 nums ，你可以对它进行一些操作。
每次操作中，选择任意一个 nums[i] ，删除它并获得 nums[i] 的点数。之后，你必须删除每个等于 nums[i] - 1 或 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。
题目链接

class Solution {
public:
    int deleteAndEarn(vector<int>& nums) {
        int min=nums[0];
        int max=nums[0];
        for(auto &e:nums)
        {
            min=fmin(e,min);
            max=fmax(e,max);
        }
        vector<int> arr(max-min+1,0);
        for(auto &e:nums)
        {
            arr[e-min]++;
        }

        if(arr.size()==1)
        return arr[0]*(min);

        arr[0]*=min;
        arr[1]=fmax(arr[0],arr[1]*(min+1));

        for(int i=2;i<arr.size();i++)
        {
            arr[i]=fmax(arr[i-1],arr[i-2]+arr[i]*(i+min));
        }

        return arr[arr.size()-1];

    }
};