feat: Add solution for LeetCode #3721

Author: 0xMashiro

SOLVED.md

@@ -360,6 +360,7 @@
 | 3684 | [Maximize Sum of At Most K Distinct Elements](https://leetcode.com/problems/maximize-sum-of-at-most-k-distinct-elements/) | [Code](src/leetcode/problems/maximize-sum-of-at-most-k-distinct-elements.cpp) / [Test](test/leetcode/problems/maximize-sum-of-at-most-k-distinct-elements.cpp) |
 | 3709 | [Design Exam Scores Tracker](https://leetcode.com/problems/design-exam-scores-tracker/) | [Code](src/leetcode/problems/design-exam-scores-tracker.cpp) / [Test](test/leetcode/problems/design-exam-scores-tracker.cpp) |
 | 3719 | [Longest Balanced Subarray I](https://leetcode.com/problems/longest-balanced-subarray-i/) | [Code](src/leetcode/problems/longest-balanced-subarray-i.cpp) / [Test](test/leetcode/problems/longest-balanced-subarray-i.cpp) |
+| 3721 | [Longest Balanced Subarray II](https://leetcode.com/problems/longest-balanced-subarray-ii/) | [Code](src/leetcode/problems/longest-balanced-subarray-ii.cpp) / [Test](test/leetcode/problems/longest-balanced-subarray-ii.cpp) |
 | 3722 | [Lexicographically Smallest String After Reverse](https://leetcode.com/problems/lexicographically-smallest-string-after-reverse/) | [Code](src/leetcode/problems/lexicographically-smallest-string-after-reverse.cpp) / [Test](test/leetcode/problems/lexicographically-smallest-string-after-reverse.cpp) |
 | 3727 | [Maximum Alternating Sum of Squares](https://leetcode.com/problems/maximum-alternating-sum-of-squares/) | [Code](src/leetcode/problems/maximum-alternating-sum-of-squares.cpp) / [Test](test/leetcode/problems/maximum-alternating-sum-of-squares.cpp) |
 | 3729 | [Count Distinct Subarrays Divisible by K in Sorted Array](https://leetcode.com/problems/count-distinct-subarrays-divisible-by-k-in-sorted-array/) | [Code](src/leetcode/problems/count-distinct-subarrays-divisible-by-k-in-sorted-array.cpp) / [Test](test/leetcode/problems/count-distinct-subarrays-divisible-by-k-in-sorted-array.cpp) |

include/leetcode/problems/longest-balanced-subarray-ii.h

@@ -0,0 +1,21 @@
+#include "leetcode/core.h"
+
+namespace leetcode {
+namespace problem_3721 {
+
+// LeetCode 兼容的 Solution 类
+class Solution {
+ public:
+  int longestBalanced(vector<int>& nums);
+};
+
+using Func = std::function<int(vector<int>&)>;
+
+class LongestBalancedSubarrayIiSolution : public SolutionBase<Func> {
+ public:
+  int longestBalanced(vector<int>& nums);
+  LongestBalancedSubarrayIiSolution();
+};
+
+}  // namespace problem_3721
+}  // namespace leetcode

src/leetcode/problems/longest-balanced-subarray-ii.cpp

@@ -0,0 +1,132 @@
+#include "leetcode/problems/longest-balanced-subarray-ii.h"
+
+namespace leetcode {
+namespace problem_3721 {
+
+// 线段树，支持区间加和查找值为0的最小下标
+class SegmentTree {
+ public:
+  SegmentTree(int n) : n(n) {
+    minv.assign(4 * n, 0);
+    maxv.assign(4 * n, 0);
+    lazy.assign(4 * n, 0);
+  }
+  
+  // 区间加
+  void range_add(int l, int r, int val) {
+    range_add(1, 0, n - 1, l, r, val);
+  }
+  
+  // 查找值为0的最小下标，如果不存在返回-1
+  int find_zero() {
+    if (maxv[1] < 0 || minv[1] > 0) return -1;
+    return find_zero(1, 0, n - 1);
+  }
+  
+ private:
+  int n;
+  vector<int> minv, maxv, lazy;
+  
+  void push_down(int node) {
+    if (lazy[node] != 0) {
+      int v = lazy[node];
+      minv[node * 2] += v;
+      maxv[node * 2] += v;
+      lazy[node * 2] += v;
+      minv[node * 2 + 1] += v;
+      maxv[node * 2 + 1] += v;
+      lazy[node * 2 + 1] += v;
+      lazy[node] = 0;
+    }
+  }
+  
+  void pull_up(int node) {
+    minv[node] = min(minv[node * 2], minv[node * 2 + 1]);
+    maxv[node] = max(maxv[node * 2], maxv[node * 2 + 1]);
+  }
+  
+  void range_add(int node, int l, int r, int ql, int qr, int val) {
+    if (ql > r || qr < l) return;
+    if (ql <= l && r <= qr) {
+      minv[node] += val;
+      maxv[node] += val;
+      lazy[node] += val;
+      return;
+    }
+    push_down(node);
+    int mid = (l + r) / 2;
+    range_add(node * 2, l, mid, ql, qr, val);
+    range_add(node * 2 + 1, mid + 1, r, ql, qr, val);
+    pull_up(node);
+  }
+  
+  int find_zero(int node, int l, int r) {
+    if (maxv[node] < 0 || minv[node] > 0) return -1;
+    if (l == r) return l;
+    push_down(node);
+    int mid = (l + r) / 2;
+    int res = find_zero(node * 2, l, mid);
+    if (res != -1) return res;
+    return find_zero(node * 2 + 1, mid + 1, r);
+  }
+};
+
+// 核心算法实现
+static int solve(vector<int>& nums) {
+  const int n = nums.size();
+  if (n < 2) return 0;
+  
+  // 需要维护 diff[0..n]，其中 diff[l] 表示子数组 [l, r-1] 的 even_count - odd_count
+  // 线段树大小为 n+1（l 的范围是 0 到 n）
+  SegmentTree st(n + 1);
+  
+  unordered_map<int, int> last_occurrence;
+  int ans = 0;
+  
+  for (int r = 0; r < n; r++) {
+    int val = nums[r];
+    int last = -1;
+    if (last_occurrence.count(val)) {
+      last = last_occurrence[val];
+    }
+    
+    // 在区间 [last+1, r] 上更新
+    // 对于左边界 l 在这个区间内，val 是子数组 [l, r] 中的新 distinct 值
+    int delta = (val % 2 == 0) ? 1 : -1;
+    st.range_add(last + 1, r, delta);
+    
+    // 查找使 diff[l] = 0 的最小 l
+    int l = st.find_zero();
+    if (l != -1 && l <= r) {
+      ans = max(ans, r - l + 1);
+    }
+    
+    last_occurrence[val] = r;
+  }
+  
+  return ans;
+}
+
+// LeetCode 兼容的 Solution 类实现
+int Solution::longestBalanced(vector<int>& nums) {
+  return solve(nums);
+}
+
+// SolutionBase 实现
+static int solution1(vector<int>& nums) {
+  return solve(nums);
+}
+
+LongestBalancedSubarrayIiSolution::LongestBalancedSubarrayIiSolution() {
+  setMetaInfo({.id = 3721,
+               .title = "Longest Balanced Subarray II",
+               .url = "https://leetcode.com/problems/longest-balanced-subarray-ii/"});
+  registerStrategy("Segment Tree", solution1);
+}
+
+int LongestBalancedSubarrayIiSolution::longestBalanced(vector<int>& nums) {
+  return getSolution()(nums);
+}
+
+}  // namespace problem_3721
+}  // namespace leetcode

test/leetcode/problems/longest-balanced-subarray-ii.cpp

@@ -0,0 +1,73 @@
+#include "leetcode/problems/longest-balanced-subarray-ii.h"
+
+#include "gtest/gtest.h"
+
+namespace leetcode {
+namespace problem_3721 {
+
+class LongestBalancedSubarrayIiTest : public ::testing::TestWithParam<std::string> {
+ protected:
+  void SetUp() override { solution.setStrategy(GetParam()); }
+
+  LongestBalancedSubarrayIiSolution solution;
+};
+
+TEST_P(LongestBalancedSubarrayIiTest, Example1) {
+  vector<int> nums = {2, 5, 4, 3};
+  EXPECT_EQ(4, solution.longestBalanced(nums));
+}
+
+TEST_P(LongestBalancedSubarrayIiTest, Example2) {
+  vector<int> nums = {3, 2, 2, 5, 4};
+  EXPECT_EQ(5, solution.longestBalanced(nums));
+}
+
+TEST_P(LongestBalancedSubarrayIiTest, Example3) {
+  vector<int> nums = {1, 2, 3, 2};
+  EXPECT_EQ(3, solution.longestBalanced(nums));
+}
+
+TEST_P(LongestBalancedSubarrayIiTest, SingleElement) {
+  // 单个偶数：distinct_even=1, distinct_odd=0，不平衡
+  vector<int> nums1 = {2};
+  EXPECT_EQ(0, solution.longestBalanced(nums1));
+  
+  // 单个奇数：distinct_even=0, distinct_odd=1，不平衡
+  vector<int> nums2 = {3};
+  EXPECT_EQ(0, solution.longestBalanced(nums2));
+}
+
+TEST_P(LongestBalancedSubarrayIiTest, TwoElements) {
+  // 偶+奇，平衡
+  vector<int> nums1 = {2, 3};
+  EXPECT_EQ(2, solution.longestBalanced(nums1));
+  
+  // 奇+偶，平衡
+  vector<int> nums2 = {3, 2};
+  EXPECT_EQ(2, solution.longestBalanced(nums2));
+  
+  // 两个偶数，不平衡
+  vector<int> nums3 = {2, 4};
+  EXPECT_EQ(0, solution.longestBalanced(nums3));
+  
+  // 两个奇数，不平衡
+  vector<int> nums4 = {1, 3};
+  EXPECT_EQ(0, solution.longestBalanced(nums4));
+}
+
+TEST_P(LongestBalancedSubarrayIiTest, AllSame) {
+  // 全相同偶数
+  vector<int> nums1 = {2, 2, 2, 2};
+  EXPECT_EQ(0, solution.longestBalanced(nums1));
+  
+  // 全相同奇数
+  vector<int> nums2 = {3, 3, 3, 3};
+  EXPECT_EQ(0, solution.longestBalanced(nums2));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    LeetCode, LongestBalancedSubarrayIiTest,
+    ::testing::ValuesIn(LongestBalancedSubarrayIiSolution().getStrategyNames()));
+
+}  // namespace problem_3721
+}  // namespace leetcode