LCA

最新推荐文章于 2025-05-19 21:42:32 发布
最新推荐文章于 2025-05-19 21:42:32 发布
阅读量78 收藏
点赞数
分类专栏： 算法 文章标签： raspberry pi dell cobol init sandbox
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u014560290/article/details/111190029
版权
本文深入探讨了LCA倍增算法在解决树上两点间最短路径问题的应用，通过多个实例展示了算法的具体实现过程，包括HDU-2586、POJ-1986、HDU-2874、ZOJ-3195和HDU-3078等题目。文章不仅提供了详尽的代码解释，还对比了不同场景下算法的细微差别，如森林LCA、树上三点间距离计算和最短路径节点权值查找。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

A - How far away ？

  HDU - 2586 
 题意：给出一棵树，树上的边有权值，查询两个点之间的最短权值和
 LCA倍增 
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<stack>
#include<cstdlib>
#include<queue>
#include<set>
#include<string.h>
#include<vector>
#include<deque>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define eps 1e-4
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
typedef long long LL;
typedef long long ll;
const int maxn = 4e4 + 5;
const int mod = 998244353;

int cnt,DEG = 30;
int vis[maxn],head[maxn],dep[maxn],fa[maxn][30],dis[maxn];

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

void addedge(int x,int y,int z) {
    edge[++cnt].to = y;
    edge[cnt].v = z;
    edge[cnt].next = head[x];
    head[x] = cnt;
}
void init() {
    cnt = 0;
    memset(vis,0,sizeof vis);
    memset(head,-1,sizeof head);
    memset(dep,0,sizeof dep);
    memset(dis,0,sizeof dis);
}
void bfs(int root) {
    queue<int>que;
    dep[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;
            dep[v] = dep[tmp] + 1;
            dis[v] = dis[tmp] + edge[i].v;
            fa[v][0] = tmp;
            que.push(v);
        }
    }
}
int LCA(int u,int v) {
    if(dep[u] > dep[v]) swap(u,v);
    int hu = dep[u],hv = dep[v],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];
}
int main()
{
    int t;
    scanf("%d",&t);
    while (t -- ) {
        init();
        int n, m;
        scanf("%d %d",&n,&m);
        for(int i = 1; i < n; i++) {
            int u,v,k;
            scanf("%d %d %d",&u,&v,&k);
            vis[v] = 1;
            addedge(u,v,k);
            addedge(v,u,k);
        }
        int root;
        for(int i = 1; i <= n; i++ ) {
            if(vis[i] == 0) {
                root = i;
                break;
            }
        }

        bfs(root);
        for(int i = 1; i <= m; i++) {
            int a,b;
            scanf("%d %d",&a,&b);
            int ans = dis[a] + dis[b] - 2 * dis[LCA(a,b)];
            printf("%d\n",ans);
        }
    }
}
View Code
 

B - Distance Queries

 POJ - 1986 
LCA倍增模版，加注释！！ 
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<stack>
#include<cstdlib>
#include<queue>
#include<set>
#include<string.h>
#include<vector>
#include<deque>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define eps 1e-4
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
typedef long long LL;
typedef long long ll;
const int maxn = 4e4 + 5;
const int mod = 998244353;

int cnt,DEG = 30;
int vis[maxn],head[maxn],dep[maxn],fa[maxn][30],dis[maxn];
//dep深度数组  fa[i][j]表示结点 i 的第2 ^ j个祖先
//dis[i] root到任意的一个i结点的距离
struct EDGE {
    int next,to,v;
}edge[maxn * 2];

void addedge(int x,int y,int z) {
    edge[++cnt].to = y;
    edge[cnt].v = z;
    edge[cnt].next = head[x];
    head[x] = cnt;
}
void init() {
    cnt = 0;
    memset(vis,0,sizeof vis);
    memset(head,-1,sizeof head);
    memset(dep,0,sizeof dep);
    memset(dis,0,sizeof dis);
    memset(fa,0,sizeof fa);
}
void bfs(int root) {
    queue<int>que;
    dep[root] = 0;  //根节点的深度为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]; //tmp这个点的2 ^ i的祖先就是 tmp的 2 ^ (i - 1)的祖先这个点的 2 ^ (i - 1)的祖先
        for(int i = head[tmp]; i != -1; i = edge[i].next) {
            int v = edge[i].to;
            if(v == fa[tmp][0]) continue;
            dep[v] = dep[tmp] + 1;
            dis[v] = dis[tmp] + edge[i].v; //dis距离数组的更新
            fa[v][0] = tmp;
            que.push(v);
        }
    }
}
int LCA(int u,int v) {
    if(dep[u] > dep[v]) swap(u,v); //使得v的深度比较大
    int hu = dep[u],hv = dep[v],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];
}
int main() {

    init();
    int n, m;
    while (~scanf("%d %d", &n, &m)) {
        for (int i = 1; i <= m; i++) {
            int u, v, k;
            char s[10];
            scanf("%d %d %d %s", &u, &v, &k, s);
            vis[v] = 1;
            addedge(u, v, k);
            addedge(v, u, k);
        }
        int root;
        for (int i = 1; i <= n; i++) {
            if (vis[i] == 0) {
                root = i;
                break;
            }
        }

        bfs(root);
        int k;
        scanf("%d", &k);
        for (int i = 1; i <= k; i++) {
            int a, b;
            scanf("%d %d", &a, &b);
            int ans = dis[a] + dis[b] - 2 * dis[LCA(a, b)];
            printf("%d\n", ans);
        }
    }

}
View Code

C - Connections between cities

 HDU - 2874 

森林求LCA

倍增 + 并查集

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<stack>
#include<cstdlib>
#include<queue>
#include<set>
#include<string.h>
#include<vector>
#include<deque>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define eps 1e-4
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
typedef long long LL;
typedef long long ll;
const int maxn = 1e5 + 5;
const int mod = 998244353;

struct Edge {
    int to,next,v;
}edge[maxn * 2];
const int DEG = 30;
int head[maxn],dep[maxn],fa[maxn][DEG],dis[maxn];
bool vis[maxn];
int pre[maxn];
int tot;
void init() {
    tot = 0;
    memset(dis,0,sizeof dis);
    memset(head,-1,sizeof head);
    memset(vis,false,sizeof vis);
    memset(dep,0,sizeof dep);
}
int find(int x) {
    if(pre[x] != x)
        return pre[x] = find(pre[x]);
    return x;
}
void combine(int x,int y) {
    int fx = find(x);
    int fy = find(y);
    if(fx != fy) {
        pre[fx] = fy;
    }
}
void addedge(int u,int v,int z) {
    edge[tot].to = v;
    edge[tot].next = head[u];
    edge[tot].v = z;
    head[u] = tot++;
}
void BFS(int root) {
    queue<int>que;
    dep[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;
            dep[v] = dep[tmp] + 1;
            dis[v] = dis[tmp] + edge[i].v;
            fa[v][0] = tmp;
            que.push(v);
        }
    }
}
int LCA(int u,int v) {
    if(dep[u] > dep[v]) swap(u,v);
    int hu = dep[u],hv = dep[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];
}
int main() {
   
    int n, m, k;
    while(~scanf("%d %d %d",&n,&m,&k)) { 
        init();
        for (int i = 1; i <= n; i++)
            pre[i] = i;
        for (int i = 0; i < m; i++) {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            addedge(a, b, c);
            addedge(b, a, c);
            combine(a, b);
            vis[b] = true;
        }
        int root;
        for (int i = 1; i <= n; i++) {
            if (vis[i] == false) {
                root = i;
                break;
            }
        }
        for (int i = 1; i <= n; i++)
            if (pre[i] == i)
                BFS(i);
        while (k--) {
            int a, b;
            scanf("%d %d", &a, &b);
            if (find(a) != find(b))
                puts("Not connected");
            else {
                int ans = dis[a] + dis[b] - 2 * dis[LCA(a, b)];
                printf("%d\n", ans);
            }
        }
    }
}
View Code

D - Design the city

 ZOJ - 3195

题意：求树上三点间的最短距离。

思路：ans=(dis(a,b)+dis(a,c)+dis(b,c))/2

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<stack>
#include<cstdlib>
#include<queue>
#include<set>
#include<string.h>
#include<vector>
#include<deque>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define eps 1e-4
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
typedef long long LL;
typedef long long ll;
const int maxn = 5e4 + 5;
const int mod = 998244353;

int cnt,DEG = 30;
int vis[maxn],head[maxn],dep[maxn],fa[maxn][30],dis[maxn];

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

void addedge(int x,int y,int z) {
    edge[++cnt].to = y;
    edge[cnt].v = z;
    edge[cnt].next = head[x];
    head[x] = cnt;
}
void init() {
    cnt = 0;
    memset(vis,0,sizeof vis);
    memset(head,-1,sizeof head);
    memset(dep,0,sizeof dep);
    memset(dis,0,sizeof dis);
}
void bfs(int root) {
    queue<int>que;
    dep[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;
            dep[v] = dep[tmp] + 1;
            dis[v] = dis[tmp] + edge[i].v;
            fa[v][0] = tmp;
            que.push(v);
        }
    }
}
int LCA(int u,int v) {
    if(dep[u] > dep[v]) swap(u,v);
    int hu = dep[u],hv = dep[v],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];
}
int main() {

    int n, m;
    int ca = 0;
    while (~scanf("%d", &n)) {
        init();
        if(ca > 0)printf("\n");
        ca++;
        for (int i = 1; i < n; i++) {
            int u, v, k;
            scanf("%d %d %d", &u, &v, &k);
            vis[v] = 1;
            addedge(u, v, k);
            addedge(v, u, k);
        }
        int root;
        for (int i = 0; i < n; i++) {
            if (vis[i] == 0) {
                root = i;
                break;
            }
        }
        scanf("%d",&m);
        bfs(root);
        for (int i = 1; i <= m; i++) {
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            int ans1 = dis[a] + dis[b] - 2 * dis[LCA(a, b)];
            int ans2 = dis[a] + dis[c] - 2 * dis[LCA(a,c)];
            int ans3 = dis[b] + dis[c] - 2 * dis[LCA(b,c)];
            printf("%d\n", (ans1 + ans2 + ans3) / 2);
        }
    }
}
View Code

E - Network

 HDU - 3078

题意：问你u，v最短路上所有节点权值的第k大

思路：就是u->lca(u,v)和v->lca(u，v)的所有节点权值放入数组，sort一下，输出第k大就行(这也太暴力了)

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<stack>
#include<cstdlib>
#include<queue>
#include<set>
#include<string.h>
#include<vector>
#include<deque>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define eps 1e-4
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
typedef long long LL;
typedef long long ll;
const int maxn = 8e4 + 5;
const int mod = 998244353;

int cnt,DEG = 30;
int vis[maxn],head[maxn],dep[maxn],fa[maxn][30],dis[maxn];
int w[maxn],path[maxn];
struct EDGE {
    int next,to;
}edge[maxn * 2];

void addedge(int x,int y) {
    edge[++cnt].to = y;
    edge[cnt].next = head[x];
    head[x] = cnt;
}
void init() {
    cnt = 0;
    memset(vis, 0, sizeof vis);
    memset(head, -1, sizeof head);
    memset(dep, 0, sizeof dep);
    memset(dis, 0, sizeof dis);
    memset(path, 0, sizeof path);
}
void bfs(int root) {
    queue<int> que;
    dep[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;
            dep[v] = dep[tmp] + 1;
            fa[v][0] = tmp;
            que.push(v);
        }
    }
}
int LCA(int u,int v) {
    if (dep[u] > dep[v]) swap(u, v);
    int hu = dep[u], hv = dep[v], 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 cmp(int h1,int h2) {
    return h1 > h2;
}

int main() {


    int n, m;
    while (~scanf("%d %d", &n, &m)) {
        init();
        for(int i = 1; i <= n; i++) scanf("%d", &w[i]);
        for (int i = 1; i < n; i++) {
            int u, v;
            scanf("%d %d", &u, &v);
            vis[v] = 1;
            addedge(u, v);
            addedge(v, u);
        }
        int root;
        for (int i = 1; i <= n; i++) {
            if (vis[i] == 0) {
                root = i;
                break;
            }
        }

        bfs(root);
        for (int i = 1; i <= m; i++) {
            int k,a, b;
            scanf("%d %d %d", &k, &a, &b);
            if(k == 0)
                w[a] = b;
            else {
                int lca = LCA(a,b);
                int num = 0;
                for(int i = a; i != lca; i = fa[i][0]) path[++num] = w[i];
                for(int i = b; i != lca; i = fa[i][0]) path[++num] = w[i];
                path[++num] = w[lca];
                if(num < k) {
                    printf("invalid request!\n");
                } else {
                    sort(path + 1,path + 1 + num,cmp);
                    printf("%d\n",path[k]);
                }
            }
        }
    }
}
View Code

K - Nearest Common Ancestors

 POJ - 1330 

ST表求LCA

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<stack>
#include<cstdlib>
#include<queue>
#include<set>
#include<string.h>
#include<vector>
#include<deque>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f3f3f3f3f
#define inf 0x3f3f3f3f
#define eps 1e-4
#define bug printf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
typedef long long LL;
typedef long long ll;
const int maxn = 1e4 + 5;
const int mod = 998244353;

int rmq[2 * maxn];  // 欧拉序列对应的深度序列
struct ST {
    int mm[2 * maxn];
    int dp[2 * maxn][20];

    void init(int n) {
        mm[0] = -1;
        for (int i = 1; i <= n; i++) {
            mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
            dp[i][0] = i;
        }
        for (int j = 1; j <= mm[n]; j++)
            for (int i = 1; i + (1 << j) - 1 <= n; i++)
                dp[i][j] =
                        rmq[dp[i][j - 1]] < rmq[dp[i + (1 << (j - 1))][j - 1]] ? dp[i][j - 1] : dp[i + (1 << (j - 1))][
                                j - 1];
    }

    int query(int a, int b) {
        if (a > b) swap(a, b);
        int k = mm[b - a + 1];
        return rmq[dp[a][k]] <= rmq[dp[b - (1 << k) + 1][k]] ? dp[a][k] : dp[b - (1 << k) + 1][k];
    }
}st;
struct Edge {
    int to, next;
}edge[maxn * 2];
int tot,head[maxn * 2];

int F[maxn * 2];    //欧拉序列 即dfs遍历的顺序
int P[maxn];        //表示点i在F中第一次出现的位置
int cnt;
void init() {
    tot = 0;
    memset(head, -1, sizeof head);
}
void addedge(int u,int v) {
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}
void dfs(int u,int pre,int dep) {
    F[++cnt] = u;
    rmq[cnt] = dep;
    P[u] = cnt;
    for (int i = head[u]; i != -1; i = edge[i].next) {
        int v = edge[i].to;
        if (v == pre) continue;
        dfs(v, u, dep + 1);
        F[++cnt] = u;
        rmq[cnt] = dep;
    }
}
void LCA_init(int root,int node_num) {
    cnt = 0;
    dfs(root, root, 0);
    st.init(2 * node_num - 1);
}
int query_lca(int u,int v) {
    return F[st.query(P[u], P[v])];
}

bool flag[maxn];
int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int n;
        scanf("%d", &n);
        init();
        memset(flag, 0, sizeof flag);
        int u, v;
        for (int i = 1; i < n; i++) {
            scanf("%d %d", &u, &v);
            addedge(u, v);
            addedge(v, u);
            flag[v] = true;
        }
        int root;
        for (int i = 1; i <= n; i++)
            if (!flag[i]) {
                root = i;
                break;
            }
        LCA_init(root, n);
        scanf("%d %d", &u, &v);
        printf("%d\n", query_lca(u, v));
    }
}
View Code
浅析LCA
夕弦
08-06 1万+
1.&amp;amp;amp;amp;nbsp;1.&amp;amp;amp;amp;nbsp;1. \ 定义 LCA（Least Common Ancestors），即最近公共祖先，指对于有根树 TTT 的两个结点 uuu 、vvv ，最近公共祖先 LCA(T,u,v)LCA(T,u,v)LCA(T, u, v) 表示一个结点 xxx, 满足 xxx 是 uuu、vvv 的祖先且 xxx 的深度尽可能大。 下面给出一个自己画的图，用来解释LCA及其算...
LCA 详解
青烟绕指柔的博客
07-30 5663
LCA（Least Common Ancestors），即最近公共祖先，是指在有根树中，找出某两个结点u和v最近的公共祖先。 ———来自百度百科 比如在上面这幅图当中： ( LCA(A,B) ---- 表示A,B的最近公共祖先。) LCA ( 2 , 7 ) == 1 ; LCA ( 4 , 8 ) == 1 ; LCA ( 6 ,10) == 1; LCA ( 5 , 6 ) ...
lca
h_hui_hui的博客
05-23 399
题意：在完全二叉树中，给两个结点的位置，求出它们最近的公共祖先（lca）,输入为十六进制，输出为十六进制。 思路：表面是lca，实际是二进制的题目。比如5和9它们的lca是2。5的二进制101、9的二进制1001；它们最长公共前缀是10，也就是2。再加上16进制和2进制可以直接换算，所以我们出一下边角问题就可以直接得到lca。复杂度就是输入数据的长度。 代码：我写了个贼暴力的解法。慢慢继续学习更优解法吧。 #include<bits/stdc++.h> using namespace..
最近公共祖先（LCA）
m0_74015873的博客
03-24 583
接下来 n 行每行一对整数 a 和 b，表示 a和 b 之间有一条无向边。如果 b是 −1，那么 a 就是树的根；对于每一个询问，若 x 是 y 的祖先则输出 1，若 y 是 x 的祖先则输出 2，否则输出 0。有 m 个询问，每个询问给出了一对节点的编号 x 和 y，询问 x 与 y 的祖孙关系。给定一棵包含 n 个节点的有根无向树，节点编号互不相同，但不一定是 1∼n。接下来 m 行，每行两个不同的正整数 x 和 y，表示一个询问。第 n+2 行是一个整数 m 表示询问个数；
倍增LCA
qq_59144780的博客
01-30 4824
朴素算法求LCA，即暴力求解，当树近乎为一条链时，找祖先时一级一级向上跳，时间复杂度接近O(n),所以可以考虑一次跳尽可能大的距离，即倍增算法；一次跳2^i（i=0,1,2....）级。 倍增法 一个节点的四级祖先就是这个节点的二级祖先的二级祖先； 设fa[j][i]为j节点的2^i级祖先；则fa[j][i]=fa[fa[j][i-1]][i-1]; 算法思想：求两节点的lca，先将深度深的结点用倍增法向上跳，直到两节点处于同一深度，此时有可能重合，则两点中任意一个结点即为lca；若没重合，则两节
LCA详解
热门推荐
刘伟的博客
10-18 2万+
LCA问题(least Comment Ancestors,最近公共祖先问题),是指给定一棵有根树T,给出若干个查询LCA(u,v)(通常查询数量较大)， 每次求树T中两个顶点u和v的最近公共祖先，即找到一个节点，同时是u和v的祖先，并且深度尽可能的大(尽可能远离树根). LCA问题的解法有很多，有一般解法，基于tarjan的解法，跳表解法以及RMQ和LCA互相转化的解法。下面我们依次
LCA总结
ZhuRanCheng的博客
05-01 836
LCA总结
LCA倍增板子
JK01WYX的博客
01-28 479
最近公共祖先简称 LCA（Lowest Common Ancestor）
倍增求 LCA
Ryan_hsMax的博客
09-30 687
LCA 指的是最近的公共祖先，倍增法求解 LCA 的步骤如下。 a. 求深度：对于每个节点 dfs 预处理处节点深度； b. 求倍增祖先：计算出每个节点向父元素跳 步所到达的节点（在这里 大于整棵树的最大深度） 备注： a. 设 f [ x , k ] 表示节点 x 向上跳 步能到达的祖先， f [ x , 0 ] 表示 x 的父元素，如对应节点不存在 f [ x , k ] = 0。 b. 将路径长度 分为两半，x 跳
SAS+proc lca浅类别分析安装程序
09-16
其中，PROC LCA（Latent Class Analysis）是SAS中的一个过程，用于执行潜在类别分析，这是一种统计方法，旨在从观测数据中识别出隐藏的、不可见的类别结构。PROC LCA尤其适用于处理多分类变量，它可以帮助研究人员...
LCA-AW2.2.zip
04-09
【LCA词汇复杂度分析软件】是一款用于自然语言处理（NLP）的专业工具，它主要聚焦于语言的复杂度分析。LCA，全称为“Language Complexity Analysis”，此软件旨在帮助用户理解和评估文本的语言难度，这对于教育、...
日立LCA电气图纸(K3500490).pdf
06-24
这导致无法从中提取任何有关“日立LCA电气图纸(K3500490).pdf”文件的知识点。为了满足题目要求，我将基于标题和描述部分提供的信息，对“日立LCA电气图纸”进行知识性的解释。 ### LCA型微机控制变压变频调速无...
openLCA:适用于LCA的专业开源软件-开源
04-28
标题中的“openLCA”指的是一个专业开源的生命周期评估（Life Cycle Assessment，简称LCA）软件，它专门用于进行环境影响分析和可持续性评估。开源软件意味着它的源代码是公开的，用户可以自由地查看、修改和分发，...
LatentClassPlots:从 R 中的 Mplus LCA 输出绘制响应概率图
06-10
LatentClassPlots 是一个 R 函数，旨在从 Mplus 中估计的潜在类分析 (LCA) 中绘制响应概率图。 参数 要从 LCA 输出绘制图，唯一需要的参数是data参数。 提供这一点将导致使用附加参数的预设的绘图。 第二个参数 ( ...
树莓派（Raspberry Pi）中切换为国内的软件源
SmileHergo的博客
05-19 908
在树莓派（Raspberry Pi）中切换为国内的软件源（例如中科大、清华等）可以显著提升 apt 安装与更新速度。apt-key 导入公钥 apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 9165938D90FDDD2E。如果你使用的是较新的系统（例如 bookworm 或之后），apt-key 已不推荐使用。这个错误是因为你添加的清华源（或其他源）缺少对应的 GPG 公钥，APT 无法验证该源的签名，因此默认禁用。
【物联网】基于树莓派的物联网开发【3】——最新镜像下载和烧录
建仔的博客专栏
05-15 1139
本文详细介绍了树莓派的组装、系统安装及配置过程。首先，列举了树莓派必备的配件，如TF卡、充电线、散热片等。接着，讲解了散热片和外壳的安装方法，并推荐了多种外壳材质。随后，详细描述了从官网下载最新系统镜像、格式化内存卡到使用烧录工具将系统写入SD卡的步骤，并提供了烧录错误的解决方案。最后，总结了烧录过程中的注意事项，如避免误格式化SD卡、提前配置网络等，确保树莓派顺利启动并正常运行。
cmd脚本-bat批处理-AdobeRemovePanel.zip
05-22
cmd脚本-bat批处理-AdobeRemovePanel.zip
HTML、CSS与JavaScript构建学生信息管理系统
最新发布
05-22
好的，以下是重新表述后的内容： 本次学生信息管理系统的效果页面代码较为复杂，主要涉及HTML、JS和CSS。在实现过程中，遇到了以下难点： 页面中有一个复选框，通过它的checked属性可以判断是否被选中。当点击该复选框时，需要将当前页面的这一列所有复选框的checked属性设置为相同的值，从而实现全选功能。 要实现仅选择当前页的功能，首先需要获取当前页面的页码，记为page。由于每一页设定只显示10条内容，因此可以通过以下规则计算当前页的起始条目索引：当前页的开始条数为(page - 1) * 10。 如果还有其他问题，可以评论或者通过邮箱（1079349989@qq.com）联系我。完整的代码可以在我的GitHub中找到，GitHub链接在本页面。
lca targan
04-03
### Targan Algorithm for Lowest Common Ancestor (LCA) The Tarjan offline algorithm is one of the most efficient methods to solve the LCA problem, especially when dealing with multiple queries on ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值