feat:去除重复字母

Author: haotf

Diff for: 16.最接近的三数之和.java

@@ -0,0 +1,49 @@
+import java.util.Arrays;
+
+/*
+ * @lc app=leetcode.cn id=16 lang=java
+ *
+ * [16] 最接近的三数之和
+ */
+
+// @lc code=start
+class Solution {
+    public int threeSumClosest(int[] nums, int target) {
+        if (nums.length < 3) {
+            return 0;
+        }
+        // 别忘了要先排序数组
+        Arrays.sort(nums);
+        // 记录三数之和与目标值的偏差
+        int delta = Integer.MAX_VALUE;
+        for (int i = 0; i < nums.length - 2; i++) {
+            // 固定 nums[i] 为三数之和中的第一个数，
+            // 然后对 nums[i+1..] 搜索接近 target - nums[i] 的两数之和
+            int sum = nums[i] + twoSumClosest(nums, i + 1, target - nums[i]);
+            if (Math.abs(delta) > Math.abs(target - sum)) {
+                delta = target - sum;
+            }
+        }
+        return target - delta;
+    }
+
+    // 在 nums[start..] 搜索最接近 target 的两数之和
+    int twoSumClosest(int[] nums, int start, int target) {
+        int lo = start, hi = nums.length - 1;
+        // 记录两数之和与目标值的偏差
+        int delta = Integer.MAX_VALUE;
+        while (lo < hi) {
+            int sum = nums[lo] + nums[hi];
+            if (Math.abs(delta) > Math.abs(target - sum)) {
+                delta = target - sum;
+            }
+            if (sum < target) {
+                lo++;
+            } else {
+                hi--;
+            }
+        }
+        return target - delta;
+    }
+}
+// @lc code=end

Diff for: 316.去除重复字母.java

@@ -0,0 +1,53 @@
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+ * @lc app=leetcode.cn id=316 lang=java
+ *
+ * [316] 去除重复字母
+ */
+
+// @lc code=start
+class Solution {
+    public String removeDuplicateLetters(String s) {
+
+        Map<Character, Integer> map = new HashMap<>();
+        Map<Character, Boolean> visited = new HashMap<>();
+        // 记录每个字符的个数
+        for (int i = 0; i < s.length(); i++) {
+            map.put(s.charAt(i), map.getOrDefault(s.charAt(i), 0) + 1);
+            visited.put(s.charAt(i), false);
+        }
+
+        StringBuilder result = new StringBuilder();
+        Deque<Character> stack = new ArrayDeque<>();
+        for (int i = 0; i < s.length(); i++) {
+            Character c = s.charAt(i);
+            if (visited.get(c)) {
+                map.put(c, map.get(c) - 1);
+                continue;
+            }
+            while (stack.size() > 0) {
+                Character peek = stack.peek();
+                if (peek >= c && map.get(peek) > 1) {
+                    visited.put(peek, false);
+                    stack.pop();
+                    map.put(peek, map.get(peek) - 1);
+                } else {
+                    break;
+                }
+            }
+            stack.push(c);
+            visited.put(c, true);
+        }
+
+        while (!stack.isEmpty()) {
+            result.append(stack.pop());
+        }
+
+        return result.reverse().toString();
+    }
+}
+// @lc code=end

Diff for: 98.验证二叉搜索树.java

@@ -8,12 +8,12 @@
 /**
  * Definition for a binary tree node.
  * public class TreeNode {
- * int val;
+ * long val;
  * TreeNode left;
  * TreeNode right;
  * TreeNode() {}
- * TreeNode(int val) { this.val = val; }
- * TreeNode(int val, TreeNode left, TreeNode right) {
+ * TreeNode(long val) { this.val = val; }
+ * TreeNode(long val, TreeNode left, TreeNode right) {
  * this.val = val;
  * this.left = left;
  * this.right = right;
@@ -22,7 +22,9 @@
  */
 class Solution {
     public boolean isValidBST(TreeNode root) {
-        return valid(root, null, null);
+        // return valid(root, null, null);
+        long[] result = traverse(root);
+        return result[0] == 1;
     }
 
     private boolean valid(TreeNode root, TreeNode max, TreeNode min) {
@@ -35,5 +37,19 @@ private boolean valid(TreeNode root, TreeNode max, TreeNode min) {
 
         return valid(root.left, root, min) && valid(root.right, max, root);
     }
+
+    private long[] traverse(TreeNode root) {
+        if (root == null)
+            return new long[] { 1, Long.MAX_VALUE, Long.MIN_VALUE };
+
+        long[] left = traverse(root.left);
+        long[] right = traverse(root.right);
+
+        if (left[0] == 0 || right[0] == 0)
+            return new long[] { 0 };
+        if (root.val > left[2] && root.val < right[1])
+            return new long[] { 1, Math.min(left[1], root.val), Math.max(right[2], root.val) };
+        return new long[] { 0 };
+    }
 }
 // @lc code=end