11073 最热门的K个搜索串

11073 最热门的K个搜索串
时间限制:350MS 内存限制:65535K
提交次数:0 通过次数:0

题型: 编程题 语言: G++;GCC;VC
Description
大家都非常喜欢而习惯用baidu，google，sogou等搜索引擎来搜索自己感兴趣的资料。
搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来，每个查询串的长度为1-255字节。
假设目前有一百万个记录（这些查询串的重复度比较高，除去重复后会少很多）。
搜索引擎统计查询串的重复频度，一个查询串的重复频度越高，说明查询它的用户越多，也就是越热门。
希望能找到最热门的10个或100个查询串。

现在问题模型是：一个无序的整数数列，数列元素个数为N，1000<=N<=1000000，
如何选出其中最大的K个数，K远小于N(K<<N, K<1000)，
比如Top10的数，或Top100的数等。本意并不要求选出的这K个数有序，也不要求剩余的N-K个数有序。
但最终输出为便于评判，还是要求排序的，具体看如下说明（3）。

说明：
（1）虽然此题N较大，还是可以一次性将整数数列导入内存的。

（2）此题认为N较大，不适合对所有元素排序后取得“最大的K个数”，
此排序法复杂度O(NlogN)，请你勿用此法，否则将判超时。请选用低于O(NlogN)阶的算法来做。

（3）此题原本是不要求选出的K个数有序，但为了在本OJ（Oline Judge）系统上便于评判，
还是请您以从大至小的不增顺序输出。

输入格式
输入：两行，第一行N和K，第二行为N个无序整数

输出格式
输出：这N个无序整数的最大的K个数

输入样例
20 6
9 1 2 5 3 2 3 4 10 7 1 5 7 6 4 8 9 6 7 5

输出样例
10 9 9 8 7 7

提示

这个问题就是在海量的N个数中求最大的K个数，K<<N。
上课时非常仔细讲解过这个问题，可以用多种方法来求解。
比较好的就是用（1）堆的方法，或（2）快速选择算法。

对算法（1）：

1. 先建一个长度为K的最小堆，存储N个元素的前K个元素，并假设他们就是最大的K个数，建堆费时O(K)；
2. 弹堆顶x，将后续N-K个元素逐个遍历，和堆顶x比较，若比x大，插入并更新堆，若比x小，丢弃；
3. 后续N-K个遍历完后，这个最小堆中的所有元素就是前K大了。将堆顶逐个输出就达到题目的有序输出的要求了。
总耗时最坏：O(K+(N-K)logK) = O(NlogK)，当K较小，接近线性效率，且堆的空间很小(只有K)，非常适合于海量数据查询第K大元素(K<<N)。
此方法得益于在堆中，插入、查找等各项操作时间复杂度均为logK。即使是求第K小，前K小，第K大，前K大也都是同理的。

对算法（2）：

采用快速选择算法，选支点元素时，用随机选择一个支点元素为宜（书上P27的算法），一般情况运行性能都很好。
倒是无须用“中位数的中位数”（P28的算法）做支点元素来完成，当然你想试试也不赖。
第K大元素找到后，做过Partition之后，第K大元素之后段（含第K大）的就是比第K大还大的前K大了。再对前K大排序输出即可。

用第K大做：

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;
const int maxn =  + ;
int myRand(int be, int en) {
    return be + (rand() % (en - be + ));
}
int findKthMin(int a[], int be, int en, int k) {
    if (be == en) return be;
    swap(a[be], a[myRand(be, en)]);
    int one = be, two = en, id = be;
    while (one != two) {
        while (two > one && a[two] >= a[id]) --two; // 找第一个比id小的, 必须先找小的
        while (one < two && a[one] <= a[id]) ++one; // 找第一个比id大的, 因为基准数是be
        if (one < two) swap(a[one], a[two]);
        //需要从右到左是因为，如果是从左到右，例子1、2、3、4、5
        //找到第一个比1大的，是2，然后找不到第一个比1小，在2中相遇
        //然后swap(a[1], a[2])  GG

    }
    swap(a[id], a[one]);
    int hasKey = one - be + ; // 有多少个元素
    if (hasKey >= k) return findKthMin(a, be, one, k);
    else return findKthMin(a, one + , en, k - hasKey);
}
int a[maxn];
void work() {
    int n, k;
    scanf("%d%d", &n, &k);
    for (int i = ; i <= n; ++i) {
        scanf("%d", a + i);
    }
    int id = findKthMin(a, , n, n - k + );
    sort(a + id, a +  + n);
    for (int i = n; i >= id; --i) {
        printf("%d ", a[i]);
    }
}

int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    work();
    return ;
}

用堆做，类似于K打擂算法，首先选K个擂主，然后每次打死一个最小的，那么剩下的优先队列里面的K个元素就是最大的K个了。

复杂度O(Nlogk)空间只需O(k)

#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <queue>
#define IOS ios::sync_with_stdio(false)
using namespace std;
#define inf (0x3f3f3f3f)
typedef long long int LL;
const int maxn =  + ;
int a[maxn];
priority_queue<int, vector<int>, greater<int> > que;
void work() {
    int n, k;
    scanf("%d%d", &n, &k);
    for (int i = ; i <= n; ++i) {
        scanf("%d", a + i);
    }
    for (int i = ; i <= k; ++i) {
        que.push(a[i]);
    }
    for (int i = k + ; i <= n; ++i) {
        int now = que.top();
        if (a[i] > now) {
            que.pop();
            que.push(a[i]);
        }
    }
    for (int i = ; i <= k; ++i) {
        a[i] = que.top();
        que.pop();
    }
    for (int i = k; i >= ; --i) {
        printf("%d ", a[i]);
    }
}

int main() {
#ifdef local
    freopen("data.txt", "r", stdin);
//    freopen("data.txt", "w", stdout);
#endif
    work();
    return ;
}