奥运排行榜

夜烨123

于 2024-12-27 20:00:22 发布

阅读量894

点赞数 14

分类专栏：数据结构文章标签：算法排序算法数据结构 c语言

本文链接：https://blog.csdn.net/2302_80273625/article/details/144752738

版权

数据结构专栏收录该内容

16 篇文章

订阅专栏

题目要求：

每年奥运会各大媒体都会公布一个排行榜，但是细心的读者发现，不同国家的排行榜略有不同。比如中国金牌总数列第一的时候，中国媒体就公布“金牌榜”；而美国的奖牌总数第一，于是美国媒体就公布“奖牌榜”。如果人口少的国家公布一个“国民人均奖牌榜”，说不定非洲的国家会成为榜魁…… 现在就请你写一个程序，对每个前来咨询的国家按照对其最有利的方式计算它的排名。

输入格式:

输入的第一行给出两个正整数N和M（≤224，因为世界上共有224个国家和地区），分别是参与排名的国家和地区的总个数、以及前来咨询的国家的个数。为简单起见，我们把国家从0 ~ N−1编号。之后有N行输入，第i行给出编号为i−1的国家的金牌数、奖牌数、国民人口数（单位为百万），数字均为[0,1000]区间内的整数，用空格分隔。最后面一行给出M个前来咨询的国家的编号，用空格分隔。

输出格式:

在一行里顺序输出前来咨询的国家的排名:计算方式编号。其排名按照对该国家最有利的方式计算；计算方式编号为：金牌榜=1，奖牌榜=2，国民人均金牌榜=3，国民人均奖牌榜=4。输出间以空格分隔，输出结尾不能有多余空格。

若某国在不同排名方式下有相同名次，则输出编号最小的计算方式。

输入样例:

4 4
51 100 1000
36 110 300
6 14 32
5 18 40
0 1 2 3

输出样例:

1:1 1:2 1:3 1:4

实现思路：

这道题我认为难度很大，但实际上我看有人很简单就写出来了，真伤心！所以，我就简单说一下我的思路好了，我认为这篇参考价值不大，但是我还是想分享一下我的脑洞。

我看我周围的同学大部分都用快排做的这道题，但是我做这道题的时候刚做完寻找大富翁那道题，我想能在排序过程中把排名也算出来的也就只有堆排序最适合了，快排从中间开始确定，有点难写。所以我又用的堆排序！（嘻嘻，难道我是堆排序的真爱粉？）

但是，有一个我们必须要注意的点是，在同一种排名方式下，如果分数相同的话，排名也会相同，就和现实中排名一样。

因为我的排名计算方法并不是通过人数计算的，所以我只要记录一下排在前一个的分数和排名就行了，如果相等那么排名就相同，否则就按照逻辑关系n-i+1算出应该的排名。

double pre = -1;
	int wh;
	for (i = n; i > 0; i--) {
		if (R[1] == pre) {
			C[id[1]].way[sh] = wh;
		} else {
			C[id[1]].way[sh] = n - i + 1;
			wh = n - i + 1;
			pre = R[1];
		}
......
}

还有一个问题是这里排序的时候不能用结构体，否则你就得写4个排序算法，所以我设置了4个数组分别记录其金牌数，奖牌数，国民人均金牌数，国民人均奖牌数，还设置了一个结构体数组来存储信息，但现在看这个结构体只要存储排名信息就可以了，其他的好像没用上，要注意这结构体数组的下标就是国家的编号。

用堆排序是可以在排序的时候把排名也算出来，但是你怎么确定此时这个R[1]对应的国家的编号呢？这是必须要解决的问题，如果用结构体的话，那么排序算法就要写4次。

所以我就又设置了一个数组id，这个数组存储编号信息。数组R[ ]和数组 id[ ]对应，即它们是捆绑关系，其实就是类似于一个结构体里的内容，R[ ]数组在排序过程中交换的时候id[ ]数组也要交换，确保下标相同就对应id[ ]数组中存储的那个编号的国家，主要是不想写四次排序算法想出来的馊主意，但是可读性太差了，不建议使用。

每一趟排序，就可以确定R[1]对应的id[1]存储的国家编号的排名，其中sh是对应的排名方式。

这就可以理解每次为什么用 C[id[1]].way[sh] 这个来存储排名信息了。

我认为这样写就是排完一次序的同时又整理好了排名，这样只进行4次排序就好了，最后再找出排名最靠前的方式也很简单。

哈哈哈，但是代码的可读性真的太差了，不过是自己想出来的还是很有成就感的，所以想为大家提供一种新的思路去解题。

代码实现：

#include <stdio.h>
#define N 225
int m, n;
typedef struct node {
	double gold;
	double medal;
	double p;
	int way[5];
} Node;
Node C[N];
double gold[N];
double medal[N];
double goldp[N];
double medalp[N];
void heapSift(double R[], int id[], int i, int ch) {    //R[i]为根节点
	double rc = R[i];
	int num = id[i];
	int j = 2 * i;
	while (j <= ch) {
		if (j < ch && R[j] < R[j + 1]) j++; //寻找值更大的孩子节点
		if (rc > R[j]) break;      //找到最终位置
		R[i] = R[j];
		id[i] = id[j];             //孩子上移
		i = j;                     //继续向下比较
		j = 2 * j;
	}
	R[i] = rc;
	id[i] = num;
}
//堆排序
void heapSort(double R[], int sh) {    //sh为排序的方法序号
	int i, num;
	double x;
	int id[n + 1];
	for (int j = 1; j <= n; j++) id[j] = j;
	for (i = n / 2; i >= 1; i--) { //从最后一个非叶子节点开始反复使用筛选法
		heapSift(R, id, i, n);
	}
	double pre = -1;
	int wh;
	for (i = n; i > 0; i--) {
		if (R[1] == pre) {
			C[id[1]].way[sh] = wh;
		} else {
			C[id[1]].way[sh] = n - i + 1;
			wh = n - i + 1;
			pre = R[1];
		}
		x = R[i];
		R[i] = R[1];
		R[1] = x;
		num = id[i];
		id[i] = id[1];
		id[1] = num;
		heapSift(R, id, 1, i - 1);
	}
	if (R[1] == pre) {
		C[id[1]].way[sh] = wh;
	} else {
		C[id[1]].way[sh] = n;
	}
}
int high(int m) {
	int min = 100000;
	int t;
	for (int i = 1; i <= 4; i++) {
		if (min > C[m].way[i]) {
			min = C[m].way[i];
			t = i;
		}
	}
	return t;
}
int main() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= n; i++) {
		scanf("%lf %lf %lf", &C[i].gold, &C[i].medal, &C[i].p);
		gold[i] = C[i].gold;
		medal[i] = C[i].medal;
		goldp[i] = C[i].gold / C[i].p;
		medalp[i] = C[i].medal / C[i].p;
	}
	heapSort(gold, 1);
	heapSort(medal, 2);
	heapSort(goldp, 3);
	heapSort(medalp, 4);
	/*for(int i=1;i<=n;i++) printf("%d\n",C[i].way[1]);
	    for(int i=1;i<=n;i++) printf("%d\n",C[i].way[2]);
		for(int i=1;i<=n;i++) printf("%d\n",C[i].way[3]);
		for(int i=1;i<=n;i++) printf("%d\n",C[i].way[4]);*/
	int a, b;
	for (int i = 0; i < m; i++) {
		scanf("%d", &a);
		b = high(a + 1);
		if (i > 0) printf(" ");
		printf("%d:%d", C[a + 1].way[b], b);
	}
	return 0;
}