PAT-A1075-PAT Judge

PAT-PAT Judge - 题目链接

---

题目描述

 The ranklist of PAT is generated from the status list, which shows the scores of the submissions. This time you are supposed to generate the ranklist for PAT.

输入描述

 Each input file contains one test case. For each case, the first line contains 3 positive integers, N (≤10 4 ), the total number of users, K (≤5), the total number of problems, and M (≤10
5 ), the total number of submissions. It is then assumed that the user id’s are 5-digit numbers from 00001 to N, and the problem id’s are from 1 to K. The next line contains K positive integers p[i] (i=1, …, K), where p[i] corresponds to the full mark of the i-th problem. Then M lines follow, each gives the information of a submission in the following format:
user_id problem_id partial_score_obtained
where partial_score_obtained is either −1 if the submission cannot even pass the compiler, or is an integer in the range [0, p[problem_id]]. All the numbers in a line are separated by a space.

输出描述

 For each test case, you are supposed to output the ranklist in the following format:
rank user_id total_score s[1] … s[K] ，where rank is calculated according to the total_score, and all the users with the same total_score obtain the same rank; and s[i] is the partial score obtained for the i-th problem. If a user has never submitted a solution for a problem, then “-” must be printed at the corresponding position. If a user has submitted several solutions to solve one problem, then the highest score will be counted.
The ranklist must be printed in non-decreasing order of the ranks. For those who have the same rank, users must be sorted in nonincreasing order according to the number of perfectly solved problems. And if there is still a tie, then they must be printed in increasing order of their id’s. For those who has never submitted any solution that can pass the compiler, or has never submitted any solution, they must NOT be shown on the ranklist. It is guaranteed that at least one user can be shown on the ranklist.

---

示例：

输入

7 4 20
20 25 25 30
00002 2 12
00007 4 17
00005 1 19
00007 2 25
00005 1 20
00002 2 2
00005 1 15
00001 1 18
00004 3 25
00002 2 25
00005 3 22
00006 4 -1
00001 2 18
00002 1 20
00004 1 15
00002 4 18
00001 3 4
00001 4 2
00005 2 -1
00004 2 0

输出

1 00002 63 20 25 - 18
2 00005 42 20 0 22 -
2 00007 42 - 25 - 17
2 00001 42 18 18 4 2
5 00004 40 15 0 25 -

---

解题思路

 1.首先老规矩创建一个接收数组对数据进行读取 每题的分值单独放在一个全局变量的数组中
 2.当数据记录是编译失败(-1)的时候,这时候需要判断是否是该题目的一个条记录(如果是就将改题目的分数的得分改成0分），限制是第一个主要是为了防止后面的编译失败的记录覆盖该题已经得分的题目记录，如果得到的分数是满分 并且也是第一次，就将完美解题的数量进行加1，如果该条记录的得分大于以往记录的最高值，就进行覆盖，只要是存在一条未编译失败答题记录的就需要输出，将flag的值编程true
 3.之后根据每道题得分的情况将总和加在一起放入score_all中，这里可以使用已经确定的flag进行优化。
emsp;4.根据题目要求编写cmp函数，进行排序。
emsp;5.根据输出的要求进行输出 -如果得分的值是-1，说明该题没有答题的记录。

参考代码

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxn = 10010;

struct Student {
    int id;
    int score[6];
    int per_solve;
    int score_all;
    bool flag;
} Student[maxn];
//分值数组
int full[10] = {0};

bool cmp(struct Student a, struct Student b) {
    if (a.score_all != b.score_all) { //分数高的优先
        return a.score_all > b.score_all;
    } else if (a.per_solve != b.per_solve) { //完美解题数多的优先
        return a.per_solve > b.per_solve;
    } else {
        return a.id < b.id; //编号小的优先
    }
}

int main() {
    int n, k, m;
    scanf("%d %d %d", &n, &k, &m);
    for (int i = 1; i <= n; ++i) {//初始化结构数组
        Student[i].id = i;
        Student[i].flag = false;
        Student[i].per_solve = 0;
        Student[i].score_all = 0;
        /*memset初始化数组 以字节为单位 -1 ：1111 1111 1111 1111
                                    0： 0000 0000 0000 0000
        比较合适的是 0 和 -1
        */
        memset(Student[i].score, -1, sizeof(Student[i].score));
    }
    for (int i = 1; i <= k; ++i) {
        scanf("%d", &full[i]);
    }
    int id, qnumber, now_score;
    for (int i = 0; i < m; ++i) {
        scanf("%d%d%d", &id, &qnumber, &now_score);
        //下面是比较重要的判断方法  可以具体看解题思路
        if (now_score != -1) {
            Student[id].flag = true;
        }
        if (now_score == -1 && Student[id].score[qnumber] == -1) {
            Student[id].score[qnumber] = 0;
        }
        if (now_score == full[qnumber] && Student[id].score[qnumber] < full[qnumber]) {
            Student[id].per_solve++;
        }
        if (Student[id].score[qnumber] < now_score) {
            Student[id].score[qnumber] = now_score;
        }
    }
    for (int i = 1; i <= n; ++i) {
        if (Student[i].flag) { //使用flag进行优化 
            for (int j = 1; j <= k; ++j) {
                if (Student[i].score[j] != -1) {
                    Student[i].score_all += Student[i].score[j];
                }
            }
        }
    }
    sort(Student + 1, Student + n + 1, cmp);
    int r = 1; //名次的常用书写方式 1 2 2 4
    for (int i = 1; i <= n && Student[i].flag == true; ++i) {
        if (i > 1 && (Student[i].score_all != Student[i - 1].score_all)) {
            r = i;
        }
        printf("%d %05d %d", r, Student[i].id, Student[i].score_all);
        for (int j = 1; j <= k; j++) {
            if (Student[i].score[j] != -1) {
                printf(" %d", Student[i].score[j]);
            } else {
                printf(" -");
            }
        }
        printf("\n");
    }
    return 0;
}