[Function add]

1. Add leetcode solutions.

Author: Seanforfun

README.md

@@ -489,6 +489,12 @@
 
 [310. Minimum Height Trees](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/310.%20Minimum%20Height%20Trees.md)
 
+[312. Burst Balloons](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/312.%20Burst%20Balloons.md)
+
+[313. Super Ugly Number](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/313.%20Super%20Ugly%20Number.md)
+
+[315. Count of Smaller Numbers After Self](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/315.%20Count%20of%20Smaller%20Numbers%20After%20Self.md)
+
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/312. Burst Balloons.md

@@ -0,0 +1,100 @@
+## 312. Burst Balloons
+
+### Question
+Given n balloons, indexed from 0 to n-1. Each balloon is painted with a number on it represented by array nums. You are asked to burst all the balloons. If the you burst balloon i you will get nums[left] * nums[i] * nums[right] coins. Here left and right are adjacent indices of i. After the burst, the left and right then becomes adjacent.
+
+Find the maximum coins you can collect by bursting the balloons wisely.
+
+Note:
+* You may imagine nums[-1] = nums[n] = 1. They are not real therefore you can not burst them.
+* 0 ≤ n ≤ 500, 0 ≤ nums[i] ≤ 100
+
+```
+Example:
+
+Input: [3,1,5,8]
+Output: 167 
+Explanation: nums = [3,1,5,8] --> [3,5,8] -->   [3,8]   -->  [8]  --> []
+             coins =  3*1*5      +  3*5*8    +  1*3*8      + 1*8*1   = 167
+```
+
+### Thinking:
+* Method 1:backtrace TLE
+```Java
+class Solution {
+    private int max = 0;
+    public int maxCoins(int[] nums) {
+        int result = 0;
+        if(nums == null || nums.length == 0) return 0;
+        backtrace(nums, new boolean[nums.length], 0, 0);
+        return this.max;
+    }
+    private void backtrace(int[] nums, boolean[] visited, int count, int sum){
+        if(count == nums.length){
+            this.max = Math.max(sum, max);
+            return;
+        }
+        for(int i = 0; i < nums.length; i++){
+            int temp = 0;
+            if(visited[i]) continue;
+            visited[i] = true;
+            int left = 1;
+            for(int j = i - 1; j >= 0; j--){
+                if(!visited[j]){
+                    left = nums[j]; break;
+                }
+            }
+            int right = 1;
+            for(int j = i + 1; j < nums.length; j++){
+                if(!visited[j]){
+                    right = nums[j]; break;
+                }
+            }
+            backtrace(nums, visited, count + 1, sum + left * nums[i] * right);
+            visited[i] = false;
+        }
+    }
+}
+```
+
+* Method 2: DP, this question is a little bit difficult and worth having more conclusion.
+    1. We create a new array with nums[len + 2], first and last index are filled with 1.
+    2. we create a dp[i][j], i means the starting position and j means end position, both included. The final result is dp[1][len].
+    3. we define the last burst balloon index as mid, we have dp[i][j] = max(dp[i][j], dp[i][mid - 1] + arr[i - 1] * arr[mid] * arr[j + 1] + dp[mid + 1][j]).
+        * dp[i][mid - 1]: the sub result of left side of last burst ballon(mid)
+        * arr[i - 1] * arr[mid] * arr[j + 1]: last one * remained left * remained right.
+        * dp[mid + 1][j]: the sub result of right side of last burst ballon(mid)
+    3. How to traversal the array:
+        * dist: the distance from left index.
+        * left: the left position.[1, len - dist + 1]
+        * right: [left, left + dist - 1]
+        * mid: last burst ballon. [left, right]
+```Java
+class Solution {
+    public int maxCoins(int[] nums) {
+        if(nums == null || nums.length == 0) return 0;
+        int len = nums.length;
+        int[][] dp = new int[len + 2][len + 2];
+        int[] arr = new int[len + 2];
+        for(int i = 1; i < len + 1; i++){
+            arr[i] = nums[i - 1];
+            dp[i][i] = arr[i];
+        }
+        arr[0] = arr[len + 1] = 1;
+        for(int dist = 1; dist <= len; dist++){
+            for(int left = 1; left <= len - dist + 1; left++){
+                int right = left + dist - 1;
+                for(int mid = left; mid <= right; mid ++){
+                    dp[left][right] = Math.max(dp[left][right], dp[left][mid - 1] + arr[left - 1] * arr[mid] * arr[right + 1] + dp[mid + 1 ][right]);
+                }
+            }
+        }
+        return dp[1][len];
+    }
+}
+```
+
+### Reference
+1. [312. Burst Balloons](https://blog.csdn.net/zjucor/article/details/56481930)
+
+

leetcode/313. Super Ugly Number.md

@@ -42,4 +42,30 @@ class Solution {
         return min;
     }
 }
+```
+
+### Second time
+1. This question is very similar to ugly number, only difference is that the prime array is dynamic, so we need to add several for-loops for finding the minimum facter and updating the index and factors.
+```Java
+class Solution {
+    public int nthSuperUglyNumber(int n, int[] primes) {
+        int[] dp = new int[n];
+        dp[0] = 1;
+        int[] index = new int[primes.length];
+        int[] factor = Arrays.copyOf(primes, primes.length);
+        for(int i = 1; i < n; i++){
+            int min = Integer.MAX_VALUE;
+            for(int j = 0; j < primes.length; j++){
+                min = Math.min(min, factor[j]);
+            }
+            dp[i] = min;
+            for(int j = 0; j < index.length; j++){
+                if(factor[j] == min){
+                    factor[j] = dp[++index[j]] * primes[j];
+                }
+            }
+        }
+        return dp[n - 1];
+    }
+}
 ```

leetcode/315. Count of Smaller Numbers After Self.md

@@ -0,0 +1,57 @@
+## 315. Count of Smaller Numbers After Self
+
+### Question
+You are given an integer array nums and you have to return a new counts array. The counts array has the property where counts[i] is the number of smaller elements to the right of nums[i].
+
+```
+Example:
+
+Input: [5,2,6,1]
+Output: [2,1,1,0] 
+Explanation:
+To the right of 5 there are 2 smaller elements (2 and 1).
+To the right of 2 there is only 1 smaller element (1).
+To the right of 6 there is 1 smaller element (1).
+To the right of 1 there is 0 smaller element.
+```
+
+### Thinking:
+* Method 1: Slow, beats 18.69%
+	* find the right closed index whose value is same as current one.
+	* only need to calculate the value between these two and add the result of that index.
+    ```Java
+    class Solution {
+        public List<Integer> countSmaller(int[] nums) {
+            Map<Integer, Integer> map = new HashMap<>();
+            int[] arr = new int[nums.length];
+            for(int i = nums.length - 1; i>= 0; i--){
+                if(map.containsKey(nums[i])){
+                    arr[i] = map.get(nums[i]);
+                }
+                else{
+                    arr[i] = -1;
+                }
+                map.put(nums[i], i);
+            }
+            int[] result = new int[nums.length];
+            for(int i = nums.length - 1; i >= 0; i--){
+                int count = 0;
+                if(arr[i] == -1){
+                    for(int j = i; j < nums.length; j++){
+                        if(nums[i] > nums[j]) count++;
+                    }
+                    result[i] = count;
+                }else{
+                    for(int j = i; j < arr[i]; j++){
+                        if(nums[i] > nums[j]) count++;
+                    }
+                    result[i] = count + result[arr[i]];
+                }
+            }
+            List<Integer> res = new LinkedList<>();
+            for(int n : result) res.add(n);
+            return res;
+        }
+    }
+    ```
+