HDU4417-主席树-划分树-离线树状数组-分块-线段树-归并树-总结

最新推荐文章于 2019-08-30 09:45:44 发布
最新推荐文章于 2019-08-30 09:45:44 发布
阅读量514 收藏
点赞数
分类专栏： 线段树 主席树+划分树 莫队/分块 树状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39599067/article/details/80586932
版权
题目：传送门

给你一段长为n序列，m次询问，询问[L,R]区间内小于等于H的数有多少个。
数据范围，n，m<=1e5

结果：

树状数组: 249ms
主席树: 218ms
归并树: 374ms
分块:C++TLE / G++AC --(不过C++把块的大小扩大3倍也能过)
归并树: TLE
线段树: WA (求大佬找下bug，我真不知道为什么会wa，感觉对如闪电

(TLE和WA一定是我太垃圾，写残了，orz)

代码如下：

主席树: AC

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e6+5;
int n,m;
struct lp{
	int l,r,sum;
}cw[N*20];
int rak[N],ar[N],br[N],tot;
void update(int l,int r,int last,int &cur,int x){
	cw[++tot]=cw[last];
	cw[tot].sum = cw[last].sum + 1;
	cur=tot;
	if(l==r)return;
	int mid=(l+r)>>1;
	if(x<=mid)update(l,mid,cw[last].l,cw[cur].l,x);
	else update(mid+1,r,cw[last].r,cw[cur].r,x);
}
int query(int l,int r,int last,int cur,int k){
	if(l==r)return cw[cur].sum-cw[last].sum;
	int mid=(l+r)>>1;
	if(k<=mid)return query(l,mid,cw[last].l,cw[cur].l,k);
	else {
		int ans=query(mid+1,r,cw[last].r,cw[cur].r,k);
		ans+=cw[cw[cur].l].sum-cw[cw[last].l].sum;
		return ans;
	}
}
int main(){
   	int tim;scanf("%d",&tim);
   	int T=0;
	while(tim--){
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;++i){
			scanf("%d",&ar[i]);
			br[i]=ar[i];
		}
		sort(br+1,br+1+n);
		int k=1;
		for(int i=2;i<=n;++i){
			if(br[i]!=br[i-1]){
				br[++k]=br[i];
			}
		}
		tot=0;cw[0].l=cw[0].r=cw[0].sum=0;
		memset(rak,0,sizeof(rak));
		for(int i=1;i<=n;++i){
			int p=lower_bound(br+1,br+1+k,ar[i])-br;
			update(1,k,rak[i-1],rak[i],p);
		}
		printf("Case %d:\n",++T );
		for(int i=0,u,v,w;i<m;++i){
			scanf("%d%d%d",&u,&v,&w);
			u++;v++;
			int p=upper_bound(br+1,br+1+k,w)-br-1;
			if(p)printf("%d\n",query(1,k,rak[u-1],rak[v],p) );
			else printf("0\n");
		}
	}
	return 0;
}

线段树：WA

#include<bits/stdc++.h>
#define lson rt<<1
#define rson rt<<1|1
#define lsonl rt<<1,l,m
#define rsonr rt<<1|1,m+1,r
using namespace std;
typedef long long LL;
const int N = 1e5+5;
int n,m,Ans[N];
struct lp{
	int l,r,sum;
}cw[N<<2];
struct lh{
	int val,id,l,r;
	bool operator <(const lh a)const{
		return val<a.val;
	}
}ar[N],br[N];
void build(int rt,int l,int r){
	cw[rt].l=l;cw[rt].r=r;cw[rt].sum=0;
	int mid=(l+r)>>1;
	if(l==r)return;
	build(lson,l,mid);
	build(rson,mid+1,r);
}
void update(int rt,int x){
	cw[rt].sum++;
	if(cw[rt].l==cw[rt].r){
        return;
    }
    int m=(cw[rt].l+cw[rt].r)/2;
    if(x<=m)update(lson,x);
    else update(rson,x);
}
int query(int rt,int l,int r){
	if(l=cw[rt].l&&cw[rt].r==r){
		return cw[rt].sum;
	}
	int m=(cw[rt].l+cw[rt].r)>>1;
	if(l>m) return query(rson,l,r);
    else if(r<=m) return query(lson,l,r);
    else{
        return query(lsonl)+query(rsonr);
    }
}
int main(){
   	int tim;
   	int T=0;
   	scanf("%d",&tim);
	while(tim--){
		scanf("%d%d",&n,&m);
		for(int i=0;i<n;++i){
			scanf("%d",&ar[i].val);
			ar[i].id=i+1;
		}
		for(int i=0;i<m;++i){
			scanf("%d%d%d",&br[i].l,&br[i].r,&br[i].val);
			br[i].id=i;
		}
		sort(ar,ar+n);
		sort(br,br+m);
		build(1,1,n);
		printf("Case %d:\n",++T );
		for(int i=0,j=0;i<m;++i){
			while(j<n&&ar[j].val<=br[i].val){
				update(1,ar[j].id);
				j++;
			}
			Ans[br[i].id]=query(1,br[i].l+1,br[i].r+1);
		}
		for(int i=0;i<m;++i){
			printf("%d\n",Ans[i] );
		}
	}
	return 0;
}

分块：AC。。。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e6+5;
int n,m;
int block,num,belong[N],ls[N],rs[N];
int ar[N];
vector<int>bk[N];
void build(){
	block=3*sqrt(n*1.0);
	num=n/block;if(n%block)num++;
	for(int i=1;i<=n;++i){
		belong[i]=(i-1)/block+1;
	}
	for(int i=1;i<=num;++i){
		ls[i]=(i-1)*block+1;
		rs[i]=i*block;
	}
	rs[num]=n;
	for(int i=0;i<=num;++i)bk[i].clear();
	for(int i=1;i<=n;++i){
		bk[belong[i]].push_back(ar[i]);
	}
	for(int i=1;i<=num;++i){
		sort(bk[i].begin(),bk[i].end());
	}
}
void get(int u,int v,int w){
	int cnt=0;
	if(belong[u]==belong[v]){
		for(int i=u;i<=v;++i){
			if(ar[i]<=w)cnt++;
		}
		printf("%d\n",cnt );
		return;
	}
	for(int i=belong[u]+1;i<belong[v];++i){
		int p=upper_bound(bk[i].begin(),bk[i].end(),w)-bk[i].begin();
		cnt+=(p<0?0:p);
	}
	if(u==ls[belong[u]]){
		int i=belong[u];
		int p=upper_bound(bk[i].begin(),bk[i].end(),w)-bk[i].begin();
		cnt+=(p<0?0:p);		
	}else{
		for(int i=u;i<=rs[belong[u]];++i){
			if(ar[i]<=w)cnt++;
		}
	}
	if(v==rs[belong[v]]){
		int i=belong[v];
		int p=upper_bound(bk[i].begin(),bk[i].end(),w)-bk[i].begin();
		cnt+=(p<0?0:p);
	}else{
		for(int i=ls[belong[v]];i<=v;++i){
			if(ar[i]<=w)cnt++;
		}
	}
	printf("%d\n",cnt );
}
int main(){
   	int tim;scanf("%d",&tim);
   	int T=0;
	while(tim--){
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;++i){
			scanf("%d",&ar[i]);
		}
		build();
		printf("Case %d:\n",++T );
		for(int i=0,u,v,w;i<m;++i){
			scanf("%d%d%d",&u,&v,&w);
			get(u+1,v+1,w);
		}
	}
	return 0;
}

归并树：TLE

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e5+5;
int n,m;
int cw[20][N];
int ar[N];
void build(int dep,int l,int r){
    if(l==r){
        cw[dep][l]=ar[l];
        return;
    }
    int mid=(l+r)>>1;
    build(dep+1,l,mid);
    build(dep+1,mid+1,r);
    int i=l,j=mid+1,k=l;
    while(i<=mid||j<=r){
        if(j>r||(i<=mid&&cw[dep+1][i]<=cw[dep+1][j])){
            cw[dep][k++]=cw[dep+1][i++];
        }else{
            cw[dep][k++]=cw[dep+1][j++];
        }
    }
}
int query(int dep,int l,int r,int L,int R,int key){
    if(L>r||R<l)return 0;
    if(L<=l&&r<=R){
        return lower_bound(&cw[dep][l],&cw[dep][r]+1,key)-&cw[dep][l];
    }
    int mid=(l+r)>>1;
    return query(dep+1,l,mid,L,R,key)+query(dep+1,mid+1,r,L,R,key);
}
int solve(int n,int L,int R,int k){
    int l=1,r=n,ans=1,mid;
    while(l<=r){
        mid=(l+r)>>1;
        int cnt=query(0,1,n,L,R,cw[0][mid]);
        if(cnt>k){
            r=mid-1;
            ans=mid-1;
        }else{
            ans=mid;
            l=mid+1;
        }
    }
    return cw[0][ans];
}
int main(){
   	int tim,T=0;
   	scanf("%d",&tim);
    while(tim--){
    	scanf("%d%d",&n,&m);
        for(int i=1;i<=n;++i){
            scanf("%d",&ar[i]);
        }
        build(0,1,n);
        printf("Case %d:\n",++T );
        while(m--){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            x++;y++;
            int l=1,r=y-x+1,mid,ans=0,tmp;
            while(l<=r){
            	mid=(l+r)>>1;
            	tmp=solve(n,x,y,mid-1);
            	if(tmp<=z){
					l=mid+1;
					ans=mid;
				}else{
					r=mid-1;
					ans=mid-1;
				}
            }
            printf("%d\n",ans );
        }
    }
    return 0;
}

树状数组: AC

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
const int N = 1e5+5;
int n,m;
int ar[N],sum[N];
inline int lowbit(int x){
	return x&(-x);
}
inline void add(int x,int d){
	while(x<=n){
		ar[x]+=d;
		x+=lowbit(x);
	}
}
inline int query(int x){
	int ans=0;
	while(x){
		ans+=ar[x];
		x-=lowbit(x);
	}
	return ans;
}
struct lh{
	int val,id;
}br[N];
bool cmp1(lh &a,lh &b){
	if(a.val!=b.val)return a.val<b.val;
	return a.id<b.id;
}
struct lp{
	int l,r,id,val;
}cw[N];
bool cmp2(lp &a,lp &b){
	if(a.val!=b.val)return a.val<b.val;
	return a.id<b.id;
}
int main(){
   	int tim;scanf("%d",&tim);
   	int T=0;
	while(tim--){
		scanf("%d%d",&n,&m);
		for(int i=0;i<n;++i){
			scanf("%d",&br[i].val);
			br[i].id=i+1;
		}
		for(int i=0;i<m;++i){
			scanf("%d%d%d",&cw[i].l,&cw[i].r,&cw[i].val);
			cw[i].l++;cw[i].r++;
			cw[i].id=i+1;
		}
		sort(br,br+n,cmp1);
		sort(cw,cw+m,cmp2);
		memset(ar,0,sizeof(ar));
		for(int i=0,j=0;i<m;++i){
			while(j<n&&br[j].val<=cw[i].val){
				add(br[j].id,1);
				j++;
			}
			sum[cw[i].id]=query(cw[i].r)-query(cw[i].l-1);
		}
		printf("Case %d:\n",++T );
		for(int i=1;i<=m;++i){
			printf("%d\n",sum[i] );
		}
	}
	return 0;
}

划分树：AC

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e5+5;
int n,m,sor[N];
struct lp{
	int cnt[N];
	int num[N];
}cw[22];
void build(int l,int r,int d){
	if(l==r)return;
	cw[d].num[0]=cw[d].cnt[0]=0;
	int same=0,mid=(l+r)>>1;
	for(int i=mid;i>=l;--i){
		if(sor[mid]==sor[i])same++;
		else break;
	}
	int lpos=l,rpos=mid+1,cnt=0;
	for(int i=l;i<=r;++i){
		if(cw[d].num[i]<sor[mid]){
			cw[d+1].num[lpos++]=cw[d].num[i];
			cnt++;
		}else if(cw[d].num[i]==sor[mid]&&same){
			same--;cnt++;
			cw[d+1].num[lpos++]=cw[d].num[i];
		}else{
			cw[d+1].num[rpos++]=cw[d].num[i];
		}
		cw[d].cnt[i]=cnt;
	}
	build(l,mid,d+1);
	build(mid+1,r,d+1);
}
int query(int l,int r,int L,int R,int k,int d){
	if(l==r)return cw[d].num[l];
	int mid=(l+r)>>1,newl,newr,left=0,sum_in_left;
	if(l==L){
		sum_in_left=cw[d].cnt[R];
	}else{
		left=cw[d].cnt[L-1];
		sum_in_left=cw[d].cnt[R]-left;
	}
	if(k<=sum_in_left){
		newl=l+left;
		newr=newl+sum_in_left-1;
		return query(l,mid,newl,newr,k,d+1);
	}else{
		newl=mid+L-l+1-left;
		newr=newl+R-L+1-sum_in_left-1;
		return query(mid+1,r,newl,newr,k-sum_in_left,d+1);
	}
}
int main(){
   	int tim;scanf("%d",&tim);
   	int T=0;
	while(tim--){
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;++i){
			scanf("%d",&sor[i]);
			cw[0].num[i]=sor[i];
		}
		sort(sor+1,sor+1+n);
		build(1,n,0);
		printf("Case %d:\n",++T );
		for(int i=0,u,v,w;i<m;++i){
			scanf("%d%d%d",&u,&v,&w);
			u++;v++;
			int l=1,r=v-u+1,mid,ans=0,tmp;
			while(l<=r){
				mid=(l+r)>>1;
				tmp=query(1,n,u,v,mid,0);
				if(tmp<=w){
					l=mid+1;
					ans=mid;
				}else{
					r=mid-1;
					ans=mid-1;
				}
			}
			printf("%d\n",ans );
		}
	}
	return 0;
}
Cwolf9
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HH神总结的线段树专辑-超经典的
08-12
### 线段树经典知识点解析 #### 一、线段树简介与代码风格 **线段树**是一种用于高效处理区间查询与更新操作的数据结构。...希望通过对这些经典题目的分析和总结，能够帮助读者更好地理解和掌握线段树的相关知识。
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
[HDU 5919] Sequence II （主席树）
mysterious
10-05 1006
链接HDU 5919题意CCPC的I题。给出一个序列，问区间[l, r]中所有不同元素出现的第一个位置（取最左）组成的序列中的中位数。 第i个询问区间依赖于第i-1个询问的答案，所以是强制在线的。题解比较经典的主席树维护区间种类问题的变形。相同元素只取最左侧位置，所以对序列a，从a[n]到a[1]建立主席树，插入新元素到主席树中时取消相同元素的贡献，只保留最左侧元素。 查询[l, r]的时候，查
HDU4417（主席树）
无限大な梦のあとの 何もない世の中じゃ
03-28 2994
前言：今天刚学的主席树，附上博客：主席树 个人觉得这篇文章写的非常好。认识：主席树就是对于序列1...n1...n的每一个前缀都构造一颗线段树来维护所要求的值。也就是说主席树实际上就是nn棵线段树。那么为什么不会MLEMLE？这个下面再说。先说一个经典的问题：静态区间第kk大？（求区间[l,r][l,r]之间第kk大的元素。无修改） 那么对于序列的前缀，需要知道[1,l−1][1,l-1]和[1,
HDU6278(主席树)
qq_39861441的博客
03-22 364
解题思路：一开始把题意理解错了，以为必须个数要等于h，其实大于等于h就行了。由于是取最大，所以得排序得从大到小排序。其他就是普通的主席树 #include<cstdio> #include<cstring> #include<algorithm> #include<iostream> #define N 100009 using namespac...
HDU：6703-array（主席树）
二营长的意大利炮友
08-30 157
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6703 题意：现在有一个长度问nnn的数列，数列里面的数各不相同且都属于[1,n][1,n][1,n]，有mmm次操作，每次操作包含两种情况，第一种是找一个pospospos，将第pospospos个数改成num[pos]+10,000,000num[pos]+10,000,000num[pos]+10...
hdu4417（主席树）
u013509299的专栏
08-11 1189
题意：求区间中比某个数小的数字有几个 思路：离散化，然后用主席树来解jiuk
基环树 笛卡尔树--2021.09.06(E).pdf
09-06
基环树是一种特殊的树形结构，它可以用于解决许多计算机科学和信息学的问题。笛卡尔树是一种特殊的基环树，它可以用于解决许多计算机科学和信息学的问题。笛卡尔树的妙用包括解决直方图中最大的矩形、单调栈的应用、...
SFF-8613硬盘连接器标准规范
最新发布
03-23
SFF-8613是存储网络工业协会（SNIA）制定的硬盘连接器标准规范，用于定义Mini Multilane 4/8X Unshielded Connector（HDun）的物理接口和性能要求。该规范是由SFF委员会制定的，旨在提供一个通用的参考标准供系统...
hdu 5919(主席树)
阿狸的博客
09-14 374
思路：主席树的模板题目，我们倒着插入题目就变成了，查询区间不同数的个数k，然后查询区间第(k+1)/2大。写了一下午，发现初始化写错了，初始化的cnt应该是1，还有数组大小要开36倍左右，我刚开始开的20倍一直tle。 #include &lt;stdio.h&gt; #include &lt;string.h&gt; #include &lt;algorithm&gt;; const int...
HDU 2665-Kth number（主席树）
信仰.的博客
08-29 584
题意：给你n个数，然后m次询问，每次询问区间[l,r]第k小的数是多少 题解：一般做法，每次将询问的区间存起来然后排序求解，这样复杂度是n^2log(n)，太暴力了，呢我们怎么做呢，这里便是采用一种常用姿势（学会之前并不觉得常用），主席树来搞（其实树状数组也能瞎搞搞），既然是第一次搞主席树，呢我就粗略的描述一下，主席树，很多人叫做可持久化线段树，顾名思义就是可以保存之前的状态和更新当前状态，其实
HDU 5915 (二分 主席树)
morejarphone~
10-15 614
题目链接：点击这里题意：给出一个序列，每次询问一个区间[l,r][l,r]，假设里面有kk个数字，求第⌈k/2⌉\lceil k/2 \rceil个出现的数字的下标.区间出现的不同数字的个数就是这个题，用主席树写好一套函数以后二分位置每次主席树上query来check一下就好了。#include <bits/stdc++.h> using namespace std; #define maxn 20
HDU 5919 （还算基础的主席树）
妍恐龙的博客....^~^眼熟我
10-11 585
                                    Sequence II Time Limit: 9000/4500 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 1045    Accepted Submission(s): 251
hdu_2665_Kth number(主席树)
bin_gege的博客
05-21 618
题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=2665 题意：给你一个区间，让你找这个区间第K大的数 题解：主席树模版题，也可以用划分树 #include #include #include #define FFC(i,a,b) for(int i=a;i<=b;++i) using namespace std; const int maxn
【hdu4417】Super Mario——主席树
weixin_30686845的博客
08-18 158
题目链接 题目大意为给定一个长度为n的区间，同时给出m个询问，每次询问在区间[l,r]中有多少个数小于或等于k。 同样考虑用主席树来维护，每次只需要找到序列b中第一个等于k的数，那么要求的数必定在b[1]~b[upper_bound(k)]这个范围内，接下来就像线段树统计区间个数那样，若完全包含则直接加上e[rr].sum-e[ll].sum,否则就分两边递归统计。而建树什么的就直接套模板即可...
Just h -index(HDU6278 主席树解法 湘潭邀请赛)
ccsu_deer
03-23 389
http://acm.hdu.edu.cn/showproblem.php?pid=6278 Just h -index Time Limit: 6000/3000 MS (Java/Others)Memory Limit: 132768/132768 K (Java/Others) Total Submission(s): 856Accepted Su...
分块（简单版树状数组，线段树）
a8512565的博客
11-06 273
前言 首先，在NOIP的比赛里分块是一个很好的水分神器，因为它可以代替树状数组，线段树，但是如果出题人要卡你的程序的话...... 分块思想 包含n个元素的整数数组A，每次可以 C(i, j) : 修改一个元素A[i] = j Q(i, j) : 询问A[i]+A[i+1]+…+A[j]的值 如何设计算法，使得修改和询问操作的时间复杂度尽量低？ 显然存在修改O(1)，查询O(n)...
HDU-4417 Super Mario,划分树+二分！
weixin_30339969的博客
02-27 74
Super Mario 这个题也做了一天，思路是很清晰，不过二分那里写残了，然后又是无限RE。。 题意：就是查询区间不大于k的数的个数。 思路：裸划分树+二分答案。将区间长度作为二分范围。这个是重点。没AC之前无限YY，AC之后却又觉得不过如此。int a[N],tree[30...
Super Mario HDU - 4417
sunyutian1998的博客
04-05 343
点击打开链接 两种做法 主席树模板题 对两个版本的线段树进行区间查询 然后做差即可 #include &lt;bits/stdc++.h&gt; using namespace std; struct node { int nl; int nr; int val; }; map &lt;int,int&gt; mp; node tree[2000010]; in...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值