feat: add solutions to lc problem: No.1039

No.1039.Minimum Score Triangulation of Polygon

Author: yanglbme

solution/1000-1099/1039.Minimum Score Triangulation of Polygon/README.md

@@ -367,6 +367,78 @@ func min(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minScoreTriangulation(values: number[]): number {
+    const n = values.length;
+    const f: number[][] = Array.from({ length: n }, () =>
+        Array.from({ length: n }, () => 0),
+    );
+    const dfs = (i: number, j: number): number => {
+        if (i + 1 === j) {
+            return 0;
+        }
+        if (f[i][j] > 0) {
+            return f[i][j];
+        }
+        let ans = 1 << 30;
+        for (let k = i + 1; k < j; ++k) {
+            ans = Math.min(
+                ans,
+                dfs(i, k) + dfs(k, j) + values[i] * values[k] * values[j],
+            );
+        }
+        f[i][j] = ans;
+        return ans;
+    };
+    return dfs(0, n - 1);
+}
+```
+
+```ts
+function minScoreTriangulation(values: number[]): number {
+    const n = values.length;
+    const f: number[][] = Array.from({ length: n }, () =>
+        Array.from({ length: n }, () => 0),
+    );
+    for (let i = n - 3; i >= 0; --i) {
+        for (let j = i + 2; j < n; ++j) {
+            f[i][j] = 1 << 30;
+            for (let k = i + 1; k < j; ++k) {
+                f[i][j] = Math.min(
+                    f[i][j],
+                    f[i][k] + f[k][j] + values[i] * values[k] * values[j],
+                );
+            }
+        }
+    }
+    return f[0][n - 1];
+}
+```
+
+```ts
+function minScoreTriangulation(values: number[]): number {
+    const n = values.length;
+    const f: number[][] = Array.from({ length: n }, () =>
+        Array.from({ length: n }, () => 0),
+    );
+    for (let l = 3; l <= n; ++l) {
+        for (let i = 0; i + l - 1 < n; ++i) {
+            const j = i + l - 1;
+            f[i][j] = 1 << 30;
+            for (let k = i + 1; k < j; ++k) {
+                f[i][j] = Math.min(
+                    f[i][j],
+                    f[i][k] + f[k][j] + values[i] * values[k] * values[j],
+                );
+            }
+        }
+    }
+    return f[0][n - 1];
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1039.Minimum Score Triangulation of Polygon/README_EN.md

@@ -301,6 +301,78 @@ func min(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minScoreTriangulation(values: number[]): number {
+    const n = values.length;
+    const f: number[][] = Array.from({ length: n }, () =>
+        Array.from({ length: n }, () => 0),
+    );
+    const dfs = (i: number, j: number): number => {
+        if (i + 1 === j) {
+            return 0;
+        }
+        if (f[i][j] > 0) {
+            return f[i][j];
+        }
+        let ans = 1 << 30;
+        for (let k = i + 1; k < j; ++k) {
+            ans = Math.min(
+                ans,
+                dfs(i, k) + dfs(k, j) + values[i] * values[k] * values[j],
+            );
+        }
+        f[i][j] = ans;
+        return ans;
+    };
+    return dfs(0, n - 1);
+}
+```
+
+```ts
+function minScoreTriangulation(values: number[]): number {
+    const n = values.length;
+    const f: number[][] = Array.from({ length: n }, () =>
+        Array.from({ length: n }, () => 0),
+    );
+    for (let i = n - 3; i >= 0; --i) {
+        for (let j = i + 2; j < n; ++j) {
+            f[i][j] = 1 << 30;
+            for (let k = i + 1; k < j; ++k) {
+                f[i][j] = Math.min(
+                    f[i][j],
+                    f[i][k] + f[k][j] + values[i] * values[k] * values[j],
+                );
+            }
+        }
+    }
+    return f[0][n - 1];
+}
+```
+
+```ts
+function minScoreTriangulation(values: number[]): number {
+    const n = values.length;
+    const f: number[][] = Array.from({ length: n }, () =>
+        Array.from({ length: n }, () => 0),
+    );
+    for (let l = 3; l <= n; ++l) {
+        for (let i = 0; i + l - 1 < n; ++i) {
+            const j = i + l - 1;
+            f[i][j] = 1 << 30;
+            for (let k = i + 1; k < j; ++k) {
+                f[i][j] = Math.min(
+                    f[i][j],
+                    f[i][k] + f[k][j] + values[i] * values[k] * values[j],
+                );
+            }
+        }
+    }
+    return f[0][n - 1];
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1039.Minimum Score Triangulation of Polygon/Solution.ts

@@ -0,0 +1,19 @@
+function minScoreTriangulation(values: number[]): number {
+    const n = values.length;
+    const f: number[][] = Array.from({ length: n }, () =>
+        Array.from({ length: n }, () => 0),
+    );
+    for (let l = 3; l <= n; ++l) {
+        for (let i = 0; i + l - 1 < n; ++i) {
+            const j = i + l - 1;
+            f[i][j] = 1 << 30;
+            for (let k = i + 1; k < j; ++k) {
+                f[i][j] = Math.min(
+                    f[i][j],
+                    f[i][k] + f[k][j] + values[i] * values[k] * values[j],
+                );
+            }
+        }
+    }
+    return f[0][n - 1];
+}