[Function add]

Seanforfun · Seanforfun · commit b853d27270b5 · 2019-07-02T16:46:31.000-04:00
1. Add leetcode solutions related to the stock buy and sell questions.
diff --git a/leetcode/123. Best Time to Buy and Sell Stock III.md b/leetcode/123. Best Time to Buy and Sell Stock III.md
@@ -79,4 +79,26 @@ class Solution {
         return first + second;
     }
 }
-```
+```
+
+### Amazon Session
+* Method 1: DP
+	```Java
+	class Solution {
+		public int maxProfit(int[] prices) {
+			if(prices == null || prices.length <= 1) return 0;
+			int len = prices.length;
+			int[][] buys = new int[len + 1][3];
+			int[][] sells = new int[len + 1][3];
+			buys[1][1] = -prices[0];
+			buys[1][2] = Integer.MIN_VALUE;
+			for(int i = 2; i <= len; i++){
+				for(int j = 1; j <= 2; j++){
+					buys[i][j] = Math.max(buys[i - 1][j], sells[i - 1][j - 1] - prices[i - 1]);
+					sells[i][j] = Math.max(sells[i - 1][j], buys[i - 1][j] + prices[i - 1]);
+				}
+			}       
+			return Math.max(sells[len][0], Math.max(sells[len][1], sells[len][2]));
+		}
+	}
+	```
diff --git a/leetcode/188. Best Time to Buy and Sell Stock IV.md b/leetcode/188. Best Time to Buy and Sell Stock IV.md
@@ -0,0 +1,73 @@
+## 188. Best Time to Buy and Sell Stock IV
+
+### Question
+Say you have an array for which the ith element is the price of a given stock on day i.
+
+Design an algorithm to find the maximum profit. You may complete at most k transactions.
+
+Note: You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
+
+```
+Example 1:
+
+Input: [2,4,1], k = 2
+Output: 2
+Explanation: Buy on day 1 (price = 2) and sell on day 2 (price = 4), profit = 4-2 = 2.
+
+Example 2:
+
+Input: [3,2,6,5,0,3], k = 2
+Output: 7
+Explanation: Buy on day 2 (price = 2) and sell on day 3 (price = 6), profit = 6-2 = 4.
+             Then buy on day 5 (price = 0) and sell on day 6 (price = 3), profit = 3-0 = 3.
+```
+
+### Solution
+* Method 1: dp
+	1. We need to pay attention to the initialization.
+	2. Transaction function is same as [123. Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/description/).
+	3. If k is larger than prices length, we treat it as question [122. Best Time to Buy and Sell Stock II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/122.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock%20II.md).
+	```Java
+	class Solution {
+		public int maxProfit(int k, int[] prices) {
+			if(k == 0 || prices == null || prices.length <= 1) return 0;
+			int len = prices.length;
+			if(k > len) return maxProfit(prices);
+			int[][] buys = new int[len + 1][k + 1];
+			int[][] sells = new int[len + 1][k + 1];
+			for(int i = 2; i <= k; i++){
+				for(int j = 0; j < i; j++){
+					buys[j][i] = Integer.MIN_VALUE;
+				}
+			}
+			int sum = 0;
+			for(int i = 1; i <= k; i++){
+				sum -= prices[i - 1];
+				buys[i][i] = sum;
+			}
+			for(int i = 2; i <= len; i++){
+				for(int j = 1; j <= k; j++){
+					buys[i][j] = Math.max(buys[i - 1][j], sells[i - 1][j - 1] - prices[i - 1]);
+					sells[i][j] = Math.max(sells[i - 1][j], buys[i - 1][j] + prices[i - 1]);
+				}
+			}        
+			int profit = 0;
+			for(int i = 0; i <= k; i++){
+				profit = Math.max(profit, sells[len][i]);
+			}
+			return profit;
+		}
+		
+		private int maxProfit(int[] prices) {
+				int len = prices.length;
+				int[] buys = new int[len + 1];
+				int[] sells = new int[len + 1];
+				buys[1] = -prices[0];
+				for(int i = 2; i <= len; i++){
+					buys[i] = Math.max(buys[i - 1], sells[i - 1] - prices[i - 1]);
+					sells[i] = Math.max(sells[i - 1], buys[i - 1] + prices[i - 1]);
+				}
+				return sells[len];
+			}
+	}
+	```
diff --git a/leetcode/309. Best Time to Buy and Sell Stock with Cooldown.md b/leetcode/309. Best Time to Buy and Sell Stock with Cooldown.md
@@ -111,6 +111,26 @@ class Solution {
 		}
 		```
 
+### Amazon Session
+* Method 1: dp
+	```Java
+	class Solution {
+		public int maxProfit(int[] prices) {
+			if(prices == null || prices.length <= 1) return 0;
+			int len = prices.length;
+			int[] buys = new int[len + 1];
+			int[] sells = new int[len + 1];
+			int[] cools = new int[len + 1];
+			buys[1] = -prices[0];
+			for(int i = 2; i <= len; i++){
+				buys[i] = Math.max(buys[i - 1], cools[i - 1] - prices[i - 1]);
+				cools[i] = Math.max(cools[i - 1], sells[i - 1]);
+				sells[i] = Math.max(buys[i - 1] + prices[i - 1], sells[i - 1]);
+			}
+			return sells[len];
+		}
+	}
+	```
 
 ### Reference
 1. [【LeetCode】309. Best Time to Buy and Sell Stock with Cooldown](https://www.cnblogs.com/jdneo/p/5228004.html)
diff --git a/leetcode/714. Best Time to Buy and Sell Stock with Transaction Fee.md b/leetcode/714. Best Time to Buy and Sell Stock with Transaction Fee.md
@@ -0,0 +1,45 @@
+## 714. Best Time to Buy and Sell Stock with Transaction Fee
+
+### Question
+Your are given an array of integers prices, for which the i-th element is the price of a given stock on day i; and a non-negative integer fee representing a transaction fee.
+
+You may complete as many transactions as you like, but you need to pay the transaction fee for each transaction. You may not buy more than 1 share of a stock at a time (ie. you must sell the stock share before you buy again.)
+
+Return the maximum profit you can make.
+
+```
+Example 1:
+
+Input: prices = [1, 3, 2, 8, 4, 9], fee = 2
+Output: 8
+Explanation: The maximum profit can be achieved by:
+Buying at prices[0] = 1
+Selling at prices[3] = 8
+Buying at prices[4] = 4
+Selling at prices[5] = 9
+The total profit is ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
+```
+
+Note:
+1. 0 < prices.length <= 50000.
+2. 0 < prices[i] < 50000.
+3. 0 <= fee < 50000.
+
+### Solutions
+* Method 1: dp
+	```Java
+	class Solution {
+		public int maxProfit(int[] prices, int fee) {
+			if(prices == null || prices.length <= 1) return 0;
+			int len = prices.length;
+			int[] buys = new int[len + 1];
+			int[] sells = new int[len + 1];
+			buys[1] = -prices[0];
+			for(int i = 2; i <= len; i++){
+				buys[i] = Math.max(buys[i - 1], sells[i - 1] - prices[i - 1]);
+				sells[i] = Math.max(sells[i - 1], buys[i - 1] + prices[i - 1] - fee);
+			}
+			return sells[len];
+		}
+	}
+	```
