LeetCode188 股票问题, 自己想了个解法但不知道算那种思路...

[qq_28768785]

刷力扣遇到这个题了...

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：
输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2：
输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

看了不少解题思路, 一看三维dp就懵了... 后来自己憋出个解法, 用例有限, 也不知道对不对? 请大佬指点.

我的解法是这样:
1.遍历数组获得每个元素向前的最大差值；
2.遍历差值集，寻找逆序。如果出现逆序，在此逆序对之间截断：
a. 逆序对前元素为前一段的最大收益值；
b. 逆序对后元素为后一段的阶梯，在后一段出现新逆序之前，收益值为当前元素 - 阶梯；
c. 如果差值集尾部未出现逆序，则尾部元素 - 阶梯为最后的最大收益值；
3.将各分段最大收益值排序，取前limited位sum即为结果；

整体时间复杂为O(nlogn), 空间O(n), 以下是java代码:

    /**
     * 思路：三维dp看不懂。。。
     *      1。遍历数组获得每个元素向前的最大差值；
     *      2。遍历差值集，寻找逆序。如果出现逆序，此逆序对之间截断：
     *          a. 逆序对前元素为前一段的最大收益值；
     *          b。逆序对后元素为后一段的阶梯，在后一段出现新逆序之前，收益值为当前元素 - 阶梯；
     *          c。如果差值集尾部未出现逆序，则尾部元素 - 阶梯为最后的最大收益值；
     *      3。将各分段最大收益值排序，取前limited位sum即为结果；
     */
    @TestTimmer
    public static int method_0(Integer[] prices, Integer limited) {
        int result = 0;
        if(Objects.nonNull(prices) && prices.length > 0 && limited > 0) {
            //先计算出所有元素的最大差值；
            int[] temp = new int[prices.length];
            //之前的最小元素；
            int min = prices[0];
            for(int i = 1; i < prices.length; i++) {
                min = Math.min(min, prices[i]);
                temp[i] = prices[i] - min;
            }
            //遍历最大差值，发现逆序出现则截断，将最大值计入数组；
            int[] results = new int[prices.length >> 1];
            min = 0;
            int step = 0;
            for(int j = 1; j < temp.length; j++) {
                //出现逆序；
                if(temp[j] < temp[j - 1]) {
                    results[min] = temp[j - 1] - step;
                    min++;
                    step = temp[j];
                } else if(j == temp.length - 1) {
                    results[min] = temp[j] - step;
                    break;
                }
            }
            //计算最大值；
            if(limited >= results.length) {
                result = IntStream.of(results).sum();
            } else {
                Arrays.sort(results);
                for(int k = results.length - 1; k > results.length - limited - 1; k--) {
                    result += results[k];
                }
            }
        }
        return result;
    }

在下算法老白, 算法名次认不全, 请大佬们指点.

@TestTimer 是我自己写的测试用注解,批量比较算法时间空间消耗的. 忽略!!!忽略!!!