Loading

二叉堆初探

一、二叉堆基础

1. 二叉堆是什么?

二叉堆就是一棵完全二叉树。

什么是完全二叉树?定义d为树的深度,则一棵完全二叉树的前(d-1)层是满的,而第d层的节点从右往左有若干连续缺失。

并且二叉堆有优先级,有的二叉堆每一个父亲都比他的儿子小,称为小根堆;反之称为大根堆。

这样说比较抽象,放一张小根堆的图:

2. 如何存储一个二叉堆?

主要有两种存储方法。

第一种是链表存储,记录左儿子右儿子,父亲与值;

int root=1;//堆顶
int siz;//堆的大小
struct Tree
{
    int ls,rs,fa,val;
}tree[100010];

第二种是用数组存储,开两倍空间,乘2表示左儿子,乘2加1表示右儿子,除以2下取整表示父亲。这种表示方式较为方便。

int siz;//堆的大小
int tree[200020];//tree[1]即为堆顶

之后都用这种写法。堆也默认为小根堆。

3. 二叉堆的操作

注:接下来的实现代码都是实现小根堆的

1. 最基础的操作

就不用说了。时间复杂度\(O(1)\)

inline int top(){return tree[1];}
inline int size(){return siz;}
inline bool empty(){return siz==0;}
2. 堆的插入

在堆底插入,再依次与其父亲作比较,选择是否交换。时间复杂度\(O(\log n)\)

举个例子:向刚刚的小根堆插入数字2。

首先我们在堆底插入2:

2<5,交换:

2<3,交换:

2>1,不能再交换了。

inline void push(int xx)
{
    tree[++siz]=xx;
    int now=siz;
    while(now!=1)
    {
        int nxt=now>>1;
        if(tree[nxt]>tree[now])swap(tree[nxt],tree[now]);
        else break;
        now=nxt;
    }
    return;
}
3. 堆的删除

删除别的元素是没有意义的,故我们只讨论删除堆顶的情况。
先将堆顶堆底交换,删掉堆底,再将堆顶向下判断和哪一个孩子交换。时间复杂度\(O(\log n)\)

还是刚才的例子:我们要删除堆顶1。首先将堆顶堆底交换:

然后把堆底删掉:

接下来我们来进行调整,以保持堆的性质。两个儿子中2更小,故与2交换:

3更小,故与3交换:

5<9,无需再交换了。

inline void pop()
{
    swap(tree[siz--],tree[1]);
    int now=1;
    while((now<<1)<=siz)
    {
        int nxt=now<<1;
        if(nxt+1<=siz&&tree[nxt+1]<tree[nxt])nxt++;
        if(tree[nxt]<tree[now])swap(tree[now],tree[nxt]);
        else break;
        now=nxt;
    }
    return;
}
4. 模板

模板题在这里

#include <iostream>
#include <cstdio>
using namespace std; 
int n,opt,x;
//------------模板开始-------------
int siz,tree[2000020];
inline int top(){return tree[1];}
inline int size(){return siz;}
inline bool empty(){return siz==0;}
inline void push(int xx)
{
    tree[++siz]=xx;
    int now=siz;
    while(now!=1)
    {
        int nxt=now>>1;
        if(tree[nxt]>tree[now])swap(tree[nxt],tree[now]);
        else break;
        now=nxt;
    }
    return;
}
inline void pop()
{
    swap(tree[siz--],tree[1]);
    int now=1;
    while((now<<1)<=siz)
    {
        int nxt=now<<1;
        if(nxt+1<=siz&&tree[nxt+1]<tree[nxt])nxt++;
        if(tree[nxt]<tree[now])swap(tree[now],tree[nxt]);
        else break;
        now=nxt;
    }
    return;
}
//------------模板结束-------------
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&opt);
		switch(opt)
		{
			case 1:
			{
				scanf("%d",&x);
				push(x);
				break;
			}
			case 2:printf("%d\n",top());break;
			case 3:pop();break;
		}
	}
	return 0;
}

4. 简单应用

1. 合并果子

这道题
简单的堆优化贪心。

#include <iostream>
#include <cstdio>
using namespace std;
int n,x,y,cnt;
//------------模板开始-------------
int siz,tree[200020];
inline int top(){return tree[1];}
inline int size(){return siz;}
inline bool empty(){return siz==0;}
inline void push(int xx)
{
    tree[++siz]=xx;
    int now=siz;
    while(now>1)
    {
        int nxt=now>>1;
        if(tree[nxt]>tree[now])swap(tree[nxt],tree[now]);
        else break;
        now=nxt;
    }
    return;
}
inline void pop()
{
    swap(tree[siz--],tree[1]);
    int now=1;
    while((now<<1)<=siz)
    {
        int nxt=now<<1;
        if(nxt+1<=siz&&tree[nxt+1]<tree[nxt])nxt++;
        if(tree[nxt]<tree[now])swap(tree[now],tree[nxt]);
        else break;
        now=nxt;
    }
    return;
}
//------------模板结束-------------
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&x);
        push(x);
    }
    for(int i=1;i<=n-1;i++)
    {
        x=top();
        pop();
        y=top();
        pop();
        cnt+=x+y;
        push(x+y);
    }
    printf("%d\n",cnt);
    return 0;
}
2. 堆排序

就是把所有的元素都放到堆里,再一个个取出。可以试试这道题

#include <iostream>
#include <cstdio>
using namespace std; 
int n,x;
//------------模板开始-------------
int siz,tree[200020];
inline int top(){return tree[1];}
inline int size(){return siz;}
inline bool empty(){return siz==0;}
inline void push(int xx)
{
    tree[++siz]=xx;
    int now=siz;
    while(now!=1)
    {
        int nxt=now>>1;
        if(tree[nxt]>tree[now])swap(tree[nxt],tree[now]);
        else break;
        now=nxt;
    }
    return;
}
inline void pop()
{
    swap(tree[siz--],tree[1]);
    int now=1;
    while((now<<1)<=siz)
    {
        int nxt=now<<1;
        if(nxt+1<=siz&&tree[nxt+1]<tree[nxt])nxt++;
        if(tree[nxt]<tree[now])swap(tree[now],tree[nxt]);
        else break;
        now=nxt;
    }
    return;
}
//------------模板结束-------------
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&x);
		push(x);
	}
	for(int i=1;i<=n;i++)
	{
		printf("%d ",top());
		pop();
	}
	return 0;
}

上面三道题的复杂度都是\(O(n\log n)\)

二、更多应用

1. STL priority_queue

在讲题目之前,先介绍一下STL中的优先队列。

优先队列其实就是堆……但只支持插入,删除堆顶等基础操作。

我们可以这样来定义一个大根堆:

#include <queue>//头文件
priority_queue<int> q;

小根堆麻烦一些:

#include <queue>
#include <vector>
#include <functional>
priority_queue<int,vector<int>,greater<int> > q;

对于结构体重载运算符即可。

#include <queue>
struct node{int x,y;};
bool operator <(node xx,node yy)
{
      if(xx.x!=yy.x)return xx.x<yy.x;
      return xx.y<yy.y;
}
priority_queue<node> q;

这是大根堆,小根堆只需改成这样:

#include <queue>
struct node{int x,y;};
bool operator <(node xx,node yy)
{
      if(xx.x!=yy.x)return xx.x>yy.x;
      return xx.y>yy.y;
}
priority_queue<node> q;

然后是一些基础操作:

q.push(x)//插入x
q.top()//返回堆顶
q.pop()//删除堆顶
q.empty()//是否为空
q.size()//元素个数

于是合并果子那题可以这样写:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
int n,x,y,ans;
priority_queue<int,vector<int>,greater<int> >q;
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&x);
		q.push(x);
	}
	for(int i=1;i<n;i++) 
	{
		x=q.top();q.pop();
		y=q.top();q.pop();
		ans+=x+y;
		q.push(x+y);
	}
	printf("%d\n",ans);
	return 0;
}

简洁了许多呢(笑

2. 比较复杂的模拟

舞蹈课 这道

不难想到,我们可以用堆来维护当前差距最小的一对舞者的编号。
当然你会发现一对舞者出列最多会导致两队舞者的组合被打破……
不过用一个danced数组来标记一下就行了(
那出列不还可能会多构造出一对舞者吗?
数据结构带师:套一个链表
然而我并不会懒得写,于是选择直接暴力跳
暴力跳的复杂度好像也不会炸。。。然而我不会证明>_<
u1s1这题奇怪的细节还是有的,并且数据不给下载,一出错直接爆0。。。
更多细节见代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <vector>
using namespace std;
string s;
int n,cnt,a[200010];
bool danced[200010];
struct node{int x,y;};
bool operator<(node p1,node p2)//重载运算符,里面的符号是反的是因为小根堆
{
    if(abs(a[p1.x]-a[p1.y])!=abs(a[p2.x]-a[p2.y]))return abs(a[p1.x]-a[p1.y])>abs(a[p2.x]-a[p2.y]);
    else return p1.x>p2.x;
}
priority_queue<node> q;
vector<node> ans;
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);cout.tie(0);
    cin >> n >> s;
    for(int i=0;i<n;i++)cin >> a[i];//因为string是从0开始于是就这样偷懒了(
    for(int i=1;i<s.length();i++)
        if(s[i-1]!=s[i])
            q.push((node){i-1,i});
    while(1)
    {
        while(!q.empty()&&(danced[q.top().x]||danced[q.top().y]))//如果这一对中有人danced那么直接扔掉
            q.pop();
        if(q.empty())break;//判空(防止死循环
        cnt++;//步数增加
        ans.push_back(q.top());//答案更新
        danced[q.top().x]=danced[q.top().y]=1;//标记
        int l=q.top().x,r=q.top().y;//暴力跳指针
        q.pop();//一定要记得这个时候把堆顶扔掉,要不然之后压进来又弹出去统计了个寂寞(
        while(l>=0&&danced[l])l--;//暴力跳左指针
        while(r<n&&danced[r])r++;//暴力跳右指针
        if(l>=0&&r<n&&!danced[l]&&!danced[r]&&s[l]!=s[r])q.push((node){l,r});//判断,决定是否插入
    }
    cout << cnt << endl;
    for(int i=0;i<cnt;i++)
        cout << ans[i].x+1 << ' ' << ans[i].y+1 << endl;
    return 0;
}

3. 对顶堆

黑匣子 这道

对顶堆其实就是一个小根堆倒着摞在一个大根堆上(
那这样子的话我们可以发现就整体来看元素从下往上是大致递增的

放图:

当然也可以倒着来理解,没有差别

对顶堆中两个堆的堆顶一般用来存储特殊数据。(对于这道题来说就是第i小)
插入的时候与堆顶作比较决定插入哪个堆里,然后再调整一次两个堆来让堆顶满足查询条件。
这样的话两个堆的大小差就会始终保持在正负1以内。
图就不放了(懒

一般来说每次的查询位置变动不大,这样我们才能保证对顶堆的时间复杂度正确。(也就是平衡操作的时间复杂度为\(O(1)\)
接下来就是详细注释的代码了……

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <queue>
#include <vector>
#include <functional>
using namespace std;
int m,n,now=1,pointer,a[200010],u[200010];
//pointer就是题目中的i……当然也可以用循环变量代替,这里它的存在就显得多余了
priority_queue<int> q1;
priority_queue<int,vector<int>,greater<int> >q2;
int main()
{
    scanf("%d%d",&m,&n);
    for(int i=1;i<=m;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++)scanf("%d",&u[i]);
    for(int i=1;i<=n;i++)
    {
        pointer++;
        if(!q1.empty()&&!q2.empty()&&q1.size()<pointer)//因为pointer自增了,这里要维护一次平衡
        {
            q1.push(q2.top());
            q2.pop();
        }
        if(!q1.empty()&&!q2.empty()&&q1.size()>pointer)
        {
            q2.push(q1.top());
            q1.pop();
        }
        for(;now<=u[i];now++)
        {
            if(!q1.empty()&&a[now]>=q1.top())q2.push(a[now]);//与堆顶比较来决定插入哪个堆中
            else q1.push(a[now]);
            if(q1.size()<pointer){q1.push(q2.top());q2.pop();}
            if(q1.size()>pointer){q2.push(q1.top());q1.pop();}//维护平衡
        }
        printf("%d\n",q1.top());
    }
    return 0;
}

相信您做完这题后就能轻松AC这道了qwq

u1s1对顶堆真的不难,我也不知道为什么这几道题评分这么高(

posted @ 2019-07-06 20:26  pjykk  阅读(164)  评论(0编辑  收藏  举报