【刷题篇】动态规划（六）

1、最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
子数组 是数组中的一个连续部分。

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

2、环形子数组的最大和

给定一个长度为 n 的环形整数数组 nums ，返回 nums 的非空 子数组 的最大可能和 。
环形数组 意味着数组的末端将会与开头相连呈环状。形式上， nums[i] 的下一个元素是 nums[(i + 1) % n] ， nums[i] 的前一个元素是 nums[(i - 1 + n) % n] 。
子数组 最多只能包含固定缓冲区 nums 中的每个元素一次。形式上，对于子数组 nums[i], nums[i + 1], …, nums[j] ，不存在 i <= k1, k2 <= j 其中 k1 % n == k2 % n 。

class Solution {
public://分为两种情况考虑
    int maxSubarraySumCircular(vector<int>& nums) {
        int n=nums.size();
        vector<int> d(n+1),p(n+1);
        int maxi=-0x3F3F3F3F,mini=0x3F3F3F3F,sum=0;
        for(int i=1;i<=n;i++)
        {   
            int x=nums[i-1];
            d[i]=max(x,d[i-1]+x);
            maxi=max(d[i],maxi);
            p[i]=min(x,p[i-1]+x);
            mini=min(mini,p[i]);
            sum+=x;
        } 
        return sum==mini?maxi:max((sum-mini),maxi);
    }
};

3、乘积最大子数组

给你一个整数数组 nums ，请你找出数组中乘积最大的非空连续子数组（该子数组中至少包含一个数字），并返回该子数组所对应的乘积。
测试用例的答案是一个 32-位 整数。
子数组 是数组的连续子序列

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        int n=nums.size();//d最大值，p最小值
        vector<int> d(n+1),p(n+1);
        d[0]=p[0]=1;

        int maxi=-0x3F3F3F3F;
        for(int i=1;i<=n;i++)
        {
            int x=nums[i-1],a=d[i-1]*nums[i-1],b=p[i-1]*nums[i-1];
            d[i]=max(x,max(a,b));
            p[i]=min(x,min(a,b));
            maxi=max(maxi,d[i]);
        }   
        return maxi;
    }
};

4、乘积为正数的最长子数组长度

给你一个整数数组 nums ，请你求出乘积为正数的最长子数组的长度。
一个数组的子数组是由原数组中零个或者更多个连续数字组成的数组。
请你返回乘积为正数的最长子数组长度。

class Solution {
public:
    int getMaxLen(vector<int>& nums) {
        int n=nums.size();
        vector<int> d(n+1),p(n+1);//一个放正数，一个放负数
        d[0]=p[0]=0;
        int maxi=-0x3F3F3F3F;
        for(int i=1;i<=n;i++)
        {
            if(nums[i-1]>0)
            {
                d[i]=d[i-1]+1;
                p[i]=p[i-1]==0?0:p[i-1]+1;
            }
            else if(nums[i-1]<0)
            {
                d[i]=p[i-1]==0?0:p[i-1]+1;
                p[i]=d[i-1]+1;
            }
            maxi=max(maxi,d[i]);
        }
        return maxi;
    }   
};

5、 等差数列划分

如果一个数列 至少有三个元素 ，并且任意两个相邻元素之差相同，则称该数列为等差数列。
例如，[1,3,5,7,9]、[7,7,7,7] 和 [3,-1,-5,-9] 都是等差数列。
给你一个整数数组 nums ，返回数组 nums 中所有为等差数组的 子数组 个数。
子数组 是数组中的一个连续序列。

class Solution {
public:
    int numberOfArithmeticSlices(vector<int>& nums) {
        int n=nums.size();
        vector<int> dp(n);
        
        int sum=0;
        for(int i=2;i<n;i++)
        {
            dp[i]=nums[i]-nums[i-1]==nums[i-1]-nums[i-2]?dp[i-1]+1:0;
            sum+=dp[i];
        }
        return sum;
    }
};

6、最长湍流子数组

给定一个整数数组 arr ，返回 arr 的 最大湍流子数组的长度 。
如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是 湍流子数组 。
更正式地来说，当 arr 的子数组 A[i], A[i+1], …, A[j] 满足仅满足下列条件时，我们称其为湍流子数组：

class Solution {
public:
    int maxTurbulenceSize(vector<int>& arr) {
        int n=arr.size();
        vector<int> d(n,1),p(n,1);
        if(n==1)
            return 1;
        int maxi=-0x3F3F3F3F;
        for(int i=1;i<n;i++)
        {
            if(arr[i-1]<arr[i])
                d[i]=p[i-1]+1;
            else if(arr[i-1]>arr[i])
                p[i]=d[i-1]+1;
            maxi=max(maxi,max(d[i],p[i]));
        }
        return maxi;
    }
};