[zclhit] add another way to print binary Tree in graphical

src/main/java/algorithm_practice/LeetCode/code000/E001_两数之和.java

@@ -4,6 +4,7 @@
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
 
 /*
 

src/main/java/algorithm_practice/LeetCode/code000/E002_两数相加.java

@@ -0,0 +1,30 @@
+package algorithm_practice.LeetCode.code000;
+
+import common.datastruct.ListNode;
+
+public class E002_两数相加 {
+  /*
+  给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
+
+如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
+
+您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+
+示例：
+
+输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
+输出：7 -> 0 -> 8
+原因：342 + 465 = 807
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/add-two-numbers
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+   */
+  public static void main(String[] args) {
+
+  }
+
+  public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+    return l1;
+  }
+}

src/main/java/algorithm_practice/LeetCode/code000/H032_最长有效括号.java

@@ -0,0 +1,59 @@
+package algorithm_practice.LeetCode.code000;
+
+import java.util.Stack;
+
+public class H032_最长有效括号 {
+
+  /*
+给定一个只包含 '(' 和 ')' 的字符串，找出最长的包含有效括号的子串的长度。
+
+示例 1:
+
+输入: "(()"
+输出: 2
+解释: 最长有效括号子串为 "()"
+示例 2:
+
+输入: ")()())"
+输出: 4
+解释: 最长有效括号子串为 "()()"
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/longest-valid-parentheses
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+   */
+  public static void main(String[] args) {
+    H032_最长有效括号 obj = new H032_最长有效括号();
+    assert 2 == obj.longestValidParentheses("(()");
+    assert 4 == obj.longestValidParentheses(")()())");
+    assert 6 == obj.longestValidParentheses("(()())");
+  }
+
+  /*
+  思路：遇到(，当前坐标入栈。
+       遇到)，pop栈内的元素，如果pop之后栈为空，就把当前坐标入栈。如果pop之后不为空，就在max和（当前坐标 - 栈顶元素）之间取最大值。
+       为了计算的正确性，一开始把-1 push到栈中。
+       时间复杂度O(n)，空间复杂度O(n)
+       这样栈最底下的元素一定是上一次没能进行左匹配的右括号的坐标
+   */
+  public int longestValidParentheses(String s) {
+    char[] c = s.toCharArray();
+
+    Stack<Integer> stack = new Stack<>();
+    stack.push(-1);
+    int maxans = 0;
+    for (int i = 0; i < c.length; i++) {
+      if (c[i] == '(') {
+        stack.push(i);
+      } else {
+        stack.pop();
+        if (stack.isEmpty()) {
+          stack.push(i);
+        } else {
+          maxans = Math.max(maxans, i - stack.peek());
+        }
+      }
+    }
+    return maxans;
+  }
+}

src/main/java/algorithm_practice/LeetCode/code000/H044_通配符匹配.java

@@ -0,0 +1,103 @@
+package algorithm_practice.LeetCode.code000;
+
+public class H044_通配符匹配 {
+  /*
+给定一个字符串 (s) 和一个字符模式 (p) ，实现一个支持 '?' 和 '*' 的通配符匹配。
+
+'?' 可以匹配任何单个字符。
+'*' 可以匹配任意字符串（包括空字符串）。
+两个字符串完全匹配才算匹配成功。
+
+说明:
+
+s 可能为空，且只包含从 a-z 的小写字母。
+p 可能为空，且只包含从 a-z 的小写字母，以及字符 ? 和 *。
+示例 1:
+
+输入:
+s = "aa"
+p = "a"
+输出: false
+解释: "a" 无法匹配 "aa" 整个字符串。
+示例 2:
+
+输入:
+s = "aa"
+p = "*"
+输出: true
+解释: '*' 可以匹配任意字符串。
+示例 3:
+
+输入:
+s = "cb"
+p = "?a"
+输出: false
+解释: '?' 可以匹配 'c', 但第二个 'a' 无法匹配 'b'。
+示例 4:
+
+输入:
+s = "adceb"
+p = "*a*b"
+输出: true
+解释: 第一个 '*' 可以匹配空字符串, 第二个 '*' 可以匹配字符串 "dce".
+示例 5:
+
+输入:
+s = "acdcb"
+p = "a*c?b"
+输出: false
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/wildcard-matching
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+   */
+
+  public static void main(String[] args) {
+    H044_通配符匹配 obj = new H044_通配符匹配();
+    assert obj.isMatch("aa", "*");
+    assert !obj.isMatch("aa", "a");
+    assert !obj.isMatch("cb", "*a");
+    assert obj.isMatch("adceb", "*a*b");
+    assert !obj.isMatch("acdcb", "a*c?b");
+  }
+
+  /*
+  1.动态规划
+状态转移方程：
+模式p[j] ！= '*'且 p[j] != '?'时， dp[i][j] = (p[j] == s[i]) && dp[i-1][j-1]
+模式p[j] == '?'时，dp[i][j] =dp[i-1][j-1]
+模式p[j] == '*'时，*可以匹配0个词，也可以匹配1个词并且*还存在，这样下次计算*还存在的时候，*还可以匹配0或1个词，以此类推*可以匹配0或无限多个字。
+所以这时候dp[i][j] = dp[i-1][j] (这时候匹配了一个词) || dp[i][j-1](这时候匹配了0个词)
+边界条件：
+为了满足某一方为空的场景，所以dp数组的大小是s.length+1行，p.length+1列。
+其中dp[0][0]是两个空串匹配场景，所以dp[0][0] = true；
+而空的p模式无法与任何非空字符串匹配，所以dp[any][0] = false;
+*可以匹配0个字母，所以dp[0][从头到尾最后一个连续的*的位置] = true，其余为false。
+   */
+  public boolean isMatch(String s, String p) {
+    int sl = s.length();
+    int pl = p.length();
+    boolean[][] dp = new boolean[sl + 1][pl + 1];
+
+    // 初始化dp数组边界条件
+    dp[0][0] = true;
+    for (int i = 1; i <= pl; i++) {
+      if (p.charAt(i - 1) == '*') {
+        dp[0][i] = true;
+      } else {
+        break;
+      }
+    }
+
+    for (int i = 1; i <= sl; i++) {
+      for (int j = 1; j <= pl; j++) {
+        if (p.charAt(j - 1) == '*') {
+          dp[i][j] = dp[i - 1][j] || dp[i][j - 1];
+        } else if (s.charAt(i - 1) == p.charAt(j - 1) || p.charAt(j - 1) == '?') {
+          dp[i][j] = dp[i - 1][j - 1];
+        }
+      }
+    }
+    return dp[sl][pl];
+  }
+}

src/main/java/algorithm_practice/LeetCode/code000/H097_交错字符串.java

@@ -0,0 +1,65 @@
+package algorithm_practice.LeetCode.code000;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+public class H097_交错字符串 {
+  /*
+  给定三个字符串 s1, s2, s3, 验证 s3 是否是由 s1 和 s2 交错组成的。
+
+示例 1:
+
+输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
+输出: true
+示例 2:
+
+输入: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
+输出: false
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/interleaving-string
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+   */
+
+  public static void main(String[] args) {
+    H097_交错字符串 obj = new H097_交错字符串();
+    System.out.println(obj.isInterleave("aabcc", "dbbca", "aadbbcbcac"));
+    System.out.println(obj.isInterleave("aabcc", "dbbca", "aadbbbaccc"));
+  }
+
+  public boolean isInterleave(String s1, String s2, String s3) {
+    int m = s1.length();
+    int n = s2.length();
+    int p = s3.length();
+
+    if (n + m != p) {
+      // directly fail
+      return false;
+    }
+
+    // init dp array
+    boolean[][] dp = new boolean[m + 1][n + 1];
+    dp[0][0] = true;
+
+    for (int i = 0; i <= m; i++) {
+      for (int j = 0; j <= n; j++) {
+        int l = i + j - 1;
+        if (i > 0) {
+          dp[i][j] = dp[i][j] || (dp[i - 1][j] && s1.charAt(i - 1) == s3.charAt(l));
+        }
+        if (j > 0) {
+          dp[i][j] = dp[i][j] || (dp[i][j - 1] && s2.charAt(j - 1) == s3.charAt(l));
+        }
+      }
+    }
+    return dp[m][n];
+  }
+
+}

src/main/java/algorithm_practice/LeetCode/code000/M015_三数之和.java

@@ -1,7 +1,6 @@
 package algorithm_practice.LeetCode.code000;
 
 import com.alibaba.fastjson.JSON;
-import com.sun.tools.doclint.Entity;
 import junit.framework.TestCase;
 import org.junit.Test;
 

src/main/java/algorithm_practice/LeetCode/code000/M056_合并区间.java

@@ -3,7 +3,6 @@
 import common.util.SysOut;
 import junit.framework.TestCase;
 import org.junit.Test;
-import sun.jvm.hotspot.utilities.BitMap;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -47,8 +46,8 @@ public void testCase() {
 
         int[][] intervals5 = new int[][]{{1, 4}, {2, 3}};
         SysOut.printArray(merge(intervals5));
-        
-        int[][] intervals6 = new int[][]{{2,3},{2,2},{3,3},{1,3},{5,7},{2,2},{4,6}};
+
+        int[][] intervals6 = new int[][]{{2, 3}, {2, 2}, {3, 3}, {1, 3}, {5, 7}, {2, 2}, {4, 6}};
         SysOut.printArray(merge(intervals6));
 
     }
@@ -81,7 +80,7 @@ public int compare(int[] o1, int[] o2) {
                 continue;
             }
 
-            int[] resultInterval = result.get(result.size()-1);
+            int[] resultInterval = result.get(result.size() - 1);
 
             if (interval[1] < resultInterval[1]) {
                 continue;
@@ -90,7 +89,7 @@ public int compare(int[] o1, int[] o2) {
             if (interval[0] <= resultInterval[1]) {
                 resultInterval[1] = interval[1];
 
-                result.remove(result.size()-1);
+                result.remove(result.size() - 1);
                 result.add(resultInterval);
             } else {
                 result.add(interval);
@@ -99,39 +98,4 @@ public int compare(int[] o1, int[] o2) {
 
         return result.toArray(new int[0][]);
     }
-
-    /**
-     * 使用BitMap
-     */
-    public int[][] merge2(int[][] intervals) {
-        BitMap bitMap = new BitMap(100);
-
-        for (int i = 0; i < intervals.length; i++) {
-            int[] interval = intervals[i];
-            for (int j = interval[0]; j < interval[1]; j++) {
-                if (j > bitMap.size()) {
-                    bitMap.set_size(j);
-                }
-
-                bitMap.atPut(j, true);
-            }
-        }
-
-        int[][] result = new int[1][2];
-        int count = 0;
-        for (int i = 0; i < bitMap.size(); i++) {
-            if (bitMap.at(i)) {
-                result[count][0] = i;
-                while (bitMap.at(i)) {
-                    i++;
-                }
-
-                result[count][1] = i;
-
-                count++;
-            }
-        }
-
-        return result;
-    }
 }