PAT Basic 1080 MOOC期终成绩 C语言(测试点3)
题目略： https://pintia.cn/problem-sets/994805260223102976/problems/994805261493977088
题解：
题目的要求就不再赘述了，并不难理解，要注意的有：
- 合格条件是： 编程成绩>=200，总成绩>=60。所以对于编程成绩小于200(包括根本没有编程成绩的)，可以直接剔除。所以，省事的做法就是只需要存储有编程成绩的学生，也就是第一部分的数据，对于后面期中和期末新出现的学生都可以直接忽略掉。对于没有期末成绩的，不必额外判断，因为按照成绩计算公式，期中只占40%，不影响最后结果。
- 最后按总分降序排列，分数相同的按学号升序排列。
- 总分要注意四舍五入，可以用math.h的round()函数或者加0.5强转int的方法。
- 没有成绩的要显示-1，初始化的时候可以设定-1为默认值
对于C++，Java或者Python来说，这道题只要用一个map(hashmap))来建立字符串到整数索引的映射，用另外一个数组来顺序存储学生的信息即可。
但是对于C语言来说，没有map这样好用的数据结构，要么把字符串存到线性表里，用binerysearch O(logN)来查找，时间还是可以过的，不会超时，参考一个别人写的题解https://github.com/OliverLew/PAT/blob/master/PATBasic/1080.c
要么就自己构造一个简单的hashmap，查找只需要O(1)的常数时间。我选择了后者，顺便可以学习一下hashmap的基本原理。
第一次尝试：
建立两个数组，一个是map数组，作为散列表，下标代表hash值，元素值为录入学生数据的顺序（从0开始），另一个是arr数组，元素类型是结构体Stu。 凭学号经过BKDRHash()函数得到hash值，并对散列表长度求MOD后得到此字符串对应的在map数组的索引，进而得到arr数组中相对应的索引。
假如： missing这个人算出一个hash值为 12345(随便举例)，map[12345]=1，arr[1]就存储missing这个人的信息。
为了保证表示散列表某个单元是否已经被占，我将其初始值设为-1，-1代表此单元为空。
但这个代码只通过了前三个测试点，测试点3大数据量的点一直错误。起初我以为是程序的逻辑有错误，经过多次检查和比较网上其他博客的解法后，断定计算逻辑是没错的。那么问题肯定出在自己构造的hashmap上。由于测试点3数据量较大（10000），我猜是hash冲突了，也就是两个不同的字符串得到hash值MOD SIZE后相等的情况，比如 5%7 == 9%7，实际上这个现象比想象中更常见。在C++和Java中的hashmap实现中，解决hash冲突的方法是把冲突的多个数据存在链表或者二叉树中。此外，解决hash冲突的方法还有开放寻址法。我选择实现开放寻址法来解决hash冲突。代码在后面。
History 卡测试点3
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct Node{
char name[21];
int pro; //编程成绩
int mid; //期中
int final; //期末
int sum; //总成绩
}Stu;
// BKDR Hash Function
unsigned int BKDRHash(char *str)
{
unsigned int seed = 131; // 31 131 1313 13131 131313 etc..
unsigned int hash = 0;
while (*str)
hash = hash * seed + (*str++);
return (hash & 0x7FFFFFFF) %57713;
}
int comp(Stu *a,Stu *b){
if(a->sum == b->sum){
return strcmp(a->name,b->name);
}else{
return b->sum - a->sum; // a>b -
}
}
int main(){
int P,M,N;
int map[57713],count=0; //count是存入的顺序
Stu arr[10001]; //顺序保存学生的信息
scanf("%d %d %d",&P,&M,&N);
for(int i=0;i<57713;i++) map[i]=-1; //每一个单元都初始化为-1
for(int i=0;i<P;i++){
char name[21];
int program;
scanf("%s %d",name,&program);
if(program >= 200){ //编程成绩小于200的直接忽略
int hash = BKDRHash(name);
map[hash] = count;
memcpy(arr[count].name,name,sizeof(char)*21);
arr[count].mid = -1; //要注意初始化为-1，有可能没有成绩，导致最后输出出错
arr[count].final = -1;
arr[count].pro = program>=0&&program<=900? program:-1;
count++; //下一个学生
}
}
for(int i=0;i<M;i++){
char name[21];
int m;
scanf("%s %d",name,&m);
int hash = BKDRHash(name);
if(map[hash] !=-1 ){ // 如果此学生已经被记录，也就是说明有编程成绩
arr[map[hash]].mid = m<=100?m:-1;
}
}
for(int i=0;i<N;i++){
char name[21];
int f;
scanf("%s %d",name,&f);
int hash = BKDRHash(name);
int idx = map[hash];
if(idx != -1){ // 如果此学生已经被记录，也就是说明有编程成绩
arr[idx].final = f<=100?f:-1;
if(arr[idx].mid > arr[idx].final){//计算总成绩
arr[idx].sum = (int)(arr[idx].mid * 0.4 + arr[idx].final*0.6 + 0.5);
}else{
arr[idx].sum = arr[idx].final;
}
}
}
qsort(arr,count,sizeof(struct Node),comp);//按要求排序
for(int i=0;i<count;i++){
if(arr[i].sum >= 60)
printf("%s %d %d %d %d\n",arr[i].name,arr[i].pro,arr[i].mid,arr[i].final,arr[i].sum);
}
return 0;
}
第二次尝试
简述一下开放寻址法。
开放寻址法的思想非常简单：如果有冲突产生，那么就要尝试寻找新的可用单元。
数学上表达为 h(X) = (Hash(X) + F(i)) mod TableSize 其中F(i)是冲突解决办法。
具体来说，发生了hash冲突时，由于hash(key1)==hash(key2)，导致key2要存入的单元被key1占了，就要给key2找一个新家。我们可以去看看下一个单元，也可以每隔S个单元看一下，等等，直到找到可用的空单元。
开放寻址法有多种实现方法，这里也不赘述。我选用的是平方探测法。具体原理来自《数据结构与算法分析 – C语言描述》118–122页。
平方解决函数的定义为：F(i) = F(i-1) + 2i - 1 。
由于存在冲突的可能，新的散列表里就不能只是存储count值，也要把字符串也存起来，以供查找。于是新的map数组元素类型是Cell结构体， key为学号字符串，val为原来的count值。新元素插入的下标由开放寻址法决定
代码如下
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define SIZE 57713
typedef struct Stu{
char name[21];
int pro;
int mid;
int final;
int sum;
}Stu;
typedef struct Cell{
char key[21];
int val;
}Cell;
// BKDR Hash Function
unsigned int BKDRHash(char *str)
{
unsigned int seed = 31; // 31 131 1313 13131 131313 etc..
unsigned int hash = 0;
while (*str)
hash = hash * seed + (*str++);
return (hash & 0x7FFFFFFF) % SIZE;
}
/*
此函数利用开放寻址法，实现从散列表中查找的功能。
对于新加入的key，将解决冲突并返回下一个可用的空单元地址。
对于已经存在的key，将返回此key的单元地址。
*/
int find(Cell *map,const char *key){
int hash = BKDRHash(key);
int step = 0;
while(map[hash].val != -1 && strcmp(map[hash].key,key)!=0){
hash += 2*(++step) - 1;
if(hash >= SIZE)
hash -= SIZE;
}
return hash;
}
/*
此函数利用开放寻址法，实现从散列表中插入的功能。
返回是否插入成功(是否已经存在)
*/
int insert(Cell *map,const char *key, int val){
int hash = find(map,key);
if(map[hash].val == -1){ // 如果find函数返回的是个空单元，说明可以插入;否则将什么也不做
map[hash].val = val;
memcpy(map[hash].key,key,sizeof(char)*21);
return 1;
}
return 0;
}
int comp(Stu *a,Stu *b){
if(a->sum == b->sum){
return strcmp(a->name,b->name);
}else{
return b->sum - a->sum;
}
}
int main(){
int P,M,N,count=0;
Cell map[SIZE]; //新的散列表
Stu arr[10001];
scanf("%d %d %d",&P,&M,&N);
for(int i=0;i<SIZE;i++)
map[i].val=-1; // -1代表空单元
for(int i=0;i<P;i++){
char name[21];
int program;
scanf("%s %d",name,&program);
if(program >= 200){
int flag = insert(map,name,count);
memcpy(arr[count].name,name,sizeof(char)*21);
arr[count].mid = -1;
arr[count].final = -1;
arr[count].pro = program>=0&&program<=900? program:-1;
if(flag) //只有插入成功，才让count递增，题目说保证学号不会重复，所以可以省略这个判断
count++;
}
}
for(int i=0;i<M;i++){
char name[21];
int m;
scanf("%s %d",name,&m);
int hashidx = find(map,name); // hashidx是map数组的索引
int idx = map[hashidx].val; // idx是arr数组的索引
if(idx != -1 ){
arr[idx].mid = m<=100?m:-1;
}
}
for(int i=0;i<N;i++){
char name[21];
int f;
scanf("%s %d",name,&f);
int hashidx = find(map,name);
int idx = map[hashidx].val;
if(idx != -1){
arr[idx].final = f<=100?f:-1;
if(arr[idx].mid > arr[idx].final){
arr[idx].sum = (int)(arr[idx].mid * 0.4 + arr[idx].final*0.6 + 0.5);
}else{
arr[idx].sum = arr[idx].final;
}
}
}
qsort(arr,count,sizeof(struct Stu),comp);
for(int i=0;i<count;i++){
if(arr[i].sum >= 60)
printf("%s %d %d %d %d\n",arr[i].name,arr[i].pro,arr[i].mid,arr[i].final,arr[i].sum);
}
return 0;
}
| 测试点 | 结果 | 耗时 | 内存 |
|---|---|---|---|
| 0 | 答案正确 | 3 ms | 1792 KB |
| 1 | 答案正确 | 3 ms | 1824 KB |
| 2 | 答案正确 | 2 ms | 1892 KB |
| 3 | 答案正确 | 12 ms | 2304 KB |
平时练习多造造轮子，可以加深对一些底层知识的理解。但是赶时间/考试/竞赛/项目 就没必要了~
扫一扫
237
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
