树链剖分 学习指南

最新推荐文章于 2023-10-31 19:01:34 发布
最新推荐文章于 2023-10-31 19:01:34 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： 学习资料
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyendra/article/details/38366827
版权

什么是树链剖分

树链剖分并不是一个复杂的算法或者数据结构，它能把一棵树拆成链。

树链，就是树上的路径。剖分，就是把路径分类为重链和轻链。

给定一棵树，将它划分成若干条互不相交的路径，满足：从节点 u->v 最多经过 logn 条路径以及 logn 条不在路径上的边。

树链剖分后，我们就可以利用其它的数据结构对在一棵树上进行路径的修改、求极值、求和的一类问题进行求解了。


一些定义

重儿子：以结点的一个儿子为根的子树的结点个数中最大的那一个儿子称为重儿子。

轻儿子：除了重儿子以外的儿子。

重边：结点与其重儿子的边称为重边。

轻边：结点与其轻儿子的边称为轻边。

重链：由重边组成的路径。

轻链：由轻边组成的路径。


描述剖分后的树

描述结点:

siz[v]：以结点v为根的子树的结点个数

dep[v]：结点v的深度，定义根结点的深度为0

fa[v]：结点v的父亲结点


描述结点与路径之间的关系:

belong[v]：结点v所属的路径编号

idx[v]：结点v在其路径中的编号

son[v]：结点v的重儿子


描述路径：

top[p]：编号为p的路径的顶端结点

len[p]：路径p的长度


描述辅助数据结构：

sump[p]：路径p的编号

seg[v]：结点v的父边在线段树中的位置

wei[v]：结点v的父边的权值


剖分后的性质

如果 (u,v) 为轻边，则 siz[v] * 2 < siz[u]，即以轻儿子为根的子树中的结点数量相对少。

从根到某一点的路径上轻链、重链的个数都不大于 logn。


树链剖分的实现

首先用一次搜索求出 dep、fa、wei 的值，深搜广搜都可以，但是深搜容易爆栈，这里使用广搜。

在广搜的过程中得到了树的拓扑序，我们按照拓扑序的逆序遍历所有的结点。

在这个过程中可以求出 siz 与 son。

对于一个结点，如果它是叶子结点，那么我们就新建一条链，使该结点作为链上的第一个结点；

如果不是叶子结点，那么它与它的重儿子属于同一条链，对链进行更新即可。

void split(){
    memset(dep,-1,sizeof(dep));
    l=0;
    dep[ que[r=1]=1 ]=0; // 将根结点插入队列，并设深度为0
    fa[1]=-1; // 默认 1 为根结点
    wei[1]=0;
    while (l<r){ // 第一遍搜索求出 fa,dep,wei
        int u=que[++l];
        vis[u]=false; // 顺便初始化vis
        for (int i=head[u];i!=-1;i=edges[i].next){
            int v=edges[i].to;
            int w=edges[i].w;
            if (dep[v]==-1){ // 未访问过的结点
                dep[ que[++r]=v ]=dep[u]+1; // 将v插入队列并设深度为dep[u]+1
                fa[v]=u; // v的父结点为u
                wei[v]=w; // v的父边权值
            }
        }
    }
    cnt=0; // 重链编号
    for (int i=n;i>0;i--){
        int u=que[i],p=-1;
        siz[u]=1;
        son[u]=p;
        for (int k=head[u];k!=-1;k=edges[k].next){
            int v=edges[k].to;
            if (vis[v]){ // 若v是u的子结点
                siz[u]+=siz[v]; // 计数
                if (p==-1||siz[v]>siz[p]){
                    son[u]=v;
                    p=v; // u的重儿子是v
                }
            }
        }
        if (p==-1){ // u是叶子结点
            idx[u]=len[++cnt]=1; // 一个新的路径编号为cnt，u是路径中的第一个结点
            belong[ top[cnt]=u ]=cnt; // u是顶端结点，且u属于路径cnt
        }
        else{ // u不是叶子结点
            idx[u]=++len[ belong[u]=belong[p] ]; // u属于重儿子所在的链，链长+1，u是路径中第len个结点
            top[ belong[u] ]=u; // u是顶端结点
        }
        vis[u]=true; // 访问标记
    }
}

路径上的求和、求极值操作

我们对树上的边进行编号，编号对应着该边在线段树上的位置，保证同一个重链上的所有点的父边的编号是连续的即可。

这样我们就可以通过对线段树进行区间操作来快速的修改同一条重链上的权值了。

如图所示：


如何快速的处理任意两个结点 (va,vb) 间的边呢。

我们设 f1=top[belong[va]]，f2=top[belong[vb]]。表示 f1 是 va 所属的链上的最顶端的点， f2 是 vb 所属的链上的最顶端的点。

当 f1 != f2 时，若 dep[f1] >= dep[f2]，那么就处理 va 的父边到 f1 父边的路径，由于它们属于同一条重链的父边，编号是连续的，因此可以用线段树进行区间处理，最后使 va = fa[f1]，重复进行该步骤直到 f1=f2。

当 f1 = f2 时，va 与 vb 在同一条重链上，若 va 与 vb 不是同一点，就区间处理 va 到 vb 路径上的边，否则修改完成。

查询操作与修改操作是类似的。

例如要查找两个结点间路径上的权值最大的边：

int find(int va,int vb){
    int f1=top[belong[va]],f2=top[belong[vb]],tmp=0;
    while (f1!=f2){
        if (dep[f1]<dep[f2]){
            swap(f1,f2);
            swap(va,vb);
        }
        tmp=max(tmp,tr.query(1,seg[f1],seg[va]));
        va=fa[f1];
        f1=top[belong[va]];
    }
    if (va==vb) return tmp;
    if (dep[va]>dep[vb]) swap(va,vb);
    return max(tmp,tr.query(1,seg[son[va]],seg[vb]));
}


相关练习题

SPOJ 375. Query on a tree

题目给出一棵含有n个结点的树，n-1条边每条边都有边权，有两种操作，修改第i条边的边权，查询两个结点的路径上最大的边权。

首先进行树链剖分，对边进行编号，建立线段树储存权值。

对于修改操作，我们找到该边在线段树上的位置然后单点更新即可。

对于查询操作，利用重链上的父边编号相同这一性质不断进行区间查询，就能快速找到最大的边权。


POJ 3237 Tree

与上一题相比多了一种操作，将两个结点间的边权取负。

用线段树维护两个值，区间上的最小值与最大值。区间取负时将最大值最小值取负后交换，打上延迟标记。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxn=101010+5;
const int maxm=maxn+maxn;

struct EDGENODE{
    int to;
    int w;
    int next;
}edges[maxm];
int head[maxn],edge;
inline void init(){
    edge=0;
    memset(head,-1,sizeof(head));
}
inline void addedge(int u,int v,int w){
    edges[edge].w=w,edges[edge].to=v,edges[edge].next=head[u],head[u]=edge++;
    edges[edge].w=w,edges[edge].to=u,edges[edge].next=head[v],head[v]=edge++;
}
int que[maxn]; // 队列
bool vis[maxn]; // 访问标记
int son[maxn]; // 重儿子
int idx[maxn]; // 结点v在其路径中的编号
int dep[maxn]; // 结点v的深度
int siz[maxn]; // 以结点v为根的子树的结点个数
int belong[maxn]; // 结点v所属的路径编号
int fa[maxn]; // 结点v的父亲结点
int top[maxn]; // 编号为p的路径的顶端结点
int len[maxn]; // 路径p的长度
int sump[maxn]; // 路径p的编号
int seg[maxn]; // 结点v的父边在线段树中的位置
int wei[maxn]; // 结点v的父边的权值
int l,r,ans,cnt;
int n;
char cmd[22];

void split(){
    memset(dep,-1,sizeof(dep));
    l=0;
    dep[ que[r=1]=1 ]=0; // 将根结点插入队列，并设深度为0
    fa[1]=-1; // 默认 1 为根结点
    wei[1]=0;
    while (l<r){ // 第一遍搜索求出 fa,dep,wei
        int u=que[++l];
        vis[u]=false; // 顺便初始化vis
        for (int i=head[u];i!=-1;i=edges[i].next){
            int v=edges[i].to;
            int w=edges[i].w;
            if (dep[v]==-1){ // 未访问过的结点
                dep[ que[++r]=v ]=dep[u]+1; // 将v插入队列并设深度为dep[u]+1
                fa[v]=u; // v的父结点为u
                wei[v]=w; // v的父边权值
            }
        }
    }
    cnt=0; // 重链编号
    for (int i=n;i>0;i--){
        int u=que[i],p=-1;
        siz[u]=1;
        son[u]=p;
        for (int k=head[u];k!=-1;k=edges[k].next){
            int v=edges[k].to;
            if (vis[v]){ // 若v是u的子结点
                siz[u]+=siz[v]; // 计数
                if (p==-1||siz[v]>siz[p]){
                    son[u]=v;
                    p=v; // u的重儿子是v
                }
            }
        }
        if (p==-1){ // u是叶子结点
            idx[u]=len[++cnt]=1; // 一个新的路径编号为cnt，u是路径中的第一个结点
            belong[ top[cnt]=u ]=cnt; // u是顶端结点，且u属于路径cnt
        }
        else{ // u不是叶子结点
            idx[u]=++len[ belong[u]=belong[p] ]; // u属于重儿子所在的链，链长+1，u是路径中第len个结点
            top[ belong[u] ]=u; // u是顶端结点
        }
        vis[u]=true; // 访问标记
    }
}
const int INF=0x3fffffff;
struct SegmentTree{
    int num[maxn];
    struct Tree{
        int l;
        int r;
        int max;
        int min;
        bool neg;
    };
    Tree tree[maxn*4];
    void push_down(int root){
        if (tree[root].neg){
            if (tree[root].l!=tree[root].r){
                tree[root<<1].neg^=1;
                tree[root<<1|1].neg^=1;
                swap(tree[root<<1].max,tree[root<<1].min);
                swap(tree[root<<1|1].max,tree[root<<1|1].min);
                tree[root<<1].max*=-1;
                tree[root<<1].min*=-1;
                tree[root<<1|1].max*=-1;
                tree[root<<1|1].min*=-1;
            }
        }
        tree[root].neg=0;
    }
    void push_up(int root){
        tree[root].max=max(tree[root<<1].max,tree[root<<1|1].max);
        tree[root].min=min(tree[root<<1].min,tree[root<<1|1].min);
    }
    void build(int root,int l,int r){
        tree[root].l=l;
        tree[root].r=r;
        tree[root].neg=0;
        if(tree[root].l==tree[root].r){
            tree[root].max=num[l];
            tree[root].min=num[l];
            tree[root].neg=0;
            return;
        }
        int mid=(l+r)/2;
        build(root<<1,l,mid);
        build(root<<1|1,mid+1,r);
        push_up(root);
    }
    void update(int root,int pos,int val){
        if(tree[root].l==tree[root].r){
            tree[root].max=val;
            tree[root].min=val;
            return;
        }
        push_down(root);
        int mid=(tree[root].l+tree[root].r)/2;
        if(pos<=mid) update(root<<1,pos,val);
        else update(root<<1|1,pos,val);
        push_up(root);
    }
    int query(int root,int L,int R){
        if(L<=tree[root].l&&R>=tree[root].r) return tree[root].max;
        push_down(root);
        int mid=(tree[root].l+tree[root].r)/2,ret=-INF;
        if(L<=mid) ret=max(ret,query(root<<1,L,R));
        if(R>mid) ret=max(ret,query(root<<1|1,L,R));
        push_up(root);
        return ret;
    }
    void nega(int root,int L,int R){
        if (L<=tree[root].l&&R>=tree[root].r){
            tree[root].neg^=1;
            swap(tree[root].max,tree[root].min);
            tree[root].max*=-1;
            tree[root].min*=-1;
            return;
        }
        push_down(root);
        int mid=(tree[root].l+tree[root].r)/2;
        if (L<=mid) nega(root<<1,L,R);
        if (R>mid) nega(root<<1|1,L,R);
        push_up(root);
    }
    void debug(int root){
        printf("rt=%d, [%d~%d], min=%d, max=%d, neg=%d\n",root,tree[root].l,tree[root].r,tree[root].min,tree[root].max,(int)tree[root].neg);
        if (tree[root].l==tree[root].r) return;
        debug(root<<1);
        debug(root<<1|1);
    }
}tr;

int find(int va,int vb){
    int f1=top[belong[va]],f2=top[belong[vb]],tmp=-INF;
    while (f1!=f2){
        if (dep[f1]<dep[f2]){
            swap(f1,f2);
            swap(va,vb);
        }
        tmp=max(tmp,tr.query(1,seg[f1],seg[va]));
        va=fa[f1];
        f1=top[belong[va]];
    }
    if (va==vb) return tmp;
    if (dep[va]>dep[vb]) swap(va,vb);
    return max(tmp,tr.query(1,seg[son[va]],seg[vb]));
}
void gao(int va,int vb){
    int f1=top[belong[va]],f2=top[belong[vb]];
    while (f1!=f2){
        if (dep[f1]<dep[f2]){
            swap(f1,f2);
            swap(va,vb);
        }
        tr.nega(1,seg[f1],seg[va]);
        va=fa[f1];
        f1=top[belong[va]];
    }
    if (va==vb) return;
    if (dep[va]>dep[vb]) swap(va,vb);
    tr.nega(1,seg[son[va]],seg[vb]);
}
int d[maxn][3];

int main()
{
    int T;
    scanf("%d",&T);
    while (T--){
        init();
        scanf("%d",&n);
        for (int i=1;i<n;i++){
            int a,b,c;
            scanf("%d%d%d",&a,&b,&c);
            d[i][0]=a;
            d[i][1]=b;
            d[i][2]=c;
            addedge(a,b,c);
        }
        split();
        sump[0]=0;
        for (int i=1;i<=cnt;i++) sump[i]=sump[i-1]+len[i];
        for (int i=1;i<=n;i++){
            seg[i]=sump[ belong[i] ]-idx[i]+1;
            tr.num[ seg[i] ]=wei[i];
        }
        tr.build(1,1,n);
        while (scanf("%s",cmd)){
            if (cmd[0]=='D') break;
            int x,y;
            scanf("%d%d",&x,&y);
            if (cmd[0]=='Q'){
                printf("%d\n",find(x,y));
            }
            if (cmd[0]=='C'){
                if (fa[d[x][1]]==d[x][0]) tr.update(1,seg[d[x][1]],y);
                else tr.update(1,seg[d[x][0]],y);
            }
            if (cmd[0]=='N'){
                gao(x,y);
            }
        }
    }
    return 0;
}

/**
1
10
1 2 1
2 3 3
3 4 8
4 5 -6
5 6 -9
6 7 -1
7 8 1
8 9 7
9 10 6
NEGATE 1 8
CHANGE 2 7
QUERY 1 3
NEGATE 1 5
CHANGE 4 7
QUERY 3 5
DONE

3
10
1 2 1
2 3 7
3 4 8
4 5 6
5 6 9
6 7 1
7 8 1
8 9 7
9 10 6
NEGATE 4 7
CHANGE 2 3
QUERY 2 9
CHANGE 2 3
QUERY 6 8
NEGATE 1 8
CHANGE 2 7
QUERY 1 3
NEGATE 1 5
CHANGE 4 7
QUERY 3 5
DONE
6
1 2 1
2 3 2
3 4 4
4 5 100
5 6 -1000
QUERY 1 2
CHANGE 1 3
QUERY 1 2
NEGATE 1 2
QUERY 1 3
QUERY 1 2
CHANGE 1 10
QUERY 1 3
NEGATE 1 2
QUERY 1 3
CHANGE 1 10
CHANGE 2 20
QUERY 1 3
NEGATE 1 2
QUERY 1 3
NEGATE 2 3
QUERY 1 3
CHANGE 1 -100
CHANGE 2 -1000
QUERY 1 4
NEGATE 1 6
QUERY 1 6
DONE
100
1 2 265
2 3 133
3 4 508
4 5 197
5 6 437
6 7 849
7 8 577
8 9 503
9 10 478
10 11 434
11 12 877
12 13 691
13 14 54
14 15 295
15 16 421
16 17 166
17 18 550
18 19 410
19 20 868
20 21 476
21 22 283
22 23 410
23 24 915
24 25 308
25 26 301
26 27 553
27 28 609
28 29 733
29 30 770
30 31 635
31 32 581
32 33 753
33 34 707
34 35 448
35 36 738
36 37 841
37 38 389
38 39 532
39 40 210
40 41 458
41 42 595
42 43 989
43 44 678
44 45 214
45 46 746
46 47 548
47 48 117
48 49 758
49 50 437
50 51 840
51 52 555
52 53 726
53 54 490
54 55 719
55 56 403
56 57 329
57 58 92
58 59 311
59 60 664
60 61 207
61 62 170
62 63 548
63 64 713
64 65 556
65 66 705
66 67 82
67 68 508
68 69 59
69 70 45
70 71 670
71 72 540
72 73 826
73 74 262
74 75 504
75 76 989
76 77 408
77 78 896
78 79 388
79 80 15
80 81 485
81 82 219
82 83 977
83 84 641
84 85 985
85 86 189
86 87 64
87 88 641
88 89 320
89 90 788
90 91 441
91 92 785
92 93 163
93 94 153
94 95 852
95 96 36
96 97 10
97 98 145
98 99 956
99 100 641
QUERY 32 69
NEGATE 1 22
CHANGE 40 53
QUERY 17 38
NEGATE 17 65
CHANGE 49 68
QUERY 44 52
NEGATE 11 53
CHANGE 9 68
QUERY 2 49
NEGATE 25 45
CHANGE 23 67
QUERY 89 90
NEGATE 5 37
CHANGE 27 53
QUERY 22 86
NEGATE 6 7
CHANGE 17 23
QUERY 78 93
NEGATE 30 63
CHANGE 56 99
QUERY 3 29
NEGATE 24 38
CHANGE 9 95
QUERY 63 66
NEGATE 69 92
CHANGE 9 91
QUERY 7 27
NEGATE 32 60
CHANGE 48 77
QUERY 47 94
NEGATE 14 27
CHANGE 50 99
QUERY 38 97
NEGATE 11 67
CHANGE 74 83
QUERY 28 81
NEGATE 13 53
CHANGE 55 88
QUERY 2 66
NEGATE 71 95
CHANGE 32 74
QUERY 14 50
NEGATE 1 28
CHANGE 16 80
QUERY 36 75
NEGATE 20 49
CHANGE 22 54
QUERY 5 46
NEGATE 12 37
CHANGE 61 94
QUERY 18 92
NEGATE 19 26
CHANGE 6 94
QUERY 33 60
NEGATE 79 87
CHANGE 30 75
QUERY 55 94
NEGATE 28 79
CHANGE 23 31
QUERY 91 95
NEGATE 28 76
CHANGE 8 41
QUERY 6 25
NEGATE 19 70
CHANGE 17 54
QUERY 52 66
NEGATE 4 95
CHANGE 19 52
QUERY 73 87
DONE


**/








cyendra
关注
专栏目录
深度学习系列资料总结
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
07-17 2万+
说明本系列深度学习资料集合包含机器学习、深度学习等各系列教程，主要以计算机视觉资料为主，包括图像识别、分类、检测、分割等，内容参考Github及网络资源，仅供个人学习。深度学习定义一般是指通过训练多层网络结构对未知数据进行分类或回归深度学习分类有监督学习方法——深度前馈网络、卷积神经网络、循环神经网络等；无监督学习方法——深度信念网、深度玻尔兹曼机，深度自编码器等。手写机器学习笔记github机器学习算法公式推导以及numpy实现github人工智能相关术语link。..................
机器学习（1）——Python数据处理与绘图
WHJ226的博客
06-14 4912
目录1 numpy数组使用1.1 numpy生成数组1.2 numpy数组属性1.3 数组的索引和切片1.4 numpy数组运算2 scipy包的使用2.1 scipy包中的模块2.2 常数模块的使用2.3 特殊函数模块的使用2.4 信号处理模块2.5 空间结构模块3 pandas包的使用3.1 pandas数组3.2 查看数据3.3 pandas读取文件4 matplotlib包的使用4.1 正余弦曲线4.2 一张图中的不同曲线 4.3 三维曲线图4.4 其他类型曲线Python具有强大的数据处理能力，
树链剖分（复习+代码解释）
gyp0205的博客
11-28 142
将树上的链通过dfs序映射成一个区间，显然一个子树对应一个连续区间，一条重链对应一个连续区间，一条链可以被分成不超过logn个区间，通过用数据结构（如线段树）维护这些区间可以实现nlogn的维护这些树链 树上操作 #include <iostream> #include <algorithm> #include <fstream> using namespace std; const int maxn=1e5+10; int n,m,a[maxn],last[..
洛谷题目目录
热门推荐
zqhf123的博客
02-07 25万+
#1 新手村 关卡1-1 洛谷的第一个任务 超级玛丽游戏（洛谷-P1000）：点击这里 A+B Problem（洛谷-P1001）：点击这里 小玉买文具（洛谷-P1421）：点击这里 小鱼的游泳时间（洛谷-P1425）：点击这里 关卡1-2 顺序与分支 小玉家的电费（洛谷-P1422）：点击这里 不高兴的津津（洛谷-P1085）：点击这里 津津的储蓄计划（洛谷-P1089）：点击这里 买铅笔（洛谷...
算法学习笔记() DFS序、树链剖分及其应用
memcpy0的博客
12-13 373
本文属于「算法学习」系列文章的汇总目录。之前的「数据结构和算法设计」系列着重于基础的数据结构和算法设计课程的学习，与之不同的是，这一系列主要用来记录大学课程范围之外的高级算法学习、优化与应用的全过程，同时也将归纳总结出简洁明了的算法模板，以便记忆和运用。在本系列学习文章中，为了透彻理解算法和代码，本人参考了诸多博客、教程、文档、书籍等资料，由于精力有限，恕不能一一列出，这里只列示重要资料的不完全参考列表： 算法竞赛进阶指南，李煜东，河南电子音像出版社，GitHub Tedukuri社区以及个人题解文章汇.
ACM算法进阶学习笔记
GROZAX的博客
12-20 271
学习笔记目录
机器学习入门日记
qq_43380851的博客
08-15 1476
关于想了好几年学机器学习，如今才翻开书的这件事 更新学习中~ 起因是在夏令营面试过程中，被老师问道，你学过机器学习吗？看过西瓜书吗？被伤了自尊心…但是在npy的熏陶下对这方面也有部分自己的思考，但是一直没有系统地学习，原理其实是不是很懂的。 我： 神经网络的原理你能给我讲讲吗？连的每条线都什么意思呀？ npy：它就是个黑盒！你会用就行了！ 我：既然能设计出来！那肯定能解释！ npy：······· 抱着它一定可以被我解释的心态，我翻开了西瓜书… 介绍一个有比较好的资源的GitHub地址： https:/
基础省选＋NOI-第3部分 树上问题
青少年趣味编程
02-08 393
算法竞赛入门经典-训练指南+陈锋+Ch3+LCA相关树上问题深入讨论 算法竞赛入门经典-训练指南+陈锋+Ch3+LCA相关树上问题深入讨论_哔哩哔哩_bilibili Codeforces Round #646 div2 训练总结及A-F题解 Codeforces Round #646 div2 训练总结及A-F题解_哔哩哔哩_bilibili Codeforces Round #651 训练总结及A-F题解 Codeforces Round #651 训练总结及A-F题解_哔哩哔哩_bi
c++学习由浅入深刷题指南(luogu)
最新发布
BadBadBad的博客
10-31 1278
任何一个伟大的目标，都有一个微不足道的开始。
0x21.搜索 - 树与图的遍历、拓扑排序
繁凡さん的博客
05-22 1111
目录一、树与图的深度优先遍历及树的一些性质1.树与图的深度优先遍历2.时间戳3.树的DFS序（树链剖分前驱知识）4.树的深度5.树的重心与sizesizesize6.图的连通块划分二、树与图的广度优先搜索三、拓扑排序 声明： 本系列博客是《算法竞赛进阶指南》+《算法竞赛入门经典》+《挑战程序设计竞赛》的学习笔记，主要是因为我三本都买了 按照《算法竞赛进阶指南》的目录顺序学习，包含书中的少部分重要知识点、例题解题报告及我个人的学习心得和对该算法的补充拓展，仅用于学习交流和复习，无任何商业用途。博客中部分内
Acmer必备算法指南
在数据结构部分，介绍了并查集、字典树（Trie）、单调队列和栈、线段树、树状数组、RMQ（Range Minimum Query）、Treap、划分树、树链剖分、Splay树、DLX（ Dancing Links ）等。这些数据结构在解决动态查询和更新...
算法入门指南：从基础到高级
包括语言相关知识、基础错误分析、基础知识讲解、枚举、模拟、排序、BFS、DFS、二分查找、动态规划及其优化、数据结构如并查集、树状数组、线段树、字典树、Splay树、ST表和划分树、树链剖分与Link-Cut Tree，以及...
最大流算法---Ford-Fulkson方法的基本思想与Edmond-Karp算法
Azarath Metrion Zinthos
04-08 3302
Ford-Fulkson的具体步骤 1、初始化网络中所有边的容量，c继承该边的容量，c初始化为0，其中边即为回退边。初始化最大流为0。 2、在残留网络中找一条从源S到汇T的增广路p。如能找到，则转步骤3,；如不能找到，则转步骤5。 3、在增广路p中找到所谓的"瓶颈"边，即路径中容量最小的边，记录下这个值X，并且累加到最大流中，转步骤4。 4、将增广路中所有c减去X，所有c加上X，构成新
【Code Library】不超过25个页面的材料
Azarath Metrion Zinthos
08-12 2029
--------------- 一、模板 --- 1、NGUNSTTD-PO Name: NeverGiveUpNeverSurrenderTerribleTerribleDamage-PowerOverwhelming Usage: Put it before main function Tags: 头文件 循环 常用语句 --- /** head-file **/
插头与轮廓线与基于连通性状态压缩的dp 学习指南
Azarath Metrion Zinthos
07-27 1882
什么是插头dp
主席树/函数式线段树/可持久化线段树 学习指南
Azarath Metrion Zinthos
08-03 1583
可持久化数据结构(Persistent data structure)就是利用函数式编程的思想使其支持询问历史版本、同时充分利用它们之间的共同数据来减少时间和空间消耗。 因此可持久化
树的直径、树的重心与树的点分治
Azarath Metrion Zinthos
08-08 1581
树的直径 树的直径(Diameter)是指树上的最长简单路。 直径的求法：两遍搜索 (BFS or DFS) 任选一点w为起点，对树进行搜索，找出离w最远的点u。 以u为起点，再进行搜索，找出离u最远的点v。则u到v的路径长度即为树的直径。 简单证明： 如果w在直径上，那么u一定是直径的一个端点。反证：若u不是端点，则从直径另一端点到w再到u的距离比直径更长
扫描线法求最大子矩阵
Azarath Metrion Zinthos
06-15 1567
问题描述： 给定一个N*M的矩阵，其中有一些格子是空地，其他是障碍。 找出一个全部由空地组成的面积/周长最大的子矩阵。 朴素算法： 枚举左上角的坐标O(mn)和右下角的坐标O(mn)，判断是否全为空地O(mn)，时间复杂度为O(m3*n3)。 扫描线法： 把点(i，j)向上所有连续的空格看做一条悬线。矩阵中的每个点都向上对应了一条悬线。 ①用h[i,j]表示点
SCC的Kosaraju算法模板
Azarath Metrion Zinthos
04-17 1502
//-----Kosaraju vectorG[maxn],G2[maxn]; vectorS; int vis[maxn],sccno[maxn],scc_cnt; void dfs1(int u) { if (vis[u]) return; vis[u]=1; for (int i=0;i<G[u].size();i++) dfs1(G[u][i]); S.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值