数据结构与算法-动态规划
往期内容
1-链表
2-栈与队列
3-树与图
4-哈希表
5-查找
6-排序
7-贪心
8-递归与分治
9-动态规划
动态规划
动态规划的套路
- 递归+备忘录(中间的变量)->递推
- 状态的定义:opt[n],dp[n]
- 状态的转移方程 opt[n]=best_of(opt[n-1],opt[n-2],…)
- 最优的子结构
1.FIB数列
Leetcode-509 斐波那契数列
递归+备忘录
class Solution {
public:
int fib(int n) {
vector<int> mem(n+1,0);
return helper(mem,n);
}
int helper(vector<int> &mem,int n)
{
if(n<2) return n;
if(mem[n]!=0) return mem[n];
return helper(mem,n-1)+helper(mem,n-2);
}
};
递推
class Solution {
public:
int fib(int n) {
if(n<2) return n;
vector<int> dp(n+1,0);
dp[0]=0;
dp[1]=1;
for(int i=2;i<=n;i++)
{
dp[i]=dp[i-1]+dp[i-2];
}
return dp[n];
}
};
状态压缩
class Solution {
public:
int fib(int n) {
if(n<2) return n;
int pre=1;
int prepre=0;
int cur;
for(int i=2;i<=n;i++)
{
cur=pre+prepre;
prepre=pre;
pre=cur;
}
return cur;
}
};
2.爬楼梯
Leetcode-70 爬楼梯
递归写法
class Solution {
public:
int climbStairs(int n) {
vector<int> mem(n+1,0);
return helper(mem,n);
}
int helper(vector<int> &mem,int n)
{
if(n==0 || n==1) return n;
if(mem[n]!=0) return mem[n];
return helper(mem,n-1)+helper(mem,n-2);
}
};
动态规划
class Solution {
public:
int climbStairs(int n) {
vector<int> dp(n+1,0);
dp[0]=1;
dp[1]=1;
for(int i=2;i<=n;i++)
{
dp[i]=dp[i-1]+dp[i-2];//可以优化,不需要知道所有的值
}
return dp[n];
}
};
3.三角形最小路径和
Leetcode-120 三角形最小路径和
1.深度优先搜索 (暴力)
2.动态规划
起始值:最下面一层值本身
递推方程: dp(i,j)=min(dp(i,j+1) , dp(i+1,j+1))+自身值
1.一维度dp
class Solution {
public:
int minimumTotal(vector<vector<int>>& triangle) {
vector<int> mini=triangle[triangle.size()-1];
for(int i=triangle.size()-2;i>=0;--i)
for(int j=0;j<triangle[i].size();++j)
{
mini[j]=triangle[i][j]+min(mini[j],mini[j+1]);//技巧
}
return mini[0];
}
};
2.二维度dp
class Solution {
public:
int minimumTotal(vector<vector<int>>& triangle) {
for(int i=triangle.size()-2;i>=0;--i)
for(int j=0;j<triangle[i].size();++j)
triangle[i][j]=triangle[i][j]+min(triangle[i+1][j],triangle[i+1][j+1]);
return triangle[0][0];
}
};
4.乘积最大子数组
class Solution {
public:
int maxProduct(vector<int>& nums) {
int mini=nums[0];//第i个位置的最大值
int maxi=nums[0];//第i个位置的最小值
int result=nums[0];//当前的最大乘积结果
for(int i=1;i<nums.size();i++)
{
if(nums[i]<0)//一定要注意此步操作,不然在后面会导致,中间变量的改变
swap(mini,maxi);
mini=min(nums[i],nums[i]*mini);
maxi=max(nums[i],nums[i]*maxi);
result=max(result,maxi);
}
return result;
}
};
5.股票买卖
121、122、123、309、188、714
6.最长递增子序列
6.1 dp
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if(nums.size()<1) return 0;
int n=nums.size();
vector<int> dp(n,1);
int result=1;//默认长度为1
for(int i=1;i<nums.size();++i)
{
for(int j=0;j<i;++j)
{
if(nums[i]>nums[j])
dp[i]=max(dp[i],dp[j]+1);
}
result=max(result,dp[i]);//保存中间最大的数
}
return result;
}
};
6.2 二分查找法
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
vector<int> res;
for(int i=0;i<nums.size();i++)
{
auto it=std::lower_bound(res.begin(),res.end(),nums[i]);
if(it==res.end())
{
res.push_back(nums[i]);
}
else
*it=nums[i];//替换
}
return res.size();
}
};
7.零钱兑换
class Solution {
public:
int coinChange(vector<int>& coins, int amount) {
vector<int> dp(amount+1,amount+1);
dp[0]=0;
for(int i=1;i<=amount;++i)
{
for(int j=0;j<coins.size();++j)
{
if((i-coins[j])>=0)
dp[i]=min(dp[i-coins[j]]+1,dp[i]);
}
}
return dp[amount]==amount+1? -1:dp[amount];
}
};
8.编辑距离
Leetcode-72 编辑距离
状态定义dp[i][j],表示word1第i个位置,变换到word2第j个位置所需要的最小步数。
class Solution {
public:
int minDistance(string word1, string word2) {
int n=word1.length();
int m=word2.length();
//定义状态
vector<vector<int>> dp(n+1,vector(m+1,0));
//初始化状态
for (int i = 0; i < n+1; i++) {
dp[i][0] = i;
}
for (int j = 0; j < m+1; j++) {
dp[0][j] = j;
}
//状态转移
for(int i=1;i<n+1;i++)
for(int j=1;j<m+1;j++)
{
if(word1[i-1]==word2[j-1])
dp[i][j]=dp[i-1][j-1];
else
dp[i][j]=min(dp[i-1][j-1],min(dp[i-1][j],dp[i][j-1]))+1;
}
return dp[n][m];
}
};
9.打家劫舍
class Solution {
public:
int rob(vector<int>& nums) {
//dp[i]=max(dp[i-2]+nums[i],dp[i-1])
if(nums.size()<2) return nums[0];
vector<int> dp(nums.size(),0);
dp[0]=nums[0];
dp[1]=max(nums[0],nums[1]);
for(int i=2;i<nums.size();i++)
{
dp[i]=max((dp[i-2]+nums[i]),dp[i-1]);
}
return dp[nums.size()-1];
}
};
二维的状态转移,笨蛋
class Solution {
public:
int rob(vector<int>& nums) {
if(nums.size()<2) return nums[0];
int len=nums.size();
vector<vector<int>> dp(len,vector<int>(2,0));
dp[0][0]=0;
dp[0][1]=nums[0];
for(int i=1;i<nums.size();i++)
{
dp[i][0]=max(dp[i-1][0],dp[i-1][1]);
dp[i][1]=dp[i-1][0]+nums[i];
}
return max(dp[len-1][0],dp[len-1][1]);
}
};
10.最大子序和
class Solution {
public:
int maxSubArray(vector<int>& nums) {
//dp[i]表示以i为结尾的最大子段和
//dp[i]=max(dp[i-1]+nums[i],nums[i])
vector<int> dp(nums.size(),0);
dp[0]=nums[0];
int result=dp[0];
for(int i=1;i<nums.size();i++){
dp[i]=max(dp[i-1]+nums[i],nums[i]);
result = max(result, dp[i]);
}
return result;
}
};
11.最小路径和
class Solution {
public:
int minPathSum(vector<vector<int>>& grid) {
int n=grid.size();
int m=grid[0].size();
vector<vector<int>> dp(n,vector<int>(m,INT_MAX ));
dp[0][0]=grid[0][0];
for(int i=1;i<n;i++)
dp[i][0]=dp[i-1][0]+grid[i][0];
for(int j=1;j<m;j++)
dp[0][j]=dp[0][j-1]+grid[0][j];
for(int i=1;i<n;i++)
for(int j=1;j<m;j++)
{
dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j];
}
return dp[n-1][m-1];
}
};