Problem Statement

Constraints

思路：試填法

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Solution:
    def maximumAND(self, nums: List[int], k: int, m: int) -> int:
        B = (max(nums) + k).bit_length()
        ans = 0
        for b in range(B, -1, -1):
            tgt = ans | (1 << b)
            def cost(x):
                if (x & tgt) == tgt:
                    return 0
                else:
                    msb = (tgt & ~x).bit_length() - 1
                    y = ((x >> msb) + 1) << msb
                    y |= (tgt & ((1 << msb) - 1))
                    return y - x
            if sum(sorted(cost(x) for x in nums)[:m]) <= k:
                ans |= (1 << b)
        return ans

Problem Statement

Constraints

思路：把可見條件轉成支配點統計

直接做法是每個詢問都從左到右掃一遍，維護目前最高高度並計數。但區間長度和詢問數都可達 $2 \cdot 10^5$，最壞會到 $\mathcal{O}(NQ)$，必須把「一座山是否可見」改寫成能快速查詢的條件。

所以問題等價於：對詢問區間 $[l,r]$，統計所有位置在 $[l,r]$ 內，且 $P_i < l$ 的山。

如何求左側第一座更高山

這是單調棧的標準用途。從左到右掃描高度，棧中保持高度嚴格遞減的位置。

遇到新山時，所有高度不大於它的棧頂都不可能成為它或後續更高山的「左側第一座更高山」，可以彈出。彈完後，若棧仍非空，棧頂就是左側最近且高度嚴格更高的位置；若棧為空，代表不存在這樣的山。

離線回答詢問

現在每座山都有一個 $P_i$。對詢問左端點 $l$ 來說，符合條件的山就是 $P_i < l$ 的那些，再限制位置落在 $[l,r]$ 內。

這是一個二維偏序查詢。把每座山視為點 $(i, P_i)$，對詢問 $[l, r]$，要統計滿足

$$l \le i \le r,\quad P_i < l$$

的點數。

• 一維是山本身的位置，要查區間 $[l, r]$。
• 另一維是 $P_i$，要滿足小於目前詢問的左端點 $l$。

可以把所有山按 $P_i$ 排序，所有詢問按左端點排序。當處理到某個左端點時，把 $P_i$ 已經小於它的山加入樹狀陣列(Fenwick Tree)；樹狀陣列按照山的位置記錄是否已加入。此時查詢 $[l, r]$ 的區間中有多少個點，就是答案。

複雜度分析

• 時間複雜度：$\mathcal{O}((N+Q)\log N)$，單調棧為 $\mathcal{O}(N)$，排序與每次樹狀陣列操作合計為 $\mathcal{O}((N+Q)\log N)$。
• 空間複雜度：$\mathcal{O}(N+Q)$，儲存詢問、$P_i$、樹狀陣列與答案陣列。

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

from atcoder.fenwicktree import FenwickTree


def solve():
    n, q = map(int, input().split())
    H = list(map(int, input().split()))

    queries = []
    for qid in range(q):
        l, r = map(lambda x: int(x) - 1, input().split())
        queries.append((l, r, qid))
    queries.sort()

    # P[i] 表示 H[i] 左側第一個 > H[i] 的位置，若不存在則為 -1
    P = [-1] * n
    st = []
    for i in range(n):
        while st and H[st[-1]] <= H[i]:
            st.pop()
        if st:
            P[i] = st[-1]
        st.append(i)

    points = [(p, idx) for idx, p in enumerate(P)]
    points.sort()

    bit = FenwickTree(n)
    ans = [0] * q

    j = 0
    for l, r, qid in queries:
        while j < n and points[j][0] < l:
            _, idx = points[j]
            bit.add(idx, 1)
            j += 1
        ans[qid] = bit.sum(l, r + 1)  # [l, r]

    print(*ans, sep="\n")


if __name__ == "__main__":
    solve()

寫在最後

Problem Statement

Constraints

思路：狀態機DP

這題涉及一個典型套路：操作「恰好一次」，且操作位置可以插在任意兩個元素之間。直接枚舉纜車使用位置，再從頭模擬到尾，會是 $\mathcal{O}(N^2)$，無法承受。

關鍵在於，走到某個位置後，對未來有用的資訊其實很少。不妨定義：

• $f[i][0]$：走完前 $i$ 段，且尚未使用纜車時，能得到的海拔。
• $f[i][1]$：走完前 $i$ 段，且已經使用纜車時，能得到的最小海拔。

其中 $f[i][0]$ 沒有分支，因為纜車還不能用；$f[i][1]$ 則把「纜車在哪個位置使用」這個選擇壓縮成一個最小值。

狀態轉移

先看「尚未使用纜車」的狀態。走完第 $i$ 段後只能照普通爬山規則更新：

$$f[i][0] = \max(f[i - 1][0] + D_i, 0)$$

再看「已經使用纜車」的狀態。它有兩種來源：

1. 纜車早在之前就用過，現在只是繼續通過當前路段。
2. 纜車在當前路段之後使用，於是從尚未使用纜車的海拔立刻折半。

對應轉移為：

$$f[i][1] = \min\left(\max(f[i - 1][1] + D_i, 0),\ \left\lfloor \frac{f[i][0]}{2} \right\rfloor\right)$$

第一項表示「之前已經使用纜車，現在走第 $i$ 段」；第二項表示「先正常走完第 $i$ 段，再立刻使用纜車」。兩者取較小值，就是走到目前位置後、纜車已使用時的最佳海拔。

複雜度分析

• 時間複雜度：$\mathcal{O}(N)$
• 空間複雜度：$\mathcal{O}(N)$，因為程式保存了整個變化序列；若讀入後直接迭代原序列，也可視為只需 $\mathcal{O}(1)$ 額外狀態

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

def solve():
    n = int(input())
    D = list(map(int, input().split()))
    assert len(D) == n

    h0 = h1 = 0
    for d in D:
        h0 = max(h0 + d, 0)
        h1 = max(h1 + d, 0)
        h1 = min(h1, h0 // 2)
    print(h1)


if __name__ == "__main__":
    solve()

Problem Statement

Constraints

思路：由左到右貪心 + 差分

先把問題從「濕度」改寫成「每段還需要增加多少」。令 $C_i=B_i-A_i$，表示第 $i$ 段距離目標還差多少水量。因為操作只能增加，若存在 $C_i<0$，代表某一段目前已經超過目標，那就不可能再修回來，直接輸出 $-1$。

接著要處理的是：從全 $0$ 的狀態開始，每次可以對長度固定為 $K$ 的區間整體 $+1$ ，能否剛好湊出這個差值陣列 $C$，並且操作次數最少。

貪心策略

從左到右掃描，遇到還有缺少水量的區段，就立刻補足以 $i$ 為起點的連續 $K$ 個區段。因為 $i$ 左邊的位置已經處理完畢，不會再有操作能覆蓋到 $i$，因此這是唯一的選擇。若掃到某個區段時已經無法放下長度 $K$ 的區間（$i > N - K$），則無解。

用差分維護目前已經增加多少

注意到一次操作的影響是長度固定的連續區間：從起點開始生效，到起點加上 $K$ 的位置失效。這正好是差分擅長維護的資訊。因此我們不用真的更新整段，只要維護目前仍然有效的總增加量；當在目前位置新增若干次操作時，立刻把它加入當前貢獻，並在 $K$ 格之後記錄一個相反變化，表示這批操作到那裡就失效。

複雜度分析

• 時間複雜度：$\mathcal{O}(N)$
• 空間複雜度：$\mathcal{O}(N)$

類題

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

def solve():
    N, K = map(int, input().split())
    A = list(map(int, input().split()))
    B = list(map(int, input().split()))

    C = [b - a for a, b in zip(A, B)]
    if any(c < 0 for c in C):
        print(-1)
        return

    ans = s = 0
    diff = [0] * (N + 1)
    for i, c in enumerate(C):
        s += diff[i]
        need = c - s
        if need < 0 or need > 0 and i + K > N:
            print(-1)
            return
        if need > 0:
            ans += need
            s += need
            diff[i + K] -= need
    print(ans)


if __name__ == "__main__":
    solve()

寫在最後

🔗 🌈 AWC0096B Adventurer’s Staircase

Problem Statement

Constraints

思路：把藥水數變成最大缺口

這題看起來可以二分需要喝的藥水數，並模擬每一層是否能打過。但其實不需要二分，也不需要反覆模擬。

先不考慮藥水。抵達某一層並開打前，戰鬥力等於初始戰鬥力加上前面已擊敗怪物的強度總和。如果這個值不夠打當前怪物，那麼缺多少，就至少需要在一開始補多少瓶藥水。

所以每一層都會給出一個下界：

$$\text{第 } i \text{ 層缺口} = \max\left(0, E_i - \left(S + \sum_{j=1}^{i-1} E_j\right)\right)$$

要讓所有樓層都能通過，只要滿足所有下界，也就是取最大缺口即可。若某些樓層本來就打得過，缺口是負數或零，對答案沒有貢獻。

複雜度分析

• 時間複雜度：$\mathcal{O}(N)$
• 空間複雜度：$\mathcal{O}(N)$，目前實作建立前綴累積陣列；若邊掃描邊維護目前戰鬥力，可降為 $\mathcal{O}(1)$。

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from itertools import accumulate


def solve():
    N, S, K = map(int, input().split())
    A = list(map(int, input().split()))
    assert len(A) == N - 1

    ps = list(accumulate(A, initial=S))

    need = max(x - s for x, s in zip(A, ps))
    print(max(0, need) if need <= K else -1)


if __name__ == "__main__":
    solve()

寫在最後

Problem Statement

Constraints

思路：依序維護窗口空閒時間

由於窗口一次只能處理一位訪客，且服務順序固定，所以沒有排程選擇，也不用排序；唯一需要維護的是「窗口目前最早什麼時候能接下一位」，即上一位訪客服務結束的時間。

令 $E[i]$ 為第 $i$ 位訪客服務結束的時間，則對於下一位訪客，開始服務的時間由兩個條件共同限制：

• 如果訪客還沒到，就必須等到他的到達時間。
• 如果窗口還在忙，就必須等到上一位服務結束。

因此開始時間就是這兩個時間的較大值；接著再加上該訪客的服務時間，就能得到新的窗口空閒時間，有以下遞迴式：

$$E[i] = \max(E[i-1], A_i) + B_i$$

複雜度分析

• 時間複雜度：$\mathcal{O}(N)$
• 空間複雜度：$\mathcal{O}(1)$，只需維護窗口下一次空閒的時間。

Code

1
2
3
4
5
6
7
8
9
10
11

def solve():
    n = int(input())

    ans = 0
    for _ in range(n):
        a, b = map(int, input().split())
        ans = max(ans, a) + b
    print(ans)

if __name__ == "__main__":
    solve()

寫在最後

🔗 🟣 P4062 [Code+#1] Yazid 的新生舞会

Problem Statement

Constraints

思路：根號分治 + 固定眾數計數

注意到如果一個子區間合法，其中嚴格過半的元素必定唯一。因此每個合法區間都可以歸到唯一的「主要元素」名下，不會重複計數。因此可以往枚舉「主要元素」的方向思考，並套用 3739 的計數方法。

接下來的關鍵是：選定一個閾值 $B$，按元素在整個序列中的出現次數分成兩類，各自用最適合的方式計數。

出現次數大的元素：沿用 3739. Count Subarrays With Majority Element II 的 $O(n)$ 作法

先考慮已經指定一個元素，如何計算它作為嚴格過半元素的子區間數量，即 3739 的題目內容。這裡可以直接沿用 3739 的做法，將該元素視為 $+1$，其餘元素視為 $-1$，計算前綴和，並統計有多少對 $(i,j)$ 滿足 $i<j$ 且 $s_i<s_j$。

又由於每次加入一個新元素後，前綴和只會變化 $+1$ 或 $-1$，因此可以在掃描過程中，直接維護「歷史前綴和中有多少個小於目前前綴和」的數量。當前綴和增加或減少時，只要補上這一步新增或移出的那一層即可。

出現次數小的元素：只需要看短區間

接著看全域出現次數 $\le B$ 的元素。如果它要成為某個長度為 $L$ 的子區間的嚴格過半元素，設它在這個子區間內出現了 $c$ 次，則有

$$2c > L.$$

又因為它在整個序列中最多出現 $B$ 次，所以 $c \le B$。因此合法區間長度必須滿足

$$L < 2c \le 2B.$$

也就是說，輕元素不可能成為長度 $\ge 2B$ 的子區間的嚴格過半元素。於是可以直接枚舉每個左端點，往右最多延伸 $2B-1$ 個位置，維護當前短區間中出現次數最多的元素。如果目前最大出現次數嚴格超過區間長度一半，且這個元素全域出現次數不超過 $B$，就把答案加一。

這部分每個左端點只枚舉 $\mathcal{O}(B)$ 個右端點，因此總時間是 $\mathcal{O}(nB)$。

複雜度平衡

兩部分合起來是

$$\mathcal{O}\left(\frac{n^2}{B}+nB\right)=\mathcal{O}\left(n\left(\frac{n}{B}+B\right)\right).$$

取 $B=\Theta(\sqrt n)$，兩項平衡，得到 $\mathcal{O}(n\sqrt n)$。

複雜度分析

• 時間複雜度：$\mathcal{O}(n\sqrt n)$
• 空間複雜度：$\mathcal{O}(n)$

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define endl '\n'

void solve() {
    int n, typ;
    cin >> n >> typ;

    vector<int> nums(n), tot(n);
    for (int& x : nums) {
        cin >> x;
        ++tot[x];
    }

    i64 ans = 0;
    int B = sqrt(n) + 1;

    // 枚舉出現次數 > B 的元素
    for (int target = 0; target < n; ++target) {
        if (tot[target] <= B) {
            continue;
        }
        // 3739. Count Subarrays With Majority Element II 的 O(n) 作法
        vector<int> cnt(2 * n + 1);
        int s = n;
        cnt[s] = 1;
        i64 lt = 0;
        for (int x : nums) {
            if (x == target) {
                lt += cnt[s];
                ++s;
            } else {
                lt -= cnt[s - 1];
                --s;
            }
            ans += lt;
            ++cnt[s];
        }
    }

    // 出現次數為 B 的元素最多只能是長度為 2B-1 區間的多數元素
    // 因此可以直接枚舉長度 < 2B 的區間，並維護出現次數最多的元素
    // unordered_map<int, int> cnt;  // TLE
    vector<int> cnt(n);
    for (int l = 0; l < n; ++l) {
        vector<int> touched;  // 紀錄被修改過的元素，方便以 O(B) 清空
        int bestCnt = 0, bestVal = -1;
        for (int r = l; r < min(n, l + 2 * B - 1); ++r) {
            int x = nums[r];
            if (cnt[x] == 0) {
                touched.push_back(x);
            }
            ++cnt[x];

            if (cnt[x] > bestCnt) {
                bestCnt = cnt[x];
                bestVal = x;
            }

            int len = r - l + 1;
            if (bestCnt * 2 > len && tot[bestVal] <= B) {
                ++ans;
            }
        }
        // 清空被修改過的元素
        for (int x : touched) {
            cnt[x] = 0;
        }
    }

    cout << ans << endl;
    return;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
    return 0;
}

Problem Statement

Constraints

思路：枚舉右維護左

差別在於這版的陣列長度到 $10^5$，不能再枚舉所有左右端點。

修改下標定義，令 $i = l,\quad j = r + 1$，則對於 $0 \le i < j \le n$，只要滿足 $s_i < s_j$ 就符合題意。也就是說，問題變成統計有多少對 $(i,j)$ 滿足 $i<j$ 且 $s_i<s_j$。

方法一：有序容器上二分

最直接的做法是維護已經出現過的前綴和集合。掃描到目前的前綴下標 $j$ 時，滿足 $s[i] < s[j]$ 的歷史前綴和 $s[i]$，就是集合中所有小於 $s[j]$ 的元素。

有序容器支援兩件事：

• 查詢有多少歷史前綴和小於目前前綴和。
• 把目前前綴和加入歷史集合，供後面的前綴下標使用。

初始時需要先放入前綴和 $s_0=0$，對應空前綴。這樣當子陣列從陣列開頭開始時，也能被正常計入。

複雜度分析

• 時間複雜度：$\mathcal{O}(n\log n)$，每個位置做一次二分查詢與插入。
• 空間複雜度：$\mathcal{O}(n)$，需要儲存歷史前綴和。

方法二：二維偏序，逆序對問題

從配對條件 $i<j$ 且 $s_i<s_j$ 來看，這就是一個二維偏序計數：一維是下標先後，另一維是前綴和值大小。由於掃描順序已經保證歷史前綴和都來自目前位置左側，剩下只要快速統計「值小於目前前綴和」的歷史數量。

前綴和的範圍只會落在 $[-n,n]$，需要用偏移量把它映射到 $[1,2n+1]$，然後用樹狀陣列維護每個前綴和值出現了幾次。每次查詢小於目前值的總出現次數，再把目前值加入資料結構。

複雜度分析

• 時間複雜度：$\mathcal{O}(n\log n)$，每個位置做一次樹狀陣列查詢與更新。
• 空間複雜度：$\mathcal{O}(n)$，值域大小為 $2n+1$。

方法三：動態維護小於目前值的數量

注意到每次加入一個新元素後，前綴和只會變化 $+1$ 或 $-1$。這意味著：當我們從上一個前綴和走到下一個前綴和時，「歷史前綴和中有多少個值小於目前值」這個答案，不會整體重算，只會發生局部變化。

因此可以在掃描過程中，直接維護「歷史前綴和中有多少個小於目前前綴和」的數量。當前綴和增加或減少時，只要補上這一步新增或移出的那一層即可。

• 若目前元素等於 target，前綴和從 $v$ 變成 $v+1$。原本等於 $v$ 的歷史前綴和，現在也變成小於新值，所以小於數量要加上「歷史中等於 $v$ 的個數」。
• 若目前元素不等於 target，前綴和從 $v$ 變成 $v-1$。原本等於 $v-1$ 的歷史前綴和，不再小於新值，所以小於數量要減去「歷史中等於 $v-1$ 的個數」。

這樣就不需要有序容器或樹狀陣列了，只要用計數陣列記錄每個前綴和值出現次數，並維護目前的小於數量即可。

複雜度分析

• 時間複雜度：$\mathcal{O}(n)$，每個位置只做常數次計數更新。
• 空間複雜度：$\mathcal{O}(n)$，需要記錄 $[-n,n]$ 範圍內的前綴和出現次數。

方法四：分治

要怎麼想到分治？回到配對條件 $i<j$ 且 $s_i<s_j$。前面的方法都是按照 $j$ 從左到右掃描，然後用資料結構回答「左邊有多少個更小的前綴和」。換個角度看，這其實是在統計一堆跨下標的配對，而這類配對計數也常常可以用 merge sort 分治處理。

具體來說，把前綴和陣列按照下標切成左右兩半。合法配對只會有三種來源：完全在左半部、完全在右半部、以及左端點在左半部且右端點在右半部。前兩種交給遞迴處理，剩下的跨區間配對，因為左半部下標一定小於右半部下標，所以只需要判斷前綴和值是否滿足 $s_i<s_j$。

跨區間的統計正好可以放進 merge sort 的合併過程。程式中會先讓左右兩段各自排好序，然後以「由大到小」的方式合併：

• 若左側目前值大於等於右側目前值，就先放左側，因為它不能和這個右側值形成合法配對。
• 若左側目前值小於右側目前值，代表左側從目前位置到中點的所有值都小於這個右側值，於是可以一次累加這些配對數量。

這種寫法本質上和「逆序對」很像，只是逆序對通常統計的是 $A_i>A_j$，這裡改成統計 $A_i<A_j$。因此標準 merge sort 求逆序對時，常見寫法會維持由小到大排序；而這裡為了方便一次統計左側有多少值小於右側目前值，合併方向改成由大到小。只要把合併方向與計數條件對應好，就能在分治過程中把所有合法配對算完。

複雜度分析

• 時間複雜度：$\mathcal{O}(n\log n)$，每一層分治都會線性合併一次，總共有 $\log n$ 層。
• 空間複雜度：$\mathcal{O}(n)$，合併時需要暫存陣列，遞迴深度為 $\mathcal{O}(\log n)$。

Code

方法一：有序容器上二分

1
2
3
4
5
6
7
8
9
10

class Solution:
    def countMajoritySubarrays(self, nums: List[int], target: int) -> int:
        ans = s = 0
        sl = SortedList()
        sl.add(0)
        for x in nums:
            s += 1 if x == target else -1
            ans += sl.bisect_left(s)
            sl.add(s)
        return ans

方法二：二維偏序，逆序對問題

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

class BIT:  # PURQ, 1-based
    __slots__ = ["tree"]

    def __init__(self, n: int):
        self.tree = [0] * (n + 1)

    def add(self, k: int, x: int) -> None:  # 令 nums[k] += x
        while k < len(self.tree):
            self.tree[k] += x
            k += k & -k

    def preSum(self, k: int) -> int:  # 求 nums[:k+1] 之和
        res = 0
        while k > 0:
            res += self.tree[k]
            k -= k & -k
        return res

    def query(self, l: int, r: int) -> int:  # 求 nums[l:r+1] 之和
        if l > r:
            return 0
        return self.preSum(r) - self.preSum(l - 1)


class Solution:
    def countMajoritySubarrays(self, nums: List[int], target: int) -> int:
        n = len(nums)

        ans = 0
        s = n + 1  # offset 為 n + 1，起始為 0 + offset = n + 1
        bit = BIT(2 * n + 1)  # [-n, n] -> [1, 2n + 1]
        bit.add(s, 1)
        for x in nums:
            s += 1 if x == target else -1
            ans += bit.query(1, s - 1)
            bit.add(s, 1)
        return ans

方法三：動態維護小於目前值的數量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Solution:
    def countMajoritySubarrays(self, nums: List[int], target: int) -> int:
        n = len(nums)
        cnt = [0] * (2 * n + 1)  # [-n, n] => [0, 2n]

        # s = cnt_target - cnt_other
        s = n  # offset 為 n，起始為 0 + offset = n
        cnt[s] = 1
        # lt = 有多少個前綴下標 i 滿足 i < j 且 s[i] < s[j]
        ans = lt = 0
        for x in nums:
            if x == target:
                lt += cnt[s]
                s += 1
            else:
                lt -= cnt[s - 1]
                s -= 1
            ans += lt
            cnt[s] += 1
        return ans

方法四：分治

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Solution4:
    def countMajoritySubarrays(self, nums: List[int], target: int) -> int:
        n = len(nums)

        A = list(accumulate((1 if x == target else -1 for x in nums), initial=0))

        def cdq(left, right):
            if left >= right:
                return 0
            mid = (left + right) // 2
            res = cdq(left, mid) + cdq(mid + 1, right)

            # 如果左右兩側已經有序，則不需要合併，且不會產生逆序對
            if A[mid] >= A[mid + 1]:
                return res

            # 使用 Merge Sort 將左右兩側合併（從大到小排列），並計算逆序對數量
            i, j = left, mid + 1
            tmp = []
            while i <= mid or j <= right:
                if j > right or i <= mid and A[i] >= A[j]:
                    tmp.append(A[i])
                    i += 1
                else:
                    tmp.append(A[j])
                    # 逆序對數量，即滿足原始陣列中 i < j 且 A[i] < A[j] 的數量（本題為由大到小）
                    res += mid - i + 1
                    j += 1
            A[left : right + 1] = tmp
            return res

        return cdq(0, n)

Problem Statement

Constraints

思路：前綴和枚舉子陣列

如果直接枚舉子陣列的所有左右端點 $[l, r]$，再逐段統計 target 出現次數，會多出一層掃描，整體為 $O(n^3)$，以本題的數據範圍來說是不接受的，因此需要可以考慮能不能把「某段裡 target 是否為多數元素」變成 $O(1)$ 判定。

等價轉換

對一個子陣列，設 target 的出現次數為 $cnt_{target}$，其餘元素的出現次數為 $cnt_{other}$。題目要求 target 出現次數嚴格超過子陣列長度的一半，也就是：

$$cnt_{target} > cnt_{other}$$

移項後，條件等價於：

$$cnt_{target} - cnt_{other} > 0$$

因此可以把子陣列中的每個元素做如下轉換：

• 等於 target 的位置記為 $+1$
• 不等於 target 的位置記為 $-1$

那麼一段子陣列的轉換後總和，正好就是：

$$cnt_{target} - cnt_{other}$$

所以問題變成：計算有多少個子陣列的轉換後區間和大於 $0$。

用前綴和做到快速判定

有了上述轉換後，只要建立轉換陣列的前綴和，就能在 $O(1)$ 時間求出任意子陣列的總和。

不妨設轉換後的陣列為 $B$，其中：

$$B_i = \begin{cases}1, & \text{if } nums[i] = target \\-1, & \text{if } nums[i] \neq target\end{cases}$$

定義前綴和：

$$s_i = \sum_{k=0}^{i-1} B_k, \quad s_0 = 0$$

對於子陣列 $[l,r]$，如果前綴和差值滿足：

$$s_{r+1} - s_l > 0$$

就表示這段子陣列的 $cnt_{target} - cnt_{other} > 0$，也就是 target 是多數元素。

因此只要枚舉所有子陣列，用前綴和差值判斷是否滿足題意即可。這樣就能把原本 $O(n^3)$ 的解法，降到 $O(n^2)$。

複雜度分析

• 時間複雜度：$\mathcal{O}(n^2)$，需要枚舉所有子陣列。
• 空間複雜度：$\mathcal{O}(n)$，需要儲存轉換後的前綴和。

Code

1
2
3
4
5
6
7
8
9
10

class Solution:
    def countMajoritySubarrays(self, nums: List[int], target: int) -> int:
        n = len(nums)
        s = list(accumulate((1 if (x == target) else -1 for x in nums), initial=0))
        ans = 0
        for i in range(n):
            for j in range(i + 1):
                if s[i + 1] - s[j] > 0:
                    ans += 1
        return ans

Problem Statement

Constraints

思路：DP 線性轉移 + 矩陣快速冪

注意兩題的差別只在資料範圍：

• 在 I 中 $n,V \le 2000$，可以逐步做 DP；
• 而在 II 中 $n$ 放大到 $10^9$，但值域縮小到 $V \le 75$。

現在問題變成：轉移輪數非常多，但狀態數非常少。而逐步 DP 的瓶頸在 $n$，不是 $V$，通常這種情況要把 $n$ 利用快速冪壓縮到 $\log n$，由於下一層的狀態是前綴和 / 後綴和，可以表示成上一層狀態的線性組合，因此可以把「從上一層 DP 到下一層 DP」寫成一個轉移矩陣，然後用矩陣快速冪計算。

方法一：拚接兩個狀態向量

回顧定義

接續 LeetCode 🔴 3699. Number of ZigZag Arrays I 的雙狀態 DP，延續之前定義的 $f_0$ 和 $f_1$。

• $f_0[i][j]$：考慮前 $i$ 個數，最後一個數字為 $j$，且最後一步是上升的方案數。
• $f_1[i][j]$：考慮前 $i$ 個數，最後一個數字為 $j$，且最後一步是下降的方案數。

初始值：

$$f_0[1][j]=f_1[1][j]=1$$

把狀態轉換成向量形式，並找出轉移矩陣

由於轉移其實就是把 $f_0$ 更新為 $f_1$ 的 prefix sum、把 $f_1$ 更新為 $f_0$ 的 suffix sum，兩者交替進行，所以可以把兩個方向的狀態拼成一個長度為 $2V$ 的向量，然後寫出一個 $2V \times 2V$ 的轉移矩陣。

令：

$$\mathbf f_i =\begin{bmatrix}f_0[i][0] & f_0[i][1] & \cdots & f_0[i][V-1] & f_1[i][0] & f_1[i][1] & \cdots & f_1[i][V-1]\end{bmatrix}^{\mathsf T}$$

初始向量為全 $1$：

$$\mathbf f_1 =\begin{bmatrix}1 & 1 & \cdots & 1 & 1 & 1 & \cdots & 1\end{bmatrix}^{\mathsf T}$$

目標是找到一個 $2V \times 2V$ 的矩陣 $M$，使得：

$$\mathbf f_i = M\mathbf f_{i-1}$$

由於狀態向量是把 $f_0$ 與 $f_1$ 拼接起來，且 $f_0$ 的狀態依賴於 $f_1$、$f_1$ 的狀態依賴於 $f_0$，因此 $M$ 可以直接寫成如下的分塊矩陣：

$$M=\begin{bmatrix}0 & A \\B & 0\end{bmatrix}$$

其中：

$$A_{i,j}=[j<i],\qquad B_{i,j}=[j>i]$$

利用矩陣快速冪計算答案

所以：

$$\mathbf f_n = M^{n-1}\mathbf f_1$$

利用矩陣快速冪計算，答案為 $\sum_x \mathbf f_n[x]$。

複雜度分析

• 時間複雜度：$\mathcal{O}(V^3\log n)$。矩陣大小為 $2V\times 2V$，一次矩陣乘法需要 $\mathcal{O}((2V)^3)=\mathcal{O}(V^3)$；快速冪需要做 $\mathcal{O}(\log n)$ 次矩陣乘法。
• 空間複雜度：$\mathcal{O}(V^2)$。需要保存 $2V\times 2V$ 的轉移矩陣，以及長度為 $2V$ 的狀態向量。

方法二：利用對稱性優化，並統一操作方式

接續 LeetCode 🔴 3699. Number of ZigZag Arrays I 的方法二和方法三，可以利用對稱性優化，並把操作統一成：做「嚴格前綴和」之後「反轉」。

因此只需要維護一個長度為 $V$ 的狀態向量 $\mathbf f_i$，且轉移矩陣 $M$ 的大小也只需要 $V\times V$。

由於反轉後新位置 $x$ 對應原位置 $V-1-x$，所以：

$$M[x][j] = 1 \quad \Longleftrightarrow \quad j < V-x-1$$

也就是反對角線左上方全為 $1$，其餘為 $0$。

因此：

$$\mathbf f_n = M^{n-1}\mathbf f_1,\qquad \mathbf f_1=\mathbf 1$$

由於只計算了一半的答案，因此最終答案要 $\times 2$。答案為：

$$2\sum_x \mathbf f_n[x]$$

複雜度分析

• 時間複雜度：$\mathcal{O}(V^3\log n)$。矩陣大小降為 $V\times V$，一次矩陣乘法為 $\mathcal{O}(V^3)$，快速冪需要 $\mathcal{O}(\log n)$ 次乘法；相比方法一，主要是常數因子更小。
• 空間複雜度：$\mathcal{O}(V^2)$。需要保存 $V\times V$ 的轉移矩陣與長度為 $V$ 的狀態向量。

Code

方法一：拚接兩個狀態向量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53