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#includeusing 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#includeusing 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#includetypedef 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

精准堆排序C语言版：

#include#includetypedef 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)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;

}