动态规划

53. 最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

输入: [-2,1,-3,4,-1,2,1,-5,4],
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

DP法

// 使用dp[i] 记录到第i个元素的最大子序列和
class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        int dp[nums.size()] = {0};
        dp[0] = nums[0];
        int res = nums[0];
        for(int i=1;i<nums.size();i++){
            dp[i] = max(nums[i],dp[i-1]+nums[i]);
            res = max(dp[i],res);
        }
        return res;
    }
};

198. 打家劫舍

int rob(vector<int>& nums) {
        int size = nums.size();
        if(size == 0) return 0;
        if(size == 1) return nums[0];
        if(size == 2) return max(nums[0],nums[1]);

        vector<int> dp(size+1,0);
        int max_val = 0;
        dp[0] = nums[0];
        dp[1] = nums[1]>nums[0]?nums[1]:nums[0];

        for(int i=2;i<size;i++){
            dp[i] = max(dp[i-2]+nums[i],dp[i-1]);
            if(dp[i]>max_val) max_val = dp[i];
        }
        return max_val;
    }
// 优化版本
    int rob(vector<int>& nums) {
       int prevMax = 0;
        int currMax = 0;
        for (auto x : nums) {
            int temp = currMax;
            // 之前最大利润+抢当前家  or  不抢当前家，保持最大利润
            currMax = max(prevMax + x, currMax);
            prevMax = temp;
        }
        return currMax;
    }

思路1
直接使用一个三维度的dp数组[m][k][j], 保存第m天，操作k次，是否持有股票的最大利润，然后找最大的
max(dp[m-1][0][0],dp[m-1][1][0],dp[m-1][2][0]);

思路2

dp1[i] = max(dp[i-1], prices[i] - minval) 从前往后遍历，表示第1天到第i天之间的最大利润（通过是否在第i天卖出确认）；
dp2[i] = max(dp[i+1], maxval - prices[i]) 从后往前遍历，表示第i天到最后一天之间的最大利润（通过是否在第i天买进确认）；
res = max(dp1 + dp2)，(dp1 + dp2)[i] 正好表示从第1天到最后一天经过两次交易的最大利润，我们的目标是找到令总利润最大的i。

class Solution {
public:
   int maxProfit(vector<int>& prices) {
        int m = prices.size();
        if(m==0) return 0;
        int dp[m][3][2];
        for(int k=0;k<3;k++) //最多可以完成 两笔 交易
        {   dp[0][k][0] = 0; // 第 1 天 操作 k 次 没有股票，所以初始值为 0
            dp[0][k][1] = - prices[0];  // 第 1 天 操作i 次 有股票， 所以初始值为 - prices[0]
        }

        for (int i=1;i<m;i++){
            dp[i][0][0] = dp[i-1][0][0];
            dp[i][0][1] = max(dp[i-1][0][1],dp[i-1][0][0] - prices[i]);
            dp[i][1][0] = max(dp[i-1][1][0],dp[i-1][0][1] + prices[i] ) ;

            dp[i][1][1] = max(dp[i-1][1][1],dp[i-1][1][0] - prices[i]);
            dp[i][2][0] = max(dp[i-1][2][0],dp[i-1][1][1] + prices[i] ) ;
            dp[i][2][1] = max(dp[i-1][2][1],dp[i-1][2][0] - prices[i] ) ;
        }
        int tmp = max(dp[m-1][0][0],dp[m-1][1][0]);
        tmp = max(tmp,dp[m-1][2][0]);
        return tmp;
    }

    int maxProfit(vector<int>& prices) {
        int m = prices.size();
        if(m<2) return 0;
        int dp1[m] = {0};
        int dp2[m] = {0};
        int minval = prices[0];
        int maxval = prices[m-1];

        for(int i=1;i<m;i++){
            dp1[i] = max(dp1[i-1],prices[i]-minval);
            minval = min(minval,prices[i]);
        }

        for(int i=m-2;i>=0;i--){
            dp2[i] = max(dp2[i+1],maxval-prices[i]);
            maxval = max(maxval,prices[i]);
        }
        int tmp = 0;
        for(int i=0;i<m;i++){
            tmp = max(tmp,dp1[i]+dp2[i]);
        }

        return tmp;
    }

};



public int maxProfit(int[] prices) {
        /**
        对于任意一天考虑四个变量:
        fstBuy: 在该天第一次买入股票可获得的最大收益 
        fstSell: 在该天第一次卖出股票可获得的最大收益
        secBuy: 在该天第二次买入股票可获得的最大收益
        secSell: 在该天第二次卖出股票可获得的最大收益
        分别对四个变量进行相应的更新, 最后secSell就是最大
        收益值(secSell >= fstSell)
        **/
        int fstBuy = Integer.MIN_VALUE, fstSell = 0;
        int secBuy = Integer.MIN_VALUE, secSell = 0;
        for(int p : prices) {
            fstBuy = Math.max(fstBuy, -p);
            fstSell = Math.max(fstSell, fstBuy + p);
            secBuy = Math.max(secBuy, fstSell - p);
            secSell = Math.max(secSell, secBuy + p); 
        }
        return secSell;
    }
    

322. 零钱兑换

这道题综合性特别强,可以用背包,深度遍历(dfs),广度遍历(bfs)

• 首先,背包的动态规划,就是取与不取的问题,

• 其次是,深度遍历(dfs),

两种方式,一种就是用字典记录深度遍历过程中得到金额i的最小个数
一种是,通过判断条件,减少递归次数

• 最后是,广度遍历(bfs),就是每一次从加上所有硬币,因为是广度遍历,所得到一定是可以用最少硬币达到的

BFS暴力法

class Solution {
public:
    
    int coinChange(vector<int>& coins, int amount) {
        if(amount == 0) return 0;
        int res = 0;
        pair<int,int> P;
        queue<pair<int,long long>> mq;
        int min_val = 100000;
        unordered_map<long long,int> dp;
        sort(coins.begin(),coins.end());

        for(int i=0;i<coins.size();i++){
            mq.push(make_pair(1,coins[i]));
            dp[coins[i]] = 1;
            if(coins[i] == amount) return 1;
        }

        while(!mq.empty()){
            long long tmp = mq.front().second;
            int index = mq.front().first;
            mq.pop();
            for(int i=0;i<coins.size();i++){
                if(tmp+coins[i]==amount ) return index+1;
                if(tmp+coins[i] < amount && dp.find(tmp+coins[i]) == dp.end()){
                    if(tmp+coins[i]<amount){
                        mq.push(make_pair(index+1,tmp+coins[i]));
                        dp[tmp+coins[i]] = index+1;
                    }
                }
            }
        }
        return -1;
    }
};

// 动态规划法
dp[i]表示金额为i需要最少的零钱个数
对于任意金额 j ,dp[j] = min(dp[j],dp[j-coin]+1),如果j-coin存在的话.

假设 f(n) 代表要凑齐金额为 n 所要用的最少硬币数量，那么有：
f(n) = min(f(n - c1), f(n - c2), ... f(n - cn)) + 1
其中 c1 ~ cn 为硬币的所有面额。

int coinChange(vector<int>& coins, int amount) {
        if(amount == 0) return 0;
        int min_val = 100000;

        vector<int> dp(amount+1,10000);
        dp[0] = 0;
        for(int i=1;i<=amount;i++){
            for(auto price:coins){
                if(i-price>=0)
                    dp[i] = min(dp[i-price]+1,dp[i]);
            }
        }
        return dp[amount]!=10000?dp[amount]:-1;
}

62. 不同路径

使用 dp[i][j] 存储走到i,j时 总可能的路径数
因为只可以向下向右走，则任意点的路径数为dp[i][j] = dp[i-1][j] + dp[i][j-1];
dp初始化最上面一排和最左面一排，因为只可以向右走和向下走，所以初始化路径数都为1，其它为0

 int uniquePaths(int m, int n) {
        vector<vector<int>> dp(n,vector<int>(m,0));
        for(int i=0;i<n;i++) dp[i][0]=1;
        for(int i=0;i<m;i++) dp[0][i]=1;
		
        for(int i=1;i<n;i++){
            for(int j=1;j<m;j++){
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[n-1][m-1];
    }
};

下面介绍 递归搜索 和 备忘录递归

递归

63. 不同路径II

状态转移方程跟上题一样，不同的是 初始化需要改变，以及如果dp[i][j]的上一步中存在障碍，则舍弃那条路的可能路径数

int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
    if(!obstacleGrid.size() || !obstacleGrid[0].size()) return 0;

    int m = obstacleGrid.size();
    int n = obstacleGrid[0].size();
    long dp[m][n];
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++)
        {
            if(i==0 && j==0){
                if(obstacleGrid[i][j]==0) dp[i][j]=1;
                else dp[i][j]=0;
            }
            else if(i==0)  {
                if( obstacleGrid[i][j]==0) dp[i][j] = dp[i][j-1];
                else dp[i][j]=0;
            }
            else if(j==0)  {
                if( obstacleGrid[i][j]==0) dp[i][j] = dp[i-1][j];
                else dp[i][j]=0;
            }
        }
    }

    for(int i=1;i<m;i++){
        for(int j=1;j<n;j++){
            if(obstacleGrid[i][j]==1) dp[i][j]=0;
            else {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
    }
    return dp[m-1][n-1];
}

64. 最小路径和

很典型的DP题，只需要注意初始化皆可以
dp[i][j] 存储走到i,j点时，当前的路径和
因为只有两个方向走，所以任意点的最小路径和，为上两个点的最小路径和加上当前点的权重 dp[i][j] = min(dp[i-1][j]+grid[i][j],dp[i][j-1]+grid[i][j]);

int minPathSum(vector<vector<int>>& grid) {
        if(!grid.size() || !grid[0].size()) return 0;
        int m = grid.size();
        int n = grid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));
        dp[0][0] = grid[0][0];

        for(int i=1;i<m;i++) dp[i][0] = dp[i-1][0]+grid[i][0];
        for(int i=1;i<n;i++) dp[0][i] = dp[0][i-1]+grid[0][i];
        
        for(int i=1;i<m;i++){
            for(int j=1;j<n;j++){
                dp[i][j] = min(dp[i-1][j]+grid[i][j],dp[i][j-1]+grid[i][j]);
            }
        }
        return dp[m-1][n-1];
    }

139. 单词拆分

使用dp[i] 表示字符串第i个位置之前的子字符可拆分出来
所以任意点的状态为 dp[i+j] = dp[i] && m.find(s.substr(i,j))!=m.end(),即第i个字符可拆分，且i-j之前的子字符也可拆分，此时就更新dp[i+j]可拆分，dp[s.size()]记录到字符最后长度时，是否存在可拆分的路径组合

"aaaaaaa"  dice = {'aaaa','aaa'}  0-3 可拆分‘aaa’ 3-6 可拆分‘aaa’  但是最后一个‘a’ 不可拆分
								   0-4 可拆分‘aaaa’   4-7可拆分‘aaa’ 

bool wordBreak(string s, vector<string>& wordDict) {
        vector<bool> dp(s.size()+1,false);
        unordered_set<string> m(wordDict.begin(), wordDict.end());
        dp[0] = true;
        
        // 从0开始，切割(1,len)长的子字符， 然后从1开始，切割(1,len-1)的子字符
        for(int i=0;i<s.size();i++){
            for(int j=1;j<=s.size()-i;j++){
                if(dp[i] && m.find(s.substr(i,j))!=m.end()){
                    dp[i+j] = true;
                }
            }
        }
        
        // 另一种切割子字符串的方式  从不同的
        // for(int i=1;i<=s.size();i++){
        //     for(int j=0;j<i;j++){
        //         if(dp[j] && m.find(s.substr(j,i-j))!=m.end()){
        //             dp[i] = true;
        //             break;
        //         }
        //     }
        // }


        return dp[s.size()];
    }

343. 整数拆分

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。

使用dp[i] 记录数字i拆分可组合的最大乘积子和
那么任意一点的可拆分最大值为 dp[i] = dp[j] * (i-j),即所有i之前的最大乘积*(i-j)的差值, 或者是直接拆分成两个数的乘积( j* (i-j) ),因为dp[j]是已经拆分过的最大值