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

* No.1143.Longest Common Subsequence
* No.1144.Decrease Elements To Make Array Zigzag

Author: yanglbme

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

@@ -57,13 +57,19 @@
 
 **方法一：动态规划**
 
-定义 `dp[i][j]` 表示 `text1[0:i-1]` 和 `text2[0:j-1]` 的最长公共子序列（闭区间）。
+我们定义 $f[i][j]$ 表示 $text1$ 的前 $i$ 个字符和 $text2$ 的前 $j$ 个字符的最长公共子序列的长度。那么答案为 $f[m][n]$，其中 $m$ 和 $n$ 分别为 $text1$ 和 $text2$ 的长度。
 
-递推公式如下：
+如果 $text1$ 的第 $i$ 个字符和 $text2$ 的第 $j$ 个字符相同，则 $f[i][j] = f[i - 1][j - 1] + 1$；如果 $text1$ 的第 $i$ 个字符和 $text2$ 的第 $j$ 个字符不同，则 $f[i][j] = max(f[i - 1][j], f[i][j - 1])$。即状态转移方程为：
 
-![](https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1100-1199/1143.Longest%20Common%20Subsequence/images/CodeCogsEqn.gif)
+$$
+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]
+\end{cases}
+$$
 
-时间复杂度：$O(mn)$。
+时间复杂度 $O(m \times n)$，空间复杂度 $O(m \times n)$。其中 $m$ 和 $n$ 分别为 $text1$ 和 $text2$ 的长度。
 
 <!-- tabs:start -->
 
@@ -75,14 +81,14 @@
 class Solution:
     def longestCommonSubsequence(self, text1: str, text2: str) -> int:
         m, n = len(text1), len(text2)
-        dp = [[0] * (n + 1) for _ in range(m + 1)]
+        f = [[0] * (n + 1) for _ in range(m + 1)]
         for i in range(1, m + 1):
             for j in range(1, n + 1):
                 if text1[i - 1] == text2[j - 1]:
-                    dp[i][j] = dp[i - 1][j - 1] + 1
+                    f[i][j] = f[i - 1][j - 1] + 1
                 else:
-                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
-        return dp[-1][-1]
+                    f[i][j] = max(f[i - 1][j], f[i][j - 1])
+        return f[m][n]
 ```
 
 ### **Java**
@@ -93,17 +99,17 @@ class Solution:
 class Solution {
     public int longestCommonSubsequence(String text1, String text2) {
         int m = text1.length(), n = text2.length();
-        int[][] dp = new int[m + 1][n + 1];
+        int[][] f = new int[m + 1][n + 1];
         for (int i = 1; i <= m; ++i) {
             for (int j = 1; j <= n; ++j) {
                 if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
-                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                    f[i][j] = f[i - 1][j - 1] + 1;
                 } else {
-                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                    f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
                 }
             }
         }
-        return dp[m][n];
+        return f[m][n];
     }
 }
 ```
@@ -115,16 +121,18 @@ class Solution {
 public:
     int longestCommonSubsequence(string text1, string text2) {
         int m = text1.size(), n = text2.size();
-        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
+        int f[m + 1][n + 1];
+        memset(f, 0, sizeof f);
         for (int i = 1; i <= m; ++i) {
             for (int j = 1; j <= n; ++j) {
-                if (text1[i - 1] == text2[j - 1])
-                    dp[i][j] = dp[i - 1][j - 1] + 1;
-                else
-                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
+                if (text1[i - 1] == text2[j - 1]) {
+                    f[i][j] = f[i - 1][j - 1] + 1;
+                } else {
+                    f[i][j] = max(f[i - 1][j], f[i][j - 1]);
+                }
             }
         }
-        return dp[m][n];
+        return f[m][n];
     }
 };
 ```
@@ -134,20 +142,20 @@ public:
 ```go
 func longestCommonSubsequence(text1 string, text2 string) int {
 	m, n := len(text1), len(text2)
-	dp := make([][]int, m+1)
-	for i := 0; i <= m; i++ {
-		dp[i] = make([]int, n+1)
+	f := make([][]int, m+1)
+	for i := range f {
+		f[i] = make([]int, n+1)
 	}
 	for i := 1; i <= m; i++ {
 		for j := 1; j <= n; j++ {
 			if text1[i-1] == text2[j-1] {
-				dp[i][j] = dp[i-1][j-1] + 1
+				f[i][j] = f[i-1][j-1] + 1
 			} else {
-				dp[i][j] = max(dp[i-1][j], dp[i][j-1])
+				f[i][j] = max(f[i-1][j], f[i][j-1])
 			}
 		}
 	}
-	return dp[m][n]
+	return f[m][n]
 }
 
 func max(a, b int) int {
@@ -169,17 +177,17 @@ func max(a, b int) int {
 var longestCommonSubsequence = function (text1, text2) {
     const m = text1.length;
     const n = text2.length;
-    const dp = new Array(m + 1).fill(0).map(() => new Array(n + 1).fill(0));
+    const f = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
     for (let i = 1; i <= m; ++i) {
         for (let j = 1; j <= n; ++j) {
             if (text1[i - 1] == text2[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
+                f[i][j] = f[i - 1][j - 1] + 1;
             } else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
             }
         }
     }
-    return dp[m][n];
+    return f[m][n];
 };
 ```
 
@@ -189,17 +197,17 @@ var longestCommonSubsequence = function (text1, text2) {
 function longestCommonSubsequence(text1: string, text2: string): number {
     const m = text1.length;
     const n = text2.length;
-    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    const f = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
     for (let i = 1; i <= m; i++) {
         for (let j = 1; j <= n; j++) {
             if (text1[i - 1] === text2[j - 1]) {
-                dp[i][j] = dp[i - 1][j - 1] + 1;
+                f[i][j] = f[i - 1][j - 1] + 1;
             } else {
-                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
             }
         }
     }
-    return dp[m][n];
+    return f[m][n];
 }
 ```
 
@@ -210,17 +218,38 @@ impl Solution {
     pub fn longest_common_subsequence(text1: String, text2: String) -> i32 {
         let (m, n) = (text1.len(), text2.len());
         let (text1, text2) = (text1.as_bytes(), text2.as_bytes());
-        let mut dp = vec![vec![0; n + 1]; m + 1];
+        let mut f = vec![vec![0; n + 1]; m + 1];
         for i in 1..=m {
             for j in 1..=n {
-                dp[i][j] = if text1[i - 1] == text2[j - 1] {
-                    dp[i - 1][j - 1] + 1
+                f[i][j] = if text1[i - 1] == text2[j - 1] {
+                    f[i - 1][j - 1] + 1
+                } else {
+                    f[i - 1][j].max(f[i][j - 1])
+                }
+            }
+        }
+        f[m][n]
+    }
+}
+```
+
+### **C#**
+
+```cs
+public class Solution {
+    public int LongestCommonSubsequence(string text1, string text2) {
+        int m = text1.Length, n = text2.Length;
+        int[,] f = new int[m + 1, n + 1];
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                if (text1[i - 1] == text2[j - 1]) {
+                    f[i, j] = f[i - 1, j - 1] + 1;
                 } else {
-                    dp[i - 1][j].max(dp[i][j - 1])
+                    f[i, j] = Math.Max(f[i - 1, j], f[i, j - 1]);
                 }
             }
         }
-        dp[m][n]
+        return f[m, n];
     }
 }
 ```