https://leetcode.cn/problems/most-stones-removed-with-same-row-or-column

Author: masx200

README.md

@@ -882,6 +882,8 @@ https://leetcode.cn/problems/long-pressed-name/
 
 https://leetcode.cn/problems/three-steps-problem-lcci
 
+https://leetcode.cn/problems/most-stones-removed-with-same-row-or-column
+
 https://leetcode.cn/problems/o8SXZn
 
 https://leetcode.cn/problems/insert-delete-getrandom-o1-duplicates-allowed/

binary-tree-level-order-traversal/test.ts

@@ -0,0 +1,16 @@
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import { assertEquals } from "../deps.ts";
+import levelOrder from "./index.ts";
+
+Deno.test("binary-tree-level-order-traversal", () => {
+    const root = new TreeNode(3);
+    root.left = new TreeNode(9);
+    root.right = new TreeNode(20);
+    root.right.left = new TreeNode(15);
+    root.right.right = new TreeNode(7);
+    const result = levelOrder(root);
+    assertEquals(result, [[3], [9, 20], [15, 7]]);
+
+    assertEquals([[1]], levelOrder(new TreeNode(1)));
+    assertEquals([], levelOrder(null));
+});

complete-binary-tree-inserter/test.ts

@@ -0,0 +1,91 @@
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import { TreeNode } from "../binary-tree-inorder-traversal/TreeNode.ts";
+import levelOrder from "../binary-tree-level-order-traversal/index.ts";
+import { zip } from "../deps.ts";
+import CBTInserter from "./index.ts";
+
+Deno.test("complete-binary-tree-inserter-1", () => {
+    const root = new TreeNode(1, new TreeNode(2));
+    const cbt = new CBTInserter(root);
+
+    assertEquals(cbt.insert(3), 1);
+    assertEquals(cbt.insert(4), 2);
+
+    assertEquals(
+        cbt.get_root(),
+        new TreeNode(1, new TreeNode(2, new TreeNode(4)), new TreeNode(3)),
+    );
+});
+Deno.test("complete-binary-tree-inserter-2", () => {
+    const root = new TreeNode(1, new TreeNode(2));
+    const cbt = new CBTInserter(root);
+
+    assertEquals(cbt.insert(3), 1);
+    assertEquals(cbt.insert(4), 2);
+
+    assertEquals(
+        cbt.get_root(),
+        new TreeNode(1, new TreeNode(2, new TreeNode(4)), new TreeNode(3)),
+    );
+    assertEquals(cbt.insert(13), 2);
+    assertEquals(cbt.insert(14), 3);
+    assertEquals(cbt.insert(213), 3);
+    assertEquals(cbt.insert(124), 4);
+    assertEquals(cbt.insert(313), 4);
+    assertEquals(cbt.insert(134), 13);
+    assertEquals(
+        [1, 2, 3, 4, 13, 14, 213, 124, 313, 134],
+        levelOrder(cbt.get_root()).flat(),
+    );
+});
+Deno.test("complete-binary-tree-inserter-3", () => {
+    const data = zip(
+        [
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+            "insert",
+        ],
+        [
+            [2],
+            [3],
+            [4],
+            [5],
+            [6],
+            [7],
+            [8],
+            [9],
+            [10],
+            [11],
+            [12],
+            [13],
+            [14],
+            [15],
+            [16],
+        ],
+        [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8],
+    ) as [string, number[], number][];
+    const root = new TreeNode(1);
+    const cbt = new CBTInserter(root);
+    for (const [target, args, result] of data) {
+        assertEquals(
+            Reflect.apply(Reflect.get(cbt, target), cbt, args),
+            result,
+        );
+    }
+    assertEquals(
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],
+        levelOrder(cbt.get_root()).flat(),
+    );
+});

most-stones-removed-with-same-row-or-column/index.ts

@@ -0,0 +1,56 @@
+export default function removeStones(stones: [number, number][]): number {
+    const parent_row = new Map<number, Set<[row: number, col: number]>>();
+    const parent_col = new Map<number, Set<[row: number, col: number]>>();
+
+    function merge(
+        ar: [row: number, col: number],
+        rp: Set<[row: number, col: number]>,
+    ) {
+        parent_row.set(ar[0], rp);
+
+        parent_col.set(ar[1], rp);
+        rp.add(ar);
+    }
+
+    for (const stone of stones) {
+        const [row, col] = stone;
+
+        const rp = parent_row.get(row);
+        const cp = parent_col.get(col);
+
+        if ((parent_row.has(row) || parent_col.has(col)) && rp || cp) {
+            if (rp === cp && cp && rp) {
+                merge(stone, rp);
+            } else {
+                combine(stone, rp, cp);
+            }
+        } else {
+            create(stone, row, col);
+        }
+    }
+
+    function create(stone: [number, number], row: number, col: number) {
+        const set = new Set([stone]);
+        parent_row.set(row, set);
+
+        parent_col.set(col, set);
+    }
+    function combine(
+        stone: [number, number],
+        rp: Set<[row: number, col: number]> | undefined,
+        cp: Set<[row: number, col: number]> | undefined,
+    ) {
+        const series: Set<[row: number, col: number]> = rp || cp || new Set();
+
+        cp?.forEach((s) => series.add(s));
+        rp?.forEach((s) => series.add(s));
+        merge(stone, series);
+
+        series.forEach(([row, col]) => {
+            parent_col.set(col, series);
+            parent_row.set(row, series);
+        });
+    }
+    return stones.length -
+        new Set([...parent_col.values(), ...parent_row.values()]).size;
+}

most-stones-removed-with-same-row-or-column/test.ts

@@ -0,0 +1,35 @@
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import removeStones from "./index.ts";
+
+Deno.test("most-stones-removed-with-same-row-or-column", () => {
+    assertEquals(
+        5,
+        removeStones([
+            [0, 0],
+            [0, 1],
+            [1, 0],
+            [1, 2],
+            [2, 1],
+            [2, 2],
+        ]),
+    );
+    assertEquals(0, removeStones([[0, 0]]));
+    assertEquals(
+        2,
+        removeStones([
+            [0, 1],
+            [1, 0],
+            [1, 1],
+        ]),
+    );
+    assertEquals(
+        3,
+        removeStones([
+            [0, 0],
+            [0, 2],
+            [1, 1],
+            [2, 0],
+            [2, 2],
+        ]),
+    );
+});