[ZOJ2112][可持久化线段树（主席树）][树状数组]Dynamic Rankings[好题]

最新推荐文章于 2020-08-11 11:30:16 发布
最新推荐文章于 2020-08-11 11:30:16 发布
阅读量888 收藏 1
点赞数 1
分类专栏： OI - Data Structure 文章标签： 持久化 结构 ZOJ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benjaminpmlee/article/details/46002531
版权

题意：

    给出一个序列，求区间第k小。要求支持单点修改。

题解：

不谈修改的时候，地球人都会做。
主要考虑如何维护修改。如果直接在建好的线段树上修改，每次需要新建 O(n) 棵线段树，显然吃不消。
请诸君一定要有一个思想，所谓“函数式线段树”，本质是“化‘树’为‘数’”，让“线段树”这一复杂的结构变得像“数字”一样可以加加减减。为什么区间第k大要用主席树做？因为我们要求区间内小于某一个数的数字个数。这显然是可加的。我们不如就类比做区间求和。带修改的区间求和如何做？树状数组可做。那树状数组每个节点维护的东西变成主席树，就能维护题目中的修改了。

（不要随便看代码。不要随便看代码。不要随便看代码。重要的事情说三遍。）

指针版：

#ifdef _MSC_VER
# include "stdafx.h"
# pragma warning(disable:4996)
#endif

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

//Global Variables & Definitions
#define lowbit(x) ((x) & (-(x)))

int X, M, N;

#define MAXN 50050
#define MAXM 10010
#define MAXT (MAXN + MAXM)

int A[MAXN];
//End Global Variables & Definitions

//Discretization
int w[MAXT];
int wcnt;

void Discre(int cnt) {
    sort(w + 1, w + cnt + 1);
    wcnt = unique(w + 1, w + cnt + 1) - w - 1;
}

int getid(int ww) {
    return lower_bound(w + 1, w + wcnt + 1, ww) - w;
}
//End Discretization

//Chairman Tree
#define DEFINE_MID int mid = (l + r) >> 1
#define lson (u -> lc)
#define rson (u -> rc)

namespace CMT {
    struct node {
        node *lc, *rc;
        int sum;
    } T[1750250];

    int tcnt = 0;
    inline void Init() {
        tcnt = 0;
    }

    inline node* newnode() {
        //return new node();
        return &T[tcnt++];
    }

    inline node* Copy(node *u) {
        node *temp = newnode();
        *temp = *u;
        return temp;
    }

    inline void PushUp(node *u) {
        u->sum = lson->sum + rson->sum;
    }

    void Build(node *u, int l, int r) {
        u->sum = 0; u->lc = u->rc = NULL;

        if (l == r) return;
        DEFINE_MID;

        lson = newnode();
        Build(lson, l, mid);
        rson = newnode();
        Build(rson, mid + 1, r);
    }

    void Insert(node *u, int l, int r, int p, int v = 1) {
        if (l == r) { u->sum += v; return; }

        DEFINE_MID;
        if (p <= mid) {
            lson = Copy(lson);
            Insert(lson, l, mid, p, v);
        }
        else {
            rson = Copy(rson);
            Insert(rson, mid + 1, r, p, v);
        }

        PushUp(u);
    }

    int Query(node *u, int l, int r, int p) {
        if (p >= r) return u->sum;

        DEFINE_MID;

        if (p == mid) return lson->sum;
        else if (p < mid) return Query(lson, l, mid, p);
        else return lson->sum + Query(rson, mid + 1, r, p);
    }
}

using CMT::node;

node* root[MAXN];
//End Chairman Tree

//Fenwick Tree
node* ftr[MAXN];

void Modify(int x, int p, int v) {
    while (x <= N) {
        ftr[x] = CMT::Copy(ftr[x]);
        CMT::Insert(ftr[x], 1, wcnt, p, v);
        x += lowbit(x);
    }
}

int sum(int x, int p) {
    int temp = 0;
    while (x) {
        temp += CMT::Query(ftr[x], 1, wcnt, p);
        x -= lowbit(x);
    }

    return temp;
}
//End Fenwick Tree

//Main Structure
inline int getans(int l, int r, int v) {
    int ansa = CMT::Query(root[r], 1, wcnt, v) - CMT::Query(root[l], 1, wcnt, v);
    ansa += sum(r, v);
    ansa -= sum(l, v);
    return ansa;
}

int Query(int l, int r, int k) {
    int L = 1, R = wcnt;

    while (L < R) {
        int mid = (L + R) >> 1;
        int tans = getans(l - 1, r, mid);

        if (tans >= k) R = mid;
        else L = mid + 1;
    }

    return w[L];
}

char Act[MAXM];
int I[MAXM], J[MAXM], K[MAXM];

void ir() {
    //Read
    scanf("%d%d", &N, &M);

    for (int i = 1; i <= N; ++i) {
        scanf("%d", &A[i]);
        w[i] = A[i];
    }

    wcnt = N;
    char temp[20]; int ii, jj, kk;
    for (int i = 0; i < M; ++i) {
        scanf("%s%d", temp, &ii);

        if ((Act[i] = temp[0]) == 'Q') {
            scanf("%d%d", &jj, &kk);

            I[i] = ii;
            J[i] = jj;
            K[i] = kk;
        }
        else {
            scanf("%d", &jj);

            I[i] = ii;
            w[++wcnt] = J[i] = jj;
        }
    }

    Discre(wcnt);

    //Build
    CMT::Init();
    root[0] = CMT::newnode();
    CMT::Build(root[0], 1, wcnt);
    for (int i = 1; i <= N; ++i) {
        root[i] = CMT::Copy(root[i - 1]);
        CMT::Insert(root[i], 1, wcnt, getid(A[i]));
    }

    for (int i = 1; i <= N; ++i) ftr[i] = root[0];
}

void solve() {
    ir();

    for (int i = 0; i < M; ++i) {
        if (Act[i] == 'Q') {
            printf("%d\n", Query(I[i], J[i], K[i]));
        }
        else {
            Modify(I[i], getid(A[I[i]]), -1);
            Modify(I[i], getid(A[I[i]] = J[i]), 1);
        }
    }
}

inline void g_ir() {
    scanf("%d", &X);
}

int main() {
    g_ir();

    while (X--) solve();
    return 0;
}

数组版：

#ifdef _MSC_VER
# include "stdafx.h"
# pragma warning(disable:4996)
#endif

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;

//Global Variables & Definitions
#define lowbit(x) ((x) & (-(x)))

int X, M, N;

#define MAXN 50050
#define MAXM 10010
#define MAXT (MAXN + MAXM)

int A[MAXN];
//End Global Variables & Definitions

//Discretization
int w[MAXT];
int wcnt;

void Discre(int cnt) {
    sort(w + 1, w + cnt + 1);
    wcnt = unique(w + 1, w + cnt + 1) - w - 1;
}

int getid(int ww) {
    return lower_bound(w + 1, w + wcnt + 1, ww) - w;
}
//End Discretization

//Chairman Tree
#define DEFINE_MID int mid = (l + r) >> 1
#define lson T[u].lc
#define rson T[u].rc

namespace CMT {
    struct node {
        int lc, rc;
        int sum;
    } T[2500250];

    int tcnt = 0;
    inline void Init() {
        tcnt = 0;
    }

    inline int newnode() {
        return tcnt++;
    }

    inline int Copy(int u) {
        int temp = newnode();
        T[temp] = T[u];
        return temp;
    }

    inline void PushUp(int u) {
        T[u].sum = T[lson].sum + T[rson].sum;
    }

    void Build(int u, int l, int r) {
        T[u].sum = 0; T[u].lc = T[u].rc = 0;

        if (l == r) return;
        DEFINE_MID;

        lson = newnode();
        Build(lson, l, mid);
        rson = newnode();
        Build(rson, mid + 1, r);
    }

    void Insert(int u, int l, int r, int p, int v = 1) {
        if (l == r) { T[u].sum += v; return; }

        DEFINE_MID;
        if (p <= mid) {
            lson = Copy(lson);
            Insert(lson, l, mid, p, v);
        }
        else {
            rson = Copy(rson);
            Insert(rson, mid + 1, r, p, v);
        }

        PushUp(u);
    }

    int Query(int u, int l, int r, int p) {
        if (p >= r) return T[u].sum;

        DEFINE_MID;

        if (p == mid) return T[lson].sum;
        else if (p < mid) return Query(lson, l, mid, p);
        else return T[lson].sum + Query(rson, mid + 1, r, p);
    }
}

using CMT::node;

int root[MAXN];
//End Chairman Tree

//Fenwick Tree
int ftr[MAXN];

void Modify(int x, int p, int v) {
    while (x <= N) {
        ftr[x] = CMT::Copy(ftr[x]);
        CMT::Insert(ftr[x], 1, wcnt, p, v);
        x += lowbit(x);
    }
}

int sum(int x, int p) {
    int temp = 0;
    while (x) {
        temp += CMT::Query(ftr[x], 1, wcnt, p);
        x -= lowbit(x);
    }

    return temp;
}
//End Fenwick Tree

//Main Structure
inline int getans(int l, int r, int v) {
    int ansa = CMT::Query(root[r], 1, wcnt, v) - CMT::Query(root[l], 1, wcnt, v);
    ansa += sum(r, v);
    ansa -= sum(l, v);
    return ansa;
}

int Query(int l, int r, int k) {
    int L = 1, R = wcnt;

    while (L < R) {
        int mid = (L + R) >> 1;
        int tans = getans(l - 1, r, mid);

        if (tans >= k) R = mid;
        else L = mid + 1;
    }

    return w[L];
}

char Act[MAXM];
int I[MAXM], J[MAXM], K[MAXM];

void ir() {
    //Read
    scanf("%d%d", &N, &M);

    for (int i = 1; i <= N; ++i) {
        scanf("%d", &A[i]);
        w[i] = A[i];
    }

    wcnt = N;
    char temp[20]; int ii, jj, kk;
    for (int i = 0; i < M; ++i) {
        scanf("%s%d", temp, &ii);

        if ((Act[i] = temp[0]) == 'Q') {
            scanf("%d%d", &jj, &kk);

            I[i] = ii;
            J[i] = jj;
            K[i] = kk;
        }
        else {
            scanf("%d", &jj);

            I[i] = ii;
            w[++wcnt] = J[i] = jj;
        }
    }

    Discre(wcnt);

    //Build
    CMT::Init();
    root[0] = CMT::newnode();
    CMT::Build(root[0], 1, wcnt);
    for (int i = 1; i <= N; ++i) {
        root[i] = CMT::Copy(root[i - 1]);
        CMT::Insert(root[i], 1, wcnt, getid(A[i]));
    }

    for (int i = 1; i <= N; ++i) ftr[i] = root[0];
}

void solve() {
    ir();

    for (int i = 0; i < M; ++i) {
        if (Act[i] == 'Q') {
            printf("%d\n", Query(I[i], J[i], K[i]));
        }
        else {
            Modify(I[i], getid(A[I[i]]), -1);
            Modify(I[i], getid(A[I[i]] = J[i]), 1);
        }
    }
}

inline void g_ir() {
    scanf("%d", &X);
}

int main() {
    g_ir();

    while (X--) solve();
    return 0;
}

（当你看到这里我才会告诉你ZOJ上指针版没有WA但是会MLE）

BenjaminPMLee
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
可持久化数据结构
11-28
可持久化数据结构研究,线段树，块状链表，区间第k大等等
深刻理解树状数组
wanglianda2007的博客
08-15 592
从构造原理的方面简单直观地深刻理解树状数组，不再死背代码。
可持久化线段树（主席树）及可持久化数组
bensanhuan的博客
08-11 493
定义：可以访问历史版本的线段树为可持久化线段树 B站讲解视频：【AgOHの数据结构】主席树 可持久化线段树之所以可以访问历史版本，是因为宏观上看，它为每个版本维护了一棵树。当然，如果真的对每个版本建一颗树，时间空间复杂度都hold不住。所以建立i版本的树时，如果某颗子树相对于i-1版本没有变化，就可以直接使其父亲对应的指针指向i-1版本的这颗子树。 主席树更多的用于单点更新问题，可以为每一次更新后的版本建立一棵树，递归更新的过程中，先令当前节点等于上一个版本的节点，如果某个子树要更新，则新开一个空间存放.
【可持久化线段树】【树状数组】[ZOJ 2112]Dynamic Rankings
weixin_30376163的博客
11-27 134
题目大意：带修改操作的区间第K大 首先可以发现因为只有在需要使用的时候才会新建节点那么最多有nlogn个节点，那么只需要在更新的时候带上值域就可以不用进行离散化了，每一次就是和普通的树状数组那么进行更新，因为求得是区间的和（大概就是可持久化的原理）但是用树状数组来做每一个更新的时候就有了求前缀和的范围，每一次加起来就好了，其实和普通的树状数组差不多的。（注意是多组数据） #...
HDU 4348. To the Moon【可持久化树状数组】
~飞呀，飞~
09-25 3412
http://acm.hdu.edu.cn/showproblem.php?pid=4348 #include #include #include #include #include #include using namespace std; const int maxn = 100010; int n, m; struct Node { long long d,
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的信息 + 连向父节点的边的贡献得到，考虑在每个节点再维护一个线段树，按距离建树用来统计子树内的节点到其父节点距离为 p 的点权和，这样...
线段树模板 zoj1128
08-31
本资源是对线段树操作比较完整的操作，包括线段树的动态插入，动态删除和维护，可以查询区段的最大值，最小值，完成线段树的基本操作。
线段树题目
07-16
大量线段树题目 zoj 1610 线段覆盖 poj 2777 线段覆盖 poj 2528 需要离散化，建树不同，需要处理不同->注意这组数据 3 1 10 1 3 6 10 the ans is 3. hdu 1754 求区间最大值 hdu 1166 求区间和 hdu 1698 成段更新 ...
hdu 1166线段树
07-02
hdu 1166线段树
zoj 题库 详细解答 解题代码
03-24
zoj 题库 详细解答 解题代码 acm
B - 可持久化动态图上树状数组维护01背包(思维) (牛客算法周周练15)
Satur9的博客
07-14 343
传送门 题意： 对于一个数组a，删除任意位置的元素a[i]需要花费a[i]*i的精力，然后i以后的元素都前进一位(即下标-1)。求把整个序列删完的最小代价。 思路： 显然对于正数我们都可以将其放在位置1去删除，花费的精力就是a[1]。 而对于负数我们可以就在原位置删除，这样得到的总精力会最小。 代码实现： #include<bits/stdc++.h> #define endl '\n' #define null NULL #define ll long long #define int
可持久化动态图上树状数组维护01背包（贪心）
计算机萌新的成长之路
01-23 462
这道题的思路就是如果是负数，直接cost+=i*a[i],但是如果是正数的话，就直接cost+=a[i]，这样子的代价才是最小的 #include<bits/stdc++.h> using namespace std; int main() { int n; long long cost=0; scanf("%d",&n); for(int i...
bzoj 2120 数颜色 树状数组套可持久化数据结构。
OceanLight的专栏
10-16 2662
查询区间l，r 中 不同值的个数， 修改操作是 单点更新。 如果没有更新，此题直接 离线。 有更新的话，就只有 树状数组套 平衡树 或者 可持久化数据结构。 问题一 。统计 在 【1，l-1】中都多少个值没有出现在 【l，r】。也就是统计 【1，l-1】中有多少个值，在【1，r】中仅出现在 【1，l-1】。 统计 对于ai ，它的下次出现与ai 值相同的点的下标是多少。 相当于 把所
bzoj1901zoj2112
binarycopycode
11-12 286
bzoj1901听说不用建静态主席树，可以直接当树状数组添加也不会爆内存，然而并没有权限号。由于zoj2112的n有5*1e5所以不能一开始就nlognlogn的空间丢进去，不然会炸，需要建一颗nlogn空间的静态线段树，然后再mlognlogn的跟新，这样就不会爆数组。静态开一个rt1[maxl],动态开一个rt2[maxl] 因为是要动态修改的区间第k大，把主席树当树状数组来看待，要求l到r
洛谷P3919 【模板】可持久化数组（可持久化线段树/平衡树）
EM LGH
10-17 409
主席树太费空间了，而本题也无需维护任何区间信息，只是查询历史版本点值，没必要构造可持久化线段树，我们可以构建结构类似于 BST 的可持久化数据结构，这样每个非叶节点也会带有权值，不会被浪费掉 Code; #include&amp;lt;cstdio&amp;gt; #include&amp;lt;algorithm&amp;gt; using namespace std; const int maxn = 1000000 + 3...
可修改的区间第K大 BZOJ1901 ZOJ2112
weixin_30692143的博客
01-03 93
http://blog.csdn.net/u014492306/article/details/47981315 //变相离线做法 离散化缩小区间范围，做两大个线段树，第一个就是普通的持久化树，有个前缀和就好。 第二个用线段树套树状数组，每次询问就把这两个都求出来加一下。 更改就更改第二个，其实更改的时候只需要建一条链然后重复用这条链衍生就好了，但是为了抄的方便，就不改了。。。 当然这...
【模板】可持久化数组（可持久化线段树/平衡树）
weixin_30326741的博客
08-13 93
传送门 原来写过一篇不能看的，现在重新写一遍，也当是复习巩固可持久化线段树的思想。 题意 给定一个数列以及两种操作： 操作1：修改某一个历史版本某个位置上的值 操作2：查询某一个历史版本某个位置上的值 对于每一个操作，都会生成一个新的历史版本。其中操作2生成的历史版本与查询的版本相同。 思路 考虑最朴素的解法，对于每一个版本，我们直接开空间保存下来，这样的话时间复杂度和空间复杂...
Codeforces 650D. Zip-line (动态LIS) （可持久化线段树 或 离线+树状数组）
岩之痕
03-11 3250
题意： 给定一个长度为n的数列，和m个询问，每个询问的格式是：将原数组的第a个数改成b之后，数组的最长上升子序列（LIS）的长度。 做法：可持久化线段树 令 h[ ] 为原数组，LIS_L[ i ] 表示以 i 结尾的LIS长度，LIS_R[ i ] 表示以 i 开头的LIS长度。这俩数组用普通LIS算法O(nlog2(n))求出。 然后来分析一下询问怎么处理： 在 h[a
ACM知识清单
jkchen's Haven
08-22 517
桶排序 排序数列分布较密，值域较小，例如1e61e61e6个数属于∈[1,10]\in[1,10]∈[1,10]。 斜率优化 dpdpdp的增量具有单调性时，可以确定转移的最优态，实现O(n)O(n)O(n)转移。 矩阵快速幂 O(logn)O(logn)O(logn)求解线性递推式第nnn项值。 容斥 欲正则反，虚虚实实。 位操作 将一个数看成二进制位，考虑每个位的贡献。 逆元 可由费马小定理或...
zoj 1700 二叉搜索树
最新发布
05-20
这道题目是一道经典的二叉搜索树问题，需要用到二叉搜索树的性质来解决。 首先，我们可以将问题转化为求解 $n$ 个节点构成的二叉搜索树的数量。假设 $F(n)$ 表示 $n$ 个节点构成的二叉搜索树的数量，那么对于任意一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值