[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -481,6 +481,8 @@
 
 [307. Range Sum Query - Mutable](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/307.%20Range%20Sum%20Query%20-%20Mutable.md)
 
+[309. Best Time to Buy and Sell Stock with Cooldown](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/309.%20Best%20Time%20to%20Buy%20and%20Sell%20Stock%20with%20Cooldown.md)
+
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/121. Best Time to Buy and Sell Stock.md

@@ -97,4 +97,22 @@ class Solution {
         return global;
     }
 }
+```
+
+### Third time
+1. This time I beat 100%, for each day, we have fixed price, we need to find the minimum price ahead.
+	* Update the max profit.
+	* Update the min price.
+```Java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if(prices == null || prices.length == 0) return 0;
+        int min = prices[0], profit = 0;
+        for(int i = 0; i < prices.length; i++){
+            profit = Math.max(profit, prices[i] - min);
+            min = Math.min(min, prices[i]);
+        }
+        return profit;
+    }
+}
 ```

leetcode/122. Best Time to Buy and Sell Stock II.md

@@ -63,4 +63,45 @@ class Solution {
         return result;
     }
 }
+```
+
+### Third time
+1. Method 1: Finding the dropping points.
+```Java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if(prices == null || prices.length == 0) return 0;
+        int profit = 0, pre = -1;
+        for(int i = 1; i < prices.length; i++){
+            if(prices[i] < prices[i - 1]){
+                if(pre != -1) profit += prices[i - 1] - prices[pre];
+                else profit += prices[i - 1] - prices[0];
+                pre = i;
+            }
+        }
+        if(pre == -1) return prices[prices.length - 1] - prices[0];
+        if(pre != prices.length - 1) profit += prices[prices.length - 1] - prices[pre];
+        return profit;
+    }
+}
+```
+
+2. Use dp to solve this question.
+	* s0(holding a stock): 1. rest 2. sell
+	* s1(not holding any stock): 1.rest, 2. buy
+```Java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if(prices == null || prices.length == 0) return 0;
+        int len = prices.length;
+        int[] s0 = new int[len + 1];
+        int[] s1 = new int[len + 1];
+        s0[1] = -prices[0];
+        for(int i = 2; i <= len; i++){
+            s0[i] = Math.max(s0[i - 1], s1[i - 1] - prices[i - 1]);
+            s1[i] = Math.max(s1[i - 1], s0[i - 1] + prices[i - 1]);
+        }
+        return s1[len];
+    }
+}
 ```

leetcode/123. Best Time to Buy and Sell Stock III.md

@@ -49,4 +49,34 @@ class Solution {
         return global[2];
     }
 }
+```
+
+### Second time
+1. (Wrong)I tried my best to solve this question but cannot pass one case: [1,2,4,2,5,7,2,4,9,0], maybe I can use recursion to solve this question, but not a good idea.
+```Java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if(prices == null || prices.length == 0) return 0;
+        int first = 0, second = 0, pre = -1, temp = 0;;
+        for(int i = 1; i < prices.length; i++){
+            if(prices[i] < prices[i - 1]){
+                temp = pre == -1 ? prices[i - 1] - prices[0] : prices[i - 1] - prices[pre];
+                pre = i;
+                if(temp >= first){
+                    second = first;
+                    first = temp;
+                }else if(temp > second) second = temp;
+            }
+        }
+        if(pre == -1) return prices[prices.length - 1] - prices[0];
+        if(pre != prices.length - 1){
+            temp = prices[prices.length - 1] - prices[pre];
+            if(temp >= first){
+                second = first;
+                first = temp;
+            }else if(temp > second) second = temp;
+        }
+        return first + second;
+    }
+}
 ```

leetcode/307. Range Sum Query - Mutable.md

@@ -128,6 +128,61 @@ class NumArray {
         return sum2 - sum1;
     }
 }
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * obj.update(i,val);
+ * int param_2 = obj.sumRange(i,j);
+ */
+```
+
+2. Use segment tree to solve this question.
+```Java
+class NumArray {
+    private int[] segment;
+    private int[] nums;
+    public NumArray(int[] nums) {
+        this.segment = new int[nums.length << 2 + 1];
+        this.nums = nums;
+        if(nums != null && nums.length != 0)    build(1, nums.length, 1);
+    }
+    private void build(int l, int r, int k){
+        if(l == r){
+            segment[k] = this.nums[l - 1];
+        }else{
+            int m = l + ((r - l) >> 1);
+            build(l, m, k << 1);
+            build(m + 1, r, k << 1 | 1);
+            segment[k] = segment[k << 1] + segment[k << 1 | 1];
+        }
+    }
+    public void update(int i, int val) {
+        update(i + 1, val - this.nums[i], 1, this.nums.length, 1);
+        this.nums[i] = val;
+    }
+    private void update(int i, int diff, int l, int r, int k){
+        if(l == r) segment[k] += diff;
+        else{
+            int mid = l + ((r - l) >> 1);
+            if(i <= mid)    update(i, diff, l, mid, k << 1);
+            else    update(i, diff, mid + 1, r, k << 1 | 1);
+            segment[k] = segment[k << 1] + segment[k << 1 | 1];
+        }
+    }
+    public int sumRange(int i, int j) {
+        return sum(i + 1, j + 1, 1, this.nums.length, 1);
+    }
+    private int sum(int L, int R, int l, int r, int k){
+        if(L <= l && R >= r) return segment[k];
+        else{
+            int m = l + ((r - l) >> 1);
+            int sum = 0;
+            if(L <= m) sum += sum(L, R, l, m, k << 1);
+            if(R > m) sum += sum(L, R, m + 1, r, k << 1 | 1);
+            return sum;
+        }
+    }
+}
 /**
  * Your NumArray object will be instantiated and called as such:
  * NumArray obj = new NumArray(nums);

leetcode/309. Best Time to Buy and Sell Stock with Cooldown.md

@@ -39,4 +39,28 @@ class Solution {
         return sell[len];
     }
 }
-```
+```
+
+### Second time
+![Imgur](https://i.imgur.com/N0jPd47.png)
+```Java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if(prices == null || prices.length == 0) return 0;
+        int len = prices.length;
+        int[] s0 = new int[len + 1];
+        int[] s1 = new int[len + 1];
+        int[] s2 = new int[len + 1];
+        s1[1] = -prices[0];
+        for(int i = 2; i <= prices.length; i++){
+            s0[i] = Math.max(s0[i - 1], s2[i - 1]);
+            s1[i] = Math.max(s1[i - 1], s0[i - 1] - prices[i - 1]);
+            s2[i] = s1[i - 1] + prices[i - 1];
+        }
+        return Math.max(s0[len], s2[len]);
+    }
+}
+```
+
+### Reference
+1. [【LeetCode】309. Best Time to Buy and Sell Stock with Cooldown](https://www.cnblogs.com/jdneo/p/5228004.html)