主席树总结

最新推荐文章于 2019-11-04 17:52:03 发布
最新推荐文章于 2019-11-04 17:52:03 发布
阅读量115 收藏
点赞数
原文链接：http://www.cnblogs.com/heyuhhh/p/10753168.html
版权

之前一直以为主席树是个什么神仙玩意儿，后面看了下其实也不是很难。主席树也被称作可持久化线段树吧，这里的线段树一般是权值线段树，普通的权值线段树只能维护整个区间的权值信息，对于部分的区
间信息不能维护。而对于每个主席树的\(root[i]\)，它存的是\(1\)~\(i\)的区间权值信息，相当于一个权值线段树的前缀和。因为某些问题区间信息具有可减性，所以可以用主席树来维护。这个之后有例题。
但对于每个前缀\(i\)都建立一颗权值线段树空间复杂度太高了，所以这里比较巧妙的一个地方就是前缀\(i\)与前缀\(i-1\)会有很多的重合部分，所以我们可以共用很多结点。那么每次插入前缀\(i\)时，共用的部分不>管，对于其余的结点我们新开一个结点就是了，所以每次最多就会开一条链。那么最后总的空间复杂度就很低了，为\(O(nlogn+nlogn)\)。时间复杂度也很低，为\(O(nlogn)\)。

 

部分代码

一开始的时候，我们会建立一颗空树，之后会以此为基础来插入前缀。

void build(int &o, int l, int r) {
    o = ++T;
    if(l == r) {
        return ;
    }
    int mid = (l + r) >> 1;
    build(ls[o], l, mid) ;
    build(rs[o], mid + 1, r) ;
}

 
之后就是对于每个前缀\(i\)的插入了。

void update(int &o, int l, int r, int last, int p) {
    o = ++T;
    ls[o] = ls[last] ;
    rs[o] = rs[last] ;//共用结点
    if(l == r) {
        sum[o] = sum[last] + 1;
        return ;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) update(ls[o], l, mid, ls[last], p) ;
    else update(rs[o], mid + 1, r, rs[last], p);
    pushup(o) ;
}
//main中
for(int i = 1; i <= n; i++) update(rt[i], 1, n, rt[i - 1], a[i]) ;

 
对于询问(以区间第k大为例)：

int query(int L, int R, int l, int r, int k) {
    if(l == r) return l;
    int s = sum[ls[R]] - sum[ls[L]] ;
    int mid = (l + r) >> 1 ;
    if(s >= k) return query(ls[L], ls[R], l, mid, k) ;
    else return query(rs[L], rs[R], mid + 1, r, k - s) ;
}

 

例题

 

POJ2104区间第k大

这是主席树基本用途之一，查询的时候通过比较区间权值数量来决定进入左子树还是右子树，具体见代码吧。
代码如下：

Code 
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5, M = 5005;
int n, m, T;
int a[N], b[N], c[N], d[N];
int rt[N] ;
int sum[N * 20], ls[N * 20], rs[N * 20];
void pushup(int o) {
    sum[o] = sum[ls[o]] + sum[rs[o]] ;
}
void build(int &o, int l, int r) {
    o = ++T;
    if(l == r) {
        return ;
    }
    int mid = (l + r) >> 1;
    build(ls[o], l, mid) ;
    build(rs[o], mid + 1, r) ;
}
void update(int &o, int l, int r, int last, int p) {
    o = ++T;
    ls[o] = ls[last] ;
    rs[o] = rs[last] ;
    if(l == r) {
        sum[o] = sum[last] + 1;
        return ;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) update(ls[o], l, mid, ls[last], p) ;
    else update(rs[o], mid + 1, r, rs[last], p);
    pushup(o) ;
}
int query(int L, int R, int l, int r, int k) {
    if(l == r) return l;
    int s = sum[ls[R]] - sum[ls[L]] ;
    int mid = (l + r) >> 1 ;
    if(s >= k) return query(ls[L], ls[R], l, mid, k) ;
    else return query(rs[L], rs[R], mid + 1, r, k - s) ;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= n; i++) cin >> a[i], b[i] = c[i] = a[i];
    sort(b + 1, b + n + 1) ;
    int D = unique(b + 1, b + n + 1) - b - 1;
    for(int i = 1; i <= n; i++) a[i] = lower_bound(b + 1, b + D + 1, a[i]) - b, d[a[i]] = c[i];
    build(rt[0], 1, D) ;
    for(int i = 1; i <= n; i++) update(rt[i], 1, D, rt[i - 1], a[i]) ;
    for(int i = 1; i <= m; i++) {
        int l, r, k ;
        cin >> l >> r >> k ;
        int ans = query(rt[l - 1], rt[r], 1, D, k) ;
        cout << d[ans] << '\n';
    }
    return 0;
}

 

洛谷模板题

可以用这个加深一下对可持久化的理解吧。
代码如下：

Code 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 5 ;
int n, m;
int a[N];
int rt[N], tre[N * 20], lc[N * 20], rc[N * 20];
int T;
void build(int &o, int l, int r) {
    o = ++T;
    if(l == r) {
        tre[o] = a[l] ;
        return ;
    }
    int mid = (l + r) >> 1;
    build(lc[o], l, mid) ;
    build(rc[o], mid + 1, r) ;
}
void update(int &o, int l, int r, int last, int sign, int p, int v) {
    o = ++T;
    lc[o] = lc[last];
    rc[o] = rc[last];
    if(sign == 0)
        return ;
    if(l == r) {
        tre[o] =  v;
        return ;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) update(lc[o], l, mid, lc[last], sign, p, v) ;
    else update(rc[o], mid + 1, r, rc[last], sign, p, v) ;
}
int query(int o, int l, int r, int p) {
    if(l == r) return tre[o] ;
    int mid = (l + r) >> 1;
    if(p <= mid) return query(lc[o], l, mid, p) ;
    else return query(rc[o], mid + 1, r, p) ;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n >> m ;
    for(int i = 1; i <= n; i++) cin >> a[i] ;
    build(rt[0], 1, n) ;
    for(int i = 1; i <= m; i++) {
        int v, op, pos, val;
        cin >> v >> op >> pos ;
        if(op == 1) {
            cin >> val ;
            update(rt[i], 1, n, rt[v], 1, pos, val) ;
        } else {
            int ans = query(rt[v], 1, n, pos) ;
            update(rt[i], 1, n, rt[v], 0, pos, 0);
            cout << ans << '\n';
        }
    }
    return 0;
}

 

洛谷P3567

题意是询问区间中是否有超过区间长度一半的数，有的话这个数是哪个。
维护一下个数，然后根据sum看是否进入左右子树来找就行了，如果最后没有则输出0。
代码如下:

Code 
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <cmath>
#include <map>
using namespace std;
typedef long long ll;
const int N = 5e5 + 5;
int n, m, T;
int a[N];
int rt[N] ;
int sum[N * 40], ls[N * 40], rs[N * 40];
void pushup(int o) {
    sum[o] = sum[ls[o]] + sum[rs[o]] ;
}
void build(int &o, int l, int r) {
    o = ++T;
    if(l == r) {
        return ;
    }
    int mid = (l + r) >> 1;
    build(ls[o], l, mid) ;
    build(rs[o], mid + 1, r) ;
}
void update(int &o, int l, int r, int last, int p) {
    o = ++T;
    ls[o] = ls[last] ;
    rs[o] = rs[last] ;
    if(l == r) {
        sum[o] = sum[last] + 1;
        return ;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) update(ls[o], l, mid, ls[last], p) ;
    else update(rs[o], mid + 1, r, rs[last], p);
    pushup(o) ;
}
int query(int L, int R, int l, int r, int k) {
    if(l == r) return l;
    int lsize = sum[ls[R]] - sum[ls[L]], rsize = sum[rs[R]] - sum[rs[L]];
    int mid = (l + r) >> 1 ;
    if(lsize >= k) return query(ls[L], ls[R], l, mid, k) ;
    else if(rsize >= k) return query(rs[L], rs[R], mid + 1, r, k) ;
    else return 0;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= n; i++) cin >> a[i];
    build(rt[0], 1, n) ;
    for(int i = 1; i <= n; i++) update(rt[i], 1, n, rt[i - 1], a[i]) ;
    for(int i = 1; i <= m; i++) {
        int l, r;
        cin >> l >> r;
        int mid = ((r - l + 1) >> 1) + 1;
        int v = query(rt[l - 1], rt[r], 1, n, mid) ;
        cout << v << '\n';
    }
    return 0;
}

 

南昌邀请赛网络赛 J. Distance on the tree

题目给出一棵树，然后每条边都有一定的边权。然后有多个询问，对于每个询问给出 \(u,v,k\)，回答从 \(u\)到 \(v\)的路径中，权值不大于 \(k\)的边有多少条。

这个题的做法还是挺多的，可以树剖，也可以直接用树状数组，我就说说主席树的做法吧。
首先因为是树上的路径，那么我们肯定是要求LCA的。然后我们对整颗数dfs一遍，在dfs过程中插入主席树，以当前结点的父亲结点为历史版本，那么这样我们就清晰地知道从根到当前结点路径的权值信息了。
对于每次询问，找到LCA，计算一波就行了。这里直接利用主席树找权值不超过k的个数，对于结点\(u\)为\(cnt[u]\)，那么最终的答案就为\(cnt[u]+cnt[v]-2*cnt[LCA]\)。
代码如下：

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
int n, m, T, D;
int b[N << 1];
int head[N];
struct Edge{
    int v, w, next;
}e[N << 1];
struct Q{
    int u, v, w;
}q[N];
struct edge{
    int u, v, w;
}E[N << 1];
int tot;
void adde(int u, int v, int w) {
    e[tot].v = v; e[tot].next = head[u]; e[tot].w = w; head[u] = tot++;
    e[tot].v = u; e[tot].next = head[v]; e[tot].w = w; head[v] = tot++;
}
int f[N][22], deep[N];
int ls[N * 20], rs[N * 20], rt[N], sum[N * 20];
void build(int &o, int l, int r) {
    o = ++T;
    if(l == r) return ;
    int mid = (l + r) >> 1;
    build(ls[o], l, mid) ;
    build(rs[o], mid + 1, r) ;
}
void update(int &o, int l, int r, int last, int v) {
    o = ++T;
    sum[o] = sum[last] + 1;
    ls[o] = ls[last]; rs[o] = rs[last] ;
    if(l == r) return ;
    int mid = (l + r) >> 1;
    if(v <= mid) update(ls[o], l, mid, ls[last], v) ;
    else update(rs[o], mid + 1, r, rs[last], v) ;
}
void dfs(int u, int fa) {
    for(int i = head[u]; i != -1; i = e[i].next) {
        int v = e[i].v;
        if(v == fa) continue ;
        deep[v] = deep[u] + 1;
        f[v][0] = u;
        for(int j = 1; j <= 20; j++) f[v][j] = f[f[v][j - 1]][j - 1] ;
        int w = lower_bound(b + 1, b + D + 1, e[i].w) - b;
        update(rt[v], 1, n + m, rt[u], w) ;
        dfs(v, u);
    }
}
int lca(int x, int y) {
    if(deep[x] < deep[y]) swap(x, y) ;
    for(int i = 20; i >= 0; i--)
        if(deep[f[x][i]] >= deep[y]) x = f[x][i] ;
    if(x == y) return x;
    for(int i = 20; i >= 0; i--)
        if(f[x][i] != f[y][i]) x = f[x][i], y = f[y][i] ;
    return f[x][0] ;
}
int query(int o, int l, int r, int last, int v) {
    if(l == r) return sum[o] - sum[last] ;
    int mid = (l + r) >> 1;
    int s = sum[ls[o]] - sum[ls[last]] ;
    if(v <= mid) return query(ls[o], l, mid, ls[last], v) ;
    else return s + query(rs[o], mid + 1, r, rs[last], v) ;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    memset(head, -1, sizeof(head)) ;
    cin >> n >> m;
    for(int i = 1; i < n; i++) {
        int u, v, w;
        cin >> u >> v >> w ;
        E[i] = edge{u, v, w} ;
        b[i] = w ;
    }
    D = n;
    for(int i = 1; i <= m; i++) {
        int u, v, w;
        cin >> u >> v >> w ;
        q[i] = Q{u, v, w} ;
        b[D++] = w;
    }
    sort(b + 1, b + D) ;
    D = unique(b + 1, b + D) - b - 1;
    for(int i = 1; i < n; i++) {
        adde(E[i].u, E[i].v, E[i].w) ;
    }
    build(rt[1], 1, n + m) ;
    dfs(1,0) ;
    for(int i = 1; i <= m; i++) {
        int u = q[i].u, v = q[i].v, w = q[i].w;
        w = lower_bound(b + 1, b + D + 1, w) - b;
        int LCA = lca(q[i].u, q[i].v) ;
        int s1 = query(rt[u], 1, n + m, rt[1], w) ;
        int s2 = query(rt[v], 1, n + m, rt[1], w) ;
        int s3 = query(rt[LCA], 1, n + m, rt[1], w) ;
        //cout << w << ' ' << s1 << ' ' << s2 << ' ' << s3 << '\n';
        cout << s1 + s2 - 2 * s3 << '\n';
    }
    return 0 ;
}

转载于:https://www.cnblogs.com/heyuhhh/p/10753168.html

dft539533
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
主席树模板总结及题集
jerans的博客
08-11 2690
介绍篇：http://blog.csdn.net/metalseed/article/details/8045038  -> 理解篇（配图比较生动）：http://blog.csdn.net/regina8023/article/details/41910615  -> 题目：poj2104 区间查询第k大元素，非递归写法，非递归不好进行回溯操作，递归更好写一些 #include #inc
主席树 总结
' 泪 添 无 言's blog
09-02 859
终于要总结一波主席树了。主席树太神奇了。。首先，主席树是什么？我的理解是，主席树首先是一颗颗地线段树，每一颗线段树都记录了不同时间的状态（这样就实现可持续化啦）。 举个例子， 有一个序列， 我们每次需要向线段树中插入序列中的一个数， 当插入第一个数的时候，就会生成一颗线段树， 然后插入第二个数的时候，就会生成第二颗线段树，第二颗线段树不仅具有第一颗线段树的值，而且还在第一颗树的基础上插入了第二个数，
模板总结——主席树
EnjoyingAC的博客
05-17 1287
任务 求静态区间第k小数。 即给定数组a和一个区间，求[l,r]中第k小的数。 简化问题 假设大小为n的数组内的值恰好为1~n的排列。比如大小为4的数组为：4,2,1,3. 要想将其他数组转化为上述简化问题，只需进行离散即可。即将原数组排序，将对应的值与排序后的下标对应起来。用下标来表示原来的值。 vector&lt;int&gt; v; int getid(int k) { ...
主席树_主席树模板_
09-30
供信息学奥林匹克竞赛选手使用 主席树模板
主席树.ppt
07-08
主席树.ppt
权值线段树和主席树入门
09-25
权值线段树和主席树入门PPT，权值线段树，顾名思义就是记录权值的线段树，普通的线段树直接以坐标为l，r建树，而权值线段树是以大小来建树，树上寸的信息是该权值的数量，而通过建树时二分从小到大的性质，可以用这...
大学生主席工作总结.docx
02-11
大学生主席工作总结.docx
学生会主席工作总结.pdf
最新发布
02-04
个人总结 年度总结 工作总结
主席树题目总结
cy41的博客
06-13 301
前置知识：基于值域的整体第k大（权值线段树） 写主席树必定需要注意空间的开销，一定要开够 若长度为n，修改为m次，则空间复杂度为n+m*logn。 可以在我的博客里翻一翻2333。 基础问题，求解区间第k大，或者区间小于等于k的个数： poj-2104 HDU-4417 下面两个前置知识LCA P2633 Count on a tree Distance on the tree ...
主席树总结（题目合集）
常胜将军的博客
03-04 1692
1、HDU 2665 题意：无修改区间第k大 思路：主席树（离线算法）网上都有各种详细的解释了，就不多说了。。。主席树的核心思想包括前缀和、二分查找、空间重复利用、转化（区间表示在此范围内的数的个数，即权值线段树）。时间和空间复杂度为nlogn。 代码： #include<iostream> #include<algorithm> using namespace...
主席树介绍
热门推荐
MetalSeed
10-07 4万+
函数式（现在又称主席式。。。）数据结构从来都没写过，感觉这个东西可以挖掘出不少东西出来，于是开一组专题。 先根据 Seter 留下的文本做一些记录。。 主席树大概是一种离线结构，我以前反正没看到过这东西，所以就自己给他起名字了！如果谁知道这东西的真名，请告诉我！ 现在我们知道，主席树的全名应该是 函数式版本的线段树。加上附带的一堆 technology。。 。。
主席树
mdnd1234的博客
04-06 639
转载自：http://blog.csdn.net/fop_zz/article/details/69240536 可持久化线段树，俗称主席树  我其实也不是很懂就来瞎口胡一通看看能不能自己卡死自己而已。。 所谓可持久化，即支持询问之前的状态  比如经过了k次操作后，我们仍然能知道第i次（1 ”然而这只是主席树很小的一部分作用“——szb  蒟蒻瑟瑟发抖  那这要怎么做到呢
主席树详解
你的目光看海的博客
09-02 1529
主席树是一种线段树的变形，可以解决区间第k大的问题。下面我谈谈自己的理解，尽可能的讲清楚些。 假设现在有序列 a[5] = {1 , 4 , 5 , 3 , 2}，有q个询问{l , r , k}问你[l , r]区间第k小的值是多少？ 容易想到对被询问区间排个序，然后输出第k个数。这种方法最直观，但也是最费时的(时间复杂度爆炸)，不可取。 另一种是先建立一个空树，再将[l , r]区间的
主席树（可持久化线段树）
孙煜晗的博客
11-04 6282
2019.11.4 今天总算弄会主席树了，发现确实不难，但是需要跳出常规线段树的思维，特别是处理子树上面 主席树的定义与作用 主席树，也称可持久化线段树，那么什么是可持久化线段树呢，即为一颗记录了所有更新过程的线段树。能够处理出从第i次更新到第j次更新的线段树变化，具体作用一会见例题。 主席树的功能 记录所有过程的线段树，按正常思维是需要开O(N*M)这么大的空间的，时间也为O（n*m），...
主席树维护dfs序——BZOJ3653/Luogu3899 谈笑风生
2333：jzqjzq的博客专栏
08-18 287
题面：BZOJ3653 Luogu3899 被luogu难度等级骗了。。。 首先看到子树的题就是dfs序了，我们用L[i]L[i]表示i的初访问戳，R[i]R[i]表示i的末访问戳 我们设size[i]size[i]表示子树大小（不包括i），deep[i]deep[i]表示深度 首先我们可以发现a,b,c在一条链上，所以我们考虑这几种情况： b是a的祖先，根据乘法原理我们可以得到答案是siz
主席树（动态维护第k大的树）zoj2112
龙崎的专栏
09-17 1298
ZOJ Problem Set - 2112 Dynamic Rankings Time Limit: 10 Seconds      Memory Limit: 32768 KB The Company Dynamic Rankings has developed a new kind of computer that is no longer satisfied with t
主席树(可持久化线段树)
jkchen's Haven
08-07 430
主席树,顾名思义,就是可持久化。。。 看了很多博客都讲的不是很清楚 有几道主席树的例题 求一个区间的第k大的数 求一个区间的小于等于k的数量 算法主要的难理解的地方就是建树,方法和线段树有很大的不同 在主席树中我们是动态建树,方法和链式前向星差不多 insert(root[last],root[cur]=++tot,1,n,k) void insert(int last,in...
我的舍友是主席 我可以合法谋取哪些利益
03-29
作为你的舍友是主席，你可以合法谋取以下利益： 1. 更好的住宿条件：作为主席的舍友，你可能会得到更好的住宿条件或更大的房间。 2. 更好的社交机会：作为主席的舍友，你可能会得到更多的社交机会，比如参加主席的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值