树链剖分模板

最新推荐文章于 2021-07-25 17:09:52 发布
最新推荐文章于 2021-07-25 17:09:52 发布
阅读量128 收藏
点赞数
分类专栏： NOIP 图论 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fantasy_world/article/details/82696536
版权
NOIP 同时被 3 个专栏收录
169 篇文章 0 订阅
订阅专栏
图论
30 篇文章 0 订阅
订阅专栏
数据结构
27 篇文章 0 订阅
订阅专栏

注意
求子树时，要用子树dfs序连续这个特性，但是不能用如下方法（sub表示x的子树中最大的dfs序）：

void dfs2(int x, int t) {
	top[x] = t;
	dfn[x] = ++cnt;
	subcnt = max(subcnt, cnt);
	rnk[cnt] = x;
	sub[x] = cnt;
	if(!son[x]) return;
	dfs2(son[x], t);
	for(int i=last[x]; i; i=e[i].to) {
		int v = e[i].v;
		if(v != son[x] && v != fa[x]) {
			dfs2(v, v);
		}
	}
	sub[x] = subcnt;
}

因为这样会无法处理叶子节点（直接返回了）
最好的办法是用size，直接算出来
dfn[x] + siz[x] - 1
细节比较多，都在注释里
变量名重复真的很可怕。。。调了半天都没发现

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
#define debug(x) cerr << #x << "=" << x << endl;
const int MAXN = 100000 + 10;
const int MAXM = 2 * MAXN;

int n,m,ans,vis[MAXN],edge_tot,r,p,dep[MAXN],son[MAXN],top[MAXN],dfn[MAXN],fa[MAXN];
int siz[MAXN],rnk[MAXN],cnt,sub[MAXN],subcnt,last[MAXN],a[MAXN];

struct Edge{
    int u,v,to;
    Edge(){}
    Edge(int u, int v, int to) : u(u), v(v), to(to) {}
}e[MAXM];

inline void add(int u, int v) {
    e[++edge_tot] = Edge(u, v, last[u]);
    last[u] = edge_tot;
}

struct segment{
    int siz,sum,add;
}tr[MAXN * 4];

void down(int now) {
    tr[now*2].sum += tr[now*2].siz * tr[now].add;
    tr[now*2+1].sum += tr[now*2+1].siz * tr[now].add;

    tr[now*2].sum %= p;
    tr[now*2+1].sum %= p;

    tr[now*2].add += tr[now].add;
    tr[now*2+1].add += tr[now].add;

    tr[now].add = 0;
}

void update(int pos) {
    tr[pos].siz = tr[pos*2].siz + tr[pos*2+1].siz;
    tr[pos].sum = tr[pos*2].sum + tr[pos*2+1].sum;
    tr[pos].sum %= p;
}

void build_segment(int now, int l, int r) {
    if(l == r) {
        tr[now].siz = 1;
        tr[now].sum = a[rnk[l]];//求出dfs序对应点的编号，然后才是其值，这里不是a[l]，是l对应的点编号
        return;
    }
    int mid = l+r>>1;
    build_segment(now*2, l, mid);
    build_segment(now*2+1, mid+1, r);
    update(now);
}

void change(int now, int l, int r, int x, int y ,int k) {
    if(x <= l && r <= y) {
        tr[now].add += k;
        tr[now].sum += tr[now].siz * k;
        tr[now].sum %= p;
        return;
    }
    down(now);
    int mid = l+r>>1;
    if(x <= mid)//用不用走左儿子只需要看询问更改边界
        change(now*2, l, mid, x, y, k);
    if(y > mid)
        change(now*2+1, mid+1, r, x, y, k);
    update(now);
}

int query(int now, int l, int r, int x, int y) {
    if(x <= l && r <= y) {
        return tr[now].sum % p;
    }
    down(now);
    long long sum = 0;
    int mid = l+r>>1;
    if(x <= mid)
        sum += query(now*2, l, mid, x, y);
    if(y > mid)
        sum += query(now*2+1, mid+1, r, x, y);
    sum %= p;
    return sum;
}

void dfs1(int x, int f, int depth) {
    fa[x] = f;
    dep[x] = depth;
    siz[x] = 1;
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v;
        if(v == f) continue;//是continue而不是v!=f就执行，因为那样要加大括号。。。
        dfs1(v, x, depth + 1);
        siz[x] += siz[v];
        if(siz[v] > siz[son[x]]) {
            son[x] = v;
        }
    }
}

void dfs2(int x, int t) {
    top[x] = t;
    dfn[x] = ++cnt;
    rnk[cnt] = x;
    if(!son[x]) return;
    dfs2(son[x], t);//保证重链上的点dfs序连续
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v;
        if(v != son[x] && v != fa[x]) {
            dfs2(v, v);
        }
    }
}

int path_query(int x, int y) {
    long long sum = 0;
    while(top[x] != top[y]) {
    	if(dep[top[x]] < dep[top[y]]) swap(x, y);//让x更深，所以先跳x
    	sum += query(1, 1, n, dfn[top[x]], dfn[x]);//一定要写topx而不是设tx = topx因为xy会发生交换，提前设置会乱掉。。。
    	sum %= p;
    	x = fa[top[x]];
    }
    if(dfn[x] > dfn[y]) swap(x, y);
    sum += query(1, 1, n, dfn[x], dfn[y]);
    sum %= p;
    return sum;
}

void path_update(int x, int y, int k) {
	while(top[x] != top[y]) {
		if(dep[top[x]] < dep[top[y]]) swap(x, y);
		change(1, 1, n, dfn[top[x]], dfn[x], k);
		x = fa[top[x]];
	}
	if(dfn[x] > dfn[y]) swap(x, y);
	change(1, 1, n, dfn[x], dfn[y], k);
}

int main() {
    scanf("%d%d%d%d", &n, &m, &r, &p);
    for(int i=1; i<=n; i++) {
        scanf("%d", &a[i]);
    }
    for(int i=1; i<n; i++) {
        int x,y;
        scanf("%d%d", &x, &y);
        add(x, y);
        add(y, x);
    }
    dfs1(r, 0, 1);
    dfs2(r,r);
    build_segment(1, 1, n);
    for(int i=1; i<=m; i++) {
        int cmd,x,y,z;
        scanf("%d", &cmd);
        if(cmd == 1) {
            scanf("%d%d%d", &x, &y, &z);
            path_update(x, y, z);
        } else if(cmd == 2) {
            scanf("%d%d", &x, &y);
            printf("%d\n", path_query(x, y));
        } else if(cmd == 3) {
            scanf("%d%d", &x, &y);
            change(1, 1, n, dfn[x], dfn[x] + siz[x] - 1, y);
        } else if(cmd == 4) {
            scanf("%d", &x);
            printf("%d\n", query(1, 1, n, dfn[x], dfn[x] + siz[x] - 1));
        }
    }
    return 0;
}

两道练手题。。。分别是点修改和边修改
洛谷P3128 [USACO15DEC]最大流Max Flow

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <ctime>
using namespace std;
#define debug(x) cerr << #x << "=" << x << endl;
const int MAXN = 50000 + 10;
const int MAXM = MAXN * 2;

int n,k,dep[MAXN],fa[MAXN],son[MAXN],dfn[MAXN],top[MAXN],rnk[MAXN],dfs_seq,edge_tot,last[MAXN],siz[MAXN];

struct Edge{
    int u,v,to;
    Edge(){}
    Edge(int u, int v, int to) : u(u), v(v), to(to){}
}e[MAXM]; 

inline void add(int u, int v) {
    e[++edge_tot] = Edge(u, v, last[u]);
    last[u] = edge_tot;
}

struct segmentTree{
    int val, tag;
}tr[MAXN*4];

void down(int now) {
    int tagadd = tr[now].tag;
    tr[now*2].val += tagadd;
    tr[now*2+1].val += tagadd;
    tr[now*2].tag += tagadd;
    tr[now*2+1].tag += tagadd;
    tr[now].tag = 0;
}

void change(int now, int l, int r, int cx, int cy, int k) {
    if(cx <= l && r <= cy) {
        tr[now].tag += k;
        tr[now].val += k;
        return;
    }
    down(now);
    int mid = l+r>>1;
    if(cx <= mid) 
        change(now*2, l, mid, cx, cy, k);
    if(cy > mid)
        change(now*2+1, mid+1, r, cx, cy, k);
    tr[now].val = max(tr[now*2].val, tr[now*2+1].val);
}

void dfs1(int x, int father, int depth) {
    dep[x] = depth;
    siz[x] = 1;
    fa[x] = father;
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v;
        if(v == father) continue;
        dfs1(v, x, depth+1);
        siz[x] += siz[v];
        if(siz[v] > siz[son[x]]) son[x] = v;
    }
}

void dfs2(int x, int t) {
    top[x] = t;
    dfn[x] = ++dfs_seq;
    rnk[dfs_seq] = x;
    if(!son[x]) return;
    dfs2(son[x], t);
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v;
        if(v == fa[x] || v == son[x]) continue;
        dfs2(v, v);
    }
}

int path_change(int x, int y, int k) {
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);
        change(1, 1, n, dfn[top[x]], dfn[x], k);
        x = fa[top[x]];
    }
    
    if(dfn[x] > dfn[y]) swap(x, y);
    change(1, 1, n, dfn[x], dfn[y], k);
}

int main() {
    scanf("%d%d", &n, &k);
    for(int i=1; i<n; i++) {
        int u,v;
        scanf("%d%d", &u, &v);
        add(u, v);
        add(v, u);
    }
    dfs1(1, 0, 1);
    dfs2(1, 1);
    for(int i=1; i<=k; i++) {
        int s, t;
        scanf("%d%d", &s, &t);
        path_change(s, t, 1);
    }
    printf("%d", tr[1].val);
    return 0;
}

洛谷P3038 [USACO11DEC]牧草种植Grass Planting

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <ctime>
using namespace std;
#define debug(x) cerr << #x << "=" << x << endl;
const int MAXN = 100000 + 10;
const int MAXM = MAXN * 2;

int n,m,dep[MAXN],fa[MAXN],son[MAXN],dfn[MAXN],top[MAXN],rnk[MAXN],dfs_seq,edge_tot,last[MAXN],siz[MAXN];

struct Edge{
    int u,v,to;
    Edge(){}
    Edge(int u, int v, int to) : u(u), v(v), to(to){}
}e[MAXM]; 

inline void add(int u, int v) {
    e[++edge_tot] = Edge(u, v, last[u]);
    last[u] = edge_tot;
}

struct segmentTree{
    int val, tag;
}tr[MAXN*4];

void down(int now) {
    tr[now*2].tag += tr[now].tag;
    tr[now*2+1].tag += tr[now].tag;
    tr[now*2].val += tr[now].tag;
    tr[now*2+1].val += tr[now].tag;
    tr[now].tag = 0;
}

void change(int now, int l, int r, int x, int y, int k) {
    if(x <= l && r <= y) {
    	tr[now].tag += k;
        tr[now].val += k;
        return;
    }
    down(now);
    int mid = l+r>>1;
    if(x <= mid) 
        change(now*2, l, mid, x, y, k);
    if(y > mid)
        change(now*2+1, mid+1, r, x, y, k);
}

int query(int now, int l, int r, int x) {
    if(l == r) return tr[now].val;
    down(now);
    int mid = l+r>>1;
    if(x <= mid)
        return query(now*2, l, mid, x);
    else
        return query(now*2+1, mid+1, r, x);
}

void dfs1(int x, int father, int depth) {
    dep[x] = depth;
    siz[x] = 1;
    fa[x] = father;
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v;
        if(v == father) continue;
        dfs1(v, x, depth+1);
        siz[x] += siz[v];
        if(siz[v] > siz[son[x]]) son[x] = v;
    }
}

void dfs2(int x, int t) {
    top[x] = t;
    dfn[x] = ++dfs_seq;
    rnk[dfs_seq] = x;
    if(!son[x]) return;
    dfs2(son[x], t);
    for(int i=last[x]; i; i=e[i].to) {
        int v = e[i].v;
        if(v == fa[x] || v == son[x]) continue;
        dfs2(v, v);
    }
}

void path_change(int x, int y, int k) {
    while(top[x] != top[y]) {
        if(dep[top[x]] < dep[top[y]]) swap(x, y);
        change(1, 1, n, dfn[top[x]], dfn[x], k);
        x = fa[top[x]];
    }
    if(dfn[x] > dfn[y]) swap(x, y);
    change(1, 1, n, dfn[x], dfn[y], k);
    change(1, 1, n, dfn[x], dfn[x], -k);
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i=1; i<n; i++) {
        int u,v;
        scanf("%d%d", &u, &v);
        add(u, v);
        add(v, u);
    }
    dfs1(1, 0, 1);
    dfs2(1, 1);
    for(int i=1; i<=m; i++) {
    	char cmd;
    	cin >> cmd;
    	int ai, bi;
    	scanf("%d%d", &ai, &bi);
    	if(cmd == 'P') {
    		path_change(ai, bi, 1);
    	} else {
    		printf("%d\n", query(1, 1, n, max(dfn[ai], dfn[bi])));
    	}
    }
    return 0;
}
Zolrk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树链剖分模板题
05-19
#include #include #include #define N 30003 #define INF 2147483647 using namespace std; int n,f[N][20],dep[N],siz[N],son[N],top[N],tot,pos[N],w[N]; int Max[N*4],Sum[N*4];...vector <int> to[N];...
树链剖分(一）-重链剖分：模板&例题
Mint_hexagram的博客
02-25 549
重链剖分的模板学习及基础模板练习
树链剖分——树链剖分模板
fdxgcw的博客
07-25 259
添加链接描述 给定一棵树，树中包含 n 个节点（编号 1∼n），其中第 i 个节点的权值为 ai。 初始时，1 号节点为树的根节点。 现在要对该树进行 m 次操作，操作分为以下 4 种类型： 1 u v k，修改路径上节点权值，将节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值增加 k。 2 u k，修改子树上节点权值，将以节点 u 为根的子树上的所有节点的权值增加 k。 3 u v，询问路径，询问节点 u 和节点 v 之间路径上的所有节点（包括这两个节点）的权值和。 4 u，询问子树，询
树链剖分（模板）
cy41的博客
08-07 269
一个个人认为讲的比较好的B站up主：【AgOHの算法胡扯】树链剖分 前置知识：图的存储及遍历，dfs序（只存第一次被访问），线段树区间操作。 树链剖分支持的操作：（点权以及边权是可以互相转化的，这里只说点权。） upd：2020/1/15最下方新增边剖示例。 修改及查询以x为根的子树权值 修改及查询一条链上的权值（链的定义为：树上两点的最短路径） int index1;//时间戳; ...
树链剖分模板 洛谷P3384
Tizzi的博客
09-12 298
#include <cstdio> const int maxn = 200000+10; struct edge{ int v, next; }e[maxn << 1]; //N、M、R、mod，分别表示树的结点个数、操作个数、根节点序号和取模数 int n, m ,r , mod, len = 1, cnt, code , x, y, z; //cnt是重新进行...
图论：树链剖分模板
qq_43597227的博客
07-23 106
/* 树链剖分——重链剖分 可以求LCA 用线段树可以在树上维护区间最值、求区间和、求子树和等 */ #include <bits/stdc++.h> using namespace std; const int maxn=1e5+10; struct node{ int v,next; }e[maxn<<1]; int head[maxn],cnt=0,ct=0; int size[maxn];//子树的节点大小 int son[maxn];//重儿子 int top[m
NOIP树链剖分习题讲解报告
11-01
P2590 [ZJOI2008]树的统计 P3384 【模板】轻重链剖分/树链剖分 P3950 部落冲突 P4092 [HEOI2016/TJOI2016]树 P2146 [NOI2015] 软件包管理器
树链剖分_题解_
10-03
树链剖分，luoguP3384 【模板】重链剖分
树链剖分 模板
everlasting的博客
10-03 258
bzoj 1036 #include #include #include #include #include #define inf 999999999 using namespace std; struct node{ int Max,sum; int l,r; }tree[120020]; int n; int w[30030],son[30030],totree[30030],
树链剖分详解及模板
热门推荐
大神养成中.....
10-21 2万+
这几天学习了一下树链剖分，顺便写一下我的理解、 早上看了一下别人的讲解，云里雾里，终于算是搞懂了、 树链剖分是解决在树上进行插点问线，插线问点等一系列树上的问题 假如现在给你一棵树，然后没两条边之间有一条权值，有一些操作，1：x---y之间的最大权值是多少，2：改变x---y之间的权值 当前这样的操作有很多，如果直接用暴力的方法的话肯定不行，那么就要想一个好的方法，我们可以想一
洛谷 P3384 【模板】树链剖分
sdfzrlt的博客
04-14 963
树链剖分
树链剖分模板+讲解
Jacky35
05-06 980
树链剖分的详解这里写得很好。我的标程与它的做法一样。 树链剖分的作用相当于在树上做线段树。 模板题 【ZJOI2008】树的统计 在一颗树上，区间查询，单点修改。 I. CHANGE u t : 把结点u的权值改为t II. QMAX u v: 询问从点u到点v的路径上的节点的最大权值 III. QSUM u v: 询问从点u到点v的路径上的节点的权值和
[模板] 树链剖分
Memories Do Not Open
05-03 244
线段树的妙用
Aragorn 树链剖分
最新发布
09-24
Aragorn 树链剖分是一种将一棵树剖分为若干条链的算法，然后利用数据结构去维护每一条链的技术。剖分完毕后，每条重链相当于一段区间，然后可以使用数据结构去维护整个树。具体过程是通过两次深度优先搜索来实现的：...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值