计蒜客 2017 NOIP 提高组模拟赛（一）Day2

最新推荐文章于 2020-03-01 19:50:39 发布
最新推荐文章于 2020-03-01 19:50:39 发布
阅读量354 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_h_h_/article/details/77918978
版权

转送门

T1：蒜头君的兔子

首先考虑暴力算法：用数组完全模拟，作为对拍程序：

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MOD 1000000007
#define ll long long
using namespace std;
int n;
ll a[15],b[15];
int main()
{
    scanf("%d",&n);
    ll sum=0;
    a[1]=1;
    for(int i=2;i<=n;i++){
        memcpy(b+1,a,sizeof(ll)*10);
        sum=((sum-a[10]+MOD)%MOD+a[1])%MOD;
        b[0]=sum;
        memcpy(a,b,sizeof(b));
    }
    sum=0;
    for(int i=0;i<10;i++){
        sum=(sum+b[i])%MOD;
    }
    printf("%lld\n",sum);
    return 0;
}

可以过6/7的数据

进一步考虑递推式：

d[i][j]表示第i天年龄为j岁兔子数目

那么有d[i][1]=d[i-1][1]+d[i-1][2]+……+d[i-1][9]
d[i][j]=d[i-1][j-1]
考虑矩阵快速幂优化
对于d[i][1]是一个9阶递推式
于是可以：
设初始状态为：
矩阵A=（0 1 0 0 0 0 0 0 0 0 0）
B=
(0 1 0 0 0 0 0 0 0 0 0
1 0 1 0 0 0 0 0 0 0 0
1 0 0 1 0 0 0 0 0 0 0
1 0 0 0 1 0 0 0 0 0 0
1 0 0 0 0 1 0 0 0 0 0
1 0 0 0 0 0 1 0 0 0 0
1 0 0 0 0 0 0 1 0 0 0
1 0 0 0 0 0 0 0 1 0 0
1 0 0 0 0 0 0 0 0 1 0
1 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 )
第二年为A*B
第三年为A*B^2
第n年为A*B^(n-1)
用快速幂优化，时间复杂度为O(1000*logn)

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MOD 1000000007
#define ll long long
#define MAXN 12
using namespace std;
struct Mat{
	int x,y;
	ll a[MAXN][MAXN];
	Mat(){
		x=y=0;
		memset(a,0,sizeof(a));
	}
};
int n;
Mat cheng(Mat A,Mat B){
	Mat ret;
	ret.x=A.x,ret.y=B.y;
	for(int i=0;i<=ret.x;i++){
		for(int j=0;j<=ret.y;j++){
			for(int k=0;k<=ret.y;k++){
				ret.a[i][j]=(ret.a[i][j]+(A.a[i][k]*B.a[k][j])%MOD)%MOD;
			}
		}
	}
	return ret;
}
Mat power(Mat A,int p){
	if(1==p){
		return A;
	}
	if(p&1){
		return cheng(power(cheng(A,A),p>>1),A);
	}
	else{
		return power(cheng(A,A),p>>1);
	}
}
int main()
{
	int n;
	scanf("%d",&n);
	Mat A,B;
	A.x=0; A.y=10;
	B.x=10; B.y=10;
	A.a[0][1]=1;
	for(int i=1;i<=9;i++){
		B.a[i][0]=1;
	}
	for(int i=0;i<=9;i++){
		B.a[i][i+1]=1;
	}
	if(n==1){
		printf("1\n");
		return 0;
	}
	Mat C=cheng(A,power(B,n-1));
	ll ans=0;
	for(int i=0;i<C.y;i++){
		ans=(ans+C.a[0][i])%MOD;
	}
	printf("%lld\n",ans);
	return 0;
}
============================================

T2:蒜头君的排序

对于求冒泡排序的最小交换次数，就是求逆序对的个数
因为冒泡每次交换只能解决一对逆序对，所以至少交换次数为逆序对的数目
对于逆序对，可以用树状数组或者是分治，效率是O(nlogn)
这里很显然不能直接做，发现题目的提示∑∣l[i]−l[i−1]∣ + \sum | r[i]-r[i-1] | \le∑∣r[i]−r[i−1]∣≤ 7×106

发现已知[L,R]可以很快速地算出[L,R+1] [L,R-1] [L+1,R] [L-1,R]

于是我们可以用莫队算法

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<cmath>
#define MAXN 30005
using namespace std;
int n,m;
int a[MAXN];
int b1[MAXN],b2[MAXN];
int sum1(int k){
	int ret=0;
	while(k>=1){
		ret+=b1[k];
		k-=(k&-k);
	}
	return ret;
}
void add1(int k,int x){
	while(k<=n){
		b1[k]+=x;
		k+=(k&-k);
	}
}
int sum2(int k){
	int ret=0;
	while(k<=n){
		ret+=b2[k];
		k+=(k&-k);
	}
	return ret;
}
void add2(int k,int x){
	while(k>=1){
		b2[k]+=x;
		k-=(k&-k);
	}
}
struct Qu{
	int L,R,Lb;
	int ans,id;
	Qu(){
		L=R=Lb=ans=0;
	}
}s[MAXN];
bool comp1(const Qu &p1,const Qu &p2){
	if(p1.Lb!=p2.Lb){
		return (p1.Lb<p2.Lb);
	}
	else{
		return (p1.R<p2.R);
	}	
}
bool comp2(const Qu &p1,const Qu &p2){
	return (p1.id<p2.id);
}
int main()
{
//	freopen("T2.in","r",stdin);
//	freopen("my.out","w",stdout);
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	int len=sqrt((double)n);
	scanf("%d",&m);
	for(int i=1;i<=m;i++){
		scanf("%d%d",&s[i].L,&s[i].R);
		s[i].id=i;
		s[i].Lb=s[i].L/len;
	}
	sort(s+1,s+m+1,comp1);
	int L=s[1].L,R=s[1].L-1,ans=0;
	for(int i=1;i<=m;i++){
		if(s[i].L!=L){
			if(L<s[i].L){
				for(int j=L;j<s[i].L;j++){
					ans-=sum1(a[j]-1);
					add1(a[j],-1);
					add2(a[j],-1);					
				}
			}
			else{
				for(int j=L-1;j>=s[i].L;j--){
					ans+=sum1(a[j]-1);
					add1(a[j],1);
					add2(a[j],1);					
				}
			}
		}
		if(s[i].R!=R){
			if(R>s[i].R){
				for(int j=R;j>s[i].R;j--){
					ans-=sum2(a[j]+1);
					add1(a[j],-1);	
					add2(a[j],-1);				
				}
			}
			else{
				for(int j=R+1;j<=s[i].R;j++){
					ans+=sum2(a[j]+1);
					add1(a[j],1);
					add2(a[j],1);				
				}
			}	
		}
		L=s[i].L,R=s[i].R;
		s[i].ans=ans;
	}
	sort(s+1,s+m+1,comp2);
	for(int i=1;i<=m;i++){
		printf("%d\n",s[i].ans);
	}
	return 0;
}
顺便附上对拍程序： 

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#define MAXN 30005
using namespace std;
int a[MAXN];
int n;
int main()
{
	freopen("T2.in","r",stdin);
	freopen("std.out","w",stdout);
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	int T;
	scanf("%d",&T);
	for(int k=1;k<=T;k++){
		int L,R;
		int ans=0;
		scanf("%d%d",&L,&R);
		for(int i=L;i<=R;i++){
			for(int j=i+1;j<=R;j++){
				if(a[i]>a[j]){
					ans++;
				}
			}
		}
		printf("%d\n",ans);
	}
	return 0;
}
T3：蒜头君救人

一开始没有考虑到可以先接人送到终点后继续回来接人，结果WA

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<queue>
#define MAXN 11
#define MAXS 1<<11
#define pii pair<int,int>
using namespace std;
int d[MAXS][MAXN][MAXN];
int b[MAXS][MAXN][MAXN];
int go[5]={0,1,0,-1,0};
char a[MAXN][MAXN];
int p[MAXN];
int n,m,k,P;
int sx,sy,tx,ty;
queue<pii> q1;
queue<int> q2;
int SPFA(){
	memset(d,0x7f,sizeof(d));
	d[0][sx][sy]=0;
	b[0][sx][sy]=1;
	q1.push(make_pair(sx,sy));
	q2.push(0);
	while(!q1.empty()){
		int x=q1.front().first,y=q1.front().second;
		int S=q2.front();
		b[S][x][y]=0;
		q1.pop(); q2.pop();
		int w=k;
		for(int i=S,j=1;i;i>>=1,j++){
			if(i&1){
				w+=p[j];
			}
		} 
		w=max(w,1);
		for(int k=0;k<4;k++){
			int dx=x+go[k],dy=y+go[k+1],dS=S;
			if(1<=dx&&dx<=n&&1<=dy&&dy<=m&&a[dx][dy]!='#'){
				if(1<=a[dx][dy]&&a[dx][dy]<=10){
					dS=(dS|(1<<(a[dx][dy]-1)));
				}
				if(d[dS][dx][dy]>d[S][x][y]+w){
					d[dS][dx][dy]=d[S][x][y]+w;
					if(!b[dS][dx][dy]){
						b[dS][dx][dy]=1;
						q1.push(make_pair(dx,dy));
						q2.push(dS);
					}
				}
			}
		}
	}
	return d[(1<<P)-1][tx][ty];
}
int main()
{
//	freopen("T3.in","r",stdin);
//	freopen("my.out","w",stdout);
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			scanf(" %c",&a[i][j]);
			if('A'<=a[i][j]&&a[i][j]<='Z'){
				a[i][j]-=64;
				P=max(P,(int)a[i][j]);
			}
			else if('s'==a[i][j]){
				sx=i; sy=j;
			}
			else if('t'==a[i][j]){
				tx=i; ty=j;
			}
		}
	}
	for(int i=1;i<=P;i++){
		char c;
		scanf(" %c %d",&c,&p[i]);
	}
	printf("%d\n",SPFA());
	return 0;
}
后来发现了这种情况，于是改为三进制数

1表示已经背上，2表示已经送走，0表示没有处理

对于到终点，可以考虑两种情况：

1）把消耗的人送走，把加快的人留下

2）全部送走（以获得最终答案）

时间复杂度约为O(3^P*n*m)

P为农民个数

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<queue>
#define INF 0x7f7f7f7f
#define MAXN 11
#define MAXS 59050
#define pii pair<int,int>
using namespace std;
int n,m,k;
int a[MAXN][MAXN];
int d[MAXS][MAXN][MAXN];
int go[5]={0,1,0,-1,0};
bool b[MAXS][MAXN][MAXN];
queue<pii > q1;
queue<int> q2;
int sx,sy,tx,ty;
int P,p[MAXN];
int Power(int x,int k){
	int ret=1;
	for(int i=1;i<=k;i++){
		ret*=x;
	}
	return ret;
}
int main()
{
//	freopen("T3.in","r",stdin);
//	freopen("my.out","w",stdout);
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			char c; scanf(" %c",&c);
			if('s'==c){
				sx=i; sy=j;
				a[i][j]=-1;
			}
			else if('t'==c){
				tx=i; ty=j;
				a[i][j]=-1;
			}
			else if('A'<=c&&c<='Z'){
				a[i][j]=c-64;
				P=max(P,a[i][j]);
			}
			else if('.'==c){
				a[i][j]=-1;
			}
		}
	}
	for(int i=1;i<=P;i++){
		char c;
		scanf(" %c %d",&c,&p[i]);
	}
	memset(d,0x7f,sizeof(d));
	d[0][sx][sy]=0;
	b[0][sx][sy]=1;
	q1.push(make_pair(sx,sy));
	q2.push(0);
	while(!q1.empty()){
		int x=q1.front().first,y=q1.front().second;
		int S=q2.front();
		b[S][x][y]=0;
		q1.pop(); q2.pop();
		int w=k;
		for(int t=S,L=1;t;t/=3,L++){
			if(1==(t%3)){
				w+=p[L];
			}
		}
		w=max(w,1);
		for(int k=0;k<4;k++){
			int dx=x+go[k],dy=y+go[k+1],dS=S;
			if(1<=dx&&dx<=n&&1<=dy&&dy<=m&&a[dx][dy]){
				if(dx==tx&&dy==ty){
					for(int t=S,L=1;t;t/=3,L++){
						if(1==(t%3)){
							dS+=Power(3,L-1);
						}
					}
					if(d[dS][dx][dy]>d[S][x][y]+w){
						d[dS][dx][dy]=d[S][x][y]+w;
						if(!b[dS][dx][dy]){
							b[dS][dx][dy]=1;
							q1.push(make_pair(dx,dy));
							q2.push(dS);
						}
					}
					if(dS==S){
						continue;
					}
					dS=S;
					for(int t=S,L=1;t;t/=3,L++){
						if(1==(t%3)&&p[L]>0){
							dS+=Power(3,L-1);
						}
					}
					if(d[dS][dx][dy]>d[S][x][y]+w){
						d[dS][dx][dy]=d[S][x][y]+w;
						if(!b[dS][dx][dy]){
							b[dS][dx][dy]=1;
							q1.push(make_pair(dx,dy));
							q2.push(dS);
						}
					}
					continue;
				}
				if(d[dS][dx][dy]>d[S][x][y]+w){
					d[dS][dx][dy]=d[S][x][y]+w;
					if(!b[dS][dx][dy]){
						b[dS][dx][dy]=1;
						q1.push(make_pair(dx,dy));
						q2.push(dS);
					}
				}
				if(a[dx][dy]>0){
					int t=S;
					for(int i=1;i<a[dx][dy];i++){
						t/=3;
					}
					t=t%3;
					if(!t){
						dS=S+Power(3,a[dx][dy]-1);
						if(d[dS][dx][dy]>d[S][x][y]+w){
							d[dS][dx][dy]=d[S][x][y]+w;
							if(!b[dS][dx][dy]){
								b[dS][dx][dy]=1;
								q1.push(make_pair(dx,dy));
								q2.push(dS);
							}
						}
					}
				}
			}
		}
	}
	int t=Power(3,P)-1;
//	for(int k=0;k<=t;k++){
//		for(int c=k,L=0;L<=5;c/=3,L++){
//			printf("%d ",c%3);
//		}
//		printf("\n");
//		for(int i=1;i<=n;i++){
//			for(int j=1;j<=m;j++){
//				if(INF==d[k][i][j]){
//					printf("- ");
//				}
//				else{
//					printf("%d ",d[k][i][j]);	
//				}
//			}
//			printf("\n");
//		}
//		printf("\n");
//	}
	printf("%d\n",d[t][tx][ty]);
	return 0;
}
顺便附上对拍程序 

#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<cstring>
#include<queue>
#define INF 0x7f7f7f7f
#define MAXN 11
#define MAXS 1<<11
#define pii pair<int,int>
using namespace std;
int d[MAXS][MAXN][MAXN];
int go[5]={0,1,0,-1,0};
char a[MAXN][MAXN];
int p[MAXN];
int n,m,k,P;
int sx,sy,tx,ty;
int ans=INF;
void dfs(int S,int x,int y,int dep){
	if(d[S][x][y]<=dep){
		return;
	}
	d[S][x][y]=dep;
	if(S==(1<<P)-1&&x==tx&&y==ty){
		ans=min(ans,dep);
	}
	int w=k;
	for(int i=S,j=1;i;i>>=1,j++){
		if(i&1){
			w+=p[j];
		}
	} 
	w=max(w,1);
	for(int k=0;k<4;k++){
		int dx=x+go[k],dy=y+go[k+1],dS=S;
		if(1<=dx&&dx<=n&&1<=dy&&dy<=m&&a[dx][dy]!='#'){
			if(1<=a[dx][dy]&&a[dx][dy]<=10){
				dS=(dS|(1<<(a[dx][dy]-1)));
			}
			dfs(dS,dx,dy,dep+w);
		}
	}
}
int main()
{
	freopen("T3.in","r",stdin);
	freopen("std.out","w",stdout);
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			scanf(" %c",&a[i][j]);
			if('A'<=a[i][j]&&a[i][j]<='Z'){
				a[i][j]-=64;
				P=max(P,(int)a[i][j]);
			}
			else if('s'==a[i][j]){
				sx=i; sy=j;
			}
			else if('t'==a[i][j]){
				tx=i; ty=j;
			}
		}
	}
	for(int i=1;i<=P;i++){
		char c;
		scanf(" %c %d",&c,&p[i]);
	}
	memset(d,0x7f,sizeof(d));
	dfs(0,sx,sy,0);
	printf("%d\n",ans);
	return 0;
}


w_h_h_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2021csp-j/s第二轮总结反思
LeeCongWei的博客
10-24 1089
刚刚结束了csp-j/s，不是很理想，这里总结一下，希望以后能够改进。 CSP-J CSP-J题目整体来说不是难，做起来也挺舒服的。 这次只用了20分钟看题，除了第二题不大确定，其余都有明确的想法。 先打了T1，把题目转换成数学式子就发现是在L到R当中选择一个数，使其模n最大。转化完后就随便做了。 然后打了T3，总的来说T3的细节还是比较多的，调了好一会儿是因为没看好题，没考虑全，还好大样例还是比较强的，调完之后应该是没有问题的了。 打完两题大概花了1h，然后回去看T2，一直不敢打5000*8000，怕TL
noip提高组模拟题5
07-21
【标题】"noip提高组模拟题5"指的是针对全国青少年信息学奥林匹克竞赛(NOIP)提高组的一次模拟测试题目集。NOIP是中国青少年在计算机科学领域的一项重要比赛，旨在提升学生的编程技能和算法理解能力。提高组是针对...
【杂文】搞一个对拍程序
aiauw80822的博客
05-21 172
【杂文】搞一个对拍程序 有时候可能我们需要数据来对程序进行差错，但良心的出题人又只给了你一个连蒙都能蒙对的数据。 对拍程序，不花时间不考码力不费脑，\(OIer\) 居家旅行必备佳品。 【原理】 采用 <\(cstdlib\)> 里的函数。 简单来说就是无限循环着做三件事： 【生成数据】 可以写一些较简单的数据方便分析并改进代码，也可以写一些较庞大的数据来测试代码运行时...
2020 计蒜客信息学 2 月提高组模拟赛 A 受力平衡(组合数学题) B 保护水库（定期重构）
ccsu_deer
03-01 395
题目链接 #include<bits/stdc++.h> using namespace std; typedef long long ll; const ll mod=1e9+7; const int N=2e6+10; ll powmod(ll a,ll b) { ll res=1; for(;b;b>>=1){ if(b&a...
计蒜客 2017 NOIP 提高组模拟赛（一）题解
Lynstery's blog
08-09 1772
最近做了一下这个，所以来写份题解。day1 T1 以前做过差不多的题，就是把矩阵转45度，然后就可以二维前缀和了。 T2 一条边对答案的贡献即经过它的路径的总条数，就等于删去这条边后得到的两个子树的点数乘积。 每次直接 O(1)O(1) 改一下就好了。 T3 直接 DPDP, f[i][j][k]f[i][j][k] 表示走到位置 (i,j)(i,j) ,已经用了 kk 次技能的受伤最小值。
计蒜客 2017 NOIP 提高组模拟赛（二）Day2
w_h_h_的博客
09-17 1269
T1:劫富济贫 这题一开始hash做的，超时 #include #include #include #include #include #include #define MAXN 3000005 #define MOD1 12000017 #define MOD2 15000127 #define ll long long #define pii pair using namespace
计蒜客 2017 NOIP 提高组模拟赛（一）Day1
w_h_h_的博客
09-12 387
T1:蒜头君打地鼠 当时用树状数组求和的，效率并不是很高，但也能过一部分数据，其实暴力用前缀和优化下似乎可以AC。 正解是矩阵旋转+二位前缀和。 #include #include #include #include #include #define MAXN 2005 #define pii pair using namespace std; int n,k; int dat[MAXN
计蒜客 2017 NOIP 提高组模拟赛（三）Day2 小区划分
苦鬼·。
09-11 731
一条街道的两侧各连续坐落着 NN 座单元楼。现在要为这些单元楼划分居民校区。规则如下：每个小区只能由同一侧连续的若干座单元楼组成。且两侧都恰有 KK 个小区（每个小区至少有一栋楼）。两侧的小区划分规则应该相同，比如，若左边的房子被分成 {1,2},{3}{1,2},{3} 这两个小区，那么右边也应该如此。这样两边合计一共有 KK 对小区。用 a_i,b_ia ​i ​​ ,b ​i ​​
计蒜客NOIP提高组模拟Day2,Pro1蒜头君的兔子
NightRaven的博客
07-30 1311
https://nanti.jisuanke.com/t/16442 中文题不讲题意。。。只要看一眼数据范围就知道暴力模拟是肯定不行的，我们就来想一想其他方法。 这题现场也没有满分解法。。。试后得知正解是矩阵乘法，就又跑去复习了一遍矩阵乘法，其实也是很好理解的。 因为一到十岁就会死，所以一共只有十种年龄，把他们都压进一个单列矩阵（单行也行），然后因为一岁的是由零岁转移来，两岁是由一岁转移来，所
计蒜客 2017 NOIP 提高组模拟赛（一）Day2 T1 蒜头军的兔子
Brian551 's Home
10-29 735
蒜头君的小伙伴在 第一年 送给他一对 一岁 的兔子，并告诉他：这种兔子 刚生下来时算 00 岁，到了 22 岁时就可以繁殖了，它在 2-102−10 岁时，每年会生下来一对兔子，这些兔子到了 22 岁也可以繁殖，但这些兔子在 1010 岁那年 生完仔后 不久就会死亡，蒜头君想知道，第 nn 年兔子 产仔之后（第 nn 年 1010 岁的兔子此时已经死亡），他会有多少对兔子。结果对 10000000
noip2017提高组试题(day1+day2)CSP竞赛比赛CSP考级.pdf
05-14
NOIP比赛，NOIP竞赛历年真题及答案，CSP比赛，CSP竞赛，CSP考级；NOIP普及组，NOIP提高组。
NOIP2012提高组复赛day2试题CSP竞赛比赛CSP考级.pdf
最新发布
05-14
NOIP比赛，NOIP竞赛历年真题及答案，CSP比赛，CSP竞赛，CSP考级；NOIP普及组，NOIP提高组。
noip提高组模拟题6
07-21
【标题】"noip提高组模拟题6"指的是全国青少年信息学奥林匹克联赛（NOIP）提高组的一个模拟测试题目集。这个模拟测试是为准备参加NOIP提高组比赛的选手们设计的，目的是帮助他们提升编程能力和算法理解。 【描述】...
noip提高组模拟题
08-14
在【压缩包子文件的文件名称列表】中，"2018提高模拟1"可能表示这是一个系列的模拟题集，"提高模拟1"可能代表第一套模拟试题，可能还包括"提高模拟2"、"提高模拟3"等，每一套都包含一系列的问题，以及对应的题解和...
noip提高组模拟题2
07-21
【标题】"noip提高组模拟题2"指的是针对全国青少年信息学奥林匹克竞赛(NOIP)提高组的一套模拟试题集。NOIP是中国信息学奥赛的重要组成部分，旨在培养青少年的计算机编程能力，提升他们的逻辑思维和问题解决技能。...
NOIP2017初赛提高组参考答案CSP竞赛比赛CSP考级.pdf
05-14
NOIP比赛，NOIP竞赛历年真题及答案，CSP比赛，CSP竞赛，CSP考级；NOIP普及组，NOIP提高组。
noip提高组模拟题7
07-21
【标题】"noip提高组模拟题7"指的是全国青少年信息学奥林匹克联赛（NOIP）提高组的一个模拟测试题目集。这个集子主要是为准备参加NOIP提高组比赛的选手设计的，目的是帮助他们提升编程技能和解题能力。通过解决这些...
noip提高组模拟题7sz
11-12
【标题】"noip提高组模拟题7sz"是一份专为NOIP（全国青少年信息学奥林匹克竞赛）提高组参赛者准备的模拟试题集。这个集合由经验丰富的专家出题，旨在帮助选手们提升在数论、图论、动态规划（DP）以及搜索算法等核心...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值