当前位置：网站首页>Multiply LCA (nearest common ancestor)

Multiply LCA (nearest common ancestor)

2022-07-02 12:10:00 【Tooth decay music】

Multiply ：

hold n Fold the simulation into ${log_{2}}^{n}$ simulation （ It's understandable ）, The reason to use 2 Is due to 2 To the power of, you can round up all positive integers

Ring problem （https://oi-wiki.org/basic/binary-lifting/）： Here, only the multiplication method is explained

Its idea is to find x + k The value of this circle , then m Secondary disassembly ${log_{2}}^{m}$ Get the answer for the first time . Have a conclusion ： most n This cycle can return to the origin , Therefore, each cycle must be neither heavy nor leaky .

List of questions ： https://www.luogu.com.cn/training/203#problems

LCA：

The common ancestor of two nodes in the tree （ Looking up, you can find the ancestor node that the nearest two points can reach at the same time ）

Some properties ： https://oi-wiki.org/graph/lca/

violence ：

dfs Look for... Layer by layer

The board of senior students , It's probably such a reason

void dfs(int u, int fa)
    father[u] = fa;
    deep[u] = deep[fa] + 1;
    for (int i = head[u]; ~i; i = edge[i].pre){
        int v = edge[i].to;
        if(v != fa)
            dfs(v, u);
    }
}

int lca1(int u, int v){
    while(u != v){
        if(deep[u] < deep[v]){
            swap(u, v);
        }
        u = father[u];
    }
    return u;
}

int lca2(int u, int v){
    if(deep[u] < deep[v]){
        swap(u, v);
    }
    while(deep[u] > deep[v]){
        u = father[u];
    }
    while(u != v){
        u = father[u];
        v = father[v];
    }
    return u;
}

Multiply LCA：

Preprocessing x Of $2^{i}$ The ancestors （ Each jump $2^{i}$ ）+ Split the height difference between two nodes

P3379 【 Templates 】 Recent public ancestor （LCA）(https://www.luogu.com.cn/problem/P3379)

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

const int maxn = 5e5 + 5;
const int DEG = 30;
#define re(a) memset(a, -1, sizeof(a))

struct Edge{
    int to, next;
}edge[maxn * 2];

int head[maxn], tot;

void addedge(int u, int v){
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void init(){
    tot = 0;
    re(head);
}

int fa[maxn][DEG], deg[maxn];

void bfs(int root){
    queue<int> que;
    deg[root] = 0;
    fa[root][0] = root;
    que.push(root);
    while(!que.empty()){
        int tmp = que.front();
        que.pop();
        for(int i = 1; i < DEG; ++i){
            fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
        }
        for (int i = head[tmp]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(v == fa[tmp][0])
                continue;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            que.push(v);
        }
    }
}

int lca(int u, int v){
    if(deg[u] > deg[v]){
        swap(u, v);
    }
    int hu = deg[u], hv = deg[v];
    int tu = u, tv = v;
    for (int det = hv - hu, i = 0; det; det >>= 1, ++i){
        if(det & 1)
            tv = fa[tv][i];
    }
    if(tu == tv)
        return tu;
    for(int i = DEG - 1; i >= 0; --i){
        if(fa[tu][i] == fa[tv][i]){
            continue;
        }
        tu = fa[tu][i];
        tv = fa[tv][i];
    }
    return fa[tu][0];
}
bool flag[maxn];
int main(){
    int n, m, s;
    init();
    memset(flag, false, sizeof(flag));
    cin >> n >> m >> s;
    for (int i = 1; i < n; ++i){
        int a, b;
        cin >> a >> b;
        addedge(a, b);
        addedge(b, a);
        flag[b] = true;
    }
    int root;
    for (int i = 1; i <= n; ++i){
        if(!flag[i]) {
            root = i;
            break;
        }
    }
    bfs(s);// The root node 
    for (int i = 0; i < m; ++i){
        int a, b;
        cin >> a >> b;
        cout << lca(a, b) << endl;
    }
        return 0;
}

topic ：

Nearest Common Ancestors（https://vjudge.net/problem/POJ-1330）

Copy down the upper board and change it

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;

const int maxn = 5e5 + 5;
const int DEG = 30;
#define re(a) memset(a, -1, sizeof(a))

struct Edge{
    int to, next;
}edge[maxn * 2];

int head[maxn], tot;

void addedge(int u, int v){
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void init(){
    tot = 0;
    re(head);
}

int fa[maxn][DEG], deg[maxn];

void bfs(int root){
    queue<int> que;
    deg[root] = 0;
    fa[root][0] = root;
    que.push(root);
    while(!que.empty()){
        int tmp = que.front();
        que.pop();
        for(int i = 1; i < DEG; ++i){
            fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
        }
        for (int i = head[tmp]; i != -1; i = edge[i].next){
            int v = edge[i].to;
            if(v == fa[tmp][0])
                continue;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            que.push(v);
        }
    }
}

int lca(int u, int v){
    if(deg[u] > deg[v]){
        swap(u, v);
    }
    int hu = deg[u], hv = deg[v];
    int tu = u, tv = v;
    for (int det = hv - hu, i = 0; det; det >>= 1, ++i){
        if(det & 1)
            tv = fa[tv][i];
    }
    if(tu == tv)
        return tu;
    for(int i = DEG - 1; i >= 0; --i){
        if(fa[tu][i] == fa[tv][i]){
            continue;
        }
        tu = fa[tu][i];
        tv = fa[tv][i];
    }
    return fa[tu][0];
}
bool flag[maxn];
int main(){
    int t;
    cin >> t;
    while(t--){
        int n;
        init();
        memset(flag, false, sizeof(flag));
        cin >> n;
        for (int i = 1; i < n; ++i){
            int a, b;
            cin >> a >> b;
            addedge(a, b);
            addedge(b, a);
            flag[b] = true;
        }
        int root;
        for (int i = 1; i <= n; ++i){
            if(!flag[i]) {
                root = i;
                break;
            }
        }
        bfs(root);// The root node 
        int a, b;
        cin >> a >> b;
        cout << lca(a, b) << endl;
    }
        return 0;
}

Wrong hemp , I'll make it up when I have a chance

Post a passable code

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
const int maxn = 1e5 + 5;
#define re(a) memset(a, 0, sizeof(a))
//other code 
vector<int> adj[maxn], cost[maxn];
int dis[maxn], up[maxn][21], dep[maxn];

void clear(int n){
    for (int i = 1; i <= n; ++i){
        dis[i] = 0;
        adj[i].clear();
        cost[i].clear();
        dep[i] = 0;
        for (int j = 0; j <= 18; ++j)
            up[i][j] = 0;
    }
}

void dfs(int s, int p){
    if(p != -1)
        up[s][0] = p;
    for (int i = 1; i <= 18; ++i)
        up[s][i] = up[up[s][i - 1]][i - 1];
    for (int i = 0; i < adj[s].size(); ++i){
        int v = adj[s][i];
        int d = cost[s][i];
        if(v == p)
            continue;
        dis[v] = dis[s] + d;
        dep[v] = dep[s] + 1;
        dfs(v, s);
    }
}

int lca(int a, int b){
    if(dep[a] > dep[b])
        swap(a, b);
    int d = dep[b] - dep[a];
    for (int i = 18; i >= 0; --i){
        if(d & (1 << i))
            b = up[b][i];
    }
    if (a == b)
        return a;
    for (int i = 18; i >= 0; --i){
        if(up[a][i] != up[b][i]){
            a = up[a][i];
            b = up[b][i];
        }
    }
    return up[a][0];
}

int main(){
    int t, n;
    cin >> t;
    while(t--){
        cin >> n;
        clear(n);
        // re(dis);
        // re(up);
        // re(dep);
        // adj->clear();
        // cost->clear();
        for (int i = 1; i < n; ++i){
            int a, b, c;
            cin >> a >> b >> c;

            adj[a].push_back(b);
            adj[b].push_back(a);

            cost[a].push_back(c);
            cost[b].push_back(c);
        }
        dfs(1, -1);
        string s;
        while(1){
            cin >> s;
            if(s == "DIST") {
                int a, b;
                cin >> a >> b;
                cout << (dis[a] + dis[b] - 2 * dis[lca(a, b)]) << endl;
            }
            else if(s == "KTH"){
                int a, b, k;
                cin >> a >> b >> k;
                if(k == 1){
                    cout << a << endl;
                    continue;
                }
                int lc = lca(a, b);
                int d = dep[a] - dep[lc];
                if(d + 1 >= k){
                    if(lc == a){
                        if(d + 1 == k) {
                            cout << b << endl;
                            continue;
                        }
                        else
                            k = d + 1 - k + 1;
                    }
                    k--;
                    for(int i = 18; i >= 0; --i){
                        if(k & (1 << i))
                            a = up[a][i];
                    }
                    cout << a << endl;
                }
                else {
                    k -= d;
                    --k;
                    d = dep[b] - dep[lc];
                    k = d - k;
                    for (int i = 18; i >= 0; --i){
                        if(k & (1 << i))
                            b = up[b][i];
                    }
                    cout << b << endl;
                }
            }
            else
                break;
        }
    }
    return 0;
}

原网站

版权声明
本文为[Tooth decay music]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/183/202207020906156543.html