leetcode刷题笔记_线性动态规划1

线性动态规划1

状态的推导是按照问题规模 i 从小到大依次推过去的，较大规模的问题的解依赖较小规模的问题的解。

单串

• 第一种是前面dp[i-1]是已知的，i 位置必须取 --比如前面提到的硬币题，就是考虑前k-1个硬币已经是最小了，只需要加入第k枚硬币就能求得最终的答案
• 第二种是前面dp[i-1]已知，i 位置必须取。也就是考虑前面dp[i-1]的最优解+加入第i个数是否最优–比如前面提到的最长上升子序列，就是在已知的上升序列的最大值的基础上考虑是否加入第i个数

题组1：最长上升序列

T1:最长上升子序列

https://leetcode-cn.com/problems/longest-increasing-subsequence/

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/dynamic-programming-1-plus/5oqnpg/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        //状态：dp[i]表示加入第i个数字的最长子序列
        //边界条件：加入第i个数字之后的最小值是1
        vector<int> dp(nums.size(),1);
        //初始条件
        dp[0]=1;
        for(int i=0;i<nums.size();i++)
        {
            for(int j=0;j<i;j++)
            {
                //加入第i个数字之后的最长子序列=前面i-1个数字的最长子序列+加入或不加入第i个数字的最长子序列
                //只有构成递增序列，最长子序列才能增加
                if(nums[j]<nums[i])
                {
                    dp[i]=max(dp[j]+1,dp[i]);
                }
            }
        }
        //遍历dp数组，找到最大值
        return *max_element(dp.begin(), dp.end());


    }
};

T2:最长递增子序列的个数

给定一个未排序的整数数组，找到最长递增子序列的个数。

https://leetcode-cn.com/leetbook/read/dynamic-programming-1-plus/5o6mrv/

class Solution {
public:
    int findNumberOfLIS(vector<int>& nums) {
        int n=nums.size();
        //记录以i结尾的最大子序列的个数
       vector<int> count(n,1);
        //状态：dp[i]表示加入第i个数之后的最长递增子序列
        
        //初始状态：加入第i个数的最长子序列最小为1,长度为1的子序列有1个
        vector<int> dp(n,1);
     
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                //转移方程：当加入第i个数之后构成递增序列，那么最长递增序列等于前i-1个数的最长递增序列+1
                //也就是遍历0-(i-1)找到最大值+1
                if(nums[j]<nums[i])
                {                  
                    //两种情况：第一种是加入选择前j个数的最大子序列+1比当前存的dp[i]大
                    //这个时候dp[i]要更新为更大的值，那么序列长度更新dp[j]的个数
                    if(dp[j]+1>dp[i])
                    {
                        dp[i]=dp[j]+1;
                        count[i]=count[j];
                        //第二种情况是选择前j个数之后的最大子序列+1和当前存的dp[i]一样
                        //那就把原来的序列个数dp[i]个数加上dp[j]的个数
                    }else if(dp[j]+1==dp[i])
                    {
                        count[i]=count[i]+count[j];
                    }
                    
                }
            }
        }
        int res=0;
        //找到最长的序列maxlen
        int maxlen=*max_element(dp.begin(),dp.end());
        for(int i=0;i<n;i++)
        {
            if(dp[i]==maxlen)
                res=res+count[i];
        }
        return res;

    }
};

T3:俄罗斯套娃信封问题

https://leetcode-cn.com/problems/russian-doll-envelopes/

class Solution {
public:
    //这题要考虑长和宽两个维度，只需要先对一个维度进行排序，然后另一个维度找最大子序列即可
    int maxEnvelopes(vector<vector<int>>& envelopes) {
        sort(envelopes.begin(),envelopes.end());
        //状态：最多有x的信封，那么去掉最后一个信封就是有x-1个信封
        //所以dp[i]=加入第i个信封最多能组成一组“俄罗斯套娃”信封的信封个数
        vector<int> dp(envelopes.size(),1);
        //初始状态：加入第i个信封组成的俄罗斯套娃的个数至少有1个
        for(int i=0;i<envelopes.size();i++)
        {
            for(int j=0;j<i;j++)
            {
                //加入第i个信封的最大值=前i-1个信封的最大值+是否加入第i个信封
                if(envelopes[i][1]>envelopes[j][1]&&envelopes[i][0]>envelopes[j][0])
                {
                    dp[i]=max(dp[j]+1,dp[i]);
                }
            }
        }
        return *max_element(dp.begin(),dp.end());

    }
};

题组2：最大子数组和

T4:最大子序和

https://leetcode-cn.com/problems/maximum-subarray/

class Solution {
public:
    int maxSubArray(vector<int>& nums) {

        //状态：加入nums[i]的最大连续子数组的最大和
        int preSum=nums[0];
        //初始条件：最大和为0
        int maxSum=0;
        
        for(int i=0;i<nums.size();i++)
        {
            //状态方程
            //对于nums[i]这个数有两种可能，要么加入到上一个最大连续数组中，那值就是nums[i]+preSum
            //要么就单独开一个数组，值是nums[i],取最大值就可以求得是否加入nums[i]能获得最大连续子数组
            preSum=max(nums[i],preSum+nums[i]);
            //判断当前的子数组最大和是不是最大的,只要比前一个大就是最大的
            maxSum=max(maxSum,preSum);
        }
        return maxSum;

    }
};

T5:乘积最大子组数

https://leetcode-cn.com/problems/maximum-product-subarray/

暴力的dp，超时了

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if(nums.size()==0)
            return 0;
        //1.状态：加入第i个数之后获得了乘积最大的子数组，最大乘积为maxPro[i]
        //上一个状态，得到了加入第i-1个数之后的最大或者最小子数组,最大乘积为minPro[i]
        //2.初始状态：不加入任何数组，最大乘积为0
        vector<int>maxPro(nums.size(),nums[0]);
        vector<int>minPro(nums.size(),nums[0]);
        
        for(int i=0;i<nums.size();i++)
        {
            for(int j=0;j<i;j++)
            {
                //3.状态转移方程
                //当前的最大值是上一个最大值*当前数字或者上一个最小值*当前数字
                maxPro[i]=max(maxPro[j]*nums[i],max(minPro[j]*nums[i],nums[i]));
                //当前的最小值是上一个最大值*当前数字或者上一个最小值*当前数字
                minPro[i]=min(maxPro[j]*nums[i],min(minPro[j]*nums[i],nums[i]));
            }
            
        }
        return *max_element(maxPro.begin(),maxPro.end());


    }
};

其实可以不需要两层for循环，可以用数组来记录遍历到当前数字的最大最小值，然后看这个数要不要加入之前的序列

class Solution {
public:
    int maxProduct(vector<int>& nums) {
        if(nums.size()==0)
            return 0;
        //1.状态：加入第i个数之后获得了乘积最大的子数组，最大乘积为maxPro[i]
        //上一个状态，得到了加入第i-1个数之后的最大或者最小子数组,最大乘积为minPro[i]
        //2.初始状态：不加入任何数组，最大乘积为0
        vector<int>maxPro(nums.size(),nums[0]);
        vector<int>minPro(nums.size(),nums[0]);
        
        for(int i=1;i<nums.size();i++)
        {           
                //3.状态转移方程
                //当前的最大值是上一个最大值*当前数字或者上一个最小值*当前数字
                maxPro[i]=max(maxPro[i-1]*nums[i],max(minPro[i-1]*nums[i],nums[i]));
                //当前的最小值是上一个最大值*当前数字或者上一个最小值*当前数字
                minPro[i]=min(maxPro[i-1]*nums[i],min(minPro[i-1]*nums[i],nums[i]));
                       
        }
        return *max_element(maxPro.begin(),maxPro.end());


    }
};

T6:环形子数组最大和

https://leetcode-cn.com/problems/maximum-sum-circular-subarray/

class Solution {
public:
    int maxSubarraySumCircular(vector<int>& nums) {
      //两种情况，一种是最大值在原数组中取到，那就直接求最长子序列
      //第二种情况是在环形数组中取到，说明取了最后一个数和第一个数，那么说明第二个数到第n-1个数有负数和，使得加到最后一个数和变小了，那只需要数组的和减去最小负数和（绝对值最大）就是最大的和  
        int n=nums.size();
        if(n==0)
            return 0;
        
        int curMax=nums[0],curMin=nums[0],maxSum=nums[0],minSum=0,sum=nums[0];
       
        for(int i=1;i<n;i++)
        {
             //求前n个数最大和
            curMax=max(curMax+nums[i],nums[i]);
            maxSum=max(curMax,maxSum);          
            //求前n个数和
            sum=sum+nums[i];
        }
         for(int i=1;i<n-1;i++)
        {           
             //求前n-1个数最小和
             curMin=min(curMin+nums[i],nums[i]);
             minSum=min(curMin,minSum);
             
        }

        return max(maxSum,sum-minSum);
        //return maxSum;
        

    }
};

T7：最大子矩阵

https://leetcode-cn.com/problems/max-submatrix-lcci/

T8：矩形区域不超过K的最大数值和

https://leetcode-cn.com/problems/max-sum-of-rectangle-no-larger-than-k/

七八两题真写不出来，太难了

题组3：打家劫舍

T9:打家劫舍

https://leetcode-cn.com/leetbook/read/dynamic-programming-1-plus/5rwy97/

对于每一间房子有两种可能，偷或者不偷

如果偷，那么到这一间房子的最大金额=这一间房子的钱+再往前2间房的钱

如果不偷，那么到这一间房子的最大金额=前一间房子的钱

class Solution {
public:
    int rob(vector<int>& nums) {
        int n=nums.size();
        //状态：dp[i]表示是否偷窃i号房屋所获得的最大金额
        
        if(n==0)
            return 0;
        if(n==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++)
        {
            //最后偷的是last号房间，那就是偷last-2获得最大金额+last房子的金额
        	//最后不偷last房间，那就是偷last-1获得的最大金额
            dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[n-1];
    }
};

T10:打家劫舍Ⅱ

https://leetcode-cn.com/problems/house-robber-ii/

• 关键在于第一家和最后一家不能同时偷，那就分别计算偷第一家不偷最后一家，偷最后一家不偷第一家，第一家和最后一家都不偷的最大值就行

class Solution {
public:
    //偷非环的房屋的最大金额,start和end分别表示起止坐标
    int robHome(vector<int>& nums,int begin,int end)
    {
        int n=end-begin+1;
        //状态：dp[i]表示是否偷窃i号房屋所获得的最大金额        
        if(n==0)
            return 0;
        if(n==1)
            return nums[begin];    
        vector<int> dp(n+1,0);
        //初始条件
        dp[begin]=nums[begin];
        dp[begin+1]=max(nums[begin],nums[begin+1]);
        for(int i=begin+2;i<=end;i++)
        {
            //最后偷的是last号房间，那就是偷last-2获得最大金额+last房子的金额
        	//最后不偷last房间，那就是偷last-1获得的最大金额
            dp[i]=max(dp[i-2]+nums[i],dp[i-1]);
        }
        return dp[end];
    }
    int rob(vector<int>& nums) {
        int n=nums.size();  
        if(n==0)
            return 0;
        if(n==1)
            return nums[0]; 
        //就是不能同时偷第一家和最后一家
        //只偷第一家
        int max1=robHome(nums,0,n-2);
        //偷最后一家不偷第一家
        int max2=robHome(nums,1,n-1);
        //第一家和最后一家都不偷
        int max3=robHome(nums,1,n-1);
        return max(max1,max(max2,max3));        
    }
};

T11:删除与获得点数

https://leetcode-cn.com/problems/delete-and-earn/

• 首先计算一下删除每个数字可以获得的最大点数
• 然后就和打家劫舍一样不能删除相邻的数字

class Solution {
public:
    int deleteAndEarn(vector<int>& nums) {
        if(nums.size()==0)
            return 0;
        if(nums.size()==1)
            return nums[0];
        
        
        vector<int> num(10001,0);
        for(int i=0;i<nums.size();i++)
        {
            num[nums[i]]+=nums[i];
        }
        //dp[i]=删除这个数之后所获得的最大点数
        vector<int> dp(10001,0);
        sort(nums.begin(),nums.end());
        dp[0]=num[0];
        dp[1]=max(num[1],dp[0]);
        for(int i=2;i<10001;i++)
        {
            dp[i]=max(dp[i-1],dp[i-2]+num[i]);
        }
        
        return dp[10000];
    }
};

T12:3n块披萨

https://leetcode-cn.com/problems/pizza-with-3n-slices/

• 遇到困难，睡大觉

题组4：需要两个位置的情况

T13:最长的斐波那契子序列的长度

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& A) {
        int n=A.size();
        if(n<3)return 0;
        int res=0;
        //找状态：dp[i][j]=以A[i][j]结尾的序列的最大长度
        //找初始条件：dp[0][1]=2,一开始每个结尾的子序列都可以初始化为2
        vector<vector<int>>dp(n,vector<int>(n,2));
        //边界条件 A[j]-A[i]是序列中A[i],A[j]的前一个数
        //因为整个数组是严格递增的，也就是说只要以A[j]-A[i]结尾的数存在且值小于A[i]即可
        //判断存在
        map<int,int> mp;
        for(int i=0;i<n;i++)
            mp[A[i]]=i;
        for(int j=1;j<n;j++)
        {
            for(int i=0;i<j;i++)
            {
                //最大子序列对应的数(A[j]-A[i],A[i],A[j])
                //对应的坐标(mp[A[j]-A[i]],i,j)
                //因为整个数组是严格递增的，也就是说只要以A[j]-A[i]结尾的数存在且值小于A[i]即可
                if(A[j]-A[i]<A[i]&&mp.find(A[j]-A[i])!=mp.end())
                {
                    dp[i][j]=max(dp[i][j],dp[mp[A[j]-A[i]]][i]+1);
                    res=max(res,dp[i][j]);
                }
                
            }
            
        }
        return res;
    }
};

T14:最长等差数列

https://leetcode-cn.com/problems/longest-arithmetic-subsequence/

class Solution {
public:
    int longestArithSeqLength(vector<int>& nums) {
        int n=nums.size();
        if(n<3)
            return 0;
        vector<vector<int>> dp(n,vector<int>(20000,1)); //dp[i][j]=以nums[i]为结尾,以j为差值的子序列的数列
        int maxlen=0;      
        for(int i=1;i<nums.size();i++)//遍历当前数
        {
            for(int j=0;j<i;j++)//遍历上一个数
            {          
                int k=nums[j]-nums[i]+10000;//差值
                //两个数的差值是k,那就是差值是k，结尾为j的数列再+1，不然就是当前数另起一个数列
                dp[i][k]=max(dp[j][k]+1,dp[i][k]);
                maxlen=max(maxlen,dp[i][k]);
                
            }
        }
        return maxlen;

    }
};