数据结构与算法9-动态规划

数据结构与算法-动态规划

往期内容
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.乘积最大子数组

Leetcode-152 乘积最大子数组

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.最长递增子序列

Leetcode-300 最长递增子序列

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.零钱兑换

Leetcode-322 零钱兑换

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.打家劫舍

Leetcode-198 打家劫舍

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.最大子序和

Leetcode-最大子序和

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.最小路径和

Leetcode-64 最小路径和

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];
    }
};