股票交易作为事后诸葛，交易次数不同时，返回挣到的最大钱数。

最新推荐文章于 2024-08-07 07:30:00 发布

朂後哋箹萣

最新推荐文章于 2024-08-07 07:30:00 发布

阅读量262

点赞数

分类专栏： LeetCode 文章标签： java 算法数据结构

本文链接：https://blog.csdn.net/z1171127310/article/details/128066040

版权

LeetCode 专栏收录该内容

85 篇文章 4 订阅

订阅专栏

问题描述：

问题一：

给定一个数组arr，从左到右表示昨天从早到晚股票的价格,作为一个事后诸葛亮，你想知道如果随便交易，且每次交易只买卖一股，返回能挣到的最大钱数。

问题二：

问题三：

给定一个数组arr，从左到右表示昨天从早到晚股票的价格，作为一个事后诸葛亮，你想知道如果交易次数不超过K次，且每次交易只买卖一股，返回能挣到的最大钱数。

思想：

问题一思想：

我们遍历数组中的每一个位置i作为股票抛出的位置，i位置之前选取最小的位置作为股票的买入点，遍历完整个数组，取最大值即为最后答案。

问题二思想：

因为题意中已知交易次数不受限制，所以我们知道要想得到最大钱数，只要把数组中所有上浮的数值加起来就为最大钱数。

问题三思想：

交易次数受到限制，我们使用动态规划的思想进行解题。

在解题前我们知道一个数学规律：若数组的长度为N，交易次数K是不会大于N/2的。若K若大于等于N/2，则该问题三等价于问题二。

定义二维数组dp[i][j]，行表示数组中的每个值，列表示交易次数，二维数组含义是0~i时间点上随便交易，不超过j次的情况下取得的最大钱数。

二维数组第一列表示0次交易取最大钱数，全部为0。二维数组第一列表示在0时间点上交易j次取得的最大钱数，全部为0。

接下来我们分析普遍位置dp[i][j]。可以分为两种大类：

1）最后交易的位置不在i位置，那么dp[i][j] = dp[i-1][j]。

2）最后交易的位置在i位置，i位置时卖出操作时能取得最大值。又分为下面几种情况：

1> 0~i上随便交易，不过交易次数不能超过j-1次的情况下，最后在i位置上买，i位置上卖。【 dp[i][j] = dp[i][j-1] + arr[i] - arr[i] 】

2> 0~i-1上随便交易，不过交易次数不能超过j-1次的情况下，最后在i-1位置上买，i位置上卖。【 dp[i][j] = dp[i-1][j-1] + arr[i] - arr[i-1] 】

3> 0~i-2上随便交易，不过交易次数不能超过j-1次的情况下，最后在i-2位置上买，i位置上卖。【 dp[i][j] = dp[i-2][j-1] + arr[i] - arr[i-2] 】

.......

ii> 0~0上随便交易，不过交易次数不能超过j-1次的情况下，最后在0位置上买，i位置上卖。【 dp[i][j] = dp[i][j-1] + arr[i] - arr[0] 】

到此全部分类完成，取出各种情况下的最大值为最后的结果。我们分析情况二中的迭代过程，我们会发现有重复的计算，因此我们可以对此进行优化。

情况2）中

1>...ii>可以整合为：max{

dp[i][j] = dp[i][j-1] - arr[i-1],

dp[i][j] = dp[i-1][j-1] - arr[i-1],

dp[i][j] = dp[i-2][j-1] - arr[i-1],

...

dp[i][j] = dp[0][j-1] - arr[0],

}+ arr[i]。这个迭代结果可以提供给下一次计算直接使用。

我们也可以使用动态规划的空间压缩技术进行代码优化。

代码：

问题一代码：

    public static int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int min = prices[0];
        int ans = 0;
        for (int i = 0; i < prices.length; i++) {
            min = Math.min(min, prices[i]);
            ans = Math.max(ans, prices[i] - min);
        }
        return ans;
    }

    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random());
        }
        return arr;
    }

    public static void main(String[] args) {
        int maxSize = 20;
        int maxValue = 20;
        int testTime = 100000;
        System.out.println("test begin!");
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);
            maxProfit(arr);
        }
        System.out.println("test end!");
    }

问题二代码：

    public static int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int money = 0;
        int pre = prices[0];
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > pre) {
                money += prices[i] - pre;
            }
            pre = prices[i];
        }
        return money;
    }

    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random());
        }
        return arr;
    }

    public static void main(String[] args) {
        int maxSize = 20;
        int maxValue = 20;
        int testTime = 100000;
        System.out.println("test begin!");
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);
            maxProfit(arr);
        }
        System.out.println("test end!");
    }

问题三代码：

动态规划代码

    public static int maxProfit1(int K, int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int N = prices.length;
        if (K >= N / 2) {
            return allTrans(prices);
        }
        int[][] dp = new int[N][K + 1];
        int ans = 0;
        //一列一列遍历
        for (int j = 1; j <= K; j++) {
            //dp[i][j] = dp[0][j]                    ---1)
            //           dp[1][j-1]  - [1]  +  [1]   ---2)1>
            //                      t       +  [1]  
            //           dp[0][j-1]  - [0]  +  [1]   ---2)1>
            //                      t       +  [1]   
            //从第一列开始遍历，所以我么那必须先设置好t的值
            int t = dp[0][j - 1] - prices[0];
            for (int i = 1; i < N; i++) {
                int nextT = Math.max(t, dp[i][j - 1] - prices[i]);
                //情况一和情况二取最大值
                dp[i][j] = Math.max(dp[i - 1][j], t + prices[i]);
                //设置下一轮的t值
                t = nextT;
                ans = Math.max(ans, dp[i][j]);
            }
        }

        return ans;
    }

使用动态规划空间压缩技术。

    public static int maxProfit2(int K,int[] prices){
        if (prices ==null|| prices.length==0){
            return 0;
        }
        int N = prices.length;
        if (K>=N/2){
            return allTrans(prices);
        }
        //dp一维表，做了空间压缩
        int[] dp = new int[N];
        int ans = 0;
        for (int tran = 1; tran<=K; tran++){
            int pre = dp[0];
            int best = pre-prices[0];
            for (int index = 1;index<N;index++){
                pre = dp[index];
                dp[index] = Math.max(dp[index-1],prices[index]+best);
                best = Math.max(best,pre-prices[index]);
                ans = Math.max(dp[index],ans);
            }
        }
        return ans;
    }

    public static int allTrans(int[] prices){
        int ans = 0;
        for (int i =0;i<prices.length;i++){
            ans += Math.max(prices[i] - prices[i-1],0);
        }
        return ans;
    }

测试代码

    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[maxSize];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random());
        }
        return arr;
    }

    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int maxSize = 20;
        int maxValue = 20;
        int testTime = 100000;
        System.out.println("test begin!");
        for (int i = 0; i < testTime; i++) {
            int[] arr = generateRandomArray(maxSize, maxValue);
            int K = 8;
            int res1 = maxProfit1(K,arr);
            int res2 = maxProfit2(K,arr);
            if (res1!=res2){
                System.out.println("Oops!");
                printArray(arr);
                System.out.println(res1);
                System.out.println(res2);
                break;
            }
        }
        System.out.println("test end!");
    }

朂後哋箹萣

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
股票交易作为事后诸葛，交易次数不同时，返回挣到的最大钱数。

问题一：给定一个数组arr，从左到右表示昨天从早到晚股票的价格,作为一个事后诸葛亮，你想知道如果随便交易，且每次交易只买卖一股，返回能挣到的最大钱数。问题二：给定一个数组arr，从左到右表示昨天从早到晚股票的价格,作为一个事后诸葛亮，你想知道如果随便交易，且每次交易只买卖一股，返回能挣到的最大钱数。问题三：给定一个数组arr，从左到右表示昨天从早到晚股票的价格，作为一个事后诸葛亮，你想知道如果交易次数不超过K次，且每次交易只买卖一股，返回
复制链接

扫一扫

专栏目录