|
26 | 26 | * |
27 | 27 | * @Auther: zhunn |
28 | 28 | * @Date: 2020/11/3 21:06 |
29 | | - * @Description: 买卖股票的最佳时机 III:1-动态规划-优化空间;2-动态规划 |
| 29 | + * @Description: 买卖股票的最佳时机 III:1-动态规划;2-动态规划-优化空间 |
30 | 30 | */ |
31 | 31 | public class Solution { |
32 | 32 |
|
33 | 33 | /** |
34 | | - * 1-动态规划-优化空间 |
35 | | - * (由于今天只参考了昨天的状态,所以直接去掉第一维度不会影响状态转移的正确性) |
| 34 | + * 1-动态规划 dp[i][j][k]: i 表示第几天(0-n),j表示交易了几次(0,1,2),k表示是否持股(0-不持股,1-持股) |
36 | 35 | * |
37 | 36 | * @param prices |
38 | | - * @return dp[i][j][k]: i 表示第几天(0-n),j表示交易了几次(0,1,2),k表示是否持股(0-不持股,1-持股) |
39 | | - * 此题可以用dp[j][k] 即可 |
| 37 | + * @return |
40 | 38 | */ |
41 | 39 | public int maxProfit(int[] prices) { |
42 | | - if (prices == null || prices.length < 2) { |
| 40 | + int len = prices.length; |
| 41 | + if (len < 2) { |
43 | 42 | return 0; |
44 | 43 | } |
45 | | - int[][] dp = new int[3][2]; |
46 | | - dp[0][0] = 0; |
47 | | - dp[1][1] = -prices[0]; |
48 | | - dp[2][1] = Integer.MIN_VALUE; // 还没发生的交易,持股的时候应该初始化为负无穷 |
49 | 44 |
|
50 | | - for (int i = 1; i < prices.length; i++) { |
51 | | - dp[1][1] = Math.max(-prices[i], dp[1][1]); |
52 | | - dp[1][0] = Math.max(dp[1][1] + prices[i], dp[1][0]); |
53 | | - dp[2][1] = Math.max(dp[1][0] - prices[i], dp[2][1]); |
54 | | - dp[2][0] = Math.max(dp[2][1] + prices[i], dp[2][0]); |
| 45 | + // 第 2 维的 0 没有意义,1 表示交易进行了 1 次,2 表示交易进行了 2 次 |
| 46 | + // 为了使得第 2 维的数值 1 和 2 有意义,这里将第 2 维的长度设置为 3 |
| 47 | + int[][][] dp = new int[len][3][2]; |
| 48 | + |
| 49 | + // 理解如下初始化 |
| 50 | + // 第 3 维规定了必须持股,因此是 -prices[0] |
| 51 | + dp[0][1][1] = -prices[0]; |
| 52 | + // 还没发生的交易,持股的时候应该初始化为负无穷 |
| 53 | + dp[0][2][1] = Integer.MIN_VALUE; |
| 54 | + |
| 55 | + for (int i = 1; i < len; i++) { |
| 56 | + // 转移顺序先持股,再卖出 |
| 57 | + dp[i][1][1] = Math.max(dp[i - 1][1][1], dp[i - 1][0][0] - prices[i]); |
| 58 | + dp[i][1][0] = Math.max(dp[i - 1][1][0], dp[i - 1][1][1] + prices[i]); |
| 59 | + dp[i][2][1] = Math.max(dp[i - 1][2][1], dp[i - 1][1][0] - prices[i]); |
| 60 | + dp[i][2][0] = Math.max(dp[i - 1][2][0], dp[i - 1][2][1] + prices[i]); |
55 | 61 | } |
56 | | - return Math.max(dp[1][0], dp[2][0]); |
| 62 | + return Math.max(dp[len - 1][1][0], dp[len - 1][2][0]); |
57 | 63 | } |
58 | 64 |
|
59 | 65 | /** |
60 | | - * 2-动态规划 |
| 66 | + * 2-动态规划-优化空间 |
| 67 | + * (由于今天只参考了昨天的状态,所以直接去掉第一维度不会影响状态转移的正确性) |
61 | 68 | * |
62 | 69 | * @param prices |
63 | | - * @return |
| 70 | + * @return dp[i][j][k]: i 表示第几天(0-n),j表示交易了几次(0,1,2),k表示是否持股(0-不持股,1-持股) |
| 71 | + * 此题可以用dp[j][k] 即可 |
64 | 72 | */ |
65 | 73 | public int maxProfit2(int[] prices) { |
66 | | - if (prices == null || prices.length == 0) { |
| 74 | + if (prices == null || prices.length < 2) { |
67 | 75 | return 0; |
68 | 76 | } |
69 | | - // dp[i][j] ,表示 [0, i] 区间里,状态为 j 的最大收益 |
70 | | - // j = 0:什么都不操作 |
71 | | - // j = 1:第 1 次买入一支股票 |
72 | | - // j = 2:第 1 次卖出一支股票 |
73 | | - // j = 3:第 2 次买入一支股票 |
74 | | - // j = 4:第 2 次卖出一支股票 |
75 | | - |
76 | | - int n = prices.length; |
77 | | - int[][] dp = new int[n][5]; |
| 77 | + int[][] dp = new int[3][2]; |
78 | 78 | dp[0][0] = 0; |
79 | | - dp[0][1] = -prices[0]; |
80 | | - for (int i = 0; i < n; i++) { |
81 | | - dp[i][3] = Integer.MIN_VALUE; |
82 | | - } |
| 79 | + dp[1][1] = -prices[0]; |
| 80 | + dp[2][1] = Integer.MIN_VALUE; // 还没发生的交易,持股的时候应该初始化为负无穷 |
83 | 81 |
|
84 | | - for (int i = 1; i < n; i++) { |
85 | | - dp[i][0] = 0; |
86 | | - dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]); |
87 | | - dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]); |
88 | | - dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]); |
89 | | - dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]); |
| 82 | + for (int i = 1; i < prices.length; i++) { |
| 83 | + dp[1][1] = Math.max(dp[1][1], dp[0][0] - prices[i]); |
| 84 | + dp[1][0] = Math.max(dp[1][0], dp[1][1] + prices[i]); |
| 85 | + dp[2][1] = Math.max(dp[2][1], dp[1][0] - prices[i]); |
| 86 | + dp[2][0] = Math.max(dp[2][0], dp[2][1] + prices[i]); |
90 | 87 | } |
91 | | - return Math.max(Math.max(dp[n - 1][0], dp[n - 1][2]), dp[n - 1][4]); |
| 88 | + return Math.max(dp[1][0], dp[2][0]); |
92 | 89 | } |
93 | 90 |
|
| 91 | + ///** |
| 92 | + // * 3-动态规划 |
| 93 | + // * |
| 94 | + // * @param |
| 95 | + // * @return |
| 96 | + // */ |
| 97 | + //public int maxProfit3(int[] prices) { |
| 98 | + // if (prices == null || prices.length == 0) { |
| 99 | + // return 0; |
| 100 | + // } |
| 101 | + // // dp[i][j] ,表示 [0, i] 区间里,状态为 j 的最大收益 |
| 102 | + // // j = 0:什么都不操作 |
| 103 | + // // j = 1:第 1 次买入一支股票 |
| 104 | + // // j = 2:第 1 次卖出一支股票 |
| 105 | + // // j = 3:第 2 次买入一支股票 |
| 106 | + // // j = 4:第 2 次卖出一支股票 |
| 107 | + // |
| 108 | + // int n = prices.length; |
| 109 | + // int[][] dp = new int[n][5]; |
| 110 | + // dp[0][0] = 0; |
| 111 | + // dp[0][1] = -prices[0]; |
| 112 | + // for (int i = 0; i < n; i++) { |
| 113 | + // dp[i][3] = Integer.MIN_VALUE; |
| 114 | + // } |
| 115 | + // |
| 116 | + // for (int i = 1; i < n; i++) { |
| 117 | + // dp[i][0] = 0; |
| 118 | + // dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]); |
| 119 | + // dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]); |
| 120 | + // dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]); |
| 121 | + // dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]); |
| 122 | + // } |
| 123 | + // return Math.max(Math.max(dp[n - 1][0], dp[n - 1][2]), dp[n - 1][4]); |
| 124 | + //} |
| 125 | + |
94 | 126 | @Test |
95 | 127 | public void test() { |
96 | 128 | int[] prices = {3, 3, 5, 0, 0, 3, 1, 4}; |
| 129 | + System.out.println(maxProfit(prices)); |
97 | 130 | System.out.println(maxProfit2(prices)); |
98 | 131 | } |
99 | 132 | } |
0 commit comments