2158-2204 (2)

gdut-yy · gdut-yy · commit d8cda5ddec4a · 2023-01-27T22:31:26.000+08:00
diff --git a/leetcode-22/src/main/java/Solution2158.java b/leetcode-22/src/main/java/Solution2158.java
@@ -0,0 +1,104 @@
+public class Solution2158 {
+    public int[] amountPainted(int[][] paint) {
+        int len = paint.length;
+
+        DynamicSegTreeUpd dynamicSegTreeUpd = new DynamicSegTreeUpd();
+        int[] res = new int[len];
+        for (int i = 0; i < len; i++) {
+            // 左闭右开
+            int l = paint[i][0];
+            int r = paint[i][1] - 1;
+            res[i] = (r - l + 1) - (int) dynamicSegTreeUpd.getSum(l, r);
+            dynamicSegTreeUpd.update(l, r, 1);
+        }
+        return res;
+    }
+
+    private static class DynamicSegTreeUpd {
+        private static final int N = Integer.MAX_VALUE;
+        private final Node root = new Node();
+
+        private static class Node {
+            Node ls, rs;
+            long sum, lazy;
+        }
+
+        // 区间 [l,r] 置为 val
+        public void update(int l, int r, int val) {
+            this.update(l, r, val, 0, N, root);
+        }
+
+        // 区间 [l,r] 求和
+        public long getSum(int l, int r) {
+            return this.getSum(l, r, 0, N, root);
+        }
+
+        private void update(int l, int r, int val, int s, int t, Node node) {
+            if (l <= s && t <= r) {
+                node.sum = (t - s + 1L) * val;
+                node.lazy = val;
+                return;
+            }
+            int mid = s + (t - s) / 2;
+            pushDown(node, s, t, mid);
+            if (l <= mid) {
+                update(l, r, val, s, mid, node.ls);
+            }
+            if (r > mid) {
+                update(l, r, val, mid + 1, t, node.rs);
+            }
+            pushUp(node);
+        }
+
+        private long getSum(int l, int r, int s, int t, Node node) {
+            if (l <= s && t <= r) {
+                return node.sum;
+            }
+            int mid = s + (t - s) / 2;
+            pushDown(node, s, t, mid);
+            long sum = 0;
+            if (l <= mid) {
+                sum = getSum(l, r, s, mid, node.ls);
+            }
+            if (r > mid) {
+                sum += getSum(l, r, mid + 1, t, node.rs);
+            }
+            return sum;
+        }
+
+        private void pushDown(Node node, int s, int t, int mid) {
+            if (node.ls == null) {
+                node.ls = new Node();
+            }
+            if (node.rs == null) {
+                node.rs = new Node();
+            }
+            if (node.lazy > 0) {
+                node.ls.sum = node.lazy * (mid - s + 1L);
+                node.rs.sum = node.lazy * (t - mid);
+                node.ls.lazy = node.lazy;
+                node.rs.lazy = node.lazy;
+                node.lazy = 0;
+            }
+        }
+
+        private void pushUp(Node node) {
+            node.sum = node.ls.sum + node.rs.sum;
+        }
+    }
+}
+/*
+$2158. 每天绘制新区域的数量
+https://leetcode.cn/problems/amount-of-new-area-painted-each-day/
+
+有一幅细长的画，可以用数轴来表示。 给你一个长度为 n 、下标从 0 开始的二维整数数组 paint ，其中 paint[i] = [starti, endi] 表示在第 i 天你需要绘制 starti 和 endi 之间的区域。
+多次绘制同一区域会导致不均匀，因此每个区域最多只能绘制 一次 。
+返回一个长度为 n 的整数数组 worklog，其中 worklog[i] 是你在第 i 天绘制的 新 区域的数量。
+提示：
+1 <= paint.length <= 10^5
+paint[i].length == 2
+0 <= starti < endi <= 5 * 10^4
+
+线段树
+区间并查集 https://leetcode.cn/problems/amount-of-new-area-painted-each-day/solution/qu-jian-bing-cha-ji-by-981377660lmt-p1zl/
+ */
diff --git a/leetcode-22/src/test/java/Solution2158Tests.java b/leetcode-22/src/test/java/Solution2158Tests.java
@@ -0,0 +1,27 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution2158Tests {
+    private final Solution2158 solution2158 = new Solution2158();
+
+    @Test
+    public void example1() {
+        int[][] paint = UtUtils.stringToInts2("[[1,4],[4,7],[5,8]]");
+        int[] expected = {3, 3, 1};
+        Assertions.assertArrayEquals(expected, solution2158.amountPainted(paint));
+    }
+
+    @Test
+    public void example2() {
+        int[][] paint = UtUtils.stringToInts2("[[1,4],[5,8],[4,7]]");
+        int[] expected = {3, 3, 1};
+        Assertions.assertArrayEquals(expected, solution2158.amountPainted(paint));
+    }
+
+    @Test
+    public void example3() {
+        int[][] paint = UtUtils.stringToInts2("[[1,5],[2,4]]");
+        int[] expected = {4, 0};
+        Assertions.assertArrayEquals(expected, solution2158.amountPainted(paint));
+    }
+}
diff --git a/leetcode-23/src/main/java/Solution2204.java b/leetcode-23/src/main/java/Solution2204.java
@@ -0,0 +1,80 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+
+public class Solution2204 {
+    private Map<Integer, List<Integer>> g;
+    private int[] deg;
+    private int[] ans;
+
+    public int[] distanceToCycle(int n, int[][] edges) {
+        g = new HashMap<>();
+        deg = new int[n];
+        for (int[] edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            g.computeIfAbsent(u, key -> new ArrayList<>()).add(v);
+            g.computeIfAbsent(v, key -> new ArrayList<>()).add(u);
+            deg[u]++;
+            deg[v]++;
+        }
+
+        // 拓扑排序，剪掉所有树枝
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            if (deg[i] == 1) {
+                queue.add(i);
+            }
+        }
+        while (!queue.isEmpty()) {
+            int u = queue.remove();
+            for (int v : g.getOrDefault(u, new ArrayList<>())) {
+                deg[v]--;
+                if (deg[v] == 1) {
+                    queue.add(v);
+                }
+            }
+        }
+
+        // 从基环出发，求所有树枝上的点的深度
+        ans = new int[n];
+        for (int root = 0; root < n; root++) {
+            if (deg[root] > 1) {
+                f(root, -1);
+            }
+        }
+        return ans;
+    }
+
+    private void f(int u, int fa) {
+        for (int v : g.getOrDefault(u, new ArrayList<>())) {
+            if (v != fa && deg[v] < 2) {
+                ans[v] = ans[u] + 1;
+                f(v, u);
+            }
+        }
+    }
+}
+/*
+$2204. 无向图中到环的距离
+https://leetcode.cn/problems/distance-to-a-cycle-in-undirected-graph/
+
+给定一个正整数 n，表示一个 连通无向图 中的节点数，该图 只包含一个 环。节点编号为 0 ~ n - 1(含)。
+你还得到了一个二维整数数组 edges，其中 edges[i] = [node1i, node2i] 表示有一条 双向 边连接图中的 node1i 和 node2i。
+两个节点 a 和 b 之间的距离定义为从 a 到 b 所需的 最小边数。
+返回一个长度为 n 的整数数组 answer，其中 answer[i] 是第 i 个节点与环中任何节点之间的最小距离。
+提示:
+3 <= n <= 10^5
+edges.length == n
+edges[i].length == 2
+0 <= node1i, node2i <= n - 1
+node1i != node2i
+图是连通的。
+这个图只有一个环。
+任何顶点对之间最多只有一条边。
+
+无向基环树 https://leetcode.cn/problems/distance-to-a-cycle-in-undirected-graph/solution/by-endlesscheng-422f/
+ */
diff --git a/leetcode-23/src/test/java/Solution2204Tests.java b/leetcode-23/src/test/java/Solution2204Tests.java
@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution2204Tests {
+    private final Solution2204 solution2204 = new Solution2204();
+
+    @Test
+    public void example1() {
+        int n = 7;
+        int[][] edges = UtUtils.stringToInts2("[[1,2],[2,4],[4,3],[3,1],[0,1],[5,2],[6,5]]");
+        int[] expected = {1, 0, 0, 0, 0, 1, 2};
+        Assertions.assertArrayEquals(expected, solution2204.distanceToCycle(n, edges));
+    }
+
+    @Test
+    public void example2() {
+        int n = 9;
+        int[][] edges = UtUtils.stringToInts2("[[0,1],[1,2],[0,2],[2,6],[6,7],[6,8],[0,3],[3,4],[3,5]]");
+        int[] expected = {0, 0, 0, 1, 2, 2, 1, 2, 2};
+        Assertions.assertArrayEquals(expected, solution2204.distanceToCycle(n, edges));
+    }
+}
