leetcode 买卖股票问题

lc121 买卖股票最佳时机

思路：dp[i]：表示到第 i 天为止能获得的最大利润，所以 dp[i] 等于max{今天的价格prices[i] - 从第 1 到第 i-1天之中股票最低价格minPrice，dp[i-1]}，所以需要一个变量 minPrice 记录到第 i-1 天为止的股票最低价格。

/**
 * 状态转移方程 dp[i] = max{dp[i-1], prices[i]-min_price[i]}
 * dp[i]：表示到ith天为止能获得的最大利润
 * @param prices
 * @return
 */
public int maxProfit(int[] prices) {
    if (prices.length < 1) {
        return 0;
    }
    int[] profit = new int[prices.length];
    int minPirces = prices[0];
    profit[0] = 0;

    for (int i = 1; i < profit.length; i++) {
        if (prices[i] < minPirces) {
            minPirces = prices[i];
        }
        profit[i] = Math.max(profit[i-1], prices[i]-minPirces);
    }
    return profit[profit.length-1];
}

lc122 买卖股票最佳时机II

思路：dp[i] 表示到第 i 天为止能获得的最大利润，dp[i] = 前一天的最大利润dp[i-1] + Math.max(prices[i]-prices[i-1], 0)， Math.max(prices[i]-prices[i-1], 0)表示当天卖出收益是否大于0，如果大于0，则卖出，如果小于0，则不卖出。

/**
 * 状态转移方程 dp[i] = dp[i-1] + max{prices[i]-prices[i-1], 0}
 * dp[i]：表示到ith天为止能获得的最大利润
 * @param prices
 * @return
 */
public int maxProfit(int[] prices) {
    int len = prices.length;
    int[] dp = new int[len];
    dp[0] = 0;

    for (int i=1; i < len; i++) {
        dp[i] = dp[i-1] + Math.max(prices[i]-prices[i-1], 0);
    }

    return dp[len-1];
}

lc123. 买卖股票的最佳时机 III

思路：

参考

根据手头是否持有股票，我们定义两个二维数组来定义状态：

dp0[i][j]: 第i天结束，已有j次买卖，手头没有股票时的最大利润

dp1[i][j]: 第i天结束，已有j次买卖，手头有股票时的最大利润

初始化：

dp0[0][j]对于所有 j 都要初始化为0，而dp1[0][j]对于所有j都要初始化为-prices[i]

返回结果：

dp0[n-1][k]就是在最后一天结束时已进行k次交易且手头无股票时的最大收益，也即返回结果

状态转移方程：

dp0[i][j] = max(dp0[i-1][j], dp1[i-1][j-1] + prices[i])

今天我没有持有股票，有两种可能：

• 昨天我也没有股票，今天选择保持，所以今天也没有股票
• 昨天我持有股票，今天选择卖出，所以我今天没有股票了

dp1[i][j] = max(dp1[i-1][j], dp0[i-1][j] - prices[i])

今天我持有股票，有两种可能：

• 昨天我持有股票，今天选择保持，今天还有股票
• 昨天我没有股票，今天选择买入，今天持有股票

public int maxProfit(int[] prices) {
    if (prices.length == 0) {
        return 0;
    }

    int[][] dp0 = new int[prices.length][3];
    int[][] dp1 = new int[prices.length][3];

    dp1[0][0] = -prices[0];
    dp1[0][1] = -prices[0];

    for (int i = 1; i < prices.length; i++) {
        // j=0
        // 持股，未卖出过，可能是今天买的，可能是之前买的
        dp1[i][0] = Math.max(dp1[i-1][0], -prices[i]);
        // j=1
        // 未持股，卖出过1次，可能是今天卖的，可能是之前卖的
        dp0[i][1] = Math.max(dp0[i-1][1], dp1[i-1][0] + prices[i]);
        // 持股，卖出过1次，可能是今天买的，可能是之前买的
        dp1[i][1] = Math.max(dp1[i-1][1], dp0[i-1][1] - prices[i]);

        // j=2
        // 未持股，卖出过2次，可能是今天卖的，可能是之前卖的
        dp0[i][2] = Math.max(dp0[i-1][2], dp1[i-1][1] + prices[i]);
    }
    // 返回最后一天状态为为持股，卖出过两次的最大利润
    return dp0[prices.length-1][2];
}

lc188. 买卖股票的最佳时机 IV

思路：与上一题类似

public int maxProfit(int k, int[] prices) {
    if (prices.length == 0 || k == 0) {
        return 0;
    }

    // 当k很大时相当于不限制次数
    if (k > prices.length / 2) {
        int max = 0;
        for (int i = 1; i < prices.length; i++) {
            max += Math.max(0, prices[i] - prices[i-1]);
        }
        return max;
    }

    int[][] dp0 = new int[prices.length][k+1];
    int[][] dp1 = new int[prices.length][k+1];

    for(int j = 0; j <= k; j++) {
        dp1[0][j] = -prices[0]; // i = 0
    }

    for (int i = 1; i < prices.length; i++) {
        // j=0
        dp1[i][0] = Math.max(dp1[i-1][0], -prices[i]);

        // j>0
        for (int j = 1; j <= k; j++) {
            // 保持或卖出
            dp0[i][j] = Math.max(dp0[i-1][j], dp1[i-1][j-1] + prices[i]);
            // 保持或卖出
            dp1[i][j] = Math.max(dp1[i-1][j], dp0[i-1][j] - prices[i]);
        }
    }
    return dp0[prices.length-1][k];
}

Cest la vie !