可持久化线段树HDU2665、bzoj3207

最新推荐文章于 2021-03-29 10:40:15 发布
最新推荐文章于 2021-03-29 10:40:15 发布
阅读量689 收藏 1
点赞数
分类专栏： ACM/ICPC 文章标签： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012915516/article/details/47682603
版权

http://acm.hdu.edu.cn/showproblem.php?pid=2665

HDU2665..求区间K小。。可以用化分树、各种树来做。也可以用持久化线段树写。

代码：

#include <algorithm>
#include <algorithm>
#include <iostream>
#include<string.h>
#include <fstream>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define exp 1e-8
#define fi first
#define se second
#define ll long long
#define INF 0x3f3f3f3f
#define lson l,mid,rt<<1
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define rson mid+1,r,(rt<<1)+1
#define all(a) a.begin(),a.end()
#define mm(a,b) memset(a,b,sizeof(a));
#define for1(a,b) for(int a=1;a<=b;a++)//1---(b)
#define rep(a,b,c) for(int a=b;a<=c;a++)//b---c
#define repp(a,b,c)for(int a=b;a>=c;a--)///
using namespace std;
void bug(string m="here"){cout<<m<<endl;}
template<typename __ll> inline void READ(__ll &m){__ll x=0,f=1;char ch=getchar();while(!(ch>='0'&&ch<='9')){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}m=x*f;}
template<typename __ll>inline void read(__ll &m){READ(m);}
template<typename __ll>inline void read(__ll &m,__ll &a){READ(m);READ(a);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b){READ(m);READ(a);READ(b);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c){READ(m);READ(a);READ(b);READ(c);}
template < class T > T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template < class T > T lcm(T a, T b) { return a / gcd(a, b) * b; }
template < class T > inline void rmin(T &a, const T &b) { if(a > b) a = b; }
template < class T > inline void rmax(T &a, const T &b) { if(a < b) a = b; }
template < class T > T pow(T a, T b) { T r = 1; while(b > 0) { if(b & 1) r = r * a; a = a * a; b /= 2; } return r; }
template < class T > T pow(T a, T b, T mod) { T r = 1; while(b > 0) { if(b & 1) r = r * a % mod; a = a * a % mod; b /= 2; } return r; }

const int maxn=100000;
int sum[maxn*200],tot;
int tree[maxn*200],ls[maxn*200],rs[maxn*200];
void init()
{
    tot=0;
}
void build(int l,int r,int &rt)
{
    rt=tot++;
    sum[rt]=0;
    if(l==r)return ;
    int m=l+r>>1;
    build(l,m,ls[rt]);
    build(m+1,r,rs[rt]);
}
void update(int last,int p,int l,int r,int &rt)
{
    rt=tot++;
    ls[rt]=ls[last],rs[rt]=rs[last],sum[rt]=sum[last]+1;
    if(l==r)return ;
    int m=l+r>>1;
    if(p<=m) update(ls[last],p,l,m,ls[rt]);
    if(p>m) update(rs[last],p,m+1,r,rs[rt]);
}
int query(int ss,int tt,int l,int r,int k)
{
    if(l==r)return l;
    int cnt=sum[ls[tt]]-sum[ls[ss]];
    int m=r+l>>1;
    if(k<=cnt)
        return query(ls[ss],ls[tt],l,m,k);
    else return query(rs[ss],rs[tt],m+1,r,k-cnt);
}
int num[maxn+100];
int Hash[maxn+100];
void solve()
{
    int n,m;
    read(n,m);
    for1(i,n)
    {
        read(num[i]);
        Hash[i]=num[i];
    }
    sort(Hash+1,Hash+1+n);
    int cnt=unique(Hash+1,Hash+1+n)-Hash-1;
    for1(i,n)num[i]=lower_bound(Hash+1,Hash+1+cnt,num[i])-Hash;
    init();build(1,cnt,tree[0]);
    for1(i,n)update(tree[i-1],num[i],1,cnt,tree[i]);
    for1(i,m)
    {
        int a,b,c;
        read(a,b,c);
        printf("%d\n",Hash[query(tree[a-1],tree[b],1,cnt,c)]);
    }
}
int main()
{
    int cas;
    read(cas);
    while(cas--)
        solve();
}



http://acm.upc.edu.cn/problem.php?id=2224

题意：给一个序列，求区间【li,ri】内大小在【a,b】区间的数的多少。。

#include <algorithm>
#include <algorithm>
#include <iostream>
#include<string.h>
#include <fstream>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define exp 1e-8
#define fi first
#define se second
#define ll long long
#define INF 0x3f3f3f3f
#define lson l,mid,rt<<1
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define rson mid+1,r,(rt<<1)+1
#define all(a) a.begin(),a.end()
#define mm(a,b) memset(a,b,sizeof(a));
#define for1(a,b) for(int a=1;a<=b;a++)//1---(b)
#define rep(a,b,c) for(int a=b;a<=c;a++)//b---c
#define repp(a,b,c)for(int a=b;a>=c;a--)///
using namespace std;
void bug(string m="here"){cout<<m<<endl;}
template<typename __ll> inline void READ(__ll &m){__ll x=0,f=1;char ch=getchar();while(!(ch>='0'&&ch<='9')){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}m=x*f;}
template<typename __ll>inline void read(__ll &m){READ(m);}
template<typename __ll>inline void read(__ll &m,__ll &a){READ(m);READ(a);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b){READ(m);READ(a);READ(b);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c){READ(m);READ(a);READ(b);READ(c);}
template < class T > T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template < class T > T lcm(T a, T b) { return a / gcd(a, b) * b; }
template < class T > inline void rmin(T &a, const T &b) { if(a > b) a = b; }
template < class T > inline void rmax(T &a, const T &b) { if(a < b) a = b; }
template < class T > T pow(T a, T b) { T r = 1; while(b > 0) { if(b & 1) r = r * a; a = a * a; b /= 2; } return r; }
template < class T > T pow(T a, T b, T mod) { T r = 1; while(b > 0) { if(b & 1) r = r * a % mod; a = a * a % mod; b /= 2; } return r; }

const int maxn=50000;
int tree[maxn*20],ls[maxn*20],rs[maxn*20];
int sum[maxn*20],tot;
void init(){tot=0;}
void pushup(int rt)
{
    sum[rt]=sum[ls[rt]]+sum[rs[rt]];
}
void build(int l,int r,int &rt)
{
    rt=tot++;
    sum[rt]=0;
    if(l==r)return ;
    int m=r+l>>1;
    build(l,m,ls[rt]);
    build(m+1,r,rs[rt]);
}
void update(int last,int p,int l,int r,int &rt)
{
    rt=tot++;
    ls[rt]=ls[last],rs[rt]=rs[last];
    sum[rt]=sum[last]+1;
    if(l==r)return;
    int m=r+l>>1;
    if(p<=m)update(ls[last],p,l,m,ls[rt]);
    else    update(rs[last],p,m+1,r,rs[rt]);
}
int query(int ss,int tt,int l,int r,int L,int R)
{
    if(L<=l&&r<=R)
        return sum[tt]-sum[ss];
    int m=l+r>>1;
    int ret=0;
    if(L<=m)
        ret+=query(ls[ss],ls[tt],l,m,L,R);
    if(R>m)
        ret+=query(rs[ss],rs[tt],m+1,r,L,R);
    return ret;
}
int num[maxn+100];
int Hash[maxn+100];
void solve()
{
    int n,m;
    read(n,m);
    for1(i,n)
    {
        read(num[i]);
        Hash[i]=num[i];
    }
    sort(Hash+1,Hash+1+n);
    int cnt=unique(Hash+1,Hash+1+n)-Hash-1;
    for1(i,n)num[i]=lower_bound(Hash+1,Hash+1+cnt,num[i])-Hash;
    init();build(1,cnt,tree[0]);
    for1(i,n)update(tree[i-1],num[i],1,cnt,tree[i]);

    while(m--)
    {
        int a,b,c,d;
        read(a,b);read(c,d);
        c=lower_bound(Hash+1,Hash+1+cnt,c)-Hash;
        d=upper_bound(Hash+1,Hash+1+cnt,d)-Hash-1;
        if(d<c)puts("0");
        else printf("%d\n",query(tree[a-1],tree[b],1,cnt,c,d));
    }
}
int main()
{
    int cas;
    read(cas);
    for1(tt,cas)
    {
        printf("Case #%d:\n",tt);
        solve();
    }
    return 0;
}

bzoj 3207.... http://www.lydsy.com/JudgeOnline/problem.php?id=3207

题意：给一个序列，问某一个区间内是否有规定的子串。子串长度为k...

一开始还真不知道怎么做~~~居然还要hash.....

可以通过hash将子串转成一个数。原来的序列也通过hash转换成n-k+1个数。。。

题目就变为在某个区间内寻找某一个数是否存在。。。OMG...ORZ...

#include <algorithm>
#include <algorithm>
#include <iostream>
#include<string.h>
#include <fstream>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <queue>
#include <stack>
#include <map>
#include <set>
#define exp 1e-8
#define fi first
#define se second
#define ll long long
#define INF 0x3f3f3f3f
#define lson l,mid,rt<<1
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define rson mid+1,r,(rt<<1)+1
#define all(a) a.begin(),a.end()
#define mm(a,b) memset(a,b,sizeof(a));
#define for1(a,b) for(int a=1;a<=b;a++)//1---(b)
#define rep(a,b,c) for(int a=b;a<=c;a++)//b---c
#define repp(a,b,c)for(int a=b;a>=c;a--)///
using namespace std;
void bug(string m="here"){cout<<m<<endl;}
template<typename __ll> inline void READ(__ll &m){__ll x=0,f=1;char ch=getchar();while(!(ch>='0'&&ch<='9')){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}m=x*f;}
template<typename __ll>inline void read(__ll &m){READ(m);}
template<typename __ll>inline void read(__ll &m,__ll &a){READ(m);READ(a);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b){READ(m);READ(a);READ(b);}
template<typename __ll>inline void read(__ll &m,__ll &a,__ll &b,__ll &c){READ(m);READ(a);READ(b);READ(c);}
template < class T > T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
template < class T > T lcm(T a, T b) { return a / gcd(a, b) * b; }
template < class T > inline void rmin(T &a, const T &b) { if(a > b) a = b; }
template < class T > inline void rmax(T &a, const T &b) { if(a < b) a = b; }
template < class T > T pow(T a, T b) { T r = 1; while(b > 0) { if(b & 1) r = r * a; a = a * a; b /= 2; } return r; }
template < class T > T pow(T a, T b, T mod) { T r = 1; while(b > 0) { if(b & 1) r = r * a % mod; a = a * a % mod; b /= 2; } return r; }

const int maxn=100000+10;   //第一次不知道范围开了好大好大。。TLE
int tree[maxn*50],ls[maxn*50],rs[maxn*50];
int sum[maxn*50],tot;
void init(){tot=0;}
void build(int l,int r,int &rt)
{
    rt=tot++;
    sum[rt]=0;
    if(l==r)return ;
    int m=r+l>>1;
    build(l,m,ls[rt]);
    build(m+1,r,rs[rt]);
}
void update(int pre,int p,int l,int r,int &rt)
{
    rt=tot++;
    ls[rt]=ls[pre],rs[rt]=rs[pre];
    sum[rt]=sum[pre]+1;
    if(l==r)return ;
    int m=r+l>>1;
    if(p<=m)update(ls[pre],p,l,m,ls[rt]);
    else  update(rs[pre],p,m+1,r,rs[rt]);
}
bool query(int ss,int tt,int p,int l,int r)
{
    if(l==r)return sum[tt]>sum[ss];
    int m=l+r>>1;
    if(p<=m)return query(ls[ss],ls[tt],p,l,m);
    return query(rs[ss],rs[tt],p,m+1,r);
}
unsigned ll num[maxn];
unsigned ll f[maxn];
unsigned ll dat[maxn];
unsigned ll Hash[maxn];
int main()
{
    int n,m,k;
    read(n,m,k);
    for1(i,n)read(num[i]);
    for1(i,n)f[i]=f[i-1]*107+num[i];
    unsigned ll M=1;
    for1(i,k)M*=107;
    for(int i=k;i<=n;i++)
    {
        dat[i-k+1]=f[i]-f[i-k]*M;
        Hash[i-k+1]=dat[i-k+1];
    }
    int cnt=n-k+1;
    sort(Hash+1,Hash+1+cnt);
    cnt=unique(Hash+1,Hash+1+cnt)-Hash-1;
    for(int i=1;i<=n-k+1;i++)dat[i]=lower_bound(Hash+1,Hash+1+cnt,dat[i])-Hash;
    init();build(1,cnt,tree[0]);
    for1(i,n-k+1)update(tree[i-1],dat[i],1,cnt,tree[i]);
    while(m--)
    {
        int a,b,c;
        read(a,b);
        unsigned ll ret=0;
        for1(i,k)
        {
            read(c);
            ret=ret*107+c;
        }
        if(b-a+1<k)
        {
            puts("No");
            continue;
        }
        int idx=lower_bound(Hash+1,Hash+1+cnt,ret)-Hash;
        a--;
        b=b-k+1;
        if(!Hash[idx]||Hash[idx]!=ret)puts("Yes");
        else if(!query(tree[a],tree[b],idx,1,cnt)) puts("Yes");
        else puts("No");
    }
    return 0;
}


粽子猪zZ
关注
专栏目录
HDU 6278 Just h -index（可持久化线段树）
alpc_qleonardo
07-25 553
大致题意：给你一个序列，然后给你很多个询问，每个询问让你求给定区间[l,r]中，最大的h，使得区间中大于等于h的数字不小于h。湘潭邀请赛现场的题目。当时听了题目，没仔细想别的方法，就用莫队算法硬刚，运气不错算是过了。现在看来，这是一道可持久化线段树的好题。首先，这里的数字都是1~n之间的，所以我们可以按照数字的大小插入线段树，每个点维护对应数字出现的次数和对应区间的数字和。然后，因为有区间操作，所以加上可持久化操作，每一次都是右端点对应线段树减去左端点对应线段树。那么问题的关键就是怎么求这个最大的h。这个h
hdu5919：Sequence II（可持久化线段树）
KsCla
04-18 1177
题目传送门：http://acm.hdu.edu.cn/showproblem.php?pid=5919 题目大意：给出一个拥有不超过2*10^5个元素的序列，再给出2*10^5个询问，对于每一个询问[L,R]，我们假设区间内有k个不同的数，他们在这个区间内第一次出现的位置分别为p1,p2,p3……pk，排序后输出第(k/2向上取整)个数。本题采用强制在线。 如原序列为：1 1 2 3 3，询
hdu4348 To the moon（可持久化线段树+标记永久化）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
08-01 431
题意： 给定长度为n的序列，m次操作，一开始的时间戳为0 操作有四种： （1）C l r d：区间[l,r]中的数都加1，同时当前的时间戳加1 。 （2）Q l r：查询当前时间戳区间[l,r]中所有数的和 。 （3）H l r t：查询时间戳t区间[l,r]的和 。 （4）B t：将当前时间戳置为t 。即回到过去t时刻。 数据范围：n,m<=1e5 解法： 显然可持久化， 但是涉及区间修改操作，所以要将标记永久化，而不能pushdown，因为pushdown需要新建的区间点太多。 标记永久化就是给节
hdu 4417 可持久化线段树 (区间<=x的数的数量
Cross
08-13 1127
链接：戳这里 Super Mario Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Problem Description Mario is world-famous plumber. His “burly” figure and amazi
可持久化线段树练习（一）
蒲公英殇的博客
03-29 232
可持久化线段树的简单题
BZOJ 4771 七彩树（可持久化线段树合并）
weixin_30300523的博客
12-25 75
题意 https://www.lydsy.com/JudgeOnline/problem.php?id=4771 思路 和 HDU 3333 其实有点像，不过是把序列的问题放在了树上，多维护一个深度即可。每个点用一个线段树维护子树内每个深度有多少种颜色（同样只保留每个颜色最浅位置），用线段树合并进行合并，由于要保留之前的颜色，所以合并应该可持久化。 为了将相同的颜色去除，再开一个线段树维...
可持久化线段树
窦小雨的小点子
11-23 257
之前在 codeforces 做过一道题目，算是第一次接触这东西吧。 题目的要求是，对一个n行n列的格子进行维护。单点更新或者区间更新。还有一个是返回第 k 次更新的状态。 直接就懵逼了。0.0   这是个什么鬼。 如果每次操作我都要记录状态的话，不用想，肯定内存会爆炸的。那我如果遇到该回去的操作时再原路返回，肯定时间会爆炸的。好吧，我知道我肯定要学一种新的数据结构了。 不过对这个题目后来
学习笔记:可持久化线段树
diaoxiangxi0422的博客
07-07 167
1、前言 线段树，众所周知，在树中的每一个元素中，保存的是线段中的一段，所维护的内容或是最大最小值，或是和等等。可持久化线段树，属于可持久化数据结构中的一种，对于可持久化数据结构这个大知识，我暂时没有去研究，今天只讲其冰山一角。 2、概念 先讲”可持久化...
BZOJ 5358 口算训练/HDU 6287（可持久化线段树）
weixin_30512785的博客
06-12 77
题意：给你L,R区间然后给你一个K，询问L到R区间的数知否能整除K 思路：因为我们是判断是否整除，所以我们可以对每一个数进行质因数分解，然后判断L到R区间内的数质因数分解后的个数大小就可以了，然后就是打表，进行主席树维护 代码： #include <cstdio> const int maxn=1e5+7; bool prime[maxn]; int pri[max...
【题解】「HDU1166」敌兵布阵(线段树)
01-20
题面 【题目描述】 有nnn个营地，已知每个营地的人数，有四条命令： (1)Add(1) Add(1)Add iii jjj，iii和jjj为正整数,表示第iii个营地增加jjj个人（jjj不超过303030） (2)Sub(2)Sub(2)Sub iii jjj ，iii和jjj为正...
可持久化线段树入门题 hdu2665 求区间第k小的数
Nicolas
09-16 2686
注意：这题题意写错了，不是区间第k大，而是区间第k小， WA了一地，看了discuss才知道，坑啊 参考了clj的论文《可持久化数据结构研究》，具体做法论文里很明确。 其实思想还是建多颗线段树，只是把这些线段树数据不相同的部分另外建了一些节点。 对于m个询问，每次要建log(n)的节点，需要 n*2+mlog(n)的内存，这题写得不好数组就开不下了 #include #inc
可持久化线段树 HDU4866 Shooting
09-08 588
题目链接  一些平行于x轴的线段作为射击目标，每次在x轴上选一个点向y轴方向射击，可以射中最近的k个目标，得分是射中目标的高度和，求这个得分。 对高度建立函数式线段树，按顺序对x轴坐标建树，维护区间和和区间个数，每次设计询问该线段树即可。 #include #include #include #include #include #include #include #incl
HDU - 5390 tree （可持久化字典树+线段树）
_Griefs
08-26 199
题目vj链接 题面： 题意： 给定一棵有根树，根节点为1，节点 iii 的权值为 vivivi。 有以下两种操作： （1） 0 x y ---- 将节点 xxx 的权值改为 yyy （2） 1 x ---- 查询 vx xor vtv_x\space xor\space v_tvx​ xor vt​ 的最大值，其中 t∈path(x,root)t \in path(x,root)t∈path(x,root) 题解： ①、考虑不带修改 vxv_xvx​ 是一个已知的
【数据结构】可持久化线段树&Trie总结
氧化钠的博客
11-22 1287
可持久化：可以访问历史版本的“升级版”的数据结构，利用访问历史版本的性质，可以做到许多在区间上的操作。可持久化线段树：例题： cqoi2111：区间第k大 给定一个长度为n的序列，m个询问，每个询问的形式为：l，r，k表示在[l,r]间中的第k大元素. (n<=100000, m<=100000,1<=l<=r<=n, 1<=k<=r-l+1) 如果用线段树来储存某个区间的第i大，显然是
基于java网上球鞋竞拍系统设计与实现.docx
09-19
基于java网上球鞋竞拍系统设计与实现.docx
基于bert实现关系三元组抽取python源码+数据集+项目说明.zip
最新发布
09-19
基于bert实现关系三元组抽取python源码+数据集+项目说明.zip基于bert实现关系三元组抽取python源码+数据集+项目说明.zip基于bert实现关系三元组抽取python源码+数据集+项目说明.zip基于bert实现关系三元组抽取python源码+数据集+项目说明.zip基于bert实现关系三元组抽取python源码+数据集+项目说明.zip 个人大四的毕业设计、课程设计、作业、经导师指导并认可通过的高分设计项目，评审平均分达96.5分。主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者，也可作为课程设计、期末大作业。 [资源说明] 不懂运行，下载完可以私聊问，可远程教学 该资源内项目源码是个人的毕设或者课设、作业，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96.5分，放心下载使用！ 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请放心下载使用！ 2、本项目适合计算机相关专业(如计科、人工智能、通信工程、自动化、电子信息等)的在校学生、老师或者企业员工下载学习，也适合小白学习进阶，当然也可作为毕设项目、课程设计、作业、项目初期立项演示等。 3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可用于毕设、课设、作业等。 下载后请首先打开README.md文件（如有），供学习参考。
基于java的足球赛会管理系统设计与实现.docx
09-19
基于java的足球赛会管理系统设计与实现.docx
基于java的婚纱摄影网的设计与实现.docx
09-19
基于java的婚纱摄影网的设计与实现.docx
NotOnlySuccess的线段树完全解析
3. HDU 1394 最小逆序数：此问题需要在线段树中实现单点增减，并进行区间求和。通过线段树，可以在O(n log n)的时间复杂度内预处理初始逆序数，然后以O(1)的时间复杂度递推出其他解。 4. HDU 2795 Billboard：这是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值