Added tasks 2201, 2203.

Author: ThanhNIT

src/main/java/g2201_2300/s2201_count_artifacts_that_can_be_extracted/Solution.java

@@ -0,0 +1,40 @@
+package g2201_2300.s2201_count_artifacts_that_can_be_extracted;
+
+// #Medium #Array #Hash_Table #Simulation #2022_06_11_Time_7_ms_(82.97%)_Space_91.5_MB_(99.45%)
+
+public class Solution {
+ public int digArtifacts(int n, int[][] artifacts, int[][] dig) {
+ int[][] ar = new int[n][n];
+ for (int[] ints : dig) {
+ ar[ints[0]][ints[1]] = 1;
+ }
+ int ans = 0;
+ for (int[] artifact : artifacts) {
+ int x1 = artifact[0];
+ int y1 = artifact[1];
+ int x2 = artifact[2];
+ int y2 = artifact[3];
+ int flag = 0;
+ int a = x1;
+ int b = y1;
+ while (a <= x2) {
+ b = y1;
+ while (b <= y2) {
+ if (ar[a][b] != 1) {
+ flag = 1;
+ break;
+ }
+ b++;
+ }
+ if (flag == 1) {
+ break;
+ }
+ a++;
+ }
+ if (a == x2 + 1 && b == y2 + 1) {
+ ans++;
+ }
+ }
+ return ans;
+ }
+}

src/main/java/g2201_2300/s2201_count_artifacts_that_can_be_extracted/readme.md

@@ -0,0 +1,51 @@
+2201\. Count Artifacts That Can Be Extracted
+
+Medium
+
+There is an `n x n` **0-indexed** grid with some artifacts buried in it. You are given the integer `n` and a **0-indexed** 2D integer array `artifacts` describing the positions of the rectangular artifacts where <code>artifacts[i] = [r1<sub>i</sub>, c1<sub>i</sub>, r2<sub>i</sub>, c2<sub>i</sub>]</code> denotes that the <code>i<sup>th</sup></code> artifact is buried in the subgrid where:
+
+* <code>(r1<sub>i</sub>, c1<sub>i</sub>)</code> is the coordinate of the **top-left** cell of the <code>i<sup>th</sup></code> artifact and
+* <code>(r2<sub>i</sub>, c2<sub>i</sub>)</code> is the coordinate of the **bottom-right** cell of the <code>i<sup>th</sup></code> artifact.
+
+You will excavate some cells of the grid and remove all the mud from them. If the cell has a part of an artifact buried underneath, it will be uncovered. If all the parts of an artifact are uncovered, you can extract it.
+
+Given a **0-indexed** 2D integer array `dig` where <code>dig[i] = [r<sub>i</sub>, c<sub>i</sub>]</code> indicates that you will excavate the cell <code>(r<sub>i</sub>, c<sub>i</sub>)</code>, return _the number of artifacts that you can extract_.
+
+The test cases are generated such that:
+
+* No two artifacts overlap.
+* Each artifact only covers at most `4` cells.
+* The entries of `dig` are unique.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/09/16/untitled-diagram.jpg)
+
+**Input:** n = 2, artifacts = [[0,0,0,0],[0,1,1,1]], dig = [[0,0],[0,1]]
+
+**Output:** 1
+
+**Explanation:** The different colors represent different artifacts. Excavated cells are labeled with a 'D' in the grid. There is 1 artifact that can be extracted, namely the red artifact. The blue artifact has one part in cell (1,1) which remains uncovered, so we cannot extract it. Thus, we return 1.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2019/09/16/untitled-diagram-1.jpg)
+
+**Input:** n = 2, artifacts = [[0,0,0,0],[0,1,1,1]], dig = [[0,0],[0,1],[1,1]]
+
+**Output:** 2
+
+**Explanation:** Both the red and blue artifacts have all parts uncovered (labeled with a 'D') and can be extracted, so we return 2.
+
+**Constraints:**
+
+* `1 <= n <= 1000`
+* <code>1 <= artifacts.length, dig.length <= min(n<sup>2</sup>, 10<sup>5</sup>)</code>
+* `artifacts[i].length == 4`
+* `dig[i].length == 2`
+* <code>0 <= r1<sub>i</sub>, c1<sub>i</sub>, r2<sub>i</sub>, c2<sub>i</sub>, r<sub>i</sub>, c<sub>i</sub> <= n - 1</code>
+* <code>r1<sub>i</sub> <= r2<sub>i</sub></code>
+* <code>c1<sub>i</sub> <= c2<sub>i</sub></code>
+* No two artifacts will overlap.
+* The number of cells covered by an artifact is **at most** `4`.
+* The entries of `dig` are unique.

src/main/java/g2201_2300/s2203_minimum_weighted_subgraph_with_the_required_paths/Solution.java

@@ -0,0 +1,72 @@
+package g2201_2300.s2203_minimum_weighted_subgraph_with_the_required_paths;
+
+// #Hard #Graph #Shortest_Path #2022_06_12_Time_241_ms_(50.34%)_Space_205.1_MB_(10.20%)
+
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.PriorityQueue;
+
+public class Solution {
+ public long minimumWeight(int n, int[][] edges, int src1, int src2, int dest) {
+ Map<Integer, Integer>[] g1 = new Map[n];
+ Map<Integer, Integer>[] g2 = new Map[n];
+ for (int[] edge : edges) {
+ int s1 = edge[0];
+ int s2 = edge[1];
+ int w = edge[2];
+ if (g1[s1] == null) {
+ g1[s1] = new HashMap<>();
+ }
+ g1[s1].put(s2, Math.min(w, g1[s1].getOrDefault(s2, Integer.MAX_VALUE)));
+ if (g2[s2] == null) {
+ g2[s2] = new HashMap<>();
+ }
+ g2[s2].put(s1, Math.min(w, g2[s2].getOrDefault(s1, Integer.MAX_VALUE)));
+ }
+ Long[] dist1 = dijkstra(g1, src1);
+ Long[] dist2 = dijkstra(g1, src2);
+ Long[] dist3 = dijkstra(g2, dest);
+ Long res = null;
+ for (int i = 0; i < n; i += 1) {
+ if (dist1[i] != null && dist2[i] != null && dist3[i] != null) {
+ long sum = dist1[i] + dist2[i] + dist3[i];
+ if (res == null || res > sum) {
+ res = sum;
+ }
+ }
+ }
+ return res == null ? -1 : res;
+ }
+
+ private Long[] dijkstra(Map<Integer, Integer>[] graph, int start) {
+ Long[] res = new Long[graph.length];
+ PriorityQueue<State> q = new PriorityQueue<>(Comparator.comparingLong(a -> a.w));
+ q.offer(new State(start, 0L));
+ while (!q.isEmpty()) {
+ State cur = q.poll();
+ if (res[cur.id] != null) {
+ continue;
+ }
+ res[cur.id] = (long) cur.w;
+ if (graph[cur.id] != null) {
+ for (int next : graph[cur.id].keySet()) {
+ if (res[next] == null) {
+ q.offer(new State(next, cur.w + graph[cur.id].get(next)));
+ }
+ }
+ }
+ }
+ return res;
+ }
+
+ private static class State {
+ long w;
+ int id;
+
+ State(int id, long w) {
+ this.id = id;
+ this.w = w;
+ }
+ }
+}

src/main/java/g2201_2300/s2203_minimum_weighted_subgraph_with_the_required_paths/readme.md

@@ -0,0 +1,43 @@
+2203\. Minimum Weighted Subgraph With the Required Paths
+
+Hard
+
+You are given an integer `n` denoting the number of nodes of a **weighted directed** graph. The nodes are numbered from `0` to `n - 1`.
+
+You are also given a 2D integer array `edges` where <code>edges[i] = [from<sub>i</sub>, to<sub>i</sub>, weight<sub>i</sub>]</code> denotes that there exists a **directed** edge from <code>from<sub>i</sub></code> to <code>to<sub>i</sub></code> with weight <code>weight<sub>i</sub></code>.
+
+Lastly, you are given three **distinct** integers `src1`, `src2`, and `dest` denoting three distinct nodes of the graph.
+
+Return _the **minimum weight** of a subgraph of the graph such that it is **possible** to reach_ `dest` _from both_ `src1` _and_ `src2` _via a set of edges of this subgraph_. In case such a subgraph does not exist, return `-1`.
+
+A **subgraph** is a graph whose vertices and edges are subsets of the original graph. The **weight** of a subgraph is the sum of weights of its constituent edges.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/02/17/example1drawio.png)
+
+**Input:** n = 6, edges = [[0,2,2],[0,5,6],[1,0,3],[1,4,5],[2,1,1],[2,3,3],[2,3,4],[3,4,2],[4,5,1]], src1 = 0, src2 = 1, dest = 5
+
+**Output:** 9
+
+**Explanation:** The above figure represents the input graph. The blue edges represent one of the subgraphs that yield the optimal answer. Note that the subgraph [[1,0,3],[0,5,6]] also yields the optimal answer. It is not possible to get a subgraph with less weight satisfying all the constraints.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/02/17/example2-1drawio.png)
+
+**Input:** n = 3, edges = [[0,1,1],[2,1,1]], src1 = 0, src2 = 1, dest = 2
+
+**Output:** -1
+
+**Explanation:** The above figure represents the input graph. It can be seen that there does not exist any path from node 1 to node 2, hence there are no subgraphs satisfying all the constraints.
+
+**Constraints:**
+
+* <code>3 <= n <= 10<sup>5</sup></code>
+* <code>0 <= edges.length <= 10<sup>5</sup></code>
+* `edges[i].length == 3`
+* <code>0 <= from<sub>i</sub>, to<sub>i</sub>, src1, src2, dest <= n - 1</code>
+* <code>from<sub>i</sub> != to<sub>i</sub></code>
+* `src1`, `src2`, and `dest` are pairwise distinct.
+* <code>1 <= weight[i] <= 10<sup>5</sup></code>

src/test/java/g2201_2300/s2201_count_artifacts_that_can_be_extracted/SolutionTest.java

@@ -0,0 +1,30 @@
+package g2201_2300.s2201_count_artifacts_that_can_be_extracted;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void digArtifacts() {
+ assertThat(
+ new Solution()
+ .digArtifacts(
+ 2,
+ new int[][] {{0, 0, 0, 0}, {0, 1, 1, 1}},
+ new int[][] {{0, 0}, {0, 1}}),
+ equalTo(1));
+ }
+
+ @Test
+ void digArtifacts2() {
+ assertThat(
+ new Solution()
+ .digArtifacts(
+ 2,
+ new int[][] {{0, 0, 0, 0}, {0, 1, 1, 1}},
+ new int[][] {{0, 0}, {0, 1}, {1, 1}}),
+ equalTo(2));
+ }
+}

src/test/java/g2201_2300/s2203_minimum_weighted_subgraph_with_the_required_paths/SolutionTest.java

@@ -0,0 +1,31 @@
+package g2201_2300.s2203_minimum_weighted_subgraph_with_the_required_paths;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+ @Test
+ void minimumWeight() {
+ assertThat(
+ new Solution()
+ .minimumWeight(
+ 6,
+ new int[][] {
+ {0, 2, 2}, {0, 5, 6}, {1, 0, 3}, {1, 4, 5}, {2, 1, 1},
+ {2, 3, 3}, {2, 3, 4}, {3, 4, 2}, {4, 5, 1}
+ },
+ 0,
+ 1,
+ 5),
+ equalTo(9L));
+ }
+
+ @Test
+ void minimumWeight2() {
+ assertThat(
+ new Solution().minimumWeight(3, new int[][] {{0, 1, 1}, {2, 1, 1}}, 0, 1, 2),
+ equalTo(-1L));
+ }
+}