feat: add python and java solutions to leetcode problem: No.300. Longest Increasing Subsequence

添加LeetCode题解：300. 最长上升子序列

Author: yanglbme

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

@@ -23,20 +23,63 @@
 
 ## 解法
 <!-- 这里可写通用的实现逻辑 -->
+动态规划求解。
 
+定义 `dp[i]` 为以 `nums[i]` 结尾的最长子序列的长度。即题目求的是 `dp[i]` （`i ∈[0, n-1]`）的最大值。
+
+状态转移方程为：
+
+`dp[i] = max(dp[j]) + 1`，其中 `0≤j<i` 且 `nums[j]<nums[i]`。
 
 ### Python3
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n < 2:
+            return n
+        dp = [0 for _ in range(n)]
+        dp[0] = 1
+        res = 1
+        for i in range(n):
+            max_val = 0
+            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])
+        return res
 ```
 
 ### Java
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        int n = nums.length;
+        if (n < 2) {
+            return n;
+        }
+        int[] dp = new int[n];
+        dp[0] = 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] = maxVal + 1;
+            res = Math.max(res, dp[i]);
+        }
+        return res;
+
+    }
+}
 ```
 
 ### ...

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

@@ -1,42 +1,81 @@
-# [300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence)
-
-## Description
-<p>Given an unsorted array of integers, find the length of longest increasing subsequence.</p>
-
-<p><b>Example:</b></p>
-
-<pre>
-<b>Input:</b> <code>[10,9,2,5,3,7,101,18]
-</code><b>Output: </b>4 
-<strong>Explanation: </strong>The longest increasing subsequence is <code>[2,3,7,101]</code>, therefore the length is <code>4</code>. </pre>
-
-<p><strong>Note: </strong></p>
-
-<ul>
-	<li>There may be more than one LIS combination, it is only necessary for you to return the length.</li>
-	<li>Your algorithm should run in O(<i>n<sup>2</sup></i>) complexity.</li>
-</ul>
-
-<p><b>Follow up:</b> Could you improve it to O(<i>n</i> log <i>n</i>) time complexity?</p>
-
-
-
-## Solutions
-
-
-### Python3
-
-```python
-
-```
-
-### Java
-
-```java
-
-```
-
-### ...
-```
-
-```
+# [300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence)
+
+## Description
+<p>Given an unsorted array of integers, find the length of longest increasing subsequence.</p>
+
+
+
+<p><b>Example:</b></p>
+
+
+
+<pre>
+
+<b>Input:</b> <code>[10,9,2,5,3,7,101,18]
+
+</code><b>Output: </b>4 
+
+<strong>Explanation: </strong>The longest increasing subsequence is <code>[2,3,7,101]</code>, therefore the length is <code>4</code>. </pre>
+
+
+
+<p><strong>Note: </strong></p>
+
+
+
+<ul>
+
+	<li>There may be more than one LIS combination, it is only necessary for you to return the length.</li>
+
+	<li>Your algorithm should run in O(<i>n<sup>2</sup></i>) complexity.</li>
+
+</ul>
+
+
+
+<p><b>Follow up:</b> Could you improve it to O(<i>n</i> log <i>n</i>) time complexity?</p>
+
+
+
+
+## Solutions
+
+
+### Python3
+
+```python
+
+```
+
+### Java
+
+```java
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        int n = nums.length;
+        if (n < 2) {
+            return n;
+        }
+        int[] dp = new int[n];
+        dp[0] = 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] = maxVal + 1;
+            res = Math.max(res, dp[i]);
+        }
+        return res;
+
+    }
+}
+```
+
+### ...
+```
+
+```

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

@@ -1,25 +1,23 @@
 class Solution {
     public int lengthOfLIS(int[] nums) {
-        if (nums == null) {
-            return 0;
-        }
         int n = nums.length;
         if (n < 2) {
             return n;
         }
-        int[] res = new int[n];
-        res[0] = 1;
-        res[1] = nums[1] > nums[0] ? 2 : 1;
-        int max = res[1];
-        for (int i = 2; i < n; ++i) {
-            res[i] = 1;
+        int[] dp = new int[n];
+        dp[0] = 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]) {
-                    res[i] = Math.max(res[i], res[j] + 1);
+                    maxVal = Math.max(maxVal, dp[j]);
                 }
             }
-            max = Math.max(max, res[i]);
+            dp[i] = maxVal + 1;
+            res = Math.max(res, dp[i]);
         }
-        return max;
+        return res;
+
     }
 }

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

@@ -0,0 +1,16 @@
+class Solution:
+    def lengthOfLIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n < 2:
+            return n
+        dp = [0 for _ in range(n)]
+        dp[0] = 1
+        res = 1
+        for i in range(n):
+            max_val = 0
+            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])
+        return res