bzoj3110（线段树套线段树、树状数组套线段树）

最新推荐文章于 2018-07-31 22:34:22 发布
最新推荐文章于 2018-07-31 22:34:22 发布
阅读量1.4k 收藏 2
点赞数
分类专栏： acm 基本算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjy2015302395/article/details/72822778
版权

http://www.lydsy.com/JudgeOnline/problem.php?id=3110
题意：
有N个位置，M个操作。操作有两种，每次操作如果是1 a b c的形式表示在第a个位置到第b个位置，每个位置加入一个数c
如果是2 a b c形式，表示询问从第a个位置到第b个位置，第C大的数是多少。

tip：

线段树套线段树，外面是权值，每个节点上的线段树是位置，
比如，如果在1~4位置加入5 就是把整个线段树中有5的log个节点，
每个节点的1~4这log区间上++。。。。
然后每次询问的时候，二分答案，
比如权值二分到3就是求1~3中有多少个在询问的区间里，还是log个节点，
每个节点跑log个得到对应区间上的个数总和

这样会ｔｌｅ＆＆　ｍｌｅ，代码如下：

/*
线段树套线段树，外面是权值，每个节点上的线段树是位置，
比如，如果在1~4位置加入5 就是把整个线段树中有5的log个节点，
每个节点的1~4这log区间上++。。。。
然后每次询问的时候，二分答案，
比如权值二分到3就是求1~3中有多少个在询问的区间里，还是log个节点，
每个节点跑log个得到对应区间上的个数总和

*/

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
using namespace std;
typedef long long LL;
const int maxn = 3e7+10;
const int maxm = 50000*4+10;
int root[maxm],N,Q;
struct pos_Tree{
    int lon,ron,add;
    unsigned int _size;
    void init(){
        lon = ron  = add = _size = 0;
    }
};

class segment_tree{
public:
    pos_Tree tree[maxn];LL cnt;
    void push_down(int k,int m,int l,int r){
        if(tree[k].add == 0)    return ;
        if(tree[k].lon == 0){
            cnt++;tree[k].lon = cnt;//tree[cnt].l = l;tree[cnt].r = (l+r)/2;
            tree[cnt]._size = (m-(m/2))*tree[k].add;tree[cnt].add = tree[k].add;
        }
        else    tree[tree[k].lon]._size +=(m-(m/2))*tree[k].add,tree[tree[k].lon].add += tree[k].add;
        if(tree[k].ron == 0){
            cnt++;tree[k].ron = cnt;//tree[cnt].l = (l+r)/2+1;tree[cnt].r = r;
            tree[cnt]._size = (m/2)*tree[k].add;tree[cnt].add = tree[k].add;
        }
        else    tree[tree[k].ron]._size +=(m/2)*tree[k].add,tree[tree[k].ron].add += tree[k].add;
        tree[k].add = 0;
    }
    void push_up(int k,int ln,int rn){
        tree[k]._size = tree[ln]._size+tree[rn]._size;
    }
    void _insert(int &k,int L,int R,int l,int r,int rt){
        if(k == 0){
            cnt++;tree[cnt].init();k = cnt;//tree[k].l = l;tree[k].r = r;
        }
        if(L <= l && R >= r){
            tree[k].add++;tree[k]._size += r-l+1;
            return ;
        }
        push_down(k,r-l+1,l,r);
        int m = (l+r)>>1;
        if(m >= L)  _insert(tree[k].lon,L,R,lson);
        if(m < R)   _insert(tree[k].ron,L,R,rson);
        push_up(k,tree[k].lon,tree[k].ron);
    }
    LL query(int k,int L,int R,int l,int r,int rt){
        if(l >= L && r <= R){
            return tree[k]._size;
        }
        push_down(k,r-l+1,l,r);
        //cout <<" k = "<<k<<endl;
        int m = (l+r)/2;
        LL ans = 0;
        if(m >= L && tree[k].lon)  ans += query(tree[k].lon,L,R,lson);
        if(m < R && tree[k].ron)   ans += query(tree[k].ron,L,R,rson);
        return ans;
    }
}pos_tree;//区间线段树

void build(int l,int r,int rt){
    root[rt] = 0;
    if(l == r)  return ;
    int m = (l+r)>>1;
    build(lson);
    build(rson);
}

void val_insert(int a,int b,int pos,int l,int r,int rt){
    if(pos >= l && pos <= r){
        pos_tree._insert(root[rt],a,b,1,N,1);
    }
    if(l == r)   return ;
    int m = (l+r)>>1;
    if(pos <= m)    val_insert(a,b,pos,lson);
    else    val_insert(a,b,pos,rson);
}

int _in(int mid,int l,int r,int rt){
    if(l == r && l == mid)  return root[rt];
    int m = (l+r)>>1;
    if(mid <= m)  return _in(mid,lson);
    else    return _in(mid,rson);

}

LL check(int L,int R,int posa,int posb,int l,int r,int rt){
    if(L <= l && R >= r){
        if(root[rt] == 0)   return 0;
        LL ans = pos_tree.query(root[rt],posa,posb,1,N,1);
        return ans ;
    }
    LL ans = 0;
    int m = (l+r)>>1;
    if(m >= L)  ans += check(L,R,posa,posb,lson);
    if(m < R)   ans += check(L,R,posa,posb,rson);
    return ans;
}

int bs(int posa,int posb,int c){
    int l = 1,r = N,ans = 100000000;
    while(l <= r){
        int mid = (l+r)>>1;
        LL pp = check(1,mid,posa,posb,1,N,1);
        if( pp >= c){//1~mid权值中到了c个就是可能得解，多了就缩小范围
            if(_in(mid,1,N,1))//mid是否是出现了得权值
                ans = min(ans,mid);
            r = mid-1;
        }
        else    l = mid+1;
    }
    return ans;
}
int op,a,b,c;
void sov(){
    pos_tree.cnt = 0;
    for(int i = 1;  i<= Q ; i++){
        scanf("%d",&op);
        if(op == 1){
            scanf("%d%d%d",&a,&b,&c);
            if(a > b)   swap(a,b);
            c = N-c+1;
            val_insert(a,b,c,1,N,1);
        }
        else{
            scanf("%d%d%d",&a,&b,&c);
            if(a > b)   swap(a,b);
            printf("%d\n",N-bs(a,b,c)+1);
        }
    }
}

int main(){
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(~scanf("%d%d",&N,&Q)){
        build(1,N,1);
        sov();
    }
    return 0;
}
/*
7 100
1 1 5 2
1 2 7 3
1 3 5 2
1 1 1 1
2 1 3 2
2 1 3 3
2 1 3 7
2 1 7 5
2 1 7 7
2 2 3 2
2 1 1 1
2 1 1 2
2 3 5 3
2 3 4 5
2 1 5 2
2 2 7 2
2 3 5 2
2 2 2 1
*/

tle版本（树状数组套线段树）：

改成树状数组，ｍｌｅ问题解决,时间复杂度仍然有logloglog

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
using namespace std;
typedef long long LL;
const int maxn = 3e7+10;
const int maxm = 50000+10;
int root[maxm],N,Q;
struct pos_Tree{
    int lon,ron,add;
    unsigned int _size;
    void init(){
        lon = ron  = add = _size = 0;
    }
};

class segment_tree{
public:
    pos_Tree tree[maxn];LL cnt;
    void push_down(int k,int m,int l,int r){
        if(tree[k].add == 0)    return ;
        if(tree[k].lon == 0){
            cnt++;tree[k].lon = cnt;//tree[cnt].l = l;tree[cnt].r = (l+r)/2;
            tree[cnt]._size = (m-(m/2))*tree[k].add;tree[cnt].add = tree[k].add;
        }
        else    tree[tree[k].lon]._size +=(m-(m/2))*tree[k].add,tree[tree[k].lon].add += tree[k].add;
        if(tree[k].ron == 0){
            cnt++;tree[k].ron = cnt;//tree[cnt].l = (l+r)/2+1;tree[cnt].r = r;
            tree[cnt]._size = (m/2)*tree[k].add;tree[cnt].add = tree[k].add;
        }
        else    tree[tree[k].ron]._size +=(m/2)*tree[k].add,tree[tree[k].ron].add += tree[k].add;
        tree[k].add = 0;
    }
    void push_up(int k,int ln,int rn){
        tree[k]._size = tree[ln]._size+tree[rn]._size;
    }
    void _insert(int &k,int L,int R,int l,int r,int rt){
        if(k == 0){
            cnt++;tree[cnt].init();k = cnt;//tree[k].l = l;tree[k].r = r;
        }
        if(L <= l && R >= r){
            tree[k].add++;tree[k]._size += r-l+1;
            return ;
        }
        push_down(k,r-l+1,l,r);
        int m = (l+r)>>1;
        if(m >= L)  _insert(tree[k].lon,L,R,lson);
        if(m < R)   _insert(tree[k].ron,L,R,rson);
        push_up(k,tree[k].lon,tree[k].ron);
    }
    LL query(int k,int L,int R,int l,int r,int rt){
        if(l >= L && r <= R){
            return tree[k]._size;
        }
        push_down(k,r-l+1,l,r);
        //cout <<" k = "<<k<<endl;
        int m = (l+r)/2;
        LL ans = 0;
        if(m >= L && tree[k].lon)  ans += query(tree[k].lon,L,R,lson);
        if(m < R && tree[k].ron)   ans += query(tree[k].ron,L,R,rson);
        return ans;
    }
}pos_tree;//Çø¼äÏ߶ÎÊ÷

int lowbit(int x){
    return x&(-x);
}

void add(int pos,int a,int b){
    for(int i = pos ; i <= N ;i += lowbit(i)){
        pos_tree._insert(root[i],a,b,1,N,1);
    }
}

LL check(int pos,int posa,int posb){
    LL sum = 0;
    for(int i = pos; i>0 ;i-=lowbit(i)){
        sum += pos_tree.query(root[i],posa,posb,1,N,1);
    }
    return sum;
}

int bs(int posa,int posb,int k){
    int l = 1,r = N;
    while(l <= r){
        int mid = (l+r)>>1;
        LL cm = check(mid,posa,posb);//1~mid
        LL cm1 = check(mid-1,posa,posb);//1~mid-1
        if(cm >= k &&  cm1 < k){
            return mid;
        }
        else if(cm >= k)  r = mid-1;
        else    l = mid+1;  //cm<k&&cm1<k

    }
}
int op,a,b,c;
void sov(){
    pos_tree.cnt = 0;
    for(int i = 1;  i<= Q ; i++){
        scanf("%d",&op);
        if(op == 1){
            scanf("%d%d%d",&a,&b,&c);
            c = N-c+1;
            if(a > b)   swap(a,b);
            add(c,a,b);
        }
        else{
            scanf("%d%d%d",&a,&b,&c);
            if(a > b)   swap(a,b);
            printf("%d\n",N-bs(a,b,c)+1);
        }
    }
}



int main(){
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(~scanf("%d%d",&N,&Q)){

        sov();
    }
}

ac版本：

超时？不用二分答案，在线段树上，直接判断大的数够不够，不够的话，往左跑看加上多少左边的可以到达要求个，够的话就往右递归，看最小的范围（ｌ==r）时候，ac代码：

/*
线段树套线段树，外面是权值，每个节点上的线段树是位置，
比如，如果在1~4位置加入5 就是把整个线段树中有5的log个节点，
每个节点的1~4这log区间上++。。。。
然后每次询问的时候，
每个节点跑log个得到对应区间上的个数总和

*/

#include <cstdio>
#include <iostream>
#include <cstring>
#include <cmath>
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
using namespace std;
typedef long long LL;
const int maxn = 3e7+10;
const int maxm = 50000*4+10;
int root[maxm],N,Q;
struct pos_Tree{
    int lon,ron,add;
    unsigned int _size;
    void init(){
        lon = ron  = add = _size = 0;
    }
};

class segment_tree{
public:
    pos_Tree tree[maxn];LL cnt;
    void push_down(int k,int m,int l,int r){
        if(tree[k].add == 0)    return ;
        if(tree[k].lon == 0){
            cnt++;tree[k].lon = cnt;//tree[cnt].l = l;tree[cnt].r = (l+r)/2;
            tree[cnt]._size = (m-(m/2))*tree[k].add;tree[cnt].add = tree[k].add;
        }
        else    tree[tree[k].lon]._size +=(m-(m/2))*tree[k].add,tree[tree[k].lon].add += tree[k].add;
        if(tree[k].ron == 0){
            cnt++;tree[k].ron = cnt;//tree[cnt].l = (l+r)/2+1;tree[cnt].r = r;
            tree[cnt]._size = (m/2)*tree[k].add;tree[cnt].add = tree[k].add;
        }
        else    tree[tree[k].ron]._size +=(m/2)*tree[k].add,tree[tree[k].ron].add += tree[k].add;
        tree[k].add = 0;
    }
    void push_up(int k,int ln,int rn){
        tree[k]._size = tree[ln]._size+tree[rn]._size;
    }
    void _insert(int &k,int L,int R,int l,int r,int rt){
        if(k == 0){
            cnt++;tree[cnt].init();k = cnt;//tree[k].l = l;tree[k].r = r;
        }
        if(L <= l && R >= r){
            tree[k].add++;tree[k]._size += r-l+1;
            return ;
        }
        push_down(k,r-l+1,l,r);
        int m = (l+r)>>1;
        if(m >= L)  _insert(tree[k].lon,L,R,lson);
        if(m < R)   _insert(tree[k].ron,L,R,rson);
        push_up(k,tree[k].lon,tree[k].ron);
    }
    LL query(int k,int L,int R,int l,int r,int rt){
        if(l >= L && r <= R){
            return tree[k]._size;
        }
        push_down(k,r-l+1,l,r);
        //cout <<" k = "<<k<<endl;
        int m = (l+r)/2;
        LL ans = 0;
        if(m >= L && tree[k].lon)  ans += query(tree[k].lon,L,R,lson);
        if(m < R && tree[k].ron)   ans += query(tree[k].ron,L,R,rson);
        return ans;
    }
}pos_tree;//区间线段树

void build(int l,int r,int rt){
    root[rt] = 0;
    if(l == r)  return ;
    int m = (l+r)>>1;
    build(lson);
    build(rson);
}

void val_insert(int a,int b,int pos,int l,int r,int rt){
    if(pos >= l && pos <= r){
        pos_tree._insert(root[rt],a,b,1,N,1);
    }
    if(l == r)   return ;
    int m = (l+r)>>1;
    if(pos <= m)    val_insert(a,b,pos,lson);
    else    val_insert(a,b,pos,rson);
}


LL check(int posa,int posb,int num,int l,int r,int rt){
    if(l == r) return l;
    int m = (l+r)>>1,ans;
    LL n1 = (root[rt*2+1] == 0)?0:pos_tree.query(root[rt*2+1],posa,posb,1,N,1);
    if(n1 < num)    ans = check(posa,posb,num-n1,lson);
    else   ans = check(posa,posb,num,rson);
    return ans;
}


int op,a,b,c;
void sov(){
    pos_tree.cnt = 0;
    for(int i = 1;  i<= Q ; i++){
        scanf("%d",&op);
        if(op == 1){
            scanf("%d%d%d",&a,&b,&c);
            if(a > b)   swap(a,b);
            val_insert(a,b,c,1,N,1);
        }
        else{
            scanf("%d%d%d",&a,&b,&c);
            if(a > b)   swap(a,b);
            printf("%d\n",check(a,b,c,1,N,1));
        }
    }
}

int main(){
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    while(~scanf("%d%d",&N,&Q)){
        build(1,N,1);
        sov();
    }
    return 0;
}
/*
7 100
1 1 5 2
1 2 7 3
1 3 5 2
1 1 1 1
2 1 3 2
2 1 3 3
2 1 3 7
2 1 7 5
2 1 7 7
2 2 3 2
2 1 1 1
2 1 1 2
2 3 5 3
2 3 4 5
2 1 5 2
2 2 7 2
2 3 5 2
2 2 2 1
*/
zjy2015302395
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树状数组+线段树
小羊的博客
03-27 1250
树状数组+线段树 树状数组 动态求连续区间和 数星星 线段树 动态求连续区间和 数列区间最大值
线段树套线段树
weixin_30750335的博客
01-20 849
二维线段树一般用线段树套线段树写，当然也可以用四叉树写 树套树，顾名思义，外层树的每个节点都是一棵树。 题目地址：https://www.luogu.org/problemnew/show/U22582 首先要了解的知识： 线段树 标记永久化 标记永久化： 参考https://www.cnblogs.com/Hallmeow/p/8004676.html 简单地讲一下，如果要详细了解...
【序列操作IV】树状数组套线段树/树套树
weixin_30244681的博客
07-27 191
题目描述 给出序列a1，a2，…，an（0≤ai≤109），有关序列的两种操作。 1.ai（1≤i≤n）变成x（0≤x≤109）。 2.求al，al+1，…，ar（1≤l≤r≤n）第k（1≤k≤r-l+1）小。 输入格式 第一行包含两个数n（1≤n≤2×104）和m（1≤m≤2×104），表示序列长度和操作次数。 接下来一行n个数，以空格隔开，表示a1...
bzoj3110常数巨大的线段树套线段树......
guoshiyuan484的博客
07-12 404
这种题目一般是一个权值线段树套一个区间线段树可以改成树状数组套线段树。。。不解释了很常规......树套树恶心#include #include #include using namespace std; unsigned int sum[15000010], tree[300000], lson[15000010], rson[15000010],t[15000010]; unsigned in
[BZOJ3110][Zjoi2013]K大数查询（主席树套线段树||整体二分 ）
zyf2000
04-28 940
仿佛将那些年幼时的记忆 全部唤起的声音 已经被那温柔的笑脸 拯救过多少次
bzoj 3730. 震波（动态点分治 + vector树状数组）
01-06
因为子树树形被破坏，在做减法时，子节点子树对父节点的贡献不能用子树维护的信息 + 连向父节点的边的贡献得到，考虑在每个节点再维护一个线段树，按距离建树用来统计子树内的节点到其父节点距离为 p 的点权和，这样...
wangjunrui666#bzoj-problem##5165. 树上倍增1
最新发布
07-25
您需要写一个树上倍增算法，以实现如下操作：A x 新建一个节点，将它作为x节点的儿子，编号为当前节点总数+1。保证询问不超过1000次输出格式对于每一个Q操作，
Link-Cut-Tree 动态树经典讲稿附例题
10-11
适用ACM和OI等算法选手，Link-Cut-Tree 动态树经典讲稿，附BZOJ多道优秀练习题，原作者吉大附中实验学校 PoPoQQQ
树形数位动态规划_黄哲威.pdf
09-14
树形数位动态规划是一种在树状结构上进行动态规划的方法，主要应用于解决与树的节点权值和路径相关的优化问题。在这个主题中，我们将会深入探讨几种与树形数位动态规划相关的经典问题和解决方案。 首先，让我们看一...
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
【整体二分】[ZJOI 2013] bzoj3110 K大数查询
每天心塞一点点
04-06 4542
题目点这里 树套树题解点这里 调完这个。。一晚上居然就又过去了。。。TAT 先说下效率 我的树套树是283136 kb 7556 ms（永久化标记的）分治是3148 kb 1296 ms _(:з)∠)_代码长度的话。。两个都差不多T_____T 思路： 整体二分这玩意。。和cdq分治挺像的样子。。 从我的理解来说。。。cdq分治是用[l, mid]更新[mid
BZOJ 3110 K大数查询 树套树
-Claude
05-27 1250
BZOJ 3110 K大数查询 树套树(双线段树)
树形list（菜单树）递归遍历list
热门推荐
Kaer_GG的博客
08-19 1万+
有些时候为了方便jsp展示菜单，我们一般将查询出的菜单直接遍历重组成树形，再到前端展示。废话不多说，直接贴代码。 首先要写个entity类 package com.guo.test; public class TestEntity { private int id; private String name; private int parentId; private int leve
整体二分及cdq分治学习小结
Rayment的博客
07-18 1474
整体二分 基本思想 听上去十分的高大上，但是究其本质就是二分答案加强版，对有些题目，我们单次二分答案的代价可能无法做到O(logn)O(log⁡n)O(\log n)。但是对于每个询问它做的操作是几乎相同的，我们认为这类询问是可以合并在一起做的，那么大可不必对于每个询问都去二分答案，我们可以对询问进行分类，划到一个区间去再进行二分答案。 可以看一看2013年XHR的论文。要注意，分了区间...
树套树——树状数组套主席树
star_city
07-31 2535
线段树套平衡树是什么脑残东西，复杂度就是假的，O(nlog3n)O(nlog3n)O(nlog^3n)让人感觉非常不靠谱。所以我们为什么不用更好写的树状数组代替线段树，更好写的主席树（权值线段树）代替平衡树呢？而且，不仅是好写，复杂度也是很对的O(nlog2n)O(nlog2n)O(nlog^2n)啊。 我们来简单理解一下树套树是什么： 思想其实很简单，树状数组的每个节点都是一颗权值线段树，并...
bzoj3110【ZJOI2013】K大数查询
AaronPolaris
02-28 1645
线段树套线段树+二分答案
bzoj 3110 K大数查询(整体二分)
glk__'blog
08-13 950
题目传送门 3110: [Zjoi2013]K大数查询 Time Limit: 20 Sec  Memory Limit: 512 MB Submit: 5043  Solved: 1752 [Submit][Status][Discuss] Description 有N个位置，M个操作。操作有两种，每次操作如果是1 a b c的形式表示在第a个位置到第b个位置，每个位置加
BZOJ 3110
weixin_30245867的博客
12-09 92
http://www.lydsy.com/JudgeOnline/problem.php?id=3110 整体二分+区间修改树状数组维护 #include<cstdio> #define FOR(i,s,t) for(register int i=s;i<=t;++i) inline int max(int a,int b){return a>b?a:b;} ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值