623-640-870-1238-1326 (5)

Author: gdut-yy

README.md

@@ -625,5 +625,6 @@ Hierholzer 算法
 - [clist.by](https://clist.by/account/zhang-yi-yang/resource/leetcode.com/)
 - [visualgo](https://visualgo.net/zh)
 - [宫水三叶の刷题日记](https://www.acoier.com/tags/)
+- [灵茶の试炼](https://docs.qq.com/sheet/DWGFoRGVZRmxNaXFz?tab=BB08J2)
 
 （全文完）

leetcode-01/src/main/java/Solution45.java

@@ -1,14 +1,14 @@
 public class Solution45 {
     public int jump(int[] nums) {
-        int len = nums.length;
-        int max = 0;
-        // 贪心
-        int end = 0;
-        int step = 0;
-        for (int i = 0; i < len - 1; i++) {
-            max = Math.max(max, i + nums[i]);
-            if (i == end) {
-                end = max;
+        int n = nums.length;
+
+        // 能到达的最远距离下标，当前下标，步数
+        int maxR = 0, curR = 0, step = 0;
+        // [1, n-1) 到达 nums[n - 1] 的最小跳跃次数
+        for (int i = 0; i < n - 1; i++) {
+            maxR = Math.max(maxR, i + nums[i]);
+            if (i == curR) {
+                curR = maxR;
                 step++;
             }
         }
@@ -28,4 +28,8 @@ public int jump(int[] nums) {
 0 <= nums[i] <= 1000
 
 贪心。
+相似题目: 1024. 视频拼接
+https://leetcode.cn/problems/video-stitching/
+1326. 灌溉花园的最少水龙头数目
+https://leetcode.cn/problems/minimum-number-of-taps-to-open-to-water-a-garden/
  */

leetcode-01/src/main/java/Solution89.java

@@ -29,4 +29,7 @@ private int g(int n) {
 1 <= n <= 16
 
 位运算
+时间复杂度 O(2^n)
+相似题目: 1238. 循环码排列
+https://leetcode.cn/problems/circular-permutation-in-binary-representation/
  */

leetcode-07/src/main/java/Solution623.java

@@ -0,0 +1,40 @@
+public class Solution623 {
+    public TreeNode addOneRow(TreeNode root, int val, int depth) {
+        if (root == null) {
+            return null;
+        }
+        if (depth == 1) {
+            return new TreeNode(val, root, null);
+        }
+        if (depth == 2) {
+            root.left = new TreeNode(val, root.left, null);
+            root.right = new TreeNode(val, null, root.right);
+        } else {
+            root.left = addOneRow(root.left, val, depth - 1);
+            root.right = addOneRow(root.right, val, depth - 1);
+        }
+        return root;
+    }
+}
+/*
+623. 在二叉树中增加一行
+https://leetcode.cn/problems/add-one-row-to-tree/
+
+给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。
+注意，根节点 root 位于深度 1 。
+加法规则如下:
+- 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。
+- cur 原来的左子树应该是新的左子树根的左子树。
+- cur 原来的右子树应该是新的右子树根的右子树。
+- 如果 depth == 1 意味着 depth - 1 根本没有深度，那么创建一个树节点，值 val 作为整个原始树的新根，而原始树就是新根的左子树。
+提示:
+节点数在 [1, 10^4] 范围内
+树的深度在 [1, 10^4]范围内
+-100 <= Node.val <= 100
+-10^5 <= val <= 10^5
+1 <= depth <= the depth of tree + 1
+
+递归
+时间复杂度 O(n)
+空间复杂度 O(n)
+ */

leetcode-07/src/main/java/Solution640.java

@@ -0,0 +1,54 @@
+public class Solution640 {
+    public String solveEquation(String equation) {
+        int n = equation.length();
+        char[] s = equation.toCharArray();
+        int x = 0;
+        int num = 0;
+
+        int i = 0;
+        int op = 1;
+        while (i < n) {
+            if (s[i] == '+') {
+                op = 1;
+                i++;
+            } else if (s[i] == '-') {
+                op = -1;
+                i++;
+            } else if (s[i] == '=') {
+                op = 1;
+                x *= -1;
+                num *= -1;
+                i++;
+            } else {
+                int j = i;
+                while (j < n && s[j] != '+' && s[j] != '-' && s[j] != '=') {
+                    j++;
+                }
+                if (s[j - 1] == 'x') {
+                    x += op * (i < j - 1 ? Integer.parseInt(equation.substring(i, j - 1)) : 1);
+                } else {
+                    num += op * Integer.parseInt(equation.substring(i, j));
+                }
+                i = j;
+            }
+        }
+        if (x == 0) {
+            return num == 0 ? "Infinite solutions" : "No solution";
+        }
+        return "x=" + -num / x;
+    }
+}
+/*
+640. 求解方程
+https://leetcode.cn/problems/solve-the-equation/
+
+求解一个给定的方程，将x以字符串 "x=#value" 的形式返回。该方程仅包含 '+' ， '-' 操作，变量 x 和其对应系数。
+如果方程没有解或存在的解不为整数，请返回 "No solution" 。如果方程有无限解，则返回 “Infinite solutions” 。
+题目保证，如果方程中只有一个解，则 'x' 的值是一个整数。
+提示:
+3 <= equation.length <= 1000
+equation 只有一个 '='. 
+方程由绝对值在 [0, 100]  范围内且无任何前导零的整数和变量 'x' 组成。
+
+模拟。表达式求值
+ */

leetcode-07/src/test/java/Solution623Tests.java

@@ -0,0 +1,24 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution623Tests {
+    private final Solution623 solution623 = new Solution623();
+
+    @Test
+    public void example1() {
+        TreeNode root = TreeNode.buildTreeNode("[4,2,6,3,1,5]");
+        int val = 1;
+        int depth = 2;
+        TreeNode expected = TreeNode.buildTreeNode("[4,1,1,2,null,null,6,3,1,5]");
+        Assertions.assertTrue(TreeNode.assertTreeNodeEquals(expected, solution623.addOneRow(root, val, depth)));
+    }
+
+    @Test
+    public void example2() {
+        TreeNode root = TreeNode.buildTreeNode("[4,2,null,3,1]");
+        int val = 1;
+        int depth = 3;
+        TreeNode expected = TreeNode.buildTreeNode("[4,2,null,1,1,3,null,null,1]");
+        Assertions.assertTrue(TreeNode.assertTreeNodeEquals(expected, solution623.addOneRow(root, val, depth)));
+    }
+}

leetcode-07/src/test/java/Solution640Tests.java

@@ -0,0 +1,27 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution640Tests {
+    private final Solution640 solution640 = new Solution640();
+
+    @Test
+    public void example1() {
+        String equation = "x+5-3+x=6+x-2";
+        String expected = "x=2";
+        Assertions.assertEquals(expected, solution640.solveEquation(equation));
+    }
+
+    @Test
+    public void example2() {
+        String equation = "x=x";
+        String expected = "Infinite solutions";
+        Assertions.assertEquals(expected, solution640.solveEquation(equation));
+    }
+
+    @Test
+    public void example3() {
+        String equation = "2x=x";
+        String expected = "x=0";
+        Assertions.assertEquals(expected, solution640.solveEquation(equation));
+    }
+}

leetcode-09/src/main/java/Solution870.java

@@ -0,0 +1,40 @@
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.stream.IntStream;
+
+public class Solution870 {
+    public int[] advantageCount(int[] nums1, int[] nums2) {
+        int n = nums1.length;
+        Arrays.sort(nums1);
+        Integer[] id2 = IntStream.range(0, n).boxed().toArray(Integer[]::new);
+        Arrays.sort(id2, Comparator.comparingInt(o -> nums2[o]));
+
+        int[] res = new int[n];
+        int l = 0, r = n - 1;
+        for (int n1 : nums1) {
+            if (n1 > nums2[id2[l]]) {
+                res[id2[l]] = n1;
+                l++;
+            } else {
+                res[id2[r]] = n1;
+                r--;
+            }
+        }
+        return res;
+    }
+}
+/*
+870. 优势洗牌
+https://leetcode.cn/problems/advantage-shuffle/
+
+给定两个大小相等的数组 nums1 和 nums2，nums1 相对于 nums2 的优势可以用满足 nums1[i] > nums2[i] 的索引 i 的数目来描述。
+返回 nums1 的任意排列，使其相对于 nums2 的优势最大化。
+提示：
+1 <= nums1.length <= 10^5
+nums2.length == nums1.length
+0 <= nums1[i], nums2[i] <= 10^9
+
+贪心。又名 “田忌赛马”
+时间复杂度 O(nlogn)
+空间复杂度 O(n)
+ */

leetcode-09/src/test/java/Solution870Tests.java

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution870Tests {
+    private final Solution870 solution870 = new Solution870();
+
+    @Test
+    public void example1() {
+        int[] nums1 = {2, 7, 11, 15};
+        int[] nums2 = {1, 10, 4, 11};
+        int[] expected = {2, 11, 7, 15};
+        Assertions.assertArrayEquals(expected, solution870.advantageCount(nums1, nums2));
+    }
+
+    @Test
+    public void example2() {
+        int[] nums1 = {12, 24, 8, 32};
+        int[] nums2 = {13, 25, 32, 11};
+        int[] expected = {24, 32, 8, 12};
+        Assertions.assertArrayEquals(expected, solution870.advantageCount(nums1, nums2));
+    }
+}

leetcode-11/src/main/java/Solution1024.java

@@ -1,29 +1,29 @@
 public class Solution1024 {
     public int videoStitching(int[][] clips, int time) {
-        // 预处理每个 start 的最长范围
-        int[] maxRange = new int[time];
+        // f[i] 表示下标 starti 对应的最长 endi
+        int[] f = new int[time];
         for (int[] clip : clips) {
-            int start = clip[0];
-            if (start < time) {
-                maxRange[start] = Math.max(maxRange[start], clip[1]);
+            int l = clip[0];
+            // 防止越界
+            if (l < time) {
+                f[l] = Math.max(f[l], clip[1]);
             }
         }
 
-        // 贪心
-        int cnt = 0;
-        int pre = 0;
-        int last = 0;
+        // 能到达的最远距离下标，当前下标，步数
+        int maxR = 0, curR = 0, step = 0;
+        // [1, time) 返回所需片段的最小数目
         for (int i = 0; i < time; i++) {
-            last = Math.max(last, maxRange[i]);
-            if (i == last) {
-                return -1;
-            }
-            if (i == pre) {
-                pre = last;
-                cnt++;
+            maxR = Math.max(maxR, f[i]);
+            if (i == curR) {
+                if (i == maxR) {
+                    return -1;
+                }
+                curR = maxR;
+                step++;
             }
         }
-        return cnt;
+        return step;
     }
 }
 /*
@@ -44,4 +44,8 @@ public int videoStitching(int[][] clips, int time) {
 每次尽可能找最长的区间延申，以达到所需片段的最小
 时间复杂度 O(clips.length + time)
 空间复杂度 O(time)
+相似题目: 45. 跳跃游戏 II
+https://leetcode.cn/problems/jump-game-ii/
+1326. 灌溉花园的最少水龙头数目
+https://leetcode.cn/problems/minimum-number-of-taps-to-open-to-water-a-garden/
  */