线性动态规划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;
}
};