feat: add python and java solutions to leetcode problem: No.0300

Author: yanglbme

README.md

@@ -133,6 +133,7 @@
 
 - [打家劫舍](/solution/0100-0199/0198.House%20Robber/README.md)
 - [打家劫舍 II](/solution/0200-0299/0213.House%20Robber%20II/README.md)
+- [最长上升子序列](/solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README.md)
 
 ### 混合问题
 

README_EN.md

@@ -122,6 +122,7 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 
 - [House Robber](/solution/0100-0199/0198.House%20Robber/README_EN.md)
 - [House Robber II](/solution/0200-0299/0213.House%20Robber%20II/README_EN.md)
+- [Longest Increasing Subsequence](/solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README_EN.md)
 
 ### Misc
 

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

@@ -46,16 +46,13 @@ class Solution:
         n = len(nums)
         if n < 2:
             return n
-        dp = [0 for _ in range(n)]
-        dp[0] = 1
+        dp = [1 for _ in nums]
         res = 1
-        for i in range(n):
-            max_val = 0
+        for i in range(1, n):
             for j in range(0, i):
                 if nums[j] < nums[i]:
-                    max_val = max(max_val, dp[j])
-                dp[i] = max_val + 1
-                res = max(res, dp[i])
+                    dp[i] = max(dp[i], dp[j] + 1)
+            res = max(res, dp[i])
         return res
 ```
 
@@ -66,25 +63,20 @@ class Solution:
 ```java
 class Solution {
     public int lengthOfLIS(int[] nums) {
-        int n = nums.length;
-        if (n < 2) {
-            return n;
-        }
+        int n;
+        if ((n = nums.length) < 2) return n;
         int[] dp = new int[n];
-        dp[0] = 1;
+        Arrays.fill(dp, 1);
         int res = 1;
         for (int i = 1; i < n; ++i) {
-            int maxVal = 0;
             for (int j = 0; j < i; ++j) {
                 if (nums[j] < nums[i]) {
-                    maxVal = Math.max(maxVal, dp[j]);
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
                 }
             }
-            dp[i] = maxVal + 1;
             res = Math.max(res, dp[i]);
         }
         return res;
-
     }
 }
 ```

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

@@ -32,33 +32,40 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n < 2:
+            return n
+        dp = [1 for _ in nums]
+        res = 1
+        for i in range(1, n):
+            for j in range(0, i):
+                if nums[j] < nums[i]:
+                    dp[i] = max(dp[i], dp[j] + 1)
+            res = max(res, dp[i])
+        return res
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public int lengthOfLIS(int[] nums) {
-        int n = nums.length;
-        if (n < 2) {
-            return n;
-        }
+        int n;
+        if ((n = nums.length) < 2) return n;
         int[] dp = new int[n];
-        dp[0] = 1;
+        Arrays.fill(dp, 1);
         int res = 1;
         for (int i = 1; i < n; ++i) {
-            int maxVal = 0;
             for (int j = 0; j < i; ++j) {
                 if (nums[j] < nums[i]) {
-                    maxVal = Math.max(maxVal, dp[j]);
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
                 }
             }
-            dp[i] = maxVal + 1;
             res = Math.max(res, dp[i]);
         }
         return res;
-
     }
 }
 ```

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

@@ -1,23 +1,18 @@
 class Solution {
     public int lengthOfLIS(int[] nums) {
-        int n = nums.length;
-        if (n < 2) {
-            return n;
-        }
+        int n;
+        if ((n = nums.length) < 2) return n;
         int[] dp = new int[n];
-        dp[0] = 1;
+        Arrays.fill(dp, 1);
         int res = 1;
         for (int i = 1; i < n; ++i) {
-            int maxVal = 0;
             for (int j = 0; j < i; ++j) {
                 if (nums[j] < nums[i]) {
-                    maxVal = Math.max(maxVal, dp[j]);
+                    dp[i] = Math.max(dp[i], dp[j] + 1);
                 }
             }
-            dp[i] = maxVal + 1;
             res = Math.max(res, dp[i]);
         }
         return res;
-
     }
 }

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

@@ -3,14 +3,11 @@ def lengthOfLIS(self, nums: List[int]) -> int:
         n = len(nums)
         if n < 2:
             return n
-        dp = [0 for _ in range(n)]
-        dp[0] = 1
+        dp = [1 for _ in nums]
         res = 1
-        for i in range(n):
-            max_val = 0
+        for i in range(1, n):
             for j in range(0, i):
                 if nums[j] < nums[i]:
-                    max_val = max(max_val, dp[j])
-                dp[i] = max_val + 1
-                res = max(res, dp[i])
+                    dp[i] = max(dp[i], dp[j] + 1)
+            res = max(res, dp[i])
         return res