add solution 301(d),507(s),508(m),513(m)

solution/0300-0399/0301.Remove Invalid Parentheses/Solution.java

@@ -0,0 +1,79 @@
+class Solution {
+    public List<String> removeInvalidParentheses(String s) {
+        // 最终结果去重
+        HashSet<String> set = new HashSet<>();
+        // 先遍历一遍，比对，找出需要删除的"（"和"）"的个数
+        // 当前处理字符的位置
+        int index = 0;
+        // 需要删除"（"的个数
+        int leftToDelete = 0;
+        // 需要删除"）"的个数
+        int rightToDelete = 0;
+        // 剩余几个"（"没有匹配到"）"
+        int leftCount = 0;
+        char[] chars = s.toCharArray();
+        for (char c : chars) {
+            switch (c) {
+                case '(':
+                    leftToDelete++;
+                    break;
+                case ')':
+                    if (leftToDelete > 0) {
+                        // 抵消
+                        leftToDelete--;
+                    } else {
+                        rightToDelete++;
+                    }
+                    break;
+                default:
+            }
+        }
+        dfs(s, index, leftCount, leftToDelete, rightToDelete, set, new StringBuilder());
+        ArrayList<String> list = new ArrayList<>();
+        list.addAll(set);
+        return list;
+    }
+
+
+    private void dfs(String s, int index, int leftCount, int leftToDelete, int rightToDelete, HashSet<String> set, StringBuilder sb) {
+        if (index == s.length()) {
+            if (leftToDelete == 0 && rightToDelete == 0 && leftCount == 0) {
+                set.add(sb.toString());
+            }
+            return;
+        }
+        char c = s.charAt(index);
+        if (c == '(') {
+            // 如果是'(',那么要么删除,要么保留.
+            // 如果删除
+            if (leftToDelete > 0) {
+                StringBuilder tmp = new StringBuilder(sb);
+                dfs(s, index + 1, leftCount, leftToDelete - 1, rightToDelete, set, tmp);
+            }
+            // 不删,或者没有可以删除的
+            StringBuilder tmp = new StringBuilder(sb);
+            tmp.append(c);
+            dfs(s, index + 1, leftCount + 1, leftToDelete, rightToDelete, set, tmp);
+        } else if (c == ')') {
+            // 删除
+            if (rightToDelete > 0) {
+                StringBuilder tmp = new StringBuilder(sb);
+                dfs(s, index + 1, leftCount, leftToDelete, rightToDelete - 1, set, tmp);
+            }
+            // 在前面有'('的时候保留.
+            if (leftCount > 0) {
+                StringBuilder tmp = new StringBuilder(sb);
+                tmp.append(c);
+                dfs(s, index + 1, leftCount - 1, leftToDelete, rightToDelete, set, tmp);
+            } else {
+                // "）"这个没有"（"和他对应，结束
+                return;
+            }
+        } else {
+            // 其他字符
+            StringBuilder tmp = new StringBuilder(sb);
+            tmp.append(c);
+            dfs(s, index + 1, leftCount, leftToDelete, rightToDelete, set, tmp);
+        }
+    }
+}

solution/0500-0599/0507.Perfect Number/Solution.java

@@ -0,0 +1,14 @@
+public class Solution {
+    public boolean checkPerfectNumber(int num) {
+        if (num == 0 || num == 1) {
+            return false;
+        }
+        int sum = 1;
+        for (int i = 2; i <= Math.sqrt(num); i++) {
+            if (num % i == 0) {
+                sum = sum + i + num / i;
+            }
+        }
+        return num == sum;
+    }
+}

solution/0500-0599/0508.Most Frequent Subtree Sum/Solution.java

@@ -0,0 +1,41 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+public class Solution {
+    // 后续遍历，遍历的同时，找最大值和计算次数
+    Map<Integer, Integer> map = new HashMap<>();
+    int max = Integer.MIN_VALUE;
+
+    public int[] findFrequentTreeSum(TreeNode root) {
+        if (root == null) {
+            return new int[0];
+        }
+        dfs(root);
+        List<Integer> list = map.entrySet().stream()
+                .filter(m -> m.getValue() == max).map(i -> i.getKey()).collect(Collectors.toList());
+        int[] res = new int[list.size()];
+        for (int i = 0; i < list.size(); i++) {
+            res[i] = list.get(i);
+        }
+        return res;
+    }
+
+    private int dfs(TreeNode root) {
+        if (root == null) {
+            return 0;
+        }
+        int left = dfs(root.left);
+        int right = dfs(root.right);
+        int sum = root.val + left + right;
+        int current = map.getOrDefault(sum, 0) + 1;
+        map.put(sum, current);
+        max = Math.max(current, max);
+        return sum;
+    }
+}

solution/0500-0599/0513.Find Bottom Left Tree Value/Solution.java

@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ * int val;
+ * TreeNode left;
+ * TreeNode right;
+ * TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    int max = -1;
+    int value = 0;
+
+    public int findBottomLeftValue(TreeNode root) {
+        dfs(root, 0);
+        return value;
+    }
+
+    private void dfs(TreeNode root, int d) {
+        if (root == null) {
+            return;
+        }
+        d++;
+        if (max < d) {
+            max = d;
+            value = root.val;
+        }
+        dfs(root.left, d);
+        dfs(root.right, d);
+    }
+}