数据结构--堆

堆是一棵完全二叉树,可以O(1)取最值,O(logn)删除最值,或插入元素。
堆的性质:每个非叶子节点比它的孩子都大(大根堆/大顶堆)/每个非叶子节点比它的孩子都小(小根堆/小顶堆)。
从上面的性质可以推出堆的根就是最值。
堆的常用操作:top返回堆顶,pop弹出堆顶,push压入新元素。
后两个操作时间是O(logn),因为弹出或压入后都要调整堆的结构,而调整的次数不超过堆的深度。
然而堆是完全二叉树,深度不超过O(logn),因此pop和push都是O(logn)的。
接下来是手写堆的代码:

//完全二叉树的保存方式:
//根:1
//节点i的左儿子i*2,右儿子i*2+1
#include<bits/stdc++.h>
using namespace std;
int n,tot;
int t[1000001];
void push(int x){
    tot++;
    t[tot]=x;
    int u=tot;
    while(t[u>>1]>t[u]){
        swap(t[u>>1],t[u]);
        u>>=1;
    }
}
void pop(){
    if(tot==0){
        return;
    }
    swap(t[1],t[tot]);
    tot--;
    int u=1;
    while(((u<<1<=tot)&&(t[u]>t[u<<1]))||(((u<<1)+1<=tot)&&(t[u]>t[(u<<1)+1]))){
        if((u<<1)+1>tot){
            swap(t[u],t[u<<1]);
            break;
        }
        if(t[u<<1]<t[(u<<1)+1]){
            swap(t[u],t[u<<1]);
            u<<=1;
        }
        else{
            swap(t[u],t[(u<<1)+1]);
            u<<=1;
            u++;
        }
    }
}
int top(){
    return t[1];
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int num;
        scanf("%d",&num);
        if(num==1){
            int x;
            scanf("%d",&x);
            push(x);
        }
        else if(num==2){
            printf("%d\n",top());
        }
        else{
            pop();
        }
    }
    return 0;
}

然后其实在竞赛中更常用的是系统自带堆——优先队列priority_queue,很方便,就是慢了一倍左右。

关于优先队列的使用方法:
priority_queue< T > (T为类型)(后面括号内为时间复杂度)
1. T top(void):返回堆顶(即最值);(1)
2. void pop(void):弹出堆顶;(logn)
3. void push(T):压入新元素;(logn)
4. bool empty(void):如果堆为空返回true,否则返回false;(1)
5. int size(void):返回堆的元素数量;(1)
另一种定义方式:(建议)
priority_queue< T , vector< T > ,less< T > > (大根堆)
priority_queue< T , vector< T > ,greater< T > > (小根堆)
用自定义类型的前提是那个类型有定义小于号(大根堆)/ 大于号(小根堆)

我这里给出优先队列的使用代码:

#include<bits/stdc++.h>
using namespace std;
int n,tot;
priority_queue<int,vector<int>,greater<int> > q;
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        int num;
        scanf("%d",&num);
        if(num==1){
            int x;
            scanf("%d",&x);
            q.push(x);
        }
        else if(num==2){
            printf("%d\n",q.top());
        }
        else{
            if(!q.empty())
            q.pop();
        }
    }
    return 0;
}

具体时间差就是:
手写堆828ms
优先队列1677ms


到这里,堆的初步介绍就结束了。
接下来最重要的还是题。

洛谷 P3378 【模板】堆

写完堆先交这个题,确保时间不超1000ms就基本合格。

洛谷 P1090 合并果子

这个题其实本身很简单,每次取两堆最小的合并再放入,重复到只剩一堆。
我想把这个题放在这儿的目的就是要说这种思想很重要,就是放入再取出的思想。
有时候这种思想可以使你的操作变得可以撤销,可以过好多题。
有一次我和@hzy一起去培训的时候就碰到了这么一个题,他想出来了,可是没时间写了,错失了100分,最后就让我这么一个只会暴力的拿了第一(笑)。

洛谷 P2085 最小函数值

这是堆的一个经典应用:求若干个单调序列中的第m小(大)
这题我们可以将每个函数看成一个单调上升的序列,这样最小值一定在某个队首,取出最小值后次小值就一定还在某个队首,这样,我们就可以一开始将所有队首放入堆中,然后每次取出某个值后,再将它的序列中的下一个值放入堆中;如此重复m次就可以得到第m小。
贴代码:

#include<bits/stdc++.h>
using namespace std;
struct func{
    int a,b,c,x,v;
    void calc(){
        v=a*x*x+b*x+c;
    }
    bool operator > (const func& y) const {
        return v>y.v;
    }
}f[10001];
int n,m;
priority_queue<func,vector<func>,greater<func> > q;

int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d %d %d",&f[i].a,&f[i].b,&f[i].c);
        f[i].x=1;
        f[i].calc();
        q.push(f[i]);
    }
    for(int i=1;i<=m;i++){
        func g=q.top();
        q.pop();
        printf("%d ",g.v);
        g.x++;
        g.calc();
        q.push(g);
    }
    return 0;
}

洛谷 P1631 序列合并

这题和上面那个本质上一样,排序后,将A序列中一个值和B序列中所有值的配对看做一个单调上升序列,像上面那样做就好了。
代码:

#include<bits/stdc++.h>
using namespace std;
int A[100001],B[100001];
struct func{
    int a,b;
    bool operator > (const func& y) const {
        return A[a]+B[b]>A[y.a]+B[y.b];
    }
}f[10001];
int n;
priority_queue<func,vector<func>,greater<func> > q;

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%d",&A[i]);
    }
    for(int i=1;i<=n;i++){
        scanf("%d",&B[i]);
    }
    sort(A+1,A+n+1);
    sort(B+1,B+n+1);
    for(int i=1;i<=n;i++){
        func g;
        g.a=i;
        g.b=1;
        q.push(g);
    }
    for(int i=1;i<=n;i++){
        func g=q.top();
        q.pop();
        printf("%d ",A[g.a]+B[g.b]);
        g.b++;
        if(g.b<=n)
        q.push(g);
    }
    return 0;
}

洛谷 P1801 黑匣子_NOI导刊2010提高(06)

这题虽然算是一个平衡树模板,可是也是一道堆的进阶题目,难度达到了提高+/省选-;
这个题中我们要开两个堆,一个大顶堆q1,一个小顶堆q2,大顶堆的顶部对着小顶堆的顶部(q1.top()<q2.top()),每次压入一个新元素的时候都要判断往哪边压,让其始终保持这个性质。
此时这两个堆合在一起被称为对顶堆。
我们还要记录一个变量size来记录q1的大小;每次GET的时候,如果size < i,就一直将q2的顶部压入q1;
如果size > i,就一直将q1的顶部压入q2;直到size==i之后q1的顶部就是查询结果。
代码不难写出:

#include<bits/stdc++.h>
using namespace std;
int a[200001],u[200001];
int n,m;
priority_queue<int,vector<int>,less<int> > q1;
priority_queue<int,vector<int>,greater<int> > q2;
int main(){
    scanf("%d %d",&n,&m);
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=1;i<=m;i++){
        scanf("%d",&u[i]);
    }
    sort(u+1,u+m+1);
    int k=1;
    int sz=0;
    for(int i=1;k<=m;i++){
        if(q2.empty()||a[i]<q2.top()){
            q1.push(a[i]);
            sz++;
        }
        else{
            q2.push(a[i]);
        }
        while(i==u[k]){
            while(sz<k){
                q1.push(q2.top());
                q2.pop();
                sz++;
            }
            while(sz>k){
                q2.push(q1.top());
                q1.pop();
                sz--;
            }
            printf("%d\n",q1.top());
            k++;
        }
    }
    return 0;
}

题目我就放这么多,关键还是要能想到用堆,数据结构对比赛只是辅助。
end

posted @ 2017-08-09 00:40  玫葵之蝶  阅读(140)  评论(0编辑  收藏  举报