add all

Author: feiyutalk

problems/521. Longest Uncommon Subsequence I/README.md

@@ -0,0 +1,45 @@
+# 521. Longest Uncommon Subsequence I
+
+## #1 暴力搜索[TLE]
+
+### 思路
+
+用深度搜索的方式遍历所有的可能的子序列，然后在这些搜索的子序列里面找出只出现过一次的最大子序列。为了统计哪些子序列只出现1次，我们可以使用`HashMap`来记录每个字序列出现的次数。
+
+### 算法
+
+```java
+class Solution {
+    Map<String, Integer> res = new HashMap<>();
+    public int findLUSlength(String a, String b) {
+        if(a == null || a.length() == 0) return b==null||b.length()==0?-1:b.length();
+        if(b == null || b.length() == 0) return a==null||a.length()==0?-1:a.length();
+        dfs(a.toCharArray(), 0, new StringBuilder());
+        dfs(b.toCharArray(), 0, new StringBuilder());
+        int max = -1;
+        for(Map.Entry<String, Integer> entry : res.entrySet()){
+            if(entry.getValue() == 1)
+                max = Math.max(max, entry.getKey().length());
+        }
+        return max;
+    }
+    
+    public void dfs(char[] chars, int step, StringBuilder sb){
+        if(step == chars.length){
+            res.put(sb.toString(), res.getOrDefault(sb.toString(), 0) + 1);
+            return;
+        }
+        //要该字符
+        sb.append(chars[step]);
+        dfs(chars, step+1, sb);
+        //不要该字符
+        sb.setLength(sb.length()-1);
+        dfs(chars, step+1, sb);
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度：$O(2^n)$
+

problems/555. Split Concatenated Strings/README.md

@@ -0,0 +1,112 @@
+# 555. Split Concatenated Strings
+
+## #1 深度优先搜索[TLE]
+
+### 思路
+
+通过深度优先遍历所有可能的组合，然后对每种可能的组合，遍历所有可能的切分点。
+
+### 算法
+
+```java
+class Solution {
+    String res = "";
+    public String splitLoopedString(String[] strs) {
+        dfs(strs, "", 0, strs.length);
+        return res;
+    }
+    
+    public void dfs(String[] strs, String s, int i, int n){
+        if(i < n){
+            dfs(strs, s + strs[i], i+1, n);
+            dfs(strs, s + new StringBuffer(strs[i]).reverse().toString(), i+1, n);
+        }else{
+            for(int j=0; j<s.length(); j++){
+                String cut = s.substring(j) + s.substring(0, j);
+                if(cut.compareTo(res) > 0)
+                    res = cut;
+            }
+        }
+    }
+}
+```
+
+### 复杂度分析
+
+## #2 广度优先遍历[MLE]
+
+### 思路
+
+想法和上面是一样的，就是在枚举的时候采用广度优先的做法。
+
+### 算法
+
+```java
+class Solution {
+    public String splitLoopedString(String[] strs) {
+        String res = "";
+        Queue<String> queue = new LinkedList<>();
+        queue.offer("");
+        int i=0, j=0;
+        while(i < strs.length){
+            String cur = queue.poll();
+            queue.offer(cur+strs[i]);
+            queue.offer(cur + new StringBuffer(strs[i]).reverse().toString());
+            j++;
+            if(j == 1<<i){
+                i++;
+                j=0;
+            }
+        }
+        while(!queue.isEmpty()){
+            String cur = queue.poll();
+            for(int k=0; k<cur.length(); k++){
+                String cut = cur.substring(k) + cur.substring(0, k);
+                if(cut.compareTo(res) > 0)
+                    res = cut;
+            }
+        }
+        return res;
+    }
+}
+```
+
+### 复杂度分析
+
+## #3 优化枚举
+
+### 思路
+
+### 算法
+
+```java
+class Solution {
+    public String splitLoopedString(String[] strs) {
+        for(int i=0; i<strs.length; i++){
+            String rev = new StringBuffer(strs[i]).reverse().toString();
+            if(rev.compareTo(strs[i]) > 0)
+                strs[i] = rev;
+        }
+        String res = "";
+        for(int i=0; i<strs.length; i++){
+            String rev = new StringBuffer(strs[i]).reverse().toString();
+            for(String s : new String[]{strs[i], rev}){
+                for(int k=0; k<s.length(); k++){
+                    StringBuffer temp = new StringBuffer();
+                    temp.append(s.substring(k));
+                    for(int j=i+1; j<strs.length; j++)
+                        temp.append(strs[j]);
+                    for(int j=0; j<i; j++){
+                        temp.append(strs[j]);
+                    }
+                    temp.append(s.substring(0, k));
+                    if(temp.toString().compareTo(res) > 0)
+                        res = temp.toString();
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+

problems/556. Next Greater Element III/README.md

@@ -0,0 +1,52 @@
+# 556. Next Greater Element III
+
+## #1 深度优先遍历[AC]
+
+### 思路
+
+遍历所有可能的情况，然后排序，最后选出第一个大于N的结果。
+
+### 算法
+
+```java
+class Solution {
+    List<Long> total = new ArrayList<>(); 
+    public int nextGreaterElement(int n) {
+        String ns = String.valueOf(n);
+        int[] nums = new int[10];
+        for(int i=0; i<ns.length(); i++){
+            nums[ns.charAt(i) - '0']++;
+        }
+        dfs(nums, 0, ns.length(), new StringBuffer());
+        Collections.sort(total);
+        // System.out.print(total);
+        for(long val : total){
+            if(val > n && val < Integer.MAX_VALUE)
+                return (int)val;
+        }
+        return -1;
+    }
+    
+    public void dfs(int[] nums, int step, int length, StringBuffer sb){
+        if(step == length){
+            total.add(Long.parseLong(sb.toString()));
+            return;
+        }else{
+            for(int i=0; i<nums.length; i++){
+                if(nums[i] <= 0)
+                    continue;
+                sb.append(""+i);
+                nums[i]--;
+                dfs(nums, step+1, length, sb);
+                sb.setLength(sb.length() - 1);
+                nums[i]++;
+            }
+        }
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度
+- 空间复杂度

problems/557. Reverse Words in a String III/README.md

@@ -0,0 +1,46 @@
+# 557. Reverse Words in a String III
+
+## #1 识别单词[AC]
+
+### 思路
+
+将字符串转为字符数组，然后线性扫描字符数组，通过判断当前是否为空格，来识别字符数组中的单词，一旦识别到单词，就用`i,j`指向单词的起始点和终止点，然后逆序这个单词。
+
+### 算法
+
+```java
+class Solution {
+    public String reverseWords(String s) {
+        /*
+        用i,j保存每个单词的起始和终止位置
+        用k表示已经遍历到的位置
+        */
+        if(s == null || s.length() == 0) return s;
+        char[] chars = s.toCharArray();
+        int i=0, j=0;
+        for(int k=0; k<s.length(); k++){
+            // System.out.print("k="+k);
+           if(chars[k] == ' ')
+               continue;
+            i = k;
+            j = k;
+            while(j < s.length() && chars[j] != ' ')
+                j++;
+            j--;
+            k = j;
+            for(;i<j; i++, j--){
+                char temp = chars[i];
+                chars[i] = chars[j];
+                chars[j] = temp;
+            }
+            // System.out.println(",String="+new String(chars));
+        }
+        return new String(chars);
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度
+- 空间复杂度

problems/583. Delete Operation for Two Strings/README.md

@@ -0,0 +1,41 @@
+#583. Delete Operation for Two Strings
+
+## #1 最大子序列[AC]
+
+### 思路
+
+该问题可以转化为求解两个字符串的最长子序列，如果我们找到了最长子序列，那么其他的字符就是我们要删掉的。
+
+### 算法
+
+```java
+class Solution {
+    /*
+    两个字符串要完全相同，我们要找到两个字符串的最长公共子序列！
+    我们可以通过动态规划的方法来求解！
+    */
+    public int minDistance(String word1, String word2) {
+        if(word1 == null || word1.length() == 0)
+            return word2 == null ? 0 : word2.length();
+        if(word2 == null || word2.length() == 0)
+            return word1 == null ? 0 : word1.length();
+        int m = word1.length();
+        int n = word2.length();
+        int[][] dp = new int[m+1][n+1];
+        for(int i=1; i<=m; i++){
+            for(int j=1; j<=n; j++){
+                int path1 = word1.charAt(i-1) == word2.charAt(j-1) ? dp[i-1][j-1] + 1 : 0;
+                int path2 = dp[i-1][j];
+                int path3 = dp[i][j-1];
+                dp[i][j] = Math.max(path1, Math.max(path2, path3));
+            }
+        }
+        return m + n - 2 * dp[m][n];
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度
+- 空间复杂度

problems/606. Construct String from Binary Tree/README.md

@@ -0,0 +1,66 @@
+# 606. Construct String from Binary Tree
+
+## #1 控制递归条件
+
+### 思路
+
+对于当前节点的不同状态，执行不同的递归条件，从而可用控制加括号的方式。
+
+### 算法
+
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public String tree2str(TreeNode t) {
+        StringBuffer sb = new StringBuffer();
+        preorder(t, sb);
+        return sb.toString();
+    }
+    
+    public void preorder(TreeNode t, StringBuffer sb){
+        if(t == null)
+            return;
+        if(t.left!= null && t.right != null){
+            sb.append("" + t.val);
+            // 左子树
+            sb.append("(");
+            preorder(t.left, sb);
+            sb.append(")");
+
+            // 右子树
+            sb.append("(");
+            preorder(t.right, sb);
+            sb.append(")");
+        }else if(t.left == null && t.right != null){
+            sb.append("" + t.val);
+            sb.append("(");
+            sb.append(")");
+            sb.append("(");
+            preorder(t.right, sb);
+            sb.append(")");
+        }else if(t.right == null && t.left != null){
+            sb.append("" + t.val);
+            // 左子树
+            sb.append("(");
+            preorder(t.left, sb);
+            sb.append(")");
+        }else{
+            sb.append("" + t.val);
+        }
+    }
+}
+```
+
+### 复杂度分析
+
+- 时间复杂度
+- 空间复杂度
+