feat: update solutions to lc problems: No.0612,2316 (doocs#1852)

* No.0612.Shortest Distance in a Plane
* No.2316.Count Unreachable Pairs of Nodes in an Undirected Graph

Author: yanglbme

solution/0600-0699/0612.Shortest Distance in a Plane/README.md

@@ -68,9 +68,8 @@ Point2D table:
 # Write your MySQL query statement below
 SELECT ROUND(SQRT(POW(p1.x - p2.x, 2) + POW(p1.y - p2.y, 2)), 2) AS shortest
 FROM
-    Point2D AS p1,
-    Point2D AS p2
-WHERE p1.x != p2.x OR p1.y != p2.y
+    Point2D AS p1
+    JOIN Point2D AS p2 ON p1.x != p2.x OR p1.y != p2.y
 ORDER BY 1
 LIMIT 1;
 ```

solution/0600-0699/0612.Shortest Distance in a Plane/README_EN.md

@@ -57,9 +57,8 @@ Point2D table:
 # Write your MySQL query statement below
 SELECT ROUND(SQRT(POW(p1.x - p2.x, 2) + POW(p1.y - p2.y, 2)), 2) AS shortest
 FROM
-    Point2D AS p1,
-    Point2D AS p2
-WHERE p1.x != p2.x OR p1.y != p2.y
+    Point2D AS p1
+    JOIN Point2D AS p2 ON p1.x != p2.x OR p1.y != p2.y
 ORDER BY 1
 LIMIT 1;
 ```

solution/0600-0699/0612.Shortest Distance in a Plane/Solution.sql

@@ -1,8 +1,7 @@
 # Write your MySQL query statement below
 SELECT ROUND(SQRT(POW(p1.x - p2.x, 2) + POW(p1.y - p2.y, 2)), 2) AS shortest
 FROM
-    Point2D AS p1,
-    Point2D AS p2
-WHERE p1.x != p2.x OR p1.y != p2.y
+    Point2D AS p1
+    JOIN Point2D AS p2 ON p1.x != p2.x OR p1.y != p2.y
 ORDER BY 1
 LIMIT 1;

solution/2300-2399/2316.Count Unreachable Pairs of Nodes in an Undirected Graph/README.md

@@ -66,25 +66,22 @@
 ```python
 class Solution:
     def countPairs(self, n: int, edges: List[List[int]]) -> int:
-        def dfs(i):
-            vis.add(i)
-            cnt = 1
-            for j in g[i]:
-                if j not in vis:
-                    cnt += dfs(j)
-            return cnt
-
-        g = defaultdict(list)
+        def dfs(i: int) -> int:
+            if vis[i]:
+                return 0
+            vis[i] = True
+            return 1 + sum(dfs(j) for j in g[i])
+
+        g = [[] for _ in range(n)]
         for a, b in edges:
             g[a].append(b)
             g[b].append(a)
-        vis = set()
+        vis = [False] * n
         ans = s = 0
         for i in range(n):
-            if i not in vis:
-                t = dfs(i)
-                ans += s * t
-                s += t
+            t = dfs(i)
+            ans += s * t
+            s += t
         return ans
 ```
 
@@ -94,36 +91,35 @@ class Solution:
 
 ```java
 class Solution {
-    private boolean[] vis;
     private List<Integer>[] g;
+    private boolean[] vis;
 
     public long countPairs(int n, int[][] edges) {
-        vis = new boolean[n];
         g = new List[n];
-        Arrays.setAll(g, k -> new ArrayList<>());
+        vis = new boolean[n];
+        Arrays.setAll(g, i -> new ArrayList<>());
         for (var e : edges) {
             int a = e[0], b = e[1];
             g[a].add(b);
             g[b].add(a);
         }
         long ans = 0, s = 0;
         for (int i = 0; i < n; ++i) {
-            if (!vis[i]) {
-                long t = dfs(i);
-                ans += s * t;
-                s += t;
-            }
+            int t = dfs(i);
+            ans += s * t;
+            s += t;
         }
         return ans;
     }
 
     private int dfs(int i) {
+        if (vis[i]) {
+            return 0;
+        }
         vis[i] = true;
         int cnt = 1;
         for (int j : g[i]) {
-            if (!vis[j]) {
-                cnt += dfs(j);
-            }
+            cnt += dfs(j);
         }
         return cnt;
     }
@@ -136,30 +132,30 @@ class Solution {
 class Solution {
 public:
     long long countPairs(int n, vector<vector<int>>& edges) {
-        vector<vector<int>> g(n);
+        vector<int> g[n];
         for (auto& e : edges) {
             int a = e[0], b = e[1];
-            g[a].emplace_back(b);
-            g[b].emplace_back(a);
+            g[a].push_back(b);
+            g[b].push_back(a);
         }
-        vector<bool> vis(n);
-        function<int(int)> dfs = [&](int i) -> int {
+        bool vis[n];
+        memset(vis, 0, sizeof(vis));
+        function<int(int)> dfs = [&](int i) {
+            if (vis[i]) {
+                return 0;
+            }
             vis[i] = true;
             int cnt = 1;
             for (int j : g[i]) {
-                if (!vis[j]) {
-                    cnt += dfs(j);
-                }
+                cnt += dfs(j);
             }
             return cnt;
         };
         long long ans = 0, s = 0;
         for (int i = 0; i < n; ++i) {
-            if (!vis[i]) {
-                long long t = dfs(i);
-                ans += s * t;
-                s += t;
-            }
+            int t = dfs(i);
+            ans += s * t;
+            s += t;
         }
         return ans;
     }
@@ -179,22 +175,21 @@ func countPairs(n int, edges [][]int) (ans int64) {
 	vis := make([]bool, n)
 	var dfs func(int) int
 	dfs = func(i int) int {
+		if vis[i] {
+			return 0
+		}
 		vis[i] = true
 		cnt := 1
 		for _, j := range g[i] {
-			if !vis[j] {
-				cnt += dfs(j)
-			}
+			cnt += dfs(j)
 		}
 		return cnt
 	}
 	var s int64
 	for i := 0; i < n; i++ {
-		if !vis[i] {
-			t := int64(dfs(i))
-			ans += s * t
-			s += t
-		}
+		t := int64(dfs(i))
+		ans += s * t
+		s += t
 	}
 	return
 }
@@ -204,30 +199,28 @@ func countPairs(n int, edges [][]int) (ans int64) {
 
 ```ts
 function countPairs(n: number, edges: number[][]): number {
-    const g = Array.from({ length: n }, () => []);
+    const g: number[][] = Array.from({ length: n }, () => []);
     for (const [a, b] of edges) {
         g[a].push(b);
         g[b].push(a);
     }
-    const vis = new Array(n).fill(false);
-    const dfs = (i: number) => {
+    const vis: boolean[] = Array(n).fill(false);
+    const dfs = (i: number): number => {
+        if (vis[i]) {
+            return 0;
+        }
         vis[i] = true;
         let cnt = 1;
         for (const j of g[i]) {
-            if (!vis[j]) {
-                cnt += dfs(j);
-            }
+            cnt += dfs(j);
         }
         return cnt;
     };
-    let ans = 0;
-    let s = 0;
+    let [ans, s] = [0, 0];
     for (let i = 0; i < n; ++i) {
-        if (!vis[i]) {
-            const t = dfs(i);
-            ans += s * t;
-            s += t;
-        }
+        const t = dfs(i);
+        ans += s * t;
+        s += t;
     }
     return ans;
 }