HDU3473+CSU1080-划分树求静态区间前k大数的和-主席树求动态区间前k的和

最新推荐文章于 2022-04-08 00:26:39 发布
最新推荐文章于 2022-04-08 00:26:39 发布
阅读量1.4k 收藏
点赞数
分类专栏： 主席树+划分树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39599067/article/details/80461387
版权

（有任何问题欢迎留言或私聊


这两天看了一下划分树的博客，推荐一个**大神博客,一看就懂。**


下面讲一下这两题题划分树的应用。

首先是HDU3473：

 题目意思很裸，读完应该就知道xi应该就是中位数。

 划分树建树复杂度时nlogn，m次查询，划分树每次查询是log复杂度。

 所以要处理出来的就是怎么O(1)求出表达式的值。

 解决方法就是把绝对值去掉，xi左边的比xi小，xi右边的比xi大，所以：

化简公式

 sum = numLxi-sumL+0+sumR-numRxi

numL是在[LR]区间中小于xi的个数=mid-L
numR是在[LR]区间中大于xi的个数=R-mid
sumL是[LR]区间中小于xi的数的和
sumR是[LR]区间中大于xi的数的和

 numL和numR很好求出来，问题在于如果枚举sumL的和复杂度是O(n)，肯定吃不消。
 为了把复杂度降低到O(log)可以用划分树求解。

 在普通划分树中再加一个sum数组，sum[i]记录的是本段从开头带i进入左子树的权值之和。
 具体看代码解释，十分详细。

AC代码：
#include<cstdio>  
#include<algorithm>
#include<cstring>
#include<cassert>  
using namespace std;
const int N = 100005;  
typedef long long LL;
/*
首先思考一下可只xi应该是中位数
我们要O1算出答案，算的时候xi在左边还是右边都行
把绝对值去掉就是: (numL*xi-sumL)+(sumR-numR*xi)
在划分树中加一个sum数组可以求出numL和sumL，再处理一个前缀和数组
sumL=sum;
sumR=pre[R]-pre[L-1]-sum;
numL=num;
numR=R-L+1-num;
mid=(R-L+2)>>1;
tmp=xi=query(mid);
sum=pre[y]-pre[x-1]-sum*2-(y-x+1-num-num)*tmp;
*/
struct lp{
	int cnt[N];//本层中从本段左端点到i有多少个进入左子树
	int num[N];//本层中从本段的数字排列
	LL sum[N];本层中从1到i进入左子树的权值和
}cw[22];
LL pre[N],sum;
int n,m,num;
int sor[N];
int build(int l,int r,int d){
	if(l==r)return cw[d].num[l];
	cw[d].sum[0]=cw[d].cnt[0]=0;
	int same=0,mid=(l+r)>>1;
	for(int i=mid;i>=l;--i){//左边有多少的和mid值相等
		if(sor[i]==sor[mid])same++;
		else break;
	}
	int cnt=0;
	int li=l,ri=mid+1;//下一层分段的起点，反正左右两边肯定是均分的(可能差1)
	for(int i=l;i<=r;++i){
		cw[d].sum[i]=cw[d].sum[i-1];//前缀进入左子树权值和
		if(cw[d].num[i]<sor[mid]){//小于mid一律入左子树
			cw[d+1].num[li++]=cw[d].num[i];
			cw[d].sum[i]+=cw[d].num[i];
			cnt++;
		}else if(cw[d].num[i]==sor[mid]&&same){
			same--;
			cnt++;
			cw[d+1].num[li++]=cw[d].num[i];
			cw[d].sum[i]+=cw[d].num[i];
		}else{
			cw[d+1].num[ri++]=cw[d].num[i];
		}
		cw[d].cnt[i]=cnt;//统计本段到i进入左子树数量
	}
	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 left=0,sum_in_left=0,mid=(l+r)>>1;
	if(L==l){
		sum_in_left=cw[d].cnt[R];
	}else{
		sum_in_left=cw[d].cnt[R]-cw[d].cnt[L-1];//这是LR区间中进入左子树的数量
		left=cw[d].cnt[L-1];//这是本段[l,L)区间中进入左子树的数量
	}
	int newl,newr;
	if(sum_in_left>=k){//第k大数在左子树
		newl=l+left;//L左边有left个进入左子树，过滤掉那些(不理解的话，取left为0理解
		newr=l+left+sum_in_left-1;//下一段此区间有效的右边界
		return query(l,mid,newl,newr,k,d+1);
	}else{//在右子树
		newl=mid+L-l+1-left;//过滤掉[l,L)中在右子树的数量
		newr=mid+R-l+1-left-sum_in_left;//右边界(我把它化简了，不过很好推得
		num+=sum_in_left;//把LR区间在左子树的数量累加
		sum+=cw[d].sum[R]-cw[d].sum[L-1];//把LR区间在左子树权值累加
		return query(mid+1,r,newl,newr,k-sum_in_left,d+1);
	}
}
int main(int argc, char const *argv[]){
	int tim;
	scanf("%d",&tim);
	for(int T=1;T<=tim;++T){
		scanf("%d",&n);
		pre[0]=0;
		for(int i=1;i<=n;++i){
			scanf("%d",&sor[i]);
			cw[0].num[i]=sor[i];
			pre[i]=pre[i-1]+sor[i];//区里出前缀和，方便O1求值
		}
		sort(sor+1,sor+1+n);//记得排序呀兄dei
		build(1,n,0);
		scanf("%d",&m);
		printf("Case #%d:\n",T);
		while(m--){
			int x,y,z;
			scanf("%d%d",&x,&y);
			x++;y++;//要自加一下，因为我的下标从1开始
			sum=0;num=0;//初始化
			z=(y-x+2)>>1;//取中间一位
			int mid=(x+y)>>1;
			LL tmp=query(1,n,x,y,z,0);
			assert(num==mid-x);
			num=mid-x;
			sum=pre[y]-pre[x-1]-sum*2-(y-x+1-num-num)*tmp;//推出来的公式
			printf("%lld\n",sum );
		}
		printf("\n");//PE一发你就知道咯
	}
	return 0;
}

第二题CSU1080：

 这题稍微难一点，但是把上面的代码改一下就可以ac了。本质是一样的，都是要log时间内求区间前k大的数和。

题意及处理：

 中文题面没啥好说的，题目说的是每个学生最多解决k个任务。

 毫无疑问，贡献为负数的任务不选

 骚操作来了，负数贡献赋值为0，这样在用划分树处理前k大的数之和就十分方便了。

 还要注意一点的是，题目给出的是难度值和贡献值对应一个下标，所以要离散化一下。离散化处理出每个学生能解决的难度对应的下标。

直接套用上面的代码，稍作修改就ac了。

AC代码：
//872ms
#include<cstdio>  
#include<algorithm>
#include<cstring>
#include<cassert>  
using namespace std;
const int N = 100005;  
typedef long long LL;
struct lh{
	int id,val;
}ar[N];
bool cmp1(lh &a,lh &b){
	if(a.id!=b.id)return a.id<b.id;
	return a.val<b.val;
}
bool cmp2(int i,int j){
	return i<j;
}
struct lp{
	int cnt[N];//本层中从本段左端点到i有多少个进入左子树
	int num[N];//本层中从本段的数字排列
	LL sum[N];本层中从1到i进入左子树的权值和
}cw[22];
int id[N],val[N];
int pre[N],sum;
int n,m,num;
int sor[N];
int build(int l,int r,int d){
	if(l==r)return cw[d].num[l];
	cw[d].sum[0]=cw[d].cnt[0]=0;
	int same=0,mid=(l+r)>>1;
	for(int i=mid;i>=l;--i){//左边有多少的和mid值相等
		if(sor[i]==sor[mid])same++;
		else break;
	}
	int cnt=0;
	int li=l,ri=mid+1;//下一层分段的起点，反正左右两边肯定是均分的(可能差1)
	for(int i=l;i<=r;++i){
		cw[d].sum[i]=cw[d].sum[i-1];//前缀进入左子树权值和
		if(cw[d].num[i]<sor[mid]){//小于mid一律入左子树
			cw[d+1].num[li++]=cw[d].num[i];
			cw[d].sum[i]+=cw[d].num[i];
			cnt++;
		}else if(cw[d].num[i]==sor[mid]&&same){
			same--;
			cnt++;
			cw[d+1].num[li++]=cw[d].num[i];
			cw[d].sum[i]+=cw[d].num[i];
		}else{
			cw[d+1].num[ri++]=cw[d].num[i];
		}
		cw[d].cnt[i]=cnt;//统计本段到i进入左子树数量
	}
	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 left=0,sum_in_left=0,mid=(l+r)>>1;
	if(L==l){
		sum_in_left=cw[d].cnt[R];
	}else{
		sum_in_left=cw[d].cnt[R]-cw[d].cnt[L-1];//这是LR区间中进入左子树的数量
		left=cw[d].cnt[L-1];//这是本段[l,L)区间中进入左子树的数量
	}
	int newl,newr;
	//printf("sum_in_left=%d\n",sum_in_left );
	if(sum_in_left>=k){//第k大数在左子树
		newl=l+left;//L左边有left个进入左子树，过滤掉那些(不理解的话，取left为0理解
		newr=l+left+sum_in_left-1;//下一段此区间有效的右边界
		return query(l,mid,newl,newr,k,d+1);
	}else{//在右子树
		newl=mid+L-l+1-left;//过滤掉[l,L)中在右子树的数量
		newr=mid+R-l+1-left-sum_in_left;//右边界(我把它化简了，不过很好推得
		//num+=sum_in_left;//把LR区间在左子树的数量累加
		sum+=cw[d].sum[R]-cw[d].sum[L-1];//把LR区间在左子树权值累加
		//printf("**%d\n",sum);
		return query(mid+1,r,newl,newr,k-sum_in_left,d+1);
	}
}
int main(int argc, char const *argv[]){
	while(~scanf("%d",&n)){
		for(int i=1;i<=n;++i){
			scanf("%d%d",&ar[i].id,&ar[i].val);
			if(ar[i].val<0)ar[i].val=0;
		}
		sort(ar+1,ar+1+n,cmp1);
		pre[0]=0;
		for(int i=1;i<=n;++i){
			pre[i]=pre[i-1]+ar[i].val;//前缀和
			id[i]=ar[i].id;//把难度值提出来，方便后面查询时得到下标
			val[i]=ar[i].val;
			sor[i]=val[i];
			cw[0].num[i]=val[i];
		}
		sort(sor+1,sor+1+n);//记得排序呀兄dei
		build(1,n,0);
		scanf("%d",&m);
		while(m--){
			int x,y,z,s;
			scanf("%d%d%d",&x,&y,&z);
			x=lower_bound(id+1,id+1+n,x)-id;//得到下标
			y=upper_bound(id+1,id+1+n,y)-id-1;
			s=y-x+1-z;
			//printf("*%d %d %d\n",x,y,s);
			if(z>y-x+1){
				printf("%d\n",pre[y]-pre[x-1]);
			}else{
				sum=0;
				int tmp=query(1,n,x,y,s,0);
				if(s)sum+=tmp;
				tmp=pre[y]-pre[x-1]-sum;
				printf("%d\n",tmp);
			}
		}
		printf("\n");//PE一发你就知道咯
	}
	return 0;
}

主席树求动态区间前k大数的和

CCPC-Wannafly Winter Camp Day5 Div1 C题 Division 主席树

#include<bits/stdc++.h>
#define fi first
#define se second
#define iis std::ios::sync_with_stdio(false)
#define pb push_back
#define o2(x) (x)*(x)
using namespace std;
typedef long long LL;
typedef pair<int, LL> pii;

const int MXN = 1e6 + 6;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, q;
int ar[MXN], num[MXN];
LL sum[MXN];
struct QUERY {
    int l, r, k;
    LL ans;
}cw[MXN];
struct lp {
    int l, r, cnt;
    LL sum;
}node[MXN*16];
int inde, Root[MXN];
void z_update(int old, int &cur, int val, LL L, LL R) {
    cur = ++ inde;
    node[cur] = node[old];
    if(L == R) {
        node[cur].sum += val - val/2;
        ++ node[cur].cnt;
        return;
    }
    LL mid = (L + R) / 2;
    if(val <= mid) z_update(node[old].l, node[cur].l, val, L, mid);
    else z_update(node[old].r, node[cur].r, val, mid+1, R);
    node[cur].sum = node[node[cur].l].sum + node[node[cur].r].sum;
    node[cur].cnt = node[node[cur].l].cnt + node[node[cur].r].cnt;
}
LL z_query(int k, int old, int cur, LL L, LL R) {
    if(L == R) {
        return (LL)k*(L-L/2);//权值为L产生的贡献是k*(L-L/2)
    }
    LL mid = (L + R) / 2;
    int tmp = node[node[cur].r].cnt - node[node[old].r].cnt;
    if(k <= tmp) {
        return z_query(k, node[old].r, node[cur].r, mid + 1, R);
    }else {
        return node[node[cur].r].sum - node[node[old].r].sum
        + z_query(k-tmp, node[old].l, node[cur].l, L, mid);
    }
}
/*LL query(int k, int old, int cur, int L, LL R) {
    printf("%d %lld %lld\n", k, node[cur].sum, node[old].sum);
    if(L == R) {
        printf("*%d %d\n", L,k*(L-L/2));
        return (LL)k*(L-L/2);
    }
    LL mid = (L + R) / 2;
    int tmp = node[node[cur].r].cnt - node[node[old].r].cnt;
    printf("%d %d %d %d %lld\n", k, tmp, node[node[old].r].cnt,node[node[cur].r].cnt,node[node[cur].r].sum - node[node[old].r].sum);
    if(k <= tmp) {
        return query(k, node[old].r, node[cur].r, mid + 1, R);
    }else {
        return node[node[cur].r].sum - node[node[old].r].sum
        + query(k-tmp, node[old].l, node[cur].l, L, mid);
    }
}*/
int main(){
    scanf("%d%d", &n, &q);
    for(int i = 1; i <= n; ++i) scanf("%d", ar+i), sum[i]=sum[i-1]+ar[i];
    for(int i = 1; i <= q; ++i) {
        scanf("%d%d%d", &cw[i].l, &cw[i].r, &cw[i].k);
        cw[i].ans = sum[cw[i].r] - sum[cw[i].l-1];
    }
    LL L, R;
    for(int T = 30; T >= 0; --T) {
        L = 1LL<<T, R = 2LL<<T, inde = 0;
        node[0].l = node[0].r = node[0].sum = node[0].cnt = 0;
        for(int i = 1; i <= n; ++i) if(ar[i]>>T&1) {
            z_update(Root[i-1], Root[i], ar[i], L, R);
            //if(T == 2) printf("[%d %d]\n", i, ar[i]);
            sum[i] = sum[i-1] + ar[i] - ar[i]/2; num[i] = num[i-1] + 1;
        }else Root[i] = Root[i-1], sum[i] = sum[i-1], num[i] = num[i-1];
        //printf("T = %d\n", T);
        for(int i = 1, tmp; i <= q; ++i) {
            if(cw[i].k == 0) continue;
            if(cw[i].k >= num[cw[i].r] - num[cw[i].l-1]) {
                cw[i].k -= num[cw[i].r] - num[cw[i].l-1];
                cw[i].ans -= sum[cw[i].r] - sum[cw[i].l-1];
            }else {
                //printf("*%lld %d ", cw[i].ans, cw[i].k);
                cw[i].ans -= z_query(cw[i].k, Root[cw[i].l-1], Root[cw[i].r], L, R);
                //printf("%lld %d\n", cw[i].ans, T);
                cw[i].k = 0;
            }
            //printf("%d %d %d\n", cw[i].l, cw[i].r, cw[i].k);
        }
        for(int i = 1; i <= n; ++i) if(ar[i]>>T&1) ar[i] >>= 1;
        //printf("***\n");
    }
    for(int i = 1; i <= q; ++i) printf("%lld\n", cw[i].ans);
    return 0;
}
Cwolf9
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【划分树】求区间K大数
Evil.livE
08-23 4242
<br />       求区间K大数，众所周知有二分答案+树套树的做法，每个询问复杂度为O(log3N)，可谓近似一个O(N)了，不仅时间复杂度高，编程复杂度也不低，后来才发现还有一种叫划分树的数据结构，专门做这种问题。<br />      本来觉得知道个树套树就够了，据我所知划分树还不支持区间修改操作，但是这次NOI一试的piano偏偏那出题人就有这么重口味，给你来两个500000的点！真是不简单，当时我都在想有没有O（N）的算法了。树套树的复杂度偏偏就被卡掉了，三个点平均每个点要跑5秒，好吧，那就学
主席树----求静态区间[l,r]第k大数和第k小数
wcxyky的博客
10-20 484
Description 给出一个长度为n的序列a，给出m次查询，每次查询区间[l,r]中第k大的数 Input 第一行两个整数n和m,分别表示序列长度和查询次数， 第二行n个整数表示序列a，之后m行每行三个整数l,r和k表示一次查询 Output 对于每次查询，输出区间[l,r]中第k大的数 Sample Input 7 2 1 5 2 6 3 7 4 1 5 3 2 7 1 ...
[csu/coj 1080]划分树求区间前k大数和
weixin_30908649的博客
05-17 292
题意：从某个区间内最多选择k个数，使得和最大 思路：首先题目给定的数有负数，如果区间前k大出现负数，那么负数不选和更大，于是对于所有最优选择，负数不会出现，所以用0取代负数，问题便转化为区间的前k大数和。 划分树： [1 6 3 8 5 4 7 2] [6 8 5 7][1 3 4 2] [8 7][6 5][3 4][1 2] [8][7]...
（ 求区间第k大及大于等于它的和 ）【 主席树扩展 】
石旭先森的博客
10-23 723
（ 求区间第k大及大于等于它的和 ）【 主席树扩展 】 即求区间第1大+第2大+第3大+...+第k大的和。 比如：a = 1 2 3 4 5 query(1,5,5) = 5+4+3+2+1 query(2,4,2) = 4 + 3 query(1,3,1) = 3 引入sumt数组，表示当前点及其儿子节点的和。 int update( int pre, int left, int right, int x ) { int node = tot++; L[node] =.
线段树与区间最大子段和问题，这一篇就够了
m0_51156601的博客
04-08 3194
1、经典的区间最大子段和问题 问题描述：给定一个序列a1,a2,a3,..ana_1,a_2, a_3,..a_na1​,a2​,a3​,..an​，如何求出该序列的最大子段和？（询问的区间个数为mmm） 解决方案： - 暴力统计：对于每一个区间[l,r][l,r][l,r]，每一次选定一个子段的起点，然后枚举子段的长度，算法复杂度为O(mn2)O(mn^2)O(mn2)。 - 动态规划：我们一次性算出所有的区间的最大子段和，然后使用直接询问答案。我们规定： - ls\color{Green}lsls
利用树型结构求解问题之一 利用划分树求解区间内的第K大值
liulanghaitian的博客
02-05 247
算法适用的问题： 对于随便给定的一组数据，求解给定区间的第K大或小的数据
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
03-05
【hdu5306】Gorgeous Sequence 线段树区间最值操作-附件资源
HDU+2000-2099+解题报告
08-31
HDU（杭州电子科技大学）在线评测系统是许多编程竞赛爱好者和学习者经常访问的平台，它提供了大量的算法题目供用户练习和挑战。这个压缩包文件“HDU 2000-2099 解题报告”显然包含了在这个题号范围内的一些问题、...
ACM hdu 线段树题目+源代码
06-19
线段树的主要应用是解决区间问题，例如区间和、区间最大值、区间最小值等。线段树可以将这些问题的时间复杂度从 O(n) 降低到 O(logn)。 Hdu 2871 Memory Control Hdu 2871 Memory Control 是一个典型的线段树...
HDU-EID-V2-核心板1
08-03
在本话题中，我们关注的是一个名为"HDU-EID-V2-核心板1"的特定设计，它涉及到STM32的核心组件、接口、电源管理和调试配置。 首先，核心板设计中提到了F103和F207两个型号的STM32芯片。F103和F207属于STM32的不同...
CSU 1080: A simple maze
yuzhaoxin1008的专栏
03-16 221
典型的bfs。 代码如下： #define MAXN 55#define INF 0x7fffffff#include#includestring.h>int T, N, M, Sr,Sc,Er,Ec, min;char s[MAXN][MAXN], vis[MAXN][MAXN];int q[MAXN*MAXN], dis[MAXN][MAXN];int dx[4] = {0,0,-1,
Gym 102770 E-Easy DP Problem （主席树查询区间前k大的和）
forward77
11-19 1715
题意：写着DP总不可能是dp吧，就是给定一个dp[i][j]的求解方式，如图中分段函数所示，然后给你一个l r k，然后问你dp[ r-l+1 ][ k ]的值为多少？ 思路：既然题目那这DP,那应该就不是DP吧。手写几项后，反正我写不出来 ，发现我们需要求得就是(∑i=1r−l+1i2\sum_{i=1}^{r-l+1}i^2∑i=1r−l+1​i2) + [blb_lbl​,bl+1,......brb_{l+1},......b_rbl+1​,......br​]中前k大的数和。 前面的式子很好维护.
静态区间第k大（划分树）
An55511的博客
02-13 178
POJ 2104为例【经典划分树问题】 思想： 利用快速排序思想， 建树时将区间内的值与区间中值相比，小于则放入左子树，大于则放入右子树，如果相等则放入左子树直到放满区间一半。 查询时，在建树过程中利用leftsum[p][i]数组保存有多少个数划分到第p层，第i个位置的左边。每次查询计算出每个区间有多少数被放入左子树，小于等于k则说明所求数在左子树，继续...
CF Round 117C. Optimal Sum 暴力(区间前k大和)+Set
noone0的博客
06-07 809
题意:长度为n的序列a.定义一个区间的价值为:该区间所有的数相加后的绝对值.操作:改变一个数的正负号.1&lt;=len&lt;=n&lt;=1e5.0&lt;=k&lt;=n,-1e9&lt;=a[i]&lt;=1e9. 问在操作不超过k次的情况下.长度为len区间的最大价值.长度为len的区间中,相同符号的显然要尽量多.所以改变的只有该区间前k大正数,或者前k小负数.如何求所有长度为len区间...
HDU 4417 Super Mario--主席树+二分（查询前K大和）
zjyang12345的博客
04-13 250
STL二分 还不是很能理解不同版本相减的操作，因此用个pushup证明自己是蒟蒻 这样add只用更新一个点，再pushup回溯，每个结点就是区间和，而且query好写一些 注意这题可以离线，因此可以二分找出要求的是第几大，但要特判找不到的情况（输出0） #include<cstdio> #include<algorithm> #include<iostrea...
划分树and主席树
Lazier’s blog
08-29 1856
//hdu 2665 这里就做为划分树模板了； #include #include using namespace std; #define N 100100 int data[N]; struct node { int v[N]; int num[N]; }td[31]; void build(int l,int r,int dep) { if(l>=r)retur
hdu 6058 Kanade's sum [区间第k大数求和] [2017 Multi-University Training Contest - Team 3]
hint
08-01 372
点击打开题目 题意:给你一个序列, 求每个区间的第k大的数的和, 如果不存在第k大的数, 则这个数为0. 分析:一个很直观的思路就是算每个数的贡献, 对于这个序列中的数$a_i$, 枚举有多少区间第k大的数为$a_i$. *往前枚举找到k - 1个比$a_i$大的数,往后枚举找到k - 1个比$a_i$大的数. 然后将左边第i大的数到第i + 1大(包含i但不
区间动态第k大 数状数组+主席树（树套树）
H_ang的博客
08-30 482
题目链接：https://www.luogu.org/problem/P2617 题目大意： 第一行有两个正整数n(1≤n≤100000)，m(1≤m≤100000)。分别表示序列的长度和指令的个数。 第二行有n个数，表示a[1],a[2]……a[n]，这些数都小于10^9。接下来的m行描述每条指令，每行的格式是下面两种格式中的一种。 Q i j k 或者 C i t Q i j k （i,j,...
静态区间第k大（分桶法和平方分割）
An55511的博客
02-15 177
POJ 2104为例 思想： 《挑战程序设计竞赛》中介绍的方法。 分桶法：把一排物品或者平面分成桶，每个桶分别维护自己内部的信息，已达到高效计算的目的。 设一共有n个数，每b个分到一个桶里，并对桶内元素进行排序。给定区间，求小于x的数的个数 对于完全包含在区间内的桶，直接二分查找满足条件的个数，每个桶处理需要O(logb)的时间。 剩余的不完全分布...
HDU2222+WA
最新发布
03-08
HDU2222+WA 是指杭电OJ（杭州电子科技大学在线评测系统）上的一道题目，题目编号为2222，题目名称为"WA"。这道题目是一个字符串匹配的问题，要求判断一个字符串中是否包含另一个字符串中的所有字符（不考虑顺序）。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值