[Function add]

1. Add leetcode solutions with tag permutation.

Author: Seanforfun

README.md

@@ -531,6 +531,12 @@
 * [216. Combination Sum III](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/216.%20Combination%20Sum%20III.md)
 * Conclusion: We can speed up the recursion using an index and if we want all elements used once, we need to sort first and in the for loop, we need to remove duplicate values.
 
+#### Permutation
+* [46. Permutations](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/46.%20Permutations.md)
+* [47. Permutations II](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/47.%20Permutations%20II.md)
+* [784. Letter Case Permutation](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/784.%20Letter%20Case%20Permutation.md)
+* [943. Find the Shortest Superstring](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/943.%20Find%20the%20Shortest%20Superstring.md)
+* [996. Number of Squareful Arrays](https://github.com/Seanforfun/Algorithm-and-Leetcode/blob/master/leetcode/996.%20Number%20of%20Squareful%20Arrays.md)
 
 ## Algorithm(4th_Edition)
 Reading notes of book Algorithm(4th Algorithm),ISBN: 9787115293800.

leetcode/943. Find the Shortest Superstring.md

@@ -0,0 +1,93 @@
+## 943. Find the Shortest Superstring
+
+### Question:
+Given an array A of strings, find any smallest string that contains each string in A as a substring.
+We may assume that no string in A is substring of another string in A.
+
+```
+Example 1:
+
+Input: ["alex","loves","leetcode"]
+Output: "alexlovesleetcode"
+Explanation: All permutations of "alex","loves","leetcode" would also be accepted.
+
+Example 2:
+
+Input: ["catg","ctaagt","gcta","ttca","atgcatc"]
+Output: "gctaagttcatgcatc"
+```
+
+Note:
+* 1 <= A.length <= 12
+* 1 <= A[i].length <= 20
+
+
+### Solution:
+* Method 1: search O(N! + N^2) AC 775ms
+    * First create a cost[i][j] matrix, means the number of characters need to be added at the end of the result if last added word is A[i] and we want to add A[j]. Cost matrix is calculated at the very beginning so it will be calculated once, and its time efficiency is O(n^2).
+    * We list all possible permutations and save the minimum. Pruning is required for remove useless iterations.
+    * We only record the path of words it goes through and concat the string at the end(we only concat once).
+    ```Java
+    class Solution {
+        public String shortestSuperstring(String[] A) {
+            if(A.length == 1) return A[0];
+            int[][] cost = new int[A.length][A.length];
+            for(int i = 0; i < A.length; i++){
+                LABEL:
+                for(int j = 0; j < A.length; j++){
+                    if(i == j){
+                        cost[i][j] = A[j].length();
+                    }else{
+                        int start = A[i].indexOf(A[j].charAt(0));
+                        if(start == -1) cost[i][j] = A[j].length();
+                        else{
+                            for(int k = start; k < A[i].length(); k++){
+                                if(A[j].startsWith(A[i].substring(k))){
+                                    cost[i][j] = A[j].length() - (A[i].length() - k);
+                                    continue LABEL;
+                                }
+                            }
+                            cost[i][j] = A[j].length();
+                        }
+                    }
+                }
+            }
+            List<Integer> res = new ArrayList<>();
+            dfs(A, cost, 0, 0, new ArrayList<Integer>(), res, 0);
+            StringBuilder sb = new StringBuilder();
+            for(int i = 0; i < res.size(); i++){
+                Integer path = res.get(i);
+                sb.append(i == 0 ? A[path]: A[path].substring(A[path].length() - cost[res.get(i - 1)][path]));
+            }
+            return sb.toString();
+        }
+        private int sum = Integer.MAX_VALUE;
+        private void dfs(String[] A, int[][] cost, int index, int temp, List<Integer> path, List<Integer> res, int visited){
+            if(temp >= sum) return;
+            if(A.length == index){
+                sum = temp;
+                res.clear();
+                res.addAll(path);
+                return;
+            }
+            for(int i = 0; i < A.length; i++){
+                if((visited & (1 << i)) > 0) continue;
+                path.add(i);
+                dfs(A, 
+                    cost, 
+                    index + 1, 
+                    index == 0 ? A[i].length(): temp + cost[path.get(index - 1)][i], 
+                    path, 
+                    res, 
+                    (visited | (1 << i)));
+                path.remove(index);
+            }
+        }
+    }
+    ```
+
+* Method 2: DP Need to fill when doing the dp questions.
+
+### Reference
+1. [花花酱 LeetCode 943. Find the Shortest Superstring - 刷题找工作 EP231](https://www.youtube.com/watch?v=u_Wc4jwrp3Q)
+

leetcode/996. Number of Squareful Arrays.md

@@ -0,0 +1,68 @@
+## 996. Number of Squareful Arrays
+
+### Question:
+Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
+
+Return the number of permutations of A that are squareful.  Two permutations A1 and A2 differ if and only if there is some index i such that A1[i] != A2[i].
+
+```
+Example 1:
+
+Input: [1,17,8]
+Output: 2
+Explanation: 
+[1,8,17] and [17,8,1] are the valid permutations.
+
+Example 2:
+
+Input: [2,2,2]
+Output: 1
+```
+ 
+Note:
+* 1 <= A.length <= 12
+* 0 <= A[i] <= 1e9
+
+
+
+### Solution:
+* Method 1: search O(N!) AC 3ms
+    * Pruning is super important, I cannot AC without pruning.
+    * need to check if the last two variables are squareful.
+    ```Java
+    class Solution {
+        private int res = 0;
+        public int numSquarefulPerms(int[] A) {
+            if(A.length == 1) return 0;
+            Arrays.sort(A);
+            dfs(A, new ArrayList<Integer>(), 0);
+            return res;
+        }
+        private void dfs(int[] A, List<Integer> temp, int visited){
+            if(temp.size() == A.length){
+                boolean flag = true;
+                for(int i = 1; i < A.length; i++){               
+                    flag &= square(temp.get(i - 1) + temp.get(i));
+                }
+                if(flag) res++;
+            }else if(temp.size() <= 1 || square(temp.get(temp.size() - 1) + temp.get(temp.size() - 2))){
+                for(int i = 0; i < A.length; i++){
+                    if((visited & (1 << i)) > 0) continue;
+                    if(i > 0 && A[i] == A[i - 1] && (visited & (1 << (i - 1))) == 0) continue;
+                    temp.add(A[i]);
+                    dfs(A, temp, visited | (1 << i));
+                    temp.remove(temp.size() - 1);
+                }
+            }
+        }
+        private boolean square(int sum){
+            return (int)Math.sqrt(sum) * (int)Math.sqrt(sum) == sum;
+        }
+    }
+    ```
+
+* Method 2: DP Need to fill when doing the dp questions.
+
+### Reference
+1. [花花酱 LeetCode 996. Number of Squareful Arrays](https://zxi.mytechroad.com/blog/searching/leetcode-996-number-of-squareful-arrays/)
+