一、倍增演算法：

 

定義：用f[i][j]表示從i位置出發的2^j個位置的資訊綜合（狀態）

一個小小的問題：為什麼是2^j而不是3^j,5^j,…？因為，假設為k^j，整個演算法的時間複雜度為(k-1)logk，當k=2時，時間複雜度最小。

這個演算法的三個應用：

 

1.倍增ST表：

 

應用：這個ST表是用來解決RMQ問題（給你n個數，m次詢問，每次詢問[l,r]這個區間的最大值），當然，解決RMQ問題是可以用線段樹來做的，但是比較麻煩，NOIP 80%是不會用線段樹來做，還是用ST表方便。

定義：f[i][j]表示：從

i到i+2^j-1這2^j個位置的元素最大值

初始化：f[i][0]=z[i]（第i個位置到第i+2⁰-1個位置的最大值，對應只有一個元素的區間）

轉移：f[i][j]=max(f[i][j-1],f[i+2^(j-1)][j-1])（把[i,i+2^j-1]這個區間分治為兩個區間，這兩個區間拼在一起就成了原來一個大的區間，兩個區間長度都為2^j-1）

 

//建立ST表，引自P2O5dalao的blog：https://zybuluo.com/P2Oileen/note/816892#應用1-st表

for(inta=1;a<=n;a++) f[a][0]=z[a];//z[]為源資料區間陣列

for(intj=1;j<=logn;j++)

{

    for(int i=1;i+z^j-1<=n;i++)

       f[i][j]=max(f[i][j-1],f[i+2^(j-1)][j-1]);

        //乘方是虛擬碼！

}

//solve

ans=max(f[l][k],f[r-2^k+1][k]);

 

所以就有兩種情況：

①假如區間長度(r-l+1)正好是2^k，那麼就直接訪問f[l][k]；

②假如區間長度(r-l+1)是2^k+p(p<2^k)，也就說明2^k≤(r-l+1)<2^k+1，我們可以慢慢地分治下去，利用字首和，就形成了樹狀陣列那樣的東西，一段區間的最大值為劃分成兩段區間最大值max1,max2相比取較大，但是這樣太慢。

有一種更好的方法：其實我們可以用兩個長度為2k的區間就一定能把這段[l,r]區間完美覆蓋起來，會有重複，但是對求最大值這件事情沒有影響，所以這段區間的最大值=max(f[l][k],f[r-2^k+1][k])。

限制：不能用來計算區間和，因為中間有重複部分，還有就是：不支援修改ST表！

 

2.樹上倍增LCA（最近公共祖先）：

 

一般是用線性Tarjan演算法來求解（這個Tarjan演算法和圖論中求有向圖強連通分量的Tarjan不同，都是一個人發明的），但是很難用到這個演算法，原因有倆：①沒遇到這樣的題目②不會！（笑哭臉），有興趣可以瞭解一下。

下面介紹倍增的演算法：

定義：f[i][j]表示：從樹上編號為i的節點向上走2^j步會走到哪個節點。

初始化：從j=0開始考慮，也就是從i號節點向上走1步到達的節點，就是i節點的父親，所以：f[i][0]=father[i]。

轉移：f[i][j]=f[f[i][j-1]][j-1]，表示：從i節點往上走2^j-1步後，再往上走2^j-1步到達的點，等價於向上走2^j步，因為2^j-1+2^j-1=2^j。（j的範圍大概[20,30)≈nlogn，只要保證2^j>節點數目n即可）

 

現在我們構造出來這個f陣列，下面介紹如何求兩個點的LCA：

定義陣列depth[i]表示i這個節點的深度，有以下兩種情況：

①depth[p1]==depth[p2]，具有一個重要的性質：兩個節點同時向上走同樣地步數，深度仍然相等，也就是說，我們讓p1,p2一步一步地往上走，當走到同一個點時候，這個點一定是LCA！

 

for(intx=19;x>=0;x--)

{

    if(f[p1][x]!=f[p2][x])//如果沒有走到同一個點，繼續往上走

    {

        p1=f[p1][x];//p1往上跳

        p2=f[p2][x];//p2往上跳

    }    

}   

if(p1!=p2)//為什麼要加這個判斷？有可能p1=p2麼？是有可能的！這個判斷是防止一開始跳之前p1=p2這種情況

{

    p1=f[p1][0];//因為上面的迴圈p1，p2只是走到了LCA的下方，這個判斷只是處理最後一步：把p1或p2往上跳到它的父親，就是LCA，返回即可

}

return p1;//p1為LCA，返回

 

②depth[p1]!=depth[p2]，假如p1比較深，就讓p1往上跳到和p2深度一樣的地方。

利用倍增f陣列p1往上跳的方法：定義往上走步數step=depth[p1]-depth[p2]，再利用二進位制轉換！

舉個栗子：假如step=13，轉為二進位制=1101，可以得出13=8+4+1,：先走8步，再走4步，再走1步就好了。

 

int get_lca(int p1,intp2)

{

    if(dpeth[p1]<depth[p2]) swap(p1,p2);

    for(int x=19;x>=0;x--)

    {

    if((2^x)<=depth[p1]-depth[p2])p1=f[p1][x];

    }

}

下面是另一種寫法思路就不多講，YY一下就可以出來的啦~

 

int x=0;

while (p1!=p2)

{

    if(!x||f[p1][x]!=f[p2][x])

    {

        p1=f[p1][x];

        p2=f[p2][x];

        x++;       

    }

    else x--;

}

 

3.快速冪：

 

按照一般思路，我們要計算a^x的話，要寫一個for迴圈，計算a×a×a×a…這樣太™麻煩並且浪費時間！

這裡運用倍增來實現快速冪，這也是運用到了分治的思想。

我們要求出x(x=2×k)個a的乘積，就可以分解為x/2個a的乘積的平方，這樣就省去一半計算量，如果x是奇數，就在原先的基礎上×a就可以了。

 

int pow(int a,int x)//求a^x的快速冪時間複雜度：O(logx)

{

    int ans=1;

    while(x)

    {

        if(x&1) ans=(ans*a);//位運算：x&1==1則x為奇數

        a=a*a;

        x=x>>1;//位運算：右移一位，即將X除以2

    }

    return ans;

}

二、分治演算法：

 

定義：將一個規模為N的問題分解為K個規模較小的子問題，這些子問題相互獨立且與原問題性質相同。求出子問題的解，就可得到原問題的解。

這個演算法的三個應用：

 

1.二分查詢：

 

定義：給定排序陣列，查詢某個數是否在陣列中 

演算法描述：在查詢所要查詢的元素時，首先與序列中間的元素進行比較，如果大於這個元素，就在當前序列的後半部分繼續查詢，如果小於這個元素，就在當前序列的前半部分繼續查詢，直到找到相同的元素，或者所查詢的序列範圍為空為止。

 

bool find(int x)//二分查詢x是否在序列z[]中

{

    left=0,right=n;

    while(left+1!=right)

    {

        middle=(left+right)>>1;

        if(z[middle]>=x) right=middle;

        else left=middle;

    }

}

還可以用lower_bound和upper_bound函式進行優化，用法詳見下：

 

#include<iostream>

#include<algorithm>//必須包含的標頭檔案，C++特有的庫函式

using namespace std;

int main()

{

    int point[5]={1,3,7,7,9};

    int ans;

    /*兩個函式傳入的：(陣列名，陣列名+陣列長度，要查詢的數字)，返回的是一個地址，減去陣列名即可得到數字在陣列中的下標*/

    ans=upper_bound(point,point+5,7)-point;//按從小到大，7最多能插入陣列point的哪個位置

    printf("%d ",ans);//輸出數字在陣列中的下標

    ans=lower_bound(point,point+5,7)-point;////按從小到大，7最少能插入陣列point的哪個位置

    printf("%d\n",ans);//輸出數字在陣列中的下標

    return 0;

}

/*

output：

相關推薦