feat: add solutions to lc problem: No.0300. Longest Increasing

Subsequence

Author: yanglbme

README.md

@@ -194,8 +194,8 @@
 - [最小路径和](./solution/0000-0099/0064.Minimum%20Path%20Sum/README.md)
 - [最长回文子串](./solution/0000-0099/0005.Longest%20Palindromic%20Substring/README.md)
 - [最长回文子序列](.solution/0500-0599/0516.Longest%20Palindromic%20Subsequence/README.md)
+- [最长递增子序列](./solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README.md)
 - [礼物的最大价值](./lcof/面试题47.%20礼物的最大价值/README.md)
-- [最长上升子序列](./solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README.md)
 - [俄罗斯套娃信封问题](./solution/0300-0399/0354.Russian%20Doll%20Envelopes/README.md)
 - [最长公共子序列](./solution/1100-1199/1143.Longest%20Common%20Subsequence/README.md)
 

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

@@ -51,14 +51,13 @@
 	<li>你能将算法的时间复杂度降低到 <code>O(n log(n))</code> 吗?</li>
 </ul>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
 动态规划求解。
 
-定义 `dp[i]` 为以 `nums[i]` 结尾的最长子序列的长度。即题目求的是 `dp[i]` （`i ∈[0, n-1]`）的最大值。
+定义 `dp[i]` 为以 `nums[i]` 结尾的最长子序列的长度，`dp[i]` 初始化为 1(`i∈[0, n)`)。即题目求的是 `dp[i]` （`i ∈[0, n-1]`）的最大值。
 
 状态转移方程为：
 
@@ -74,8 +73,6 @@
 class Solution:
     def lengthOfLIS(self, nums: List[int]) -> int:
         n = len(nums)
-        if n < 2:
-            return n
         dp = [1] * n
         res = 1
         for i in range(1, n):
@@ -110,6 +107,56 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+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);
+                }
+            }
+            res = max(res, dp[i]);
+        }
+        return res;
+    }
+};
+```
+
+### **Go**
+
+```go
+func lengthOfLIS(nums []int) int {
+	n := len(nums)
+	dp := make([]int, n)
+	dp[0] = 1
+	res := 1
+	for i := 1; i < n; i++ {
+		dp[i] = 1
+		for 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
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
 ### **...**
 
 ```

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

@@ -47,9 +47,10 @@
 	<li>Could you improve it to <code>O(n log(n))</code> time complexity?</li>
 </ul>
 
-
 ## Solutions
 
+Dynamic programming.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -58,8 +59,6 @@
 class Solution:
     def lengthOfLIS(self, nums: List[int]) -> int:
         n = len(nums)
-        if n < 2:
-            return n
         dp = [1] * n
         res = 1
         for i in range(1, n):
@@ -92,6 +91,56 @@ class Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+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);
+                }
+            }
+            res = max(res, dp[i]);
+        }
+        return res;
+    }
+};
+```
+
+### **Go**
+
+```go
+func lengthOfLIS(nums []int) int {
+	n := len(nums)
+	dp := make([]int, n)
+	dp[0] = 1
+	res := 1
+	for i := 1; i < n; i++ {
+		dp[i] = 1
+		for 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
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+```
+
 ### **...**
 
 ```

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

@@ -1,17 +1,17 @@
 class Solution {
 public:
     int lengthOfLIS(vector<int>& nums) {
-        if (nums.size() == 0)
-            return 0 ;
-        int M[nums.size()] = {0, } ;
-        int MM = -1 ;
-        for (int i = nums.size()-1; i >= 0; --i)
-        {
-            for (int j = i+1; j < nums.size(); ++j)
-                if (nums[i] < nums[j])
-                    M[i] = max(M[i], M[j]) ;
-            MM = max(++M[i], MM) ;
+        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);
+                }
+            }
+            res = max(res, dp[i]);
         }
-        return MM ;
+        return res;
     }
-};
+};

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

@@ -0,0 +1,23 @@
+func lengthOfLIS(nums []int) int {
+	n := len(nums)
+	dp := make([]int, n)
+	dp[0] = 1
+	res := 1
+	for i := 1; i < n; i++ {
+		dp[i] = 1
+		for 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
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

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

@@ -7,7 +7,7 @@ public int lengthOfLIS(int[] nums) {
         for (int i = 1; i < n; ++i) {
             for (int j = 0; j < i; ++j) {
                 if (nums[j] < nums[i]) {
-                    dp[i] = Math.max(dp[i], dp[j] + 1);   
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
                 }
             }
             res = Math.max(res, dp[i]);

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

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