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

Author: yanglbme

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

@@ -46,10 +46,10 @@ class Solution:
         n = len(nums)
         if n < 2:
             return n
-        dp = [1 for _ in nums]
+        dp = [1] * n
         res = 1
         for i in range(1, n):
-            for j in range(0, i):
+            for j in range(i):
                 if nums[j] < nums[i]:
                     dp[i] = max(dp[i], dp[j] + 1)
             res = max(res, dp[i])

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

@@ -37,10 +37,10 @@ class Solution:
         n = len(nums)
         if n < 2:
             return n
-        dp = [1 for _ in nums]
+        dp = [1] * n
         res = 1
         for i in range(1, n):
-            for j in range(0, i):
+            for j in range(i):
                 if nums[j] < nums[i]:
                     dp[i] = max(dp[i], dp[j] + 1)
             res = max(res, dp[i])

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

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

solution/0600-0699/0674.Longest Continuous Increasing Subsequence/README.md

@@ -30,22 +30,48 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+设 f(i) 表示将数组第 i 项作为最长连续递增子序列的最后一项时，子序列的长度。
+
+那么，当 `nums[i - 1] < nums[i]`，即 `f(i) = f(i - 1)` + 1，否则 `f(i) = 1`。问题转换为求 f(i) (`i ∈ [0 ,n - 1]`) 的最大值。
+
+由于 f(i) 只与前一项 f(i - 1) 有关联，故不需要用一个数组存储。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def findLengthOfLCIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n < 2:
+            return n
+        res = f = 1
+        for i in range(1, n):
+            f = 1 + (f if nums[i - 1] < nums[i] else 0)
+            res = max(res, f)
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int findLengthOfLCIS(int[] nums) {
+        int n;
+        if ((n = nums.length) < 2) return n;
+        int res = 1, f = 1;
+        for (int i = 1; i < n; ++i) {
+            f = 1 + (nums[i - 1] < nums[i] ? f : 0);
+            res = Math.max(res, f);
+        }
+        return res;
+    }
+}
 ```
 
 ### **...**

solution/0600-0699/0674.Longest Continuous Increasing Subsequence/README_EN.md

@@ -53,13 +53,33 @@ Length of the array will not exceed 10,000.
 ### **Python3**
 
 ```python
-
+class Solution:
+    def findLengthOfLCIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n < 2:
+            return n
+        res = f = 1
+        for i in range(1, n):
+            f = 1 + (f if nums[i - 1] < nums[i] else 0)
+            res = max(res, f)
+        return res
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int findLengthOfLCIS(int[] nums) {
+        int n;
+        if ((n = nums.length) < 2) return n;
+        int res = 1, f = 1;
+        for (int i = 1; i < n; ++i) {
+            f = 1 + (nums[i - 1] < nums[i] ? f : 0);
+            res = Math.max(res, f);
+        }
+        return res;
+    }
+}
 ```
 
 ### **...**

solution/0600-0699/0674.Longest Continuous Increasing Subsequence/Solution.java

@@ -1,17 +1,12 @@
 class Solution {
     public int findLengthOfLCIS(int[] nums) {
-        if (nums == null || nums.length == 0) {
-            return 0;
-        }
-        int cnt = 1;
-        int res = 1;
-        for (int i = 1; i < nums.length; ++i) {
-            if (nums[i] > nums[i - 1]) {
-                res = Math.max(res, ++cnt);
-            } else {
-                cnt = 1;
-            }
+        int n;
+        if ((n = nums.length) < 2) return n;
+        int res = 1, f = 1;
+        for (int i = 1; i < n; ++i) {
+            f = 1 + (nums[i - 1] < nums[i] ? f : 0);
+            res = Math.max(res, f);
         }
         return res;
     }
-}
+}

solution/0600-0699/0674.Longest Continuous Increasing Subsequence/Solution.py

@@ -0,0 +1,10 @@
+class Solution:
+    def findLengthOfLCIS(self, nums: List[int]) -> int:
+        n = len(nums)
+        if n < 2:
+            return n
+        res = f = 1
+        for i in range(1, n):
+            f = 1 + (f if nums[i - 1] < nums[i] else 0)
+            res = max(res, f)
+        return res