2022年蓝桥杯省赛 C++ A组

已于 2023-10-16 21:44:20 修改
阅读量143 收藏 3
点赞数
文章标签： c++ 开发语言
于 2023-03-22 22:37:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50533561/article/details/129718459
版权

A.裁纸刀（找规律）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
ll res=4;
int main(){
	/*int n,m;
	cin>>n>>m;
	res+=n-1;
	res+=(m-1)*n;
	cout<<res;
	*/
	cout<<443;
	return 0;
}

B.灭鼠先锋（博弈论）

        注意必败态的判别条件，这里必败态是只剩一个地方没放，和放石子不同，放石子是放满了才是必败态，注意区别！！！所以这里要手动统计还剩的地方，判断是否为必败态 

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
map<string,int> f;
int check(string s){
	int t=0;
	for(int i=0;i<8;i++){
		if(s[i]=='0') t++;
	}
	return t;
}
int sg(string x){
	if(f.count(x)) return f[x];
	//x为必败态 
	if(check(x)==1){
		f[x]=0;
		return f[x];
	}
	set<int> st;
	//放一个 
	for(int i=0;i<8;i++){
		if(x[i]=='X') continue;
		string t=x;
		t[i]='X';
		st.insert(sg(t));
	}
	//放两个
	for(int i=0;i+1<=3;i++){
		if(x[i]=='X'||x[i+1]=='X') continue;
		string t=x;
		t[i]='X';
		t[i+1]='X';
		st.insert(sg(t));
	} 
	for(int i=4;i+1<=7;i++){
		if(x[i]=='X'||x[i+1]=='X') continue;
		string t=x;
		t[i]='X';
		t[i+1]='X';
		st.insert(sg(t));
	} 
	for(int i=0;;i++){
		if(!st.count(i)){
			f[x]=i;
			break;
		}
	}
	return f[x];
}
int main(){
	/*string s[]={"X0000000","XX000000","0X000000","0XX00000"};
	for(int i=0;i<4;i++){
		//先手走了一步
		//先手后手转换 sg=0 先手必胜 
		if(sg(s[i])==0) cout<<"V";
		else cout<<"L";
	}*/ 
	cout<<"LLLV"; 
	return 0;
}

C.求和（前缀和）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+5;
ll res;
ll w[N];
ll sum[N];
int n;
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%lld",&w[i]);
		sum[i]=sum[i-1]+w[i];
	}
	for(int i=1;i<=n;i++){
		res+=w[i]*(sum[n]-sum[i]);
	}
	printf("%lld",res);
}

D.选数异或（思维）

        判断[l,r]之间是否有两个数异或等于x，等价是否存在一个数t，在区间内同时存在t^x

① 用pos[i]记录i上次出现的位置

② 用left[i]记录在w[i]左侧，且与w[i]匹配的最近的数的位置

        遍历[l,r]，判断是否存在left[i]>=l即可（可能超时，正确做法是用线段树，维护区间内left的最大值，判断[l,r]内left最大值是否>=l）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
ll w[N];
int n,m;
ll x;
unordered_map<ll,int> pos;//上次出现的位置
int left_[N];//i左边最近的满足要求的数的位置 
int main(){
	scanf("%d%d%lld",&n,&m,&x);
	for(int i=1;i<=n;i++){
		scanf("%lld",&w[i]);
		pos[w[i]]=i; 
		left_[i]=pos[w[i]^x];
	}
	while(m--){
		int l,r;
		scanf("%d%d",&l,&r);
		bool f=false;
		for(int i=l;i<=r;i++){
			if(left_[i]>=l){
				f=true;
				break;
			}
		}
		if(f) printf("yes\n");
		else printf("no\n");
	}
}

线段树维护

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
#define fast(); ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
const int N=1e5+5;
int n,m;
ll A[N],x;
unordered_map<ll,int> pos;//某个数上次出现的位置 
int left_[N];//left_[i] 左边最近的满足的数的位置 
struct node{
	int l,r;
	int maxn;
}tr[N<<2];
void pushup(int u){
	tr[u].maxn=max(tr[u<<1].maxn,tr[u<<1|1].maxn);
}
void build(int u,int l,int r){
	if(l==r){
		tr[u].l=tr[u].r=l;
		tr[u].maxn=left_[l];
		return;
	}
	tr[u].l=l;
	tr[u].r=r;
	int mid=l+r>>1;
	build(u<<1,l,mid);
	build(u<<1|1,mid+1,r);
	pushup(u);
}
//求l,r的left[i]的最大值 
int query(int u,int l,int r){
	if(tr[u].l>=l&&tr[u].r<=r) return tr[u].maxn;
	int mid=tr[u].l+tr[u].r>>1;
	int maxn=0;  
	if(mid>=l) maxn=max(maxn,query(u<<1,l,r));
	if(mid<r) maxn=max(maxn,query(u<<1|1,l,r));
	return maxn;
}
int main(){
	scanf("%d%d%lld",&n,&m,&x);
	for(int i=1;i<=n;i++){
		scanf("%d",&A[i]);
		pos[A[i]]=i;
		left_[i]=pos[A[i]^x];
	}
	build(1,1,n);
	while(m--){
		int l,r;
		scanf("%d%d",&l,&r);
		int res=query(1,l,r);
		if(res>=l) printf("yes\n");
		else printf("no\n");
	}
}

E.爬树的甲壳虫（概率期望推导+逆元）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
const int N=1e5+5,mod=998244353;
int n;
ll xx[N],yy[N];
ll qmi(ll a,ll k){
	ll res=1;
	while(k){
		if(k&1) res=res*a%mod;
		a=a*a%mod;
		k>>=1;
	}
	return res;
}
int main(){
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>xx[i]>>yy[i];
	}
	ll res=0,d=1;
	for(int i=n;i>=1;i--){
		ll x=xx[i],y=yy[i];
		d=(d*y)%mod;
		d=d*qmi(y-x,mod-2)%mod;
		res=(res+d)%mod;
	}
	cout<<res;
}

F.青蛙过河（二分）

        枚举区间长度L，check为判断所有长度为L的区间和是否全不小于2x，二分枚举满足要求的最大区间长度

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
int n,x;
int h[N];
ll sum[N];
bool check(int mid){
	for(int i=1;i+mid-1<n;i++){
		int j=i+mid-1;
		if(sum[j]-sum[i-1]<(ll)2*x) return false;
	}
	return true;
}
int main(){
	scanf("%d%d",&n,&x);
	for(int i=1;i<n;i++){
		scanf("%d",&h[i]);
		sum[i]=sum[i-1]+h[i];
	}
	int l=0,r=n-1;
	while(l<r){
		int mid=l+r>>1;
		if(check(mid)){
			r=mid;
		}else{
			l=mid+1;
		}
	}
	cout<<l<<endl;
	
}

G.最长不下降子序列（上升子序列+线段树）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
const int N=1e5+5;
int dp1[N];//以a[i]结尾的最长不下降子序列的长度
int dp2[N];//以a[i]开头的最长不下降子序列的长度
int a[N],b[N];
int n,k;
int res,m;
struct node{
	int l,r;
	int maxn;
}tr[N<<2];
void pushup(int u){
	tr[u].maxn=max(tr[u<<1].maxn,tr[u<<1|1].maxn);
}
void build(int u,int l,int r){
	if(l==r){
		tr[u]={l,r,0};
	}else{
		tr[u]={l,r};
		int mid=l+r>>1;
		build(u<<1,l,mid);
		build(u<<1|1,mid+1,r);
		pushup(u);
	}
}
void modify(int u,int pos,int val){
	if(tr[u].l==tr[u].r) tr[u].maxn=max(tr[u].maxn,val);
	else{
		int mid=tr[u].l+tr[u].r>>1;
		if(pos<=mid) modify(u<<1,pos,val);
		else modify(u<<1|1,pos,val);
		pushup(u);
	}
}
int query(int u,int l,int r){
	if(tr[u].l>=l&&tr[u].r<=r) return tr[u].maxn;
	int mid=tr[u].l+tr[u].r>>1;
	int maxn=-1;
	if(l<=mid) maxn=max(maxn,query(u<<1,l,r));
	else maxn=max(maxn,query(u<<1|1,l,r));
	return maxn;
}
int main(){
	cin>>n>>k;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		b[i]=a[i];
	}
	sort(b+1,b+n+1);
	if(n==k){
		cout<<n;
		return 0;
	}
	m=unique(b+1,b+n+1)-(b+1);
	for(int i=1;i<=n;i++){
		int l=1,r=m;
		while(l<r){
			int mid=l+r>>1;
			if(b[mid]>=a[i]) r=mid;
			else l=mid+1; 
		}
		a[i]=l;
	}
	build(1,1,m);
	//从前往后，查在a[i]前，且比a[i]小的，dp1的最大值 
	for(int i=1;i<=n-k;i++){
		dp1[i]=query(1,1,a[i])+1;
		modify(1,a[i],dp1[i]);
	}
	build(1,1,m);
	//从后往前，查在a[i]后，且比a[i]大的，dp2的最大值 
	for(int i=n;i>=k+1;i--){
		res=max(res,dp1[i-k]+k+query(1,a[i-k],m));
		dp2[i]=query(1,a[i],m)+1;
		modify(1,a[i],dp2[i]);
	}
	for(int i=1;i<=n-k;i++){
		res=max(res,dp1[i]+k);
	}
	for(int i=n;i>=k+1;i--){
		res=max(res,dp2[i]+k);
	}
	cout<<res;
}

H.扫描游戏（几何）

        根据象限和斜率，按照顺时针排序，模拟

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
const int N=2e5+5;
int res[N],idx;
struct node{
    ll x,y,z;
    double h;
    int pos;
};
int n;
ll L;
vector<node> vc;
bool cmp(node a,node b){
    if((ll)a.x*b.x<0) return a.x>b.x;
    double ka,kb;
    if(a.x==0){
        if(a.y>=0) ka=1e9;
        else ka=-1e9;
    }else{
        ka=a.y*1.0/a.x;
    }
    if(b.x==0){
        if(b.y>=0) kb=1e9;
        else kb=-1e9;
    }else{
        kb=b.y*1.0/b.x;
    }
    return ka>kb;
}
int main(){
    scanf("%d%lld",&n,&L);
    memset(res,-1,sizeof res);
    for(int i=1;i<=n;i++){
        ll x,y,z;scanf("%lld%lld%lld",&x,&y,&z);
        node t={x,y,z,(double)sqrt(x*x*1.0+y*y*1.0),i};
        vc.push_back(t);
    }
    int cnt=0;
    do{
        vector<node> ne;
        sort(vc.begin(),vc.end(),cmp);
        double kk=1e-18;
        for(int i=0;i<vc.size();i++){
            node t=vc[i];
            if(t.h<=L){
                double k;
                if(t.x==0) k=-1e9;
                else k=t.y*1.0/t.x;
                if(k!=kk){
                    res[t.pos]=++idx;
                }else{
                    res[t.pos]=idx++;
                }
                kk=k;
                L+=t.z;
            }else{
                ne.push_back(t); 
            }
        }
        if(vc.size()==ne.size()) cnt++;
        else cnt=0;
        vc=ne;
    }while(cnt<=2);
    for(int i=1;i<=n;i++){
        printf("%d",res[i]);
        if(i!=n) printf(" ");
    }
}

I.数的拆分（质数）

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
const int N=4005;
int prime[N];
int cnt;
bool vis[N];
void init(){
	for(int i=2;i<N;i++){
		if(!vis[i]){
			prime[++cnt]=i;
		}
		for(int j=1;prime[j]*i<N;j++){
			vis[prime[j]*i]=true;
			if(i%prime[j]==0) break;
		}
	}
}
//判断是否是平方数/立方数 
bool check(ll x){
	if((ll)sqrt(x)*sqrt(x)==x) return true;
	int l=1,r=2e6;
	while(l<r){
		int mid=l+r>>1;
		if((ll)mid*mid*mid>=x) r=mid;
		else l=mid+1;
	}
	if((ll)l*l*l==x) return true;
	return false;
}
int main(){
	init();
	int t;cin>>t;
	while(t--){
		ll x;cin>>x;
		if(check(x)){
			cout<<"yes"<<endl;
			continue;
		}
		bool f=true;
		for(int i=1;i<=cnt;i++){
			if(x%prime[i]==0){
				int s=0;
				while(x%prime[i]==0){
					s++;
					x/=prime[i];
				}
				if(s<2){
					f=false;
					break;
				}
			}
		}
		if(f&&check(x)){
			cout<<"yes"<<endl;
		}else{
			cout<<"no"<<endl;
		}
	}
}

J.推导部分和（差分约束+并查集）

        根据等式建立差分约束，并查集记录两点间是否有约束关系

对于一个点x，如果还未被访问过，说明发现新的约束点集合，点x是集合内编号最小的点，从点x开始bfs求的集合内点到x的距离

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
const int N=1e5+5,M=N<<1;
int h[N],e[M],ne[M],idx;
ll w[M];
int p[N];
int find(int x){
    if(p[x]!=x) p[x]=find(p[x]);
    return p[x];
}
int n,m,q;
void add(int a,int b,ll c){
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}
ll dis[N];
bool vis[N];
void bfs(int st){
    queue<int> q;
    vis[st]=true;
    dis[st]=0;
    q.push(st);
    while(!q.empty()){
        int t=q.front();q.pop();
        for(int i=h[t];~i;i=ne[i]){
            int j=e[i];
            if(vis[j]) continue;
            vis[j]=true;
            dis[j]=dis[t]+w[i];
            q.push(j);
        }
    }
}
int main(){
    cin>>n>>m>>q;
    memset(h,-1,sizeof h);
    for(int i=0;i<=n;i++) p[i]=i;
    for(int i=1;i<=m;i++){
        int l,r;ll s;cin>>l>>r>>s;
        add(l-1,r,s);
        add(r,l-1,-s);
        p[find(l-1)]=find(r);
    }
    for(int i=0;i<=n;i++){
        if(!vis[i]){
            bfs(i);
        }
    }
    while(q--){
        int l,r;cin>>l>>r;
        if(find(l-1)!=find(r)) cout<<"UNKNOWN\n";
        else{
            ll res=dis[r]-dis[l-1];
            cout<<res<<endl;
        }
    }
}

Vic.GoodLuck
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
2019蓝桥杯C_C++省赛 真题
03-25
2019蓝桥杯C_C++省赛 真题2019蓝桥杯C_C++省赛B组
第九届蓝桥杯（省赛）C++C组真题题解
热门推荐
pursuit的博客
04-11 28万+
第九届蓝桥杯（省赛）C++C组真题题解，仅为个人题解，有误请指出
2024第十五届蓝桥杯省赛C++A组程序设计题解
最新发布
weixin_73611714的博客
04-16 6219
ps：没有答案，考场上的代码，不一定对，大佬们轻喷，可以提供点更好的思路~
蓝桥杯C++A组真题练习（一）
csdnwqy030429的博客
04-06 2100
蓝桥杯C++A组真题练习糖果重复字符串子串分值修改数组 糖果 状压DP水题，没啥好说的。 #include<iostream> #include<cstring> using namespace std; const int N = 110, M = 20, K = 1 << 20, INF = 0x3f3f3f3f; int w[N], dp[K], n, m, k; int read() {//快读板子 char ch = getchar(); int x =
2012-2020蓝桥C++ B组蓝桥杯省赛真题（第一题）
qq_57867712的博客
02-27 1522
2012-2020蓝桥C++ B组蓝桥杯省赛真题（第一题）
第十二届蓝桥杯 2021年省赛真题 (C/C++ 大学A组) 第一场
NOW I GOT ONE WAY
03-12 6594
蓝桥杯 2021年省赛真题 (C/C++ 大学A组 ）
2022年第十三届蓝桥杯大赛软件赛省赛C/C++ 大学C 组
06-21
2022年第十三届蓝桥杯大赛软件赛省赛C/C++ 大学C 组
2022年第十三届蓝桥杯省赛 C/C++ B组 真题
08-08
试题 A: 九进制转十进制 试题 B: 顺子日期 试题 C: 刷题统计 试题 D: 修剪灌木 试题 E: X 进制减法 试题 F: 统计子矩阵 试题 G: 积木画 试题 H: 扫雷 试题 I: 李白打酒加强版 试题 J: 砍竹子
2022年第十三届蓝桥杯省赛c/C++B组题目
04-09
2022年第十三届蓝桥杯省赛c/C++B组题目 解密码：QaTLL2d7
2022年第十三届蓝桥杯大赛软件赛C/C++ 大学 B 组省赛、省赛第二场、决赛
06-21
2022年第十三届蓝桥杯大赛软件赛C/C++ 大学 B 组省赛、省赛第二场、决赛
十三届蓝桥杯c/c++B组试题
06-30
十三届蓝桥杯c/c++B组试题试题 C: 卡牌试题 A: 2022试题 B: 钟表试题 D: 最大数字试题 E: 出差试题 F: 费用报销试题 G: 故障试题 H: 机房试题 I: 齿轮试题 I: 齿轮他一共有 n 块砖，他发现第 i 砖的重量为 wi，价值...
2018年第九届蓝桥杯省赛真题C/C++(B组)
04-01
2018年第九届蓝桥杯省赛真题 C/C++ 语言大学B组原题。
2018年4月1日蓝桥杯省赛第九届蓝桥杯真题C/C++(A组)
04-02
2018年4月1日蓝桥杯省赛第九届蓝桥杯真题C/C++(A组)!2018年4月1日蓝桥杯省赛第九届蓝桥杯真题C/C++(A组)
第十三届蓝桥杯C/C++A组真题
qq_45864279的博客
04-10 691
第十三届蓝桥杯C/C++A组试题真题
2019年第十届蓝桥杯大赛C++ A组真题
qq_44789060的博客
03-25 1488
2019年第十届蓝桥杯大赛C++ A组真题 试题一：平方和 试题二：数列求值 试题三：最大降雨量 试题四：迷宫 试题五：RSA解密 试题六：完全二叉树的权值 试题七：外卖店优先级 试题八：修改数组 试题九：糖果 试题十：组合数问题 ...
【蓝桥杯】2023年第十四届蓝桥杯大赛软件类省赛C/C++大学A组真题
m0_74183164的博客
09-19 6135
根据题意多写几个，不难发现奇数似乎都能拆成y2 − z2的形式？因此，我们从奇偶的角度来找规律。那么，在这里就可以得出结论辣。但是好在，已知一个数x，对应的奇数、4的倍数的数的个数是可以算出来的。初步想法，x = y2 − z2=（y+z)(y-z)（这一步还不能过属实有点钻牛角尖了。但时间是（r-l）*x，数据1e9，直接T了。即x存在两个因数之和为偶数就能满足条件。即x=a*b，a=y+z，b=y-z。即a+b是2的倍数就好了。1.奇数 2.4的倍数。
蓝桥杯题选（C++ A组）（2019.2020.2021.2022省赛及2020国赛部分题）
春弦的博客
02-23 1083
2021 砝码称重 砝码称重https://www.acwing.com/problem/content/3420 略有变形的01背包问题 先把所有砝码可能达到的最大总重sum计算出来，每次多讨论一个砝码时枚举1~sum之间的所有数，如果被标记过（表明之前已经得到过这个重量），我们可以在此数基础上加上当前砝码重量/减去当前砝码重量，并对得到的数值进行标记，并把当前讨论的砝码的单独的重量打上标记，这样一层一层推进。 #include<bits/stdc++.h> using ...
C/C++ 第十届蓝桥杯大赛省赛真题（大学A组） 题解
陈陈陈Chan的博客
08-06 2680
文章目录1. 平方和2. 数列求值3. 最大降雨量4. 迷宫5. RSA解密6. 完全二叉树的权值7. 外卖店优先级8. 修改数组9. 糖果10. 组合数问题 题目 类型 平方和 结果填空 数列求值 结果填空 最大降雨量 结果填空 迷宫 结果填空 RSA解密 结果填空 完全二叉树的权值 编程题 外卖店优先级 编程题 修改数组 编程题 糖果 编程题 组合数问题 编程题 1. 平方和 本题总分：5分 问题描述 小明对数位中含有 2、0、1、9 的数字很感
第十二届蓝桥杯软件类省赛C++ B组 题目 + 题解
qq_45662097的博客
06-20 1117
文章目录试题 A: 空间试题 B: 卡片试题 C: 直线试题 D: 货物摆放试题 E: 路径试题 F: 时间显示试题 G: 砝码称重 试题 A: 空间 【问题描述】 小蓝准备用 256MB 的内存空间开一个数组，数组的每个元素都是 32 位 二进制整数，如果不考虑程序占用的空间和维护内存需要的辅助空间，请问 256MB 的空间可以存储多少个 32 位二进制整数？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。 /
蓝桥杯省赛c++b组常用的STL函数
03-31
1. vector：动态数组，支持动态扩容和访问元素。 2. list：双向链表，支持插入和删除操作。 3. set/multiset：红黑树实现的集合/多重集合，支持元素的快速查找、插入和删除操作。 4. map/multimap：红黑树实现的映射/多重映射，支持键值对的快速查找、插入和删除操作。 5. queue：队列，支持队列的基本操作：入队、出队、获取队首元素等。 6. stack：栈，支持栈的基本操作：入栈、出栈、获取栈顶元素等。 7. priority_queue：优先队列，支持插入元素、获取队首元素等操作，但是队列中的元素按照优先级排序。 8. algorithm：STL算法库，包含了许多常用的算法，如排序、查找、计数、求和、变换等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Vic.GoodLuck

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值