小记
时隔太久，只觉得赛时怎么想出题的过程，但是代码不是很记得了，部分代码用的是2021年第十二届蓝桥杯省赛C/C++B组题解总结_weiambt的博客-CSDN博客_蓝桥杯2021省赛 这位博主的
做题情况
| 题号 | 题目类型 | 难度 | 本人考场情况 |
|---|---|---|---|
| A | 基础知识 | 签到 | 蒙（知识忘记了） |
| B | 模拟题 | 签到 | ok |
| C | 难 | 跳 | |
| D | 素数分解+排列组合 | 中档 | ok |
| E | 最短路算法模板题 | 中档 | 跳（算法忘记怎么写了） |
| F | 模拟题 | 签到 | ok |
| G | 动态规划 | 中档 | ok |
| H | 难 | no（暴力） | |
| I | 难 | no（暴力） | |
| J | 难 | no（特例骗分） |
也就是2个填空+2个大题确定，其余蒙看命，最终山东省省一，而且记得是在第3页还是第2页的省一，排名不差。
A题
析：
B是Byte的缩写，B就是Byte，也就是字节（Byte）；b是bit的缩写，b就是bit，也就是比特位（bit）。
B与b不同，注意区分，KB是千字节，Kb是千比特位。
1MB（兆字节） = 1024KB（千字节）= 1024*1024B(字节)
8bit（比特位）= 1Byte（字节）；
解：
256MB=1024*1024B
32bit（位)=4B
ans=256*1024*1024/4
#include <iostream>
#include "bits/stdc++.h"
#include "cstdio"
typedef long long int ll ;
using namespace std;
int main() {
cout<<256*1024*1024/4<<endl; //67108864
return 0;
}
B题
析：
这是个签到题，只要按题编程即可
#include <iostream>
#include "bits/stdc++.h"
#include "cstdio"
typedef long long int ll ;
using namespace std;
int number[10]; //表示代表0-9的卡片已经用了几张
bool check(int a)
{
while (a)
{
int b=a%10;
if(number[b]<2021)number[b]++;
else return 0;
a/=10;
}
return 1;
}
int main() {
memset(number,0,sizeof(number));
int ans=0;
while (1)
{
if(check(ans+1))++ans;
else break;
}
cout<<ans<<endl;
return 0;
}
C题
考场上看到这题的时候，知道这个应该是要分析之后找规律，或者用数学公式，就跳过了。
D题
这题其实很像紫书里的一道dfs搜索题目，很容易想歪，用递归做，而用递归暴力搜索做会超时。
我那时想到像这种有关数字的题目，可以测试一些它的参数，作为寻找方法的线索。
而这里其实是求约数，那就先把组成n的所有质数求出来，
跑出来发现 2021041820210418 = 2 ∗ 3 3 ∗ 17 ∗ 131 ∗ 2857 ∗ 5882353 2021041820210418=2*3^3*17*131*2857*5882353 2021041820210418=2∗33∗17∗131∗2857∗5882353
那么这时就把6种数字类型，9个数据放进3个篮子的问题
当3个3被分别放入3个篮子时，即 3 5 3^5 35 种
当3个3被拆成 2个3和1个3放入3个篮子时，即 3 5 ∗ C 3 2 ∗ 2 = 3 5 ∗ 6 3^5*C_3^2*2=3^5*6 35∗C32∗2=35∗6
当3个3被一起放入一个篮子时，即 3 5 ∗ 3 3^5*3 35∗3
故而答案是 3 5 ∗ ( 1 + 6 + 3 ) = 2430 3^5*(1+6+3)=2430 35∗(1+6+3)=2430
#include <iostream>
#include "bits/stdc++.h"
#include "cstdio"
typedef long long int ll ;
using namespace std;
int prime[40][2];
int check_prime(ll n)
{
int a=2;
int cnt=0,number=0;
while (a<=n)
{
if(n%a==0)
{
++cnt;
prime[cnt][0]=a;
prime[cnt][1]=0;
while (n%a==0)
{
n/=a;
prime[cnt][1]++;
number++;
}
}
++a;
}
//打印出分解出的质数，及其个数
for(int i=1;i<=cnt;++i) {
printf("%d:%d %d\n", i, prime[i][0], prime[i][1]);
}
}
int main()
{
//分解出质数
ll n=2021041820210418;
check_prime(n);
//计算答案
ll ans=1;
for(int i=1;i<=5;++i)ans*=3;
ans*=10;
cout<<ans<<endl;
}
E题
【样例输入】
6
【样例输出】
13
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ N ≤ 10；
对于所有评测用例，1 ≤ N ≤ 1000000000。
求单源到其他点的最短距离，且没有负边，那就可直接用dijkstar
（可见若真考算法，也是模板入门的难度）
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
const int N=2510;
int g[N][N],dist[N],st[N];
int n=2021;
int gcd(int a, int b)
{
return b ? gcd(b, a % b) : a;
}
int lcm(int a,int b){
return a*b/gcd(a,b);
}
int dijkstra(){
memset(dist,0x3f,sizeof dist);
dist[1]=0;
for(int i=1;i<=n;i++){
int t=-1;
for(int j=1;j<=n;j++){
if(!st[j] && (t==-1 || dist[j]<dist[t]))
t=j;
}
st[t]=1;
for(int j=1;j<=n;j++){
dist[j]=min(dist[j],dist[t]+g[t][j]);
}
}
return dist[n];
}
int main(){
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++){
if(i!=j){
if(fabs(i-j)<=21){
g[i][j]=lcm(i,j);
g[j][i]=lcm(i,j);
}
else{
g[i][j]=0x3f3f3f3f;
g[j][i]=0x3f3f3f3f;
}
}
}
cout<<dijkstra();//10266837
return 0;
}
F题 时间显示
【样例输入 1】
46800999
【样例输出 1】
13:00:00
【样例输入 2】
1618708103123
【样例输出 2】
01:08:23
【评测用例规模与约定】
对于所有评测用例，给定的时间为不超过 1018 的正整数。
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long LL;
int main()
{
LL n;
cin>>n;
n/=1000;
int h=n/3600%24;
n=n%3600;
int m=n/60%60;
n=n%60;
int s=n%60;
printf("%02d:%02d:%02d",h,m,s);
return 0;
}
G题 砝码称重
【样例输入】
3
1 4 6
【样例输出】
10
【样例说明】
能称出的 10 种重量是：1、2、3、4、5、6、7、9、10、11。
1 = 1；
2 = 6 6 4 (天平一边放 6，另一边放 4)；
3 = 4 1；
4 = 4；
5 = 6 1；
6 = 6；
7 = 1 + 6；
9 = 4 + 6 1；
10 = 4 + 6；
11 = 1 + 4 + 6。【评测用例规模与约定】
对于 50% 的评测用例，1 ≤ N ≤ 15。
对于所有评测用例，1 ≤ N ≤ 100，N 个砝码总重不超过 100000。
考场时咋一看是dp，慌了，但是后面的题更不会了，于是再想想发现这是个简单dp，就做出来了。
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 110, M = 2e5 + 10;
int n,m;//m记录最大重量
int a[N];
bool dp[N][M];//dp[i][j]表示前i个砝码，称出j的集合，值为bool值，能称出j就true
//砝码称重
int main()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i],m+=a[i];
dp[0][0]=true;
for (int i = 1; i <= n;i++)//前i个
for (int j = 0; j <=m;j++)//称出j
dp[i][j]=dp[i-1][j]||dp[i-1][j+a[i]]||dp[i-1][abs(j-a[i])];
//只要有一种情况为真，那么dp[i][j]就真
int ans=0;
for(int i=1;i<=m;i++)
if(dp[n][i])
ans++;
cout<<ans;
return 0;
}
H题 杨辉三角形
【样例输入】
6
【样例输出】
13
【评测用例规模与约定】
对于 20% 的评测用例，1 ≤ N ≤ 10；
对于所有评测用例，1 ≤ N ≤ 1000000000。
这个题没办法，数太大了，故只能暴力，算出前几个样例就算几个吧。
// 二项式定理，对于C(3，n)，当n等于2000时，C(3，2000)＞1e9
// 因此只需要算到第2000行就好了，剩下的再算C(1，n)和C(2，n)就好了。
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int a[2005][2005];
int main(){
ll N;
cin>>N;
memset(a,0,sizeof(a));
a[0][0]=1;
for(int i=1;i<2005;i++){
for(int j=1;j<=i;j++){
a[i][j]=a[i-1][j]+a[i-1][j-1];
if(a[i][j]==N){
cout<<i*(i-1)/2+j<<endl;
return 0;
}
}
}
//如果上面的没找到，说明只有C(1,n)和C(2,n)满足了
//n*(n-1)/2==N
ll n=sqrt(N*2)+1;
if(n*(n-1)/2==N){
//C(2,n)
cout<<n*(n+1)/2+3<<endl;
}else{
//C(1,n)
cout<<N*(N+1)/2+2<<endl;
}
}
I题
【评测用例规模与约定】
对于 30% 的评测用例，n, m ≤ 1000；
对于 60% 的评测用例，n, m ≤ 5000；
对于所有评测用例，1 ≤ n, m ≤ 100000，0 ≤ ai ≤ 1，1 ≤ bi ≤ n。
这个是倒数第2题了，时间我那时也剩不多，就用最朴素的方法做了，能过几个样例看命了。
#include<iostream>
#include<algorithm>
using namespace std;
int a[101000];
int main()
{
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++)a[i]=i;
while(m--){
int p,q;
cin>>p>>q;
if(p==0){
sort(a+1,a+q+1,greater<int>());
}else{
sort(a+q,a+n+1);
}
}
for(int i=1;i<=n;i++) cout<<a[i]<<" ";
return 0;
}
J题
【样例输入】
((()
【样例输出】
5
【评测用例规模与约定】
对于 40% 的评测用例，|s| ≤ 200。
对于所有评测用例，1 ≤ |s| ≤ 5000。
没时间了，一看就麻烦，“if” 样例骗分！
#include "bits/stdc++.h"
using namespace std;
int main()
{
string ss;
cin>>ss;
if(ss=="((()")cout<<5<<endl;
}
1819
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
