https://leetcode.cn/problems/largest-component-size-by-common-factor https://leetcode.cn/problems/maximum-level-sum-of-a-binary-tree/

Author: masx200

README.md

@@ -10,6 +10,10 @@ leetcode 测试
 
 ##### 包含的内容如下
 
+https://leetcode.cn/problems/largest-component-size-by-common-factor
+
+https://leetcode.cn/problems/maximum-level-sum-of-a-binary-tree/
+
 https://leetcode.cn/problems/valid-square/
 
 https://leetcode.cn/problems/wildcard-matching

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

@@ -0,0 +1,80 @@
+function largestComponentSize(nums: number[]) {
+    // const max = Math.max(...nums);
+    const uf = new UnionFind(/*max + 1*/);
+    for (let n of nums) {
+        const temp = n;
+        for (let i = 2; i <= n / i; i++) {
+            let flag = false;
+            while (n % i === 0) {
+                n /= i;
+                flag = true;
+            }
+            if (flag) {
+                uf.union(temp, i);
+            }
+        }
+        if (n > 1) {
+            uf.union(n, temp);
+        }
+    }
+
+    const count: Map<number, number> = new Map();
+    let res = 0;
+    for (const n of nums) {
+        const p = uf.find(n);
+        //  if (!count[p]) count[p] = 0;
+        //   count[p]++;
+
+        count.set(p, (count.get(p) ?? 0) + 1);
+        res = Math.max(res, count.get(p) ?? 0);
+    }
+
+    return res;
+}
+
+class UnionFind {
+    sizes: Map<number, number> = new Map();
+    parents: Map<number, number> = new Map();
+    constructor(/*size:number*/) {
+        // 初始化数组，其值为其索引值
+        /* this.parents = Array(size)
+             .fill(0)
+             .map((_, i) => i);
+         this.sizes = Array(size).fill(1);
+         */
+    }
+
+    /**
+     * 返回某个节点x的根节点
+     */
+    find(x: number) {
+        if (x !== (this.parents.get(x) ?? x)) {
+            this.parents.set(x, this.find(this.parents.get(x) ?? x));
+        }
+        return this.parents.get(x) ?? x;
+    }
+
+    /**
+     * 连接
+     */
+    union(a: number, b: number) {
+        const fa = this.find(a);
+        const fb = this.find(b);
+        if (fa == fb) {
+            return;
+        }
+        const sa = this.sizes.get(fa) ?? 1;
+        const sb = this.sizes.get(fb) ?? 1;
+
+        if (sa < sb) {
+            this.parents.set(fa, fb);
+            // fb是root
+            this.sizes.set(fb, sb + sa);
+        } else {
+            this.parents.set(fb, fa);
+            // fa是root
+            this.sizes.set(fa, sb + sa);
+        }
+    }
+}
+export default largestComponentSize;

maximum-level-sum-of-a-binary-tree/index.ts

@@ -0,0 +1,19 @@
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { level } from "../binary-tree-level-order-traversal-ii/level.ts";
+
+function maxLevelSum(root: TreeNode | null): number {
+    if (!root) return 0;
+    const current: TreeNode[] = [root];
+    const result: number[] = [];
+
+    level(current, (r) => result.push(r.reduce((a, b) => a + b)));
+
+    const sums = result;
+
+    const max_entries = Array.from(sums.entries()).reduceRight((a, v) =>
+        a[1] > v[1] ? a : v
+    );
+    return max_entries[0] + 1;
+}
+
+export default maxLevelSum;

wildcard-matching/index.ts

@@ -42,15 +42,15 @@ function check_fixs(s: string, words: string[]): boolean {
         if (suffix) {
             const matched = str.match(
                 //@ts-ignore
-                new RegExp(`^(.*?)${suffix.replaceAll("?", ".")}$`)
+                new RegExp(`^(.*?)${suffix.replaceAll("?", ".")}$`),
             );
             if (!matched) return false;
             str = matched[1];
         }
         if (prefix) {
             const matched = str.match(
                 //@ts-ignore
-                new RegExp(`^${prefix.replaceAll("?", ".")}(.*?)$`)
+                new RegExp(`^${prefix.replaceAll("?", ".")}(.*?)$`),
             );
             if (!matched) return false;
             str = matched[1];
@@ -65,21 +65,21 @@ function check_regular(s: string, p: string): boolean {
     return new RegExp(
         //@ts-ignore
         "^" + p.replaceAll("?", ".").replaceAll(/\*+/g, ".*") + "$",
-        "g"
+        "g",
     ).test(s);
 }
 function check_words(s: string, words: string[]): boolean {
     // console.log("check_words", s, words);
     if (words.length === 0) return true;
     const mid_index = words.reduce(
         (a, v, i) => (v.length > words[a].length ? i : a),
-        Math.floor(words.length / 2)
+        Math.floor(words.length / 2),
     );
     // const mid_index = Math.floor(words.length / 2);
     const middle = words[mid_index];
     const matched_array = Array.from(
         //@ts-ignore
-        s.matchAll(new RegExp(`${middle.replaceAll("?", ".")}`, "g"))
+        s.matchAll(new RegExp(`${middle.replaceAll("?", ".")}`, "g")),
     );
 
     // console.log(matched_array);