PTA L1-8 静静的推荐

PTA L1-8 静静的推荐

分数 20

全屏浏览题目

切换布局

作者陈越

单位浙江大学

天梯赛结束后，某企业的人力资源部希望组委会能推荐一批优秀的学生，这个整理推荐名单的任务就由静静姐负责。企业接受推荐的流程是这样的：

只考虑得分不低于 175 分的学生；
一共接受 K 批次的推荐名单；
同一批推荐名单上的学生的成绩原则上应严格递增；
如果有的学生天梯赛成绩虽然与前一个人相同，但其参加过 PAT 考试，且成绩达到了该企业的面试分数线，则也可以接受。

给定全体参赛学生的成绩和他们的 PAT 考试成绩，请你帮静静姐算一算，她最多能向企业推荐多少学生？

输入格式：

输入第一行给出 3 个正整数：N（≤105）为参赛学生人数，K（≤5×103）为企业接受的推荐批次，S（≤100）为该企业的 PAT 面试分数线。

随后 N 行，每行给出两个分数，依次为一位学生的天梯赛分数（最高分 290）和 PAT 分数（最高分 100）。

输出格式：

在一行中输出静静姐最多能向企业推荐的学生人数。

输入样例：
10 2 90
203 0
169 91
175 88
175 0
175 90
189 0
189 0
189 95
189 89
256 100
输出样例：
8
样例解释：

第一批可以选择 175、189、203、256 这四个分数的学生各一名，此外 175 分 PAT 分数达到 90 分的学生和 189 分 PAT 分数达到 95 分的学生可以额外进入名单。第二批就只剩下 175、189 两个分数的学生各一名可以进入名单了。最终一共 8 人进入推荐名单。

代码长度限制

16 KB

Java (javac)

时间限制

1300 ms

内存限制

256 MB

Python (python3)

时间限制

400 ms

内存限制

64 MB

其他编译器

时间限制

200 ms

内存限制

64 MB

我的答案：

一、信息

1.天梯赛结束后，企业的人力资源部希望能推荐一些学生。

2.只考虑得分不低于175分的学生

3.一共接收K批次的推荐名单

4.同一批推荐名单上的学生成绩原则应该严格递增

5.如果优点学生天梯赛成绩与前一个人相同，但通过了PTA考试，且成绩达到了企业的面试分数线，则也可以接受。

6.给出全体参赛学生的成绩和它们的PAT考试成绩，请你的PAT考试成绩，请你算一算他能向企业推荐多少学生。

7.输入格式

三个输入，一个是参赛学生人数，二是企业接受推荐批次，S为该企业的PAT面试分数线

8.输出格式

在一行中输出静静姐最多能向企业推荐的人数

二、分析

条件1.告诉我们的此次题目的目的

条件2.其实就是第一个限制条件也是规则说明了只考虑175分及以上的人

条件3.就是告诉我们第二个限制条件，表面上很简单但其实告诉我们一种特殊情况，我们不妨来看看有几种情况：

1.第一种情况就是每一个人的分数都不一样即没有同分，这种情况很简单因为其实动用第一个限制条件就行了，难道你们不觉得很奇怪吗这种情况因为如果这样就不需要条件3的限制条件了。

2.第二种情况就是存在有同分的情况

其实这个问题就是他每一批都会先遍历第一列的元素然后再遍历第二列元素相当于:

这里以第一批为例我们第一次会收到175、189、203、256 四个学生不同分然后他开始遍历第二列又查到PTA过90分的两个同学175 和189

从这个样例分析中我就知道了，其实每一批次是通过先检测第一列然后检测第二列在放入这个批次

三、步骤

第一步定义一个数据结果用来存结果，问题出现就是首先用什么数据结构来模拟这个批次的队列就是怎么存结果

第二步 k就是批次其实就是循环的次数所以我们可以通过循环k次然后遍历

第三步进入第k次遍历，然后判断第一列是否天梯赛的分数是否符合175分及以上，满足的话就压入数据结构中，然后判断第二列是否符合限制条件2.满足就压入数据结构中。

第四步结果输出数据结构的数就行了。

四、出现的问题

问题1.存储结构的数据结构应该选择什么

我一个大神同学推荐我使用map数据结构。

问题2.

正确答案：

一、信息

题目描述：根据一定的规则筛选学生，为企业推荐K批学生。筛选规则为：

只考虑得分不低于 175 分的学生。
同一批推荐名单上的学生的成绩原则上应严格递增。
如果有的学生天梯赛成绩与前一个人相同，但其参加过 PAT 考试，且成绩达到了企业的面试分数线，则也可以接受。

二、分析

先对满足天梯赛分数>=175并且PAT分数>=S的学生进行计数，并标记这些学生不再参与后续计算。
对于满足天梯赛分数>=175的学生，使用map记录每一个分数的出现次数，只要这个分数的出现次数不超过K就可以计入结果。

三、算法设计

数组思路：

初始化一个数组counts用于跟踪每个天梯赛分数的推荐次数。
遍历每个学生，检查其是否满足上述的推荐条件。
如果满足条件，增加总推荐数，并更新对应天梯赛分数的推荐次数。

map思路：

遍历所有学生的分数。
对于天梯赛分数>=175并且PAT分数>=S的学生，增加答案计数，并标记这些学生不再参与后续计算。
对于天梯赛分数>=175的学生，检查该分数在map中的出现次数，如果不超过K则增加答案计数。

四、代码实现

数组实现：

C语言：

#include <stdio.h>

int main() {
    int n, k, s, total = 0;
    int ladderScores[100500] = {0}, patScores[100500] = {0};
    int counts[291] = {0}; // 天梯赛最高分290

    // 输入
    scanf("%d %d %d", &n, &k, &s);
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &ladderScores[i], &patScores[i]);
    }

    // 处理
    for (int i = 0; i < n; i++) {
        if (ladderScores[i] >= 175) {
            // 如果PAT分数达标
            if (patScores[i] >= s) {
                total++;
                continue;
            }
            // 检查这个天梯赛分数是否已经推荐k次
            if (counts[ladderScores[i]] < k) {
                total++;
                counts[ladderScores[i]]++;
            }
        }
    }

    // 输出结果
    printf("%d\n", total);
    return 0;
}

Map实现：

C语言:

#include <stdio.h>

// 简单的map数据结构
typedef struct {
    int keys[100500];
    int values[100500];
    int size;
} SimpleMap;

// 初始化map
void initMap(SimpleMap *m) {
    m->size = 0;
}

// 向map中插入或更新一个键值对
void put(SimpleMap *m, int key, int value) {
    for (int i = 0; i < m->size; i++) {
        if (m->keys[i] == key) {
            m->values[i] = value;
            return;
        }
    }
    m->keys[m->size] = key;
    m->values[m->size] = value;
    m->size++;
}

// 从map中获取一个键对应的值，如果键不存在返回defaultValue
int get(SimpleMap *m, int key, int defaultValue) {
    for (int i = 0; i < m->size; i++) {
        if (m->keys[i] == key) {
            return m->values[i];
        }
    }
    return defaultValue;
}

int main() {
    int n, k, s, total = 0;
    int ladderScore, patScore;
    SimpleMap scoreCounts;
    initMap(&scoreCounts);

    // 输入
    scanf("%d %d %d", &n, &k, &s);
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &ladderScore, &patScore);

        if (ladderScore >= 175) {
            // 如果PAT分数达标
            if (patScore >= s) {
                total++;
                continue;
            }
            // 检查这个天梯赛分数是否已经推荐k次
            int count = get(&scoreCounts, ladderScore, 0);
            if (count < k) {
                total++;
                put(&scoreCounts, ladderScore, count + 1);
            }
        }
    }

    // 输出结果
    printf("%d\n", total);
    return 0;
}

C++：

#include <iostream>
#include <unordered_map>
using namespace std;

int main() {
    int n, k, s, total = 0;
    int ladderScore, patScore;
    unordered_map<int, int> scoreCounts; // 使用C++ STL中的unordered_map作为map

    // 输入
    cin >> n >> k >> s;
    for (int i = 0; i < n; i++) {
        cin >> ladderScore >> patScore;

        if (ladderScore >= 175) {
            // 如果PAT分数达标
            if (patScore >= s) {
                total++;
                continue;
            }
            // 检查这个天梯赛分数是否已经推荐k次
            if (scoreCounts[ladderScore] < k) {
                total++;
                scoreCounts[ladderScore]++;
            }
        }
    }

    // 输出结果
    cout << total << endl;
    return 0;
}

这里就显示了一个问题C++STL库是真好用啊

注意事项：

使用C++的标准库中的unordered_map来替代手动实现的SimpleMap。unordered_map是C++ STL中的一个高效的键值对容器。
使用C++的流输入输出来替代C的scanf和printf。
不再需要手动实现initMap、put和get函数，因为unordered_map已经提供了相应的功能。

Java实现：

import java.util.HashMap;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();
        int k = sc.nextInt();
        int s = sc.nextInt();
        int total = 0;

        HashMap<Integer, Integer> scoreCounts = new HashMap<>();

        for (int i = 0; i < n; i++) {
            int ladderScore = sc.nextInt();
            int patScore = sc.nextInt();

            if (ladderScore >= 175) {
                // 如果PAT分数达标
                if (patScore >= s) {
                    total++;
                    continue;
                }
                // 检查这个天梯赛分数是否已经推荐k次
                scoreCounts.putIfAbsent(ladderScore, 0);
                if (scoreCounts.get(ladderScore) < k) {
                    total++;
                    scoreCounts.put(ladderScore, scoreCounts.get(ladderScore) + 1);
                }
            }
        }

        System.out.println(total);
    }
}