30、买卖股票的最好时机

买卖股票的最好时机(一)

描述
假设你有一个数组prices，长度为n，其中prices[i]是股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益
1.你可以买入一次股票和卖出一次股票，并非每天都可以买入或卖出一次，总共只能买入和卖出一次，且买入必须在卖出的前面的某一天
2.如果不能获取到任何利润，请返回0
3.假设买入卖出均无手续费

数据范围： 0≤n≤105,0≤val≤1040 \le n \le 10^5 , 0 \le val \le 10^40≤n≤105,0≤val≤104
要求：空间复杂度 O(1)O(1)O(1)，时间复杂度 O(n)O(n)O(n)
示例1

输入：[8,9,2,5,4,7,1]
返回值：5
说明：在第3天(股票价格 = 2)的时候买入，在第6天(股票价格 = 7)的时候卖出，最大利润 = 7-2 = 5，不能选择在第2天买入，第3天卖出，这样就亏损7了；同时，你也不能在买入前卖出股票。

示例2

输入：[2,4,1]
返回值： 2

示例3

输入： [3,2,1]
返回值： 0

思路：

对于每天有到此为止的最大收益和是否持股两个状态，因此我们可以用动态规划。

具体做法：

step 1：用dp[i][0]表示第i天不持股到该天为止的最大收益，dp[i][1]表示第i天持股，到该天为止的最大收益。
step 2：（初始状态） 第一天不持股，则总收益为0，dp[0][0]=0；第一天持股，则总收益为买股票的花费，此时为负数，dp[0][1]=−prices[0]。
step 3：（状态转移） 对于之后的每一天，如果当天不持股，有可能是前面的若干天中卖掉了或是还没买，因此到此为止的总收益和前一天相同，也有可能是当天才卖掉，我们选择较大的状态dp[i][0]=max(dp[i−1][0],dp[i−1][1]+prices[i])；
step 4：如果当天持股，有可能是前面若干天中买了股票，当天还没卖，因此收益与前一天相同，也有可能是当天买入，此时收益为负的股价，同样是选取最大值：dp[i][1]=max(dp[i−1][1],−prices[i])。

import java.util.*;


public class Solution {
    /**
     *
     * @param prices int整型一维数组
     * @return int整型
     */
    public int maxProfit (int[] prices) {
        // write code here
        //1、获取数组prces的长度n
        int n = prices.length;
        //2、dp[i][0]表示某一天不持股到改天为止的最大收益，dp[i][1]表示某天持股，到该天为止的最大收益
        int[][] dp = new int[n][2];
        //3、第一天不持股，总收益为0
        dp[0][0] = 0;
        //4、第一天持股，总收益为减去该天的股价
        dp[0][1] = -prices[0];
        //5、遍历后续每天，状态转移
        for (int i = 1; i < n; i++) {
            //5.1如果当天不持股，有可能是前面的若干天中卖掉了或是还没有买，因此到此为止的总收益和前一天相同。
            //也有可能当天才卖掉，我们选择较大的状态dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i])
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);


            //5.2如果当天持股，有可能是前面若干天中买了股票，当天还没卖，因此收益与前一天相同
            //也有可能当卖入，此时收益为负的股价，同样是选取最大值dp[i][1]=max(dp[i-1][1],-prices[i])
            dp[i][1] = Math.max(dp[i - 1][1], -prices[i]);


        }
        //6、最后一天不持股，到该天为止的最大收益
        return dp[n - 1][0];





    }
}

买卖股票的最好时机(二)

描述
假设你有一个数组prices，长度为n，其中prices[i]是某只股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益

1. 你可以多次买卖该只股票，但是再次购买前必须卖出之前的股票
2. 如果不能获取收益，请返回0
3. 假设买入卖出均无手续费

数据范围： 1≤n≤1×1051 \le n \le 1 \times 10^51≤n≤1×105 ， 1≤prices[i]≤1041 \le prices[i] \le 10^41≤prices[i]≤104
要求：空间复杂度 O(n)O(n)O(n)，时间复杂度 O(n)O(n)O(n)
进阶：空间复杂度 O(1)O(1)O(1)，时间复杂度 O(n)O(n)O(n)
示例1

输入：[8,9,2,5,4,7,1]
返回值： 7
说明：
在第1天(股票价格=8)买入，第2天(股票价格=9)卖出，获利9-8=1
在第3天(股票价格=2)买入，第4天(股票价格=5)卖出，获利5-2=3
在第5天(股票价格=4)买入，第6天(股票价格=7)卖出，获利7-4=3 总获利1+3+3=7，返回7

示例2

输入： [5,4,3,2,1]
返回值：0
说明： 由于每天股票都在跌，因此不进行任何交易最优。最大收益为0。

示例3

输入： [1,2,3,4,5]
返回值： 4
说明： 第一天买进，最后一天卖出最优。中间的当天买进当天卖出不影响最终结果。最大收益为4。
备注： 总天数不大于200000。保证股票每一天的价格在[1,100]范围内。

题目主要信息：

给出一个数组表示连续多日的股票价格
你可以选择在某一天买入股票，在另一天卖出股票，买卖可以有多次机会，但是同一天只能买或者只能卖
假设买卖没有手续费，问最高收益是多少，即卖出的价格减去买入的价格，如果没有利润需要返回0

思路：

这道题与买卖股票的最好时机(一)的区别在于可以多次买入卖出。 但是对于每天还是有到此为止的最大收益和是否持股两个状态，因此我们照样可以用动态规划。

具体做法：

step 1：用dp[i][0]表示第i天不持股到该天为止的最大收益，dp[i][1]dp[i][1]dp[i][1]表示第i天持股，到该天为止的最大收益。
step 2：（初始状态） 第一天不持股，则总收益为0，dp[0][0]=0；第一天持股，则总收益为买股票的花费，此时为负数，dp[0][1]=−prices[0]。
step 3：（状态转移） 对于之后的每一天，如果当天不持股，有可能是前面的若干天中卖掉了或是还没买，因此到此为止的总收益和前一天相同，也有可能是当天卖掉股票，我们选择较大的状态dp[i][0]=max(dp[i−1][0],dp[i−1][1]+prices[i])；
step4：如果当天持股，可能是前几天买入的还没卖，因此收益与前一天相同，也有可能是当天买入，减去买入的花费，同样是选取最大值：dp[i][1]=max(dp[i−1][1],dp[i−1][0]−prices[i])。

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 计算最大收益
     * @param prices int整型一维数组 股票每一天的价格
     * @return int整型
     */
    public int maxProfit (int[] prices) {
        // write code here
        //1.得到prices的长度
        int n = prices.length;
        //2.dp[i][0]表示某一天不持股到该天为止的最大收益，dp[i][1]表示某天持股，到该天为止的最大收益
        int[][] dp = new int[n][2];
        //3.第一天不持股，总收益为0
        dp[0][0] = 0;

        //4.第一天持股，总收益 为减去该天的股价
        dp[0][1] = -prices[0];


        //5.遍历后续每天，状态转移
        for (int i = 1; i < n; i++) {

            //5.1如果当天不持股，有可能是前面的若干天中卖掉或是没买，因此到此为止的总收益和前一天相同
            //也有可能当天卖掉股票，我们选择较大的状态dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i])
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]);


            //5.2如果当天持股，可能是前近几天买入的还没卖，因此收益与前一天相同
            //也有可能是当天卖入，减去卖入的花费，同样是选取最大值 dp[i][1]=max(dp[i-1][1],dp[i-1[1]+prices[i]])
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);

        }



        //6.最后一天不持股，到该天为止的最大收益
        return dp[n - 1][0];




    }
}

买卖股票的最好时机(三)

描述
假设你有一个数组prices，长度为n，其中prices[i]是某只股票在第i天的价格，请根据这个价格数组，返回买卖股票能获得的最大收益

1. 你最多可以对该股票有两笔交易操作，一笔交易代表着一次买入与一次卖出，但是再次购买前必须卖出之前的股票
2. 如果不能获取收益，请返回0
3. 假设买入卖出均无手续费

数据范围：1≤n≤1051 \le n \le 10^51≤n≤105，股票的价格满足 1≤val≤1041 \le val\le 10^41≤val≤104
要求: 空间复杂度 O(n)O(n)O(n)，时间复杂度 O(n)O(n)O(n)
进阶：空间复杂度 O(1)O(1)O(1)，时间复杂度 O(n)O(n)O(n)
示例1

输入： [8,9,3,5,1,3]
返回值： 4
说明： 第三天(股票价格=3)买进，第四天(股票价格=5)卖出，收益为2 第五天(股票价格=1)买进，第六天(股票价格=3)卖出，收益为2
总收益为4。

示例2

输入：[9,8,4,1]
返回值：0

示例3

输入： [1,2,8,3,8]
返回值： 12
说明： 第一笔股票交易在第一天买进，第三天卖出；第二笔股票交易在第四天买进，第五天卖出；总收益为12。
因最多只可以同时持有一只股票，所以不能在第一天进行第一笔股票交易的买进操作，又在第二天进行第二笔股票交易的买进操作（此时第一笔股票交易还没卖出），最后两笔股票交易同时在第三天卖出，也即以上操作不满足题目要求。
备注： 总天数不大于200000。保证股票每一天的价格在[1,100]范围内。

题目主要信息:

给出一个数组表示连续多日的股票价格
你可以选择在某一天买入股票，在另一天卖出股票，可以最多买入两次卖出两次，但是第二次买入必须在第一次卖出后，且每天只能进行一次操作
假设买卖没有手续费，问最高收益是多少，即卖出的价格减去买入的价格，如果没有利润需要返回0

思路：

这道题与买卖股票的最好时机(一)的区别在于最多可以买入卖出2次，那实际上相当于它的状态多了几个，对于每天有到此为止的最大收益和持股情况两个状态，持股情况有了5种变化，我们用：

dp[i][0]表示到第i天为止没有买过股票的最大收益
dp[i][1]表示到第i天为止买过一次股票还没有卖出的最大收益
dp[i][2]表示到第i天为止买过一次也卖出过一次股票的最大收益
dp[i][3]表示到第i天为止买过两次只卖出过一次股票的最大收益
dp[i][4]表示到第i天为止买过两次同时也买出过两次股票的最大收益

于是使用动态规划，有了如下的状态转移
具体做法：

step 1：（初始状态） 与上述提到的题类似，第0天有买入了和没有买两种状态：dp[0][0]=0、dp[0][1]=−prices[0]。
step 2：状态转移： 对于后续的每一天，如果当天还是状态0，则与前一天相同，没有区别；
step 3：如果当天状态为1，可能是之前买过了或者当天才第一次买入，选取较大值：dp[i][1]=max(dp[i−1][1],dp[i−1][0]−prices[i])；
step 4：如果当天状态是2，那必须是在1的状态下（已经买入了一次）当天卖出第一次，或者早在之前就卖出只是还没买入第二次，选取较大值：dp[i][2]=max(dp[i−1][2],dp[i−1][1]+prices[i])；
step 5：如果当天状态是3，那必须是在2的状态下（已经卖出了第一次）当天买入了第二次，或者早在之前就买入了第二次，只是还没卖出，选取较大值：dp[i][3]=max(dp[i−1][3],dp[i−1][2]−prices[i]);
step 6：如果当天是状态4，那必须是在3的状态下（已经买入了第二次）当天再卖出第二次，或者早在之前就卖出了第二次，选取较大值：dp[i][4]=max(dp[i−1][4],dp[i−1][3]+prices[i])。
step 7：最后我们还要从0、第一次卖出、第二次卖出中选取最大值，因为有可能没有收益，也有可能只交易一次收益最大。

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 两次交易所能获得的最大收益
     * @param prices int整型一维数组 股票每一天的价格
     * @return int整型
     */
    public int maxProfit (int[] prices) {
        // write code here
        //1.获取prices的长度 n
        int n = prices.length;
        //2.dp[i][0]表示某一天不持股到该天为止的最大收益，dp[i][1]表示某天持股，到该天为止的最大收益
        int[][] dp = new int[n][5];
        //3.初始化dp为最小
        Arrays.fill(dp[0], -10000);

        //4.第0天不持有状态
        dp[0][0] = 0;

        //5.第0天持有股票
        dp[0][1] = -prices[0];

        //6.状态转移
        for (int i = 1; i < n; i++) {

            //6.1如果当天状态是0，则与前一天相同
            dp[i][0] = dp[i - 1][0];
            //6.2如果当天的状态为1，可能之前买过了或者当天才第一次买入，选取最大值dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i])
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);

            //6.3如果当天状态是2，那必须是在1的状态下(已经买入了一次) 当天卖出第一次，或者早在之前卖出只是还没买入第二次，选取最大值 dp[i][2]=max(dp[i-1][2],dp[i-1][1]+prices[i])
            dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);

            //6.4如果当天状态是3，那必须是在2的状态下（已经卖出了第一次）当天迈入了第二次，或者早在之前就买入了第二次，只是还没卖，选取最大值dp[i][3]=max(dp[i-1][3],dp[i-1][2]=prices[i])
            dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);

            //6.5如果当天状态是4，那必须是在3的状态下（已经买入第二次）当天 卖出第二次，或者早在之前就卖出第二次 选取较大值dp[i][4]=max(dp[i-1][4],dp[i-1][3]+prices[i])
            dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

        }
        //7.选取最大值，可以只操作一次(最后我们还是要从0、第一次卖出、第二次卖出中选取最大值，因为有可能没有收益，也有可能只交易一次收益最大)
        return Math.max(dp[n - 1][2], Math.max(0, dp[n - 1][4]));
    }
}