feat: add solutions to lc problems: No.1493,2730

Author: yanglbme

solution/1400-1499/1493.Longest Subarray of 1's After Deleting One Element/README.md

@@ -304,4 +304,100 @@ function longestSubarray(nums: number[]): number {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法三：双指针（优化）
+
+方法二中，我们每次会循环移动左指针，直到 $cnt \leq 1$。由于题目求的是最长子数组，意味着我们不需要缩小子数组的长度，因此，如果 $\textit{cnt} \gt 1$，我们只移动左指针一次，右指针也继续向右移动。这样可以保证子数组的长度不会减小。
+
+最后，我们返回的答案即为 $n - l - 1$，其中 $l$ 为左指针的位置。
+
+时间复杂度 $O(n)$，其中 $n$ 为数组 $nums$ 的长度。空间复杂度 $O(1)$。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def longestSubarray(self, nums: List[int]) -> int:
+        cnt = l = 0
+        for x in nums:
+            cnt += x ^ 1
+            if cnt > 1:
+                cnt -= nums[l] ^ 1
+                l += 1
+        return len(nums) - l - 1
+```
+
+#### Java
+
+```java
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int ans = 0, cnt = 0, l = 0;
+        for (int x : nums) {
+            cnt += x ^ 1;
+            if (cnt > 1) {
+                cnt -= nums[l++] ^ 1;
+            }
+        }
+        return nums.length - l - 1;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int longestSubarray(vector<int>& nums) {
+        int ans = 0, cnt = 0, l = 0;
+        for (int x : nums) {
+            cnt += x ^ 1;
+            if (cnt > 1) {
+                cnt -= nums[l++] ^ 1;
+            }
+        }
+        return nums.size() - l - 1;
+    }
+};
+```
+
+#### Go
+
+```go
+func longestSubarray(nums []int) (ans int) {
+	cnt, l := 0, 0
+	for _, x := range nums {
+		cnt += x ^ 1
+		if cnt > 1 {
+			cnt -= nums[l] ^ 1
+			l++
+		}
+	}
+	return len(nums) - l - 1
+}
+```
+
+#### TypeScript
+
+```ts
+function longestSubarray(nums: number[]): number {
+    let [cnt, l] = [0, 0];
+    for (const x of nums) {
+        cnt += x ^ 1;
+        if (cnt > 1) {
+            cnt -= nums[l++] ^ 1;
+        }
+    }
+    return nums.length - l - 1;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1400-1499/1493.Longest Subarray of 1's After Deleting One Element/README_EN.md

@@ -303,4 +303,100 @@ function longestSubarray(nums: number[]): number {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### Solution 3: Two Pointers (Optimization)
+
+In Solution 2, we move the left pointer in a loop until $cnt \leq 1$. Since the problem asks for the longest subarray, it means we don't need to reduce the length of the subarray. Therefore, if $\textit{cnt} \gt 1$, we only move the left pointer once, and the right pointer continues to move to the right. This ensures that the length of the subarray does not decrease.
+
+Finally, the answer we return is $n - l - 1$, where $l$ is the position of the left pointer.
+
+The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def longestSubarray(self, nums: List[int]) -> int:
+        cnt = l = 0
+        for x in nums:
+            cnt += x ^ 1
+            if cnt > 1:
+                cnt -= nums[l] ^ 1
+                l += 1
+        return len(nums) - l - 1
+```
+
+#### Java
+
+```java
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int ans = 0, cnt = 0, l = 0;
+        for (int x : nums) {
+            cnt += x ^ 1;
+            if (cnt > 1) {
+                cnt -= nums[l++] ^ 1;
+            }
+        }
+        return nums.length - l - 1;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int longestSubarray(vector<int>& nums) {
+        int ans = 0, cnt = 0, l = 0;
+        for (int x : nums) {
+            cnt += x ^ 1;
+            if (cnt > 1) {
+                cnt -= nums[l++] ^ 1;
+            }
+        }
+        return nums.size() - l - 1;
+    }
+};
+```
+
+#### Go
+
+```go
+func longestSubarray(nums []int) (ans int) {
+	cnt, l := 0, 0
+	for _, x := range nums {
+		cnt += x ^ 1
+		if cnt > 1 {
+			cnt -= nums[l] ^ 1
+			l++
+		}
+	}
+	return len(nums) - l - 1
+}
+```
+
+#### TypeScript
+
+```ts
+function longestSubarray(nums: number[]): number {
+    let [cnt, l] = [0, 0];
+    for (const x of nums) {
+        cnt += x ^ 1;
+        if (cnt > 1) {
+            cnt -= nums[l++] ^ 1;
+        }
+    }
+    return nums.length - l - 1;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->

solution/1400-1499/1493.Longest Subarray of 1's After Deleting One Element/Solution3.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int longestSubarray(vector<int>& nums) {
+        int ans = 0, cnt = 0, l = 0;
+        for (int x : nums) {
+            cnt += x ^ 1;
+            if (cnt > 1) {
+                cnt -= nums[l++] ^ 1;
+            }
+        }
+        return nums.size() - l - 1;
+    }
+};

solution/1400-1499/1493.Longest Subarray of 1's After Deleting One Element/Solution3.go

@@ -0,0 +1,11 @@
+func longestSubarray(nums []int) (ans int) {
+	cnt, l := 0, 0
+	for _, x := range nums {
+		cnt += x ^ 1
+		if cnt > 1 {
+			cnt -= nums[l] ^ 1
+			l++
+		}
+	}
+	return len(nums) - l - 1
+}

solution/1400-1499/1493.Longest Subarray of 1's After Deleting One Element/Solution3.java

@@ -0,0 +1,12 @@
+class Solution {
+    public int longestSubarray(int[] nums) {
+        int ans = 0, cnt = 0, l = 0;
+        for (int x : nums) {
+            cnt += x ^ 1;
+            if (cnt > 1) {
+                cnt -= nums[l++] ^ 1;
+            }
+        }
+        return nums.length - l - 1;
+    }
+}

solution/1400-1499/1493.Longest Subarray of 1's After Deleting One Element/Solution3.py

@@ -0,0 +1,9 @@
+class Solution:
+    def longestSubarray(self, nums: List[int]) -> int:
+        cnt = l = 0
+        for x in nums:
+            cnt += x ^ 1
+            if cnt > 1:
+                cnt -= nums[l] ^ 1
+                l += 1
+        return len(nums) - l - 1

solution/1400-1499/1493.Longest Subarray of 1's After Deleting One Element/Solution3.ts

@@ -0,0 +1,10 @@
+function longestSubarray(nums: number[]): number {
+    let [cnt, l] = [0, 0];
+    for (const x of nums) {
+        cnt += x ^ 1;
+        if (cnt > 1) {
+            cnt -= nums[l++] ^ 1;
+        }
+    }
+    return nums.length - l - 1;
+}

solution/2700-2799/2730.Find the Longest Semi-Repetitive Substring/README.md

@@ -182,4 +182,109 @@ function longestSemiRepetitiveSubstring(s: string): number {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法二：双指针（优化）
+
+由于题目只需要我们找到最长的半重复子字符串的长度，因此，每次当区间内相邻字符相等的个数超过 $1$ 时，我们可以只移动左指针 $l$ 一次，右指针 $r$ 继续向右移动。这样可以保证子字符串的长度不会减小。
+
+最后答案为 $n - l$，其中 $n$ 是字符串的长度。
+
+时间复杂度 $O(n)$，其中 $n$ 是字符串的长度。空间复杂度 $O(1)$。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def longestSemiRepetitiveSubstring(self, s: str) -> int:
+        n = len(s)
+        cnt = l = 0
+        for i in range(1, n):
+            cnt += s[i] == s[i - 1]
+            if cnt > 1:
+                cnt -= s[l] == s[l + 1]
+                l += 1
+        return n - l
+```
+
+#### Java
+
+```java
+class Solution {
+    public int longestSemiRepetitiveSubstring(String s) {
+        int n = s.length();
+        int cnt = 0, l = 0;
+        for (int i = 1; i < n; ++i) {
+            cnt += s.charAt(i) == s.charAt(i - 1) ? 1 : 0;
+            if (cnt > 1) {
+                cnt -= s.charAt(l) == s.charAt(++l) ? 1 : 0;
+            }
+        }
+        return n - l;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int longestSemiRepetitiveSubstring(string s) {
+        int n = s.length();
+        int cnt = 0, l = 0;
+        for (int i = 1; i < n; ++i) {
+            cnt += s[i] == s[i - 1] ? 1 : 0;
+            if (cnt > 1) {
+                cnt -= s[l] == s[++l] ? 1 : 0;
+            }
+        }
+        return n - l;
+    }
+};
+```
+
+#### Go
+
+```go
+func longestSemiRepetitiveSubstring(s string) (ans int) {
+	cnt, l := 0, 0
+	for i, c := range s[1:] {
+		if byte(c) == s[i] {
+			cnt++
+		}
+		if cnt > 1 {
+			if s[l] == s[l+1] {
+				cnt--
+			}
+			l++
+		}
+	}
+	return len(s) - l
+}
+```
+
+#### TypeScript
+
+```ts
+function longestSemiRepetitiveSubstring(s: string): number {
+    const n = s.length;
+    let [cnt, l] = [0, 0];
+    for (let i = 1; i < n; ++i) {
+        cnt += s[i] === s[i - 1] ? 1 : 0;
+        if (cnt > 1) {
+            cnt -= s[l] === s[l + 1] ? 1 : 0;
+            ++l;
+        }
+    }
+    return n - l;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->