代码随想录算法训练营第四十九天| 121 买卖股票的最佳时机 122 买卖股票的最佳时机II

Posted 2023-04-12 Hulmos626

代码随想录算法训练营第四十九天| 121 买卖股票的最佳时机 122 买卖股票的最佳时机II

LeetCode 121 买卖股票的最佳时机

题目: 121.买卖股票的最佳时机

动规五部曲：

• 确定dp数组以及下标的含义

**dp[i][0] 表示第i天持有股票所得最多现金 **

• 确定递推公式

dp[i][0] = max(dp[i - 1][0], -prices[i])

• dp数组如何初始化

由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0])可以看出其基础是要从dp[0][0]和dp[0][1]推导出来，dp[0][1] = 0

• 确定遍历顺序

从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，从前向后遍历。

• 举例来推导dp数组

整体代码：

class Solution 
public:
    int maxProfit(vector<int>& prices) 
        int len = prices.size();
        if (len == 0) return 0;
        vector<vector<int>> dp(len, vector<int>(2));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) 
            dp[i][0] = max(dp[i - 1][0], -prices[i]);
            dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
        
        return dp[len - 1][1];
    
;

LeetCode 122 买卖股票的最佳时机II

题目: 122.买卖股票的最佳时机II

本题和上题的区别是上题中，股票全程只能买卖一次，所以如果买入股票，那么第i天持有股票即dp[i][0]一定是 -prices[i]

本题因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。

dp[i][0] 表示第i天持有股票所得现金。

dp[i][1] 表示第i天不持有股票所得最多现金

整体代码：

class Solution 
public:
    int maxProfit(vector<int>& prices) 
        int len = prices.size();
        vector<vector<int>> dp(len, vector<int>(2, 0));
        dp[0][0] -= prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) 
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]); // 注意这里是和121. 买卖股票的最佳时机唯一不同的地方。
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        
        return dp[len - 1][1];
    
;

代码随想录算法训练营第30天

今日刷题3道：39. 组合总和，40.组合总和II，131.分割回文串

●  39. 组合总和

题目链接/文章讲解：https://programmercarl.com/0039.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8C.html

视频讲解：https://www.bilibili.com/video/BV1KT4y1M7HJ

class Solution

private:

    vector<vector<int>> result;

    vector<int> path;

    void backtracking(vector<int>& candidates, int sum, int target, int index)

        if(sum > target) return;

        if(sum == target)

            result.push_back(path);

            return;

       

        for(int i=index;i<candidates.size();i++)

            sum+=candidates[i];

            path.push_back(candidates[i]);

            backtracking(candidates,sum,target,i);

            sum-=candidates[i];

            path.pop_back();

       

   

public:

    vector<vector<int>> combinationSum(vector<int>& candidates, int target)

        backtracking(candidates,0,target,0);

        return result;

   

;

 

●  40.组合总和II

题目链接/文章讲解：https://programmercarl.com/0040.%E7%BB%84%E5%90%88%E6%80%BB%E5%92%8CII.html

视频讲解：https://www.bilibili.com/video/BV12V4y1V73A

class Solution

private:

    vector<vector<int>> result;

    vector<int> path;

    void backtracking(vector<int>& candidates, int sum, int target, int index, vector<bool>& used)

        if(sum > target) return;

        if(sum == target)

            result.push_back(path);

            return;

       

        for(int i=index;i<candidates.size();i++)

            if(i>0 && candidates[i]==candidates[i-1] && used[i-1] == false)

                continue;

           

            sum+=candidates[i];

            path.push_back(candidates[i]);

            used[i]=true;

            backtracking(candidates,sum,target,i+1,used);

            used[i]=false;

            sum-=candidates[i];

            path.pop_back();

       

   

public:

    vector<vector<int>> combinationSum2(vector<int>& candidates, int target)

        vector<bool> used(candidates.size(),false);

        sort(candidates.begin(),candidates.end());

        backtracking(candidates,0,target,0, used);

        return result;

   

;

 

●  131.分割回文串

https://programmercarl.com/0131.%E5%88%86%E5%89%B2%E5%9B%9E%E6%96%87%E4%B8%B2.html

视频讲解：https://www.bilibili.com/video/BV1c54y1e7k6

 

class Solution

private:

    vector<vector<string>> result;

    vector<string> path;

    void backtracking(const string& s, int startIndex)

        if(startIndex >= s.size())

            result.push_back(path);

            return;

       

        for(int i=startIndex;i<s.size();i++)

            if(isPalindrome(s,startIndex,i))

                string str = s.substr(startIndex,i-startIndex+1);

                path.push_back(str);

            else

                continue;

           

            backtracking(s,i+1);

            path.pop_back();

       

   

    bool isPalindrome(const string& s, int start, int end)

        for(int i=start,j=end;i<j;i++,j--)

            if(s[i]!=s[j])

                return false;

           

       

        return true;

   

public:

    vector<vector<string>> partition(string s)

        backtracking(s,0);

        return result;

   

;