第十二届蓝桥杯一月校内模拟赛题解

最新推荐文章于 2023-12-02 21:32:31 发布

幸愉信奥

最新推荐文章于 2023-12-02 21:32:31 发布

阅读量4.4k

点赞数 13

分类专栏：蓝桥杯文章标签：蓝桥杯

本文链接：https://blog.csdn.net/Edviv/article/details/112429831

版权

蓝桥杯专栏收录该内容

16 篇文章 1 订阅

订阅专栏

文章目录

引言
填空题
编程题

引言

本蒟蒻实力有限，可能有些代码是错误，希望多多包涵，欢迎指出。喜欢本篇文章请一键三连，谢谢~

填空题

请问在 1 到 2020 中，有多少个数既是 4 的整数倍，又是 6 的整数倍

#include <iostream>
using namespace std;
int main()
{
    int ans = 0;
    for(int i = 1; i <= 2020; ++i)
        if(i%4 == 0 && i %6 == 0) ans++;
    cout<<ans<<endl;
    return 0;
}

My Answer:

小明要用二进制来表示 1 到 10000 的所有整数，要求不同的整数用不同的
二进制数表示，请问，为了表示 1 到 10000 的所有整数，至少需要多少个
二进制位？

#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
    int temp = 0;
    string s;
    int ans = 0;
    for(int i = 1; i <= 10000; i++)
    {
        s.clear();
        int t = i;
        while(t>0)
        {
            int yu = t%2;
            t /= 2;
            s = s + (char)(yu + '0');
        }
        //cout<<s.size()<<endl;
        ans += s.size();
        int x = s.size();
        temp = max(temp,x);
    }
    cout<<temp<<endl;
    cout<<ans<<endl;
    return 0;
}

My Answer:

请问有多少个序列满足下面的条件：
1. 序列的长度为 5。
2. 序列中的每个数都是 1 到 10 之间的整数。
3. 序列中后面的数大于等于前面的数。

#include <iostream>
#include <cstring>
using namespace std;
int a[6];
int main()
{
    int ans = 0;
    for(int i = 10000; i <= 99999; ++i)
    {
        memset(a, 0, sizeof a);
        int t = i, idx = 0;
        while(t>0)
        {
            a[idx++] = t%10;
            t /= 10;
        }
        int ok = 1;
        for(int j = 0; j < idx-1; j++)
            if(a[j] < a[j+1] || a[j] <= 1) ok = 0;
        if(ok) ans++;
    }
    cout<<ans<<endl;
    return 0;
}

My Answer:

一个无向图包含 2020 条边，如果图中没有自环和重边，请问最少包含多
少个结点？

My Answer:

两个字母之间的距离定义为它们在字母表中位置的距离。例如 A 和 C 的
距离为2，L 和 Q 的距离为 5。对于一个字符串，我们称字符串中两两字
符之间的距离之和为字符串的内部距离。例如：ZOO 的内部距离为 22，其
中 Z 和 O 的距离为 11。请问，LANQIAO 的内部距离是多少？

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    int ans = 0;
    string s = "LANQIAO";
    for(int i = 0; i < s.size(); i++)
        for(int j = i + 1; j < s.size(); j++)
        {
         //   if(s[j] > s[i]) cout<<s[j]<<" - " <<s[i]<< " = "<<s[j]-s[i]<<endl;
          //  else cout<<s[i]<<" - " <<s[j]<< " = "<<s[i]-s[j ]<<endl;
            if(s[j] < s[i]) ans = ans + (int)(s[i] - s[j]);
            else  ans = ans + (int)(s[j] - s[i]);
        }
    cout<<ans<<endl;
    return 0;
}

My Answer:

编程题

题目描述
给定一个平行四边形的底边长度 $l$ 和高度 $h$ ，求平行四边形的面积。
输入格式
输入的第一行包含一个整数 $l$ ，表示平行四边形的底边长度。
第二行包含一个整数 $h$ ，表示平行四边形的高。
输出格式
输出一个整数，表示平行四边形的面积。（提示：底边长度和高都是整数的平行四边形面积为整数）
样例输入

2
7

样例输出

数据规模和约定
对于所有评测用例： $\leq l, h \leq 100$

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    int l,h;
    cin>>l>>h;
    int ans = l*h;
    cout<<ans<<endl;
    return 0;
}

题目描述
现在时间是 $a$ 点 $b$ 分，请问 $t$ 分钟后，是几点几分？
输入格式
输入的第一行包含一个整数 $a$ 。
第二行包含一个整数 $b$ 。
第三行包含一个整数 $t$ 。
输出格式
输出第一行包含一个整数，表示结果是几点。
第二行包含一个整数，表示结果是几分。
样例输入

3
20
165

样例说明

6
5

数据规模和约定
对于所有评测用例： $\leq a \leq 23, 0 \leq b \leq 59, 0 \leq t, t$ 分钟后还是在当天。

#include <iostream>
#include <cstring>
#include <string>
using namespace std;
int main()
{
    int a,b,t;
    cin>>a>>b>>t;
    int yu = (b+t)%60;
    int s = (b+t)/60;
    cout<<(a+s)<<endl;
    cout<<yu<<endl;
    return 0;
}

题目描述
小蓝负责花园的灌溉工作。
花园可以看成一个 $n$ 行 $m$ 列的方格图形。中间有一部分位置上安装有出水管。
小蓝可以控制一个按钮同时打开所有的出水管，打开时，有出水管的位置可以被认为已经灌溉好。
每经过一分钟，水就会向四面扩展一个方格，被扩展到的方格可以被认为已经灌溉好。即如果前一分钟某一个方格被灌溉好，则下一分钟它上下左右的四个方格也被灌溉好。
给定花园水管的位置，请问 $k$ 分钟后，有多少个方格被灌溉好？
输入格式
输入的第一行包含两个整数 $n$ , $m$ 。
第二行包含一个整数 $t$ ，表示出水管的数量。
接下来 $t$ 行描述出水管的位置，其中第 $i$ 行包含两个数 $r, c$ 表示第 $r$ 行第 $c$ 列有一个排水管。
接下来一行包含一个整数 $k$ 。
输出格式
输出一个整数，表示答案。
样例输入

样例输出

样例说明
用1表示灌溉到，0表示未灌溉到。
打开水管时：
　　000000
　　010000
　　000100
1分钟后：
　　010000
　　111100
　　011110
　　共有9个方格被灌溉好。
数据规模和约定 　
对于所有评测用例： $\leq n, m \leq 100, 1 \leq t \leq 10, 1 \leq k \leq 100$ 。
将最初水龙头的位置标记，存入队列，再用一个队列存储下一分钟蔓延的位置，每分钟结束，更新队列中的元素，最后输出在规定时间内灌溉的位置有多少个即可。

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
using namespace std;
char mp[110][110];
int vis[110][110];
int dir[4][2] = {0,1,-1,0,0,-1,1,0};
struct node{
    int x,y;
    char ch;
};
node a[110];
bool inbound(int x, int l, int r)
{
    if(x < l || x > r) return false;
    return true;
}

int main()
{
    int n,m,t;
    cin>>n>>m>>t;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) vis[i][j] = 0, mp[i][j] = '0';
    queue<node> q;
    for(int i = 0; i < t; i++)
    {
        int x,y;
        cin>>x>>y;
        mp[x][y] = '1';
        vis[x][y] = 1;
        a[i] = {x,y,'1'};
        q.push(a[i]);
    }
    int ans = t, k = 0;
    cin>>k;
    int time = 0;
    queue<node> p;
    while(!q.empty())
    {
        node now = q.front();
        q.pop();
        int x = now.x, y = now.y;
        char ch = now.ch;
        for(int i = 0; i < 4; i++)
        {
            int tx = x + dir[i][0];
            int ty = y + dir[i][1];
            if(!inbound(tx,1,n) || !inbound(ty,1,m)) continue;
            if(!vis[tx][ty] && mp[tx][ty] == '0')
            {
                ans++;
                node temp = {tx,ty,'1'};
                mp[tx][ty] = '1';
                p.push(temp);
            }
        }
        if(q.empty())
        {
            time++;
            while(!p.empty())
            {
                node s = p.front();
                p.pop();
                q.push(s);
            }
        }
        if(time >= k) break;
    }
    cout<<ans<<endl;
    /***
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cout<<mp[i][j]<<" ";
        }
        cout<<'\n';
    }
    ***/
    return 0;
}

题目描述
小蓝有一张黑白图像，由 $n * m$ 个像素组成，其中从上到下共 $n$ 行，每行从左到右 $m$ 列。每个像素由一个 0 到 255 之间的灰度值表示。
现在，小蓝准备对图像进行模糊操作，操作的方法为：
对于每个像素，将以它为中心 3 * 3 区域内的所有像素（可能是 9 个像素或少于 9 个像素）求和后除以这个范围内的像素个数（取下整），得到的值就是模糊后的结果。
请注意每个像素都要用原图中的灰度值计算求和。
输入格式
输入的第一行包含两个整数 $n, m$ 。
第 2 行到第 $n + 1$ 行每行包含 $m$ 个整数，表示每个像素的灰度值，相邻整数之间用一个空格分隔。
输出格式
输出 $n$ 行，每行 $m$ 个整数，相邻整数之间用空格分隔，表示模糊后的图像。
样例输入

3 4
0 0 0 255
0 0 255 0
0 30 255 255

样例输出

0 42 85 127
5 60 116 170
7 90 132 191

数据规模和约定
对于所有评测用例， $\leq n, m \leq 100$ 。
扩展有8个方向扩展，然后以当前这个点为中心向 8 个方向扩展即可，最后按照题意求模糊值。

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
using namespace std;
int vis[110][110];
int dir[8][2] = {0,1,-1,1,-1,0,-1,-1,0,-1,1,-1,1,0,1,1};
int mp[110][110];
int ans[110][110];
bool inbound(int x, int l, int r)
{
    if(x < l || x > r) return false;
    return true;
}

int main()
{
    int n,m;
    cin>>n>>m;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) cin>>mp[i][j];

    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            int t = mp[i][j], cnt = 1;
            for(int k = 0; k < 8; k++)
            {
                int tx = i + dir[k][0];
                int ty = j + dir[k][1];
                if(!inbound(tx,1,n) || !inbound(ty,1,m)) continue;
                t += mp[tx][ty];
                cnt++;
            }
            ans[i][j] = (int)(t/cnt);
        }
    }
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
            if(j == 1) cout<<ans[i][j];
            else cout<<" "<<ans[i][j];
        cout<<'\n';
    }

    return 0;
}

题目描述
小蓝在一个 $n$ 行 $m$ 列的方格图中玩一个游戏。
开始时，小蓝站在方格图的左上角，即第 1 行第 1 列。
小蓝可以在方格图上走动，走动时，如果当前在第 $r$ 行第 $c$ 列，他不能走到行号比 $r$ 小的行，也不能走到列号比 $c$ 小的列。同时，他一步走的直线距离不超过3。
例如，如果当前小蓝在第 3 行第 5 列，他下一步可以走到第 3 行第 6 列、第 3 行第 7 列、第 3 行第 8 列、第 4 行第 5 列、第 4 行第 6 列、第 4 行第 7 列、第 5 行第 5 列、第 5 行第 6 列、第 6 行第 5 列之一。
小蓝最终要走到第 $n$ 行第 $m$ 列。
在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。
小蓝希望，从第 1 行第 1 列走到第 $n$ 行第 $m$ 列后，总的权值和最大。请问最大是多少？
输入格式
输入的第一行包含两个整数 $n, m$ ，表示图的大小。
接下来 $n$ 行，每行 $m$ 个整数，表示方格图中每个点的权值。
输出格式
输出一个整数，表示最大权值和。
样例输入

3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4

样例输出

数据规模和约定
对于30%的评测用例， $\leq n, m \leq 10$ ；
对于50%的评测用例， $\leq n, m \leq 20$ ；
对于所有评测用例， $\leq n \leq 100，-10000 \leq 权值 \leq 10000$

动态规划， $d p [i] [j]$ 表示在第 $i$ 第 $j$ 列，属性表示权值，处理特殊的行和列以及特殊的点，然后其余点的状态转移方程就是在可以扩展来的点选取最大值加。答案就是 $d p [n] [m]$

#include <iostream>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
using namespace std;
int vis[110][110];
int mp[110][110];
int ans[110][110];

int main()
{
    int n,m;
    memset(mp, 0, sizeof mp);
    memset(ans,0,sizeof ans);
    cin>>n>>m;
    for(int i = 1; i <= n; i++)
        for(int j = 1; j <= m; j++) cin>>mp[i][j],ans[i][j] = mp[i][j];

    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            if(i == 1)
            {
                if(j == 1) continue;
                else if(j == 2) ans[i][j] += mp[i][j-1];
                else if(j == 3) ans[i][j] += max(mp[i][j-2],ans[i][j-1]);
                else ans[i][j] +=  max(ans[i][j-1],max(ans[i][j-2],mp[i][j-3]));
            }
            else if(j == 1)
            {
                if(i == 2) ans[i][j] += mp[i-1][j];
                else if(i == 3) ans[i][j] += max(ans[i-1][j],mp[i-2][j]);
                else ans[i][j] += max(ans[i-1][j],max(ans[i-2][j],mp[i-3][j]));
            }
            else if(i == 2 && j == 2)
            {
                ans[i][j] += max(mp[1][1],max(mp[1][2],mp[2][1]));
            }
            else if(i == 2 && j == 3)
            {
                int x = max(mp[1][1],mp[1][2]);
                int y = max(mp[2][1],mp[2][2]);
                ans[i][j] += max(mp[1][3],max(x,y));
            }
            else if(i == 3 && j == 2)
            {
                int x = max(mp[1][1],mp[1][2]);
                int y = max(mp[2][1],mp[2][2]);
                ans[i][j] += max(mp[3][1],max(x,y));
            }
            else
            {
                int x = max(ans[i][j-1],max(ans[i][j-2],ans[i][j-3]));
                int y = max(ans[i-1][j],max(ans[i-2][j],ans[i-3][j]));
                int z = max(ans[i-1][j-1],max(ans[i-2][j-1],ans[i-1][j-2]));
                ans[i][j] += max(x,max(y,z));
            }
        }
    }

    /***
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            cout<<ans[i][j]<<" ";
        }
        cout<<'\n';
    }
    ***/
    cout<<ans[n][m]<<endl;
    return 0;
}