7/18 树状数组阶段性检测总结

序言#

今天有一场本人考得不知道是好还是不好的一场考试。

Emm...

废话不多说，让我们来看题。

 

---

T1 count#

Link

题目大意：统计这些自然数各自出现的次数，并按照自然数从小到大的顺序输出统计结果。

pts：80

问题：数组开小了

思路：由于常数过大，已经超过了1e10，并且输入个数1≤n≤200005，由此，我们想到了离散化。

因题目只要求统计数出现的次数，并没有要求其他，所以离散化是适用的。

而离散化剩下的就是一些排序之类的简单操作了。

Code

#include<bits/stdc++.h>
using namespace std;
long long n,q,b[200005];
long long Bit[200005];
bool v[200005];

struct node{
	long long ai,bh,k,ys;
}a[200005];

struct node2{
	long long a1,a2,a3;
}s[200005];

bool cmp(node x,node y){
	if(x.bh>y.bh){
		return 0;
	}
	return 1;
}

bool cmp2(node2 x,node2 y){
	if(x.a1>y.a1){
		return 0;
	}
	return 1;
}

long long read(){
    long long 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-48;
        ch=getchar();
    }
    return x*f;
}

int main(){
	// freopen("count.in","r",stdin);
	// freopen("count.out","w",stdout);
	scanf("%lld",&n);
	for(int i=1;i<=n;i++){
		a[i].ai=read();
		b[i]=a[i].ai;
		a[i].bh=i;
		a[i].ys=a[i].ai;
	}
	sort(b+1,b+n+1);
	for(int i=1;i<=n;i++){
		a[i].ai=lower_bound(b+1,b+n+1,a[i].ai)-b;
	}
	for(int i=1;i<=n;i++){
		a[a[i].ai].k++;
	}
	sort(a+1,a+n+1,cmp);
	int tot=0;
	for(int i=1;i<=n;i++){
		if(v[a[i].ai]!=1){
			s[++tot].a1=a[i].ys;
			s[tot].a2=a[a[i].ai].k;
			v[a[i].ai]=1;
		}
	}
	sort(s+1,s+tot+1,cmp2);
	for(int i=1;i<=tot;i++){
		printf("%lld %lld\n",s[i].a1,s[i].a2);
	}
    return 0;	
}

PS:#

测评的时候一大堆AC，本人可怜的80pts夹在中间，本来还想着离散化写挂了，自我反省一番，结果翻了代码一看：

bool v[20005];

 更该反省了......

---

 

T2 Friend#

Link

题目大意：输出1~n中不是质数的数总数。

pts：100

思路：一道签到题，直接拿出埃氏筛

埃氏筛：将每个质数的倍数都标记成合数，以达到筛选素数的目的。

Code

#include<bits/stdc++.h>
using namespace std;
int n,q,b[100005];
long long Bit[10005];
bool v[2000005];
int main(){
	scanf("%d",&n);
	v[2]=0;
	int ans=1;
	for(int i=2;i<=n;i++){
		if(v[i]==0){
			for(int j=i*2;j<=n;j+=i){
				if(v[j]==0){
					ans++;
				}
				v[j]=1;
			}
		}
	}
	printf("%d",ans);
    return 0;	
}

 

---

T3 Self-Number#

Link

题目大意：对于每一个正整数n，定义d(n)为n加上它每一位数字的和，数字n被称作d(n)的发生器，一个没有发生器的数被称作Self-Number。

给定n,k和s[1],s[2]...s[k]，求n前有多少Self-Number以及第s[k]个Self-Number。

pts：100

思路：设一个布尔类型的数组f,f[0]为Self-Number,f[1]为否。

因为每一数都可以作为发生数，所以我们从1开始枚举到n，枚举到每一数，就把以它作为发生器的数的f置为1。

如枚举到一数f为0，就把答案变量加一。最后按题输出即可。

Code

 #include<iostream>
using namespace std;
int a[10000075];
int b[5001];
int main(){
	int n,k;
	cin>>n>>k;
	for(int i=0;i<k;i++){
		cin>>b[i];
	} 
	int j=0;
	for(int i=1;a[j]<=n&&i<10000075;i++){
		if(!a[i]){
			a[++j]=i;
		}  
		int sum=i;		
		for(int t=i;t;t/=10){
			sum+=t%10;
		}		
		if(sum<10000075){
			a[sum]=1;
		} 
	}
	cout<<((a[j]>n)?j-1:j)<<endl;
	for(int i=0;i<k;i++){
		cout<<a[b[i]]<<" ";
	} 	
	return 0;
	
}

---

T4 简单题#

Link

题目大意：有一数组初始为0，有两操作，一是将区间l~r的每个数均反转,二是询问一数的状态。

pts：100

思路：看题修改区间就知为树状数组，此题为树状数组区间修改，单点查询的应用板题。

其实在草稿纸上画几笔就知只用把UpDate函数中加的操作变与一，或把Sum返回值与一即可。

Code

 #include<bits/stdc++.h>
using namespace std;
long long n,m,q,a[500005];
long long Bit[500005];

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

void UpDate(int x,int y){
	for(int i=x;i<=n;i+=LowBit(i)){
		Bit[i]+=y;
	}
}

long long Sum(int x){
	long long pre=0;
	for(int i=x;i>0;i-=LowBit(i)){
		pre+=Bit[i];
	}
	return pre;
}

int read(){
    int 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-48;
        ch=getchar();
    }
    return x*f;
}

int main(){
	scanf("%d%d",&n,&m);
	while(m--){
		q=read();
		int l,r;
		if(q==1){
			l=read();
			r=read();
			UpDate(l,1);
			UpDate(r+1,-1);
		}
		else{
			l=read();
			printf("%d\n",Sum(l)%2);
		}
	}
    return 0;	
}

---

T5 火神之友#

题目大意：查询一个数组中的一个区间[L,R]，回答在这个区间中有多少个值刚好出现 2 次

pts:40

问题：能力不够，暴力拿40pts。

思路：首先看数据范围，(1<=N,Q<=500000)，暴力O(n²)肯定过不了。

让我们来思考一下，假设这个区间全为同一值。设一指针j，从左端点开始枚举。枚举到第二位时，出现了2次'3'。

此时，我们应保存答案，就将第一位进行+1操作，表示此区间此值有一组答案。

继续枚举，到第三位时，就出现了3次'3'，很明显当左区间为第一位时是不符题意的，但左区间为第二位时又有一组答案。怎么办？将第二位+1，第一位-2。这样，左端点为第二位时就能统计一组答案，而左端点为第一位时就没有答案。

继续枚举，到第四位时，如果我们重复+1,-2操作，在统计左端点为第一位时，又发现此时总值为-1了。怎么办？将第一位再+1，这样，无论左端点为第几位，都是符合题意的。

枚举下去，我们会发现只用重复此操作即可。在统计答案时，我们只须求此区间前缀和。

求前缀和时，因我们先算小区间，一串计算下来已经减去了很多重复计算，对于500000的数据，肯定是过得了的。

还要注意一点，我们需按此区间右端点从小到大排序，因为如果先枚举大区间，小区间内的值就会被改变，但如果先枚举小区间，就不会有问题。

Code

 #include<bits/stdc++.h>
using namespace std;
long long n,q,ans[500005];
long long Bit[500005],b[500005],last[500005];
map<int,int> o;

struct node{
	int l,r,id,ans;
	bool operator<(const node &t)const{
	    return r < t.r; 
	}
}xw[500005];

struct node2{
	int ai,bi,ci,x;
};

bool cmp(node x,node y){
	if(x.r>y.r){
		return 0;
	}
	return 1;
}

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

void UpDate(int pos,int val){
    while(pos<=n&&pos>0){
    	Bit[pos]+=val;
		pos=pos+LowBit(pos);
	}
}

long long Sum(int x){
	long long pre=0;
	for(int i=x;i>0;i-=LowBit(i)){
		pre+=Bit[i];
	}
	return pre;
}


long long read(){
    long long 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-48;
        ch=getchar();
    }
    return x*f;
}

int main(){
	scanf("%d%d",&n,&q);
	for(int i=1;i<=n;i++){
        b[i]=read();
        if(o.find(b[i])!=o.end()){//此数已经出现过 
        	last[i]=o[b[i]];
		}
        else{
        	last[i]=-1;
		}
        o[b[i]]=i;
    }
    for(int i=0;i<q;i++){
    	xw[i].l=read();
    	xw[i].r=read();
		xw[i].id=i;//方便输出 
	}
    sort(xw,xw+q);
    for(int i=0,j=0;i<q;i++){
    	while(j<=xw[i].r){
    		if(last[j]!=-1){//+1操作 
    			UpDate(last[j],1);
			}
            if(last[last[j]]!=-1){//-1操作 
            	UpDate(last[last[j]],-2);
			}
            if(last[last[last[j]]]!=-1){//+1操作，制0
            	UpDate(last[last[last[j]]],1);
			}
			j++;
		}
        ans[xw[i].id]=Sum(xw[i].r)-Sum(xw[i].l-1);//保存答案 
    }
    for(int i=0;i<q;i++){
    	printf("%d\n",ans[i]);
	} 
    return 0;	
}

---

总结：#

T1丢分不应该，T5确实不行，还是应提升自身实力。

虽然这次有一丢丢小进步。

---

完结