2021年第十二届蓝桥杯省赛B组C/C++题解
这次蓝桥杯总的来说要比前几年会难一些，因为大多数涉及到思维，所以普遍分低，希望今年自己还能有省一。
这里是我自己写的一些题解，答案核对后一般是正确的给大家讲讲我的思路。
没什么好说的：
1MB=1024KB 1KB=1024B 32位bit是4字节
所以答案是256* 1024 *1024 / 4 =67108864
答案：67108864
计算每个数字的使用情况，最后不够的时候停止，此时是第一个不能拼出的使用要减去一个
#include<iostream>
using namespace std;
int main(){
int cnt[10];
for(int i=0;i<10;i++)
cnt[i]=2021;
for(int i=1;;i++){
int t=i;
while(t){
int a=t%10;
if(cnt[a]>0)cnt[a]--;
else break;
t/=10;
}
if(t){
cout<<i;
break;
}
}
return 0;
}
//3181
答案：3181
本质不同，计算他的y=kx+b中的k和b的值，然后排一下重即可
#include<bits/stdc++.h>
using namespace std;
typedef pair<double,double> pdd;
set<pdd> m;//存斜率k和截距b
const int N=30;
pdd point[N*N];
#define x first
#define y second
int main(){
int cnt=0;
for(int i=0;i<20;i++){
for(int j=0;j<21;j++){
point[cnt].x=i;
point[cnt].y=j;
cnt++;
}
}
int ans=20+21;
for(int i=0;i<cnt;i++){
for(int j=0;j<cnt;j++){
if(point[i].x==point[j].x||point[i].y==point[j].y)
continue;
double k=(point[j].y-point[i].y)/(point[j].x-point[i].x);
double b=(point[j].x*point[i].y-point[j].y*point[i].x)/(point[j].x-point[i].x);
m.insert({k,b});
}
}
for(auto it=m.begin();it!=m.end();it++)
ans++;
cout<<ans<<endl;
}
//40257
答案：40257
纯暴力法
#include<iostream>
using namespace std;
typedef long long ll;
int main(){
ll n=2021041820210418,res=0;
for(ll i=1;i*i*i<=n;i++)
if(n%i==0)
for(ll j=i;i*j*j<=n;j++)
if(n/i%j==0){
ll k=n/i/j;
if(i==j&&i==k)res++;
else if(i==j||j==k||i==k)res+=3;
else res+=6;
}
cout<<res;
}
分解一下n的所有因数然后排序，最后组合所有数判断是否能组成n即可
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
vector<ll> m;
int main(){
ll n=2021041820210418,res=0;
for(ll i=1;i<=n/i;i++)
if(n%i==0){
ll t=n/i;
m.push_back(i);
if(t!=i)m.push_back(t);
}
for(int i=0;i<m.size();i++)
for(int j=0;j<m.size();j++)
if(n/m[i]%m[j]==0)
res++;
cout<<res<<endl;
res=0;
for(ll i:m)
for(ll j:m)
for(ll k:m)
if(i*j*k==n)
res++;
cout<<res;
}
//2430
答案：2430
很简单的最短路，最多8e8的数据量，暴力一下就好了
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=3000;
typedef long long ll;
ll lu[N][N];
ll _gcd(ll a,ll b){
return b==0?a:_gcd(b,a%b);
}
int main(){
memset(lu,0x3f3f3f3f,sizeof(lu));
for(ll i=1;i<=2021;i++)
for(ll j=i+1;j<=i+21;j++)
lu[i][j]=lu[j][i]=i*j/_gcd(i,j);
for(int i=1;i<=2021;i++)
for(int j=i+1;j<=2021;j++)
for(int k=i+1;k<j;k++)
lu[i][j]=min(lu[i][j],lu[i][k]+lu[k][j]);
cout<<lu[1][2021];
}
//10266837
答案：10266837
注意几点，补前导0，这里还要开到整形的long long不然会爆，我考的时候没看到，还测试了一下会不会超过1e18如果超过可以开__int128_t或者手写高精度
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long ll;
int main(){
ll cnt;
cin>>cnt;
cnt/=1000;
cnt%=86400;
printf("%02d:%02d:%02d",cnt/3600,cnt/60%60,cnt%60);
return 0;
}
这题我们要判断可以得到的数，如果暴力配对太麻烦了，所以我们采用背包来压缩状态，注意他一个砝码只能用一次又要前后都同时改变，所以得开二维数组不相互影响，但是空间给的不够全开，所以我们用二维的滚动数组优化一下即可
#include<iostream>
using namespace std;
#define io ios::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
const int M=1e6+7;
typedef long long ll;
bool dp[2][M];
int main(){
io;
int n,t,sum=0,res=0;
cin>>n;
for(int i=1;i<=n;i++){
cin>>t;
sum+=t;
for(int j=1;j<=sum;j++){
if(j<=t)
dp[i&1][j]=dp[!(i&1)][j+t]||dp[!(i&1)][j]||dp[!(i&1)][t-j];
else
dp[i&1][j]=dp[!(i&1)][j+t]||dp[!(i&1)][j-t]||dp[!(i&1)][j];
dp[i&1][t]=1;
}
}
for(int i=1;i<=sum;i++)
if(dp[n&1][i]){
res++;
}
cout<<res;
return 0;
}
使用压位高精来代表集合类进行dp
#include<bits/stdc++.h>
using namespace std;
const int N=1e2+7,M=1e5+7;
bitset<M> S;//压位高精
int s[N];
int main(){
int n;
cin>>n;
for(int i=0;i<n;i++)
cin>>s[i];
S[0]=1;
for(int i=0;i<n;i++)
S|=S<<s[i];//先对组成的合进行合并，在对差值进行合并
for(int i=0;i<n;i++)
S|=S>>s[i];
cout<<S.count()-1;//减去0
}
这题有几个槽点，数据比较离谱，而且好像没啥规律，有想过二分但是最后得不出来最后答案所以暴力加剪枝出来了，时间复杂度sqrt(n)用滚动数据可以不用开额外空间
#include<iostream>
using namespace std;
#define endl "\n"
typedef long long ll;
int main(){
ll n,res=1;
cin>>n;
for(int i=1;;i++){
ll j,cnt=1,flag=0;
if((i*(i-1))/2>n){res=n*(n+1)/2+2;break;}
if(cnt==n)break;
for(j=0;j<=(i+1)/2;j++){
if(cnt>n)break;
else if(cnt==n){res+=j+1;flag=1;break;}
cnt=cnt*(i-j)/(j+1);
}
if(flag)
break;
else
res+=i+1;
}
cout<<res;
return 0;
}
这道题用普通的快排可以过20%的数据，使用桶排序可以过60%的样例，然后通过对桶排的剪枝，最终可以达到时间复杂度最多nlogn的复杂度。
#include<iostream>
#include<algorithm>
using namespace std;
typedef pair<int,int>PII;
const int N=1e5+7;
PII stk[N];//栈记录有效操作
int s[N],top;//最后的数组，top为栈的头指针
int main(){
int n,m;
cin>>n>>m;
while(m--){//m次操作
int q,p;
cin>>q>>p;
if(!q){
while(top && stk[top].first==0)p=max(p,stk[top--].second);//对于重复降序，我们只需要保持最长值
while(top>=2 && stk[top-1].second<=p)top-=2;//维持交错的单调性
stk[++top]={0,p};
}
else if(top){
while(top && stk[top].first==1)p=min(p,stk[top--].second);
while(top>=2 && stk[top-1].second >=p)top-=2;
stk[++top]={1,p};
}
}
int l=1,r=n,k=n;
for(int i=1;i<=top;i++)//读取栈
if(stk[i].first)//读取他的正逆序
while(l<stk[i].second && l<r)s[l++]=k--;
else
while(r>stk[i].second && l<r)s[r--]=k--;
//最后补充未填充的数
if(top%2)//若有余数则为降序
while(l<=r)s[l++]=k--;
else
while(l<=r)s[r--]=k--;
for(int i=1;i<=n;i++)
cout<<s[i]<<" ";
}
#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
const int N=5e3+7;
typedef long long ll;
int n;
string s;
ll dp[N][N];
ll cale(){
memset(dp,0,sizeof dp);
dp[0][0]=1;
for(int i=1;i<=n;i++)
if(s[i-1]=='(')
for(int j=1;j<=n;j++)
dp[i][j]=dp[i-1][j-1];
else{
dp[i][0]=(dp[i-1][0]+dp[i-1][1])%mod;
for(int j=1;j<=n;j++)
dp[i][j]=(dp[i-1][j+1]+dp[i][j-1])%mod;
}
for(int i=0;i<=n;i++)
if(dp[n][i])
return dp[n][i];
return -1;
}
int main(){
cin>>s;
n=s.length();
ll l=cale();
reverse(s.begin(),s.end());
for(int i=0;i<n;i++)
if(s[i]=='(')s[i]=')';
else s[i]='(';
ll r=cale();
cout<<l*r%mod;
}
总结：这次蓝桥杯非常有趣，虽然大家都说傻逼，但是还是非常锻炼思维的，蓝桥杯这样发展下去就可以脱离暴力杯的业界口碑了，需要继续努力。我们也要从蓝桥杯逐渐成为acmer。加油加油加油。
扫一扫
2161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
