PTA 7-38 寻找大富翁(25 分)解法(C/C++)暴力快排/精准堆排 解法

7-38 寻找大富翁 (25分)

胡润研究院的调查显示,截至2017年底,中国个人资产超过1亿元的高净值人群达15万人。假设给出N个人的个人资产值,请快速找出资产排前M位的大富翁。

输入格式:

输入首先给出两个正整数N(≤10​^6​​)和M(≤10),其中N为总人数,M为需要找出的大富翁数;接下来一行给出N个人的个人资产值,以百万元为单位,为不超过长整型范围的整数。数字间以空格分隔。

输出格式:

在一行内按非递增顺序输出资产排前M位的大富翁的个人资产值。数字间以空格分隔,但结尾不得有多余空格。

输入样例:

8 3
8 12 7 3 20 9 5 18

输出样例:

20 18 12

 坑点说明:

注意有可能M>N,此时按照常理应取M=N

实测输入数据(第二行数据)不超过int32位。


 解法一:系统自带快速排序法(直接能想到的暴力解法)

 C++版本:

#include
#include
#include
using namespace std;
typedef int ELE;
const size_t SIZE = 1000000;
ELE A[SIZE];
size_t N, M;
int main() {
	scanf("%d %d\n", &N, &M);
	M = min(N, M);	//坑点先处理
	for (size_t i = 0; i < N; i++){
		scanf("%d", &A[i]);
	}
	sort(A, A+N, std::greater());	//降序排序
	//输出M个数
	printf("%d", A[0]); //第一名
	for (size_t i = 1; i < M;++i) {
		printf(" %d", A[i]);
	}
//	system("pause");
	return 0;
}

C语言版本在附录(算法完全一致)


解法二:仅对前M名进行堆排序

由于输入的总数N最高可达10的6次方,但只求前M名的结果且M不超过10,能不能利用此减少处理的数据量呢?答案是肯定的,虽然输入N个数的操作不可能避免,但是可以将存储和排序的个数减少到M(M先取min(N,M))。

只需建立M个的小根堆,先录入M个元素,后面的N-M个元素仅当大于堆顶(堆中最小者,即第M大),才替换堆顶并调整。最后堆中M个元素就是全部N个元素中的前M大。因为只求前M名,所以新输入的不比当前第M名大则丢弃!

有些程序员做法是排N个元素(最高达10^6)的堆排序,完全没利用上M很小的优势。同规模的堆排序本来就比快速排序慢!而且堆太大时cache命中率低下,访存速度就更慢了,会比暴力快排解法慢得多。

下面解法是用自编的小根堆而非优先队列,速度较快。其实只要默一遍堆排序向下调整这一个函数,就可以用于此题,因为此题不需要从堆尾插入元素,只需要更新堆顶,而C++自带的优先队列C++11版本的STL还不支持更新堆顶操作(强烈建议官方添加此操作~~汗)。

C++解法如下:

#include
#include
using namespace std;
typedef unsigned int U32;
typedef int ELE;
typedef const ELE & ELE_CR;	//_CR表示常引用
const U32 SIZE = 11;
ELE H[SIZE]; //Heap Sort
U32 sizeH = 0;
bool cmp(ELE_CR parent, ELE_CR child) {
	return parent< child;	//小根堆(必须父<=子)
}
void downShift(int i);
int N, M;
int main() {
	scanf("%d %d\n", &N, &M);
	M = min(N,M);	//坑点先处理
	//先输入M个
	for (sizeH = 0; sizeH < M; ) {
		scanf("%d", &H[++sizeH]);	//注意堆排序H[0]不算节点
	}
	//建堆,倒序遍历每个非叶节点向下调整即可。
	for (int i = sizeH / 2; i>0; --i) {
		downShift(i);	//向下调整
	}
	//再输入 N-M个
	for (int i = N - M; i-- > 0;) {
		scanf("%d", &H[0]);
		if (H[0] > H[1]) {	//比堆顶(第M名)大
			H[1] = H[0];	//替代掉
			downShift(1);	//向下调整
		}
	}
	sort(H + 1, H + 1 + M);	//前M名升序排序
	printf("%d",H[M]);		//倒序输出M个
	for (int i = M-1; i >= 1; --i) {
		printf(" %d", H[i]);
	}
//	system("pause");
	return 0;
}
void downShift(int i) {
	ELE key = H[i];	//虚交换——备份(key作为值,H[i]作为地址)
	for (int j; (j = 2 * i) <= sizeH; i = j) {
		if (j < sizeH && cmp(H[j + 1], H[j]))++j;	//左右两个子节点取更"父"者
		if (cmp(H[j], key))H[i] = H[j];	//虚交换(父子节点)
		else break;
	}
	H[i] = key;		//虚交换——复原
}

此解法比暴力快排解法执行快20%左右(OJ平台执行时间会有波动,需要多次交叉测量取平均),其实一大半的时间浪费在IO上,如果M超过1000,估计怎么优化都还是暴力快排更快吧。


附录:

暴力快排C语言解法:

#include
#include
typedef int ELE;
typedef const void* CR;
#define INT(pointer) (*((int*)pointer))
int cmp(CR a, CR b) {	//降序排序
	return INT(b) - INT(a);
}
#define FOR(I,S,E) for(int I=(S);I<(E);I++)
#define MIN(a,b)            (((a) < (b)) ? (a) : (b))
#define SIZE 1000000
ELE A[SIZE];
int N, M;
int main() {
	scanf("%d %d\n", &N, &M);
	M = MIN(N, M);	//坑点先处理
	FOR(i,0,N) {
		scanf("%d", &A[i]);
	}
	qsort(A, N, sizeof(ELE), cmp);	//降序排序
	//输出M个数
	printf("%d", A[0]); 
	FOR(i,1,M) {
		printf(" %d", A[i]);
	}
	//	system("pause");
	return 0;
}

精准堆排序C语言版:

#include
#include
typedef unsigned int U32;
typedef int ELE;
typedef const void* CR;
#define INT(pointer) (*((int*)pointer))
int cmp(CR a, CR b) { return INT(a) - INT(b); }
#define MIN(a,b)            (((a) < (b)) ? (a) : (b))
#define SIZE 11
ELE H[SIZE]; //Heap Sort
U32 sizeH = 0;
#define CMP(PARENT,CHILD) ((PARENT)<(CHILD))//小根堆(必须父<=子)
void downShift(int i);
int N, M;
int main() {
	scanf("%d %d\n", &N, &M);
	M = MIN(N,M);	//坑点先处理
	//先输入M个
	for (sizeH = 0; sizeH < M; ) {
		scanf("%d", &H[++sizeH]);   //注意堆排序H[0]不算节点
	}
	//建堆,倒序遍历每个非叶节点向下调整即可。
	for (int i = sizeH / 2; i>0; --i) {
		downShift(i);	//向下调整
	}
	//再输入 N-M个
	for (int i = N - M; i-- > 0;) {
		scanf("%d", &H[0]);
		if (H[0] > H[1]) {	//比堆顶(第M名)大
			H[1] = H[0];	//替代掉
			downShift(1);   //向下调整
		}
	}
	qsort(H + 1, M, sizeof(ELE), cmp);	//前M名升序
	printf("%d",H[M]);
	for (int i = M; i-- > 1;) {
		printf(" %d", H[i]);
	}
//	system("pause");
	return 0;
}
void downShift(int i) {
	ELE key = H[i];
	for (int j; (j = 2 * i) <= sizeH; i = j) {
		if (j < sizeH && CMP(H[j + 1], H[j]))++j;
		if (CMP(H[j], key))H[i] = H[j];
		else break;
	}
	H[i] = key;
}

 

你可能感兴趣的:(PAT乙级,排序算法,c++,数据结构)