https://leetcode.cn/problems/number-of-good-paths/

Author: masx200

README.md

@@ -10,6 +10,8 @@ leetcode 测试
 
 ##### 包含的内容如下
 
+https://leetcode.cn/problems/number-of-good-paths/
+
 https://leetcode.cn/problems/count-all-possible-routes/
 
 https://leetcode.cn/problems/sort-the-people/

largest-component-size-by-common-factor/UnionFind.ts

@@ -9,6 +9,9 @@ export class UnionFind<T = number> {
         }
         return this.#parents.get(x) ?? x;
     }
+    size(x: T): number {
+        return (this.#sizes.get(this.find(x)) ?? 1);
+    }
     connected(p: T, q: T): boolean {
         return this.find(p) == this.find(q);
     }

number-of-good-paths/index.ts

@@ -0,0 +1,41 @@
+import { UnionFind } from "../largest-component-size-by-common-factor/UnionFind.ts";
+function numberOfGoodPaths(vals: number[], edges: number[][]): number {
+    const n = vals.length;
+    const cnt = new Map<number, number[]>();
+
+    for (const [i, v] of vals.entries()) {
+        const arr = cnt.get(v) ?? [];
+        arr.push(i);
+        cnt.set(v, arr);
+    }
+    edges.sort((a, b) =>
+        Math.max(vals[a[0]], vals[a[1]]) - Math.max(vals[b[0]], vals[b[1]])
+    );
+    const uf = new UnionFind();
+    let ans = n;
+    let j = 0;
+
+    for (const [val, vec] of [...cnt.entries()].sort((a, b) => a[0] - b[0])) {
+        while (
+            j < edges.length && vals[edges[j][0]] <= val &&
+            vals[edges[j][1]] <= val
+        ) {
+            uf.union(edges[j][0], edges[j][1]);
+            j++;
+        }
+
+        const count = new Map<number, number>();
+
+        for (const v of vec) {
+            const key = uf.find(v);
+            count.set(key, (count.get(key) ?? 0) + 1);
+        }
+
+        ans += [...count.values()].reduce(
+            (p, c) => p + Math.floor(c * (c - 1) / 2),
+            0,
+        );
+    }
+    return ans;
+}
+export default numberOfGoodPaths;

number-of-good-paths/test.ts

@@ -0,0 +1,25 @@
+import { assertEquals } from "asserts";
+import numberOfGoodPaths from "./index.ts";
+Deno.test("number-of-good-paths", () => {
+    const inputs: [vals: number[], edges: number[][]][] = [
+        [[1, 3, 2, 1, 3], [[0, 1], [0, 2], [2, 3], [2, 4]]],
+        [[1, 1, 2, 2, 3], [[0, 1], [1, 2], [2, 3], [2, 4]]],
+        [[1], []],
+        [[2, 5, 5, 1, 5, 2, 3, 5, 1, 5], [
+            [0, 1],
+            [2, 1],
+            [3, 2],
+            [3, 4],
+            [3, 5],
+            [5, 6],
+            [1, 7],
+            [8, 4],
+            [
+                9,
+                7,
+            ],
+        ]],
+    ];
+    const outputs = [6, 7, 1, 20];
+    assertEquals(inputs.map((a) => numberOfGoodPaths(a[0], a[1])), outputs);
+});