Added task 2316.

Author: javadev

README.md

@@ -1485,6 +1485,7 @@ implementation 'com.github.javadev:leetcode-in-java:1.11'
 
 | #    |      Title     | Difficulty  | Tag         | Time, ms | Time, %
 |------|----------------|-------------|-------------|----------|---------
+| 2316 |[Count Unreachable Pairs of Nodes in an Undirected Graph](src/main/java/g2301_2400/s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph/Solution.java)| Medium || 32 | 100.00
 | 2315 |[Count Asterisks](src/main/java/g2301_2400/s2315_count_asterisks/Solution.java)| Easy || 1 | 100.00
 | 2312 |[Selling Pieces of Wood](src/main/java/g2301_2400/s2312_selling_pieces_of_wood/Solution.java)| Hard | Backtracking | 78 | 63.64
 | 2311 |[Longest Binary Subsequence Less Than or Equal to K](src/main/java/g2301_2400/s2311_longest_binary_subsequence_less_than_or_equal_to_k/Solution.java)| Medium | String, Dynamic_Programming, Greedy, Memoization | 1 | 100.00

src/main/java/g2301_2400/s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph/Solution.java

@@ -0,0 +1,59 @@
+package g2301_2400.s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph;
+
+// #Medium #2022_06_26_Time_32_ms_(100.00%)_Space_108.9_MB_(100.00%)
+
+import java.util.HashMap;
+
+public class Solution {
+    public long countPairs(int n, int[][] edges) {
+        DSU d = new DSU(n);
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int[] e : edges) {
+            d.union(e[0], e[1]);
+        }
+        long ans = 0;
+        for (int i = 0; i < n; i++) {
+            int p = d.findParent(i);
+            int cnt = map.containsKey(p) ? map.get(p) : 0;
+            ans += i - cnt;
+            map.put(p, map.getOrDefault(p, 0) + 1);
+        }
+        return ans;
+    }
+
+    private static class DSU {
+        int[] rank;
+        int[] parent;
+
+        DSU(int n) {
+            rank = new int[n + 1];
+            parent = new int[n + 1];
+            for (int i = 1; i <= n; i++) {
+                parent[i] = i;
+            }
+        }
+
+        int findParent(int node) {
+            if (parent[node] == node) {
+                return node;
+            }
+            parent[node] = findParent(parent[node]);
+            return findParent(parent[node]);
+        }
+
+        boolean union(int x, int y) {
+            int px = findParent(x);
+            int py = findParent(y);
+            if (px == py) {
+                return false;
+            }
+            if (rank[px] > rank[py]) {
+                parent[py] = px;
+            } else {
+                parent[px] = py;
+                rank[py]++;
+            }
+            return true;
+        }
+    }
+}

src/main/java/g2301_2400/s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph/readme.md

@@ -0,0 +1,40 @@
+2316\. Count Unreachable Pairs of Nodes in an Undirected Graph
+
+Medium
+
+You are given an integer `n`. There is an **undirected** graph with `n` nodes, numbered from `0` to `n - 1`. You are given a 2D integer array `edges` where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> denotes that there exists an **undirected** edge connecting nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code>.
+
+Return _the **number of pairs** of different nodes that are **unreachable** from each other_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2022/05/05/tc-3.png)
+
+**Input:** n = 3, edges = [[0,1],[0,2],[1,2]]
+
+**Output:** 0
+
+**Explanation:** There are no pairs of nodes that are unreachable from each other.
+
+Therefore, we return 0.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2022/05/05/tc-2.png)
+
+**Input:** n = 7, edges = [[0,2],[0,5],[2,4],[1,6],[5,4]]
+
+**Output:** 14
+
+**Explanation:** There are 14 pairs of nodes that are unreachable from each other: [[0,1],[0,3],[0,6],[1,2],[1,3],[1,4],[1,5],[2,3],[2,6],[3,4],[3,5],[3,6],[4,6],[5,6]].
+
+Therefore, we return 14.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= edges.length <= 2 * 10<sup>5</sup></code>
+*   `edges[i].length == 2`
+*   <code>0 <= a<sub>i</sub>, b<sub>i</sub> < n</code>
+*   <code>a<sub>i</sub> != b<sub>i</sub></code>
+*   There are no repeated edges.

src/test/java/g1101_1200/s1114_print_in_order/FooTest.java

@@ -15,7 +15,7 @@ void foo() throws InterruptedException {
         new Thread(() -> foo.first(() -> fooData[0]++)).start();
         new Thread(() -> foo.second(() -> fooData[0]++)).start();
         new Thread(() -> foo.third(() -> fooData[0]++)).start();
-        TimeUnit.MILLISECONDS.sleep(500);
+        TimeUnit.MILLISECONDS.sleep(600);
         assertThat(fooData[0], equalTo(3));
     }
 }

src/test/java/g2301_2400/s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph/SolutionTest.java

@@ -0,0 +1,20 @@
+package g2301_2400.s2316_count_unreachable_pairs_of_nodes_in_an_undirected_graph;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void countPairs() {
+        assertThat(new Solution().countPairs(3, new int[][] {{0, 1}, {0, 2}, {1, 2}}), equalTo(0L));
+    }
+
+    @Test
+    void countPairs2() {
+        assertThat(
+                new Solution().countPairs(7, new int[][] {{0, 2}, {0, 5}, {2, 4}, {1, 6}, {5, 4}}),
+                equalTo(14L));
+    }
+}