堆是一棵完全二叉树，可以O(1)取最值，O(logn)删除最值，或插入元素。

堆的性质：每个非叶子节点比它的孩子都大（大根堆/大顶堆）/每个非叶子节点比它的孩子都小（小根堆/小顶堆）。

从上面的性质可以推出堆的根就是最值。

堆的常用操作：top返回堆顶，pop弹出堆顶，push压入新元素。

后两个操作时间是O(logn)，因为弹出或压入后都要调整堆的结构，而调整的次数不超过堆的深度。

然而堆是完全二叉树，深度不超过O(logn)，因此pop和push都是O(logn)的。

接下来是手写堆的代码：

//完全二叉树的保存方式：//根：1//节点i的左儿子i*2，右儿子i*2+1#include
     
      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]
      
       <<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
     
      using namespace std;int n,tot;priority_queue
      
       
        ,greater
        
          > 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
     
      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
      
       
        ,greater
        
          > 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
     
      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
      
       
        ,greater
        
          > 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
     
      using namespace std;int a[200001],u[200001];int n,m;priority_queue
      
       
        ,less
        
          > q1;priority_queue
         
          
           ,greater
           
             > 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]
            
             k){ q2.push(q1.top()); q1.pop(); sz--; } printf("%d\n",q1.top()); k++; } } return 0;}
            
           
          
         
        
       
      
     

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

end