feat: add solutions to lc problem: No.2581 (doocs#2378)

No.2581.Count Number of Possible Root Nodes

Author: yanglbme

solution/2500-2599/2581.Count Number of Possible Root Nodes/README.md

@@ -194,7 +194,7 @@ class Solution {
 public:
     int rootCount(vector<vector<int>>& edges, vector<vector<int>>& guesses, int k) {
         int n = edges.size() + 1;
-        vector<vector<int>> g(n);
+        vector<int> g[n];
         unordered_map<long long, int> gs;
         auto f = [&](int i, int j) {
             return 1LL * i * n + j;
@@ -291,6 +291,50 @@ func rootCount(edges [][]int, guesses [][]int, k int) (ans int) {
 }
 ```
 
+```ts
+function rootCount(edges: number[][], guesses: number[][], k: number): number {
+    const n = edges.length + 1;
+    const g: number[][] = Array.from({ length: n }, () => []);
+    const gs: Map<number, number> = new Map();
+    const f = (i: number, j: number) => i * n + j;
+    for (const [a, b] of edges) {
+        g[a].push(b);
+        g[b].push(a);
+    }
+    for (const [a, b] of guesses) {
+        const x = f(a, b);
+        gs.set(x, gs.has(x) ? gs.get(x)! + 1 : 1);
+    }
+    let ans = 0;
+    let cnt = 0;
+    const dfs1 = (i: number, fa: number): void => {
+        for (const j of g[i]) {
+            if (j !== fa) {
+                cnt += gs.get(f(i, j)) || 0;
+                dfs1(j, i);
+            }
+        }
+    };
+    const dfs2 = (i: number, fa: number): void => {
+        ans += cnt >= k ? 1 : 0;
+        for (const j of g[i]) {
+            if (j !== fa) {
+                const a = gs.get(f(i, j)) || 0;
+                const b = gs.get(f(j, i)) || 0;
+                cnt -= a;
+                cnt += b;
+                dfs2(j, i);
+                cnt -= b;
+                cnt += a;
+            }
+        }
+    };
+    dfs1(0, -1);
+    dfs2(0, -1);
+    return ans;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/2500-2599/2581.Count Number of Possible Root Nodes/README_EN.md

@@ -188,7 +188,7 @@ class Solution {
 public:
     int rootCount(vector<vector<int>>& edges, vector<vector<int>>& guesses, int k) {
         int n = edges.size() + 1;
-        vector<vector<int>> g(n);
+        vector<int> g[n];
         unordered_map<long long, int> gs;
         auto f = [&](int i, int j) {
             return 1LL * i * n + j;
@@ -285,6 +285,50 @@ func rootCount(edges [][]int, guesses [][]int, k int) (ans int) {
 }
 ```
 
+```ts
+function rootCount(edges: number[][], guesses: number[][], k: number): number {
+    const n = edges.length + 1;
+    const g: number[][] = Array.from({ length: n }, () => []);
+    const gs: Map<number, number> = new Map();
+    const f = (i: number, j: number) => i * n + j;
+    for (const [a, b] of edges) {
+        g[a].push(b);
+        g[b].push(a);
+    }
+    for (const [a, b] of guesses) {
+        const x = f(a, b);
+        gs.set(x, gs.has(x) ? gs.get(x)! + 1 : 1);
+    }
+    let ans = 0;
+    let cnt = 0;
+    const dfs1 = (i: number, fa: number): void => {
+        for (const j of g[i]) {
+            if (j !== fa) {
+                cnt += gs.get(f(i, j)) || 0;
+                dfs1(j, i);
+            }
+        }
+    };
+    const dfs2 = (i: number, fa: number): void => {
+        ans += cnt >= k ? 1 : 0;
+        for (const j of g[i]) {
+            if (j !== fa) {
+                const a = gs.get(f(i, j)) || 0;
+                const b = gs.get(f(j, i)) || 0;
+                cnt -= a;
+                cnt += b;
+                dfs2(j, i);
+                cnt -= b;
+                cnt += a;
+            }
+        }
+    };
+    dfs1(0, -1);
+    dfs2(0, -1);
+    return ans;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- end -->

solution/2500-2599/2581.Count Number of Possible Root Nodes/Solution.cpp

@@ -2,7 +2,7 @@ class Solution {
 public:
     int rootCount(vector<vector<int>>& edges, vector<vector<int>>& guesses, int k) {
         int n = edges.size() + 1;
-        vector<vector<int>> g(n);
+        vector<int> g[n];
         unordered_map<long long, int> gs;
         auto f = [&](int i, int j) {
             return 1LL * i * n + j;

solution/2500-2599/2581.Count Number of Possible Root Nodes/Solution.ts

@@ -0,0 +1,41 @@
+function rootCount(edges: number[][], guesses: number[][], k: number): number {
+    const n = edges.length + 1;
+    const g: number[][] = Array.from({ length: n }, () => []);
+    const gs: Map<number, number> = new Map();
+    const f = (i: number, j: number) => i * n + j;
+    for (const [a, b] of edges) {
+        g[a].push(b);
+        g[b].push(a);
+    }
+    for (const [a, b] of guesses) {
+        const x = f(a, b);
+        gs.set(x, gs.has(x) ? gs.get(x)! + 1 : 1);
+    }
+    let ans = 0;
+    let cnt = 0;
+    const dfs1 = (i: number, fa: number): void => {
+        for (const j of g[i]) {
+            if (j !== fa) {
+                cnt += gs.get(f(i, j)) || 0;
+                dfs1(j, i);
+            }
+        }
+    };
+    const dfs2 = (i: number, fa: number): void => {
+        ans += cnt >= k ? 1 : 0;
+        for (const j of g[i]) {
+            if (j !== fa) {
+                const a = gs.get(f(i, j)) || 0;
+                const b = gs.get(f(j, i)) || 0;
+                cnt -= a;
+                cnt += b;
+                dfs2(j, i);
+                cnt -= b;
+                cnt += a;
+            }
+        }
+    };
+    dfs1(0, -1);
+    dfs2(0, -1);
+    return ans;
+}