feat: add solutions to lc problem: No.3480

solution/3400-3499/3480.Maximize Subarrays After Removing One Conflicting Pair/README.md

@@ -82,32 +82,237 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：枚举 + 维护最小与次小值
+
+我们把所有冲突对 $(a, b)$（假设 $a \lt b$）存入一个列表 $g$ 中，其中 $g[a]$ 表示所有与 $a$ 冲突的数 $b$ 的集合。
+
+假设没有删除，那么我们可以倒序枚举每个子数组的左端点 $a$，那么其右端点的上界就是所有 $g[x \geq a]$ 中的最小值 $b_1$（不包括 $b_1$），对答案的贡献就是 $b_1 - a$。
+
+如果我们删除了一个包含 $b_1$ 的冲突对，那么此时新的 $b_1$ 就是所有 $g[x \geq a]$ 中的次小值 $b_2$，其对答案新增的贡献为 $b_2 - b_1$。我们用一个数组 $\text{cnt}$ 来记录每个 $b_1$ 的新增贡献。
+
+最终答案就是所有 $b_1 - a$ 的贡献加上 $\text{cnt}[b_1]$ 的最大值。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是冲突对的数量。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def maxSubarrays(self, n: int, conflictingPairs: List[List[int]]) -> int:
+        g = [[] for _ in range(n + 1)]
+        for a, b in conflictingPairs:
+            if a > b:
+                a, b = b, a
+            g[a].append(b)
+        cnt = [0] * (n + 2)
+        ans = add = 0
+        b1 = b2 = n + 1
+        for a in range(n, 0, -1):
+            for b in g[a]:
+                if b < b1:
+                    b2, b1 = b1, b
+                elif b < b2:
+                    b2 = b
+            ans += b1 - a
+            cnt[b1] += b2 - b1
+            add = max(add, cnt[b1])
+        ans += add
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public long maxSubarrays(int n, int[][] conflictingPairs) {
+        List<Integer>[] g = new List[n + 1];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (int[] pair : conflictingPairs) {
+            int a = pair[0], b = pair[1];
+            if (a > b) {
+                int c = a;
+                a = b;
+                b = c;
+            }
+            g[a].add(b);
+        }
+        long[] cnt = new long[n + 2];
+        long ans = 0, add = 0;
+        int b1 = n + 1, b2 = n + 1;
+        for (int a = n; a > 0; --a) {
+            for (int b : g[a]) {
+                if (b < b1) {
+                    b2 = b1;
+                    b1 = b;
+                } else if (b < b2) {
+                    b2 = b;
+                }
+            }
+            ans += b1 - a;
+            cnt[b1] += b2 - b1;
+            add = Math.max(add, cnt[b1]);
+        }
+        ans += add;
+        return ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long maxSubarrays(int n, vector<vector<int>>& conflictingPairs) {
+        vector<vector<int>> g(n + 1);
+        for (auto& pair : conflictingPairs) {
+            int a = pair[0], b = pair[1];
+            if (a > b) {
+                swap(a, b);
+            }
+            g[a].push_back(b);
+        }
+
+        vector<long long> cnt(n + 2, 0);
+        long long ans = 0, add = 0;
+        int b1 = n + 1, b2 = n + 1;
+
+        for (int a = n; a > 0; --a) {
+            for (int b : g[a]) {
+                if (b < b1) {
+                    b2 = b1;
+                    b1 = b;
+                } else if (b < b2) {
+                    b2 = b;
+                }
+            }
+            ans += b1 - a;
+            cnt[b1] += b2 - b1;
+            add = max(add, cnt[b1]);
+        }
+
+        ans += add;
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func maxSubarrays(n int, conflictingPairs [][]int) (ans int64) {
+	g := make([][]int, n+1)
+	for _, pair := range conflictingPairs {
+		a, b := pair[0], pair[1]
+		if a > b {
+			a, b = b, a
+		}
+		g[a] = append(g[a], b)
+	}
+
+	cnt := make([]int64, n+2)
+	var add int64
+	b1, b2 := n+1, n+1
+
+	for a := n; a > 0; a-- {
+		for _, b := range g[a] {
+			if b < b1 {
+				b2 = b1
+				b1 = b
+			} else if b < b2 {
+				b2 = b
+			}
+		}
+		ans += int64(b1 - a)
+		cnt[b1] += int64(b2 - b1)
+		if cnt[b1] > add {
+			add = cnt[b1]
+		}
+	}
+
+	ans += add
+	return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function maxSubarrays(n: number, conflictingPairs: number[][]): number {
+    const g: number[][] = Array.from({ length: n + 1 }, () => []);
+    for (let [a, b] of conflictingPairs) {
+        if (a > b) {
+            [a, b] = [b, a];
+        }
+        g[a].push(b);
+    }
+
+    const cnt: number[] = Array(n + 2).fill(0);
+    let ans = 0,
+        add = 0;
+    let b1 = n + 1,
+        b2 = n + 1;
+
+    for (let a = n; a > 0; a--) {
+        for (const b of g[a]) {
+            if (b < b1) {
+                b2 = b1;
+                b1 = b;
+            } else if (b < b2) {
+                b2 = b;
+            }
+        }
+        ans += b1 - a;
+        cnt[b1] += b2 - b1;
+        add = Math.max(add, cnt[b1]);
+    }
+
+    ans += add;
+    return ans;
+}
+```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn max_subarrays(n: i32, conflicting_pairs: Vec<Vec<i32>>) -> i64 {
+        let mut g: Vec<Vec<i32>> = vec![vec![]; (n + 1) as usize];
+        for pair in conflicting_pairs {
+            let mut a = pair[0];
+            let mut b = pair[1];
+            if a > b {
+                std::mem::swap(&mut a, &mut b);
+            }
+            g[a as usize].push(b);
+        }
+
+        let mut cnt: Vec<i64> = vec![0; (n + 2) as usize];
+        let mut ans = 0i64;
+        let mut add = 0i64;
+        let mut b1 = n + 1;
+        let mut b2 = n + 1;
+
+        for a in (1..=n).rev() {
+            for &b in &g[a as usize] {
+                if b < b1 {
+                    b2 = b1;
+                    b1 = b;
+                } else if b < b2 {
+                    b2 = b;
+                }
+            }
+            ans += (b1 - a) as i64;
+            cnt[b1 as usize] += (b2 - b1) as i64;
+            add = std::cmp::max(add, cnt[b1 as usize]);
+        }
+
+        ans += add;
+        ans
+    }
+}
 ```
 
 <!-- tabs:end -->