687 lines
26 KiB
Markdown
687 lines
26 KiB
Markdown
---
|
||
title: "Algoritmy a datové struktury"
|
||
description: "TODO"
|
||
---
|
||
|
||
> [!NOTE]
|
||
> Pokročilé techniky návrhu algoritmů: dynamické programování, hladové strategie, backtracking. Amortizovaná analýza. Vyhledávání řetězců: naivní algoritmus pro hledání řetězců, Karp-Rabinův algoritmus, hledání řetězců pomocí konečných automatů. Algoritmus Knuth-Morris-Pratt.
|
||
> <br>
|
||
> _IV003_
|
||
|
||
|
||
## Pokročilé techniky návrhu algoritmů
|
||
|
||
### Dynamické programování
|
||
|
||
> I thought dynamic programming was a good name. It was something not even a Congressman could object to. So I used it as an umbrella for my activities.
|
||
>
|
||
> — Richard Bellman
|
||
|
||
Intutivně je _dynamické programování_ spojením dvou věcí: "rozbalené" rekurze (taky se tomu říká _bottom-up přístup_) a _memoizace_.
|
||
|
||
- Je použitelné na problémy, které lze rozdělit na podproblémy.
|
||
- Obzvlášť vhodné je pak v těch případech, kde se podproblémy překrývají -- dochází k tomu, že se něco počítá víckrát.
|
||
|
||
Konkrétněji, dynamické programování je vhodnou technikou, pokud:
|
||
|
||
- podproblémů je polynomiální počet,
|
||
- (optimální) řešení původního problému lze jednoduše spočítat z (optimálních) řešení jeho podproblémů,
|
||
- podproblémy jde přirozeně seřadit od _nejmenšího_ po _největší_.
|
||
|
||
> [!TIP]
|
||
> O tom, že problémů musí být polynomiální počet, přemýšlím intuitivně tak, že se musí dát vyřešit v nějakém vícenásobném `for`-cyklu a uložit do multi-dimenzionálního pole.
|
||
> <br>
|
||
> Pokud mám $l$ zanořených cyklů, vyřeším nejvíc $n^l$ podproblémů.
|
||
|
||
|
||
#### Memoizace
|
||
|
||
_Memoizace_ v zásadě není nic jiného než tabulka, pole, `HashSet`, nebo něco podobného, kam si algoritmus ukládá řešení jednotlivých podproblémů.
|
||
|
||
> [!TIP]
|
||
> V pseudokódu se označuje jako $M$ (asi memory), $A$ (asi array), nebo $C$ (asi cache).
|
||
|
||
#### Bottom-up
|
||
|
||
Rekurze tradičně řeší problém _zeshora_ -- začně celým problémem, který si rozdělí na podproblémy, a ty na podpodproblémy, atd. Bottom-up approach jde na to obráceně. Začně těmi nejmenšími podproblémy a postupně se prokousává k rešení celku.
|
||
|
||
Jediným háček je v tom přijít na to, které podproblémy jsou ty nejmenší a v jakém pořádí je musíme spočítat, aby byly všechny připravené pro výpočet větších podproblémů. Bez tohohle algoritmus nebude fungovat korektně.
|
||
|
||
> [!NOTE]
|
||
> Zjednodušeně jde o to přetransformovat rekurzi na cykly. Pěkný vedlejším efektem je, že je jednodušší určit složitost algoritmu.
|
||
|
||
|
||
#### Kuchařka
|
||
|
||
1. Rozděl problém na (překrývající se) podproblémy.
|
||
2. Napiš rekurzivní algoritmus nebo alespoň Bellmanův rekurentní vztah (značený $\text{OPT}$ protože dává _optimální_ řešení).
|
||
3. Urči správné pořadí počítání podproblémů tak, aby se každý počítal právě jednou (bottom-up přístup).
|
||
4. Pokud je to nutné, sestav z optimální hodnoty její realizaci (třeba cestu nebo něco).
|
||
5. Sepiš pseudokód.
|
||
6. Dokaž korektnost rekurentního vztahu, bottom-up pořadí a rekonstrukce (zejména terminace).
|
||
7. Okomentuj složitost.
|
||
|
||
#### Problémy
|
||
|
||
- **Weighted interval scheduling**\
|
||
Z množiny $n$ intervalů (událostí, úkolů, atd.), které se mohou překrývat v čase, a mají určitou váhu $w_i$, vyber takovou množinu intervalů $S$, pro kterou je $\sum_{i \in S} w_s$ maximální.
|
||
|
||
- **Řešení**
|
||
|
||
Řešení využívá toho, že čas plyne výhradně dopředu, takže se můžeme na podproblémy dívat chronologicky a nebudou se překrývat.
|
||
|
||
Nechť $p(j)$ je index takové události $i < j$, že $i$ a $j$ jsou kompatibilní.
|
||
|
||
```math
|
||
\text{OPT}(j) = \begin{cases}
|
||
|
||
0 & \text{pokud } j = 0 \\
|
||
\max \{ \text{OPT}(j-1), w_j + \text{OPT}(p(j)) \} & \text{pokud } j > 0
|
||
|
||
\end{cases}
|
||
```
|
||
|
||
- **Parenthesization**\
|
||
Mějme hromadu matic, které chceme pronásobit. Víme, že maticové násobení je asociativní, takže můžeme zvolit různé pořadí násobení -- různé odzávorkování. Nicméně, není komutativní, takže nesmíme matice prohazovat. Cena násobení matice o velikosti $i \times j$ a $j \times k$ je $i \cdot j \cdot k$. Jaké pořadí zvolit, aby byl výsledný součin co nejlevnější?
|
||
|
||
- **Problém**
|
||
|
||
Máme matice $A_1, A_2, ..., A_n$, které chceme pronásobit.
|
||
|
||
Potřebujeme najít index $k$ takový, že $\textcolor{red}{(A_1 \cdot ... \cdot A_k)} \cdot \textcolor{blue}{(A_{k+1} \cdot ... \cdot A_n)}$ je nefektivnější. To nám problém rozděluje na dva podproblémy: červený a modrý.
|
||
|
||
- **Řešení**
|
||
|
||
```math
|
||
\text{OPT}(i, j) = \begin{cases}
|
||
|
||
0 & \text{pokud } i = j \\
|
||
\min_{i \leq k < j} \{ \text{OPT}(i, k) + \text{OPT}(k+1, j) + p_{i-1} \cdot p_k \cdot p_j \} & \text{pokud } i < j
|
||
|
||
\end{cases}
|
||
```
|
||
|
||
- **Knapsack**\
|
||
Mějme batoh s nosností $W$ a $n$ věcí, které bychom do něj rádi naložili. Každá věc $i$ má hodnotu $v_i$ a váhu $w_i$. Jaké věci vybrat, aby byla hodnota naložených věcí co největší, ale batoh je furt unesl?
|
||
|
||
- **Řešení**
|
||
|
||
Vychází z myšlenky, že batoh, ve kterém už něco je, je _jakoby_ batoh s nižší nosností.
|
||
|
||
Procházíme věci postupně přes index $i$ a pro každou řešíme, jestli ji chceme v batohu o nosnosti $w$:
|
||
|
||
```math
|
||
\text{OPT}(i, w) = \begin{cases}
|
||
|
||
0 & \text{pokud } i = 0 \\
|
||
\text{OPT}(i - 1, w) & \text{pokud } w_i > w \\
|
||
\max \{ \text{OPT}(i - 1, w), v_i + \text{OPT}(i - 1, w - w_i) \} & \text{pokud } w_i \leq w
|
||
|
||
\end{cases}
|
||
```
|
||
|
||
### Hladové (greedy) strategie
|
||
|
||
> Přijde Honza na pracovní pohovor a budoucí šéf se ho ptá: "Co je vaše dobrá schopnost?"
|
||
> Honza odpoví: "Umím rychle počítat."
|
||
> "Kolik je 1024 na druhou?"
|
||
> "MILION STO TISÍC," vyhrkne ze sebe Honza.
|
||
> Šéf se chvíli zamyslí a povídá: "Ale to je špatně, výsledek je 1048576!"
|
||
> A Honza na to: "No sice špatně, ale sakra rychle!"
|
||
|
||
Greedy algoritmy nachází řešení globálního problému tak, že volí lokálně optimální řešení. Tahle taktika nemusí vést ke globálně optimálnímu řešení, ale alespoň ho spočítá rychle.
|
||
|
||
- Ve výpočtu směřuje bottom-up.
|
||
- Ideálně funguje na problémy, kde optimální řešení podproblému je součástí optimálního řešení celého problému.
|
||
- Dobře se navrhuje, špatně dokazuje.
|
||
|
||
#### Problémy
|
||
|
||
- **Cashier’s algorithm (mince)**\
|
||
Jak zaplatit danou částku s co nejmenším počtem mincí různých hodnot?
|
||
|
||
- **Řešení**\
|
||
V každé iteraci vol minci s nejvyšší hodnotou, dokud není zaplacena celá částka.
|
||
|
||
- **Interval scheduling**\
|
||
Z množiny intervalů, které mají začátek a konec, **ale mají stejnou hodnotu**, vyber největší podmnožinu intervalů, které se nepřekrývají.
|
||
|
||
- **Řešení**\
|
||
Vybereme ty, které končí nejdřív.
|
||
|
||
### Backtracking
|
||
|
||
_Inteligentní brute-force nad prostorem řešení._
|
||
|
||
Technika hledání řešení problému postupným sestavováním _kandidátního_ řešení. [backtracking](#backtracking)
|
||
|
||
- Částečný kandidát může být zavrhnut, pokud nemůže být dokončen.
|
||
- Můžeme dokonce zavrhnout kompletní řešení, pokud je chceme najít všechna.
|
||
- Pokud je kandidát zavrhnut, algoritmus se vrátí o kus zpět (backtrackuje), upraví parametry a zkusí to znovu.
|
||
|
||
**Porovnání s dynamickým programováním**
|
||
|
||
| Dynamické programování |
|
||
| ------------------------------------------------------------ |
|
||
| Backtracking |
|
||
| Hledá řešení _překrývajících se podproblémů_. |
|
||
| Hledá _všechna_ řešení. |
|
||
| Hledá _optimální_ řešení. |
|
||
| Hledá všechna, _libovolná_ řešení, _hrubou silou_. |
|
||
| Má blíž k BFS -- staví "vrstvy". |
|
||
| Má blíž k DFS -- zanoří se do jednoho řešení a pak se vrátí. |
|
||
| Typicky zabírá víc paměti kvůli memoizaci. |
|
||
| Typicky trvá déle, protože hledá _všechna_ řešení. |
|
||
| Mívá cykly. |
|
||
| Mívá rekurzi. |
|
||
|
||
#### Problémy
|
||
|
||
- **Sudoku**\
|
||
Hledá řešení tak, že pro pole vybere možné řešení a zanoří se, pokud funguje tak _hurá_, pokud ne, tak backtrackuje a zkusí jinou možnou cifru.
|
||
- **Eight queens**\
|
||
Jak rozestavit osm šachových královen na šachovnic tak, aby se vzájemně neohrožovaly?
|
||
|
||
## Amortizovaná analýza
|
||
|
||
> - **_amortize(v)_**
|
||
> - _amortisen_ -- "to alienate lands", "to deaden, destroy"
|
||
> - _amortir_ (Old French) -- "deaden, kill, destroy; give up by right"
|
||
> - _\*admortire_ (Vulgar Latin) -- to extinquish
|
||
>
|
||
> — Online Etymology Dictionary
|
||
|
||
Umožňuje přesnější analýzu časové a prostorové složitosti, protože uvažujeme kontext, ve které se analyzovaný algoritmus používá. Určujeme složitost operace v **posloupnosti operací**, **ne samostatně**.
|
||
|
||
**Připomenutí**
|
||
|
||
> [!TIP]
|
||
> Viz bakalářská otázka [Korektnost a složitost algoritmu](../../szb/korektnost-a-slozitost-algoritmu/).
|
||
|
||
Základními pojmy analýzy složitosti jsou:
|
||
|
||
- **Časová složitost**\
|
||
Funkce velikosti vstupu $n$ algoritmu. Počítá počet _kroků_ (nějaké výpočetní jednotky) potřebných k vyřešení problému.
|
||
- **Prostorová složitost**\
|
||
Funkce velikosti vstup $n$ algoritmu. Počítá počet _polí_ (nějaké jednotky prostoru), která algoritmus potřebuje navštívit k vyřešení problému.
|
||
- **Asymptotická notace**\
|
||
Umožňuje zanedbat hardwarové rozdíly. Popisuje, že složitost roste _alespoň tak_, _nejvýš tak_ nebo _stejně_ jako jiná funkce.
|
||
- **Big O**\
|
||
Horní mez, složitost v nejhorším případě. Množina funkcí rostoucích stejně rychle jako $g$, nebo **pomaleji**:
|
||
|
||
```math
|
||
\mathcal{O}(g(n)) = \{f : (\exists c, n_0 \in \mathbb{N}^+)(\forall n \geq n_0)(f(n) \le c \cdot g(n)) \}
|
||
```
|
||
|
||
- **Omega**\
|
||
Spodní mez, složitost v nejlepším případě. Množina funkcí rostoucích stejně rychle jako $g$, nebo **rychleji**.
|
||
|
||
```math
|
||
\Omega(g) = \{f : (\exists c, n_0 \in \mathbb{N}^+)(\forall n \geq n_0)(f(n) \ge c \cdot g(n)) \}
|
||
```
|
||
|
||
- **Theta**\
|
||
Horní i spodní mez. Množina funkcí rostoucích stejně rychle jako $g$.
|
||
|
||
```math
|
||
\Theta(g) = \mathcal{O}(g) \cap \Omega(g)
|
||
```
|
||
|
||
### Aggregate method (brute force)
|
||
|
||
Analyzujeme celou sekvenci operací najednou. Nepoužíváme žádné chytristiky ani fígle.
|
||
|
||
**Zásobník (brute force)**
|
||
|
||
- **Věta**\
|
||
Pokud začneme s prázdným zásobníkem, pak libovolná posloupnost $n$ operací `Push`, `Pop` a `Multi-Pop` zabere $\mathcal{O}(n)$ času.
|
||
- **Důkaz**
|
||
- Každý prvek je `Pop`nut nejvýše jednou pro každý jeho `Push`.
|
||
- V posloupnosti je $\le n$ `Push`ů.
|
||
- V posloupnosti je $\le n$ `Pop`ů (včetně těch v `Multi-Pop`u).
|
||
- Celá posloupnost má tak nejvýše složitost $2n$.
|
||
|
||
### Accounting method (banker's method)
|
||
|
||
Používá fígl, kdy velké množství _levných_ operací "předplatí" jednu _drahou_ operaci. Využívá metaforu bankovního účtu.
|
||
|
||
- Každé operaci přiřadíme fiktivní _kreditovou_ cenu.
|
||
- Při realizaci operace zaplatíme _skutečnou_ cenu naspořenými kredity.
|
||
- Počáteční stav je 0 kreditů.
|
||
|
||
Pro každou operaci v posloupnosti:
|
||
|
||
- Pokud je _skutečná_ cena nižší než _kreditová_, tak zaplatíme skutečnou cenu a přebývající kredity uspoříme na _účtu_.
|
||
- Pokud je _skutečná_ cena vyšší než _kreditová_, tak zaplatíme skutečnou cenu a případný nedostatek kreditů doplatíme z úspor na _účtu_.
|
||
|
||
> [!IMPORTANT]
|
||
> Pokud je po celou dobu provádění operací stav účtu **nezáporný**, pak je _skutečná_ složitost celé posloupnosti operací menší nebo rovna součtu _kreditových_ cen operací.
|
||
|
||
> [!WARNING]
|
||
> Pokud stav účtu **kdykoliv během posloupnosti** klesne pod nulu, pak jsou kreditové ceny nastaveny **špatně**!
|
||
|
||
> [!TIP]
|
||
> Tato metoda se dá upravit tak, že kredity náleží individuálním objektům ve struktuře místo struktury jako celku. Cena operace se pak platí z kreditů objektů, nad kterým operace probíhá.
|
||
|
||
**Zásobník (kredity)**
|
||
|
||
| Operace |
|
||
| --------------- |
|
||
| Skutečná cena |
|
||
| Kreditová cena |
|
||
| `Push` |
|
||
| 1 |
|
||
| 2 |
|
||
| `Pop` |
|
||
| 1 |
|
||
| 0 |
|
||
| `Multi-Pop` |
|
||
| stem:[\min(k,\ |
|
||
| S\ |
|
||
| )] |
|
||
| 0 |
|
||
|
||
- **Invariant**\
|
||
Počet kreditů na účtu je rovný počtu prvků na zásobníku.
|
||
- **Důkaz**
|
||
- Invariant platí pro prádný zásobník.
|
||
- S `Push` operací se na účet připíše právě 1 kredit. (Čímž se předplatí `Pop` nebo `Multi-Pop`.)
|
||
- `Pop` a `Multi-Pop` operace spotřebují právě 1 kredit z účtu.
|
||
- Tedy stav účtu nikdy neklesne pod 0.
|
||
- Tedy složitost posloupnosti je nejvýše součet kreditových cen, tedy $2n$.
|
||
|
||
### Potential method (physicist's method)
|
||
|
||
Hraje si s představou toho, že struktura je fyzikální systém s nějakou energetickou hladinou -- potenciálem. Výhodou této metody je, že stačí zvolit _jednu_ funkci, která splňuje dané podmínky. Nevýhodou je, že takovou funkci najít je těžké. Člověk zkrátka buď dostane nápad nebo ne.
|
||
|
||
- **Potenciálová funkce**\
|
||
Funkce $\Phi$, která přiřadí dané struktuře $S$ hodnotu. Platí, že:
|
||
|
||
```math
|
||
\begin{align*}
|
||
\Phi(S_0) &= 0 \text{, kde } S_0 \text{ je počáteční stav} \\
|
||
\Phi(S_i) &\ge 0 \text{ pro každou strukturu } S_i
|
||
\end{align*}
|
||
```
|
||
|
||
- **Amortizovaná cena**\
|
||
Pokud $c_i$ je _skutečná_ cena operace, pak pro amortizovanou cenu $\hat{c_i}$ platí:
|
||
|
||
```math
|
||
\hat{c_i} = c_i + \Phi(S_i) - \Phi(S_{i-1})
|
||
```
|
||
|
||
- **Potenciálová věta**\
|
||
Počínaje počátečním stavem $S_0$, celková _skutečná_ cena posloupnosti $n$ operací je nejvýše součet jejich amortizovaných cen.
|
||
- **Důkaz**
|
||
|
||
```math
|
||
\begin{align*}
|
||
\sum_{i=1}^n \hat{c_i} &= \sum_{i=1}^n (c_i + \Phi(S_i) - \Phi(S_{i-1})) \\
|
||
&= \sum_{i=1}^n c_i + \Phi(S_n) - \Phi(S_0) \\
|
||
&\geq \sum_{i=1}^n c_i \quad\tiny\blacksquare
|
||
\end{align*}
|
||
```
|
||
|
||
**Zásobník (potenciálová věta)**
|
||
|
||
$\Phi(S) = |S|$ (počet prvků na zásobníku)
|
||
|
||
| Operace |
|
||
| ------------------------- |
|
||
| Skutečná cena |
|
||
| Amortizovaná cena |
|
||
| `Push` |
|
||
| 1 |
|
||
| stem:[\hat{c_i} = 1 + (\ |
|
||
| S\ |
|
||
| + 1) - \ |
|
||
| S\ |
|
||
| = 2] |
|
||
| `Pop` |
|
||
| 1 |
|
||
| stem:[\hat{c_i} = 1 + \ |
|
||
| S\ |
|
||
| - (\ |
|
||
| S\ |
|
||
| + 1) = 0] |
|
||
| `Multi-Pop` |
|
||
| stem:[\min(k,\ |
|
||
| S\ |
|
||
| )] |
|
||
| |
|
||
|
||
```math
|
||
\hat{c_i} =
|
||
\begin{cases}
|
||
k + (\|S\| - k) - \|S\| = 0 & \text{pokud } \|S\| > k \\
|
||
\|S\| + (\|S\| - \|S\|) - \|S\| = 0 & \text{pokud } \|S\| \le k
|
||
|
||
\end{cases}
|
||
```
|
||
|
||
- **Věta**\
|
||
Počínaje prázdným zásobníkem, libovolná sekvence operací zabere $\mathcal{O}(n)$ času.
|
||
- **Důkaz (případ `Push`)**
|
||
- Skutečná cena je $c_i = 1$.
|
||
- Amortizovaná cena je $\hat{c_i} = c_i + \Phi(S_i) - \Phi(S_{i-1}) = 1 + (|S| + 1) - |S| = 2$.
|
||
- **Důkaz (případ `Pop`)**
|
||
- Skutečná cena je $c_i = 1$.
|
||
- Amortizovaná cena je $\hat{c_i} = c_i + \Phi(S_i) - \Phi(S_{i-1}) = 1 - 1 = 0$.
|
||
- **Důkaz (případ `Multi-Pop`)**
|
||
- Skutečná cena je $c_i = k$.
|
||
- Amortizovaná cena je $\hat{c_i} = c_i + \Phi(S_i) - \Phi(S_{i-1}) = k - k = 0$.
|
||
- **Důkaz (závěr)**
|
||
- Amortizovaná cena všech operací je $\hat{c_i} \le 2$.
|
||
- Součet amortizovaných cen posloupnosti $n$ operací je pak $\sum_{i=1}^n \hat{c_i} \le 2n$.
|
||
- Z potenciálnové věty plyne, že skutečná cena posloupnosti je $\le 2n$.
|
||
|
||
---
|
||
|
||
**Slavné potenciálové funkce**
|
||
|
||
- **Fibonnacciho halda**
|
||
|
||
```math
|
||
\Phi(H) = 2 \cdot \text{trees}(H) - 2 \cdot \text{marks}(H)
|
||
```
|
||
|
||
- **Splay trees**\
|
||
Binární vyhledávací stromy, kde poslední přídané prvky jsou přístupné rychleji. [(zdroj)](https://en.wikipedia.org/wiki/Splay_tree)
|
||
|
||
```math
|
||
\Phi(T) = \sum_{x \in T} \lfloor \log_2 \text{size}(x) \rfloor
|
||
```
|
||
|
||
- **Move-to-front**\
|
||
Transformace dat používaná při kompresi dat. [(zdroj)](https://en.wikipedia.org/wiki/Move-to-front_transform)
|
||
|
||
```math
|
||
\Phi(L) = 2 \cdot \text{inversions}(L, L^*)
|
||
```
|
||
|
||
- **Preflow-push (push-relabel)**
|
||
|
||
```math
|
||
\Phi(f) = \sum_{v \,:\, \text{excess}(v) > 0} \text{height}(v)
|
||
```
|
||
|
||
- **Red-black trees**
|
||
|
||
```math
|
||
\Phi(T) = \sum_{x \in T} w(x)
|
||
|
||
\\
|
||
|
||
w(x) = \begin{cases}
|
||
0 & \text{pokud } x \text{ je červený} \\
|
||
1 & \text{pokud } x \text{ je černý a nemá žádné červené potomky} \\
|
||
0 & \text{pokud } x \text{ je černý a má jednoho červeného potomka} \\
|
||
2 & \text{pokud } x \text{ je černý a má dva červené potomky}
|
||
\end{cases}
|
||
```
|
||
|
||
## Vyhledávání řetězců (string matching)
|
||
|
||
_String matching_ označuje rodinu problémů obsahující třeba:
|
||
|
||
- Nalezení prvního přesného výskytu podřetězce (_patternu_) v řetězci (_stringu_ / _textu_).
|
||
- Nalezení všech výskytů podřetězce v řetězci.
|
||
- Výpočet vzdálenosti dvou řetězců.
|
||
- Hledání opakujících se podřetězců.
|
||
|
||
Většinou je řetězec polem znaků z konečné abecedy $\Sigma$. String matching algoritmy se ale dají použít na ledacos.
|
||
|
||
Vzorek $P$ se vyskytuje v textu $T$ s posunem $s$, pokud $0 \le s \le n - m$ a zároveň $T\lbrack (s+1) .. (s + m) \rbrack = P$. Pro nalezení platných posunů lze použít řadu algoritmů, které se liší složitostí předzpracování i samotného vyhledávání: [iv003-strings](#iv003-strings)
|
||
|
||
| Algoritmus |
|
||
| ----------------------------------- |
|
||
| Preprocessing |
|
||
| Searching |
|
||
| Brute force / naivní |
|
||
| $0$ |
|
||
| $\mathcal{O}((n - m + 1) \cdot m)$ |
|
||
| Karp-Rabin |
|
||
| $\Theta(m)$ |
|
||
| $\mathcal{O}((n - m + 1) \cdot m)$ |
|
||
| finite automata |
|
||
| stem:[\Theta(m \cdot \ |
|
||
| \Sigma\ |
|
||
| )] |
|
||
| $\Theta(n)$ |
|
||
| Knuth-Morris-Pratt |
|
||
| $\Theta(m)$ |
|
||
| $\Theta(m)$ |
|
||
| Boyer-Moore |
|
||
| stem:[\Theta(m + \ |
|
||
| \Sigma\ |
|
||
| )] |
|
||
| $\mathcal{O}((n - m + 1) \cdot m)$ |
|
||
|
||
- $T$ nebo $T\lbrack 1..n \rbrack$ -- text.
|
||
- $P$ nebo $P\lbrack 1..m \rbrack$ -- pattern.
|
||
- $n$ -- délka textu $T$.
|
||
- $m$ -- délka vzorku / podřetězce / patternu $P$.
|
||
- $\Sigma$ -- konečná abeceda, ze které je složen text i pattern.
|
||
|
||
### Brute force / naivní
|
||
|
||
Prochází všechny pozice v textu a porovnává je s patternem. Pokud se neshodují, posune se o jedno pole dopředu.
|
||
|
||
Pokud se text neshoduje už v prvním znaku, je složitost lineární. Avšak v nejhorším případě, kdy se pattern shoduje s textem až na poslední znak, je složitost až kvadratická.
|
||
|
||
```csharp
|
||
int Naive(string text, string pattern)
|
||
{
|
||
int n = text.Length;
|
||
int m = pattern.Length;
|
||
for (int i = 0; i < n - m + 1; i++)
|
||
{
|
||
// NB: Substring creates a new string but let's not worry about that.
|
||
if (text.Substring(i, m) == pattern)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
```
|
||
|
||
- **Složitost**\
|
||
Cyklus je proveden $n-m+1$-krát. V každé iteraci se provede přinejhorším až $m$ porovnání. (Zanedbáváme složitost `Substring`, která v C# dělá kopii.)
|
||
|
||
### Karp-Rabin
|
||
|
||
Používá hashování. Vytvoří hash z patternu a hashuje i všechny podřetězce délky $m$ v textu. Nejprve eliminuje všechny pozice, kde se hashe neshodují. Pokud se shodují, porovná je znak po znaku.
|
||
|
||
```csharp
|
||
int KarpRabin(string text, string pattern)
|
||
{
|
||
int n = text.Length;
|
||
int m = pattern.Length;
|
||
int patternHash = pattern.GetHash();
|
||
for (int i = 0; i < n - m + 1; i++)
|
||
{
|
||
// NB: Assume that `GetHash` is a rolling hash, even though in .NET it's not.
|
||
if (text.Substring(i, m).GetHash() == patternHash)
|
||
{
|
||
if (text.Substring(i, m) == pattern)
|
||
{
|
||
return i;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
```
|
||
|
||
- **Hashování**\
|
||
Trik spočívá v použití _rolling_ hashovacího algoritmu. Ten je schopný při výpočtu hashe pro $T\lbrack s .. (s + m) \rbrack$ použít hash $T\lbrack s .. (s + m - 1) \rbrack$ s využitím pouze jednoho dalšího znaku $T\lbrack s + m \rbrack$. Přepočet hashe je tedy $\mathcal{O}(1)$.
|
||
|
||
Jeden takový algoritmus lze získat použitím Hornerova schématu pro evaluaci polynomu. [horner](#horner) Předpokládejme, že $\Sigma = \{0, 1, ..., 9\}$ (velikost může být libovolná), pak pro hash $h$ platí
|
||
|
||
```math
|
||
\begin{align*}
|
||
h &= P[1] + 10 \cdot P[2] + 10^2 \cdot P[3] + ... + 10^{m-1} \cdot P[m] \\
|
||
&= P[1] + 10 \cdot (P[2] + 10 \cdot (P[3] + ... + 10 \cdot P[m] ... ))
|
||
\end{align*}
|
||
```
|
||
|
||
Pokud jsou hashe příliš velké, lze navíc použít modulo $q$, kde $10 \cdot q \approx \text{machine word}$.
|
||
|
||
- **Složitost**\
|
||
Předzpracování zahrnuje výpočet $T \lbrack 1..m \rbrack$ v $\Theta(m)$.
|
||
|
||
Složitost výpočtu je v nejhorším případě $\mathcal{O}((n - m + 1) \cdot m)$, jelikož je potřeba porovnat všechny podřetězce délky $m$ s patternem.
|
||
|
||
Tento algoritmus se hodí použít, pokud hledáme v textu celé věty, protože neočekáváme velké množství "falešných" shod, které mají stejný hash jako $P$. V tomto případě je průměrná složitost $\mathcal{O}(n)$.
|
||
|
||
### Konečné automaty
|
||
|
||
Složitost naivního algortmu lze vylepšit použitím konečného automatu.
|
||
|
||
Mějmě DFA $A = (\{0, ..., m\}, \Sigma, \delta, \{0\}, \{m\})$, kde přechodobou funkci definujeme jako:
|
||
|
||
```math
|
||
\delta(q, x) = \text{největší } k \text{ takové, že } P[1..k] \text{ je \textbf{prefix} a zároveň \textbf{suffix} } P[1..q] . x
|
||
```
|
||
|
||
Jinými slovy, $\delta$ vrací delků nejdelšího možného začátku $P$, který se nachází na daném místě (stavu $q$) v řetězci $T$.
|
||
|
||
Prakticky by příprava přechodové funkce mohla vypadat takto:
|
||
|
||
```csharp
|
||
int[,] CreateAutomaton(string pattern)
|
||
{
|
||
int m = pattern.Length;
|
||
// NB: Assumes that the alphabet is ASCII.
|
||
int[,] automaton = new int[m + 1, 256];
|
||
for (int q = 0; q <= m; q++)
|
||
{
|
||
for (int c = 0; c < 256; c++)
|
||
{
|
||
int k = Math.Min(m + 1, q + 2);
|
||
do
|
||
{
|
||
k--;
|
||
}
|
||
while (!pattern.Substring(0, q).Equals(pattern.Substring(0, k) + (char)c));
|
||
automaton[q, c] = k;
|
||
}
|
||
}
|
||
return automaton;
|
||
}
|
||
```
|
||
|
||
Vyhledávání v textu pak bude vypadat takto:
|
||
|
||
```csharp
|
||
int FiniteAutomaton(string text, string pattern)
|
||
{
|
||
int n = text.Length;
|
||
int m = pattern.Length;
|
||
int[,] automaton = CreateAutomaton(pattern);
|
||
int q = 0;
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
q = automaton[q, text[i]];
|
||
if (q == m)
|
||
{
|
||
return i - m + 1;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
```
|
||
|
||
Tato metoda šetří čas, pokud se pattern v některých místech opakuje. Mějmě například pattern `abcDabcE` a text `abcDabcDabcE`. Tato metoda nemusí začínat porovnávat pattern od začátku po přečtení druhého `D`, ale začne od $P \lbrack 5 \rbrack$ (včetně), protože _ví_, že předchozí část patternu se již vyskytla v textu.
|
||
|
||
Jinými slovy na indexu druhého `D` je `abcD` nejdelší prefix $P$, který je zároveň suffixem už načteného řetězce.
|
||
|
||
- **Složitost**\
|
||
Vytvoření automatu vyžaduje $\Theta(m^3 \cdot |\Sigma|)$ času, dá se však provést efektivněji než v `CreateAutomaton` a to v čase $\Theta(m \cdot |\Sigma|)$.
|
||
|
||
Složitost hledání je pak v $\Theta(n)$. [iv003-strings](#iv003-strings)
|
||
|
||
### Knuth-Morris-Pratt (KMP)
|
||
|
||
KMP představuje efektivnější využití idei z metody konečného automatu:
|
||
|
||
- Každý stav $q$ je označen písmenem z patternu. Výjimkou je počáteční stav $S$ a koncový stav $F$.
|
||
- Každý stav má hranu `success`, která popisuje sekvenci znaků z patternu, a `failure` hranu, která míří do některého z předchozích stavů -- takového, že už načtené znaky jsou největší možný prefix patternu.
|
||
|
||
V reálné implementaci nejsou `success` hrany potřeba; potřebujeme jen vědět, kam skočit v případě neúspěchu.
|
||
|
||
```csharp
|
||
/// <summary>
|
||
/// Computes the longest proper prefix of P[0..i]
|
||
/// that is also a suffix of P[0..i].
|
||
/// </summary>
|
||
int[] ComputeFailure(string pattern)
|
||
{
|
||
int m = pattern.Length;
|
||
int[] fail = new int[m];
|
||
int j = 0;
|
||
for (int i = 1; i < m; i++)
|
||
{
|
||
while (j >= 0 && pattern[j] != pattern[i])
|
||
{
|
||
j = fail[j];
|
||
}
|
||
|
||
// If comparison at i fails,
|
||
// return to j as the new starting point.
|
||
fail[i] = j;
|
||
|
||
j++;
|
||
}
|
||
return fail;
|
||
}
|
||
|
||
int KnuthMorrisPratt(string text, string pattern)
|
||
{
|
||
int[] fail = ComputeFailure(pattern);
|
||
int n = text.Length;
|
||
int m = pattern.Length;
|
||
// NB: I index from 0 here. Although I use 1..n in the text.
|
||
int i = 0;
|
||
int j = 0;
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
while (j >= 0 && text[i] != pattern[j])
|
||
{
|
||
/*
|
||
There can be at most n-1 failed comparisons
|
||
since the number of times we decrease j cannot
|
||
exceed the number of times we increment i.
|
||
*/
|
||
j = fail[j];
|
||
}
|
||
|
||
j++;
|
||
if (j == m)
|
||
{
|
||
return i - m;
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
```
|
||
|
||
> [!WARNING]
|
||
> Nejsem si jistý, že ty indexy v kódu výše mám dobře.
|
||
|
||
> [!NOTE]
|
||
> "In other words we can amortize character mismatches against earlier character matches." [iv003-strings](#iv003-strings)
|
||
|
||
- **Složitost**\
|
||
Amortizací neúspěšných porovnání vůči úspěšným získáme $\mathcal{O}(m)$ pro `ComputeFailure` a $\mathcal{O}(n)$ pro `KnuthMorrisPratt`.
|
||
|
||
## Zdroje
|
||
|
||
- [[[iv003, 1]]] [IV003 Algoritmy a datové struktury II (jaro 2021)](https://is.muni.cz/auth/el/fi/jaro2021/IV003/)
|
||
- [[[iv003-strings,2]]] https://is.muni.cz/auth/el/fi/jaro2021/IV003/um/slides/stringmatching.pdf
|
||
- [[[rabin-karp-wiki,3]]] https://en.wikipedia.org/wiki/Rabin%E2%80%93Karp_algorithm
|
||
- [[[horner,4]]] https://en.wikipedia.org/wiki/Horner%27s_method
|
||
- [[[backtracking,5]]] https://betterprogramming.pub/the-technical-interview-guide-to-backtracking-e1a03ca4abad
|