优先队列简介

优先队列

STL中封装了优先队列（priority_queue）这种结构，它和普通队列的区别是：普通的队列是一种先进先出的数据结构，元素在队列尾部追加，从队列头删除。
而在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出（first in,largest out)的行为特征。

相关定义及操作

类的定义

#include<assert.h>
#include<iostream.h>
#include<stdlib.h>

constintmaxPQSize=50;//缺省元素个数

template<class Type>
class PQueue{
public:
    PQueue();
    ~PQueue()
    {
        delete[]pqelements;
    }
    void PQInsert(const Type& item);
    Type PQRemove();
    void makeEmpty()
    {
        count=0;
    }
    int IsEmpty() const
    {
        returncount==0;
    }
    intIsFull() const
    {
        return count==maxPQSize;
    }
    int Length() const
    {
        return count;
    }
    private:
    Type *pqelements;//存放数组
    int count;//队列元素计数
};

优先队列的头文件是 < queue >

优先队列是0个或多个元素的集合,每个元素都有一个优先权或值,对优先队列执行的操作有
1) 查找;
2) 插入一个新元素;
3) 删除.
在最小优先队列(min priority queue)中,查找操作用来搜索优先权最小的元素,删除操作用来删除该元素;对于最大优先队列(max priority queue),查找操作用来搜索优先权最大的元素,删除操作用来删除该元素.优先权队列中的元素可以有相同的优先权,查找与删除操作可根据任意优先权进行.

优先队列默认有3个参数，第一个是元素类型，第二个是容器类型，第三个是比较算子。其中后两个都可以省略，默认容器是vector,默认算子为less,即大的往前排，小的往后排。

以下几种写法等价

priority_queue<int> q1;
priority_queue<int,vector<int> > q2;
priority_queue<int,vector<int>,less<int> > q3;

可以看到，默认模板有三个参数，第一个是优先队列处理的类，第二个参数比较有特点，是容纳优先队列的容器。实际上，优先队列是由这个容器 + C语言中关于heap的相关操作实现的。这个容器默认是vector，也可以是dequeue，因为后者功能更强大，而性能相对于vector较差，考虑到包装在优先队列后，后者功能并不能很好发挥，所以一般选择vector来做这个容器。第三个参数比较重要，支持一个比较结构，默认是less，默认情况下，会选择第一个参数决定的类的<运算符来做这个比较函数。

所以这里顺序值得注意，第三个参数默认值为less,但是大的在前，所以如果我们想让小的先出，就要进行运算符重载。

class Student
{
    int id;
    char name[20];
    bool gender;
    bool operator < (Student &a) const
    {
        return id > a.id;
    }
};

可以看到id小的最后返回true，也即a.id小的意味着整个类是大的，即排在前面

也可以将第三个默认参数less<> 改为great<> 即”小的在前” 那这样对于一个结构体
我们需要重载>运算符

struct node{
    int x;
    int y;
    node (int xx,int yy){
        x=xx;
        y=yy;
    }
    bool operator > (const node &a) const {//先比较x再比较y
        if(x==a.x) return y>a.y;
        return x>a.x; 
    }
};

查找操作(优先级最高的)

q.top();

插入操作

q.push();

删除操作

q.pop();

例子1（运算符重载实例）

#include<bits/stdc++.h>
using namespace std;

const int maxn=2e5+10;

struct point{
    int t,limit;
}pt[maxn];

//对于优先队列 默认的是若a<b 则b在前面；下面看具体的“逻辑形式”
struct cmp{//运算符重载。 先是limit小的在前面 ; limit一样的 t大的在上面
    bool operator()(const point &a,const point &b){
        if(a.limit==b.limit) return a.t<b.t;
        return a.limit>b.limit;
    }
};

priority_queue<point,vector<point>,cmp> quee;

//也可以这样
//struct point{
//    int t,limit;
//    bool operator < (const point & a) const {
//        if(limit==a.limit) return t<a.t;
//        return limit>a.limit;
//    }
//}pt[maxn];
//priority_queue<point> quee;

int main()
{
    pt[0]=(point){100,3};
    pt[1]=(point){150,4};
    pt[2]=(point){80,4};
    pt[3]=(point){90,2};
    pt[4]=(point){300,2};
    for(int i=0;i<5;++i){
        quee.push(pt[i]);
    }
    //下面打印
    while(!quee.empty())
    {
        point tmp=quee.top();
        cout<<tmp.t<<' '<<tmp.limit<<endl;
        quee.pop();
    }
    return 0;
}

例子2（优化迪杰斯特拉算法）

int cost[MAX_V][MAX_V];
int d[MAX_V], V, s;
//自定义优先队列less比较函数
struct cmp
{
    bool operator()(int &a, int &b) const
    {
        //因为优先出列判定为!cmp，所以反向定义实现最小值优先
        return d[a] > d[b];
    }
};
void Dijkstra()
{
    std::priority_queue<int, std::vector<int>, cmp> pq;
    pq.push(s);
    d[s] = 0;
    while (!pq.empty())
    {
        int tmp = pq.top();pq.pop();
        for (int i = 0;i < V;++i)
        {
            if (d[i] > d[tmp] + cost[tmp][i])
            {
                d[i] = d[tmp] + cost[tmp][i];
                pq.push(i);
            }
        }
    }
}

例题 POJ 1502

//求v1到其他点最短路径中longest path
//优先队列优化O(Mlog(N))
#include<iostream>
#include<string.h>
#include<cstdio>
#include<stdlib.h>
#include<queue>
using namespace std;
#define mp make_pair

typedef pair<int,int> node;
const int maxn=1000,inf=0x3f3f3f3f;

vector<node> G[maxn];//first 点的编号 second 距离

void addEdge(int u,int v,int w){
    G[u].push_back(mp(v,w));
    G[v].push_back(mp(u,w));
}

int dis[maxn];//记录从源点到某一点的最短距离
int n;//点数
int ans;

void dijkstra(int s)
{
    priority_queue<node,vector<node>,greater<node> > que;//小根堆 默认比较first
    //first存起点到该点最短距离 second是点的编号
    for(int i=1;i<=n;++i) dis[i]=inf;
    dis[s]=0;
    que.push(mp(0,s));//起点
    while(!que.empty())
    {
        node p=que.top();que.pop();
        int v=p.second;//顶点的编号
        if(dis[v]<p.first) continue;
        //否则更新
        ans=max(ans,p.first);
        for(int i=0;i<G[v].size();++i){//松弛
            node e=G[v][i];
            if(dis[v]+e.second<dis[e.first]){
                dis[e.first]=dis[v]+e.second;
                que.push(mp(dis[e.first],e.first));
            }
        }
    }
}

int main()
{
    //ios::sync_with_stdio(false);
    string s;
    s.resize(10);
    scanf("%d",&n);
    ans=-inf;
    for(int i=2;i<=n;++i){
        for(int j=1;j<i;++j){
            scanf("%s",&s[0]);
            //printf("%s\n",s.c_str());
            if(s[0]=='x') continue;
            else addEdge(i,j,atoi(s.c_str()));
        }
    }
    dijkstra(1);
    printf("%d\n",ans);
    return 0;
}