十四届蓝桥青少C++组2022年8月评测中高级

最新推荐文章于 2024-12-06 08:00:00 发布

原创最新推荐文章于 2024-12-06 08:00:00 发布 · 925 阅读

12 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#c++ #算法 #数据结构

c++蓝桥杯专栏收录该内容

11 篇文章

订阅专栏

编程题

第一题（难度系数2，18 个计分点）

题目编号：LQQS22082101CB01 知识点：算数运算符字符串

编程实现：个位数

题目描述：

给定一个正整数N（10<N<1000），输出正整数个位上的数字。

输入描述：输入一个正整数N（10<N<1000）

输出描述：输出正整数N个位上的数字

样例输入：123

样例输出：3

评分标准：

6分：能正确输出一组数据；

6分：能正确输出两组数据；

6分：能正确输出三组数据。

测试用例：

输入

555

210

542

输出

解析：基础题，详见代码：

#include <iostream>
using namespace std;
int n;
int main()
{
    cin >> n;
    cout << n % 10;
    return 0;
}

第二题（难度系数 3，20 个计分点）

题目编号：LQQS22082101CB02 知识点：判断算数运算符逻辑运算符

编程实现：判断数字

题目描述：

给定一个正整数N（100≤N＜100000），统计出100到N（包含100和N）之间的正整数中，有多少个正整数满足以下条件：

1）正整数个位数不为3；

2）正整数十位数不为5；

3）正整数百位数不为7。

输入描述：输入一个正整数N（100≤N＜100000）

输出描述：输出100到N（包含100和N）之间有多少个正整数满足条件

样例输入：110

样例输出：10

评分标准：

6分：能正确输出一组数据；

6分：能正确输出两组数据；

8分：能正确输出三组数据。

测试用例：

输入

310

600

999

输出

172

406

648

解析：循环判断，计数，详见代码：

#include <iostream>
using namespace std;
int n, cnt = 0;
int main()
{
    cin >> n;
    for (int i = 100; i <= n; i++)
        if (i % 10 != 3 && i / 10 % 10 != 5 && i / 100 != 7)
            cnt++;
    cout << cnt;
    return 0;
}

第三题（难度系数 3，25 个计分点）

题目编号：LQQS22082101CB03 知识点：字符串判断循环比较运算符

编程实现：去重

提示信息：

字典序大小，是指字符串中字母在字母表中的先后顺序，即字母表中越靠前的字母，字典序越小。

例如：两个字符串acd和cad，两个字符串的第一个字母分别为"a"和"c"，其中"a"在字母表中排在"c"的前边，故字符串acd字典序小与字符串cad。假如第一个字母相同，就比较第二个字母，以此类推。

题目描述：

给定一个长度小于200的字符串S，且字符串中只包含小写字母，然后按照以下要求对字符串S进行去重，并输出去重后的字符串。

要求：

1)如果有重复出现的字母，只保留1个，其他的去掉；

2)不得改变各字母相对位置；

3)保证去重后的字符串的字典序最小。

例如：

S=“cacd”，重复的字母有c，如果去掉第一个字母c，结果为acd；如果去掉第二个字母c结果为cad，比较两个去重后的结果，第一个结果的字典序小于第二个结果的字典序，故选择去掉第一个c，输出acd。

输入描述：输入一个长度小于200的字符串S，且字符串中只包含小写字母

输出描述：按照要求对字符串S进行去重，并输出

样例输入：cdacd

样例输出：acd

评分标准：

6分：能正确输出一组数据；

6分：能正确输出两组数据；

6分：能正确输出三组数据；

7分：能正确输出四组数据。

测试用例：

输入

bcabc

cbacdcbc

poiuyqwertyiuyt

asdfghjwertyuidfghjkert

输出

abc

acdb

poiqwertuy

asdfghjwertyuik

#include <bits/stdc++.h>
using namespace std;
string a, s;
int vis[155];
bool check(int res, char c)
{
  for (int i = res; i < s.size(); i++)
    if (s[i] == c)
      return 1;
  return 0;
}
bool judge(int res)
{
  for (int i = 0; i < 26; i++)
    if (i != res)
      if (vis[i] != -1)
        if (!check(vis[res], i + 'a'))
          return 0;
  return 1;
}
int main()
{
  cin >> s;
  while (s.size())
  {
    a = "";
    memset(vis, -1, sizeof vis);
    for (int i = s.size() - 1; i >= 0; i--)
      vis[s[i] - 'a'] = i + 1;
    for (int i = 0; i < 26; i++)
    {
      if (vis[i] != -1)
      {
        if (judge(i))
        {
          cout << char(i + 'a');
          for (int j = vis[i]; j < s.size(); j++)
            if (s[j] != char(i + 'a'))
              a += s[j];
          s = a;
          break;
        }
      }
    }
  }
  return 0;
}

第四题（难度系数4，30个计分点）

题目编号：LQQS22082101CB04 知识点：二维数组判断循环逻辑运算符比较运算符

编程实现：路径最小和

题目描述：

有一个N*M的矩阵方格，每个方格中都有一个正整数，现从左上角方格出发向右下角方格移动，每次只能向下或向右移动一个方格，请你找出一条最小路径，并输出该路径上的正整数之和。

最小路径：这条路径上的正整数之和最小。

例如：

N=2，M=3，2*3的矩阵方格中的正整数如下，

按照移动规则，从左上角方格移动到右下角方格的路径共3条，分别为1->3->5->6，1->3->4->6，1->2->4->6，3条路径上的正整数之和分别为15、14和13，其中正整数之和最小的一条路径是1->2->4->6，和为13，故输出13。

输入描述：

第一行输入两个正整数N和M（2≤N≤100，2≤M≤100），N表示矩阵方格的行数，M表示矩阵方格的列数，两个正整数之间以一个空格隔开

第二行开始输入N行，每行M个正整数（1≤正整数≤200），正整数之间以一个空格隔开

输出描述：

输出一个整数，表示最小路径上的正整数之和

样例输入：

2 3

1 3 5

2 4 6

样例输出：

评分标准：

7分：能正确输出一组数据；

7分：能正确输出两组数据；

8分：能正确输出三组数据；

8分：能正确输出四组数据。

测试用例：

输入

2 3

1 2 3

4 5 6

3 3

1 3 1

1 5 1

4 2 1

4 8

2 7 3 4 1 5 9 6

9 8 7 6 5 4 3 2

3 4 2 1 7 4 5 3

8 7 2 4 1 2 6 3

6 9

9 8 7 6 5 4 3 2 1

1 3 1 6 5 4 3 2 6

1 6 5 4 3 2 2 6 9

2 4 47 2 4 1 2 6 1

2 5 2 7 2 4 1 2 6

5 8 2 7 3 4 5 9 4

10 15

3 4 1 7 4 5 2 8 7 2 4 23 12 12 34

13 41 11 71 14 15 12 81 17 12 14 23 12 12 34

32 42 21 27 42 5 22 8 27 2 4 23 12 12 34

13 4 1 37 4 35 32 8 7 23 4 13 7 43 53

53 45 22 14 72 44 52 39 29 58 28 78 22 42 18

12 6 3 22 51 2 71 2 4 13 2 56 5 22 8

58 37 46 25 14 73 42 51 30 22 71 34 13 23 62

12 25 21 9 8 77 26 57 4 63 12 71 21 27 62

17 6 52 4 23 2 22 6 9 22 5 2 77 21 24

22 52 12 47 52 64 11 76 5 74 53 24 24 61 29

输出

247

#include <bits/stdc++.h>
using namespace std;
int n, m, a[105][105], dp[105][105];
int main() {
    memset(dp, 0x3f, sizeof dp);
    cin >> n >> m;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            cin >> a[i][j];
    dp[1][1] = a[1][1];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + a[i][j];
    cout << dp[n][m];
    return 0;
}

第五题（难度系数 5，35 个计分点）

题目编号：LQQS22082101CB05 知识点：二维数组判断循环比较运算符算法内置函数

编程实现：操作字符串

题目描述：

给定两个字符串S1和S2（1<S1长度<100，1<S2长度<100），然后按照以下三种操作，将S1转为S2，问最少操作几次可以完成。

可对字符串进行三种操作：

插入一个字符；
删除一个字符；
修改一个字符。

例如：

S1=abcd，S2=ebde，S1转为S2最少需要操作3次，

第一次操作：将abcd中的字符a修改成e,修改后为ebcd;

第二次操作：将ebcd中的字符c删除,删除后为ebd;

第三次操作：在ebd末端插入字符e,插入后为ebde，

经过3次操作，字符串abcd转为字符串ebde。

输入描述：

第一行输入一个字符串S1（1<S1长度<100）

第二行输入一个字符串S2（1<S2长度<100）

输出描述：

输出一个整数，表示将S1转为S2的最少操作次数

样例输入：

abcd

ebde

样例输出：

评分标准：

7分：能正确输出一组数据；

7分：能正确输出两组数据；

7分：能正确输出三组数据；

7分：能正确输出四组数据；

7分：能正确输出五组数据。

测试用例：

输入

nowcoder

new

intention

execution

now

nowcoder

fgjgdwekgcfr

yfyyiouu

qwertyuiasdfghjghjkdfgrghjk

sfdghjwertyuisdfghjjsdfgh

输出

#include <bits/stdc++.h>
using namespace std;
string a, b;
int dp[105][105];
int main() {
    memset(dp, 0x3f, sizeof dp);
    cin >> a >> b;
    dp[0][0] = 0;
    for (int i = 1; i <= a.size(); i++)
        dp[i][0] = i;
    for (int i = 1; i <= b.size(); i++)
        dp[0][i] = i;
    for (int i = 1; i <= a.size(); i++)
        for (int j = 1; j <= b.size(); j++) {
            if (a[i - 1] == b[j - 1])
                dp[i][j] = dp[i - 1][j - 1];
            else
                dp[i][j] = min({dp[i - 1][j - 1], dp[i][j - 1], dp[i - 1][j]}) + 1;
        }
    cout << dp[a.size()][b.size()];
    return 0;
}