https://leetcode.cn/problems/longest-string-chain/

Author: masx200

README.md

@@ -10,6 +10,8 @@ leetcode 测试
 
 ##### 包含的内容如下
 
+https://leetcode.cn/problems/longest-string-chain/
+
 https://leetcode.cn/problems/add-two-polynomials-represented-as-linked-lists/
 
 https://leetcode.cn/problems/print-immutable-linked-list-in-reverse/

add-two-polynomials-represented-as-linked-lists/test.ts

@@ -1,46 +1,46 @@
-import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
-import addPoly from "./index.ts";
-import { ArrayToPolyNode } from "./ArrayToPolyNode.ts";
-import { PolyNodeToArray } from "./PolyNodeToArray.ts";
-Deno.test("add-two-polynomials-represented-as-linked-lists", () => {
-    const cases = [
-        [[[1, 2]], [[-1, 2]], []],
-        [
-            [
-                [2, 2],
-                [4, 1],
-                [3, 0],
-            ],
-
-            [
-                [3, 2],
-                [-4, 1],
-                [-1, 0],
-            ],
-            [
-                [5, 2],
-                [2, 0],
-            ],
-        ],
-        [
-            [[1, 1]],
-            [[1, 0]],
-            [
-                [1, 1],
-                [1, 0],
-            ],
-        ],
-    ];
-
-    cases.forEach(([a, b, c]) => {
-        assertEquals(
-            c,
-            PolyNodeToArray(
-                addPoly(
-                    ArrayToPolyNode(a as [number, number][]),
-                    ArrayToPolyNode(b as [number, number][])
-                )
-            )
-        );
-    });
-});
+import { assertEquals } from "https://deno.land/[email protected]/testing/asserts.ts";
+import addPoly from "./index.ts";
+import { ArrayToPolyNode } from "./ArrayToPolyNode.ts";
+import { PolyNodeToArray } from "./PolyNodeToArray.ts";
+Deno.test("add-two-polynomials-represented-as-linked-lists", () => {
+    const cases = [
+        [[[1, 2]], [[-1, 2]], []],
+        [
+            [
+                [2, 2],
+                [4, 1],
+                [3, 0],
+            ],
+
+            [
+                [3, 2],
+                [-4, 1],
+                [-1, 0],
+            ],
+            [
+                [5, 2],
+                [2, 0],
+            ],
+        ],
+        [
+            [[1, 1]],
+            [[1, 0]],
+            [
+                [1, 1],
+                [1, 0],
+            ],
+        ],
+    ];
+
+    cases.forEach(([a, b, c]) => {
+        assertEquals(
+            c,
+            PolyNodeToArray(
+                addPoly(
+                    ArrayToPolyNode(a as [number, number][]),
+                    ArrayToPolyNode(b as [number, number][]),
+                ),
+            ),
+        );
+    });
+});

longest-string-chain/index.ts

@@ -0,0 +1,43 @@
+export default function longestStrChain(words: string[]): number {
+    const map = new Map<number, Set<number>>();
+    let res = 1;
+    words.sort((a, b) => a.length - b.length);
+    words.forEach((i, idx) => {
+        const set = map.get(i.length) ?? new Set();
+        if (!map.has(i.length)) map.set(i.length, set);
+        set.add(idx);
+    });
+
+    const dp: number[] = words.map(() => 1);
+    for (let i = 0; i < dp.length; i++) {
+        const set = map.get(words[i].length - 1);
+        if (set) {
+            for (const idx of set) {
+                if (can(words[idx], words[i])) {
+                    dp[i] = Math.max(dp[i], dp[idx] + 1);
+                }
+                res = Math.max(res, dp[i]);
+            }
+        }
+    }
+    return res;
+}
+function can(s1: string, s2: string) {
+    // abc
+    // adbc
+    let c1 = 0,
+        c2 = 0;
+    let wrong = 0;
+    while (c1 < s1.length) {
+        if (s1[c1] !== s2[c2]) {
+            wrong += 1;
+            if (wrong > 1) return false;
+            c2 += 1;
+        }
+        if (s1[c1] === s2[c2]) {
+            c1 += 1;
+            c2 += 1;
+        }
+    }
+    return true;
+}