2021-06-28~2021-06-29训练总结

最新推荐文章于 2021-11-16 08:40:56 发布

「已注销」

最新推荐文章于 2021-11-16 08:40:56 发布

阅读量133

点赞数

本文链接：https://blog.csdn.net/fangshaonian/article/details/118313235

版权

还是太菜了qwq，在随时查了C++ reference资料的情况下写了一天就写不动了qwq，~~明天好好补题吧awa……~~ 还是摸鱼吧qwq

A - Time to Raid Cowavans（CF 103D）

原题链接：Problem - 103D - Codeforces

（我觉得吧，要是没某dalao教我，我估计死活想不出来分类讨论qwq）

首先采取离线存储所有a，b询问，考虑到b很小的时候复杂度将接近O(n)，对于b较小的时候用前缀和数组维护间隔b的和，对于b较大的时候直接暴力求和即可。

这样的总体时间复杂度为O(qn+n/q*(n-q))，空间复杂度为O(q*n)，取q=sqrt(n)有此时总体复杂度为O(n*sqrt(n)+(n-q)*sqrt(n))，即可卡过qwq

#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
ll s[355555];
ll p[355555];
pair<ll,pair<ll,ll> >sr[300005];
pair<ll,ll>sc[300005];
bool cmp(pair<ll,pair<ll,ll> >x,pair<ll,pair<ll,ll> >y){
	return x.second.second<y.second.second;
}
int main(){
	ll n,m,i,j,k,a,b,su=0,sg;
	scanf("%lld",&n);
	for(i=1;i<=n;i++) scanf("%lld",&s[i]),su+=s[i],p[i]=su;
	scanf("%lld",&m);
	for(i=1;i<=m;i++){
		scanf("%lld%lld",&a,&b);
		sr[i]={i,{a,b}};
	}
	sort(sr+1,sr+1+m,cmp);
	for(j=1,sg=-1;j<=m;j++){
		a=sr[j].second.first,b=sr[j].second.second;
		if(b<=233){
			if(b!=sg){
				for(i=n,su=0;i>=1;i--) p[i]=p[i+b]+s[i];
				sg=b;
			}
			sc[j].first=sr[j].first;
			sc[j].second=p[a];
		}
		else{
			for(i=a,su=0;i<=n;i+=b) su+=s[i];
			sc[j].first=sr[j].first;
			sc[j].second=su;	
		}
	}
	sort(sc+1,sc+1+m);
	for(i=1;i<=m;i++) cout<<sc[i].second<<endl;
    return 0;
}

B - A and B and Compilation Errors（CF 519B）

原题链接：Problem - 519B - Codeforces

相当水的水题，只要排序判重一遍就能过。

#include<iostream>
#include<algorithm> 
#define ll long long
using namespace std;
ll s[100005],p1[100005],p2[100005];
int main(){
	ll n,i,j,k,zc;
	scanf("%lld",&n);
	for(i=1;i<=n;i++) scanf("%lld",&s[i]);
	for(i=1;i<=n-1;i++) scanf("%lld",&p1[i]);
	for(i=1;i<=n-2;i++) scanf("%lld",&p2[i]);
	sort(s+1,s+1+n);
	sort(p1+1,p1+1+n-1);
	sort(p2+1,p2+1+n-2);
	for(i=1;i<=n-1;i++) if(s[i]!=p1[i]) break;
	printf("%lld\n",s[i]);
	for(i=1;i<=n-2;i++) if(p2[i]!=p1[i]) break;
	printf("%lld\n",p1[i]);
    return 0;
}

C - Color the Fence（CF 349B）

原题链接：Problem - 349B - Codeforces

经典贪心题。

首先，由于位数大的数一定更大，先按照9个数中的最小值贪心出最大的位数，记此时n的剩余值为N。在同样的位数下，较大位的数更大一定较其他数变大更优，从首位开始遍历9-1，判断是否可以花费s[b]-s[a]的代价将a变为b，b>a，维护此时b的最大值；如果不能维护，退出循环即可。

#include<iostream>
#define ll long long
using namespace std;
ll s[10],p[1000005];
int main(){
	ll n,i,j,k,zxzx=1e18,zx,wz,pd=0,sl=0;
	scanf("%lld",&n);
	for(i=1;i<=9;i++) scanf("%lld",&s[i]),zxzx=min(zxzx,s[i]);
	while(n>0){
		if(n<zxzx) break;
		for(i=1,zx=1e18;i<=9;i++){
			if(s[i]<=zx and s[i]<=n){
				zx=s[i];
				wz=i;
			}
		}
		n-=s[wz];
		pd=1;
		p[++sl]=wz;
	}
	for(i=1;i<=sl;i++){
		if(n<=0) break;
		for(j=9;j>=p[i];j--){
			if(n>=s[j]-s[p[i]]){
				n-=s[j]-s[p[i]];
				p[i]=j;
				break;
			}
		}
	}
	for(i=1;i<=sl;i++) printf("%lld",p[i]);
	if(pd==0) printf("-1");
    return 0;
}

D - Snacktower（CF 767A）

原题链接：Problem - 767A - Codeforces

单调栈水题。由于输出一定是N-1的顺序，只是在输出行上有不同，那么在每一个位置只需模拟是否出栈即可。（另：因为过于水了单指针都行awa）

#include<iostream>
#include<stack>
#define ll long long
using namespace std;
ll p[1000005];
int main(){
	ll n,i,j,k,zc,dq;
	scanf("%lld",&n),dq=n;
	for(i=1;i<=n;i++){
		scanf("%lld",&zc);
		p[zc]=1;
		while(dq>=1 and p[dq]==1){
			printf("%lld ",dq);
			dq--;
		}
		printf("\n");
	}
    return 0;
}

E - Stripe（CF 18C）

原题链接：Problem - 18C - Codeforces

前缀和水题。

由于要的是两个区间和相等的子区间，那么首先维护遍历至每一个位置的前缀和，再遍历是否有总和一半的前缀和即可，复杂度为O(n)。

#include<iostream>
#define ll long long
using namespace std;
ll s[100005];
int main(){
	ll n,i,j,k,wz,su=0,zc,sl=0;
	scanf("%lld",&n);
	for(i=1;i<=n;i++){
		scanf("%lld",&zc);
		su+=zc;
		s[i]=su;
	}
	for(i=1;i<=n-1;i++){
		if(s[i]*2==su) sl++;
	}
	printf("%lld",sl);
    return 0;
}

F - Queue（待补）

G - Mike and Feet（CF 548D）

原题链接：Problem - 548D - Codeforces

（依然感谢某位大佬指点我这题用单调栈的性质咋做qwq）

首先，考虑到区间最小值唯一，且必然为数组元素之一，可知：所求最小值最大区间必然包括数组的对应值。那么，我们可以利用单调栈双向维护上升区间来维护每一个元素向前/向后所能找到的第一个比他小的元素的索引，两者相减即为该元素的最大区间。

换句话说，对于数组中每一个元素s[i]，若它为一段连续子区间的最小值，其能占有的最大子区间应当满足：[l,r]，l=1 or s[l-1]<s[i]，r=n or s[r+1]<s[i]，从而此时有以s[i]为最小值的区间[l,r]。由于数组中元素最多只有n个，这样的区间可以由：从右至左的单调栈和反之的单调栈来直接维护，从而就有每一个元素的区间长度最大值。

注意到某确定最小值的区间即使删去一个元素依然不影响其按照某元素生成的区间最小值，那么我们可以空维护最大值的方式维护没有对应区间的最大最小值。即：da[i]=max(da[i],da[i+1])

#include<iostream>
#include<stack>
#define ll long long
using namespace std;
ll s[200005],p1[200005],p2[200005],sc[200005];
stack<ll>cc;
int main(){
	ll n,i,j,k;
	scanf("%lld",&n);
	for(i=1,s[0]=s[n+1]=0;i<=n;i++) scanf("%lld",&s[i]);
	for(i=1;i<=n+1;i++){
		while(cc.size()>0 and s[cc.top()]>s[i]){
			p1[cc.top()]=i;
			cc.pop();
		}
		cc.push(i);
	}
	while(cc.size()>0) cc.pop();
	for(i=n;i>=0;i--){
		while(cc.size()>0 and s[cc.top()]>s[i]){
			p2[cc.top()]=i;
			cc.pop();
		}
		cc.push(i);
	}
	//for(i=1;i<=n;i++) cout<<i<<"|"<<p1[i]<<"|"<<p2[i]<<endl;
	for(i=1;i<=n;i++) sc[p1[i]-p2[i]-1]=max(sc[p1[i]-p2[i]-1],s[i]);
	for(i=n-1;i>=1;i--) sc[i]=max(sc[i],sc[i+1]);
	for(i=1;i<=n;i++) printf("%lld ",sc[i]);
    return 0;
}

H - Longest Regular Bracket Sequence（CF 5C）

原题链接：Problem - 5C - Codeforces

与G题其实类似（但是我太蔡了想出了H题没独立想出G题qwq），对于每一个括号，可以用单调栈的方式维护其对应的另一个对应括号，并标记括号位置。

所求合法最大括号区间长度，实际上就是求有标记的括号段的最大值，这一点可以用O(n)的扫描来做到。

#include<iostream>
#include<stack>
#define ll long long
using namespace std;
ll s[1000005];
stack<ll>cc;
int main(){
	string sr;
	ll n,i,j,k,zd=0,zdsl=0,zc,sg,slsl,su=0;
	cin>>sr;
	for(i=0;i<=sr.length()-1;i++) s[i]=-1;
	for(i=sg=0;i<=sr.length()-1;i++){
		if(sr[i]==')'){
			if(cc.size()>0){
				zc=cc.top();
				cc.pop();
				s[i]=zc;
				s[zc]=i;
			}
		}
		else cc.push(i);
	}
	//for(i=0;i<=sr.length()-1;i++) cout<<s[i]<<"|";
	//cout<<endl;
	for(i=0,su=0;i<=sr.length()-1;i++){
		if(s[i]==-1 or i==sr.length()-1){
			if(i==sr.length()-1 and s[i]!=-1) su++;
			if(zd==su) zdsl++;
			if(zd<su){
				zd=su;
				zdsl=1;
			}
			su=0;
		}
		else su++;
	}
	if(zd>0) printf("%lld %lld",zd,zdsl);
	else printf("0 1");
    return 0;
}

I - Maximum Submatrix 2（CF 376D）

原题链接：Problem - 376D - Codeforces

鬼想得到这居然是个dp题（此处膜拜某z姓名jy但又不愿具名的大佬），只需要用O(n*m)维护每一行下1-j的‘1’数目（这一点在输入时顺便可以做到），然后对于每一列，排序计算可能的矩形总和即可。

在此处吐槽亿下我qwq：交了N发，其实是自己蔡输入写挂了还要嘲讽别人的屑就是我qwq（为啥string跑的比char数组或者单个char字符慢那么多啊呜呜呜）

#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
ll s[5005][5005],p[5005][5005],zczc[5005];
char sr[5005];
void kp(int i,int j){
	ll mid=zczc[(i+j)/2],z=i,r=j;
	while(z<=r){
		while(zczc[z]<mid) z++;
		while(zczc[r]>mid) r--;
		if(z<=r){
			swap(zczc[z],zczc[r]);
			z++;r--;	
		}
	}
	if(i<r) kp(i,r);
	if(z<j) kp(z,j);
}
int main(){
	ll n,m,i,j,k,zc,zd=0;
	scanf("%lld%lld",&n,&m);
	for(i=1;i<=n;i++){
		scanf("%s",sr);
		for(j=1;j<=m;j++){
			if(sr[j-1]=='1') s[i][j]=1,p[i][j]=p[i][j-1]+1;
			else s[i][j]=0,p[i][j]=0;
		}
	}
	/*for(i=1;i<=n;i++){
		for(j=1;j<=m;j++){
			cout<<p[i][j]<<"|";
		}
		cout<<endl;
	}*/
	for(j=1;j<=m;j++){
		for(i=1;i<=n;i++) zczc[i]=p[i][j];
		//sort(zczc+1,zczc+1+n);
		kp(1,n);
		for(i=n;i>=1;i--){
			if(zczc[i]==0) break;
			zd=max(zd,zczc[i]*(n+1-i));
		}
	}
	printf("%lld",zd);
    return 0;
}

J - Preparing for the Contest（待补）

K - Mahmoud and a xor trip（待补）

L - Cells Not Under Attack（CF 701B）

原题链接：Problem - 701B - Codeforces

容斥原理签到题。对于每一个车棋子的坐标(a,b)，用两个数组维护横纵坐标有无出现过，记录每一个棋子放下后，已经占据的横行数量与纵列数量A,B，根据容斥原理，有：

数量=N*N-(A+B)*N+A*B

这样就轻松的过了题（和数据结构有啥关系qwq）

#include<iostream>
#define ll long long
using namespace std;
ll s[100005],p[100005];
int main(){
	ll m,n,i,j,k,a,b,sl1=0,sl2=0;
	scanf("%lld%lld",&n,&m);
	while(m--){
		scanf("%lld%lld",&a,&b);
		if(s[a]==0){
			sl1++;
			s[a]=1;
		}
		if(p[b]==0){
			sl2++;
			p[b]=1;
		}
		printf("%lld ",n*n-(sl1+sl2)*n+sl1*sl2);
	}
    return 0;
}

M - Too Easy Problems（待补）

N - Minimum Array（CF 1157E）

原题链接：Problem - 1157E - Codeforces

一道set的题。显然，为了让答案数组字典序最小，尽可能选取使两者和模N的数字即可，那么，则需要对元素进行排序，对于每一个元素，按照相加后尽可能答案小的规则，贪心二分选取即可。

需要特判：如果没有找到，返回最小的那个。

#include<iostream>
#include<algorithm>
#include<set>
#define ll long long
using namespace std;
ll s[200005],p[200005];
set<ll>cc;
int main(){
	ll n,i,j,k,zc,zczc;
	scanf("%lld",&n);
	for(i=1;i<=n;i++) scanf("%lld",&s[i]);
	for(i=1;i<=n;i++){
		scanf("%lld",&zc);
		if(p[zc]==0) cc.insert(zc);
		p[zc]++;
	}
	for(i=1;i<=n;i++){
		set<ll>::iterator dq=cc.lower_bound(n-s[i]);
		if(dq==cc.end()) dq=cc.begin();
		zc=*dq;
		p[zc]--;
		if(p[zc]==0) cc.erase(dq);
		printf("%lld ",(s[i]+zc)%n);
	}
    return 0;
}

O - Powerful array（CF 86D）

原题链接：Problem - 86D - Codeforces

莫队模板题。照着洛谷的某dalao的指导，写了一发莫队qwq。

由于k*(i+1)^2-k*i^2=k*(2*i+1)，可知添加/删除一个元素在记录每一个元素数量的前提下是O(1)的。考虑朴素做法，这样对于每一个li,ri进行扫描，最坏复杂度为O(n^2)。（纯暴力是由于扫描完li,ri后还需扫描一边元素值来获得数量，复杂度为O(n^3)）

然后对于查询采用离线处理，将查询区间全部输入，按照左区间为关键字分块，然后对每一个小块中的查询进行按照右区间为关键字的排序。那么，可知对于左区间端点，最多移动sqrt(n)次；对于右区间端点，最多移动n次，可知此时每一个块的时间复杂度为O(sqrt(n)+n)。由于分块，可知总体时间复杂度O(sqrt(n)*(sqrt(n)+n))=O(n*sqrt(n)+n)，故正好可以通过本题。

#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#define ll long long
using namespace std;
vector<pair<ll,pair<ll,ll> > >p[555];
pair<ll,pair<ll,ll> >zczc;
ll s[200005],sc[200005],sl[1000006];
bool cmp(pair<ll,pair<ll,ll> >x,pair<ll,pair<ll,ll> >y){
	return x.second.second<y.second.second;
}
int main(){
	ll n,m,i,j,k,a,b,cd,su=0,azc,bzc;
	scanf("%lld%lld",&n,&m),cd=sqrt(n);
	for(i=1;i<=n;i++) scanf("%lld",&s[i]);
	for(i=1;i<=m;i++){
		scanf("%lld%lld",&a,&b);
		zczc={i,{a,b}};
		p[a/cd+1].push_back(zczc);
	}
	for(i=1;i<=n/cd+1;i++) sort(p[i].begin(),p[i].end(),cmp);
	for(k=1,a=b=0;k<=n/cd+1;k++){
		if(p[k].size()==0) continue;
		for(j=0;j<=p[k].size()-1;j++){
			zczc=p[k][j];
			azc=zczc.second.first,bzc=zczc.second.second;
			//cout<<azc<<"|"<<bzc<<"|||"<<a<<"|"<<b<<endl;
			if(azc!=a){
				if(azc<a) for(i=azc;i<=a-1;i++) su+=s[i]*(2*sl[s[i]]+1),sl[s[i]]++;
				else for(i=a;i<=azc-1;i++) sl[s[i]]--,su-=s[i]*(2*sl[s[i]]+1);
			}
			if(bzc!=b){
				if(bzc<b) for(i=bzc+1;i<=b;i++) sl[s[i]]--,su-=s[i]*(2*sl[s[i]]+1);
				else for(i=b+1;i<=bzc;i++) su+=s[i]*(2*sl[s[i]]+1),sl[s[i]]++;
			}
			a=azc,b=bzc;
			sc[zczc.first]=su;
			//cout<<a<<"|"<<b<<"|"<<su<<endl;
		}
	}
	for(i=1;i<=m;i++) printf("%lld\n",sc[i]);
    return 0;
}

P - Interesting Array（待补）

Q - Tree and Queries（待补）

R - Ant colony（待补）

S - Subsegments（待补）

T - Little Girl and Maximum Sum（待补）

U - A Simple Task（待补）

V - Queries about less or equal elements（CF 600B）

原题链接：Problem - 600B - Codeforces

这题放在最后一题我也是惊了awa，估计是龙老师想鼓励我们做后面的题qwq。

简单排序后二分，根据索引即可得出答案。

#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
ll s[200005];
int main(){
	ll n,m,i,j,k,zc;
	scanf("%lld%lld",&n,&m);
	for(i=1;i<=n;i++) scanf("%lld",&s[i]);
	sort(s+1,s+1+n);
	for(i=1;i<=m;i++){
		scanf("%lld",&zc);
		ll sc=upper_bound(s+1,s+1+n,zc)-s-1;
		printf("%lld ",sc);
	}
    return 0;
}

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021-06-28~2021-06-29训练总结

还是太菜了qwq，在随时查了C++ reference资料的情况下写了一天就写不动了qwq，明天好好补题吧awa……A - Time to Raid Cowavans（CF 103D）原题链接：Problem - 103D - Codeforces（我觉得吧，要是没某dalao教我，我估计死活想不出来分类讨论qwq）首先采取离线存储所有a，b询问，考虑到b很小的时候复杂度将接近O(n)，对于b较小的时候用前缀和数组维护间隔b的和，对于b较大的时候直接暴力求和即可。这样的总体时间复杂度为O
复制链接

扫一扫