3.6 最近公共祖先

最新推荐文章于 2024-05-13 21:58:37 发布
最新推荐文章于 2024-05-13 21:58:37 发布
阅读量131 收藏
点赞数
分类专栏： AcWing算法提高课
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/esjiang/article/details/114707897
版权

最近公共祖先
为了一般化, 把一个点本身也称为它的祖先.(将当前点往根节点走, 路过的点全部称为祖先)

在这里插入图片描述
当然祖先有可能是红色和绿色点中的某一个点, 当然有可能两点是重叠的.

向上标记法

从一个点开始向上遍历, 在遍历的过程中, 将它路过点的点都标记一下, 比方说搞个bool数组, 路过的全部标记成1.
标记完后, 从另外一个点开始往上走, 当另外一个点第1次走到标记的点的时候, 那么当前点就是最近的公共祖先
O(n): 最坏情况下一条链, 每次走到根节点

倍增法

先预处理下, 每个点向上走 2 k 2^k 2k步的父亲是谁
fa[i, j] 表示从i开始, 向上走2^j步所能走到的节点, 0 <= j <= log n (暂时不明白为什么是 ⌊ log ⁡ n ⌋ \lfloor \log n\rfloor ⌊logn⌋)

⌊ log ⁡ n ⌋ \lfloor \log n\rfloor ⌊logn⌋ 因为0表示0辈祖先, 即父节点, 1表示2^1辈祖先, 即爷爷节点, 因此 ⌊ log ⁡ n ⌋ \lfloor \log n\rfloor ⌊logn⌋相当于 当前祖先链上, 往上走了n步, 可以走到超过根节点的情况
在这里插入图片描述

在这里插入图片描述
j = 0, f[i, j] = i的父亲节点
j > 0的时候, 如果要跳2^j步, 可以通过j -1递推求, f[i, j] = f[f[i, j - 1], j - 1](先从i跳 2 j − 1 2^{j - 1} 2j−1步, f[i, j - 1], 然后在此基础上再跳 2 j − 1 2^{j - 1} 2j−1, f[f[i, j -1], j - 1]) (yxc:既可以用bfs, 也可以用dfs来求)
depth[i] : 表示深度: 规定根节点的深度为1, 第2层的深度为2, 第3层的距离为3. 其实也可发现, 深度就是到根节点的距离+ 1, 也是可以用DFS/ BFS来求

可以利用这两个数组来求LCA
步骤:
[1] 先将两个点跳到同一层(怎么做呢)
[2] 让两个点同时往上跳, 一直跳到他们的最近公共祖先的下一层

为什么跳到下一层呢? 因为这样好判断, f[a][k] = f[b][k]只能说明f[a][k] 和f[b][k]是a和b的公共祖先, 但不知道是不是最近的, 但是f[a][k] != f[b][k] 说明我们没有走到最近公共祖先上, 因此只能跳下一层, 用拼凑的思想, 直到k枚举完0为止, 枚举完f[a][k] 应该走到最近公共祖先的下一层, 那么f[x][0] 就是答案

[1] 基于2进制拼凑的思想,
已经有了 2 0 , 2 1 , 2 2 , . . . 2 k 2^0, 2^1, 2^2, ... 2^k 20,21,22,...2k 然后去拼凑t, 只要 t ≥ 2 k t \geq 2^k t≥2k, 那么说明第k位是1, 然后 t = t − 2 k t = t -2^k t=t−2k, 继续看接着拼凑
具体在树上, 先看x, y差了多少层, 差depth[x] - depth[y]
之前已经出来出来 f[i, j]中j所有可以跳的2^k步, 2^0, 2^1 …,
然后现在是想用2^0, 2^1 …,拼凑出来depth[x] - depth[y], 比方说我现在跳2^k还没有跳到y的上面的话, 那就可以继续跳, 以此类推, 从大到小推一遍, 用2^0, 2^1 …,拼凑出来depth[x] - depth[y]

1172. 祖孙询问

分析

先把树先构造出来, 然后把数预处理下, 预处理完后, 对于每个查询, 做步骤中的两部, 倍增找到最近公共祖先, 找完之后判断x与y的祖孙关系
时间复杂度O( (n + m)logn))

code

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

const int N = 40010, M = N * 2;

int n, m;
int h[N], e[M], ne[M], idx;
int depth[N], fa[N][16]; // 2^15 = 32768
int q[N];

void add(int a, int b){
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

void bfs(int root){
    memset(depth, 0x3f, sizeof depth);
    // 哨兵0
    depth[0] = 0, depth[root] = 1;
    int hh = 0, tt = 0;
    q[0] = root;
    
    while (hh <= tt){
        int t = q[hh ++ ];
        for (int i = h[t]; ~i; i = ne[i]){
            int j = e[i];
            if (depth[j] > depth[t] + 1){
                depth[j] = depth[t] + 1;
                q[ ++ tt] = j;
                fa[j][0] = t;
                for (int k = 1; k <= 15; k ++ )
                    fa[j][k] = fa[fa[j][k - 1]][k - 1];
            }
        }
    }
}

int lca(int a, int b){
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 15; k >= 0; k -- )
        if (depth[fa[a][k]] >= depth[b]) // 2进制拼凑, 哨兵的好处, 如果跳出了根节点的话, 那么depth[fa[a][k]] == 0, 但右边树中任何一个点深度 > 0, 所以if条件肯定不成立.
            a = fa[a][k];
    if (a == b) return a;
    
    for (int k = 15; k >= 0; k -- ) // 一起往上跳, 从可以跳到最远的为位置起跳
        // 类似2进制拼凑的思想, 当不相等, 就继续跳, 凑出最近的不相等的位置k
        if (fa[a][k] != fa[b][k]){ // 哨兵的好处, a与b此时在同一层, a跳出去, 那么b也跳出了, 不会进入if
            a = fa[a][k];
            b = fa[b][k];
        }
    return fa[a][0];
}

int main(){
    scanf("%d", &n);
    int root = 0;
    memset(h, -1, sizeof h);
    
    for (int i = 0; i < n; i ++ ){
        int a, b;
        scanf("%d%d", &a, &b);
        if (b == -1) root = a;
        else add(a, b), add(b, a);
    }
    
    bfs(root);// bfs计算depth 以及f数组, 记得要添加哨兵depth[0] = 0;
    
    scanf("%d", &m);
    
    while (m -- ){
        int a, b;
        scanf("%d%d", &a, &b);
        int p = lca(a, b);
        if (p == a) puts("1");
        else if (p == b) puts("2");
        else puts("0");
    }
    
    return 0;
}

在线做法

每读入一个询问, 立即输出答案, 再读入一个询问, 再输出

离线做法

必须先把所有询问统一读入, 统一计算完后, 统一输出

Tarjan—离线求LCA O(n + m)

在深度优先遍历的过程中, 将所有点分成3大类

  1. 已经遍历过的点, 且回溯过的点 (回溯过指dfs函数已经结束了)(绿色圈出来的点)
  2. 正在搜索的分支, 当前在递归栈中的点(红色边上的点)
  3. 还未搜索到的点(右边的点)
    比方说问x与绿色圈出来中的点的最近公共祖先, 可以合并到它的根节点当中.
    如下图示意:在这里插入图片描述

合并的话可以用并查集来做
遍历完当前x点之后, 可以扫描与x相关的询问, 如果与x相关的点已经被搜索且回溯过了, 那么得到这两个点的lca就是并查集中的代表元素

这样做的话, 发现每个点只会被遍历1次, 所有点只会被合并1次, 然后对于每个查询, 也只会被查询1次, 由于并查集合并和查询是O(1)的, 因此真个算法时间复杂度是线性的O(n + m)

1171. 距离

分析

在树上求两个点的长度, 连接树上两点只有1条路径.
d(x): x到根节点的距离
d(y): y到根节点的距离
p: x与y的最近公共祖先
因为d§被计算了两次, 剪掉就是两点的距离
在这里插入图片描述
因此, 此题的核心操作, 就是询问两个点的最近公共祖先是谁

code

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

typedef pair<int, int> PII;

const int N = 10010, M = N * 2;

int n, m;
int h[N], e[M], w[M], ne[M], idx;
int dist[N];
int p[N];
int res[M];
int st[N];
vector<PII> query[N]; // first存查询的另外一个点, second存查询编号

void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

void dfs(int u, int fa){
    for (int i = h[u]; ~i; i = ne[i]){
        int j = e[i];
        if (j == fa) continue;
        dist[j] = dist[u] + w[i];
        dfs(j, u);
    }
}

int find(int x){
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int tarjan(int u){
    st[u] = 1;
    for (int i = h[u]; ~i; i = ne[i]){// 遍历下和u相关的邻点, 递归tarjan
        int j = e[i];
        if (!st[j]){// 只有在右边没搜素的点才可以纳入搜索的范围
            tarjan(j);
            p[j] = u;// 遍历完后已经是绿色点, 合并到根节点u
        }
    }
    
    for (auto item : query[u]){
        int y = item.first, id = item.second;
        if (st[y] == 2){// 只有st[y]已经被标记成2才可以搜lca
            int anc = find(y);
            res[id] = dist[u] + dist[y] - dist[anc] * 2;
        }
    }
    
    st[u] = 2;// 当前u已经递归完成, 标记为2类点
}


int main(){
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    for (int i = 0; i < n - 1; i ++ ){
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        add(a, b, c), add(b, a, c);
    }
    
    for (int i = 0; i < m; i ++ ){
        int a, b;
        scanf("%d%d", &a, &b);
        if (a != b){
            query[a].push_back({b, i});
            query[b].push_back({a, i});
        }
    }
    
    for (int i = 1; i <= n; i ++ ) p[i] = i;
    
    dfs(1, -1); // 递归求下每个节点到根节点的距离
    tarjan(1);
    
    for (int i = 0; i < m; i ++ ) printf("%d\n", res[i]);
    
    return 0;
}

RMQ(区间求最值)

后面会讲
不是很常用, 比tarjan和倍增都要麻烦
在这里插入图片描述

356. 次小生成树

分析

取自嘿呀!大佬博客题解

  • 根据存在次小生成树与最小生成树只差一条边。
  • 我们可以先通过kruskal求出最小生成树 O(mlogm)
  • 通过这个树初始化某点到其他点的路径中最大边、次大边。 O(n2)
  • 遍历所有未在树中的边（u–>v）， 看是否大于u到v的边的最大值， 若大于那么可以替换这条边，若不大于那就再判断是否大于次值，若大于同理进行替换。
    在这里插入图片描述
  • 由于这里的n过于大， 那么n2 的O(mlogm + n2) 的复杂度就不行。 那么考虑优化一下查找u—>v的路径的最大值。可以通过lca进行优化。
  • 根据f[x][k] = f[f[x][k-1]][k-1]的递推。 我们可以类似求出d[x][k] = max(d[x][k - 1], d[f[x][k-1]][k - 1])
  • 在这里插入图片描述
  • 查询的时候我们是查询x–>y中路径的最大值、次大值。 那么可以在lca的查询中。查询x->lca那一段中的所有最大、次大，y到lca中所有的最大、次大， 最后从这些最大、次大里面选出最大、次大值即可。

联动题

  1. 秘密的牛奶运输

code

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010, M = 300010, INF = 0x3f3f3f3f;
typedef long long LL;
int h[N], e[M], w[M], ne[M], idx;
int q[N], depth[N];
int fa[N][17], d1[N][17], d2[N][17];
int n, m;
int p[N];

struct Edge{
    int a, b, w;
    bool used;
    bool operator< (const Edge &t){
        return w < t.w;
    }
}edge[M];

void add(int a, int b, int c){
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}

int find(int x){
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

LL kruskal(){
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    LL res = 0;
    sort(edge, edge + m);

    for (int i = 0; i < m; i ++ ){
        int a = find(edge[i].a), b = find(edge[i].b), w = edge[i].w;
        if (a != b){
            res += w;
            edge[i].used = 1;
            p[a] = b;
        }
    }
    return res;
}

void build(){// 建立最小生成树
    memset(h, -1, sizeof h);
    for (int i = 0; i < m; i ++ ){
        if (edge[i].used){
            int a = edge[i].a, b = edge[i].b, w = edge[i].w;
            add(a, b, w), add(b, a, w);
        }
    }
}

void bfs(){
    memset(depth, 0x3f, sizeof depth);
    int hh = 0, tt = 0;
    depth[0] = 0, depth[1] = 1;
    q[0] = 1;
    
    while (hh <= tt){
        int t = q[hh ++ ];
        for (int i = h[t]; ~i; i = ne[i]){
            int j = e[i];
            if (depth[j] > depth[t] + 1){
                depth[j] = depth[t] + 1;
                q[++ tt] = j;
                fa[j][0] = t;
                d1[j][0] = w[i], d2[j][0] = -INF;
                for (int k = 1; k <= 16; k ++ ){
                    int anc = fa[j][k - 1];
                    fa[j][k] = fa[anc][k - 1];
                    int distance[4] = {d1[j][k - 1], d2[j][k - 1], d1[anc][k - 1], d2[anc][k - 1]};
                    d1[j][k] = d2[j][k] = -INF;
                    for (int u = 0; u < 4; u ++ ){
                        int d = distance[u];
                        if (d > d1[j][k]) d2[j][k] = d1[j][k], d1[j][k] = d;
                        else if (d != d1[j][k] && d > d2[j][k]) d2[j][k] = d;
                    }
                }
            }
        }
    }
}

int lca(int a, int b, int w){
    static int distance[N * 2];
    int cnt = 0;
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 16; k >= 0; k -- ) // a往上跳, 往上条前, 记录距离
        if (depth[fa[a][k]] >= depth[b]){
            distance[cnt ++] = d1[a][k];
            distance[cnt ++] = d2[a][k];
            a = fa[a][k];
        }
        
    if (a != b)
    { // a, b同时往上条, 也记录距离
        for (int k = 16; k >= 0; k -- )
            if (fa[a][k] != fa[b][k])
            {
                distance[cnt ++ ] = d1[a][k];
                distance[cnt ++ ] = d2[a][k];
                distance[cnt ++ ] = d1[b][k];
                distance[cnt ++ ] = d2[b][k];
                a = fa[a][k], b = fa[b][k];
            }
        distance[cnt ++ ] = d1[a][0];// 到lca只有1条边了, 因此只用添加当前的最大边
        distance[cnt ++ ] = d1[b][0];
    }

    int dist1 = -INF, dist2 = -INF;
    for (int i = 0; i < cnt; i ++ )
    {
        int d = distance[i];
        if (d > dist1) dist2 = dist1, dist1 = d;
        else if (d != dist1 && d > dist2) dist2 = d;
    }

    if (w > dist1) return w - dist1;
    if (w > dist2) return w - dist2;
    return INF;
}




int main(){
    scanf("%d%d", &n, &m);
    for (int i = 0; i < m; i ++ ){
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edge[i] = {a, b, w};
    }
    


    LL sum = kruskal();
    
    build();
    
    bfs(); // 不熟悉
    
    LL res = 1e18;
    
    for (int i = 0; i < m; i ++ ){
        int a = edge[i].a, b = edge[i].b, w = edge[i].w;
        res = min(res, sum + lca(a, b, w)); // lca函数不熟悉
    }
    
    printf("%lld\n", res);
    
    return 0;
}

352. 闇の連鎖

分析

Dark 有N-1条边, 并且任意两个节点之间都存在一条由主要边构成的路径->告诉我们是一棵树
只能砍2次, 第1次只能看树边, 第2次只能砍非树边, 问有多少种方案能使得图不连通

如果只是一棵树的话, 任意去掉树边, 就可以变得不连通.
但是有非树边的话, 除了砍掉非树边(红色), 还要砍下 非树边连接的两点之间的树边(绿色)

在这里插入图片描述
如果再有一条非树边, 那么要需要砍

对于非树边构成的环上的每条树边来说, 如果要砍树边, 要使得图不连通的话, 还要砍对应的非树边

因此可以枚举非树边(红边), 将非树边构成的环上的树边(绿边)都 +1, 表示砍了非树边(红边)之后, 还想要图不连通的话, 还需要多砍1条边
在枚举完非树边(红边)之后, 再遍历下原来的树, 看下每条边上标的数字是几, 表示砍完非树边以后, 还需要额外砍几条树边

假如当前树边值为c = 0, 那么可以砍任何一条非树边都可以使得图不连通, 因此ans + m
c = 1, 表示砍了这条树边, 还需要砍1条非树边, 因此必须砍非树边, 只有1种方案, ans + 1
c > 1, 表示砍了这条树边, 还需要砍c条非树边, 但是只能砍1条, 因此无论如何都不能使得图不连通, 因此答案+0

核心问题:

如何快速的给树上的每一条边增加一个数, 以及快速的求出来每条边上的值是多少

类似基础课中的差分, 差分可以快速O(1)的给某一段+相同值, 然后用O(n)求出每个数是多少

在这里插入图片描述
最终每个值就是差分的前缀和

树上的差分

假设想给x到y的路径上每条边+c
x, y, c
d(x) += c
d(y) += c
d§ -= 2c
最终每个点的值是以这个点为根的子树里的所有点的和, 就表示这个点和它父节点之间边上的值
举个例子:
对于子树外的任何一部个部分, +2c, -2c没有任何变化

(因为子树外的任何边的目的地作为更节点构成的子树, 一定包含p, x, y, 因此必定+c, +c , -2c)

对于树内的影响, 角落内红色的子树, 不影响, 因为那些子树上不包含x, y, p
因此只对图中红色边有影响
在这里插入图片描述
所以以上等式, 只对x, y路径上的边权+c

题目再分析

回到原问题, 先求下非树边x, y的最近公共祖先p, 然后让d(x) += c, d(y) += c, d§ -=2c, 然后遍历下整棵树, 求下每颗子树的总权值之和是多少
对于所有权值之和为0的, +m
1的, +1
> 1的, 不用管
注意下, 根节点是没有对应任何一条非树边的, 所以根节点不用管

因为根节点的两条边都是树边啊啊~~~

code

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

const int N = 100010, M = N * 2;

int n, m;
int h[N], e[M], ne[M], idx;
int depth[N], fa[N][17];
int d[N];// 树上点的值
int q[N];
int ans;

void add(int a, int b){
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

void bfs(){
    memset(depth, 0x3f, sizeof depth);
    int hh = 0, tt = 0;
    depth[0] = 0, depth[1] = 1;
    q[0] = 1;
    
    while (hh <= tt){
        int t = q[hh ++ ];
        for (int i = h[t]; ~i; i = ne[i]){
            int j = e[i];
            if (depth[j] > depth[t] + 1){
                depth[j] = depth[t] + 1;
                q[++ tt] = j;
                fa[j][0] = t;
                for (int k = 1; k <= 16; k ++ ){
                    fa[j][k] = fa[fa[j][k - 1]][k - 1];
                }
            }
        }
    }
    
}

int lca(int a, int b){
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 16; k >= 0; k -- )
        if (depth[fa[a][k]] >= depth[b]) // >= , 而不是>
            a = fa[a][k];
            
    if (a == b) return a;
    
    for (int k = 16; k >= 0; k -- )
        if (fa[a][k] != fa[b][k])
            a = fa[a][k], b = fa[b][k];
            
    return fa[a][0];
}

int dfs(int u, int father){ // 返回以u为根节点的所有子树上边权值之和
    int res = d[u];
    for (int i = h[u]; ~i; i = ne[i]){
        int j = e[i];
        if (j != father) {
            int s = dfs(j, u);
            if (s == 0) ans += m;
            else if (s == 1) ans += 1;
            res += s;
        }
    }
    return res;
}

int main(){
    scanf("%d%d", &n, &m);
    memset(h, -1, sizeof h);
    
    for (int i = 0; i < n - 1; i ++ ){
        int a, b;
        scanf("%d%d", &a, &b);
        add(a, b), add(b, a);
    }
    bfs(); // 做lca前的预备, depth计算 fa计算
    
    for (int i = 0; i < m; i ++ ){ // 不能while (m -- ), 因为dfs中还要用到m
        int a, b;
        scanf("%d%d", &a, &b);
        int p = lca(a, b);
        d[a] ++, d[b] ++ , d[p] -= 2; // 差分
    }
    
    // exit(0);
    dfs(1, -1);
    
    printf("%d\n", ans);
    
    return 0;
}
打雷要下雨，雷欧
关注
专栏目录
LCA(最近公共祖先)
qq_43597036的博客
04-16 522
LCA(最近公共祖先) 1.倍增法（在线算法） 2.Tarjan（离线算法） 一、倍增法 1、 算法过程： 1.预处理出 fa[i,j] ,和 depth[i] 。( fa[i,j] 表示从i这个点向上跳2j到达的点，depth[i] 表示这个点在这课有根树中的深度，同时要将 depth[0] 设置为0，方便代码的书写)。 2.先将两个点跳到同一个深度。 3.让两个点同时向上跳，直到两个点跳到其最近公共最先的下一层。（如果跳到同一层的话，不能确定是否是最近的）。 4.输出fa[当前点][0]即为最近公共祖
3.6.Git原理之二叉树的最近公共祖先
m0_38057941的博客
08-07 202
236. 二叉树的最近公共祖先 1.题目分析 1.可以考虑递归的方式，考虑3种情况： 情况1：p、q存在于以node为根的树中，则返回node； 情况2：p、q都不在以node为根的树中，则返回null； 情况3：p、q只有1个存在于以node为根的树中，则返回p、q中存在的那个； 算法使用了后序遍历：所以是一种自底向上的遍历方法，可以保证p、q第一次会合的地方就是最近公共祖先。 2.代码 class Solution { public TreeNode lowestCommonAncesto
二叉树的最近公共祖先
m0_46388866的博客
02-17 226
二叉树的最近公共祖先 (labuladong算法小抄3.6总结) 这个问题需要知道就是p点和q点所在的位置。然后再根据这两个点的位置，来寻找他们最近的交叉点，也就是最近的公共祖先的位置。其实本质上还是一个树的遍历问题。但是不同的是它需要处理的情况比较多，代码不难，难的地方在于怎么找到这个交叉点。 首先来思考一下，既然想要找到p和q的最近公共祖先，那么先要找到这两个点。然后找到两个点之后就需要通知上一层的树，告诉他我找到了这个点了，并且把本节点返回去了作为公共祖先的可能候选点。 但实际上细分就是会有三种情况：
3.3-3.6二叉树专题
weixin_50340097的博客
08-23 420
遍历BST，找到合适的位置:从root节点开始，按照左小右大的规则找位置，我们为了简化问题，就不做那种从已有节点中强行插入的操作了，我们要的最终效果是找到一个空的位置，按照规则将节点连接上就好了。或许可能会问，诶这个右子树中的任意一个节点不是也比左子树的所有节点都要大吗，那我在右边瞎选一个就不行吗，注意，这里要求的是两个同时成立，万一你选出来的这个节点比右子树的一个节点要大咋办?给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的 key 对应的节点，并保证二叉搜索树的性质不变。
3.6 Git 分支 - 分支的衍合
GarfieldEr007的专栏
03-08 943
分支的衍合 把一个分支中的修改整合到另一个分支的办法有两种：merge 和 rebase（译注：rebase 的翻译暂定为“衍合”，大家知道就可以了。）。在本章我们会学习什么是衍合，如何使用衍合，为什么衍合操作如此富有魅力，以及我们应该在什么情况下使用衍合。 基本的衍合操作 请回顾之前有关合并的一节（见图 3-27），你会看到开发进程分叉到两个不同分支，又各自提交了更新。
Git 分支---3.6分支的衍合
snowsnowsnow1991的博客
06-05 394
转载于http://www.open-open.com/lib/view/open1328069889514.html 3.6  分支的衍合 把一个分支整合到另一个分支的办法有两种：merge 和 rebase（译注：rebase 的翻译暂定为“衍合”，大家知道就可以了。）。在本章我们会学习什么是衍合，如何使用衍合，为什么衍合操作如此富有魅力，以及我们应该在什么情况下使用衍合。 基本的衍合操
【每日刷题3.5/3.6】20道算法+10道面试 - 阿V
weixin_46554635的博客
03-06 748
梦想成为拿到大厂offer，成为一名游戏开发大牛，目标岗位：游戏研发设计师。
自学算法竞赛笔记
最新发布
fry_rice_at_pub的博客
05-13 681
思路2：DP 状态转移方程：a[x][y]+=max(a[x+1][y],a[x+1][y+1]) 备份数组+当前点下行方向数组。思路1：记忆化搜索+DFS，从下到上累加和可以重复使用。
算法训练——二叉树算法
庄小焱
01-29 615
本博文将详细的介绍有关于二叉树算法的问题。帮助大家能够对二叉树的问题有一个清晰的了解和学习，帮助大家在面试过程中遇到二叉树问题提供一个可以参考的思路。
cat0501#Java_notes#公共祖先2
07-25
3.6 Git 原理之二叉树最近公共祖先本文对应的力扣题目：236.二叉树的最近公共祖先// 情况 1// 情况 2// 情况 3return left ==
算法刷题提高阶段-图论9
12-24
以3.6 最近公共祖先.mp4为例，视频可能详细讲解了如何利用DFS进行最近公共祖先的求解。首先，我们可以从根节点开始，对树进行一次深度优先遍历，同时记录下每个节点到根节点的路径信息。在遍历过程中，当遇到节点u和...
2023年前端面试汇总-React
越陌度阡
06-29 910
React并不是将click事件绑定到了div的真实DOM上，而是在document处监听了所有的事件，当事件发生并且冒泡到document处的时候，React将事件内容封装并交由真正的处理函数运行。这样的方式不仅仅减少了内存的消耗，还能在组件挂在销毁时统一订阅和移除事件。除此之外，冒泡到document上的事件也不是原生的浏览器事件，而是由react自己实现的合成事件（SyntheticEvent）。因此如果不想要是事件冒泡的话应该调用event.preventDefault()方法，而不是调用event
3.3.1 最小生成树的典型应用
esjiang的博客
03-07 4934
命题: Kruskal算法的正确性 证明: 假设不选择“Prim选择的边”, 即选择了红色虚线的边, 那么我们再连接“Prim算法选择的边”, 可以构成环, 然后再删掉红色虚线边, 一定可以使树中权值之和减小, 与当前选择是权值和最小的方案, 矛盾.(因为prim算法计算加边的时候, 保证了选择的边权最小) ...
3.7 有向图的强连通分量
esjiang的博客
03-14 1034
连通分量 对于一个有向图, 连通分量: 对于分量中任意u, v, 必然可以从u走到v, 也可以从v走到u 强(极大)连通分量 极大连通分量. 如果连通分量加上任何一个点之后, 都不是连通分量了, 那么称这个连通分量为极大连通分量(强连通分量) 强连通分量的用途 可以把任意一个有向图, 转化称一个有向无环图. 有向图 —>缩点(将所有连通分量缩成一个点)–> 有向无环图(DAG)(拓扑图) 有向无环图/拓扑图的好处: 求最短路/最长路的时候, 可以按照顺序递推O(n + m) 一般先去求下这个图
3.4 SPFA找负环
esjiang的博客
03-08 598
负环 有向图或者无向图中, 存在环路, 使得一圈的权值之和 < 0, 称为负环 负环为什么要单独处理, 比如最短路中, 如果一个点能走到负环上, 那么就能在这个点上转无穷多次, 每转1次, 距离就会小一点, 因此图形中, 某些点的最短路就会变成−∞-\infty−∞, 会影响最短路算法的正确性 求负环的常用方法, 基于SPFA (1) : 统计每个点入队的次数, 如果某个点入队n次, 说明存在负环 实际上就是bellman-ford算法: bellman-ford算法说迭代n次, 还有点被更新的话,
2.1.3 BFS中的双向广搜和A-star
esjiang的博客
02-24 285
AcWing 190. 字串变换 注意，扩展节点的时候一定要扩展一层 A* 证明：A*算法的正确性
2.2.3 DFS之迭代加深、双向DFS、IDA*
esjiang的博客
02-25 262
#kong
3.1.1 单源最短路的建图方式
esjiang的博客
02-27 259
单源最短路的一些算法 {边权非负{朴素Dijkstra堆优化Dijkstra有负权边{Bellman−Ford（用的情况少）spfa（99%情况用这种算法） \left\{ \begin{matrix}边权非负\left\{\begin{matrix} 朴素Dijkstra \\ 堆优化Dijkstra \end{matrix}\right.\\ 有负权边\left\{\begin{matrix} Bellman-Ford （用的情况少）\\ spfa （99\%情况用这种算法）
3.3.2 最小生成树的扩展应用
esjiang的博客
03-07 254
回顾下最小生成树的理论基础 解释 假设选蓝色箭头的边, 再连上红色边, 因为红色边权 <= 蓝色边, 因此可以去掉蓝色边, 连接红色边, 边权之和会减小 解释 当前已经有一些连通块, 那么连通块之间的最短边, 一定在生成树里 假设连接两个连通块权值最小的边, 左右两个点已经在某个连通块里, 此时如果不选最小的边, 由于这两个了连通块最终会被连通, 被其他路径连通, 因此在其他路径上一定存在边权>= 最小边的边, 因此去掉下面的蓝色边, 加入上面的蓝色边, 边权之和会减小, 不影响连通
Lucene 3.6 索引格式详解
"本文档详细介绍了lucene3.6中的索引结构，包括各个部分与硬盘上文件夹中对应文件的关系，以及作者多年学术和编程经验的总结。" 在Lucene 3.6版本中，索引格式是其核心组成部分，它负责高效地存储和检索文本数据。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值