2024年全国青少年信息素养大赛国赛PYTHON组(C++做法)

目录

前提

第一题

第二题

第三题

第四题

第五题:

第六题

前提

鄙人是C++学生，所以将PYTHON题做为C++题，还请各位多多海涵！！！
部分芝士来自度娘和其它网站
温馨提示:题目顺序可能不同，请各位仔细浏览!
 

第一题

题目描述
蓝蓝最近学到了一些单词，比如orange(橘子)，apple(苹果)，pear(梨)。他准备用梨的单词来造句。但是注意，单词pear是有单复数的。当有0或者1个梨时，是pear，当有2个或者2个以上的梨时，就是复数pears。蓝蓝准备这样造句子:如果他有1个梨，就输出I have 1 pear,如果他有2个梨，就输出I have 2 pears.请你帮他完成造句。
输入描述 一行，一个非负整数x。
输出描述 一行英文句子。
样例1
输入:
3
输出:
I have 3 pears.

解题思路:
其实也没有什么思路，只是最基础的输入输出程序。 但是有一个注意点，就是当有0或者1个梨时,是pear。

代码如下:

#include <bits/stdc++.h>
using namespace std;
int main() {
	int x;
	cin >> x;
	if (x <= 1) cout << "I have " << x << " pear.";
	else cout << "I have " << x << " pears.";
	return 0;
}

第二题

题目描述
白白很喜欢数学，她自己的口算能力很强,一般的基础运算对她来说已经非常容易了。于是，她自己发明了一种新的计算方式 ~。这个~的计算方式是这样的，A~B，就是取出A和B的所有数字对，进行乘积并求和。例如，45~678=4x6+4x7+4x8+5x6+5x7+5x8=189请你帮助白白完成数学计算。
输入描述
一行两个整数，m和n，用空格隔开。
输出描述
一行一个整数，表示利用新的计算方式的结果。
样例1
输入:
123 45
输出:
54

解题思路:
此题可用给出的计算方式，来编写程序。通过题目给出的例子，可写出这个计算过程。

• 4 和 6 的乘积
• 4 和 7 的乘积
• 4 和 8 的乘积
• 5 和 6 的乘积
• 5 和 7 的乘积
• 5 和 8 的乘积

就此来看，我们可以用双重循环的做法来接此题。(为了省事，m,n可以直接用string)

代码如下:

#include <bits/stdc++.h>
using namespace std;
int main() {
	string ms, ns;
	cin >> ms >> ns;
	vector<int> md, nd;
	for (char c : ms) {
		md.push_back(c - '0');
	}
	for (char c : ns) {
		nd.push_back(c - '0');
	}
	int result = 0;
	for (int md : md) {
		for (int nd : nd) {
			result += md * nd;
		}
	}
	cout << result;
	return 0;
}

第三题

题目描述
输入一个正整数n，输出对应的数字方阵。
输入描述
一行，一个正整数n(2=<n<=30)
输出描述
多行，每一行的数字间用1个空格隔开
样例1
输入:
7
输出:
1 3 6 10 15 21
2 5 9 14 20
4 8 13 19
7 12 18
11 17
16

解题思路:

1. 矩阵的构建：

   • 填充矩阵：我们需要填充一个n*n的矩阵，其中数字按对角线的方式填充。从左上角到右下角的对角线逐渐填入递增的数字。
   • 对角线划分：
     • 第一部分是从矩阵的左上角开始，向下填充所有的对角线。
     • 第二部分是从矩阵的左侧开始，填充剩余的对角线

2. 填充矩阵：

   • 第一部分：填充从矩阵左上角到右下角的对角线。
     • 对于每个对角线，初始位置是(i,0)，然后填充到(0,i)位置。
   • 第二部分：填充从矩阵的左侧到下方的对角线。
     • 对于每个对角线，初始位置是(0,i)，然后填充到(n-i-1,n-1)位置。

温馨提示:鄙人尝试了好几次，最终只能计算整个矩阵，在输出上弄了个巧劲。恳求大佬指点一二!!!

代码如下:

#include <bits/stdc++.h>
using namespace std;
int a[30][30];
int main() {
	int n, k = 1;
	cin >> n;
    //第一部分，对角线从左上角到右下角
	for (int i = 0; i < n; i++) {
		for (int ii = i, j = 0; ii >= 0; ii--, j++) {
			a[ii][j] = k++;
		}
	}
    //第二部分，对角线从矩阵的左侧到下方
	for (int i = 1; i < n; i++) {
		for (int ii = i, j = n - 1; j >= 0 && ii < n; j--, ii++) {
			a[j][ii] = k++;
		}
	}
	for (int i = 0; i < n - 1; i++) {
		for (int j = 0; j < n - i - 1; j++) {
			cout << a[i][j] << " ";
		}
		cout << endl;
	}
	return 0;
}

第四题

题目描述
现在有一列人在排队，小明想从这队人中，找出身高从低到高的人，重新排成一队。在找人的过程中，小明在原队伍从前到后开始选择，不可以回头。在选择过程中，他可以让一个人进入新的队伍。但是每一个进入新队伍的人，必须新队伍中的前一个人高。
例如，一队人的身高分别是 175 172 181 169 173 189,那么小明可以选择172的人进入新队伍,之后选择181的人进入队伍，但是后面的169 173的人都比181的人矮，因此不能进入新队伍。最后小明可以让189的人进入新队伍。那么此时新队伍中有3个人。
小明也可以选择让181的人先进入新队伍，那么最终新队伍就只能有181 189两个人。
现在有一列队伍，请你求出最多能进入新队伍的人数。
输入描述
一行，m个正整数，中间用空格隔开，表示m个人的身高。
输出描述
一行一个数字，表示进入新队伍的最多人数。
样例1
输入:
160 168 171 120 189 173 162 179 186
输出:
6

解题思路
题目要求我们从一队身高不同的人中选择出最多数量的身高递增子序列，这个问题可以使用动态规划或者贪心算法结合二分查找来解决。在这道题中，给定了一系列的身高，我们需要找出能够组成的最长递增子序列的长度。我们可以用贪心算法配合multiset来高效地解决这个问题。

1. 问题转化： 我们需要在给定的身高序列中找出最长的递增子序列（LIS）。每个人的身高只能被选择一次，且新的队伍必须是递增的。

2. 贪心策略：

   • 我们可以使用 multiset(或vector配合二分查找）来维持当前找到的递增子序列的状态。
   • 对于每一个新出现的身高，我们尝试将它放入当前的递增子序列中。如果可以放入（即该身高大于序列中的某个元素），则替换掉序列中第一个大于等于该身高的元素。
   • 如果该身高比所有序列中的元素都大，就在序列的末尾添加它。

3. 使用 multiset 的理由：

   • multiset 允许我们高效地查找和更新递增子序列中的元素。特别是lower_bound操作可以在O(log n)时间内找到第一个不小于给定值的元素，从而实现更新操作。由于每个人的身高最多操作一次，因此总的时间复杂度是O(m log m)。

芝士插入:C++语言中，multiset是<set>库中一个非常有用的类型，它可以看成一个序列，插入一个数，删除一个数都能够在O(logn)的时间内完成，而且他能时刻保证序列中的数是有序的，而且序列中可以存在重复的数。(来自CSDN-二喵君)

代码如下:

#include <bits/stdc++.h>
using namespace std;
int main() {
    int n;
    cin >> n;
    multiset<int> v;
    for (int i = 0; i < n; i++) {
        int h;
        cin >> h;
        auto it = v.lower_bound(h);  //找到第一个大于等于 h 的位置
        if (it == v.end()) {
            v.insert(h);  //如果没有找到合适的位置，直接插入到末尾
        } else {
            v.erase(it);  //如果找到了，替换掉该位置的元素
            v.insert(h);
        }
    }
    cout << v.size();
    return 0;
}

第五题:

题目描述
已知现在有m(0<=m<=10)个相同的小球，还有n(1<=n<=10)个相同的箱子，现在需要把小球放进箱子中每个箱子里面，都可以放任意数量的小球，也可以选择不放。那么，一共有多少种放置方法?注:小球没有编号且相同，箱子没有编号且相同，因此如果有3个小球，3个箱子，如下两种方式是同一种放置方法，请勿重复计算。
方式1:在一个箱子中放2个小球，下一个箱子放1个小球，最后一个箱子不放。

方式2:在一个箱子中放1个小球，下一个箱子放2个小球，最后一个箱子不放。
输入描述
一行，两个正整数m,n，中间用空格分隔。
输出描述
一行一个整数，表示总的分法。
样例1
输入:
7 3
输出:
8
解题思路:
为了求解将m个相同的小球放入n个相同的箱子中的不同放置方法的总数，我们可以利用动态规划来解决。这个问题实际上是计算 “将m个相同的物品放入n个相同的容器中” 的组合方式数。
1.动态规划（DP）方法： 我们使用一个二维 DP 数组dp[i][j]来表示将i个小球放入j个箱子的不同方法数。

• 状态定义：

  • dp[i][j]表示将i个小球放入j个箱子中的放置方式的数量。

• 状态转移：

  • 如果我们不使用第j个箱子，那么dp[i][j]等于dp[i][j-1]。
  • 如果我们使用第j个箱子，那么可以考虑从i-j个小球中放置到j个箱子的情况，即dp[i-j][j]。
  • 综合上述两点，状态转移方程是:
  •                                      

• 边界条件：

  • dp[0][0] = 1将 0 个小球放入 0 个箱子的唯一方法是空放置。
  • dp[i][0] = 0(对于 i > 0)：将 i 个小球放入 0 个箱子的放置方法为 0。
  • dp[0][j] = 1(对于j >= 0)：将 0 个小球放入 j 个箱子的放置方法为 1（每个箱子都为空）。
  • 这种方法的时间复杂度为O(m*n)

代码如下:

#include <bits/stdc++.h>
using namespace std;
int main() {
    int m, n;
    cin >> m >> n;
    vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
    //初始化边界条件
    dp[0][0] = 1;
    for (int i = 0; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            dp[i][j] = dp[i][j - 1];
            if (i >= j) {
                dp[i][j] += dp[i - j][j]; 
                /*
                    对于每个dp[i][j]，我们首先考虑将i个小球分配到j-1个箱子中(dp[i][j-                            
                    1])，这表示不使用第j个箱子。
                    然后我们考虑将第j个箱子至少放一个小球，这样我们需要将剩下的i-j个小球分 
                    配到j个箱子中(dp[i-j][j])。
                */
            }
        }
    }
    cout << dp[m][n]; //dp[m][n]即为将m个小球放入n个箱子的不同方式总数。
    return 0;
}

第六题

题目描述
小鱼为了让自己能够更好的成长，决定报名参加各类公开课。不过不同的公开课开始和结束的时间点也是不同的，有些是白天的课程，有些是给上夜班的人提供的课程。如果两节课上课时间有重叠，就只能选择其中一个参加。
当然，参加越多的公开课，得到的成长也会更好，因此请规划一下小鱼的日程，统计最多可以参加几节公开课?
输入描述
第一行整数n，表示有n门公开课，接下来n行每行是2个整数start和end(0<=start<end<24),表示课程开始、结束的时间。
输出描述
小鱼最多参加的课程数目
样例1
输入
7
0 2
2 4
1 3
1 2
3 5
3 4
4 5
输出:
3

解题思路:

1. 问题转化： 我们需要选择一组课程，使得没有两个课程的时间段有重叠，并且我们所选择的课程数量最大。这个问题可以通过贪心算法来解决，具体方法是 按课程结束时间排序，然后从中选择不冲突的课程。

2. 贪心算法的核心思想：

   • 排序：首先，将所有课程按结束时间进行排序。排序后的课程列表能帮助我们在每一步选择结束时间最早的课程，最大化剩余时间。
   • 选择课程：遍历排序后的课程列表，保持当前选择的课程结束时间，选择下一个课程时，如果它的开始时间不早于当前选择的课程结束时间，则选择该课程。

3. 详细步骤：

   1. 读取课程的开始和结束时间，并存储到一个结构体中。
   2. 按课程的结束时间对课程进行排序。
   3. 遍历排序后的课程列表，选择那些不与当前选择课程时间重叠的课程。
4. 时间复杂度：
        排序的时间复杂度是O(n log n)。
        遍历课程的时间复杂度是O(n)。
        总的时间复杂度是O(n log n)，这是对这个问题的最优解决方案。

代码如下:

#include <bits/stdc++.h>
using namespace std;
struct C {
	int start;
	int end;
};
//比较函数，用于按照课程的结束时间排序
bool cmp(const C &a, const C &b) {
	return a.end < b.end;
}

int main() {
	int n;
	cin >> n;
	vector<C> v(n);
	for (int i = 0; i < n; i++) {
		cin >> v[i].start >> v[i].end;
	}
	//按照课程的结束时间排序
	sort(v.begin(), v.end(), cmp);
	int count = 0;  //计数器，记录最大参加课程的数量
	int endt = -1;  //记录最后一个选择课程的结束时间
	//遍历所有课程
	for (const C &c : v) {
		//如果当前课程的开始时间不早于最后一个选择课程的结束时间
		if (c.start >= endt) {
			count++;  //选择当前课程
			endt = c.end;  //更新最后选择课程的结束时间
		}
	}
	cout << count;
	return 0;
}