🔗 ABC381F 1122 Subsequence

Problem Statement

Constraints

思路：狀態壓縮 DP 維護最早結尾位置

問題本質與突破口

題目要求選出一個 1122 子序列：每種被選中的數字恰好出現兩次，且這兩次必須相鄰構成一個「對」。

注意約束條件，關鍵限制是 $A_i \leq 20$，值域僅 20 種數字，遠小於序列長度 $N \leq 2 \times 10^5$。

由於每種數字只能選擇「不選（0 次）」或「選（2 次）」兩種狀態，我們可以用一個 $20$-bit 的遮罩來表示已選數字的集合。這樣總共有 $2^{20} \approx 10^6$ 種狀態，對 DP 來說是可行的。

狀態設計：最早結尾的貪心策略

對於一個已選數字集合 $S$，在原序列中可能存在多種不同的 1122 子序列選法（相同集合但用不同位置）。我們需要從中選出「最有利於後續擴展」的那一種。

• 定義：$f[S]$ 表示選取集合 $S$ 中的數字構成合法 1122 子序列時，該子序列在陣列中的最早結尾位置（0-indexed）。
• 初始狀態：空集合的結尾設為 $-1$（代表「序列開頭之前」），其餘狀態初始化為 $N$（代表無窮大，表示尚未找到合法構造）。

轉移：加入一對新數字

假設已知狀態 $S'$ 的最早結尾位置為 $p = f[S']$，現在想加入數字 $x$（$x \notin S'$）形成新狀態 $S = S' \cup \{x\}$。

加入 $x$ 的配對必須滿足兩個條件：

1. 兩個 $x$ 的位置都嚴格在 $p$ 之後（不與已選子序列重疊）
2. 與前述的貪心策略類似，這裡選擇最早的兩個 $x$ 來配對，確保新狀態 $S$ 的結尾位置盡可能早。

可以預處理每個數字 $x$ 的出現位置列表，在該列表中找到第一個嚴格大於 $p$ 的位置，然後再取下一個位置作為配對的第二個元素。這樣就能確定新狀態 $S$ 的結尾位置。

若 $f[S] < N$（即狀態 $S$ 存在合法構造），則集合大小 $|S|$ 為可選取的數字種類數。每種數字貢獻長度 $2$，故總長度為 $2 \times |S|$。

複雜度分析

• 時間複雜度：$\mathcal{O}(N + K \cdot 2^K \log N)$，其中 $K = 20$。
  • 預處理 $O(N)$，建立每個元素對應的位置列表；
  • DP 枚舉 $2^K$ 個狀態，每個狀態遍歷其設定位元（均攤每狀態 $O(K)$），每次二分搜尋 $O(\log N)$。
• 空間複雜度：$\mathcal{O}(N + 2^K)$。位置表儲存所有 $N$ 個索引；DP 陣列大小 $2^K$。

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

from bisect import bisect_left

M = 20


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

    pos = [[] for _ in range(M + 1)]
    for i, v in enumerate(A):
        pos[v - 1].append(i)

    # f[mask] = 選取集合 mask 構成 1122 子序列的最早結尾位置
    f = [n] * (1 << M)
    f[0] = -1

    ans = 0
    for s in range(1 << M):
        # 枚舉 s 中每個位元作為「最後加入的數字」，嘗試從 s\{j} 轉移
        t = s
        while t:
            lb = t & -t
            j = lb.bit_length() - 1
            # 在 j 的位置表中找第一個 > f[s\{j}] 的索引，+1 即為配對的第二個位置
            idx = bisect_left(pos[j], f[s ^ lb]) + 1
            if idx < len(pos[j]):
                f[s] = min(f[s], pos[j][idx])
            t ^= lb
        if f[s] < n:
            ans = max(ans, s.bit_count())
    print(ans << 1)


if __name__ == "__main__":
    solve()

🔗 ABC381E 11/22 Subsequence

Problem Statement

Constraints

思路：二分答案

一個合法的 11/22 子序列長度一定是奇數，並且可以寫成：

$$k \text{ 個 } 1 + 1 \text{ 個 } / + k \text{ 個 } 2$$

因此，問題轉化為：對每個查詢區間，找出最大的 $k$，使得區間內能依序選出 $k$ 個 1、一個 /、再 $k$ 個 2。答案即為 $2k+1$。

為什麼可以二分答案

若 $k$ 可行，則任何更小的 $k' < k$ 也必然可行——只需捨棄多餘的配對，因此可行性具有單調性，故每個查詢可以對 $k$ 進行二分搜尋，找出最大的可行值。

檢查給定的 $k$ 是否可行

要檢查 $k$ 是否可行，最寬容的貪心策略是讓 1 盡量靠左、2 盡量靠右，以最大化中間能放 / 的範圍：

• 在查詢區間內，取左側第 $k$ 個 1 的位置。
• 在查詢區間內，取右側倒數第 $k$ 個 2 的位置。

若這兩個位置之間至少存在一個 /，則 $k$ 可行——選這兩個位置之間的任一個 / 即可配對。

反之，若這樣最寬容的安排都找不到中間的 /，任何其他選法只會讓 / 的可用範圍更窄，因此 $k$ 必然不可行。

找到區間內左側第 $k$ 個 1 和右側倒數第 $k$ 個 2 的位置，可以用二分搜尋在預先記錄的 1 和 2 的位置列表中找到。檢查兩個位置之間是否有 /，則可以用前綴和在 $\mathcal{O}(1)$ 時間內完成。

複雜度分析

• 時間複雜度：$\mathcal{O}(N + Q \log^2 N)$
  • 預處理 $N$ 個字元的位置信息和前綴和需要 $\mathcal{O}(N)$。
  • 對於每個查詢，二分答案 $k$ 需要 $\mathcal{O}(\log N)$，每次檢查 $k$ 的可行性又需要兩次二分搜尋（各 $\mathcal{O}(\log N)$）和一次前綴和查詢（$\mathcal{O}(1)$），總計 $\mathcal{O}(\log^2 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

from bisect import bisect_left, bisect_right
from collections import defaultdict
from itertools import accumulate


def solve():
    n, q = map(int, input().split())
    s = input()
    assert len(s) == n

    # 記錄每個字元出現的所有位置 (1-indexed)
    pos = defaultdict(list)
    for i, ch in enumerate(s, start=1):
        pos[ch].append(i)

    # '/' 的前綴和：ss[i] = s[1..i] 中 '/' 的個數
    ss = list(accumulate(map(lambda ch: ch == "/", s), initial=0))

    for _ in range(q):
        l, r = map(int, input().split())

        # 區間內沒有 '/' 則不可能形成 11/22
        if ss[r] - ss[l - 1] == 0:
            print(0)
            continue

        def check(mid: int) -> bool:
            # 在 [l, r] 內找第 mid 個 '1' 的位置
            idx1 = bisect_left(pos["1"], l) + mid - 1
            # 在 [l, r] 內找倒數第 mid 個 '2' 的位置
            idx2 = bisect_right(pos["2"], r) - mid
            if idx1 >= len(pos["1"]) or idx2 < 0:
                return False
            ll, rr = pos["1"][idx1], pos["2"][idx2]
            # [ll, rr] 之間是否有至少一個 '/'
            return ss[rr] - ss[ll - 1] > 0

        # 二分搜尋最大的可行 k
        left, right = 1, r - l + 1
        while left <= right:
            mid = (left + right) >> 1
            if check(mid):
                left = mid + 1
            else:
                right = mid - 1
        # 答案 = 2k + 1
        print(1 + (right << 1))


if __name__ == "__main__":
    solve()

🔗 ABC381D 1122 Substring

Problem Statement

Constraints

思路：依配對起點分組，做兩次滑動窗口

1122 序列要求子陣列長度為偶數，且可切成若干相鄰二元組，每組內兩元素相等、組間數字不重複。直接枚舉所有子陣列是 $\mathcal{O}(N^2)$，不可行。

因此，分別以兩種起點掃描，每次前進兩格。在每種起點下，問題轉化為：在一串二元組上，找最長連續不重複數字區間，可用滑動窗口解決：

• 右端點每次向右移動兩個位置：若該組兩元素不相等，則窗口必須在此斷裂——左端點跳到下一組起點，計數器清空重來。
• 若兩元素相等，檢查該數字是否已在窗口內出現：若已出現，則不斷收縮左端點，直到不再重複為止。
• 每成功加入一組後，以目前窗口長度更新答案即可。

複雜度分析

• 時間複雜度：$\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
28
29
30

from collections import defaultdict


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

    def calc(st: int) -> int:
        res = 0
        left = st
        cnt = defaultdict(int)
        for i in range(st, n - 1, 2):
            x = A[i]
            if x != A[i + 1]:
                left = i + 2
                cnt.clear()
                continue
            while cnt[x] > 0:
                cnt[A[left]] -= 1
                left += 2
            cnt[x] += 1
            res = max(res, i + 2 - left)
        return res

    print(max(calc(0), calc(1)))


if __name__ == "__main__":
    solve()

🔗 ABC457F Second Gap

Problem Statement

Constraints

思路：排列 DP (Permutation DP)

題目要求我們構造排列，使得每個後綴的「最大值」與「次大值」距離都符合給定的 $D$ 陣列。

與其直接構造整個排列，不如從右到左（從最短後綴到最長後綴）逐步加入元素，觀察最大值與次大值的變化。

基於上述觀察，我們可以定義狀態：令 $f[i][j]$ 表示在目前後綴 $[i, N)$ 中，最大值位於位置 $j$ 的合法排列數。

初始狀態為最後兩個位置，無論誰大誰小，最大值與次大值的距離必然是 $1$，因此最大值在倒數第一或倒數第二個位置的方案數皆為 $1$。

狀態轉移推導

當我們從右往左處理到 $i$ 時，令目標位置 $j = i + D_i$。只有當舊後綴的最大值恰好落在 $j$ 時，新元素才有機會成為新的最大值或次大值。

我們將新元素的加入分為三種情況討論，並採用刷表法 (Forward DP) 的視角，將 $f[i + 1][j]$ 的方案數推演至 $f[i]$：

1. 成為新的最大值：舊後綴的最大值退居次大值。為了滿足距離要求，舊最大值必須在目標位置 $j$。轉移後，新的最大值位置變成目前位置 $i$。

   $$f[i][i] \gets f[i][i] + f[i + 1][j]$$

2. 成為新的次大值：舊後綴的最大值蟬聯冠軍。同樣地，舊最大值必須在目標位置 $j$。轉移後，最大值位置依然在目標位置 $j$。

   $$f[i][j] \gets f[i][j] + f[i + 1][j]$$

3. 排在第三名以後：最大值與次大值的人選和位置都不變。這意味著目前後綴的距離要求必須與上一個後綴完全相同（即 $D_i = D_{i+1}$）。此時新元素可以安插在第 $3$ 名到最後一名的任何順位。由於 $[i, n)$ 中共有 $N - i + $1 個元素，扣掉最大值與次大值後，共有 $N - i - 1$ 種選擇。對於所有合法的舊最大值位置 $k$，皆有：

   $$f[i][k] \gets f[i][k] + f[i + 1][k] \times (N - i - 1) \quad \text{for } k \in [i + 1, N)$$

優化轉移

由於 $N$ 可達 $2 \times 10^5$，顯然逐個位置維護二維 $f$ 值的方法肯定會超時。但觀察轉移方程式可以發現，前兩種情況只需要知道 $f[i + 1][j]$ 的值，而第三種情況則是對整個後綴的狀態進行區間乘法。

如果先做第三種情況的區間乘法更新，再做第一與第二種情況的點更新，則不會互相干擾。因此每一輪的轉移可以簡化為三個步驟，且我們只需要滾動維護一維狀態：

1. 先將目標位置的方案數 $f[i + 1][j]$ 提取出來備用。
2. 批次更新：對應第三種情況。若距離要求相同，將所有既有狀態乘上可選順位數 $(N - i - 1)$；若不同，則清空所有狀態。
3. 點更新：對應第一與第二種情況。將剛才提取的方案數，分別加到「目前位置 $i$」與「目標位置 $j$」上。

最終答案即為 $\sum_{k=0}^{N-1} f[0][k]$。

方法一：懶標記線段樹(Lazy Segment Tree)

由於狀態轉移涉及「全域乘法」與「單點加法」，最直覺的作法是使用支援區間修改的資料結構。

我們可以用一棵懶標記線段樹來維護每個位置作為最大值的方案數。每次轉移時，先單點查詢目標位置的值。接著根據 $D_i$ 是否等於 $D_{i+1}$，對 $[i + 1, n)$ 的區間套用區間乘法（乘上順位數或乘上 $0$）。最後再用單點加法將備用的值加回目前位置 $i$ 與目標位置 $j$。

最終，線段樹上所有位置的方案數總和即為答案。

複雜度分析

• 時間複雜度：$\mathcal{O}(N \log N)$，每次轉移需要進行線段樹的單點與區間操作。
• 空間複雜度：$\mathcal{O}(N)$，線段樹所需的空間。

方法二：全域乘法標記

再看一次懶線段樹的操作，可以發現區間乘法其實只是在「所有目前有效的狀態」上一起乘同一個係數。既然每個狀態都被乘上相同的數，就不必真的逐一更新；只要把這個共同倍率另外記下來即可。

因此我們維護一個全域倍率，並讓表中的值滿足以下不變量：

$$\text{實際方案數} = \text{表中儲存值} \times \text{全域倍率}$$

在這個不變量下，三種操作分別變成：

• 讀取狀態：先取出表中儲存值，再乘上全域倍率，還原成真正的方案數。
• 批次乘法：若距離要求相同，只需要更新全域倍率；若距離要求不同，所有舊狀態都不再合法，直接清空表並把倍率重設為 $1$。
• 新增狀態：新產生的方案數本身已經是「實際值」。但表中不能直接存實際值，否則之後讀取時還會再乘一次全域倍率。因此寫入前要先乘上目前全域倍率的反元素，把它換回表中應該儲存的形式。

由於模數 $998244353$ 是質數，而且有效狀態下的全域倍率不會變成 $0$，所以可以用模反元素完成這個還原。當距離要求不同、理論上要把舊狀態乘成 $0$ 時，程式直接清空表並重設倍率，避免了除以 $0$ 的問題。

最後，把表中所有儲存值加總，再乘回全域倍率，就能得到所有合法排列數。這個作法省去了線段樹的對數操作，實作也更輕量。

複雜度分析

• 時間複雜度：$\mathcal{O}(N \log \text{MOD})$，主要瓶頸在於每次寫入時計算模反元素的快速冪。
• 空間複雜度：$\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

from atcoder.lazysegtree import LazySegTree

MOD = 998244353


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

    def op(x: int, y: int) -> int:
        return (x + y) % MOD

    def mapping(f: int, x: int) -> int:
        return (f * x) % MOD

    def composition(f: int, g: int) -> int:
        return (f * g) % MOD

    f = LazySegTree(op, 0, mapping, composition, 1, n)
    f.set(n - 1, 1)
    f.set(n - 2, 1)
    for i in range(n - 3, -1, -1):
        j = i + D[i]
        fj = f.get(j)  # f[i + 1][j]

        if D[i] == D[i + 1]:
            f.apply(i + 1, n, n - i - 2)
        else:
            f.apply(i + 1, n, 0)

        f.set(i, op(f.get(i), fj))
        f.set(j, op(f.get(j), fj))

    print(f.all_prod())


if __name__ == "__main__":
    solve()

方法二：全域乘法標記

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

from collections import defaultdict

MOD = 998244353


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

    f = defaultdict(int)
    f[n - 2] = f[n - 1] = 1
    mul = 1

    for i in range(n - 3, -1, -1):
        j = i + D[i]
        fj = f[j] * mul % MOD  # f[i+1][j]

        if D[i] == D[i + 1]:
            c = n - i - 2
            mul = mul * c % MOD
        else:
            f.clear()
            mul = 1
        add = fj * pow(mul, MOD - 2, MOD) % MOD
        f[i] = (f[i] + add) % MOD
        f[j] = (f[j] + add) % MOD

    ans = sum(v for v in f.values()) * mul % MOD
    print(ans)


if __name__ == "__main__":
    solve()

🔗 ABC457G Catch All Apples

Problem Statement

Constraints

思路：座標轉換 + Dilworth 定理

把可達性條件寫成不等式

考慮兩顆蘋果，假設前者的時間和位置為 $(T_i, X_i)$，後者為 $(T_j, X_j)$ 且 $T_i \le T_j$。同一個機器人能不能先接住前者再接後者？

機器人速度上限為 $1$，所以唯一的要求是：兩者的時間差足以覆蓋位置差，也就是 $|X_j - X_i| \le T_j - T_i$。

展開絕對值得到兩條不等式：

$$\begin{cases}X_j - X_i \le T_j - T_i \\[4pt]X_i - X_j \le T_j - T_i\end{cases}$$

整理後分別得到：

$$T_i + X_i \le T_j + X_j,\quad T_i - X_i \le T_j - X_j$$

兩者必須同時成立。也就是說，定義兩個轉換值 $u = T + X$ 和 $v = T - X$，則可接續的充要條件就是 $u_i \le u_j$ 且 $v_i \le v_j$。

從最少人數到最大反鏈

每顆蘋果對應到 $u$-$v$ 平面上的一個點。若 $i$ 能接續到 $j$，表示它們可由同一個機器人處理。因此，一條合法的受理序列對應到平面上兩座標都不下降的一條點列（鏈）。

題目問最少需要幾條不下降鏈才能覆蓋所有點——這正是偏序集的最少鏈覆蓋問題。

做過 P1020 [NOIP 1999 提高组] 导弹拦截 的讀者可能對這個轉換不陌生：根據 Dilworth 定理：在有限偏序集中，最少鏈覆蓋數等於最大反鏈的大小。

這裡的反鏈是一組兩兩不可接續的蘋果——任取兩顆，都無法排進同一個機器人的受理順序中。換句話說，對反鏈中的任意兩點 $i, j$，不能同時滿足 $u_i \le u_j$ 且 $v_i \le v_j$（否則它們就是可接續的）。

刻畫反鏈：v 的嚴格下降子序列

反鏈的條件——任意兩點不能同時滿足 $u_i \le u_j$ 且 $v_i \le v_j$ 的條件，只涉及點在兩個維度上的相對大小，與它們在序列中的出現順序無關。因此，為了方便判斷，我們可以先按 $u$ 排序，這並不會改變任何一對點是否構成反鏈。

在排序後的序列上，對任意滿足 $i < j$ 的兩點，$u_{i} \le u_{j}$ 已由順序自動保證。若它們同屬一個反鏈，$v_{i} \le v_{j}$ 就不能成立。這迫使反鏈內部的第二座標必須遞減：$v_{i} > v_{j}$，即 $v$ 沿序列嚴格下降。

反過來看，凡 $v$ 嚴格下降的子序列，其中任兩點必不滿足 $v_{i} \le v_{j}$，因此不滿足可接續條件，確實是合法反鏈。

綜上，$v$ 的嚴格下降子序列與反鏈一一對應，最長者的長度即為最大反鏈大小。

複雜度分析

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

類題

• P1020 [NOIP 1999 提高组] 导弹拦截
• P5939 [POI 1998 R3] 折线

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

from bisect import bisect_left


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

    points = []
    for i in range(n):
        t, x = map(int, input().split())
        points.append((t + x, t - x))
    points.sort()

    # 求 v 的 LDS 長度
    f = []
    for _, v in points:
        idx = bisect_left(f, -v)
        if idx == len(f):
            f.append(-v)
        else:
            f[idx] = -v
    print(len(f))


if __name__ == "__main__":
    solve()

🔗 ABC457E Crossing Table Cloth

Problem Statement

Constraints

思路：端點分組 + 後綴最小值預處理

從條件拆解

題目要求恰好選兩塊桌布覆蓋指定的連續區間，且不能蓋到區間以外的格子，這包含了三個條件：

1. 必須有一塊桌布恰好從詢問左端點 $S$ 出發——若起點更左，會蓋到區間外的格子。
2. 必須有一塊桌布恰好到詢問右端點 $T$ 結束——若終點更右，同樣會超出。
3. 兩塊桌布的覆蓋區域必須銜接（可重疊，但不能有空隙）。

因此，每筆詢問的答案取決於：是否存在左端恰為 $S$ 的桌布，以及右端恰為 $T$ 的桌布，且兩者的覆蓋範圍能串成一段。

對於左端同為 $S$ 的所有桌布，右端越遠、涵蓋越廣，越容易和右側的桌布接上。對右端同為 $T$ 的桌布同理，左端越靠左、越容易和左側的桌布接上。因此我們可以在範圍內找出「最佳候選」：左端為 $S$ 的桌布中右端最遠的，以及右端為 $T$ 的桌布中左端最靠近的。

情況一：存在恰好覆蓋 $[S, T]$ 的桌布

若存在恰好覆蓋 $[S,T]$ 的桌布，從左端 $S$ 和右端 $T$ 各自選出的最佳候選會指向同一塊桌布，違反必須選取兩塊不同桌布的限制。

此時需另找一塊桌布搭配，而能被選為第二塊的桌布，其覆蓋範圍必須完全落在 $[S,T]$ 內（否則會超出詢問區間）。所有落在 $[S,T]$ 內的桌布可歸為以下三種情形：

1. 完全與 $[S,T]$ 重疊：存在兩塊以上完全相同的 $[S,T]$ 桌布，直接取兩塊即可。
2. 左端比 $S$ 靠右，且右端不超過 $T$：存在一塊桌布滿足左端 $\ge S+1$、右端 $\le T$。
3. 右端比 $T$ 靠左，且左端不低於 $S$：存在一塊桌布滿足左端 $\ge S$、右端 $\le T-1$（即右端 $< T$）。

後綴最小值預處理

情形 1 可直接由計數器判斷。情形 2 和 3 則需要回答一類共同問題：「是否存在某塊桌布，左端不小於 $x$、且右端不大於 $y$？」。

為此預處理一個後綴最小值陣列：對每個位置 $x$，記錄「所有左端 $\ge x$ 的桌布中，右端的最小值」。這樣一來，對任意查詢只需 $O(1)$ 時間——直接在該位置上讀取後綴最小值，並與 $y$ 比較即可。

對應到程式邏輯：

• 情形 2：查位置 $S+1$ 的後綴最小值是否 $\le T$
• 情形 3：查位置 $S$ 的後綴最小值是否 $< T$

情況二：根據端點分組，二分找最佳候選

若不存在恰好覆蓋 $[S,T]$ 的桌布，就必須從左端為 $S$ 的群組中選一塊、從右端為 $T$ 的群組中選另一塊，並確認兩塊的覆蓋範圍能無縫銜接。

前面的交換論證已經指出：對每個端點群組，只需考慮該組內的「最佳候選」——左端 $S$ 的群組中右端最遠的那塊、右端 $T$ 的群組中左端最靠左的那塊。因此每筆詢問的要務就是快速定位出這兩個候選。

分組與排序：

• 將桌布按左端點分組，每組內依右端點遞增排序。
• 將桌布按右端點分組，每組內依左端點遞增排序。

對詢問 $(S, T)$ 的查詢：

• 在左端為 $S$ 的群組中，二分找出右端不超過 $T$ 的最大值——即最後一個 $\le T$ 的元素。這保證選出的桌布不會超出詢問區間的右界。
• 在右端為 $T$ 的群組中，二分找出左端不小於 $S$ 的最小值——即第一個 $\ge S$ 的元素。這保證選出的桌布不會超出詢問區間的左界。

銜接檢查：找到兩塊候選後，比較左側候選的右端 $+1$ 與右側候選的左端。若前者不小於後者，表示兩段覆蓋之間不存在未被覆蓋的空隙（可能重疊或恰好相鄰）；否則兩段之間有遺漏的格子，判定為失敗。

複雜度分析

• 時間複雜度：$\mathcal{O}((M+Q)\log M + N)$
• 空間複雜度：$\mathcal{O}(M+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

from collections import defaultdict
from bisect import bisect_left, bisect_right
from itertools import accumulate


def solve():
    n, m = map(int, input().split())
    intervals = [tuple(map(int, input().split())) for _ in range(m)]

    cnt = defaultdict(int)
    byL = defaultdict(list)  # L -> List[(R, idx)]
    byR = defaultdict(list)  # R -> List[(L, idx)]
    minR_at_L = [float("inf")] * (n + 1)

    for i, (l, r) in enumerate(intervals):
        cnt[(l, r)] += 1
        byL[l].append(r)
        byR[r].append(l)
        minR_at_L[l] = min(minR_at_L[l], r)

    for l, arr in byL.items():
        arr.sort()
    for r, arr in byR.items():
        arr.sort()

    # suf[x] = 所有 L >= x 的桌布中，最小的 R
    suf = list(accumulate(minR_at_L[::-1], min, initial=float("inf")))[::-1]

    q = int(input())
    for _ in range(q):
        s, t = map(int, input().split())
        if s not in byL or t not in byR:
            print("No")
            continue

        if cnt[(s, t)] > 0:
            ok = False
            ok |= cnt[(s, t)] >= 2  # 有兩塊以上完全相同的 [s, t]
            ok |= suf[s + 1] <= t  # 存在 L > s 且 R <= t 的桌布
            ok |= suf[s] < t  # 存在 L >= s 且 R < t 的桌布
            print("Yes" if ok else "No")
            continue

        idx1 = bisect_right(byL[s], t) - 1
        idx2 = bisect_left(byR[t], s)

        if idx1 < 0 or idx2 == len(byR[t]):
            print("No")
            continue

        r = byL[s][idx1]
        l = byR[t][idx2]

        if l > r + 1:
            print("No")
        else:
            print("Yes")


if __name__ == "__main__":
    solve()

🔗 ABC457D Raise Minimum

Problem Statement

Constraints

思路：二分答案

這題要最大化「所有元素中的最小值」。如果直接模擬每一次操作，會卡在操作次數可能很大；但我們其實不需要知道每一步怎麼做，只需要判斷某個候選最小值能不能被達成。

如何檢查一個目標值

假設現在想讓所有元素都至少變成某個目標值。對於已經不小於目標值的元素，不需要做任何事；對於還不夠大的元素，就必須補足差距。

第 $i$ 個元素每操作一次可以增加 $i$，因此若它距離目標值還差 $d$，至少需要

$$\left\lceil \frac{d}{i} \right\rceil$$

次操作才能補到目標值以上。把所有不足元素需要的操作次數加總，如果總和不超過 $K$，代表這個目標值可行；反之不可行。

二分範圍

答案的下界可以從目前陣列的最小值開始，因為即使不做任何操作，最小值也至少是這個數。

答案的上界可以用「把所有操作都集中在某一個元素上」後，各元素各自能到達的最大值取最小：

$$\min_i(A_i + iK)$$

真正的答案不可能超過這個值，因為任一元素最多也只能被操作 $K$ 次。

複雜度分析

• 時間複雜度：$\mathcal{O}(N \log V)$，其中 $V$ 是答案二分的值域大小。
• 空間複雜度：$\mathcal{O}(1)$，除了輸入陣列外只使用常數額外空間。

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

def solve():
    n, k = map(int, input().split())
    A = list(map(int, input().split()))

    def check(mid: int) -> bool:
        left_k = k
        for i, x in enumerate(A, start=1):
            if x >= mid:
                continue
            # 使用 math.ceil 會有浮點數誤差
            # left_k -= math.ceil((mid - x) / i)
            left_k -= ((mid - x) + i - 1) // i
            if left_k < 0:
                return False
        return True

    left = min(A)
    right = min(x + i * k for i, x in enumerate(A, start=1))
    while left <= right:
        mid = (left + right) // 2
        if check(mid):
            left = mid + 1
        else:
            right = mid - 1
    print(right)


if __name__ == "__main__":
    solve()

🔗 ABC438F Sum of Mex

Problem Statement

Constraints

思路：貢獻轉換與鏈的動態維護

對一條路徑而言，假設它的 mex 是 $m$，這意味著：

1. 路徑上包含 $0, 1, \dots, m-1$
2. 路徑上不包含 $m$

這條路徑對答案的貢獻是 $m$。我們可以將貢獻 $m$ 拆解為：

$$m = \sum_{x=1}^{N} [m \ge x]$$

根據前面的拆解，所有路徑的 mex 總和可以寫成：

$$\sum_{\text{路徑}} m = \sum_{\text{路徑}} \sum_{x=1}^{N} [m \ge x]$$

交換加總順序後得到：

$$\sum_{x=1}^{N} \left( \sum_{\text{路徑}} [m \ge x] \right)$$

而「$\text{mex} \ge x$」等價於「這條路徑包含所有點 $0, 1, \dots, x-1$」。
因此，若令 $g(x)$ 為「包含所有點 $0, 1, \dots, x-1$ 的路徑數量」，那麼所有路徑的 mex 總和即為：

$$\sum_{x=1}^{N} g(x)$$

基礎：包含根節點的路徑數

以點 $0$ 為根。整棵樹的路徑總數為 $\frac{N(N+1)}{2}$，而完全落在某個子樹內的路徑必定不經過根節點。若某子樹大小為 $s$，其內部路徑數為 $\frac{s(s+1)}{2}$。

因此，包含點 $0$ 的路徑數為：

$$g(1) = \frac{N(N+1)}{2} - \sum_{c} \frac{s_c(s_c+1)}{2}$$

維護必要點構成的鏈

要求路徑同時包含點 $0, 1, \dots, x-1$ 時，這些點在樹上的最小連通子圖必須是一條鏈，否則無任何簡單路徑能覆蓋。初始時鏈僅含點 $0$，兩端點重合。

依序加入點 $x$，有兩種情形：

情況一：新點已在鏈上

之前延伸其他點時已順便將其納入，鏈不變，$g(x+1) = g(x)$。

情況二：新點不在鏈上

從新點向父節點方向走，直到首次碰到鏈上的點。

計算包含當前鏈的路徑數

鏈成功延伸後（或確定不變），需要計算涵蓋當前鏈的路徑數量。

一條路徑若要覆蓋整條鏈，其兩端必須分別落在鏈的兩側之外：

• 非根端點：該側必須以端點的子樹內某點結束，可選點數即為端點的子樹大小。
• 根端點（點 $0$）：該側不能落在已被鏈佔用方向的子樹內。因此每當鏈從根向外延伸時，直接將根的「子樹大小」扣除該方向子樹的大小，根的剩餘大小即為該側可選點數。

複雜度分析

• 時間複雜度：$\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
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

import sys

sys.setrecursionlimit(int(3e5))


def main():
    n = int(input())
    g = [[] for _ in range(n)]

    for _ in range(n - 1):
        u, v = map(int, input().split())
        g[u].append(v)
        g[v].append(u)

    pa = [-1] * n
    sz = [1] * n

    def dfs(u, fa):
        pa[u] = fa
        for v in g[u]:
            if v == fa:
                continue
            dfs(v, u)
            sz[u] += sz[v]

    dfs(0, -1)

    # g(1)：路徑包含點 0 的數量
    # 全部路徑數量是 N * (N + 1) // 2
    # 不經過 0 的路徑，一定完全在 0 的某個兒子子樹中
    ans = n * (n + 1) // 2
    for v in g[0]:
        ans -= sz[v] * (sz[v] + 1) // 2

    # vis[x] 表示 x 是否已經在目前維護的路徑上
    vis = [False] * n
    vis[0] = True

    L = R = 0  # 目前維護的最小路徑兩端點
    for x in range(1, n):
        # 如果 x 已經在目前路徑上，新增 x 不會改變條件
        if vis[x]:
            ans += sz[L] * sz[R]
            continue

        # 從 x 往上跳，直到遇到目前路徑上的點 y
        vis[x] = True
        v = x
        while not vis[pa[v]]:
            vis[pa[v]] = True
            v = pa[v]
        y = pa[v]

        # 如果 y 不是目前路徑端點，表示接到路徑中間，會產生分叉
        # 之後不可能存在包含所有 0..x 的簡單路徑
        if y != L and y != R:
            break

        # y 是端點，可以把端點延伸成 x
        if y == L:
            L = x
        else:
            R = x

        # 如果是從根 0 往某個方向延伸，
        # 那麼根這一側能選的端點數量要扣掉 child 這棵子樹
        if y == 0:
            sz[0] -= sz[v]

        # 目前路徑端點是 L, R
        # 可以選的總路徑數量就是兩側大小相乘
        ans += sz[L] * sz[R]

    print(ans)


if __name__ == "__main__":
    main()

🔗 ABC438E Heavy Buckets

Problem Statement

Constraints

思路：倍增

從逐步模擬開始

由於每個桶都只會將水倒入唯一的目標桶，因此從任意起點出發，後續的移動路徑是完全確定的。面對單次查詢，最直覺的做法是逐步模擬：每走一步就將當前所在的桶編號計入總和。

然而，由於操作次數 $T$ 可能非常大，若對每個查詢都進行逐步模擬，整體時間複雜度將與「所有查詢的移動次數總和」成正比，這顯然會導致超時。

這正是「倍增法（Binary Lifting）」的核心思想。

預處理每段長度的終點與總和

為了加速查詢，我們可以定義以下狀態來記錄跳躍資訊：

• $pos[i][j]$：從桶 $i$ 出發，走 $2^j$ 步後會停在哪個桶。
• $val[i][j]$：從桶 $i$ 出發，走 $2^j$ 步途中累加到的桶編號總和。

對於長度為 $2^0 = 1$ 的基礎情況，從桶 $i$ 出發走一步，會先貢獻該桶的編號，接著便移動到其指定的目標桶 $A_i$：

• $pos[i][0] = A_i$
• $val[i][0] = i$

對於更長的移動距離 $2^j$（$j > 0$），我們可以將其拆解為兩段長度為 $2^{j-1}$ 的連續移動。先從起點走完前半段，抵達中繼位置 $pos[i][j-1]$，再從該中繼位置出發走完後半段：

• $pos[i][j] = pos[\,pos[i][j-1]\,][j-1]$
• $val[i][j] = val[i][j-1] + val[\,pos[i][j-1]\,][j-1]$

用二進位拆解查詢

任何整數的移動次數 $T$ 都可以被拆解為若干個 $2^j$ 的總和。因此，在處理查詢時，我們只需將目標步數轉換為二進位表示，並逐位檢查。

設初始位置 $curr = B$，累加答案 $ans = 0$。對於 $T$ 的每一個二進位位元 $j$（從低位到高位）：

• 若 $T$ 的第 $j$ 位元為 $1$，代表需要走這段 $2^j$ 的距離，我們便將預先算好的總和累加，並更新當前位置：
  • $ans \gets ans + val[curr][j]$
  • $curr \gets pos[curr][j]$

透過這種方式，每次查詢最多只需進行 $\log T$ 次跳躍，大幅提升了查詢效率。

複雜度分析

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

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

def solve():
    n, q = map(int, input().split())
    A = list(map(lambda x: int(x) - 1, input().split()))

    pos = [[0] * 32 for _ in range(n)]
    val = [[0] * 32 for _ in range(n)]

    for i, x in enumerate(A):
        pos[i][0] = x
        val[i][0] = i + 1

    for j in range(1, 32):
        for i in range(n):
            pos[i][j] = pos[pos[i][j - 1]][j - 1]
            val[i][j] = val[i][j - 1] + val[pos[i][j - 1]][j - 1]

    for _ in range(q):
        t, b = map(int, input().split())
        b -= 1
        ans = 0
        for i in range(32):
            if (t >> i) & 1:
                ans += val[b][i]
                b = pos[b][i]
        print(ans)


if __name__ == "__main__":
    solve()

🔗 ABC438D Tail of Snake

Problem Statement

Constraints

思路：連續三段的最佳分割

題意要求將序列切成三段，且每段至少有一個元素。也就是說，我們需要最大化：

$$\max_{1 \le l < r \le N-1} \left( \sum_{i=1}^{l} A_i + \sum_{i=l+1}^{r} B_i + \sum_{i=r+1}^{N} C_i \right)$$

如果直接暴力枚舉 $l, r$ 兩個切點可以得到答案，但枚舉會是 $O(N^2)$ 級，顯然是不能接受的。