2022 第十三届蓝桥杯大赛软件赛省赛（第二场），C/C++ 大学B组题解

文章目录

• • • 第1题 —— 练习 （5分）
    • 第2题 —— 三角回文数 （5分）
    • 第3题 —— 卡片 （10分）
    • 第4题 —— 考勤刷卡 （10分）
    • 第5题 —— 最大和 （15分）
    • 第6题 —— 染色时间 （15分）
    • 第7题 —— k 倍区间 （20分）
    • 第8题 —— 选素数 （20分）
    • 第9题 —— 第几小 （25分）
    • 第10题 —— 单峰序列 （25分）

补题链接：地址

第1题 —— 练习 （5分）

• 题意：过了样例交上去0分，问可能是ABC的哪一种
• 显然都是，答案：ABC

#include <iostream>
using namespace std;
int main()
{
  // 请在此输入您的代码
  cout<<"ABC";
  return 0;
}

第2题 —— 三角回文数 （5分）

• 题意：求第一个大于某2e8的数的回文数，且满足他可以等于1+2+…某个k。

• 一种是从2e8开始往上枚举，判断每个数是不是回文+三角，三角可以根号再乘附近的几个数特判一下。
  另一种是枚举三角，1+2+…k，判断是不是回文和大于2e8，+k加到后面就是指数级了，上升也很快。

• 答案：35133153

#include<bits/stdc++.h>
using namespace std;

int main(){
    int x = 0;
    for(int i = 1; ; i++){
        x += i;
        if(x <= 20220514)continue;
        string s = to_string(x);
        string t = s;
        reverse(t.begin(),t.end());
        if(s==t)break;
    }
    cout<<x<<"\n";
    return 0;
}

第3题 —— 卡片 （10分）

• 题意：n个人，给每个人随机发两张卡片（可以相同，没有顺序），求至少需要有多少种卡片，才能让n个人拿到的卡片组合都不同。
• 看一下样例，明显C（k,2）>=n，求k。(k-1)k/2>=n，可以跟上一题一样枚举，a[i]=a[i-1]+1递推上去即可。

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n;  cin>>n;
    int i, x = 0;
    for(i = 1; ; i++){
        x += i;
        if(x < n)continue;
        break;
    }
    cout<<i<<"\n";
    return 0;
}

第4题 —— 考勤刷卡 （10分）

• 题意：n（1e4）条考勤记录，按顺序输出每个考勤了的员工的编号。
• 丢到set里输出就行，时间不用管。

#include<bits/stdc++.h>
using namespace std;

int main(){
    int n;  cin>>n;
    set<int>se;
    for(int i = 1; i <= n; i++){
        string t; int id;  cin>>t>>id;
        se.insert(id);
    }
    for(auto x : se){
        cout<<x<<"\n";
    }
    return 0;
}

第5题 —— 最大和 （15分）

• 题意：1-n共n个格子，每个格子有个分数（可能负数），开始站在1，下次可以跳到p+1到p+D(n-p)中的任意格子，D(x)为x的最小质因数，问能获得的最大分是多少。
• 数据范围n是1e4，感觉是个dp，状态到n为止能获得的最大分。 宝物绝对值不超过1e5，暴力转移的时候质因数分解logn（或者根号n直接暴力1e3最小质因数也可以的）， nlogn刚好可以过。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5+10;
int a[maxn], f[maxn];

int isprime(int x){ //判断素数
    for(int i = 2; i*i <= x; i++){
        if(x%i==0)return 0;
    }
    return 1;
}
int find(int x){//找最小质因数
    if(x==0 || x==1)return x;
    for(int i = 2; i*i <= x; i++){
        if(x%i==0 && isprime(i))return i;
    }
}

int main(){
    int n;  cin>>n;
    for(int i = 1; i <= n; i++)cin>>a[i];
    memset(f, 0xc0, sizeof(f));
    f[1] = a[1];
    for(int i = 1; i <= n; i++){
        int x = i+find(n-i);  //最小质因数
        for(int j = i+1; j <= x; j++){
            f[j] = max(f[j], f[i]+a[j]);
        }
    }
    cout<<f[n]<<"\n";
    return 0;
}

第6题 —— 染色时间 （15分）

• 题意：给出nm的棋盘，初始都是白色，每个格子被染色后等aij秒变色，变色后对四周的格子都染色，每个格子只能被染色一次。时刻0对a00染色，求多少时间染完棋盘。
• 感觉暴力bfs遍历就行，加个堆每次取出当前最早变色的格子出来给周围的染一下，然后维护下每个格子有没有都被染过就行。数据范围500可以说是随便怎么写都行了。

#include<bits/stdc++.h>
using namespace std;
const int maxn = 510;
int a[maxn][maxn], vis[maxn][maxn];

struct node{int x, y, time;}; //完成变色的时间
bool operator < (node a, node b){ return a.time > b.time; }
priority_queue<node, vector<node>, less<node> >q;
int dx[] = { 0,0,1,-1 };
int dy[] = { 1,-1,0,0 };

int main(){
    int n, m;  cin>>n>>m;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= m; j++){
            cin>>a[i][j];
        }
    }
    int res = 0;
    q.push((node){1, 1, a[1][1]});
    vis[0][0] = 1;
    while(q.size()){
        node t = q.top();  q.pop();
        res = max(res, t.time);
        for(int i = 0; i < 4; i++){
            int nx = t.x+dx[i], ny = t.y+dy[i];
            if(nx>=1&&nx<=n && ny>=1&&ny<=m && vis[nx][ny]==0){//没染过色
                vis[nx][ny] = 1;
                q.push((node){nx,ny, t.time+a[nx][ny]});
            }
        }
    }
    cout<<res<<"\n";
    return 0;
}

第7题 —— k 倍区间 （20分）

• 题意： 给出一个序列和一个k，求有多少个子区间的区间和是k的整数倍。
• 数据范围1e5，枚举所有区间是做不到了的， nlogn估计往数据结构去想，但是求子区间和无非也就是差分前缀和。
• 考虑前缀和求区间和，a[r]-a[l-1]是k的倍数，那么只要%k余数相同就好了，不难处理出过程中的前缀和值，然后前面有多少个跟当前%k余数相同的值，就是有多少个区间，扫一遍O(n)就行了（当然排序二分也是可以的，复杂度都一样，map查询logn，大家半斤八两）。
• 注意到一个坑点，不能是负整数倍，所以不能简单的累加，每次要遍历一遍%k余数的，要满足前面那个数比当前这个大才行。还有就是1e9的前缀和要开longlong。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
map<int,vector<LL>>mp; //mp[x]: 维护余数为x的前缀和有哪些
LL s[4]; //前缀和, 滚动数组

int main(){
    int n, k;  cin>>n>>k;
    LL ans = 0;
    mp[0].push_back(0); //别忘了
    for(int i = 1; i <= n; i++){
        int x;  cin>>x;
        s[i%2] = s[(i-1+2)%2]+x;
        int r = (s[i%2]%k+k)%k; //%k余数
        int len = mp[r].size();
        for(int j = 0; j < len; j++){
            if(mp[r][j] <= s[i%2])ans++;
        }
        // sort(mp[r].begin(), mp[r].end());
        // ans += upper_bound(mp[r].begin(), mp[r].end(), s[i%2])-mp[r].begin();
        mp[r].push_back(s[i%2]);
    }
    cout<<ans<<"\n";
    return 0;
}

第8题 —— 选素数 （20分）

• 题意：给你两个数，s和t，每回合可以选一个小于s且不是s因数的素数p，然后找到p的倍数中刚好大于s的那个数y，并让s=y，进入下一回合。 求多少回合后s>t。
• 这题官网没有提交链接啊，代码补了对不对也不知道，我就不写了。。。（名正言顺的翘了摸鱼去了）
• 思路方向：
  最大数据询问2e5，st 1e7，明显是个结论题， 可以找找规律。
  20%的数据明显照着模拟就送。
  50%数据500组，5e5，大概是优化下暴力，nlogn的复杂度，素数可以线性筛O(n)筛出来，个数大概是根号n，每次枚举每个素数，然后找倍数O1就够，如果满足条件就进入下一回合了，复杂度n根号n应该是可以拿到50%的。
  或者，emmm，s-1，s-2这种很接近的数里应该有素数吧，并且肯定不是s的因数了，那么就O1过去了？ 结论的话，盲猜跟gcd有点关系，不知道对不对，可以找找规律蛤。

第9题 —— 第几小 （25分）

• 题意：给一个数组，支持单点修改，以及求区间中比a[p]小的数的个数, a[p]在区间内。n是1e5，操作是2e5。
• 思路：首先，感觉暴力扫区间乱搞之类的可以拿40%。。1e5这种明显数据结构，区间操作就线段树。分块之类的应该也可以，一下子没想到线段树怎么维护，主席树第k小值应该可以做，感觉都有点长懒得写了，直接放一个可以过的分块代码

//分块可以AC 20个点的块长， sqrt(n)*5

#include<bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int n;  cin>>n;
    vector<int> a(n+1,0);

    //分块
    int len = sqrt(n)*5; //块长
    int k = (n%len==0)?n/len:n/len+1;//块数
    vector<int> block[k+1]; //本体
    vector<int> belong(n+1,0);
    int blockNum = 0;
    for(int i=1;i<=n;i++){ //分块
        cin>>a[i];
        blockNum=(i-1)/len+1;
        belong[i]=blockNum;
        block[blockNum].push_back(a[i]);
    }
    for(int i=1;i<=k;i++){  //块排序
        sort(block[i].begin(),block[i].end(),less<int>());
    }

    //输入操作
    int m;  cin>>m;
    vector<vector<int>> op(m,vector<int>(4,0));
    for(int i=0;i<m;i++){
        cin>>op[i][0];
        cin>>op[i][1]>>op[i][2];
        if(op[i][0]==2)cin>>op[i][3];
    }
    //执行
    vector<int> res;
    for(int i = 0; i < m; i++){
        int num1=op[i][1], num2=op[i][2], num3=op[i][3];
        if(op[i][0]==1){ //修改
            auto it=lower_bound(block[belong[num1]].begin(),block[belong[num1]].end(),a[num1]);
            block[belong[num1]].erase(it);
            it=lower_bound(block[belong[num1]].begin(),block[belong[num1]].end(),num2);
            if(it==block[belong[num1]].end())block[belong[num1]].push_back(num2);
            else block[belong[num1]].insert(it,num2);
            a[num1] = num2;
        }else{ //查询
            int count = 0, mid = a[num3];
            //先查左右两端分块中满足条件的元组数,因为num1和num2所在的块不一定一整块都参与比较
            for(int j=num1;j<=min(num2,belong[num1]*len);j++){
                if(a[j]<mid)count++;
            }
            if(belong[num1]!=belong[num2]){
                for(int j=(belong[num2]-1)*len+1;j<=num2;j++){
                    if(a[j]<mid)count++;
                }
            }
            //区间查询,用二分法查询每个块中小于a[p]的元素个数
            for(int j=belong[num1]+1;j<=belong[num2]-1;j++){
                count+=lower_bound(block[j].begin(),block[j].end(),a[num3])-block[j].begin();
            }
            res.push_back(count+1);
        }
    }
    for(auto &&num:res)cout<<num<<" ";
    return 0;
}

第10题 —— 单峰序列 （25分）

• 题意：给出n和m，求构造序列满足长度1-n，和为m，且序列存在一个最高峰，左边递增右边递减，nm都是1e5，求可行的构造方案数。
• 显然是个dp，开始不难盲猜状态dp[i][j]为，长为i，总和为j的，满足xx条件的的个数，但是原先那个条件显然不太好转移， 考虑把条件改为严格递增，然后手动选取k点让严格递增的序列在k点左右两边自由组合，那么方案数就是排列组合2^x，可以算得出来。
• 转移就是长度i-1的加个数字过来，或者和为j-i的每个数加个1过来。因为需要包含最小元素1，所以先固定一个1，dp[i-1][j-1-(i-1)]=dp[i-1][j-i]。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mod = 1e9+7;
LL pows(LL a, LL x, LL p){if(x==0)return 1; LL t = pows(a, x>>1,p);if(x%2==0)return t*t%p;return t*t%p*a%p;}

int main(){
    int n, m;  cin>>n>>m;
    int nn = sqrt(2*m)+2;
    while(nn*(nn+1)>2*m)nn--;
    n = min(n, nn);
    //dp
    vector<vector<LL>>f(n+1, vector<LL>(m+1));
    LL res = 1;
    for(int i = 0; i <= m; i++)f[1][i] = 1;
    for(int i = 2; i <= n; i++){
        for(int j = 1; j <= m; j++){
            if(i>=j)continue;
            f[i][j] = (f[i][j-i]+f[i-1][j-i])%mod;
        }
    }
    for(int i = 2; i <= n; i++){
        res = (res+(f[i][m]*pows(2, i-1, mod))%mod)%mod;
    }
    cout<<res<<"\n";
    return 0;
}