由於字串這個主題暑假培訓沒教

所以這堂課的重心會在講解演算法原理

題目不會帶太多因為我也沒寫過多少字串題

夠電的人可以直接下滑戳題單或寫自己的題目

或是看臺上的人雜耍順便嘴砲

DISCLAIMER

題單在此

名詞定義

字串

由一堆字元排列成的序列

字元可以是字母、數字、任意符號

$$ S = "StarBurstStream" $$

$$ T = "48763" $$

$$ U = "1011111001111011" $$

符號表示

第 $i$ 個字元：$S_i$
長度：$|S|$
串接：$S + T$
字元集：$C$
字元集大小：$|C|$

子字串

$S = "Star{\color{cyan} Burst}Stream"$

子字串

$S = "Star{\color{cyan} Burst}Stream"$

$ \uparrow $

$ l $

$ \uparrow $

$ r $

子字串

$S = "Star{\color{cyan} Burst}Stream"$

$ \uparrow $

$ l $

$ \uparrow $

$ r $

$S[l, r] = "{\color{cyan} Burst}"$

前綴／後綴

$S = "{\color{cyan} StarBu}rstStream"$

$S = "StarBurs{\color{cyan} tStream}"$

字串大小關係

$S = "aab {\color{cyan}b}"$

$T = "aab{\color{cyan}c}"$

$S < T$

$S = "aab"$

$T = "aab{\color{cyan}c}"$

$S < T$

（空字元最小）

由左到右比對，比到第一個不一樣的字元

字典序

用剛才的比較方式排序字串

$ a $

$ aaab $

$ aab $

$ abb $

$ baab $

字串匹配

Matching

字串匹配

"Matching" $\Rightarrow$ 配對，檢查是否相同

字串匹配

給定字串 $S, P$

求 $P$ 在 $S$ 中出現的次數及位置

字串 $P$ 稱為模式字串 (Pattern)

字串匹配

$S = "abaaabbaaab"$

$ P = "ab" $

字串匹配

$S = "{\color{cyan}ab}aa{\color{cyan}ab}baa{\color{cyan}ab}"$

$ S[0, 1] = P $

$ S[4, 5] = P $

$ S[9, 10] = P $

$\Rightarrow P$ 出現了 $3$ 次

暴力匹配

枚舉開始位置，然後慢慢往下比對

S | A A B A A B A A B B B

P | A A B A A B B B

枚舉開始位置，然後慢慢往下比對

S | A A B A A B A A B B B

P | A A B A A B B B

枚舉開始位置，然後慢慢往下比對

S | A A B A A B A A B B B

P | A A B A A B B B

枚舉開始位置，然後慢慢往下比對

S | A A B A A B A A B B B

P | A A B A A B B B

枚舉開始位置，然後慢慢往下比對

S | A A B A A B A A B B B

P | A A B A A B B B

P | A A B A A B B B Matched！

時間複雜度

假設字串 $S$ 是隨機給定

考慮現在從 $S$ 某個位置開始匹配

$P$ 的第 $1$ 個字元被比對的機率：$1$

$P$ 的第 $2$ 個字元被比對的機率：$1 \over |C|$

...

$P$ 的第 $k$ 個字元被比對的機率：$1 \over {|C|^{k-1}}$

時間複雜度

期望比對次數

$$\sum_{k=1}^{|P|} {{1} \over {|C|^{k-1}}} < {{|C|}\over{|C|-1}} \leq 2$$

時間複雜度

期望比對次數

$$\sum_{k=1}^{|P|} {{1} \over {|C|^k-1}} < {{|C|}\over{|C|-1}} \leq 2$$

總共匹配 $|S|-|P|$ 次

期望複雜度 $O(2 \times (|S|-|P|)) $

時間複雜度

期望比對次數

$$\sum_{k=1}^{|P|} {{1} \over {|C|^k-1}} < {{|C|}\over{|C|-1}} \leq 2$$

總共匹配 $|S|-|P|$ 次

期望複雜度 $O(2 \times (|S|-|P|)) $

$ O(|S|+|P|) $ ！

天底下哪有那麼好的事

$S = "aaaaaaaaaaaaaaaa"$

$ P = "aaaaa" $

$ O(|S||P|) $

~~喔其實有啦~~

~~打過 YTP 就知道~~

Rolling Hash

唬爛美學

雜湊 (Hash)

把龐雜的資訊壓縮、精簡

讓檢索、比對物件變得更簡單、快速

雜湊 (Hash)

把龐雜的資訊壓縮、精簡

讓檢索、比對物件變得更簡單、快速

代價：丟失一些訊息，比對正確率降低

雜湊函式 (Hash Function)

一個好的雜湊函式 $f$ 具備以下條件：

複雜度：比對 $f(x), f(y)$ < 比對 $x, y$
$x = y \Longrightarrow f(x) = f(y) $
$f(x) = f(y)$ 但 $x \neq y$ 的機率盡量低

雜湊函式 (Hash Function)

一個好的雜湊函式 $f$ 具備以下條件：

複雜度：比對 $f(x), f(y)$ < 比對 $x, y$
$x = y \Longrightarrow f(x) = f(y) $
$f(x) = f(y)$ 但 $x \neq y$ 的機率盡量低

雜湊碰撞

字串的雜湊 - Rolling Hash

選定數字 $p, M$

字串 $S$ 的雜湊函數：

$ f(S) = (S_0 \cdot p^{|S|-1} + S_1 \cdot p^{|S|-2} + ... + S_{|S|-1} \cdot p^0) \mod M$

把 $S$ 想成是一個 $p$ 進位的數字

再把這個數字模 $M$ (壓縮到值域 $[0, M-1]$)

怎麼選 $p, M$

通常 $p$ 是一個略 $> |C|$ 的質數

Ex. 小寫字母字串 $(|C|=26)$ $\Rightarrow p 取 29$

$M$ 要一個夠大的質數

Ex. $ 10^9 + 7, 10^8 + 7, 998244353 $

但盡量不要超過 $ 3\times10^9 $

不然乘法的時候 long long 會溢位

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

把 Hash 想成倒三角形

ll Hash(string& s) {
    ll ret = 0;
    for (auto& i : s) {
        ret *= p;
        ret += (i-'a'+1);
        ret %= MOD;
    }
    return ret;
}

前綴 Hash

vector<ll> rh;
void build() {
    rh[0] = s[0]-'a'+1;
    for (int i = 1; i < (int)s.size(); i++) {
        rh[i] = rh[i-1]*p + (s[i]-'a'+1);
        rh[i] %= MOD;
    }
}

區間 Hash

ll query(int l, int r) {
    ll ret = rh[r] - (l ? rh[l-1] * pe[r-l+1] : 0);
    ret = (ret % MOD + MOD) % MOD;
    return ret;
}

$l$

$r$

區間 Hash

ll query(int l, int r) {
    ll ret = rh[r] - (l ? rh[l-1] * pe[r-l+1] : 0);
    ret = (ret % MOD + MOD) % MOD;
    return ret;
}

$rh(l-1)$

$rh(r)$

$ f(S[l, r]) = rh(r) - rh(l-1) \times p^{r-l+1} $

區間 Hash

ll query(int l, int r) {
    ll ret = rh[r] - (l ? rh[l-1] * pe[r-l+1] : 0);
    ret = (ret % MOD + MOD) % MOD;
    return ret;
}

$rh(l-1) \times p^{r-l+1} $

$rh(l-1)$

$rh(r)$

$ f(S[l, r]) = rh(r) - rh(l-1) \times p^{r-l+1} $

區間 Hash

ll query(int l, int r) {
    ll ret = rh[r] - (l ? rh[l-1] * pe[r-l+1] : 0);
    ret = (ret % MOD + MOD) % MOD;
    return ret;
}

$ f(S[l, r]) = rh(r) - rh(l-1) \times p^{r-l+1} $

$rh(l-1)$

$rh(r)$

注意事項

Birthday Attack

假設選的模數是 $10^9+7$

如果對 $10^5$ (約$> \sqrt{10^9+7}$) 個字串進行 Hash

碰撞機率 $> 99\%$

Birthday Attack

假設選的模數是 $10^9+7$

如果對 $10^5$ (約$> \sqrt{10^9+7}$) 個字串進行 Hash

碰撞機率 $> 99\%$

怎麼辦QQ？

一個 Mod 不夠

那就開兩個

一個 Mod 不夠

那就開兩個

兩個 Mod 不夠那就開三個

...

48762 個 Mod 不夠那就開 48763 個

例題

CSES - String Matching

字串匹配裸題

測試匹配演算法用

CSES - Longest Palindrome

輸入一個字串 $S$

求最長迴文子字串

$|S| \leq 10^6 $

好像可以來點 Hash + Binary Se...

提示（Touch Me）：

CSES - Minimal Rotation

將 $S$ 的開頭字元移到結尾稱作一次旋轉

求將 $S$ 經過數次旋轉後

能得到字典序最小的字串為何

$ |S| \leq 10^6 $

練習

或者你可以用 hash 揍後面的題目

KMP Algorithm

從失敗中吸取經驗

KMP 改良了暴力匹配的過程

省去一些不必要的匹配過程

而且複雜度意外的優美

KMP = Knuth-Morris-Pratt

觀察一下暴力比對過程

S | A A B A A B A A B B B

P | A A B A A B B B

觀察一下暴力比對過程

S | A A B A A B A A B B B

P | A A B A A B B B

觀察一下暴力比對過程

S | A A B A A B A A B B B

P | A A B A A B B B

匹配失敗了QQ

但真的只能把 P 位移一格然後重做嗎？

繼續 try 之前先停住，考慮接下來的匹配點

S |

P |

...

把紅色位置想成門檻

S |

P |

...

接下來如果要能匹配成功

必定要先跨過這道檻

S |

P |

...

那能夠跨過這道門檻的匹配點有什麼性質？

S |

P |

...

那能夠跨過這道門檻的匹配點有什麼性質？

S |

P |

...

那能夠跨過這道門檻的匹配點有什麼性質？

到門檻之前都要長得跟 S 一模一樣！

S |

P |

...

我們先把能走到門檻面前的匹配點稱為候選點

只有他們才有機會匹配成功

S |

P |

...

正式地說

從 P 開頭取一段前綴，再從 S[$i$] 之前取一段等長的後綴

如果取出來的前綴跟後綴是一樣的 $\Rightarrow$ 候選點

$i$

S |

P |

...

並且我們要從第一個候選點開始繼續匹配

$\Rightarrow$ 選最長的共同前後綴！

$i$

S |

P |

...

「從 P 開頭取一段前綴，再從 S[$i$] 之前取一段等長的後綴」

注意到其實也可以從 P[$j$] 取

$j$

S |

P |

...

「從 P 開頭取一段前綴，再從 S[$i$] 之前取一段等長的後綴」

注意到其實也可以從 P[$j$] 取

$j$

蛤，為什麼突然這麼說

如果都是在 P 上面做事

而且不需要先知道 S 長怎樣...

如果都是在 P 上面做事

而且不需要先知道 S 長怎樣...

預處理！

對於長度為 $n$ 的字串 $P=p_0\ p_1\ ...\ p_{n-1}$

定義 $P$ 的失配函數 $F$ 如下：

\[F(i)=\begin{cases}max\{k:{\color{yellow} P[0,k-1]=P[i-k+1,i]},\ k < i+1\}&\text{if $i \neq 0$ and $k$ exists.}\\ 0&\text{otherwise.}\end{cases}\]

$F(i)$ 其實就是位置 $i$ 的最長共同前後綴長度。

稱為失配函數 $\Rightarrow$ 匹配失敗的時候會用到。

Failure Function／定義

假設我們已經預先算好了每個 $F(i)$

可以來匹配字串了！

S |

P |

S |

P |

S |

P |

S |

P |

匹配失敗，找下一個候選點

$j$

$i$

S |

P |

$j$

$i$

S |

P |

$j$

$i$

P |

$F(j-1)$

S |

P |

$j$

$i$

P |

$F(j-1)$

$j \rightarrow F(j-1)$

繼續跟 $S[i]$ 匹配

S |

P |

$j$

$i$

P |

啊如果又匹配失敗

$F(j-1)$

S |

P |

$j$

$i$

P |

啊如果又匹配失敗

那就再跳一次

$F(j-1)$

S |

P |

$j$

$i$

P |

$F(F(j-1)-1)$

$F(j-1)$

S |

P |

$j$

$i$

P |

$F(j)$

P |

$F(j-1) \rightarrow F(F(j-1)-1)$

$F(F(j-1)-1)$

S |

$i$

...

$j'$

反正就一直跳，跳到能繼續下去為止

P |

S |

...

繼續匹配zzz...

P |

S |

...

P.S. 如果跳到不能再跳，但還是匹配失敗的話

P |

$j'$

$i$

S |

...

P.S. 如果跳到不能再跳，但還是匹配失敗的話

那就直接往下一格從頭做

P |

$j'$

$i$

P |

$j'+1$

複雜度證明

假設匹配到 $S[i], P[j]$

則接下來會有兩種情況

$S[i]=P[j]$：$i, j$ 都會加 $1$
$S[i]\neq P[j]$：重複讓 $j$ 變成 $F(j-1)$ 直到此情況不成立（讓 $j$ 減少）

複雜度證明

情況 1 只會發生 $|S|-1$ 次

而因為 $0 \leq F(j-1) \leq |P| $

且情況 2 發生次數 $\leq$ 情況 1（有加才有減）

$O(|S|)$！

$S[i]=P[j]$：$i, j$ 都會加 $1$
$S[i]\neq P[j]$：重複讓 $j$ 變成 $F(j-1)$ 直到此情況不成立（讓 $j$ 減少）

KMP Algorithm／Code

pi：字串 p 的指針
si：字串 s 的指針
for (int si = 0; si < n; si++) {
	while (匹配失敗 && pi 還可以跳) 跳到下一個候選點;
	if (s[si] == p[pi]) pi++;
	if (匹配成功) {
    	cout << "Matched!\n";
        pi = f[pi-1];  // 匹配成功 -> 跳到下一個候選點
    }
}

int pi = 0;
for (int si = 0; si < n; si++) {
	while (pi && s[si] != p[pi]) pi = f[pi-1];
	if (s[si] == p[pi]) pi++;
	if (pi == m) {
    	cout << "Matched!\n";
        pi = f[pi-1];
    }
}

那要怎麼快速計算 $F(i)$

假設我們已經算完 $F(1)\sim F(i)$

現在計算 $F(i+1)$

abaabaaba?

$i+1$

箭頭長 $= F(i)$

#Case 1

藍色箭頭可以延伸

abaabaabaa

$i+1$

$F(i+1) := F(i) + 1$

#Case 2

藍色箭頭不能延伸

abaabaabab

$i+1$

#Case 2

藍色箭頭不能延伸

abaabaabab

$i+1$

找到最長的箭頭

像藍色一樣也符合共同前後綴的條件

#Case 2

藍色箭頭不能延伸

abaabaabab

$i+1$

找到最長的箭頭

像藍色一樣也符合共同前後綴的條件

$F(F(i)-1)$

#Case 2

藍色箭頭不能延伸

abaabaabab

$i+1$

找到最長的箭頭

像藍色一樣也符合共同前後綴的條件

$F(F(i)-1)$

有發現了嗎

這跟剛剛匹配失敗要「跳」是一樣的！

#Case 2

abaabaabab

$i+1$

繼續檢查箭頭能不能延伸

如果不行，就一直跳

#Case 2

abaabaabab

$i+1$

繼續檢查箭頭能不能延伸

如果不行，就一直跳

#Case 2

abaabaabab

$i+1$

繼續檢查箭頭能不能延伸

如果不行，就一直跳

#Case 2

abaabaabab

$i+1$

繼續檢查箭頭能不能延伸

如果不行，就一直跳

#Case 2

abaabaabab

$i+1$

繼續檢查箭頭能不能延伸

如果不行，就一直跳

$F(i+1)=2$

複雜度證明

性質：$F$ 每次最多增加 1

且 $0 \leq F(i) \leq n$

$\Rightarrow F$ 的變動量不超過 $2n$（一樣，有加才有減）

每次變動只比較字元一次

$O(|P|)$！

Failure Function／Code

ptr：箭頭
i：現在在蓋 f[i]
vector<int> f;
void build() {
	f.clear(); f.resize(m, 0);
	int ptr = 0;
	for (int i = 1; i < m; i++) {
		while (箭頭不能延伸 && 可以跳) 找下一個箭頭;
		if 可以延伸) ptr++;
		f[i] = ptr;
	}
}

vector<int> f;
void build() {
	f.clear(); f.resize(m, 0);
	int ptr = 0;
	for (int i = 1; i < m; i++) {
		while (ptr && p[i] != p[ptr]) ptr = f[ptr-1];
		if (p[i] == p[ptr]) ptr++;
		f[i] = ptr;
	}
}

Failure Function／Code

vector<int> f;
void build() {
	f.clear(); f.resize(m, 0);
	int ptr = 0;
	for (int i = 1; i < m; i++) {
		while (ptr && p[i] != p[ptr]) ptr = f[ptr-1];
		if (p[i] == p[ptr]) ptr++;
		f[i] = ptr;
	}
}

跟剛剛字串匹配的 Code 長得差不多

其實可以把蓋 $F$ 的過程想成 $P$ 跟自己匹配！

Gusfield's Algorithm

俗稱 Z Algorithm

z

Z Algorithm

複雜度也是 $O(|S|+|P|)$

比剛才的 KMP 還要直觀、好想

實用性也更高

對於長度為 $n$ 的字串 $P=p_0\ p_1\ ...\ p_{n-1}$

定義 $P$ 的 $Z$ 函數如下：

\[Z(i)=\begin{cases}max\{k:{\color{yellow} P[0,k-1]=P[i,i+k-1]}\}&\text{if $k$ exists.}\\ 0&\text{otherwise.}\end{cases}\]

$Z(i)$ 其實就是從 $i$ 開始的後綴跟 $P$ 的最長共同前綴長度。

Z Value／定義

$i$

$i+Z(i)-1$

$Z(i)-1$

$0$

怎麼蓋 Z？

暴力枚舉 $O(n^2)$

這顯然不是我們要的複雜度

Intuition

假設現在要算 $Z(i)$

我們試著利用已經算過的東西

來估算一下 $Z(i)$ 至少有多大

不要無腦地從 $0$ 開始

把先前算過的 $Z(1) ... Z(i-1)$

看成一堆區間

$[1, Z(1)]$

$[2, Z(2)]$

...

$[i-1, Z(i-1)]$

這些是我們「已經算過的」資訊

接下來要好好利用它們

把先前算過的 $Z(1) ... Z(i-1)$

看成一堆區間

$[1, Z(1)]$

$[2, Z(2)]$

...

$[i-1, Z(i-1)]$

這些是我們「已經算過的」資訊

接下來要好好利用它們

P.S. 不考慮 $Z(0)$

$Z(0)$ 不用算，自動等於原字串長

從那坨區間當中

抓右界最大的出來

令該區間為 $[l, r]$

$l$

$r$

#Case 1

$i > r$

$i$

$l$

$r$

#Case 1

$i > r$

進入了全新、未知的領域

只能從頭開始做

$i$

$l$

$r$

#Case 2

$i \leq r$

$i$

$l$

$r$

#Case 2

$i \leq r$

$i$

$l$

$r$

#Case 2

$i \leq r$

$i$

$l$

$r$

$i-l$

#Case 2

$i \leq r$

$i$

$l$

$r$

$i-l$

$Z(i-l)$

#Case 2

$i \leq r$

$i$

$l$

$r$

$i-l$

$Z(i-l)$

#Case 2

$i \leq r$

$i$

$l$

$r$

$i-l$

$Z(i-l)$

$min(Z(i-l), r-i+1)$

$Z(i-l)$

不能超過$r$

我們不知道$r$ 以後的字元長怎樣

#Case 2

$i \leq r$

$Z(i)$ 至少有 $min(Z(i-l), r-i+1)$ 那麼大

$i$

$l$

$r$

$i-l$

$Z(i-l)$

$min(Z(i-l), r-i+1)$

$Z(i-l)$

#Case 2

$i \leq r$

$Z(i)$ 至少有 $min(Z(i-l), r-i+1)$ 那麼大

$i$

$l$

$r$

$i-l$

$Z(i-l)$

$min(Z(i-l), r-i+1)$

$Z(i-l)$

這是我們能知道最大的下界

所以接下來就繼續暴力看 $Z(i)$ 能不能變更大！

Gusfield's Algorithm／Code

vector<int> z;
void build_z() {
	z.clear(); z.resize(n, 0);
	int l = 0, r = 0;
	for (int i = 1; i < n; i++) {
		if (i <= r) z[i] = min(z[i-l], r-i+1);
		while (i+z[i] < n && s[z[i]] == s[i+z[i]]) z[i]++;
		if (i+z[i]-1 > r) l = i, r = i+z[i]-1;
	}
}

void build_z() {
	int l = 0, r = 0;
	for (int i = 1; i < n; i++) {
		if (i <= r) 估算 z[i] 下界
		while (z[i] 能變更大) 那就讓它更大;
        	更新 l, r;
	}
}

複雜度證明

注意到 $r$ 只會遞增

且最多增加 $n-1$ 次

接下來一樣分各種情況來討論

複雜度證明

每次計算 $Z(i)$ 的時候

$i>r$： $r$ 增加
$i<r, i+Z(i-l)-1 \leq r$：則 $Z(i)$ 不可能變更大，$Z(i)$ 計算完畢
$i<r, i+Z(i-l)-1 > r$：$r$ 可能增加

2. 不會影響 $r$，且所花時間 $O(1)$

1. 3. 由於 $r$ 最多只會增加 $n-1$ 次，均攤 $O(n)$

總複雜度：$O(n)$！

怎麼拿 Z 做字串匹配

把 P 跟 S 黏在一起

T = P + "$" + S

"$" 是不在 P, S 內的字元

蓋字串 T 的 Z 陣列

看 "$" 以後的 $Z(i)$ 有沒有 $=|P|$

Suffix Array

後綴數組

把一個字串所有的後綴丟到一個陣列

接著對裡面所有後綴排序

得到的陣列叫做 Suffix Array

把一個字串所有的後綴丟到一個陣列

接著對裡面所有後綴排序

得到的陣列叫做 Suffix Array

排序後的後綴陣列有一些神奇的性質可以解決題目

但總之先來學怎麼蓋 Suffix Array 吧

Suffix Array／建構

Naive 做法

$O(n \log n)$ 排序演算法

每次 compare $O(n)$ 暴力匹配

總複雜度 $O(n^2 \log n)$

Suffix Array／建構

Naive 做法

$O(n \log n)$ 排序演算法

每次 compare $O(n)$ 暴力匹配

總複雜度 $O(n^2 \log n)$

能不能更快？

Suffix Array／建構

rolling hash！

$O(n \log n)$ 排序演算法

每次 compare 二分搜 $\Rightarrow O(\log n)$

總複雜度 $O(n \log^2 n)$

Suffix Array／倍增法

還可以怎麼做／更快的方法

倍增！

Suffix Array／倍增法

還可以怎麼做／更快的方法

倍增！

Suffix Array／倍增法

一些名詞

後綴 $i$：從 index $i$ 開始的後綴，也就是 $S_{i...|S|-1}$

$sa(r)$：排序後的 Suffix Array，第 $r$ 個後綴

$rk(i)$：後綴 $i$ 在 $sa$ 中的排名

$sa$ 跟 $rk$ 互為反函數

Suffix Array／倍增法

一些名詞

後綴 $i$：從 index $i$ 開始的後綴，也就是 $S_{i...|S|-1}$

$sa(r)$：排序後的 Suffix Array，第 $r$ 個後綴

$rk(i)$：後綴 $i$ 在 $sa$ 中的排名

$sa$ 跟 $rk$ 互為反函數

$sa(r)$：第 $r$ 小的後綴是誰

$rk(i)$：後綴 $i$ 是第幾小

Suffix Array／倍增法

S = "aababbb"

為了實作方便

我們在 S 後面加上一個字元 "$"

這個 "$" 比 S 裡面的字元都還要小

Suffix Array／倍增法

S = "aababbb$"

$

aababbb$

ababbb$

abbb$

b$

babbb$

bb$

bbb$

7

0

1

3

6

2

5

4

rk(7) = 0

rk(0) = 1

rk(1) = 2

rk(3) = 3

rk(6) = 4

rk(2) = 5

rk(5) = 6

rk(4) = 7

Suffix Array／倍增法

S = "aababbb$"

$

aababbb$

ababbb$

abbb$

b$

babbb$

bb$

bbb$

7

0

1

3

6

2

5

4

rk(7) = 0

rk(0) = 1

rk(1) = 2

rk(3) = 3

rk(6) = 4

rk(2) = 5

rk(5) = 6

rk(4) = 7

Suffix Array

Suffix Array／倍增法

方便起見，先想像 S 是無限循環的

$aababbb...

aababbb$...

ababbb$a...

abbb$aab...

b$aababb...

babbb$aa...

bb$aabab...

bbb$aaba...

7

0

1

3

6

2

5

4

rk(7) = 0

rk(0) = 1

rk(1) = 2

rk(3) = 3

rk(6) = 4

rk(2) = 5

rk(5) = 6

rk(4) = 7

Suffix Array

Suffix Array／倍增法

Intuition

為了方便理解

以 $S[i \rightarrow k]$

代表從 $S_i$ 開始往後延伸長度 $k$ 的字串

$[i \rightarrow k]$

$S$

Suffix Array／倍增法

Intuition

如果已經排序完所有 $S[i \rightarrow k]$

接下來排序

$S[i \rightarrow 2k]$

$S$

Suffix Array／倍增法

比較兩個長度 $2k$ 的字串...

$S[i\rightarrow 2k]$

$S[j\rightarrow 2k]$

Suffix Array／倍增法

從中間砍半...

$S[i\rightarrow 2k]$

$S[j\rightarrow 2k]$

Suffix Array／倍增法

先比較左半邊

$S[i\rightarrow 2k]$

$S[j\rightarrow 2k]$

如果左半邊一樣大

那就比較右半邊

Suffix Array／倍增法

$S[i\rightarrow 2k]$

$S[j\rightarrow 2k]$

左右兩半都是長度 $k$ 的字串

由於已經排序完所有 $S[i\rightarrow k]$

$\Rightarrow$ $O(1)$ 完成大小比較！

先比較左半邊

如果左半邊一樣大

那就比較右半邊

Suffix Array／倍增法

Step 1／Base Case：排序 $S[i \rightarrow 1]$

Step 2／

利用 $S[i \rightarrow 2^0]$ 的結果，排序 $S[i \rightarrow 2^1]$

利用 $S[i \rightarrow 2^1]$ 的結果，排序 $S[i \rightarrow 2^2]$

利用 $S[i \rightarrow 2^2]$ 的結果，排序 $S[i \rightarrow 2^3]$

...

Suffix Array／倍增法

Step 1／Base Case：排序 $S[i \rightarrow 1]$

Step 2／

利用 $S[i \rightarrow 2^0]$ 的結果，排序 $S[i \rightarrow 2^1]$

利用 $S[i \rightarrow 2^1]$ 的結果，排序 $S[i \rightarrow 2^2]$

利用 $S[i \rightarrow 2^2]$ 的結果，排序 $S[i \rightarrow 2^3]$

...

重複直到 $S[i \rightarrow 2^k]$，其中 $2^k$ 已經 $\geq$ $S$ 原本的長度！

Suffix Array／倍增法

右邊是我們要排序的 Suffix Array

aababbb$

ababbb$a

babbb$aa

abbb$aab

bbb$aaba

bb$aabab

b$aababb

$aababbb

0

1

2

3

4

5

6

7

S = "aababbb$"

Suffix Array／倍增法

Step 1／Base Case：排序 $S[i \rightarrow 1]$

aababbb$

ababbb$a

babbb$aa

abbb$aab

bbb$aaba

bb$aabab

b$aababb

$aababbb

S = "aababbb$"

0

1

2

3

4

5

6

7

Suffix Array／倍增法

Step 1／Base Case：排序 $S[i \rightarrow 1]$

排序完成！

$aababbb

aababbb$

ababbb$a

abbb$aab

babbb$aa

bbb$aaba

bb$aabab

b$aababb

S = "aababbb$"

7

0

1

3

2

4

5

6

Suffix Array／倍增法

Step 2／

利用 $S[i \rightarrow 2^0]$ 的結果，排序 $S[i \rightarrow 2^1]$

$aababbb

aababbb$

ababbb$a

abbb$aab

babbb$aa

bbb$aaba

bb$aabab

b$aababb

S = "aababbb$"

7

0

1

3

2

4

5

6

Suffix Array／倍增法

Step 2／

利用 $S[i \rightarrow 2^0]$ 的結果，排序 $S[i \rightarrow 2^1]$

排序完成！

$aababbb

aababbb$

ababbb$a

abbb$aab

b$aababb

babbb$aa

bbb$aaba

bb$aabab

S = "aababbb$"

7

0

1

3

6

2

4

5

Suffix Array／倍增法

Step 2／

利用 $S[i \rightarrow 2^1]$ 的結果，排序 $S[i \rightarrow 2^2]$

$aababbb

aababbb$

ababbb$a

abbb$aab

b$aababb

babbb$aa

bbb$aaba

bb$aabab

S = "aababbb$"

7

0

1

3

6

2

4

5

Suffix Array／倍增法

Step 2／

利用 $S[i \rightarrow 2^1]$ 的結果，排序 $S[i \rightarrow 2^2]$

排序完成！

$aababbb

aababbb$

ababbb$a

abbb$aab

b$aababb

babbb$aa

bb$aabab

bbb$aaba

S = "aababbb$"

7

0

1

3

6

2

5

4

Suffix Array／倍增法

Step 2／

利用 $S[i \rightarrow 2^2]$ 的結果，排序 $S[i \rightarrow 2^3]$

$aababbb

aababbb$

ababbb$a

abbb$aab

b$aababb

babbb$aa

bb$aabab

bbb$aaba

S = "aababbb$"

7

0

1

3

6

2

5

4

Suffix Array／倍增法

Step 2／

利用 $S[i \rightarrow 2^2]$ 的結果，排序 $S[i \rightarrow 2^3]$

排序完成！

$aababbb

aababbb$

ababbb$a

abbb$aab

b$aababb

babbb$aa

bb$aabab

bbb$aaba

S = "aababbb$"

7

0

1

3

6

2

5

4

Suffix Array／倍增法

Step 2／

$2^3$ 已經 $\geq$ 原本長度

終止排序！

$aababbb

aababbb$

ababbb$a

abbb$aab

b$aababb

babbb$aa

bb$aabab

bbb$aaba

S = "aababbb$"

7

0

1

3

6

2

5

4

Suffix Array／倍增法

倍增法的複雜度取決於排序時使用的演算法

如果使用 std::sort $\Rightarrow O(n \log ^2 n) $

Suffix Array／倍增法

倍增法的複雜度取決於排序時使用的演算法

如果使用 std::sort $\Rightarrow O(n \log ^2 n) $

但因為 Suffix Array 值域是 $[0, n-1]$

所以可以用 Radix Sort

複雜度降為 $O(n \log n)$！

Suffix Array／模板請享用

struct suffixarray {
	string s;
	int n;  // 字串長度
	vector<int> suf, rk;
	// suf: Suffix Array
	// rk:  後綴 i 的排名

	// radix sort 要用的東西
	vector<int> cnt, pos;
	vector<pair<pii, int> > buc[2];
    
	void init(string& ss) {
		s = ss + (char)0;  // 加特殊字元到結尾
		n = (int)s.size();
		suf.resize(n);
		rk.resize(n);
		cnt.resize(n);
		pos.resize(n);
		Each(i, buc) i.resize(n);
	}

	// radix sort
	inline void radix_sort() {
		// 一開始 pair 被放在 buc[0]
		// 先排序 pair.second，放到 buc[1]
		// 接著排序 pair.first，放回 buc[0]
		REP(t, 2) {
			fill(cnt.begin(), cnt.end(), 0);
			Each(i, buc[t]) cnt[(t?i.F.F:i.F.S)]++;
			REP(i, n) pos[i] = i ? pos[i-1]+cnt[i-1] : 0;
			Each(i, buc[t]) buc[t^1][pos[(t?i.F.F:i.F.S)]++] = i;
		}
	}

	// 蓋 suf, rk
	inline bool fill_suf() {
		// buc[0]：已經排序好的
		REP(i, n) suf[i] = buc[0][i].S;

		// 蓋 rk
		rk[suf[0]] = 0;
		bool end = true;
		FOR(i, 1, n, 1) {
			bool dif = buc[0][i].F != buc[0][i-1].F;
			end &= dif;
			rk[suf[i]] = rk[suf[i-1]] + dif;
		}
		return end;

		// end：剪枝
		// 如果每個東西都長的不一樣
		// 那就不需要繼續倍增了
	}

	// 倍增蓋 Suffix Array
	void buildSA() {

		// 邊界條件：排序 [i->1]
		REP(i, n) buc[0][i] = mp(mp(s[i], s[i]), i);
		sort(buc[0].begin(), buc[0].end());
		if (fill_suf()) return;
		
		// 利用 [i->2^k] 的結果排序 [i->2^(k+1)]
		for (int k = 0; (1<<k) < n; k++) {
			// 把 [i->2^(k+1)] 以 pair(左半rank, 右半rank) 表示
			REP(i, n) buc[0][i] = mp(mp(rk[i], rk[(i+(1<<k))%n]), i);
			radix_sort();
			if (fill_suf()) return;
		}
	}
    
};
suffixarray sa;

填鴨教學繼續

除了 SA 之外

我們還要加蓋另一個奇怪的陣列

對於長度兩個字串 $S, T$

定義 $lcp(S, T)$ 為兩字串的最長共同前綴長度。

$S$

$T$

$lcp(S, T)$

LCP Array／定義

$

aababbb$

ababbb$

abbb$

b$

babbb$

bb$

bbb$

7

0

1

3

6

2

5

4

LCP Array／定義

接下來

我們要在 Suffix Array 上蓋 LCP Array

$lcp[i]=\begin{cases}lcp(\text{後綴}sa[i], \text{後綴}sa[i-1])&\text{if i>0}\\ 0&\text{otherwise.}\end{cases}$

接下來

我們要在 Suffix Array 上蓋 LCP Array

$lcp[i]=\begin{cases}lcp(\text{後綴}sa[i], \text{後綴}sa[i-1])&\text{if i>0}\\ 0&\text{otherwise.}\end{cases}$

$

aababbb$

ababbb$

abbb$

b$

babbb$

bb$

bbb$

7

0

1

3

6

2

5

4

LCP Array／定義

0

1

2

0

1

2

LCP Array

學怎麼蓋 LCP Array 之前

有一個重要的性質要先理解

Lemma.

對於 $i < j$，

$lcp(sa(i), sa(j)) = min\{lcp(sa(k-1), sa(k))\ |\ i < k \leq j\}$

$sa(j)$

$sa(i)$

$\vdots$

Lemma.

對於 $i < j$，

$lcp(sa(i), sa(j)) = min\{lcp[i+1], ..., lcp[j]\}$

$sa(j)$

$sa(i)$

$\vdots$

$lcp[i+1]$

$\vdots$

$lcp[j]$

這一段區間

取最小值

Proof.

設 $lcp(i, j) = k, i<j$，並設 $min\{lcp[i+1], ..., lcp[j]\} = m$。

由於 Suffix Array 已經排序好 $\Longrightarrow sa(i), sa(i+1), ..., s(j)$ 前 $k$ 個字元必定相同。

從而有 $m \geq k$。

而如果 $m > k$，則代表 $lcp(i, j) > k$，矛盾。

故 $m = k$，即 $lcp(sa(i), sa(j)) = min\{lcp[i+1], ..., lcp[j]\}$。

接下來介紹 $O(n)$ 蓋 LCP Array 的方法

"Kasai-Arimura-Arikawa-Lee-Park Algorithm"

LCP Array／建構

重要觀念

我們是在 SA 上面蓋表

但建表的順序要按照後綴原本的 index

主要是因為要利用以下這個性質：

LCP Array／建構

右邊是 Suffix Array 局部樣貌

設後綴 $i, j$ 在 SA 中相鄰且 $j$ 在 $i$ 上方

令 $lcp(i, j) = k, k>0$

LCP Array／建構

$i$

$j$

$k$

LCP Array／建構

$i$

$j$

$i+1$

$j+1$

右邊是 Suffix Array 局部樣貌

設後綴 $i, j$ 在 SA 中相鄰且 $j$ 在 $i$ 上方

令 $lcp(i, j) = k, k>0$

觀察到後綴 $i+1$ 其實只是後綴 $i$ 去掉第一個字

後綴 $j+1$ 亦然

$\Longrightarrow lcp(i+1, j+1) = k-1$

$k$

$k-1$

$\vdots$

LCP Array／建構

$i$

$j$

$i+1$

$j+1$

右邊是 Suffix Array 局部樣貌

設後綴 $i, j$ 在 SA 中相鄰且 $j$ 在 $i$ 上方

令 $lcp(i, j) = k, k>0$

觀察到後綴 $i+1$ 其實只是後綴 $i$ 去掉第一個字

後綴 $j+1$ 亦然

$\Longrightarrow lcp(i+1, j+1) = k-1$

再由前面的 Lemma.

$\Longrightarrow lcp[i+1]$ 至少 $\geq k-1$！

$k$

$k-1$

$\vdots$

LCP Array／建構

void buildLCP() {
	lcp[0] = 0;
	REP(i, n) {
		// building lcp[rk[i]]
		if (rk[i] == 0) continue;
		if (i) lcp[rk[i]] = max(0LL, lcp[rk[i-1]]-1);
		int j = suf[rk[i]-1];
		while (i+lcp[rk[i]] < n && j+lcp[rk[i]] < n &&
			 s[i+lcp[rk[i]]] == s[j+lcp[rk[i]]]) lcp[rk[i]]++;
	}
}

複雜度分析跟 KMP 很像

我懶得寫證明反正是 $O(n)$

字串演算法

內容大綱

名詞定義

字串

符號表示

子字串

子字串

子字串

前綴／後綴

字串大小關係

字典序

字串匹配

字串匹配

字串匹配

字串匹配

字串匹配

暴力匹配

時間複雜度

時間複雜度

時間複雜度

時間複雜度

天底下哪有那麼好的事

注意事項

例題

預處理！