LCA 多次詢問解法總結

題目：N個節點，M次詢問，求兩點間的最近公共祖先

一、並查集+DFS（也叫Tarjan）-------離線O(M+N)

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
#define N 10100
vector <int> a[N];
int vis[N],fa[N],In[N];
int l,r;
void ini()
{
    for(int i = 0; i < N; i++)a[i].clear();//存樹
    for(int i = 0; i < N; i++)vis[i]=0;//存是否被處理過
    for(int i = 0; i < N; i++)fa[i]=i;
    for(int i = 0; i < N; i++)In[i]=0;//存每個節點的入度
}
int get_fa(int x)
{
    if(x==fa[x])return x;
    return fa[x]=get_fa(fa[x]);
}
void LCA(int u)
{
    int len=a[u].size();
    for(int i = 0; i < len; i++)
    {
        int v=a[u][i];
        LCA(v);
        fa[v]=u;
    }
    vis[u]=1;
    if((l==u&&vis[r]))  //此時l,r不在以u爲根的子樹上，且r那顆子樹已經處理完畢，fa[r所在子樹的根]=l,r共同的祖先（已經賦過值），所以get_fa(r);
        printf("%d\n",get_fa(r));
    if(r==u&&vis[l])
        printf("%d\n",get_fa(l));//同理
        //printf("haha\n");
}
int  main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
        int n;scanf("%d",&n);
        ini();
        for(int i = 1; i < n; i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            a[x].push_back(y);
            In[y]++;
        }
        scanf("%d%d",&l,&r);
       // printf("haha\n");
        for(int i = 1; i <= n; i++)
            if(!In[i])LCA(i);
    }
    return 0;
}

每個節點(比如爲x)運行完之後就將x的父指針指向它的父親(這時父親節點的父指針依然指向自己)，然後再去運行x的兄弟節點，這時兄弟節點下的某個節點(比如y)如果在查詢中，且查詢如果恰好是(y, x的子孫)，則x所在並查集樹中的根節點一定是x的父節點，而這個父節點也是y的祖先，因此可知(y, x的子孫)的祖先一定包含x的父節點，由上面過程知道不能可包含比x的父節點更低的祖先節點，因此x的祖先節點必然是(y, x的子孫)的最近公共祖先)；

二、裸RMQ--------在線（N(log N)預處理，每次 log N 查詢） O（N(log N)+M(log N)）

設P[i][j]表示結點i往上移動2^j步所到達的結點，P[i][j]可以通過以下遞推公式計算：

$P[i][j]=\left\{\begin{matrix} parent(i), j=0 \\P[P[i][j-1]][j-1] \end{matrix}\right.$

利用P數組可以快速的將結點i向上移動n步，方法是將n表示爲2進制數。比如n=6，二進制爲110，那麼利用P數組先向上移動4步(2^2)，然後再繼續移動2步(2^1)，即P[ P[i][2] ][1]。

預處理計算P數組代碼如下：

map<TreeNode*, int> nodeToId;
map<int, TreeNode*> idToNode;
const int MAXLOGN=20; //樹中最大結點數爲1<<20
int P[1 << MAXLOGN][MAXLOGN];

//allNodes存放樹中所有的結點
void preProcessTree(vector<TreeNode *> allNodes) {
    int n = allNodes.size();
    // 初始化P中所有元素爲-1
    for (int i = 0; i < n; i++)
        for (int j = 0; 1 << j < n; j++)
            P[i][j] = -1;
    for (int i = 0; i < n; i++) {
        nodeToId[allNodes[i]] = i;
        idToNode[i] = allNodes[i];
    }
    // P[i][0]=parent(i)
    for (int i = 0; i < n; i++)
        P[i][0] = allNodes[i]->parent ? nodeToId[allNodes[i]->parent] : -1;
    // 計算P[i][j]
    for (int j = 1; 1 << j < n; j++)
        for (int i = 0; i < n; i++)
            if (P[i][j] != -1)
                P[i][j] = P[P[i][j - 1]][j - 1];
}

另外我們還需要預處理計算出每個結點的深度L[]，預處理之後，查詢node1和node2的LCA算法如下。

TreeNode* getLCA(TreeNode *node1, TreeNode *node2, int L[]) {
    int id1 = nodeToId[node1], id2 = nodeToId[node2];
    //如果node2的深度比node1深，那麼交換node1和node2
    if (L[id1] < L[id2]) swap(id1, id2);
    //計算[log(L[id1])]
    int log;
    for (log = 1; 1 << log <= L[id1]; log++);
    log--;
    //將node1向上移動L[id1]-L[id2]步，使得node1和node2在同一深度上
    for (int i = log; i >= 0; i--)
        if (L[id1] - (1 << i) >= L[id2])
            id1 = P[id1][i];
    if (id1 == id2) return idToNode[id1];
    //使用P數組計算LCA(idToNode[id1], idToNode[id2])
    for (i = log; i >= 0; i--)
        if (P[id1][i] != -1 && P[id1][i] != P[id2][i])
            id1 = P[id1][i], id2 = P[id2][i];
    return idToNode[id1];
}

時間複雜度分析：假設樹包含n個結點，由於P數組有nlogn個值需要計算，因此預處理的時間複雜度爲O(nlogn)。查詢兩個結點的LCA時，函數getLCA中兩個循環最多執行2logn次，因此查詢的時間複雜度爲O(logn)。

三、LCA轉化爲RMQ--------在線（N(log N)預處理，每次 O(1) 查詢） O（N(log N)+M）

對於有根樹T的兩個結點u、v，最近公共祖先LCA(T,u,v)表示一個結點x，滿足x是u、v的祖先且x的深度儘可能大。另一種理解方式是把T理解爲一個無向無環圖，而LCA(T,u,v)即u到v的最短路上深度最小的點。
這裏給出一個LCA的例子：
例一
對於T=<V,E>
V={1,2,3,4,5}
E={(1,2),(1,3),(3,4),(3,5)}
則有：
LCA(T,5,2)=1
LCA(T,3,4)=3
LCA(T,4,5)=3

RMQ問題與LCA問題的關係緊密，可以相互轉換，相應的求解算法也有異曲同工之妙。下面給出LCA問題向RMQ問題的轉化方法。

對樹進行深度優先遍歷，每當“進入”或回溯到某個結點時，將這個結點的編號存入數組E最後一位。同時記錄結點i在數組中第一次出現的位置(事實上就是進入結點i時記錄的位置)，記做R[i]。如果結點E[i]的深度記做D[i]，易見，這時求LCA(T,u,v)，就等價於求E[RMQ(D,R[u],R [v])]，(R[u]<R[v])，其中RMQ(D,R[u],R [v])就是在D數組中求下標從R[u]到R[v]的最小值的下標。例如一，求解步驟如下：

數列E[i]爲：1,2,1,3,4,3,5,3,1

R[i]爲：1,2,4,5,7

D[i]爲：0,1,0,1,2,1,2,1,0

於是有：

LCA(T,5,2) = E[RMQ(D,R[2],R[5])] = E[RMQ(D,2,7)] = E[3] = 1

LCA(T,3,4) = E[RMQ(D,R[3],R[4])] = E[RMQ(D,4,5)] = E[4] = 3

LCA(T,4,5) = E[RMQ(D,R[4],R[5])] = E[RMQ(D,5,7)] = E[6] = 3

易知，轉化後得到的數列長度爲樹的結點數的兩倍減一，所以轉化後的RMQ問題與LCA問題的規模同次。

再舉一個例子幫助理解:

   (1)

    / \

(2)   (7)

/ \     \

(3) (4)   (8)

    /   \

(5)    (6)

一個nlogn 預處理，O(1)查詢的算法.

Step 1:

        按先序遍歷整棵樹，記下兩個信息:結點訪問順序和結點深度.

        如上圖:

        結點訪問順序是: 1 2 3 2 4 5 4 6 4 2 1 7 8 7 1 //共2n-1個值

        結點對應深度是: 0 1 2 1 2 3 2 3 2 1 0 1 2 1 0

Step 2:

        如果查詢結點3與結點6的公共祖先,則考慮在訪問順序中

        3第一次出現，到6第一次出現的子序列: 3 2 4 5 4 6.

        這顯然是由結點3到結點6的一條路徑.

        在這條路徑中，深度最小的就是最近公共祖先(LCA). 即

        結點2是3和6的LCA.

Step 3:

        於是問題轉化爲, 給定一個數組R,及兩個數字i,j,如何找出

        數組R中從i位置到j位置的最小值..

        如上例,就是R[]={0,1,2,1,2,3,2,3,2,1,0,1,2,1,0}.

        i=2;j=7;

        接下來就是經典的RMQ問題.

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
#define maxn 100010
int cnt,id;
int head[maxn];
bool vis[maxn];
int dep[maxn*2+1], E[maxn*2+1], R[maxn];//R表示節點第一次出現的位置；dep表示時間戳爲i時的深度；E表示時間戳爲i時的節點
int f[maxn*2+1][20],d[50]; //f[] is RMQ, d[i] is 2^i
struct Edge
{
    int to,next,weight;
}edges[maxn]; //鄰接表
void init()
{
    cnt=id=0;
    memset(vis,false,sizeof(vis));
    memset(head,-1,sizeof(head));
}

void insert(int a, int b, int weight)
{
    edges[cnt].to=b;
    edges[cnt].next=head[a];
    edges[cnt].weight=weight;
    head[a]=cnt++;
}
void DFS(int u, int d)
{
    vis[u]=1;
    R[u]=id;E[id]=u;dep[id++]=d;
    for(int i = head[u]; i != -1; i=edges[i].next)
    {
        int v=edges[i].to;
        if(!vis[v])
        {
            DFS(v,d+1);
            E[id]=u;dep[id++]=d;
        }
    }
}
void InitRMQ(const int &id,int n)
{
    d[0]=1;
    for(int i = 1; i < n; i++)d[i]=2*d[i-1];
    for(int i = 0; i < id; i++)f[i][0]=i;
    int k=int(log(double(n))/log(2.0))+1;
    for(int j = 1; j < k; j++)
        for(int i = 0; i < id; i++)
        {
            if(i+d[j-1]-1<id)
                f[i][j]=dep[f[i][j-1]]>dep[f[i+d[j-1]][j-1]]?f[i+d[j-1]][j-1]:f[i][j-1];
            else break;
        }
}
int Query(int x, int y)
{
    int k;
    k=int(log(double(y-x+1))/log(2.0));
    return dep[f[x][k]]>dep[f[y-d[k]+1][k]]?f[y-d[k]+1][k]:f[x][k];
}
void Answer()
{
    int Q;scanf("%d",&Q);
    for(int i = 0; i < Q; i++)
    {
        int x,y;
        scanf("%d%d",&x,&y);          //查詢x,y的LCA
        x=R[x];y=R[y];
        if(x>y)swap(x,y);
        printf("%d\n",E[Query(x,y)]);
    }
}
int main()
{
    int t;scanf("%d",&t);
    while(t--)
    {
        init();
        int n,m;scanf("%d%d",&n,&m);
        for(int i = 0; i < m; i++)
        {
            int a,b,c;scanf("%d%d%d",&a,&b,&c);
            insert(a,b,c);
        }
        DFS(1,0);
        InitRMQ(id,n);
        Answer();
    }
    return 0;
}

LCA 多次詢問解法總結

LCA 多次詢問解法總結

揹包專輯（轉）

分佈式計算、網格計算和雲計算

hdu4628狀態壓縮DP

HDU 4679 Terrorist’s destroy (拆邊+樹的直徑)

Mac下配置sublime實現LaTeX

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

linux以太網驅動總結

LCA 多次詢問 解法總結

LCA 多次詢問解法總結