feat: update solutions to lc problems: No.0300,1143

Author: yanglbme

solution/0300-0399/0300.Longest Increasing Subsequence/README.md

@@ -74,13 +74,11 @@ class Solution:
     def lengthOfLIS(self, nums: List[int]) -> int:
         n = len(nums)
         dp = [1] * n
-        res = 1
         for i in range(1, n):
             for j in range(i):
                 if nums[j] < nums[i]:
                     dp[i] = max(dp[i], dp[j] + 1)
-            res = max(res, dp[i])
-        return res
+        return max(dp)
 ```
 
 ### **Java**
@@ -132,16 +130,14 @@ public:
     int lengthOfLIS(vector<int>& nums) {
         int n = nums.size();
         vector<int> dp(n, 1);
-        int res = 1;
-        for (int i = 1; i < n; ++i) {
-            for (int j = 0; j < i; ++j) {
-                if (nums[j] < nums[i]) {
-                    dp[i] = max(dp[i], dp[j] + 1);
-                }
+        for (int i = 1; i < n; ++i)
+        {
+            for (int j = 0; j < i; ++j)
+            {
+                if (nums[j] < nums[i]) dp[i] = max(dp[i], dp[j] + 1);
             }
-            res = max(res, dp[i]);
         }
-        return res;
+        return *max_element(dp.begin(), dp.end());
     }
 };
 ```

solution/0300-0399/0300.Longest Increasing Subsequence/README_EN.md

@@ -60,13 +60,11 @@ class Solution:
     def lengthOfLIS(self, nums: List[int]) -> int:
         n = len(nums)
         dp = [1] * n
-        res = 1
         for i in range(1, n):
             for j in range(i):
                 if nums[j] < nums[i]:
                     dp[i] = max(dp[i], dp[j] + 1)
-            res = max(res, dp[i])
-        return res
+        return max(dp)
 ```
 
 ### **Java**
@@ -116,16 +114,14 @@ public:
     int lengthOfLIS(vector<int>& nums) {
         int n = nums.size();
         vector<int> dp(n, 1);
-        int res = 1;
-        for (int i = 1; i < n; ++i) {
-            for (int j = 0; j < i; ++j) {
-                if (nums[j] < nums[i]) {
-                    dp[i] = max(dp[i], dp[j] + 1);
-                }
+        for (int i = 1; i < n; ++i)
+        {
+            for (int j = 0; j < i; ++j)
+            {
+                if (nums[j] < nums[i]) dp[i] = max(dp[i], dp[j] + 1);
             }
-            res = max(res, dp[i]);
         }
-        return res;
+        return *max_element(dp.begin(), dp.end());
     }
 };
 ```

solution/0300-0399/0300.Longest Increasing Subsequence/Solution.cpp

@@ -3,15 +3,13 @@ class Solution {
     int lengthOfLIS(vector<int>& nums) {
         int n = nums.size();
         vector<int> dp(n, 1);
-        int res = 1;
-        for (int i = 1; i < n; ++i) {
-            for (int j = 0; j < i; ++j) {
-                if (nums[j] < nums[i]) {
-                    dp[i] = max(dp[i], dp[j] + 1);
-                }
+        for (int i = 1; i < n; ++i)
+        {
+            for (int j = 0; j < i; ++j)
+            {
+                if (nums[j] < nums[i]) dp[i] = max(dp[i], dp[j] + 1);
             }
-            res = max(res, dp[i]);
         }
-        return res;
+        return *max_element(dp.begin(), dp.end());
     }
 };

solution/0300-0399/0300.Longest Increasing Subsequence/Solution.py

@@ -2,10 +2,8 @@ class Solution:
     def lengthOfLIS(self, nums: List[int]) -> int:
         n = len(nums)
         dp = [1] * n
-        res = 1
         for i in range(1, n):
             for j in range(i):
                 if nums[j] < nums[i]:
                     dp[i] = max(dp[i], dp[j] + 1)
-            res = max(res, dp[i])
-        return res
+        return max(dp)

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

@@ -62,7 +62,7 @@
 
 递推公式如下：
 
-![](https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1100-1199/1143.Longest%20Common%20Subsequence/images/gif.gif)
+![](https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1100-1199/1143.Longest%20Common%20Subsequence/images/CodeCogsEqn.gif)
 
 <!-- tabs:start -->
 
@@ -119,14 +119,8 @@ public:
         {
             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]) dp[i][j] = dp[i - 1][j - 1] + 1;
+                else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
             }
         }
         return dp[m][n];

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

@@ -52,6 +52,8 @@
 
 Dynamic programming.
 
+![](https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/1100-1199/1143.Longest%20Common%20Subsequence/images/CodeCogsEqn.gif)
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -103,14 +105,8 @@ public:
         {
             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]) dp[i][j] = dp[i - 1][j - 1] + 1;
+                else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
             }
         }
         return dp[m][n];

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

@@ -7,14 +7,8 @@ class Solution {
         {
             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]) dp[i][j] = dp[i - 1][j - 1] + 1;
+                else dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
             }
         }
         return dp[m][n];