🔗 🌈 ABC465E Digit Circus

Problem Statement

Constraints

思路：數位 DP

因為 $N$ 最多有 $500$ 位，直接枚舉 $1$ 到 $N$ 顯然是不可行的。這時候可以考慮數位 DP 的方法，按位構造數字，並記錄相同狀態的結果，避免重複計算。

額外狀態

最後要判斷三件事：是否為 $3$ 的倍數、是否包含數字 $3$、是否剛好用了三種不同數字，因此除了數位DP基本的狀態外，還需要維護以下狀態：

• 是否為 $3$ 的倍數，需要維護目前數位和對 $3$ 的餘數 $s \in \{0, 1, 2\}$。
• 是否包含數字 $3$，可以從「出現過的數字集合 $msk$」判斷。
• 是否剛好用了三種不同數字，也可以從同一個集合的大小判斷。

條件判斷

由於我們需要統計恰好滿足一個條件的數字，看似需要使用排容原理，但其實可以直接在每個數字構造完成時檢查三個條件的布林值，並計算它們的總和是否為 $1$。這樣就不需要額外的排容計算。

複雜度分析

• 時間複雜度：$\mathcal{O}(10 \cdot n \cdot 3 \cdot 2^{10})$，其中 $n$ 是 $N$ 的位數。這是因為可記憶化的狀態由 $(i, s, msk)$ 決定，總共有 $n \cdot 3 \cdot 2^{10}$ 種，而每個狀態最多枚舉 $0$ 到 $9$ 這 $10$ 個數字作為下一位。
• 空間複雜度：$\mathcal{O}(n \cdot 3 \cdot 2^{10})$。memo 只需要存所有 $(i, s, msk)$ 狀態的答案。

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

MOD = 998244353


def solve():
    r = input().strip()
    l = 1

    n = len(r)
    diff = n - len(str(l))
    high = list(map(int, str(r)))
    low = list(map(int, str(l).zfill(n)))  # 補前導零，使 low 和 high 對齊

    memo = [[[-1] * (1 << 10) for _ in range(3)] for _ in range(n)]

    # @cache
    def dfs(i: int, s: int, msk: int, limit_low: bool, limit_high: bool) -> int:
        if i == n:
            return ((s == 0) + (msk.bit_count() == 3) + ((msk >> 3) & 1)) == 1

        if not limit_low and not limit_high and memo[i][s][msk] != -1:
            return memo[i][s][msk]

        # 第 i 個數位可以從 lo 枚舉到 hi
        # 如果對數位還有其它約束，應該只在下面的 for 迴圈做限制，不應修改 lo 或 hi
        st = lo = low[i] if limit_low else 0
        hi = high[i] if limit_high else 9

        res = 0
        if i < diff and limit_low:
            res += dfs(i + 1, 0, 0, True, False)  # 前導 0
            st = 1
        for d in range(st, hi + 1):
            res += dfs(i + 1, (s + d) % 3, msk | (1 << d), limit_low and d == lo, limit_high and d == hi)
        if not limit_low and not limit_high:
            memo[i][s][msk] = res % MOD
        return res % MOD

    ans = dfs(0, 0, 0, True, True)
    print(ans)


if __name__ == "__main__":
    solve()

🔗 🌈 AWC0104E Warehouse Inventory Management

Problem Statement

Constraints

思路：差值正部總和 + 根號分治

這題的操作同時提到庫存與需求，但真正影響答案的只有兩者的差值。把每個倉庫的狀態改寫成「需求量減庫存量」後，所有操作都會變成同一種形式：對一段連續位置加上一個值。

令差值為

$$C_i=B_i-A_i$$

答案就是差值的正部總和：

$$\sum_i \max(0,C_i)$$

收到新訂單時，區間內的差值整段增加；收到新進貨時，區間內的差值整段減少。於是問題變成：

如果每次更新後都掃過整個數列，單次操作是 $\mathcal{O}(N)$，在 $N,Q\le 5\times 10^4$ 時不可行。接下來的關鍵是：如何只重算受影響的部分，又能知道哪些元素在加值後跨過 $0$。

Lazy Segment Tree 的侷限

看到「區間加值 + 全域查詢」，很自然會先想到 Lazy Segment Tree。但 Lazy Segment Tree 能高效運作有一個前提：節點資訊在套上懶標記後，可以直接用公式推算出新的節點資訊。

例如區間總和：節點維護的區間長度為 $L$，原始總和為 $S$，整段加 $v$ 後，新總和就是 $S+v\cdot L$。公式只需要 $S$、$L$、$v$ 三個量，不需要知道區間內每個元素的值。

但 $\sum\max(0,x)$ 不是線性的——$\max(0,a+b)\neq\max(0,a)+\max(0,b)$。因此「加 $v$ 後的正部總和」無法從原本的正部總和、最大值、最小值這些節點資訊推出來。

根號分治：保留排序後分布，分塊維護

既然瓶頸是「不知道哪些元素會跨過 $0$」，就需要保留局部區間內的值排序後的分布。

直接排序整個陣列顯然是不行的，因為每次對子區間更新都有可能會破壞順序，若每次更新完都重新排序，這樣開銷太大了。

但如果只看一個被完整覆蓋的塊，整塊加值只是把塊內所有值一起平移，相對大小與排序結果都不會改變。於是可以把數列切成大小為 $S$ 的區塊，在「整塊懶更新」和「邊界暴力重建」之間取得平衡。

每個區塊維護的資訊

對於每個位置，保留一個尚未套用整塊偏移量的基準值 $D_i$。若該位置所在塊的整體偏移量為 $\textit{lazy}$，則真正的差值為：

$$C_i = D_i+\textit{lazy}$$

每個塊保存三類資訊：

1. 塊內基準值的排序結果 $sorted = [D_{i_1}, D_{i_2}, \ldots, D_{i_k}]$，用來二分找出非負元素的起點。
2. 排序後基準值的前綴和 $presum$，用來快速計算一段後綴的總和。
3. 一個整塊偏移量 $\textit{lazy}$，記錄這個塊被完整加過多少，也就是尚未逐一寫回塊內元素的懶標記。

完整覆蓋一個塊時，不需要動塊內每個元素，也不需要重新排序，只改整個區塊偏移量 $\textit{lazy}$ 就好。

用二分 + 前綴和計算貢獻

對某個塊，只有真正差值 $\ge 0$ 的元素會產生貢獻，也就是滿足

$$D_i + \textit{lazy} \ge 0$$

的元素會產生貢獻。等價地，$D_i \ge -\textit{lazy}$。

由於塊內基準值已排序，可以使用二分搜尋找到第一個不小於 $-\textit{lazy}$ 的位置。設從該位置到塊尾有 $k$ 個元素，整個塊的貢獻就是：

$$\sum D_i+k\cdot\textit{lazy}$$

其中 $\sum D_i$ 是這段後綴的基準值總和，可以在重建區塊時預處理前綴和，使得在計算時可以 $\mathcal{O}(1)$ 算出；二分本身需要 $\mathcal{O}(\log S)$。

區間更新

對於每一次更新，可以分兩部分處理：

1. 完整覆蓋的塊

整個塊都被加上同一個值時，塊內元素的相對順序不變，因此只需要：

1. 扣掉這個塊更新前的貢獻。
2. 修改整塊偏移量。
3. 加回更新後的貢獻。

這一類塊不用重建排序結果。

2. 邊界不完整的塊

左右兩端通常只會更新塊中的一部分位置，這會破壞原本排序結果所代表的值分布。因此需要逐一修改受影響位置的基準值，最後重建排序結果與前綴和。

區塊大小 $S$ 的選擇

每次操作最多兩個邊界塊需要暴力重建，代價 $\mathcal{O}(S\log S)$。中間完整覆蓋的塊最多 $\mathcal{O}(\frac{N}{S})$ 個，每個區塊只需要做兩次二分，每次二分代價為 $\mathcal{O}(\log S)$。

因此單次操作的代價為：

$$\mathcal{O}\left(S\log S+\frac{N}{S}\log S\right) = \mathcal{O}\left((S+\frac{N}{S})\log S\right)$$

忽略 $\log S$ 項，我們想要最小化 $S+\frac{N}{S}$，可以取 $S=\sqrt N$，每次操作約 $\mathcal{O}(\sqrt N\log N)$。

複雜度分析

• 時間複雜度：每次 $\mathcal{O}(\sqrt N\log N)$，總 $\mathcal{O}(Q\sqrt N\log 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

from bisect import bisect_left
from itertools import accumulate


n, q = list(map(int, input().split()))
C: list[int] = []
for _ in range(n):
    # a, b = map(int, input().split())
    a, b = list(map(int, input().split()))
    C.append(b - a)

# B = isqrt(n) + 1
B = int(n**0.5) + 1
m = (n + B - 1) // B  # ceil(n / B)

bucket: list[list[int]] = [[] for _ in range(m)]
presum: list[list[int]] = [[] for _ in range(m)]
lazy: list[int] = [0] * m
ans = sum(max(0, x) for x in C)


def build(b: int) -> None:
    l = b * B
    r = min(n, (b + 1) * B)
    bucket[b] = sorted(C[l:r])
    presum[b] = list(accumulate(bucket[b], initial=0))


def count(b: int) -> int:
    A = bucket[b]
    ps = presum[b]
    idx = bisect_left(A, -lazy[b])
    cnt = len(A) - idx
    return ps[-1] - ps[idx] + cnt * lazy[b]


def add(b: int, l: int, r: int, v: int) -> None:
    global ans
    ans -= count(b)
    for i in range(l, r + 1):
        C[i] += v
    build(b)
    ans += count(b)


for b in range(m):
    build(b)


for _ in range(q):
    op, l, r, v = list(map(int, input().split()))
    l, r = l - 1, r - 1
    if op == 2:
        v = -v

    bl, br = l // B, r // B
    if bl == br:
        add(bl, l, r, v)
    else:
        add(bl, l, (bl + 1) * B - 1, v)
        add(br, br * B, r, v)
        for b in range(bl + 1, br):
            ans -= count(b)
            lazy[b] += v
            ans += count(b)
    print(ans)

寫在最後

🔗 🌈 AWC0104D Radio Tower and Receiver

Problem Statement

Constraints

思路：等差數列差分

先看題目本質。對於一座位於中心位置、強度為 $B$ 的基地台，它對左右兩側的貢獻不是任意形狀，而是一個「三角形」：中心位置貢獻 $B$，往左或往右每走一步就少 $1$，直到不再為正為止。

也就是說，每座基地台其實是在總強度陣列上加上兩段等差數列：

• 左半邊：從影響範圍左端一路遞增到中心，公差為 $1$。
• 右半邊：從中心右側一路遞減到影響範圍右端，公差為 $-1$。

如果逐座基地台、逐個位置累加，最壞會退化成 $\mathcal{O}(NM)$，無法通過 $2\times 10^5$ 的資料範圍。既然每次加的都是等差數列，就應該想辦法一次標記整段，而不是逐項累加。

從普通差分到等差數列差分

回顧普通差分：對區間加上常數 $v$，只需要在差分陣列的左端點加 $v$、右端點後一個位置減 $v$，最後做一次前綴和就能還原。

現在要加的不是常數，而是一段等差數列。先看加入後，一階差分陣列會變成什麼樣子。以長度為 $4$ 的區間 $[l,r]$ 為例，若加上

$$s,\ s+d,\ s+2d,\ s+3d$$

令末項 $e=s+3d$。原序列、一階差分，以及在一階差分上再做一次差分（二階差分）的變化如下：

因此，若要在 $[l,r]$ 加入首項為 $s$、公差為 $d$ 的等差數列，設末項為

$$e=s+(r-l)d$$

只要做以下四個端點更新：

$$\begin{aligned}D_l &\mathrel{+}= s\\D_{l+1} &\mathrel{+}= d-s\\D_{r+1} &\mathrel{+}= -d-e\\D_{r+2} &\mathrel{+}= e\end{aligned}$$

最後對這個二階差分陣列做兩次前綴和，就能還原所有位置的總接收強度。

複雜度分析

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

def solve():
    n, m = map(int, input().split())
    T = list(map(int, input().split()))
    P, B = [], []
    for _ in range(m):
        p, b = map(int, input().split())
        P.append(p - 1)
        B.append(b)
    assert len(T) == n and len(P) == m and len(B) == m

    # 等差數列差分
    diff = [0] * (n + 2)

    def add(l, r, s, d):
        if l > r:
            return
        e = s + (r - l) * d
        diff[l] += s
        diff[l + 1] += d - s
        diff[r + 1] += -d - e
        diff[r + 2] += e

    for p, b in zip(P, B):
        l = max(p - b, 0)
        add(l, p, b - (p - l), 1)
        r = min(p + b, n - 1)
        add(p + 1, r, b - 1, -1)

    ans = 0
    s = ss = 0
    for i, t in enumerate(T):
        s += diff[i]
        ss += s
        if ss <= t:
            ans = max(ans, ss)
    print(ans)


if __name__ == "__main__":
    solve()

寫在最後

🔗 🌈 AWC0104C Deciding the Meeting Place

Problem Statement

Constraints

思路：中位數貪心

先忽略禁止點的限制，本題等同於「給定數線上若干個點，選一個整數座標 $T$，使其他點到它的距離和最小」。

我們可以發現，如果我們把所有數字都變成中位數，那麼所需花費最小，可以由以下兩種方法來證明。

• 若 $n$ 為奇數，則中位數為 $nums[\lfloor \frac{n}{2} \rfloor]$，將所有數變成 $nums[\lfloor \frac{n}{2} \rfloor]$ 的代價最小。
• 若 $n$ 為偶數，則不管取 $[\,nums[\lfloor \frac{n}{2} \rfloor - 1],\ nums[\lfloor \frac{n}{2} \rfloor]\,]$ 之間的任意數字都可以使代價最小。

方法一：排序 + 雙指標分組

先看可行性的本質。在一維數線上，禁止點不能跨越，這等價於把數線切成若干個連通區間。兩個朋友如果被某個禁止點隔開，不管集合地點選在哪裡，至少有一方必須跨過禁止點，所以不可能一起到達。反過來，只要所有朋友都在同一個連通區間內，就可以在這段裡選集合地點，接著再套中位數貪心。

因此問題就變成了「將所有朋友分組，每組內都是連通的，且任意兩組之間存在禁止點隔開」。若只有一段，則在該段內取中位數就是答案。

這樣做的好處是能直接知道朋友被分成了幾段，且每段有哪些朋友（其實是我一開始看錯題目了QwQ）。不過本題只需要判斷段數是否為 $1$：超過一段就無解；若只有一段，在該段內取中位數就是答案。

複雜度分析

• 時間複雜度：$\mathcal{O}(N \log N + M \log M)$，排序後雙指標線性掃描。
• 空間複雜度：$\mathcal{O}(N)$，需要保存分段結果；若只記錄段數，也可以降到 $\mathcal{O}(1)$ 額外空間。

方法二：直接判斷中位數模型是否可用

方法一會把所有連通區間實際切出來。不過對這題來說，我們只需要判斷一件事：所有朋友是否位於同一個可達區間。

排序朋友座標後（也可以直接取最小值和最大值，不過求中位數本身就需要排序），最左與最右位置決定了所有朋友的整體跨度。若存在某個禁止點滿足

$$\min A_i \le B_j \le \max A_i,$$

它就會把這段跨度切開。由於朋友座標不會等於禁止點，這個禁止點必然把朋友分到左右兩側；若要聚到同一點，至少有一側必須跨過禁止點，因此無解。

反過來，如果沒有禁止點落在這段跨度內，所有朋友之間就沒有阻隔，可以直接套用中位數貪心。此時選排序後的中位數，答案就是所有朋友到它的距離和。

複雜度分析

• 時間複雜度：$\mathcal{O}(N \log N + M)$，排序朋友座標後，線性檢查所有禁止點。
• 空間複雜度：$\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
30
31
32
33
34
35
36
37
38
39

from math import inf


def solve():
    n, m = map(int, input().split())
    A = list(map(int, input().split()))
    if m > 0:
        B = list(map(int, input().split()))
    else:
        B = []
    assert len(A) == n and len(B) == m

    A.sort()
    B.sort()
    B.append(inf)

    i = j = 0
    groups = []
    while i < n:
        group = []
        while B[j] < A[i]:
            j += 1
        while i < n and A[i] < B[j]:
            group.append(A[i])
            i += 1
        groups.append(group)

    if len(groups) > 1:
        print(-1)
    else:
        g = groups[0]
        k = len(g)
        mid = g[k // 2]
        ans = sum(abs(x - mid) for x in g)
        print(ans)


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

def solve():
    n, m = map(int, input().split())
    A = list(map(int, input().split()))
    if m > 0:
        B = list(map(int, input().split()))
    else:
        B = []
    assert len(A) == n and len(B) == m

    A.sort()

    for b in B:
        if A[0] <= b <= A[-1]:
            print(-1)
            return

    mid = A[n // 2]
    ans = sum(abs(x - mid) for x in A)
    print(ans)


if __name__ == "__main__":
    solve()

寫在最後

🔗 🌈 AWC0104B Bus Arrival Time

Problem Statement

Constraints

思路：計算每條路線的下一班車

每條路線的到站時間都是公差固定的倍數序列，所以只要算出這條路線第一個不小於 $T$ 的倍數即可。

把每條路線各自算出的候選到站時間取最小值，就是答案。若 $T=0$，所有路線在時間 $0$ 都有車，因此公式也會自然得到 $0$。

複雜度分析

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

Code

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

from math import inf


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

    ans = inf
    for x in A:
        m = (T + x - 1) // x  # ceil(T / x)
        ans = min(ans, x * m)
    print(ans)


if __name__ == "__main__":
    solve()

寫在最後

🔗 🌈 AWC0104A Election of the Class President

Problem Statement

Constraints

思路：一次遍歷

只需要知道兩件事：

1. 目前看過的最高票數 $mx$，以及其對應的編號（即 $ans$ ）
2. 這個最高票目前出現的次數 $cnt$

按照題意模擬即可。若最高票只出現一次，輸出其編號；否則輸出 -1。

複雜度分析

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

Code

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

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

    mx = -1
    ans = cnt = 0
    for i, x in enumerate(A, 1):
        if x > mx:
            mx = x
            ans = i
            cnt = 1
        elif x == mx:
            cnt += 1
    print(ans if cnt == 1 else -1)


if __name__ == "__main__":
    solve()

寫在最後

🔗 🟣 ABC458F Critical Misread

Problem Statement

Constraints

思路：AC 自動機 + 矩陣快速冪

先從最樸素的想法開始。如果當前狀態為 $s$（先不管要如何得出狀態），那麼下一步就是考慮在字串後面增加一個小寫字母。假設增加字母 $c$ 後會轉移到狀態 $t$，且這個過程沒有讓任何禁字串出現，那麼目前狀態的方案數就可以貢獻給下一個狀態。

也就是說，可以定義：

$$f_i[s] = \text{填了 } i \text{ 個字元後，位於狀態 } s \text{ 的方案數}$$

若從狀態 $s$ 加上某個字元後能合法走到狀態 $t$，就有轉移：

$$f_{i+1}[t] \leftarrow f_{i+1}[t] + f_i[s]$$

初始時還沒有填任何字元，只在起始狀態有一種方案。

第一個問題可以用 AC 自動機解決：將給定的禁字串視為模式串，建構 AC 自動機。讓目前狀態記錄「目前字串後綴」對應到哪個模式串前綴。只要再加入一個字元後沒有匹配到任何模式串，就可以轉移。

在確認使用 AC 自動機後，狀態數量就是 Trie 的節點數。根據限制條件，模式串最多有 $10$ 個、每個長度最多 $10$，所以除了根節點以外，節點數不超過所有模式串總長，也就是至多 $100$ 個左右。

而對於任意的 $i$，從 $f_i$ 到 $f_{i+1}$ 的轉移規則完全相同，和 $i$ 無關，因此可以用矩陣快速冪加速。

標記非法狀態

根據題意，任何包含模式串的字串都不合法。也就是說，當前狀態如果已經匹配到某個模式串，就不能再繼續延伸。

透過 AC 自動機的特性，當前狀態如果滿足以下任一條件，就代表目前字串已經包含模式串：

1. 節點本身有完整模式串結尾。
2. 節點的 last 指標不是根節點，表示某個後綴已經匹配到模式串。

如何列出轉移矩陣

注意上面的轉移只和目前狀態與加入字元有關，和 $t$ 無關。因此可以把「走一步」寫成固定矩陣。

令轉移矩陣為 $T$，並採用 column vector 表示狀態計數。也就是說：

$$F_{t+1} = T F_t$$

那麼矩陣中的元素應該這樣定義：

$$T_{v,u} = \#\{c \in \texttt{a..z} \mid \delta(u,c)=v,\ u,v \text{ 都是合法狀態}\}$$

其中 $\delta(u,c)$ 表示在 AC 自動機上，從狀態 $u$ 加入字元 $c$ 後到達的狀態。

複雜度分析

• 時間複雜度：$\mathcal{O}(L|\Sigma| + L^3\log N)$，其中 $L=\sum |S_i|$，且本題有 $L \le 10\times 10=100$，$|\Sigma|=26$。
  AC 自動機節點數至多為 $L+1$，可視為 $\mathcal{O}(L)$；建自動機與建立轉移矩陣需要 $\mathcal{O}(L|\Sigma|)$，矩陣快速冪為 $\mathcal{O}(L^3\log N)$。
• 空間複雜度：$\mathcal{O}(L|\Sigma| + L^2)$，分別來自 AC 自動機轉移與矩陣。

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

from collections import deque

MOD = 998244353


class Node:
    def __init__(self):
        self.child = [None] * 26
        self.fail = None  # fail pointer
        self.last = None  # suffix link，用來快速跳到一定是某個 word 結尾的節點
        self.length = 0  # 可以取代 is_end 和 depth
        self.id = -1


class AhoCorasick:
    def __init__(self):
        self.root = Node()
        self.root.id = 0
        self.nodes = [self.root]  # 保留所有節點

    def insert(self, word: str):
        node = self.root
        for ch in word:
            c = ord(ch) - ord("a")
            if not node.child[c]:
                node.child[c] = Node()
                node.child[c].id = len(self.nodes)
                self.nodes.append(node.child[c])
            node = node.child[c]
        node.length = len(word)

    def build(self):  # O(|Σ|N)，N 是節點數；若 |Σ|=26 視為常數，則為 O(N) = O(L)
        self.root.fail = self.root.last = self.root
        # BFS
        q = deque()
        for i, v in enumerate(self.root.child):
            if v is None:
                # 添加虛擬子節點
                self.root.child[i] = self.root
            else:
                v.fail = v.last = self.root
                q.append(v)
        while q:
            u = q.popleft()
            for i, v in enumerate(u.child):
                if v is None:
                    # 添加虛擬子節點
                    u.child[i] = u.fail.child[i]
                else:
                    # 失配位置
                    v.fail = u.fail.child[i]
                    # 上一個一定是某個 word 結尾的節點
                    v.last = v.fail if v.fail.length else v.fail.last
                    q.append(v)


class Matrix:
    def __init__(self, mat):
        self.mat = mat

    def __mul__(self, other):
        A, B = self.mat, other.mat
        assert len(A[0]) == len(B)
        n, p, m = len(A), len(B), len(B[0])
        res = [[0] * m for _ in range(n)]
        for i in range(n):
            ri = res[i]
            Ai = A[i]
            for k in range(p):
                if Ai[k] == 0:
                    continue
                x = Ai[k]
                Bk = B[k]
                for j in range(m):
                    ri[j] = (ri[j] + x * Bk[j]) % MOD
        return Matrix(res)

    def __pow__(self, k):
        assert len(self.mat) == len(self.mat[0])
        n = len(self.mat)
        res = Matrix([[int(i == j) for j in range(n)] for i in range(n)])
        base = self
        while k > 0:
            if k & 1:
                res *= base
            base *= base
            k >>= 1
        return res

    def mul_pow(self, k, x):
        assert len(self.mat[0]) == len(x.mat)
        res = x
        base = self
        while k > 0:
            if k & 1:
                res = base * res
            base *= base
            k >>= 1
        return res

    def __getitem__(self, i):
        return self.mat[i]

    def __str__(self):
        return "\n".join(map(lambda x: " ".join(map(str, x)), self.mat))


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

    ac = AhoCorasick()
    for _ in range(k):
        ac.insert(input().strip())
    ac.build()

    nodes = ac.nodes
    m = len(nodes)

    bad = [False] * m
    for node in nodes:
        if node.length > 0 or node.last != ac.root:
            bad[node.id] = True

    # T[v][u] 表示從 u 狀態加入一個字元後，到達 v 狀態的方案數
    T = [[0] * m for _ in range(m)]
    for u in nodes:
        if bad[u.id]:
            continue
        for v in u.child:
            if bad[v.id]:
                continue
            T[v.id][u.id] += 1

    T = Matrix(T)
    f = Matrix([[1] if i == 0 else [0] for i in range(m)])
    f = T.mul_pow(n, f)

    ans = sum(f[i][0] for i in range(m) if not bad[i]) % MOD
    print(ans)


if __name__ == "__main__":
    solve()

寫在最後

🔗 🟣 P2292 [HNOI2004] L 语言

Problem Statement

Constraints

思路：AC 自動機 + 前綴可分割 DP

先只看「可理解」這件事本身，可以先用 DP 定義前綴的可理解性：

$$f_i =\begin{cases}\text{true}, & \text{若長度為 } i \text{ 的前綴是可理解的} \\\text{false}, & \text{若長度為 } i \text{ 的前綴不可被理解的}\end{cases}$$

空前綴自然是合法的，所以 $f_0=\text{true}$。

那麼當某個字典單字剛好作為這個前綴的後綴時，只要它前面的部分也能被理解，當前前綴就能被理解。

換句話說，如果長度為 $L$ 的單字在第 $i$ 個位置結尾，就有轉移：

$$f_i \leftarrow f_i \lor f_{i-L}$$

所以問題變成：掃描文章時，如何快速知道「有哪些字典單字在目前位置結尾」。

最直接的做法是每到一個位置，就枚舉所有單字並檢查是否匹配文章後綴。但文章單串長度可達 $2\times 10^6$，詢問又有多篇，這樣做顯然是不能接受的。

注意這題的字典是固定的，文章有很多篇；每篇文章都要一邊掃描，一邊查詢目前位置結尾的所有字典單字。這正是多模式匹配的使用場景，所以自然想到 AC 自動機。

因此只要枚舉所有在目前位置結尾的單字長度 $L_k$，檢查 $f_{i-L_k}$ 是否為真即可。

方法一：沿著 fail 鏈枚舉匹配長度

在構建完 AC 自動機後，掃描文章時每到一個字元，就沿著自動機走一步，找到目前文章後綴對應的節點。而延著 fail 鏈往上走，就能找到所有在目前位置結尾的單字。

但如果直接沿著 fail 鏈往上跳，確實可以找到所有後綴匹配，但中間會經過很多「不是單字結尾」的節點，這些節點對 DP 轉移沒有用。於是可以額外維護 last：它指向 fail 鏈上最近的一個單字結尾節點，相當於把不必要的節點跳過。

這樣從目前節點開始沿著 last 往上走，就能依序得到所有在目前位置結尾的單字長度 $L_k$。

剪枝

不過就算使用了 last，仍然可能有很多單字長度要枚舉，在本題加強後的資料面前仍然會超時。可以考慮以下兩個關鍵剪枝：

1. 設目前已知最大可理解長度為 $ans$，現在掃描到位置 $i$。如果想讓答案從 $ans$ 延伸到 $i$，中間這段至少要由一個長度為 $i-ans$ 的單字接上；但字典中的單字最長只有 $max\_len$。所以一旦 $i-ans>max\_len$，這個缺口不可能被任何單字補上，後面也無法再接回合法切分，可以直接停止處理這篇文章。
2. 由於題目只問最長前綴位置，不問方案數，也不問切分方式。因此在枚舉目前位置結尾的單字長度時，只要找到一個能讓 $f_i$ 成立的長度，就可以立刻停止；繼續找其他長度不會改變 $f_i$ 的真假。

複雜度分析

• 時間複雜度：$\mathcal{O}(S|\Sigma| + M\min(n,\max |s|))$，其中 $S$ 是字典 trie 的節點數，$|\Sigma|=26$，$M$ 是 $Q$ 篇文章的總長度。每個位置沿 last 最多只會經過所有能在此結尾的單字節點，數量不超過字典單字數 $n$，也不超過題目給定的單字長度上界 $\max |s|\le 20$。
• 空間複雜度：$\mathcal{O}(S|\Sigma| + m)$，其中 $m$ 是單篇文章長度上界，來自處理單篇文章時的 DP 陣列。

方法二：狀態壓縮 DP

方法一的瓶頸在於每次都要沿著 last 鏈逐個嘗試長度，最壞需要 $\mathcal{O}(\min(n,\max |s|))$ 的時間。

注意到題目保證 $|s|\le 20$，所有可能的單字長度只有 $1$ 到 $20$，因此可以把「匹配長度集合」壓縮成一個整數 $\text{matchMask}$：第 $L-1$ 位為 $1$ 表示長度為 $L$ 的單字在目前位置結尾。

建立 AC 自動機時，替每個節點維護這個 bitmask。節點自身的長度和沿失配指標繼承的長度都會貢獻到 mask 中，在 BFS 的過程中即可一併處理完畢。之後掃描到某個位置時，直接讀目前節點的 mask，就能在 $\mathcal{O}(1)$ 知道所有可用的匹配長度。

DP 的歷史狀態同樣只需要保留最近 $\max |s|$ 個，因此也能將其壓縮成另一個整數 $\text{stateMask}$：第 $L-1$ 位為 $1$，就代表往前數 $L$ 個字元之前的那個前綴是可被理解的。

於是轉移式

$$\exists L,\quad \text{長度 }L\text{ 的單字在目前位置結尾，且 } f_{i-L}=1$$

變成兩個整數求交集：

$$\text{matchMask} \ \&\ \text{stateMask} \ne 0$$

只要結果非零，就表示存在某個單字能接在合法前綴之後，目前前綴可被理解。

掃描完目前位置後，把狀態遮罩左移一位：所有歷史前綴離下一個位置又遠了一格。若目前前綴合法，就把最低位設為 $1$。同時只保留最近 $\max |s|$ 位，因為超過這個距離的狀態永遠不會再被用到。

複雜度分析

• 時間複雜度：建 AC 自動機為 $\mathcal{O}(S|\Sigma|)$；每篇文章只需線性掃描，為 $\mathcal{O}(m)$。
• 空間複雜度：$\mathcal{O}(S|\Sigma| + m)$。DP 狀態被壓成常數個整數，不再需要與文章長度同級的陣列，但目前寫法仍需要處理輸入時的字串。

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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

#include <bits/stdc++.h>
using namespace std;
const int ALPH = 26;
#define endl '\n'

struct Node {
    array<Node*, ALPH> child;
    Node *fail, *last;
    int length;
    Node() : fail(nullptr), last(nullptr), length(0) {
        fill(child.begin(), child.end(), nullptr);
    }
};

class AhoCorasick {
public:
    Node* root;

    AhoCorasick() {
        root = new Node();
    }

    void insert(const string& word) {
        Node* node = root;
        for (char ch : word) {
            int idx = ch - 'a';
            if (node->child[idx] == nullptr) node->child[idx] = new Node();
            node = node->child[idx];
        }
        node->length = word.length();
    }

    void build() {
        root->fail = root->last = root;
        // BFS
        queue<Node*> q;
        for (int i = 0; i < ALPH; ++i) {
            if (root->child[i] == nullptr) {
                // 添加虛擬子節點
                root->child[i] = root;
            } else {
                root->child[i]->fail = root->child[i]->last = root;
                q.push(root->child[i]);
            }
        }
        while (!q.empty()) {
            Node* u = q.front();
            q.pop();
            for (int i = 0; i < ALPH; ++i) {
                Node* v = u->child[i];
                if (v == nullptr) {
                    // 添加虛擬子節點
                    u->child[i] = u->fail->child[i];
                } else {
                    // 失配位置
                    v->fail = u->fail->child[i];
                    // 上一個一定是某個 word 結尾的節點
                    v->last = (v->fail->length > 0) ? v->fail : v->fail->last;
                    q.push(v);
                }
            }
        }
    }
};

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

    AhoCorasick ac;
    string pattern, t;
    int max_len = 0;
    for (int i = 0; i < n; ++i) {
        cin >> pattern;
        ac.insert(pattern);
        max_len = max(max_len, (int)pattern.length());
    }
    ac.build();

    while (q--) {
        cin >> t;
        int m = t.length();

        int ans = 0;
        vector<bool> f(m + 1, false);
        f[0] = true;

        Node* node = ac.root;
        for (int i = 1; i <= t.length(); ++i) {
            // 剪枝：當前需要長度至少為 i - ans 的模式串才能匹配，
            // 但這個長度不可能超過 max_len
            if (i - ans > max_len) break;

            node = node->child[t[i - 1] - 'a'];

            // 沒有任何字串的前綴與 t[..i] 的後綴匹配
            if (node == ac.root) break;

            // 沿著 last 往上尋找
            Node* temp = node;
            while (temp != ac.root) {
                f[i] = f[i] || f[i - temp->length];
                // 剪枝：已經匹配就沒必要再往上找了，主要是這個避免 TLE
                if (f[i]) {
                    ans = i;  // 更新答案
                    break;
                }
                temp = temp->last;
            }
        }
        cout << ans << endl;
    }
    return;
}

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