feat: add solutions to lc problems: No.0072,1143

* No.0072.Edit Distance
* No.1143.Longest Common Subsequence

Author: yanglbme

solution/0000-0099/0072.Edit Distance/README.md

@@ -57,7 +57,7 @@ exection -> execution (插入 'u')
 
 **方法一：动态规划**
 
-我们定义 $f[i][j]$ 表示将 $word1$ 的前 $i$ 个字符转换成 $word2$ 的前 $j$ 个字符所使用的最少操作数。初始时 $f[i][0] = i$, f[0][j] = j$。其中 $i \in [1, m], j \in [0, n]$。
+我们定义 $f[i][j]$ 表示将 $word1$ 的前 $i$ 个字符转换成 $word2$ 的前 $j$ 个字符所使用的最少操作数。初始时 $f[i][0] = i$, $f[0][j] = j$。其中 $i \in [1, m], j \in [0, n]$。
 
 考虑 $f[i][j]$：
 
@@ -215,6 +215,38 @@ function minDistance(word1: string, word2: string): number {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var minDistance = function (word1, word2) {
+    const m = word1.length;
+    const n = word2.length;
+    const f = Array(m + 1)
+        .fill(0)
+        .map(() => Array(n + 1).fill(0));
+    for (let j = 1; j <= n; ++j) {
+        f[0][j] = j;
+    }
+    for (let i = 1; i <= m; ++i) {
+        f[i][0] = i;
+        for (let j = 1; j <= n; ++j) {
+            if (word1[i - 1] === word2[j - 1]) {
+                f[i][j] = f[i - 1][j - 1];
+            } else {
+                f[i][j] =
+                    Math.min(f[i - 1][j], f[i][j - 1], f[i - 1][j - 1]) + 1;
+            }
+        }
+    }
+    return f[m][n];
+};
+```
+
 ### **...**
 
 ```

solution/0000-0099/0072.Edit Distance/README_EN.md

@@ -49,7 +49,29 @@ exection -> execution (insert 'u')
 
 ## Solutions
 
-Dynamic programming.
+**Solution 1: Dynamic Programming**
+
+We define $f[i][j]$ as the minimum number of operations to convert $word1$ of length $i$ to $word2$ of length $j$. $f[i][0] = i$, $f[0][j] = j$, $i \in [1, m], j \in [0, n]$.
+
+We consider $f[i][j]$:
+
+-   If $word1[i - 1] = word2[j - 1]$, then we only need to consider the minimum number of operations to convert $word1$ of length $i - 1$ to $word2$ of length $j - 1$, so $f[i][j] = f[i - 1][j - 1]$;
+-   Otherwise, we can consider insert, delete, and replace operations, then $f[i][j] = \min(f[i - 1][j], f[i][j - 1], f[i - 1][j - 1]) + 1$.
+
+Finally, we can get the state transition equation:
+
+$$
+f[i][j] = \begin{cases}
+i, & \text{if } j = 0 \\
+j, & \text{if } i = 0 \\
+f[i - 1][j - 1], & \text{if } word1[i - 1] = word2[j - 1] \\
+\min(f[i - 1][j], f[i][j - 1], f[i - 1][j - 1]) + 1, & \text{otherwise}
+\end{cases}
+$$
+
+Finally, we return $f[m][n]$.
+
+The time complexity is $O(m \times n)$, and the space complexity is $O(m \times n)$. $m$ and $n$ are the lengths of $word1$ and $word2$ respectively.
 
 <!-- tabs:start -->
 
@@ -183,6 +205,38 @@ function minDistance(word1: string, word2: string): number {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var minDistance = function (word1, word2) {
+    const m = word1.length;
+    const n = word2.length;
+    const f = Array(m + 1)
+        .fill(0)
+        .map(() => Array(n + 1).fill(0));
+    for (let j = 1; j <= n; ++j) {
+        f[0][j] = j;
+    }
+    for (let i = 1; i <= m; ++i) {
+        f[i][0] = i;
+        for (let j = 1; j <= n; ++j) {
+            if (word1[i - 1] === word2[j - 1]) {
+                f[i][j] = f[i - 1][j - 1];
+            } else {
+                f[i][j] =
+                    Math.min(f[i - 1][j], f[i][j - 1], f[i - 1][j - 1]) + 1;
+            }
+        }
+    }
+    return f[m][n];
+};
+```
+
 ### **...**
 
 ```

solution/0000-0099/0072.Edit Distance/Solution.js

@@ -0,0 +1,27 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var minDistance = function (word1, word2) {
+    const m = word1.length;
+    const n = word2.length;
+    const f = Array(m + 1)
+        .fill(0)
+        .map(() => Array(n + 1).fill(0));
+    for (let j = 1; j <= n; ++j) {
+        f[0][j] = j;
+    }
+    for (let i = 1; i <= m; ++i) {
+        f[i][0] = i;
+        for (let j = 1; j <= n; ++j) {
+            if (word1[i - 1] === word2[j - 1]) {
+                f[i][j] = f[i - 1][j - 1];
+            } else {
+                f[i][j] =
+                    Math.min(f[i - 1][j], f[i][j - 1], f[i - 1][j - 1]) + 1;
+            }
+        }
+    }
+    return f[m][n];
+};

solution/1100-1199/1143.Longest Common Subsequence/README.md

@@ -65,7 +65,7 @@ $$
 f[i][j] =
 \begin{cases}
 f[i - 1][j - 1] + 1, & text1[i - 1] = text2[j - 1] \\
-max(f[i - 1][j], f[i][j - 1]), & text1[i - 1] \neq text2[j - 1]
+\max(f[i - 1][j], f[i][j - 1]), & text1[i - 1] \neq text2[j - 1]
 \end{cases}
 $$
 
@@ -254,6 +254,28 @@ public class Solution {
 }
 ```
 
+### **Kotlin**
+
+```kotlin
+class Solution {
+    fun longestCommonSubsequence(text1: String, text2: String): Int {
+        val m = text1.length
+        val n = text2.length
+        val f = Array(m + 1) { IntArray(n + 1) }
+        for (i in 1..m) {
+            for (j in 1..n) {
+                if (text1[i - 1] == text2[j - 1]) {
+                    f[i][j] = f[i - 1][j - 1] + 1
+                } else {
+                    f[i][j] = Math.max(f[i - 1][j], f[i][j - 1])
+                }
+            }
+        }
+        return f[m][n]
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1100-1199/1143.Longest Common Subsequence/README_EN.md

@@ -49,16 +49,22 @@
 
 ## Solutions
 
-Dynamic programming.
+**Solution 1: Dynamic Programming**
+
+Let $f[i][j]$ be the length of the longest common subsequence of $text1$ and $text2$ with length $i$ and $j$, respectively. The answer is $f[m][n]$, where $m$ and $n$ are the lengths of $text1$ and $text2$, respectively.
+
+If the $i$-th character of $text1$ and the $j$-th character of $text2$ are the same, then $f[i][j] = f[i - 1][j - 1] + 1$; if the $i$-th character of $text1$ and the $j$-th character of $text2$ are different, then $f[i][j] = max(f[i - 1][j], f[i][j - 1])$. That is, the state transition equation is:
 
 $$
 f[i][j] =
 \begin{cases}
 f[i - 1][j - 1] + 1, & text1[i - 1] = text2[j - 1] \\
-max(f[i - 1][j], f[i][j - 1]), & text1[i - 1] \neq text2[j - 1]
+\max(f[i - 1][j], f[i][j - 1]), & text1[i - 1] \neq text2[j - 1]
 \end{cases}
 $$
 
+Time complexity $O(m \times n)$, space complexity $O(m \times n)$. Where $m$ and $n$ are the lengths of $text1$ and $text2$, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -238,6 +244,28 @@ public class Solution {
 }
 ```
 
+### **Kotlin**
+
+```kotlin
+class Solution {
+    fun longestCommonSubsequence(text1: String, text2: String): Int {
+        val m = text1.length
+        val n = text2.length
+        val f = Array(m + 1) { IntArray(n + 1) }
+        for (i in 1..m) {
+            for (j in 1..n) {
+                if (text1[i - 1] == text2[j - 1]) {
+                    f[i][j] = f[i - 1][j - 1] + 1
+                } else {
+                    f[i][j] = Math.max(f[i - 1][j], f[i][j - 1])
+                }
+            }
+        }
+        return f[m][n]
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1100-1199/1143.Longest Common Subsequence/Solution.kt

@@ -0,0 +1,17 @@
+class Solution {
+    fun longestCommonSubsequence(text1: String, text2: String): Int {
+        val m = text1.length
+        val n = text2.length
+        val f = Array(m + 1) { IntArray(n + 1) }
+        for (i in 1..m) {
+            for (j in 1..n) {
+                if (text1[i - 1] == text2[j - 1]) {
+                    f[i][j] = f[i - 1][j - 1] + 1
+                } else {
+                    f[i][j] = Math.max(f[i - 1][j], f[i][j - 1])
+                }
+            }
+        }
+        return f[m][n]
+    }
+}

solution/1100-1199/1144.Decrease Elements To Make Array Zigzag/README.md

@@ -49,7 +49,7 @@
 
 我们可以分别枚举偶数位和奇数位作为“比相邻元素小”的元素，然后计算需要的操作次数。取两者的最小值即可。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组 $nums$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->