代码随想录刷题|LeetCode 121. 买卖股票的最佳时机 122.买卖股票的最佳时机II

目录

121. 买卖股票的最佳时机

思路

暴力解法

贪心算法

动态规划

买卖股票的最佳时机

贪心算法

动态规划

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

思路

分析递推公式

买卖股票的最佳时机II

贪心算法

动态规划

---

121. 买卖股票的最佳时机

题目链接：力扣

思路

暴力解法

        暴力解答会超出时长
        
        

贪心算法

        因为股票就买卖一次，贪心算法的想法是：取最左侧最小值，取最右侧的最大值，那么这个差值就是可以得到的最大利润

动态规划

        其实我们要做的是，就是两件事：
        在什么时候买入的时候最小
        在什么时候卖出的时候赚的最多

1、确定dp数组及其下标的含义

        dp[i][0] : 表示第 i 天持有股票所得最多现金的情况。一开始现金是0 ，如果买入就是负数
                      这里实际意义是： 保存买入的最小数
        dp[i][1]：表示第 i 天不持有股票所得最多现金
                      这里实际意义是：根据当前保存的最小买入数，保存当天卖出的话可获得的最大利润

2、确定递推公式

对于持有股票dp[i][0]:

• 如果在 i - 1 天就持有了股票，那就不能再买了，这种状态就是dp[i - 1][0]
• 如果要在 i 天买入，这种状态就是 -prices[i]
• 所以这个就是代表，怎么买入才能话最少的钱，所以应该选其中的最大值
  因此 ： dp[i][0] = Math.max( dp[i -1][0] , -prices[i] );

对于不持有股票dp[i][1]

• 如果在 i - 1天已经卖出股票了，那就保持之前的状态，就是dp[i-1][1]
• 如果前面没有卖出过，那就试试在 i 天卖出，这种状态就是:卖出的价格 - 前面买入的最小数，因此是：prices[ i ] - dp[i - 1][0]
• 所以这个就是代表，当天价格 - 之前获得的最小买入，保存的是获得的利润，所以应该选取其中的最大值，因此：dp[i][1] = Math.max(dp[i -1][1], prices[i] - dp[i- 1][0]);

3、初始化dp数组

        从递推公式可以看出，我们是需要对dp[0][0]和dp[0][1]进行初始化的

        dp[0][0] 表示如果在 第0天买入股票后，手中的现金为：dp[0][0] = 0 - prices[0] = -prices[0]
        dp[0][1] 表示如果在 第0天卖出股票后，手中的现金为：dp[0][1] = 0

4、遍历顺序

        显然，是从前向后遍历

买卖股票的最佳时机

贪心算法

class Solution {
    public int maxProfit(int[] prices) {

        // 最小值
        int left = Integer.MAX_VALUE;
        // 结果
        int result = 0;

        for (int i = 0; i < prices.length; i++) {
            left = Math.min(left,prices[i]);
            result = Math.max(result,prices[i]-left);
        }

        return result;
    }
}

动态规划

版本一：使用二维数组

class Solution {
    public int maxProfit(int[] prices) {

        // 创建dp数组
        int[][] dp = new int[prices.length][2];

        // 初始化dp[]数组
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        // 进行动态推算
        for (int i = 1; i < prices.length; i++) {
            dp[i][0] = Math.max(dp[i-1][0],-prices[i]);  // 将最小买入位保存了下来
            dp[i][1] = Math.max(dp[i-1][1],prices[i] + dp[i-1][0]);  // 不断获取什么时候卖出的之后最大
        }

        return dp[prices.length-1][1];
    }
}

版本二：使用二维滚动数组

class Solution {
    public int maxProfit(int[] prices) {

        // 创建dp数组
        int[][] dp = new int[2][2];

        // 初始化dp[]数组
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        // 进行动态推算
        for (int i = 1; i < prices.length; i++) {
            dp[i % 2][0] = Math.max(dp[(i-1) % 2][0],-prices[i]);  // 将最小买入位保存了下来
            dp[i % 2][1] = Math.max(dp[(i-1) % 2][1],prices[i] + dp[(i-1) % 2][0]);  // 不断获取什么时候卖出的之后最大
        }

        return dp[(prices.length-1) % 2][1];
    }
}

版本三：使用一维数组

class Solution {
    public int maxProfit(int[] prices) {
        
        // 创建dp数组
        int[] dp = new int[2];

        // dp[0]保存最小买入数
        dp[0] = Integer.MAX_VALUE;
        // dp[i]保存当前卖出可获得的最大利润
        dp[1] = 0;

        for (int i = 0; i < prices.length; i++) {
            // 更新最小买入
            dp[0] = Math.min(dp[0],prices[i]);
            // 获取当前卖出可获取的利润
            dp[1] = Math.max(dp[1],prices[i]-dp[0]);
        }

        return dp[1];
    }
}

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

题目链接：力扣

思路

        这道题目在贪心算法的时候做过，再使用动态规划完成，与121题目的区别是可以买卖多次，买入前必须卖出

        和121除了递推公式，其他都是一样的

分析递推公式

dp数组的含义：

• dp[i][0] 表示第 i 天持有股票所得现金，就是买入股票后手中的现金
• dp[i][1] 表示第 i 天不持有股票所得的最多现金，就是卖出股票后手中的现金
• 其实这两个，代表的都是手中有的现金数

怎么推导dp[i][0]:

• 如果第 i-1 天持有股票，表示已经买入股票了，就不能再买入了，保持前面的状态就可以，也就是：dp[i - 1][0]
• 如果第 i-1 天没有持有股票，表示可以买入股票了，那么就买入，手中的现金就是，dp[i - 1][1] - prices[i]

怎么推导dp[i][1]:

• 如果第 i-1 天不持有股票了，那就不可以卖，那么就是保持现状，dp[i - 1][1]
• 如果第 i-1 天持有股票，那就可以卖了，dp[i - 1][0] + prices[i]

买卖股票的最佳时机II

贪心算法

class Solution {
    public int maxProfit(int[] prices) {

        int result = 0;

        for (int i = 0; i + 1 < prices.length; i++) {
            int temp = prices[i + 1] - prices[i];
            if (temp > 0) {
                result += temp;
            }
        }

        return result;
    }
}

动态规划

版本一：使用二维数组

class Solution {
    public int maxProfit(int[] prices) {

        // 创建的dp[]数组
        int[][] dp = new int[prices.length][2];

        // 初始化dp数组
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        // 推导dp数组
        for (int i = 1; i < prices.length; i++) {
            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-prices[i]); // 这里与121的区别
            dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }

        return dp[prices.length - 1][1];
    }
}

版本二：使用滚动二维数组

class Solution {
    public int maxProfit(int[] prices) {

        // 创建的dp[]数组
        int[][] dp = new int[2][2];

        // 初始化dp数组
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        // 推导dp数组
        for (int i = 1; i < prices.length; i++) {
            dp[i % 2][0] = Math.max(dp[(i-1) % 2][0],dp[(i-1) % 2][1]-prices[i]);
            dp[i % 2][1] = Math.max(dp[(i-1) % 2][1],dp[(i-1) % 2][0]+prices[i]);
        }

        return dp[(prices.length - 1) % 2][1];
    }
}

版本三：使用一维数组

class Solution {
    public int maxProfit(int[] prices) {

        // 创建的dp[]数组
        int[] dp = new int[2];

        // 初始化dp数组
        dp[0] = Integer.MIN_VALUE; // 代表持有当前股票手中的现金
        dp[1] = 0;                 // 代表卖出卖出股票手中的现金

        // 推导dp数组
        for (int i = 0; i < prices.length; i++) {
            // 前一天是持有的情况
            dp[0] = Math.max(dp[0],dp[1] - prices[i]);
            dp[1] = Math.max(dp[1],dp[0] + prices[i]);
        }

        return dp[1];
    }
}