一、动归引入
leetcode 70. 爬楼梯
class Solution { public: int climbStairs(int n) { map<int,int>donser; for(int i=1;i<=n;i++) { if(i==0||i==1||i==2) donser[i]=i; else donser[i]=donser[i-1]+donser[i-2]; } return donser[n]; } }; ------------------------------------------------------------------------ class Solution { public: int climbStairs(int n) { if(n<=3) return n; int now=3,last_1=2,last_2=1; for(int i=3;i<=n;i++) { now=last_1+last_2; last_2=last_1; last_1=now; } return now; } };
leetcode 198. 打家劫舍
前一个位置取了值，下一个位置就不能再取，寻找最大的组合。dp[i]表示抢了i处以后的最大总金额，dp[i]=maxl+nums[i] (maxl=(maxl>dp[0->i-1]?maxl:dp[0->i-1]))
class Solution { public: int rob(vector<int>& nums) { if(nums.size()==0) return 0; if(nums.size()<2) return nums[0]; vector<int>dp(nums.size(),0); dp[0]=nums[0]; dp[1]=nums[1]; for(int i=2;i<nums.size();i++) { int maxl=0; for(int j=0;j<i-1;j++) maxl=(maxl>dp[j]?maxl:dp[j]); dp[i]=maxl+nums[i]; } return (dp[nums.size()-1]>dp[nums.size()-2]?dp[nums.size()-1]:dp[nums.size()-2]); } };
leetcode 213. 打家劫舍 II
在上一题基础上做了首尾相连，也就是头和尾只能选一个。改进方法就是分别查找不含头的最大价值和不含尾的最大价值，输出二者中的最大值
#include<map> class Solution { public: int deal(vector<int>& nums) { vector<int>dp(nums.size(),0); dp[0]=nums[0]; dp[1]=nums[1]; for(int i=2;i<nums.size();i++) { int maxl=0; for(int j=0;j<i-1;j++) maxl=(maxl>dp[j]?maxl:dp[j]); dp[i]=maxl+nums[i]; } return (dp[nums.size()-1]>dp[nums.size()-2]?dp[nums.size()-1]:dp[nums.size()-2]); } int rob(vector<int>& nums) { if(nums.size()==0) return 0; if(nums.size()==1) return nums[0]; if(nums.size()==2) return max(nums[0],nums[1]); vector<int> num1,num2; for(int i=0;i<nums.size();i++) { if(i==0) { num2.push_back(nums[i]); continue; } if(i==nums.size()-1) { num1.push_back(nums[i]); continue; } num1.push_back(nums[i]); num2.push_back(nums[i]); } return max(deal(num1),deal(num2)); } };
递推 f(n,x)=f(n-1,x-1)+f(n-1,x-2)+f(n-1,x-3)+f(n-1,x-4)+f(n-1,x-5)+f(n-1,x-6)
class Solution { public: int f(int n,int x,vector<vector<int> >&dp) { if(x<=0||n<=0) return 0; if(dp[n][x]!=0) return dp[n][x]; int sum=0; for(int i=1;i<=6;i++) { sum+=f(n-1,x-i,dp); } dp[n][x]=sum; return sum; } vector<double> twoSum(int n) { vector<vector<int> >dp(n+1,vector<int>(6*n+1,0)); vector<double>result; for(int i=1;i<=6;i++) dp[1][i]=1; int sum=0,ll=0; for(int x=n;x<=int((n*6+n)/2);x++) { ll=f(n,x,dp); sum+=ll; result.push_back(ll); } int size=result.size(); sum*=2; if(n%2==0) sum-=ll; for(int i=size-1;i>=0;i--) { if(n%2==0&&i==size-1) { result[i]=result[i]/sum; continue; } result[i]=result[i]/sum; result.push_back(result[i]); } return result; } };
72. 编辑距离
递推三个状态：
替换：到dp[i-1][j-1]到k步，那么word1[i-1]==word2[j-1]时dp[i][j]要k步，≠时k+1步
删除：到dp[i-1][j]要k步，那么到dp[i][j]要k+1步
添加：到dp[i][j-1]要k步，那么到dp[i][j]要k+1步
const int inf = 0x3f3f3f3f; class Solution { public: int minDistance(string word1, string word2) { int a=word1.size(); int b=word2.size(); if(a==0||b==0) return a+b; vector<vector<int> >dp(a+1,vector<int>(b+1,inf)); for(int i=0;i<=a;i++) dp[i][0]=i; for(int j=0;j<=b;j++) dp[0][j]=j; for(int i=1;i<=a;i++) { for(int j=1;j<=b;j++) { if(word1[i-1]==word2[j-1]) dp[i][j]=min(dp[i-1][j-1],dp[i][j]); else dp[i][j]=min(dp[i-1][j-1]+1,dp[i][j]); dp[i][j]=min(dp[i-1][j]+1,dp[i][j]); dp[i][j]=min(dp[i][j-1]+1,dp[i][j]); } } /*for(int i=1;i<=a;i++) { for(int j=1;j<=b;j++) { cout<<dp[i][j]<<" "; } cout<<endl; }*/ return dp[a][b]; } };
5. 最长回文子串
设dp[i][j]==1表示从i到j是一个回文串
dp[i][j]=1的条件是dp[i+1][j-1]==1且s[i]==s[j]
特殊情况*bb*这样子，判断一下j-i是不是==1，是的话dp[i][j]=1
class Solution { public: string longestPalindrome(string s) { if(s.size()<=1) return s; int size=s.size(); int max_len=1; int start=0; vector<vector<int> >dp(size,vector<int>(size,0)); for(int i=0;i<size;i++)//对角线置1 dp[i][i]=1; for(int i=size-1;i>=0;i--) { for(int j=i+1;j<size;j++) { if(s[i]==s[j]) { if(j-i==1)//处理bb情况 { dp[i][j]=1; max_len=max(max_len,j-i+1); if(max_len==j-i+1) start=i; } else if(dp[i+1][j-1]==1) { dp[i][j]=dp[i+1][j-1]; max_len=max(max_len,j-i+1); if(max_len==j-i+1) start=i; } } } } return s.substr(start,max_len); } };
二、0-1背包
01背包经典模板
01背包列出了所有可用的元素，每个元素可用一次或者不用。
n是n件物品，m是背包最大容量，v[]存每件物品的价值，w[]存每件物品的体积，
f[]维护一个一维数组：f(m) 当前背包容量为m的情况下取得的价值为f(m)
状态转移方程：f(m)=max( f(m) , f(m-w[i])+v[i] ) 表示不选当前物品 或者 选择当前物品
容量从大到小遍历，那么到最后的f[m]取决的结果是基于上一物品选择
#include<bits/stdc++.h> using namespace std; const int N=1010; int f[N]; int v[N],w[N]; int n,m; int main() { cin>>n>>m; for(int i=0;i<n;i++) cin>>v[i]>>w[i]; for(int i=0;i<n;i++) for(int j=m;j>=w[i];j--) f[j]=max(f[j],f[j-w[i]]+v[i]); cout<<f[m]<<endl; }
leetcode 416. 分割等和子集
class Solution { public: bool canPartition(vector<int>& nums) { int sum=0; vector<int>v,w,f;//v存价值 w存体积 f[i]=j表示容积为i时价值为j for(int i=0;i<nums.size();i++) { sum+=nums[i]; v.push_back(nums[i]); w.push_back(nums[i]); } if(sum%2==1) return false; sum/=2;//背包容量为sum for(int i=0;i<=sum;i++)//初始化f f.push_back(0); for(int i=0;i<nums.size();i++) { for(int j=sum;j>=w[i];j--) { f[j]=max(f[j],f[j-w[i]]+v[i]); } } if(f[sum]==sum) return true; return false; } };
leetcode 474. 一和零
本题是01背包的扩展，二维费用背包，有两个费用指标，多加一层内循环即可
class Solution { public: int findMaxForm(vector<string>& strs, int m, int n) { vector<int>goods_0; vector<int>goods_1; vector<vector<int>>dp(m+1,vector<int>(n+1,0)); for(int i=0;i<strs.size();i++)//创建输入 { string tmp=strs[i]; int x=0,y=0; for(int j=0;j<tmp.size();j++) { if(tmp[j]=='0') x++; if(tmp[j]=='1') y++; } goods_0.push_back(x); goods_1.push_back(y); } for(int i=0;i<strs.size();i++) for(int j=m;j>=goods_0[i];j--) for(int k=n;k>=goods_1[i];k--) dp[j][k]=max(dp[j][k],dp[j-goods_0[i]][k-goods_1[i]]+1); return dp[m][n]; } };
leetcode 494. 目标和
01背包的变体，即：每一个数字都要用，每一个数字或是加或是减，下标需要平移到正数
dp[i][j]=A表示截止到第i+1个数，这i+1个数的数字和为j时的方案数为A个。 状态转移方程：dp[i][j]=dp[i-1][j-nums[i]]+dp[i-1][j+nums[i]]
class Solution { public: int findTargetSumWays(vector<int>& nums, int S) { int count=0; for(int i=0;i<nums.size();i++) count+=nums[i]; if(count<S) return 0; vector<vector<int>>dp(nums.size()+1,vector<int>((count+2)*2,0)); dp[0][nums[0]*(-1)+count]+=1; dp[0][nums[0]+count]+=1; for(int i=1;i<nums.size();i++) { for(int j=0;j<=count*2;j++) { int x=(j-nums[i])>0?(j-nums[i]):0; int y=(j+nums[i])<=count*2?(j+nums[i]):0; dp[i][j]=dp[i-1][x]+dp[i-1][y]; } } return dp[nums.size()-1][abs(S)+count]; } };
三、最长公共子序列
leetcode 1143. 最长公共子序列
分析，两串匹配串放在一起组成一个二维表，逐层更新表内内容，直到最后。
状态转移方程：A==B时 dp[i][j]=dp[i-1][j-1]+1
A!=B时 dp[i][j]=max( dp[i-1][j] , dp[i][j-1] )
class Solution { public: int longestCommonSubsequence(string text1, string text2) { vector<vector<int>> dp(text2.size()+1,vector<int>(text1.size()+1,0));//初始化 for(int i=1;i<=text2.size();i++) { char A=text2[i-1]; for(int j=1;j<=text1.size();j++) { char B=text1[j-1]; if(A==B) dp[i][j]=dp[i-1][j-1]+1; else dp[i][j]=max(dp[i-1][j],dp[i][j-1]); } } return dp[text2.size()][text1.size()]; } };
优化：将二维数组改成只有两行的数组节省空间，原理：原来解法的更新只看两行继续存着意义不大，因此只留两行
class Solution { public: int longestCommonSubsequence(string text1, string text2) { vector<vector<int>> dp(2,vector<int>(text1.size()+1,0)); for(int i=1;i<=text2.size();i++) { char A=text2[i-1]; for(int j=1;j<=text1.size();j++) { char B=text1[j-1]; if(A==B) dp[i&1][j]=dp[(i-1)&1][j-1]+1; else dp[i&1][j]=max(dp[(i-1)&1][j],dp[i&1][j-1]); } } return dp[text2.size()&1][text1.size()]; } };
四、最长上升子序列
leetcode 300. 最长上升子序列
分析：在一个数字串中寻找最长上升，用一个一维dp。dp[i]表示截至当前i位置最长的上升序列
状态转移方程：dp[i]=max(dp[j]+1 j: 0->i-1)
class Solution { public: int maxl(vector<int>&dp) { int max=0; for(int i=0;i<dp.size();i++) { if(dp[i]>max) max=dp[i]; } return max; } int lengthOfLIS(vector<int>& nums) { vector<int>dp(nums.size(),0); for(int i=0;i<nums.size();i++) { int lable=0; if(i==0) { dp[i]=1; continue; } for(int j=i-1;j>=0;j--) { if(nums[j]<nums[i]&&dp[i]<dp[j]+1) { dp[i]=dp[j]+1; lable=1; } } if(lable==0) dp[i]=1; } return maxl(dp); } }; --------------------------------------------------------------- 优化 dp初值付1这样就不要lable了 class Solution { public: int maxl(vector<int>&dp) { int max=0; for(int i=0;i<dp.size();i++) { if(dp[i]>max) max=dp[i]; } return max; } int lengthOfLIS(vector<int>& nums) { vector<int>dp(nums.size(),1); for(int i=0;i<nums.size();i++) { for(int j=i-1;j>=0;j--) { if(nums[j]<nums[i]&&dp[i]<dp[j]+1) dp[i]=dp[j]+1; } } return maxl(dp); } };
五、完全背包
完全背包相比于01背包，每件物品可以取无限多次，完全背包的核心代码：(简记和01背包的不同之处在于第二层循环)
dp[m]表示的就是当容量<=m时的最优解是多少，可能背包并没有装满。如果需要恰好容量==m时的最优解是多少，初始化dp[0]=0 其他的初始化为-∞
dp[j]表示容量最大为j时所能存放的最大价值。 状态转移方程：dp[j]=max(dp[j],dp[j-v[i]]+w[i])
for(int i=0;i<N;i++) for(int j=v[i];j<=m;j++) dp[j]=max(dp[j],dp[j-w[i]]+v[i]);
leetcode 322. 零钱兑换
这道题不是纯的完全背包，因为恰好装满背包的方法有无数种，而本体需要的结果是所有结果中所用数量最少的那一个解
dp[j]表示容量最大为j时所用的最少硬币数量。 状态转移方程：dp[j]=min(dp[j],dp[j-w[i]]+1)
#define MAX 999999 int minl(int a,int b) { return (a>b?b:a); } class Solution { public: int coinChange(vector<int>& coins, int amount) { vector<int>dp(amount+1,MAX); dp[0]=0; for(int i=0;i<coins.size();i++) { for(int j=coins[i];j<=amount;j++) { dp[j]=minl(dp[j],dp[j-coins[i]]+1); } } return (dp[amount]==MAX?-1:dp[amount]); } };
leetcode 518. 零钱兑换 II
和上一题的不同之处在于，本题要求解的是所有装满背包的组合数目
dp[j]表示装满容量j时的可能的组合数目。 状态转移方程：dp[j]=dp[j]+dp[j-w[i]]
class Solution { public: int change(int amount, vector<int>& coins) { vector<int>dp(amount+1,0); dp[0]=1; for(int i=0;i<coins.size();i++) { for(int j=coins[i];j<=amount;j++) { dp[j]=dp[j]+dp[j-coins[i]]; } } return dp[amount]; } };
六、多重背包
多重背包可以看作是01背包的扩展，每一件物品最多有固定个，简单的来理解就是内层多加一个循环遍历物品数量
dp[j]表示容量为j时物品最大的价值。 状态转移方程：dp[j]=max(dp[j] , dp[j-w[i]]+v[i] , dp[j-2*w[i]]+2*v[i] , ......，dp[j-k*w[i]]+k*v[i] ) 设有最多k个物品i
for(int i=0;i<n;i++) for(int j=m;j>=v[i];j--) for(int k=1;k<=s&&j-k*w[i]>=0;k++) f[j]=max(f[j],f[j-k*w[i]]+k*v[i]);
多重背包的二进制优化
原理：物品A（价值v重量w）有7个，如果全都列举出来就是{（0*v，0*w），（1*v，1*w），......，（7*v，7*w）}，这样再当作01背包来做时间复杂度太高
改进：由于2^0=1，2^1=2，2^2=4 ，1 2 4 可以组成0~7的所有情况，所以只需{（1*v，1*w），（2*v，2*w），（4*v，4*w）}就可以表示所有的可能性
再如10 2^0=1，2^1=2，2^2=4。1 2 4 可以组成0~7的所有情况，10-7=3 ，还需要加入一个3 ，只需{（1*v，1*w），（2*v，2*w），（3*v，3*w），（4*v，4*w）}就可以表示所有的可能性
共有n个物品，背包总重量为m。 物品i 的价值为v，重量为w，最多个数为s struct Good { int v,w };//存价值和重量 int main() { '''''' for(int i=0;i<n;i++) { cin>>v>>w>>s; for(int k=1;k<=s;k*=2) { s-=k; goods.push_back({v*k,w*k}); } if(s>0) goods.push_back(v*s,w*s); } '''''''' 同01背包 }
七、买股票问题
买股票问题可以用一个模型来解决：参考文章
dp[i][k][j]=W表示第i天，剩余可交易次数为k，j=0未持有股票 j=1持有股票
dp[i][k][0]=max( dp[i-1][k][0] , dp[i-1][k][1]+prise[i] ) 当前i天未持有股票 -> 前一天就没有持有 或者 前一天持有今天卖出了
dp[i][k][1]=max( dp[i-1][k][1] , dp[i-1][k-1][0]-prise[i] ) 当前i天持有股票 -> 前一天就持有 或者 前一天未持有今天买入了
k当只能交易一次，或者可以交易无限次时无效直接去掉。
只能交易一次dp[i-1][k-1][0]项无效去掉
leetcode 121. 买卖股票的最佳时机 交易一次
class Solution { public: int maxProfit(vector<int>& prices) { if(prices.size()==0) return 0; vector<vector<int>>dp(prices.size(),vector<int>(2,0)); dp[0][0]=0; dp[0][1]=-1*prices[0]; for(int i=1;i<prices.size();i++) { dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]); dp[i][1]=max(dp[i-1][1],-prices[i]); } return dp[prices.size()-1][0]; } };
leetcode 122. 买卖股票的最佳时机 II 交易无限次
class Solution { public: int maxProfit(vector<int>& prices) { if(prices.size()==0) return 0; vector<vector<int>>dp(prices.size(),vector<int>(2,0)); dp[0][0]=0; dp[0][1]=-prices[0]; for(int i=1;i<prices.size();i++) { dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]); dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]); } return dp[prices.size()-1][0]; } };
leetcode 123. 买卖股票的最佳时机 III 交易两次
class Solution { public: int maxProfit(vector<int>& prices) { if(prices.size()==0) return 0; vector<vector<vector<int> > >dp=(vector<vector<vector<int> > >(prices.size(),vector<vector<int> >(2+1,vector<int>(2,0)))); dp[0][1][1]=-prices[0]; dp[0][2][1]=-prices[0]; for(int i=1;i<prices.size();i++) { for(int k=2;k>0;k--) { dp[i][k][0]=max(dp[i-1][k][0],dp[i-1][k][1]+prices[i]); dp[i][k][1]=max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i]); } } return max(dp[prices.size()-1][2][0],dp[prices.size()-1][1][0]); } };
leetcode 188. 买卖股票的最佳时机 IV 最多交易K次
int minl(int a,int b) { return (a>b?b:a); } class Solution { public: int max_Profit_2(vector<int>& prices) { if(prices.size()==0) return 0; vector<vector<int>>dp(prices.size(),vector<int>(2,0)); dp[0][0]=0; dp[0][1]=-prices[0]; for(int i=1;i<prices.size();i++) { dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]); dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]); } return dp[prices.size()-1][0]; } int maxProfit(int k,vector<int>& prices) { if(prices.size()==0) return 0; if(k>prices.size()/2) return max_Profit_2(prices); vector<vector<vector<int> > >dp=(vector<vector<vector<int> > >(prices.size(),vector<vector<int> >(k+1,vector<int>(2,0)))); for(int kk=k;kk>0;kk--) dp[0][kk][1]=-prices[0]; for(int i=1;i<prices.size();i++) { for(int kk=k;kk>0;kk--) { dp[i][kk][0]=max(dp[i-1][kk][0],dp[i-1][kk][1]+prices[i]); dp[i][kk][1]=max(dp[i-1][kk][1],dp[i-1][kk-1][0]-prices[i]); } } int maxl=0; for(int kk=k;kk>0;kk--) if(dp[prices.size()-1][k][0]>maxl) maxl=dp[prices.size()-1][k][0]; return maxl; } };
leetcode 309. 最佳买卖股票时机含冷冻期 冷冻期换成i-2
class Solution { public: int maxProfit(vector<int>& prices) { if(prices.size()<=1) return 0; vector<vector<int>>dp(prices.size(),vector<int>(2,0)); dp[0][1]=-prices[0]; dp[1][1]=max(dp[0][1],-prices[1]); dp[1][0]=max(0,prices[1]-prices[0]); for(int i=2;i<prices.size();i++) { dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]); dp[i][1]=max(dp[i-1][1],dp[i-2][0]-prices[i]); } return dp[prices.size()-1][0]; } };
leetcode 714. 买卖股票的最佳时机含手续费 给价格减去交易费
class Solution { public: int maxProfit(vector<int>& prices,int fee) { if(prices.size()==0) return 0; vector<vector<int>>dp(prices.size(),vector<int>(2,0)); dp[0][0]=0; dp[0][1]=-prices[0]; for(int i=1;i<prices.size();i++) { dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]-fee); dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]); } return dp[prices.size()-1][0]; } };
leetcode 887. 鸡蛋掉落
常规思路：dp[K][N]表示在存在K个好鸡蛋的情况下要测试N层楼必须的最小尝试次数，
鸡蛋在dp[K][N]处的下一个状态可能由两个状态组成：max(dp[K][N-i],dp[K-1][i-1]) 在第i层扔过鸡蛋以后没有碎，在第i层扔过鸡蛋以后碎了。i：1->N遍历取最小的一个
#define inf 999999 int minl(int a,int b) { return (a>b?b:a); } class Solution { public: int dpl(vector<vector<int> >&dp,int K, int N) { int lable=inf; if(N==0) return 0; if(K==1) return N; if(dp[K][N]!=0) return dp[K][N]; for(int i=1;i<=N&&K-1>=0;i++) { lable=minl(lable,max(dpl(dp,K-1,i-1),dpl(dp,K,N-i))+1); } dp[K][N]=lable; //cout<<K<<"->"<<N<<"->"<<lable<<" "; return lable; } int superEggDrop(int K, int N) { vector<vector<int> >dp(K+1,vector<int>(N+1,0)); return dpl(dp,K,N); } };
面试题62. 圆圈中最后剩下的数字
从最后状态向前推，最后只有一个数字时，也就是0号位置是安全位置，倒着推到最初状态这个0号位置的所在。
1个人：0
2个人：（0+m）%2
3个人：（（0+m）%2 +m）%3
n个人：.......................................%n
class Solution { public: int lastRemaining(int n, int m) { int out=0; for(int i=2;i<=n;i++) { out=(out+m)%i; } return out; } };
leetcode 32. 最长有效括号
本题需要找好dp的定义。
dp[i]表示以s[i]为结尾的串有效长度，如图：
class Solution { public: int longestValidParentheses(string s) { if(s.size()<=1) return 0; vector<int>dp(s.size(),0); int maxl=0; if(s[0]=='('&&s[1]==')') dp[1]=2; for(int i=2;i<s.size();i++) { if(s[i]=='('){}//A else { if(s[i-1]=='(')//B { if(i-2<0)//D { dp[i]=2; } else//E { dp[i]=dp[i-2]+2; } } else if(s[i-1]==')')//C { if(i-1-dp[i-1]<0 || s[i-1-dp[i-1]]==')'){}//F else if(s[i-1-dp[i-1]]=='(')//G { if(i-2-dp[i-1]<0)//H { dp[i]=dp[i-1]+2; } else//I { dp[i]=dp[i-1]+2+dp[i-2-dp[i-1]]; } } } } } for(int i=0;i<s.size();i++) maxl=(dp[i]>maxl?dp[i]:maxl); return maxl; } };