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;
}