DP

h2pl · h2pl · commit b79b83135869 · 2018-04-11T12:04:22.000+08:00
股票问题通解
dp结束
diff --git a/src/DP/其他问题如股票/股票问题通解.java b/src/DP/其他问题如股票/股票问题通解.java
diff --git a/src/DP/其他问题如股票/需要交易费用的股票交易_多数组.java b/src/DP/其他问题如股票/需要交易费用的股票交易_多数组.java
diff --git a/src/DP/其他问题如股票/需要冷却期的股票交易_双数组.java b/src/DP/其他问题如股票/需要冷却期的股票交易_双数组.java
diff --git a/src/DP/分割整数/按平方数来分割整数.java b/src/DP/分割整数/按平方数来分割整数.java
@@ -1,4 +1,4 @@
-package DP;
+package DP.分割整数;
 
 /**
  * Created by 周杰伦 on 2018/4/3.
diff --git a/src/DP/字符串编辑/删除两个字符串的字符使它们相等.java b/src/DP/字符串编辑/删除两个字符串的字符使它们相等.java
@@ -3,7 +3,7 @@
 /**
  * Created by 周杰伦 on 2018/4/9.
  */
-public class 字符串编辑 {
+public class 删除两个字符串的字符使它们相等 {
     public static void main(String[] args) {
         String a = "eat";
         String b = "sea";
diff --git a/src/DP/字符串编辑/复制粘贴字符.java b/src/DP/字符串编辑/复制粘贴字符.java
@@ -0,0 +1,33 @@
+package DP.字符串编辑;
+
+/**
+ * Created by 周杰伦 on 2018/4/11.
+ */
+public class 复制粘贴字符 {
+    public static void main(String[] args) {
+        System.out.println(minSteps(3));
+        System.out.println(minSteps(4));
+        System.out.println(minSteps(5));
+        System.out.println(minSteps(6));
+        System.out.println(minSteps(7));
+        System.out.println(minSteps(8));
+    }
+    public static int minSteps(int n) {
+        if (n == 1) return 0;
+        int []dp = new int[n + 1];
+        dp[1] = 1;
+        //dp[2] = 2;
+        //dp[3] = 3;
+        //dp[4] = 4; dp[5] = 5;dp[6] = 5;dp[7] = 7;dp[8] = 6;
+
+        for (int i = 2;i <= n;i ++) {
+            dp[i] = i;
+            for (int j = 1;j < i;j ++) {
+                if (i % j == 0) {
+                    dp[i] = Math.min(dp[i], dp[j] + ((i/j)));
+                }
+            }
+        }
+        return dp[n];
+    }
+}
diff --git a/src/DP/矩阵路径/爬楼梯方法总数.java b/src/DP/矩阵路径/爬楼梯方法总数.java
@@ -1,4 +1,4 @@
-package DP.经典;
+package DP.矩阵路径;
 
 /**
  * Created by 周杰伦 on 2018/4/4.
diff --git a/src/DP/矩阵路径/矩阵的总路径数.java b/src/DP/矩阵路径/矩阵的总路径数.java
@@ -1,4 +1,4 @@
-package DP.经典;
+package DP.矩阵路径;
 
 /**
  * Created by 周杰伦 on 2018/4/4.
diff --git a/src/DP/股票买卖/买入和售出股票最大的收益.java b/src/DP/股票买卖/买入和售出股票最大的收益.java
@@ -1,4 +1,4 @@
-package DP.其他问题如股票;
+package DP.股票买卖;
 
 /**
  * Created by 周杰伦 on 2018/4/9.
diff --git a/src/DP/股票买卖/只能进行k次的股票交易.java b/src/DP/股票买卖/只能进行k次的股票交易.java
@@ -0,0 +1,7 @@
+package DP.股票买卖;
+
+/**
+ * Created by 周杰伦 on 2018/4/11.
+ */
+public class 只能进行k次的股票交易 {
+}
diff --git a/src/DP/股票买卖/只能进行两次的股票交易.java b/src/DP/股票买卖/只能进行两次的股票交易.java
@@ -0,0 +1,7 @@
+package DP.股票买卖;
+
+/**
+ * Created by 周杰伦 on 2018/4/11.
+ */
+public class 只能进行两次的股票交易 {
+}
diff --git a/src/DP/股票买卖/股票问题通解.java b/src/DP/股票买卖/股票问题通解.java
@@ -0,0 +1,134 @@
+package DP.股票买卖;
+
+import java.util.Arrays;
+
+/**
+ * Created by 周杰伦 on 2018/4/10.
+ * I -- General cases
+
+ The idea begins with the following question: Given an array representing the price of stock on each day, what determines the maximum profit we can obtain?
+
+ Most of you can quickly come up with answers like “it depends on which day we are and how many transactions we are allowed to complete”. Sure, those are important factors as they manifest themselves in the problem descriptions. However, there is a hidden factor that is not so obvious but vital in determining the maximum profit, which is elaborated below.
+
+ First let’s spell out the notations to streamline our analyses. Let prices be the stock price array with length n, i denote the i-th day (i will go from 0 to n-1), k denote the maximum number of transactions allowed to complete, T[i][k] be the maximum profit that could be gained at the end of the i-th day with at most k transactions. Apparently we have base cases: T[-1][k] = T[i][0] = 0, that is, no stock or no transaction yield no profit (note the first day has i = 0 so i = -1 means no stock). Now if we can somehow relate T[i][k] to its subproblems like T[i-1][k], T[i][k-1], T[i-1][k-1], ..., we will have a working recurrence relation and the problem can be solved recursively. So how do we achieve that?
+
+ The most straightforward way would be looking at actions taken on the i-th day. How many options do we have? The answer is three: buy, sell, rest. Which one should we take? The answer is: we don’t really know, but to find out which one is easy. We can try each option and then choose the one that maximizes our profit, provided there are no other restrictions. However, we do have an extra restriction saying no multiple transactions are allowed at the same time, meaning if we decide to buy on the i-th day, there should be 0 stock held in our hand before we buy; if we decide to sell on the i-th day, there should be exactly 1 stock held in our hand before we sell. The number of stocks held in our hand is the hidden factor mentioned above that will affect the action on the i-th day and thus affect the maximum profit.
+
+ Therefore our definition of T[i][k] should really be split into two: T[i][k][0] and T[i][k][1], where the former denotes the maximum profit at the end of the i-th day with at most k transactions and with 0 stock in our hand AFTER taking the action, while the latter denotes the maximum profit at the end of the i-th day with at most k transactions and with 1 stock in our hand AFTER taking the action. Now the base cases and the recurrence relations can be written as:
+
+ Base cases:
+ T[-1][k][0] = 0, T[-1][k][1] = -Infinity
+ T[i][0][0] = 0, T[i][0][1] = -Infinity
+
+ Recurrence relations:
+ T[i][k][0] = max(T[i-1][k][0], T[i-1][k][1] + prices[i])
+ T[i][k][1] = max(T[i-1][k][1], T[i-1][k-1][0] - prices[i])
+
+ For the base cases, T[-1][k][0] = T[i][0][0] = 0 has the same meaning as before while T[-1][k][1] = T[i][0][1] = -Infinity emphasizes the fact that it is impossible for us to have 1 stock in hand if there is no stock available or no transactions are allowed.
+
+ For T[i][k][0] in the recurrence relations, the actions taken on the i-th day can only be rest and sell, since we have 0 stock in our hand at the end of the day. T[i-1][k][0] is the maximum profit if action rest is taken, while T[i-1][k][1] + prices[i] is the maximum profit if action sell is taken. Note that the maximum number of allowable transactions remains the same, due to the fact that a transaction consists of two actions coming as a pair – buy and sell. Only action buy will change the maximum number of transactions allowed (well, there is actually an alternative interpretation, see my comment below).
+
+ For T[i][k][1] in the recurrence relations, the actions taken on the i-th day can only be rest and buy, since we have 1 stock in our hand at the end of the day. T[i-1][k][1] is the maximum profit if action rest is taken, while T[i-1][k-1][0] - prices[i] is the maximum profit if action buy is taken. Note that the maximum number of allowable transactions decreases by one, since buying on the i-th day will use one transaction, as explained above.
+
+ To find the maximum profit at the end of the last day, we can simply loop through the prices array and update T[i][k][0] and T[i][k][1] according to the recurrence relations above. The final answer will be T[i][k][0] (we always have larger profit if we end up with 0 stock in hand).
+
+ III -- Summary
+
+ In summary, the most general case of the stock problem can be characterized by three factors, the ordinal of the day i, the maximum number of allowable transactions k and the number of stocks in our hand at the end of the day. I have shown the recurrence relations for the maximum profits and their termination conditions, which leads to the O(nk) time and O(k) space solution. The results are then applied to each of the six cases, with the last two using slightly modified recurrence relations due to the additional requirements. I should mention that peterleetcode also introduced a nice solution here which generalizes to arbitrary k values. If you have a taste, take a look.
+
+ Hope this helps and happy coding!
+ */
+public class 股票问题通解 {
+    //一次交易
+    public int maxProfitOnce(int[] prices) {
+        int T_i10 = 0, T_i11 = Integer.MIN_VALUE;
+
+        for (int price : prices) {
+            T_i10 = Math.max(T_i10, T_i11 + price);
+            T_i11 = Math.max(T_i11, -price);
+        }
+
+        return T_i10;
+    }
+    //无限次数交易
+    public int maxProfitInfinity(int[] prices) {
+        int T_ik0 = 0, T_ik1 = Integer.MIN_VALUE;
+
+        for (int price : prices) {
+            int T_ik0_old = T_ik0;
+            T_ik0 = Math.max(T_ik0, T_ik1 + price);
+            T_ik1 = Math.max(T_ik1, T_ik0_old - price);
+        }
+
+        return T_ik0;
+    }
+
+    //k次交易
+    public int maxProfitKtimes(int[] prices) {
+        int T_i10 = 0, T_i11 = Integer.MIN_VALUE, T_i20 = 0, T_i21 = Integer.MIN_VALUE;
+
+        for (int price : prices) {
+            T_i20 = Math.max(T_i20, T_i21 + price);
+            T_i21 = Math.max(T_i21, T_i10 - price);
+            T_i10 = Math.max(T_i10, T_i11 + price);
+            T_i11 = Math.max(T_i11, -price);
+        }
+
+        return T_i20;
+    }
+
+    //k是任意的
+    public int maxProfitKisArbitrary(int k, int[] prices) {
+        if (k >= prices.length >>> 1) {
+            int T_ik0 = 0, T_ik1 = Integer.MIN_VALUE;
+
+            for (int price : prices) {
+                int T_ik0_old = T_ik0;
+                T_ik0 = Math.max(T_ik0, T_ik1 + price);
+                T_ik1 = Math.max(T_ik1, T_ik0_old - price);
+            }
+
+            return T_ik0;
+        }
+
+        int[] T_ik0 = new int[k + 1];
+        int[] T_ik1 = new int[k + 1];
+        Arrays.fill(T_ik1, Integer.MIN_VALUE);
+
+        for (int price : prices) {
+            for (int j = k; j > 0; j--) {
+                T_ik0[j] = Math.max(T_ik0[j], T_ik1[j] + price);
+                T_ik1[j] = Math.max(T_ik1[j], T_ik0[j - 1] - price);
+            }
+        }
+
+        return T_ik0[k];
+    }
+
+    //有冷却时间的交易
+    public int maxProfitCoolDown(int[] prices) {
+        int T_ik0_pre = 0, T_ik0 = 0, T_ik1 = Integer.MIN_VALUE;
+
+        for (int price : prices) {
+            int T_ik0_old = T_ik0;
+            T_ik0 = Math.max(T_ik0, T_ik1 + price);
+            T_ik1 = Math.max(T_ik1, T_ik0_pre - price);
+            T_ik0_pre = T_ik0_old;
+        }
+
+        return T_ik0;
+    }
+
+    //需要手续费的交易
+    public int maxProfitWithFee(int[] prices, int fee) {
+        int T_ik0 = 0, T_ik1 = Integer.MIN_VALUE;
+
+        for (int price : prices) {
+            int T_ik0_old = T_ik0;
+            T_ik0 = Math.max(T_ik0, T_ik1 + price);
+            T_ik1 = Math.max(T_ik1, T_ik0_old - price - fee);
+        }
+
+        return T_ik0;
+    }
+}
diff --git a/src/DP/股票买卖/需要交易费用的股票交易_多数组.java b/src/DP/股票买卖/需要交易费用的股票交易_多数组.java
@@ -0,0 +1,58 @@
+package DP.股票买卖;
+
+/**
+ * Created by 周杰伦 on 2018/4/10.
+ */
+public class 需要交易费用的股票交易_多数组 {
+    public static void main(String[] args) {
+        int []a = {1, 3, 2, 8, 4, 9};
+        System.out.println(maxProfit(a, 2));
+    }
+    public static int maxProfit(int[] prices, int fee) {
+        if (prices.length < 2)return 0;
+        int []sell = new int[prices.length];
+        int []buy = new int[prices.length];
+        int []hold = new int[prices.length];
+        int []empty = new int[prices.length];
+        sell[0] = 0;
+        buy[0] = - prices[0];
+        hold[0] = Integer.MIN_VALUE;
+        empty[0] = 0;
+        for (int i = 1;i < prices.length;i ++) {
+            empty[i] = Math.max(empty[i - 1], sell[i - 1]);
+            buy[i] = Math.max(empty[i - 1],sell[i - 1]) - prices[i];
+            hold[i] = Math.max(buy[i - 1], hold[i - 1]);
+            sell[i] = Math.max(buy[i - 1],hold[i - 1] ) + prices[i] - fee;
+        }
+        int max = Math.max(sell[prices.length - 1], empty[prices.length - 1]);
+        return max;
+    }
+
+//    public int maxProfit(int[] prices, int fee) {
+//        if(prices.length <= 1) return 0;
+//        int[] buy = new int[prices.length];
+//        int[] hold = new int[prices.length];
+//        int[] skip = new int[prices.length];
+//        int[] sell = new int[prices.length];
+//        // the moment we buy a stock, our balance should decrease
+//        buy[0] = 0 - prices[0];
+//        // assume if we have stock in the first day, we are still in deficit
+//        hold[0] = 0 - prices[0];
+//        for(int i = 1; i < prices.length; i++){
+//            // We can only buy on today if we sold stock
+//            // or skipped with empty portfolio yesterday
+//            buy[i] = Math.max(skip[i-1], sell[i-1]) - prices[i];
+//            // Can only hold if we bought or already holding stock yesterday
+//            hold[i] = Math.max(buy[i-1], hold[i-1]);
+//            // Can skip only if we skipped, or sold stock yesterday
+//            skip[i] = Math.max(skip[i-1], sell[i-1]);
+//            // Can sell only if we bought, or held stock yesterday
+//            sell[i] = Math.max(buy[i-1], hold[i-1]) + prices[i] - fee;
+//        }
+//        // Get the max of all the 4 actions on the last day.
+//        int max = Math.max(buy[prices.length - 1], hold[prices.length - 1]);
+//        max = Math.max(skip[prices.length - 1], max);
+//        max = Math.max(sell[prices.length - 1], max);
+//        return Math.max(max, 0);
+//    }
+}
diff --git a/src/DP/股票买卖/需要冷却期的股票交易_双数组.java b/src/DP/股票买卖/需要冷却期的股票交易_双数组.java
@@ -0,0 +1,49 @@
+package DP.股票买卖;
+
+/**
+ * Created by 周杰伦 on 2018/4/9.
+ */
+public class 需要冷却期的股票交易_双数组 {
+    public static void main(String[] args) {
+        int []a = {6,1,3,2,4,7};
+        System.out.println(maxProfit(a));
+    }
+
+    //错误的解法。
+//    public static int maxProfit(int[] prices) {
+//        if (prices.length < 2) return 0;
+//        int[] sell = new int[prices.length];
+//        int []cool = new int[prices.length];
+//        int []buy = new int[prices.length];
+//        sell[0] = Integer.MIN_VALUE;
+//        sell[1] = prices[1] - prices[0];
+//        cool[0] = Integer.MIN_VALUE;
+//        cool[1] = Integer.MIN_VALUE;
+//        buy[0] = - prices[0];
+//        buy[1] = - prices[1];
+//        for (int i = 2;i < prices.length;i ++) {
+//            //buy[i] = cool[i - 1]
+//            buy[i] = cool[i - 1];
+//            sell[i] = Math.max(sell[i - 1] + prices[i] - prices[i - 1]  ,buy[i - 1] + prices[i]);
+//            cool[i] = Math.max(cool[i - 1], sell[i - 1]);
+//        }
+//        int max = Math.max(sell[prices.length - 1], cool[prices.length - 1]);
+//        return max;
+//    }
+
+
+    public static int maxProfit(int[] prices) {
+        if(prices == null || prices.length < 2){
+            return 0;
+        }
+        int len = prices.length;
+        int[] sell = new int[len]; //sell[i] means must sell at day i
+        int[] cooldown = new int[len]; //cooldown[i] means day i is cooldown day
+        sell[1] = prices[1] - prices[0];
+        for(int i = 2; i < prices.length; ++i){
+            cooldown[i] = Math.max(sell[i - 1], cooldown[i - 1]);
+            sell[i] = prices[i] - prices[i - 1] + Math.max(sell[i - 1], cooldown[i - 2]);
+        }
+        return Math.max(sell[len - 1], cooldown[len - 1]);
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package DP;`
	`1`	`+package DP.分割整数;`
`2`	`2`
`3`	`3`	`/**`
`4`	`4`	`* Created by 周杰伦 on 2018/4/3.`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package DP.经典;`
	`1`	`+package DP.矩阵路径;`
`2`	`2`
`3`	`3`	`/**`
`4`	`4`	`* Created by 周杰伦 on 2018/4/4.`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package DP.其他问题如股票;`
	`1`	`+package DP.股票买卖;`
`2`	`2`
`3`	`3`	`/**`
`4`	`4`	`* Created by 周杰伦 on 2018/4/9.`