【算法學習筆記十三】隨機算法

按照字典中使用的定義，當事件不可預測地發生時，它被認爲是隨機的。

對象在沒有任何計劃的情況下被創建時稱爲隨機。

根本的問題是，隨機性是否真的存在，或者我們是否只使用這個術語來建模具有未知規律性的對象和事件。

測試串的相等性

我們要檢查RI和RII是否包含相同的數據。通信協議的複雜性是爲了解決這個決策問題而必須在RI和RII之間交換的比特數，我們顯然試圖將這種複雜性降到最低。

可以證明，解決此任務的每個確定性通信協議必須在RI和RII之間交換至少n位發送n = $10^{16}$ 位，並確保所有數據都安全地到達另一端是一項非常重要的任務

設 $x=x_1,x_2,...,x_n,x_i\in {0,1}$ ，我們表示 $Number(x)=\sum_{i=1}^{n}2^{n-i}x_i$ ，表示x的二進制字符串；

初始情況:RI有一個n位的序列x, x = x1x2…xn，和RII有一個序列y，由n個比特組成，y = y1y2...yn。

階段1:RI從區間[2,]中隨機均勻地選擇一個素數p。

階段2:RI計算整數s = Number(x)對p取餘，並將s和p的二進制表示形式發送給RII。

階段3:在閱讀s和p之後，RII計算q = number (y) mod p。

如果q = s，則RII輸出“x = y”。

如果q ≠ s，然後RII輸出 “x ≠ y”。

協議的唯一通信涉及提交正整數s和p的二進制表示，因此消息的長度最多爲4logn。讓我們首先認識到隨機方案可能會出錯，對於任何輸入(x, y)，壞素數的個數最多爲n - 1。因此錯誤概率最多是。

當輸入x=y相等時，輸出一定是正確的；當輸出x≠y時，輸入時x≠y。

給定x≠y，錯誤概率 $P(error)=\frac{bad\ primes}{prim(n^2)}$ ，壞素數指的是當對於x≠y的輸入，輸出錯誤的結果，即x=y，指 $\leq n^2$ 的素數個數。例如，當輸入15和22，p爲7時，輸出的結果爲15=22，那麼此時7就是一個壞素數

素數定理： $\lim_{m\rightarrow \infty }\frac{prim(m)}{m/lnm}=1$ ，且 $prim(m)> \frac{m}{lnm},m>67$

當n>9， $prim(n^2)> \frac{n^2}{lnn^2}$ 。

p對於(x,y)是壞素數 $\Leftrightarrow$ p可整除因子分解 $w=p_1^{i1}p_2^{i2}...p_k^{ik},p_1<p_2<...<p_k$ 是素數，若k≥n， $w\geq p_1p_2...p_k>1*2*...*n=n!>2^n$ ，與已知矛盾，則k<n。

$P(error)=\frac{bad\ primes}{prim(n^2)}\leq \frac{n}{n^2/lnn^2}\leq lnn^2/n$ 。

隨機算法A的錯誤概率可以通過執行A的多次獨立運行而大幅度降低從理論上講，所有的確定性算法都是絕對正確的，而隨機算法可能會出錯。但本質是，確定性程序並不是絕對可靠的，因爲在它們在計算機上運行的過程中，可能會出現硬件錯誤，然後它們可能會產生錯誤的結果。顯然，出現硬件錯誤的概率隨着程序的運行時間成比例地增長。因此，快速隨機算法比慢速確定性算法更可靠。

不要求算法的輸出必須在特定輸入的每次運行中都是相同的。放寬條件，算法必須爲所有可能的輸入正確地解決問題。隨機算法在應用於相同的輸入時可能會給出不同的結果。但執行時間或空間需求往往小於最優確定性算法。它們非常容易理解和實現。

指示隨機變量(Indicator random variables,IRV)

一個轉換概率和期望的方便方法。

假設我們有一個樣本空間S和一個事件A，那麼與事件A關聯的指示隨機變量I{A}被定義爲

$I(A)=\left\{\begin{matrix} 1 & if\ A\ occurs\\ 0 & if\ A\ does\ not\ occurs \end{matrix}\right.$

引理:給定一個樣本空間S和一個事件A，令 $X_A=I\{A\}$ ，那麼 $E[X_A]=Pr\{A\}$ 。

生日悖論:

一間屋子裏有多少人，纔有50%的機會其中兩人是在一年的同一天出生的?

球和垃圾箱:

隨機把相同的球扔進b箱，一個箱子裏有多少個球?在一個給定的箱子裏有一個球之前，平均要扔多少個球?要投擲多少個球才能使每個箱子裏至少有一個球?

正面:

拋一枚均勻硬幣n次，你希望看到的最長的連續正面是什麼?

僱傭問題

通過職業介紹所僱傭一名新的辦公室助理，機構每天會給你派一個候選人，你會面試那個人，然後決定是否僱傭他，你必須付給中介一筆小額的面試費，要想真正僱傭一個求職者，你必須解僱你現在的辦公室助理，並向職業介紹所支付一大筆僱傭費。你承諾在任何時候都要有最適合這份工作的人估計一下這個價格是多少。
HIRE-ASSISTANT(n)
1. best←0
2. for i←1 to n
3.     interview candidate i
4.     if candidate i is better than candidate best
5.     then best←i and hire candidate i
6. endfor
面試和招聘產生的成本:。最壞情況分析的結果是。但最壞的情況很少發生。

引理:假設候選人以隨機順序出現，算法僱傭助手的總僱傭成本爲。

$X_i=\left\{\begin{matrix} 1 & if\ i\ is\ hired\\ 0 & if\ i\ is\ not \end{matrix}\right.$ ，整個過程僱傭的人數。

如果i比1到i-1的人都好，則i會被僱傭，與後面的人無關，E[Xi]=Pr{i被僱傭}=1/i； $E[X_i]=E[\Sigma X_i]=\Sigma E[X_i]=\Sigma 1/i=\Theta (logn)$

在線僱傭問題

如果我們只有一次機會招聘一個人，如何設計算法來找到最接近的人?在最大限度地減少面試次數和最大限度地提高候選人的招聘質量之間如何取捨?面試完一個人需要馬上做決定——僱傭或者不僱傭，如果不僱傭，那麼這個人不再有機會，如果僱傭，後面的沒有機會面試和被僱傭。

策略:面試並拒絕前k個申請者，然後僱傭比之前所有申請者都優秀的第一個申請者。
ON-LINE-MAXIMUM(k,n)
1. bestscore←0
2. for i←1 to k
3.     if score(i)>bestscore then bestscore←score(i)
4. for i←k+1 to n
5.     if score(i)>bestscore then return i
6. return n
k=n/e，至少有可能僱傭最優秀的應聘者概率爲1/e。

證明：

固定k， $M(j)=\max_{1\leq i\leq j}score\{i\}$ ，表示前j個人中的最高分；S：成功僱傭到最好的；：最好的是第i個且被僱傭。

$Pr(S)=\sum_{i=1}^{n}Pr(S_i) \\ \because Pr(S_i)=0,i=1,...k \\ \therefore Pr(S)=\sum_{k+1}^{n}Pr(S_i)$ ，：最好的人在第i位；：k+1到i-1的人未被僱傭 $Pr(S_i)=Pr\{B_i\cap O_i\}=Pr\{B_i\}\cdot Pr\{O_i\}$ (前i個人中最好的出現在前k位) $=\frac{1}{ n}\cdot \frac{k}{i-1}$ ； $Pr(S)=\sum_{i=k+1}^{n}Pr(S_i)=\sum_{i=k+1}^{n}\frac{k}{n(i-1)}=\frac{k}{n}\sum_{i=k}^{n-1}\frac{1}{i}$ ， $\int_{k}^{n}\frac{1}{x}dx \leq \sum_{k}^{n-1}\frac{1}{i} \leq \int_{k-1}^{n-1}\frac{1}{x}dx$ ，即 $\frac{k}{n}(lnn-lnk)\leq Pr(S)\leq \frac{k}{n}(ln(n-1)-ln(k-1))$ ，爲了使得到最好的人選的概率最大，就要使下界儘可能地大，則k=n/e。

隨機算法模型1

隨機算法可以看作是部分由隨機過程控制的算法。隨機算法允許在任何需要的時候拋出“公平”硬幣，並且使用拋硬幣的結果來決定算法將以何種方式繼續工作。隨機算法的質量通常以運行時間和可靠性(正確性)的程度來衡量。

該模型認爲隨機算法A是確定性策略算法的有限集合A1,A2,..,An的概率分佈(隨機選擇其中一個)。將A對輸入w爲概率空間 $(S_{A,W},Prob)$ ，其中 $S_{A,W}$ = {A1,A2，…，An}， Prob爲概率分佈。通常，Prob是一個均勻概率分佈。我們通常傾向於將 $S_{A,W}$ = {C1, C2，…，Cn}作爲A在w上的所有運行(計算)的集合，其中Ci是第i個確定性算法在w上的計算。

對於一個給定的輸入w，隨機算法A選擇第i個具有概率問題的確定性算法概率爲Prob({Ai})，初始i = 1，…n，其餘的計算都是完全確定的。

運行時間(Time)

令Time(Ci)表示計算Ci的長度(時間複雜度)。

A在w的期望時間複雜度: $Exp-Time_A(w)=\sum Prob(\{C_i\})\ast Time(C_i)$

隨機算法A的期望時間複雜度: $Exp-Time_A(n)=max\{Exp-Time_A(w)|the\ length\ of\ w\ is\ n\}$

隨機算法A的時間複雜度: $Time_A(n)=max\{Time(C)|C\ is\ run\ of\ A\ on\ an\ input\ of\ length\ n\}$

可靠性(Reliability)

定義指示變量X： $S_{A,W}\rightarrow \{0,1\}$ ，如果Ci在wi上計算得到正確的結果，那麼X(Ci)=1，否則X(Ci)=0，i=1,...,n。A對於輸入w的成功概率爲 $E[X]=\sum X(C_i)\ast Prob(\{C_i\})=Prob(Event(X=1))$ ，錯誤概率爲。A的錯誤概率爲 $Error_A(n)=max\{Error_A(w)|the\ length\ of\ w\ is\ n\}$

注意，我們對時間複雜度度量的定義假設A的所有運行都是有限的，即不允許A進行無限次計算。一般來說，隨機算法允許有無限的計算。在這種情況下，測量A的有限計算的期望時間複雜度，並計算運行無限計算的概率，然後將其添加到錯誤概率(即無限計算的發生被認爲是一個錯誤)。

隨機算法模型2(推廣)

將隨機算法表示爲非確定性算法，對於每個非確定性選擇都有一個概率分佈。

我們可以通過所謂的計算樹 $T_{A,w}$ 來描述隨機算法A在輸入w上的所有計算(運行)。樹的頂點由配置標記的每條路徑從根到葉在這棵樹對應的計算w。每條邊的樹是標記的值[0,1]決定從給定的配置選擇的概率。

第二個模型是對第一個模型的概括。它用於描述在計算的某些確定部分之後重複地做出隨機選擇的算法。

隨機快排(Randomized Quicksort)

算法 RQS(A):

        輸入:給定線性順序的一組元素。

       步驟1:如果A = {b}，則輸出“b”。如果|A|≥2，則隨機選擇一個元素a∈A。

       步驟2:設置 $A<:=\{b\in A|b<a\}$ , $A>:=\{c\in A|c>a\}$

       步驟3:輸出“RQS(A<),a, RQS(A>)”

沒有錯誤輸出的計算。RQS(A)在A上有指數級的許多不同的計算。一個輸入上的RQS的計算樹不僅非常大(特別是它的寬度)，而且它也是非常不規則的。選擇合適的隨機變量不僅決定了算法分析的成功與否，也決定了分析的難度。 $Exp-Time_{RQS}(n)=O(nlogn)$

證明：

X(C)表示比較數，設爲算法輸出，定義 $X_{ij}(C)=1,S_iS_j$ 比較過，否則=0。

$T=\sum_{i=1}^{n}\sum_{j>i}X_{ij}(C)$ 表示總的比較次數， $p_{ij}$ 是比較的概率， $E[T]=\sum_{i=1}^{n}\sum_{j>i}E(X_{ij})=p_{ij}$ ；

如果主元從 $S_1...S_{i-1}$ 或者 $S_{j+1}...S_n$ 中選取，則會被分到同一個子集，不會影響今後的比較，只要考慮在中選取主元。

$p_{ij}=\frac{|\{S_i,S_j\}|}{|\{S_i...S_j\}|}=\frac{2}{j-i+1}$ ， $E[T]=\sum_{i=1}^{n}\sum_{j>i}p_ij=\sum_{i=1}^{n}\sum_{j>i}\frac{2}{j-i+1}\leq \sum_{i=1}^{n}\sum_{k=1}^{n-i+1}\frac{2}{k}\leq 2\sum_{i=1}^{n}\sum_{k=1}^{n}\frac{1}{k}$ $=2n\sum_{k=1}^{n}\frac{1}{k}=O(nlogn)$ 。

隨機選擇(Random Select)

算法RSEL (A,k)

       輸入:A = {a1, a2， . .， an}， n∈IN−{0}，且滿足1≤k≤n的整數k。

       步驟1:如果n = 1，則輸出“a1”否則隨機一致地選擇i∈{1,2，…，n};

       步驟2:計算 $A<:=\{b\in A|b<a_i\}$ , $A>:=\{c\in A|c>a_i\}$

       步驟3:if | A< |>k，那麼RSEL(A<; k);

                 else if|A<| = k−1，則輸出“ai”;

                 else RSEL(A>， k−|A<|−1);

顯然，算法RSEL(A, k)會在每次運行時計算正確的輸出，並且 $Exp-Time_{RSEL}(A,k)=O(n)$ 。

隨機算法分類：

決策問題和計算函數的隨機算法的標準分類：拉斯維加斯算法，單邊誤差蒙特卡羅算法，有界誤差蒙特卡羅算法，無界誤差蒙特卡羅算法。這種分類是基於隨機算法的錯誤概率的種類和大小，與它們的設計方法無關。

拉斯維加斯算法(LAS VEGAS ALGORITHMS)

隨機算法A被稱爲拉斯維加斯算法，它計算一個函數F，對於任意輸入x (F的任意參數x)， Prob(A(x) = F(x)) = 1。(表示LV算法總是正確的，隨機選擇，隨機快排都屬於LV)(而蒙特卡洛算法是會會出錯的)

對於拉斯維加斯算法，我們總是研究期望的複雜度。RQS和RSEL，在這兩種算法中，我們在最壞情況複雜度和期望複雜度之間有本質的區別。但關鍵的一點是，預期的複雜性非常接近最有效運行的複雜性。

假設A是一個隨機算法，它允許答案是“?”A是函數F的拉斯維加斯算法，對於每個輸入x：

(i) Prob(A(x) = F(x)) ≥ 1/2, and

(ii) Prob(A(x) = “?”) = 1 − Prob(A(x) = F(x)) ≤ ½.

$\large Protocol\ LV_{10}$ ：

我們有兩臺電腦RI和RII。RI的輸入由10個字符串組成，x1, x2， . .， x10∈ $\{0,1\}^n$ , RII也有10個字符串，y1, y2， . .， y10∈ $\{0,1\}^n$ 。任務是估計是否存在j∈{1，…，10}，使得xj = yj。如果存在這樣的j，則協議必須接受輸入((x1， . .， x10)， (y1， . .， y10))，如果不存在，則必須拒絕輸入。

第一步：選擇10個小於的素數()；

第二步：xi與對應的素數pi計算餘數si，並把所有的素數p和餘數發送給RII；

第三步：RII收到後，yi與pi計算餘數qi，比較si和qi是否相等，如果不相等，那麼對於所有i，xi≠yi，並輸出“0”或者拒絕；如果相等，那麼將最小的i，記作j，即sj=yj，然後把yj和j返回給RI；

第四步：RI將xj和yj逐位的比較，如果相等則輸出“1”，否則輸出“？”。

通訊量達到n+40logn+4，這是LV算法。

證明：

1）對於所有的i，xi≠yi，對於pi，有xi mod pi ≠ yi mod pi，概率至少爲1-2lnn/n(在上面已經證明)，證明Prob(LV(xi,yi)=0)≥1/2；

$\geq (1-\frac{2lnn}{n})^{10}=\sum_{i=0}^{10}(-1)^i\binom{10}{i}(\frac{2lnn}{n})^i\geq 1-\binom{10}{1}\frac{2lnn}{n}\geq 1/2$ ，當n足夠大。

2）設xj=yj，j是最小的滿足等式的下標，必然有xj mod pj = yj mod pj，在第四步會比較xj和yj且接受，當可能j並不會被RII發送給RI，會發送的充要條件是：xi mod pi ≠ yi mod pi ，i=1,...,j-1，即不然正確的j'無法發送到RI。把以上的條件記爲Ej。

若j=1，不會出錯；

若j>1, $Prob(E_j)\geq (1-\frac{2lnn}{n})^{j-1}\geq 1-\frac{2(j-1)lnn}{n}$ ，當j=10時取最小值，Prob(LV(xi,yi)=1)≥1-18lnn/n≥1/2；若存在l<j，使xl mod pl =yl mod pl，則會輸出“？”。

如何轉換模型中的答案“?”使得模型中所有的輸出都必須是正確的結果：

如果 $T_{A,w}$ 是算法A在輸入w上的計算樹，那麼我們得到了計算樹 $T_{A',w}$ ，在掛起的樹 $T_{A,w}$ ，A '在w上的計算輸出“?”。這種轉換的缺點是新算法A '包含無限的計算。另一方面，可以保證，如果它停止，算法A '以正確的結果結束。 $Exp-Time_{A'}(n)=O(Time_A(n))$ 。

時間複雜性證明：

A：LV算法；A':可以得到明確結果的算法；

設當輸入w，輸出？，計算時間最長，令 $Set_i=\{c\in S_{A',w}|(i-1)Time_A(w)<Time(c)\leq i\cdot Time_A(w)\}$ ，恰好運行了i次算法A得到正確結果了， $S_{A',w}=\bigcup_{i=1}^{\infty }Set_i,Set_r\neq Set_s,r\neq s$ 。(得到正確結果可能一次，也可能兩次...)

運行算法A，i次之後仍未得到正確結果的概率 $\leq 1/2^i$ , $Prob(\{c\})_{c\in \bigcup_{i=1}^{k}set_i}\geq 1-1/2^k$ ；

$Exp-Time_{A'}(w)= \sum_{c\in S_{A',w}}Time_{A'}(c)Prob(c)$ (運行i次的時間以及運行i次出現的概率)

如何轉換總是提供正確的結果的拉斯維加斯算法到可能輸出" ?“的拉斯維加斯算法：

我們考慮一個計算樹 $T_{A,w}$ ，它包含許多短的(有效的)計算，但也有一些相對長的(可能是無限的)計算。當一個計算的運行時間超過了有效計算的時間(即當可能認爲正在運行的計算是一個非常長的計算)，他可以決定停止這個計算並輸出“?”。時間複雜度的約束是什麼停止計算?花費時間兩倍期望時間的，就足夠了停止工作。

單邊誤差蒙特卡洛算法(ONE-SIDED-ERROR MONTH CARLO ALGORITHMS)

A是一個隨機算法,讓(Σ，L)是一個決策問題。A是一個對於L的單邊誤差蒙特卡羅算法，簡稱1MC算法。如果

(i)對於每個x∈L, Prob(A(x) = 1)≥1/2，且

(ii) 對於每個 $x\notin L$ , Prob(A(x) = 0 ) = 1.

1MC算法就是1MC∗算法，當

(i ')對於每一個x∈L, Prob(A(x) = 1)隨着|x|的增長而趨於1。

算法輸出1，肯定是正確的；輸出0，可能是正確的。

錯誤概率隨計算重複次數的增加呈指數遞減(在同一輸入上獨立運行)。在相同的輸入條件下，執行1MC算法A的k次重複工作

(i)複雜度只增加k倍(即以線性方式)，

(ii)誤差概率以指數速度k趨近於0。(運行k次，只要有1次爲1，就輸出1，此時一定是對的如果所有的k爲0，則輸出0，輸出0錯誤的概率)

用Ak表示1MC算法，該算法在任何輸入上由k個獨立運行的1MC算法a組成，並且當且僅當至少有一個運行接受該輸入。

有界誤差蒙特卡洛算法(BOUNDED-ERROR MONTH CARLO ALGORITHMS)

設F是一個函數。一個隨機算法A是F的一個有界蒙特卡羅算法, 簡稱2MC算法,當如果存在一個實數ε,0<ε≤1/2,對於每一個F的輸入x，Prob(A(x) = F (x))≥1/2 +ε。(區別於1MC的判定問題，1MC重複運行就是2MC)。

對於任意2MC算法A和任意正整數t，考慮以下隨機算法2MC算法

輸入:x

步驟1:獨立運行t次算法A，保存t次的計算結果 $\alpha _1,\alpha _2,...,\alpha _t$ ；

步驟2: 如果有α出現至少 $\left \lceil t/2 \right \rceil$ 次，在序列α1, α2, ...,αt中 , 然後輸出 “α” ，否則輸出“?” 。

在計算一個錯誤的結果或" ?” 意味着正確的結果沒有出現至少 $\left \lceil t/2 \right \rceil$ 次。

$Time_{A_k}(n)=O(Time_A(n))$ ，運行k次的時間複雜性和運行1次的時間複雜性是同階的，k與輸入規模無關

這個觀察的結果是,如果一個漸近速度比任何確定性算法快計算F,然後用一個錯誤概率低於Ak選擇δ也比任何確定性算法更加有效。

無界誤差蒙特卡洛算法(UNBOUNDED-ERROR MONTH CARLO ALGORITHMS)

設F是一個函數，如果對於F的每個輸入x, Prob(A (x) = F(x))>1/2，我們說一個隨機算法A是一個計算F的無邊界誤差蒙特卡羅算法，簡稱MC算法。

有界誤差蒙特卡羅算法和無界誤差蒙特卡羅算法的區別是什麼?

爲了得到Prob(Ak(x) = F(x)) $>1-\delta$ ， $\delta$ 是一個固定的常數，需要多少次A對x的獨立運行？

$Time_{A_k}(x)\geq (-ln\delta )/2\cdot 2^{2\cdot |x|}\cdot Time_A(x),(\varepsilon _x=1/2^{|x|})$ (正確率與輸入規模有關)

因此，Ak的運行時間是輸入長度|x|的指數，即使在A非常快的情況下。

Protocol UMC

考慮以下隨機的兩臺計算機之間的通信協議RI和RII，認識語言 $L_{unequal}={(x,y)|x,y\in \{0,1\}^n,x\neq y,n\in IN}$

初始情況:RI有n比特，x = x1x2…xn, RII有n個比特，y = y1y2...yn, n∈IN−{0}。

輸入 (x, y) 必須接受，當且僅當 x $\neq$ y。

階段1:RI隨機地選擇一個數字j∈{1,2，…，n}，並將j和xj發送給RII。

階段2:RII比較xj和yj。如果 xj $\neq$ yj , RII接受輸入(x, y). {RII確信 x $\neq$ y, 即(x, y)∈Lunequal}

如果xj = yj，則RII以1/2-1/(2n)的概率接受(x, y)，以1/2 + 1/(2n)的概率拒絕(x, y)。

在每個計算UMC的通信複雜性是 $\left \lceil log_2(n+1) \right \rceil+1$ 位。

UMC是一種蒙特卡羅協議。

優化問題的隨機算法分類

優化問題是一個6元組 $U=(\Sigma _I,\Sigma _O,L,M,cost,goal)$ ,

$\Sigma _I$ 是輸入字母表

$\Sigma _O$ 爲輸出字母

L⊆ $\Sigma *_I$ 是可行的語言輸入(輸入一個只允許有一個合理的解釋的)。x∈L稱爲U的問題實例。

M是一個函數映射L到 $P(\Sigma _o*)$ ,對於每個x∈L, M (x)是集合x可行的解決方案。

cost是代價函數 : $\cup _{x\in L}(M(x)\times \{x\})\rightarrow IR^+$ ，映射值都是大於0的

goal∈{minimum, maximum}爲目標。

一個可行解α∈M (x)被稱爲最優問題實例的x，如果 $cost(\alpha ,x)=Opt(x)=goal\{cost(\beta ,x)|\beta \in M(x)\}$ 。

算法A對於任意x∈L，

(1) A(x)∈M(x) (A(x)是問題實例U(x)的可行解)

(2)cost(A(x), (x)) =goal{cost(β,x) |β∈M (x)}。

$U=(\Sigma _I,\Sigma _O,L,M,cost,goal)$ 是一個優化問題。

A是U的一致算法，如果對於每一個x∈L, A對x的計算的輸出A(x)是x(即A(x)∈M(x))的可行解。

設A是U的一致算法，對於每一個x∈L，我們定義A對x的近似比爲 $Ratio_A(x)=max\{cost(A(x))/Opt_U(x),Opt_U(x)/cost(A(x))\}$ ,
其中爲U的實例x的最優解的代價。

對於任何一個正實數 $\delta > 1$ ，我們說A是U的 $\delta$ 近似算法，如果 $Ratio_A(x)\leq \delta$ ，x∈L。

Algorithm VCA（最小頂點覆蓋問題）
Input: A graph G = (V,E).
Phase 1. C := ∅; A := ∅; E’ := E;
Phase 2. while E’ ≠ ∅ do
take an arbitrary edge {u, v} from E’;
C := C ∪ {u, v}; A := A ∪ {{u, v}};
E ‘:= E’ − {all edges incident to u or v};
Output: C

Time_VCA(G) = O(|E|)
Ratio_VCA(G) ≤ 2（近似解不會超過最優解的2倍）
A是極大匹配

隨機算法設計的範例

挫敗敵人(Foiling the Adversary)

挫敗對手常用於解決某些問題

(i)每個確定性算法(策略)都有一些最壞的情況，在這種情況下算法不能有效地計算出正確的輸出，

(ii)但存在一類確定性算法，對於每一個問題實例，這類算法中的大多數算法都能有效地計算出正確的結果。

這種方法也稱爲避免最壞情況輸入的方法。

應用挫敗對手的方法的藝術在於找到一組合適的確定性算法(策略)，這樣，對於任何問題實例，大多數算法都能有效地計算出正確的結果。

Hashing

哈希是一種動態數據管理方法。所考慮的數據記錄具有唯一的名稱，並且可以使用這些名稱來請求它們。數據記錄的唯一名稱稱爲鍵(該數據記錄的鍵)，整個數據管理由鍵決定，動態數據管理包括執行以下三個字典操作序列:

Search (T, k): Search for the key (data record) k in the data structure T .

Insert (T, k): Insert the new key (data record) k in the data structure T .

Delete (T, k): Delete the key (data record) k in the data structure T .

動態數據結構,AVL樹和B樹,使我們能夠執行任何這些三種業務Θ(log n)),這是在最壞的情況下以及在平均情況下。哈希的第一個目標是將期望複雜度降低到O(1)。

我們假設我們有內存T，可以直接訪問T的每個內存單元，這些內存單元稱爲槽(slots)，而T稱爲哈希表或直接地址表。大小|T|是T的槽數，我們設置T ={0,1,2，…，m−1}，我們有一個大的集合U，叫做全集(universe)，包含所有可能的鍵。

通常情況下，|U|>>|T |，因此不可能將整個全集U嵌入T中，但這並不壞，因爲U並不對應於任何實際的數據記錄(鍵)，它只是應用程序中可能出現的所有鍵的集合。因此，與其嘗試管理U，我們的目標是在T中保存一個鍵的實際集合S(數據記錄)。集合S由一個經過考慮的應用程序給出，其大小通常可與|T | = m相比較。

我們的任務是保存一組S⊆U的鍵在T(數據記錄)。重點是我們不能影響S的選擇，我們沒有任何關於S的初步信息，通常，S大約和T一樣大，我們確定|S| = n。

任務是確定一個映射h: U→T = {0,1,…, m−1}這樣一組S⊆U是均勻“分散”到T。從U到T的函數h稱爲哈希函數。

我們必須在不知道S的情況下選擇h，並且在數據管理的過程中，應用Insert (T, k)和Delete (T, k)操作，集合S可能會發生很大的變化。

我們對h提出以下要求:

(i) h可以有效地計算；

(ii)h S⊆U大多數數據集映射到T以這樣一種方式,對於i∈{0,1,…,m−1},集合 $T(i)=\{a\in S|h(a)=i\}$ 的規模爲。

爲了滿足至少(ii)，我們至少要有一個哈希函數h它均勻地將U的所有鍵分佈在T中。這種哈希函數的一個例子是 $h_m(x)= x\ mod\ m$ 定義的函數。

令U = IN爲全集，令T ={0,1，…，m−1}，m∈IN−{0,1}。設n爲正整數，h: U→T爲滿足Prob(h(x) = i) =1/m的哈希函數。對於T的每一個槽l，

(i)隨機 $S\in P_n(U),P_n(U)=\{S\subseteq U||S|=n\}$ 分配給槽l的元素個數(即 S中h(x) = l的元素x個數)小於n/m+ 1；

(ii)如果n = m，則Prob(來自隨機S∈Pn(U)的多個鍵在第l個槽中)<1/2。

這確保了執行任何字典操作的預期複雜度是O(n/m)，對於n=O(m)，則是O(1)。這是成立的，因爲分配給T的任意槽的鍵的期望數目小於n/m + 1。這裏期望被認爲是所有可能集合S的平均值。

(i)對每一個哈希函數h,存在“壞”集合S(例如,一個集合 $S\subseteq U_{h,i}=\{a\in U|h(a)=i\}$ )；

(ii)每一個滿足Prob(h(x) = i) =1/m的哈希函數在T中成功地分佈了一個隨機集合S(以及全集U的大多數子集)的鍵。

對於h(即每一個確定性哈希)的每一個選擇，(i)表示對手可以構造任意壞的輸入S，另一方面(ii)表示有許多哈希函數可以確保大多數輸入S的最佳可能分佈。

根據挫敗對手的思想，必須從一組哈希函數中隨機選擇一個哈希函數，使每個輸入集S都均勻分佈在T中，具有很高的概率。

我們需要一個哈希函數的集合H從中可以均勻地隨機選擇h。這意味着我們的概率空間是(H, )， H的創建方式應該是(H, ProbH)對所有可能的S都是有效的。

定義:設H爲從U到T ={0,1，…，m−1}的有限哈希函數集。集合H稱爲universal，如果U中的每一對元素 x, y , x ≠ y, |{h ∈ H | h(x) = h(y)}| ≤ |H|/m holds, 即， H中的m個哈希函數至多映射x和y到T的同一個槽。

我們立即觀察到，在概率空間(h, )中，每個全域哈希函數集都滿足條件ProbH(h(x) = h(y))≤1/m。

定理:設S⊆U是一個任意的鍵集,|S| = n。H是一個通用類的哈希函數從U到T = {0,1,…, m−1}。每個x ∈ S和隨機選擇h ∈ H，集合 $S_x(h)=\{a\in S|a\neq x,h(a)=h(x)\}$ 的預期規模最多 |S|/|T| = n/m。

定理的結論是，T的任意槽的期望鍵數小於1 + n/m。因此，假設存在通用哈希函數集，則通用哈希函數集的概念是解決動態數據管理問題的工具。

引理:令U爲一個有限集。從U到T的所有函數的類 $H_{U,T}=\{h|h:U\rightarrow T\}$ 是通用的。

我們不能在實際應用中使用 $H_{U,T}$ ，至少有兩個原因。

(1) $H_{U,T}$ 太大，無法有效地從 $H_{U,T}$ 中隨機選擇h。

(2) $H_{U,T}$ 的大多數函數可以被看作是隨機映射，因爲它們沒有比完整表表示更短的描述。這樣的函數不能有效地計算。

我們希望有一個這樣的哈希函數的泛型H

(i) H很小(至多是|U|的多項式)，且

(ii) H的每個哈希函數都可以非常有效地計算。

對於素數p，U={0,1,2,...,p-1}，對於任意自然數a,b∈U，我們定義對於每個x∈U，線性哈希函數 $h_{a,b}$ : U→T by $h_{a,b}(x)$ = ((ax + b) mod p) mod m。

設 $H^p_{lin}=\{h_{a,b}|a\in \{1,2,...,p-1\},b\in \{1,2,...,p-1\}\}$ ，b∈{0,1，. .，p−1}}是一組哈希函數。

定理:對於任意素數p, $H^p_{lin}$ 類是哈希函數的一個普遍類，從U ={0，…，p−1}到T ={0, 1，…，m−1}。

指紋識別(Fingerprinting)

基本思想：它是求解等價問題的一種方法。其基本思想是通過這些表示的指紋來比較某些對象的兩個(完整)表示。創建指紋的方法是從有限的可能性集合中隨機選擇的。這背後的主要思想是，對於任何兩個不同的對象，大多數創建指紋的方法都保存了兩個對象之間的差異。因此，總的來說，我們對指紋提出了以下兩個要求。

(i)指紋必須簡單和簡短，以確保能夠有效地比較它們。爲了實現這一點，指紋不僅可以是給定對象的壓縮表示，還可以是它們的不完整表示。

(ii)儘管物體的大小有限制，但它的指紋必須包含儘可能多的有關該物體的基本信息。

目的是找一個M，這樣對任何兩個不同的對象O1和O2有足夠多的映射f ∈ M且 $f(O_1)\neq f(O_2)$ 。

集合M可以被視爲證明O1 ≠ O2的候選集合，和映射h ∈ M是 (O1) ≠ (O2) 的證明，如果 h(O1) ≠ h(O2).

因此，指紋應用的關鍵在於在指紋比對的效率(指紋的大小)和M中證人的數量之間尋找一個合理的折衷。

通信協議：假設RI字符串 $x\in \{0,1\}^n$ , RII有一字符串 $u_i\in \{0,1\}^n,i=1,...,k$ 的集合 $U=\{u_1,u_2,...,u_k\}$ 。RII不知道任何的字符串x,和RI沒有U的任何知識，計算機必須找出是否有x∈U。

問題是，對於U的規模，這種方法仍然提供有效的通信協議。

階段1:RI一致地隨機選擇素數p∈PRIM(n²)。

階段2:RI計算數字s = number (x) mod p並將s和p發送給RII。

階段3:接收到s和p後，計算機RII計算出qi = Number(ui) mod p (i = 1，…，k)

如果s∈{q1, q2，…，qk}，則RII輸出“s∈U”。

如果s $\notin$ {q1, q2, 。 ., qk}, 然後 RII 輸出 “s $\notin$ U”.

協議PSet的通信複雜度爲4·logn

$Error_{PSet}(x,U)\leq 1/2,k\leq n/(4lnn)$

因此，PSet是一個單邊誤差蒙特卡羅協議，用於確定k≤n/(4·ln n)時x與U的隸屬度。

Disjointness problem

協議PDisj

初始情況:計算機RI有一集合V = {v1,v2,...,vl}⊆ $\{0,1\}^n$ 和計算機RII有一組U = {u1,u2,...uk}⊆ $\{0,1\}^n$ ，正整數l和k。電腦都不知道其他的數據。電腦RI和RII必須決定是否 V ∩ U = ∅ 或 V ∩ U ≠ ∅。

階段1:RI隨機選擇一個素數p∈PRIM()。

階段2:RI計算數字si = Number(vi) mod p ，i=1, 2，…，l，並將p, s1, s2，…，sl發送給RII。

階段3:接收到p, s1, s2，…，sl後，計算機RII計算出qm = Number(um) mod p，m = 1,2，…，k。

如果{s1, s2,. ., sl} ∩ {q1, q2,. ., qk} ≠ ∅，RII 輸出 “U ∩ V ≠ ∅”。

如果{s1, s2,…, sl}∩{q1,q2,..., qk} =∅，RII輸出“U∩V =∅”。

PDisj是1MC∗協議，對於兩集合U, V⊆ $\{0,1\}^n$ 的disjointness problem，|U| · |V | = o(n/ ln n)，錯誤率趨於0 。

Protocol d-R for Equality Problem

初始情況:計算機RI有一個x∈ $\{0,1\}^n$ ，計算機RII有一個y∈ $\{0,1\}^n$ 。

階段1:RI從集合PRIM()= {p | p≤是一個素數}中均勻地隨機選擇一個素數p。

階段2:RI計算數字s = number (x) mod p並將s和p發送給RII。

階段3:接收到s和p後，RII計算q = number (y) mod p。

如果q≠s，然後RII輸出 “x ≠ y”。

如果q = s，則RII輸出“x = y”。

通信複雜度 $2\left \lceil logn^d \right \rceil$ ，只在d中線性增長，而錯誤概率隨d的指數增長趨近於0。當x=y時，不會出錯；當x≠y時，Err=|壞素數|/|素數全體|≤n-1/prim()=dlnn/ $n^{d-1}$ 。

字串判別問題(The Substring Problem)

給定一個文本x = x1x2…xn和文本y = y1y2 ...ym作爲字符串在一個字母Σ= {0,1},n≤m,任務是決定是否x是y的子字符串

步驟1:從PRIM(f(n, m))中隨機均勻地選擇一個素數p。

步驟2:計算 $Finger_p(x):=Number(x)\ mod\ p$ 。

步驟3:依次計算， $Finger_p(y(r,n)):=Number(y,(r,n))\ mod\ p$ 對所有r∈{1,2，. .，m−n + 1}（從r開始，長度爲n的字符串），並檢查是否。對於j∈{1,2，…，m−n+1}，使得，比較y(j, n)和x。如果y(j, n) = x，則停止並輸出“j”。否則繼續計算。若y(r, n) = x無r，則輸出“∅”。

顯然，這個算法是拉斯維加斯算法，因爲它總是計算正確的輸出。

選擇，得到Exp-time = O(m)。 $\because Num(y(r+1,n))=2[Num(y(r,n))-2^{n-1}y_r]$ ，那麼指紋之間也存在關係 $F_p(y(r+1,n))=[2[F(y(r,n))-2^{n-1}y_r\%p]+y_{r+n}]\%p$ ，計算時間爲O(1)，所以所有指紋的計算爲O(m)，而不是O(nm)。

矩陣乘法驗證(Verification of Matrix Multiplication)

給定三個(n×n)矩陣A、B和C，決定A·B是否等於C

步驟1:隨機選擇統一一個向量α∈ $\{0,1\}^n$ 。

步驟2:計算向量β:= A·(B·α)和γ:= C·α

步驟3:如果β=γ，然後輸出“A·B = C”,

如果 β ≠ γ 然後輸出 “A · B ≠ C”。

算法的複雜度爲O()。

引理: A,B, 和 C 是(n × n)矩陣,，使得A · B ≠ C，那麼至少 $2^{n-1}$ 個α用於識別出 “A · B ≠ C” ,此時的A·(B·α)≠C·α。

引理確保至少一半的向量α 可以識別A· B 和 C。因此, 錯誤概率在任何輸入 (A,B,C) A·B ≠ C 最多是1/2。因此，它是一個1MC的矩陣乘法驗證算法。

成功放大(Success Amplification)

基本思想：放大是一種減小誤差的方法。簡單的方法是在相同的輸入上重複整個計算，但是我們只能重複一些計算部分，或者以不同的方式多次重複不同的部分。這樣做的目的是要更多地關注那些出錯概率比其他部分大的計算部分。

MIN-CUT(參考)

輸入:多重統計 G = (V, E, c)，其中c: E→IN−{0}決定了G的邊的多樣性。

約束條件:G的所有可行解的集合爲G的所有cut的集合M(G) = {(V1, V2) | V1∪V2 = V, V1∩V2 =∅}。

代價: 對於每cut(V1, V2)∈M(G), cost((V1, V2),G) =∑c(e)， e∈S(V1,V2) 和 S(V1, V2) = {{x, y} ∈ E | x ∈ V1 和 y ∈ V2}。cost((V1, V2)，G)等於V1和V2之間的邊數

目標:最小

著名的MIN-CUT確定性算法的運行時間O(|V|·|E|·log(/|E|)

壓縮操作Contract(G, e)

對於給定的多圖G = (V,E)和一條邊e = {x, y}∈E，對邊E進行收縮意味着:頂點x和y被一個新的頂點(x, y)替換，多邊e = {x, y}以這種方式刪除(收縮)(我們不允許任何自己到自己的邊)，每條邊{r, s} r∈{x, y} 和 s $\notin$ {x, y}被一個新的邊{ver(x, y) , s}取代, G 剩餘的部分保持不變。

將Contract(G, e)可視化，只需將頂點x和y摺疊成一個新的頂點。我們用G/{e}表示結果圖。

給定一組邊F⊆E,收縮的影響並不依賴於收縮的順序。

一個將隨機選擇的邊收縮，直到得到一個恰好有兩個頂點V1和V2的多重圖。顯然V1∪V2 = V, V1∩V2 =∅。因此，(V1, V2)是G的一個切割點，兩個頂點V1和V2之間的邊數對應於切割點(V1, V2)的代價。我們可以將邊{x, y}的收縮看作是說頂點x和y必須位於靠近的切邊的同一側，從而將所有切邊的集合限制爲一側有x和y的切邊。這樣，可能的割集單調地減少，直到它只包含一個cut。

壓縮算法：

輸入:一個連通多重圖G = (V, E, c)

步驟1:對每個頂點v∈V，設置label (v):= {v}。

步驟2:當G有兩個以上的頂點時，選擇一條邊e = {x, y}∈E (G);G:=Contract(G, e);

對於新的頂點z = ver(x, y)，label(z):= label (x)∪label (y);

步驟3:如果G = ({u, v}，則輸出“(label (u)， label (v))”和“cost = |E(G)|”

定理:算法壓縮是一個隨機多項式時間算法，計算n個頂點的多重圖G的最小cut，概率至少爲2/(n(n−1))

運行次計算該算法的最小cut的概率至少爲1−1/e。但是算法 $CONTRACTION_{n^2/2}$ 的複雜度是O()。

過於複雜的原因是放大法的簡單應用，即通過重複整個算法的運行來增加成功的概率。

改進方案Algorithm DETRAN(l)：

輸入:n條邊的多圖G = (V, E, c)， n∈IN, n≥3。

步驟1:對G執行算法收縮，以得到l(n)個頂點的多圖G/F(不是2個頂點結束)。

步驟2:對G/F應用著名的確定性算法，計算G/F的最優割D。

輸出:D(第一步隨機，第二步隨機)

引理:令l: IN→IN爲1≤l(n) <n的單調遞增函數;DETRAN(l)算法在時間內運行，它至少找到一個最優解的概率 $\binom{l(n)}{2}/\binom{n}{2}$ 。

定理: 對算法 $DETRAN_{(n^\left \lfloor 2/3 \right \rfloor)}$ 獨立重複運行 $n^2/(n^{\left \lfloor 2/3 \right \rfloor})^2$ 的運行時間爲 $O(n^{8/3})$ ，得到最優解的概率至少 $1-e^{-1}$ 。

Algorithm REPTREE(G)

輸入:多圖G = (V, E, c)， |V | = n, n∈IN, n≥3。

過程:

if n≤6，則確定地計算最小cut

else

$h:=\left \lceil 1+n/\sqrt{2} \right \rceil$ ;

進行兩次獨立的收縮，得到兩個大小爲h的多圖G/F1和G/F2;

REPTREE (G / F1);

REPTREE (G / F2)

輸出REPTREE(G/F1)和REPTREE(G/F2)計算的兩個切點中較小的一個。

定理:算法REPTREE工作時間和找到最小cut的概率至少 $1/\Omega (logn)$

重複次數足以將失敗概率降低到隨着n的增加而趨於0的函數，總複雜度爲。

前面不容易出錯的少重複幾次，後面容易出錯的多重複幾次。

豐富的目擊者(Abundance of Witnesses)

目擊者輸入x是額外的信息，有了它的知識，計算x的輸出比沒有這個信息時要有效得多。我們需要應用大量證人的範例，對於每一個問題實例，一組證人的候選人，其中有大量的證人。這通常意味着候選人集合的基數與集合中的證人數之間的比值是一個常數。然後，只需從候選集合中隨機選擇一個元素，並以合理的概率獲得一個見證就足夠了。用這種方法，一個人可以有效地解決問題，即使他或她沒有成功地發現所考慮的問題的本質。

尋找目擊者素性測試

對於給定的正整數n，判斷n是否是合數或素數。

由於n的輸入長度是其二進制表示的長度log(n + 1)，我們的目標是設計一個運行在時間爲的算法(c爲一個小常數)。

Simple method - NAIV(相當於蠻力搜索)

輸入:一個數字n∈IN−{0,1,2}。

I:= 2

PRIM:= TRUE

while $I<\sqrt{n}$ 和PRIM= TRUE do

if n mod I=0，那麼PRIM:= FALSE;

I:= I + 1

if PRIM= TRUE，那麼輸出n是素數，否則輸出" n是合數"

我們正在尋找一種證人，它能有效地證明“n是合數”這一論斷。

證人的適當定義的規定:

(i)“n是合數”這一事實的證人必須提供有效證明這一事實的可能性。

(ii)無論是否是證人，每一個證人候選人都必須能有效地加以覈對。

(iii)候選人名單的規定必須使候選人名單中有大量的證人(越多越好)。

設素數m表示所有素數的集合。最簡單的想法就是: “number a ∈ {2,...,n − 1 } 是 “n $\notin$ PRIM”的目擊者，當且僅當a整除n。
Algorithm  EXP
Input: A real number x and a nonnegative integer n
Output: x^n
    1. y ← 1
    2. Let n be dkdk-1...d0 in binary notation
    3. for j ← k down to 0
    4.     y ← y^2
    5.     if dj=1 then y ← xy
    6. end for
    7. return y
歸納法；時間複雜度爲O((logn)^3)
Algorithm  EXPMOD
Input: positive integers a, m and n with m≤n
Output: a^m(mod n)
    1. let the binary digits of m be bk,bk-1,...,b0
    2. c ← 1
    3. for j ← k downto 0
    4.     c ← c^2 (mod n)
    5.     if bj=1 then c ← ac (mod n)
    6. end for
    7. return c

費馬小定理：如果n是質數，那麼對於所有的a!=0 (mod n)有 $a^{n-1}\equiv 1$ (mod n)

a是“n是合數”的證據 $\Leftrightarrow\ a^{n-1}\%n\neq 1$ 。但 $a^{n-1}\%n\equiv 1$ ，不能推出n是素數。(僞素數)

Algorithm  PTEST1
Input: A positive odd integer n5
Output: prime if n is prime; otherwise composite
    #等於1推出的素數可能是準確的
    1. if EXPMOD(2,n-1,n)恆等於1 (mod n) then return prime    {probably}
    #不等於1推出合數的結果一定是正確的
    2. else return composite      {definitely}

Algorithm 14.8 PTEST2
Input: A positive odd integer n≥5
Output: prime if n is prime; otherwise composite
    1. a←random(2,n-2)
    2. if EXPMOD(a,n-1,n)恆等於1 (mod n) then return prime    {probably}
    3. else return composite      {definitely}

Carmichael數：對於所有相對於n互素的正整數a都滿足上面的定理，但n是合數，最小的Carmichael數是561。

WITNESS(a,n)#判斷a是否可以作爲證明n是素數的證據
1. let n-1=2^t*u, where t≥1 and u is odd
2. x0←EXPMOD(a,u,n)
3. for i←1 to t
4.     xi←xi-1^2 mod n
5.     if xi=1 and xi-1≠1 and xi-1≠n-1 then return TRUE
6. end for
7. if xt≠1 then return TRUE
8. return FALSE

定理:如果n是奇合數，則證明n是合數的witness至少爲(n-1)/2。

Miller-Rabin Algorithm
Input: A positive odd integer n≥5
Output: prime if n is prime; otherwise composite
    1. for j←1 to s
    2.     a←random(2,n-1)
    3.     if WITNESS(a,n) then return composite      {definitely}
    4. end for
    5. return prime      {probably}

定理:對於任意奇數n>2和正整數s, Miller-Rabin犯錯的概率最多爲 $2^{-s}$ 。

所有有效的隨機算法素性測試的方法是基於大量的證人,所以很長一段時間懸而未決的領域是各種各樣的證人,證人的確是隨機分佈在候選集還是隻是找不到一個現有秩序的分佈。

2002年發現了證人的定義，其性質是:如果p是複合的，那麼在最小的候選點中必須總有一個證人證明p是複合的。這一發現導致了在時間 $O(log^{11}n)$ 運行的確定的質數測試算法。儘管這一結果具有巨大的理論重要性，但這種確定性算法在當前應用中無法與快速隨機算法競爭。

【算法學習筆記十三】隨機算法

測試串的相等性

指示隨機變量(Indicator random variables,IRV)

隨機算法模型1

隨機算法模型2(推廣)

隨機算法分類：

優化問題的隨機算法分類

隨機算法設計的範例

【算法學習筆記十四】近似算法

【算法學習筆記十一】計算複雜性

【算法學習筆記十二】回溯法(一)

【算法學習筆記十二】回溯法(二)

【算法學習筆記十三】隨機算法

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結