优先队列

优先队列：顾名思义，首先它是一个队列，但是它强调了“优先”二字，所以，已经不能算是一般意义上的队列了，它的“优先”意指取队首元素时，有一定的选择性，即根据元素的属性选择某一项值最优的出队~

百度百科上这样描述的：

　　优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素

　　优先队列的类定义　　

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

优先队列，其构造及具体实现我们可以先不用深究，我们现在只需要了解其特性，及在做题中的用法，相信，看过之后你会收获不少。

使用优先队列，首先要包函STL头文件"queue"，

以一个例子来解释吧(呃，写完才发现，这个代码包函了几乎所有我们要用到的用法，仔细看看吧)：

view plaincopy to clipboardprint?

/*优先队列的基本使用    2010/7/24    dooder*/  

#include<stdio.h>  

#include<functional>  

#include<queue>  

#include<vector>  

using namespace std;  

//定义结构，使用运算符重载,自定义优先级1  

struct cmp1{  

    bool operator ()(int &a,int &b){  

        return a>b;//最小值优先  

    }  

};  

struct cmp2{  

    bool operator ()(int &a,int &b){  

        return a<b;//最大值优先  

    }  

};  

//定义结构，使用运算符重载,自定义优先级2  

struct number1{  

    int x;  

    bool operator < (const number1 &a) const {  

        return x>a.x;//最小值优先  

    }  

};  

struct number2{  

    int x;  

    bool operator < (const number2 &a) const {  

        return x<a.x;//最大值优先  

    }  

};  

int a[]={14,10,56,7,83,22,36,91,3,47,72,0};  

number1 num1[]={14,10,56,7,83,22,36,91,3,47,72,0};  

number2 num2[]={14,10,56,7,83,22,36,91,3,47,72,0};  

  

int main()  

{   priority_queue<int>que;//采用默认优先级构造队列  

  

    priority_queue<int,vector<int>,cmp1>que1;//最小值优先  

    priority_queue<int,vector<int>,cmp2>que2;//最大值优先  

  

    priority_queue<int,vector<int>,greater<int> >que3;//注意“>>”会被认为错误，  

                                                      //这是右移运算符，所以这里用空格号隔开  

    priority_queue<int,vector<int>,less<int> >que4;最大值优先  

  

    priority_queue<number1>que5;  

    priority_queue<number2>que6;  

  

    int i;  

    for(i=0;a[i];i++){  

        que.push(a[i]);  

        que1.push(a[i]);  

        que2.push(a[i]);  

        que3.push(a[i]);  

        que4.push(a[i]);  

    }  

    for(i=0;num1[i].x;i++)  

        que5.push(num1[i]);  

    for(i=0;num2[i].x;i++)  

        que6.push(num2[i]);  

  

  

    printf("采用默认优先关系:\n(priority_queue<int>que;)\n");  

    printf("Queue 0:\n");  

    while(!que.empty()){  

        printf("%3d",que.top());  

        que.pop();  

    }  

    puts("");  

    puts("");  

  

    printf("采用结构体自定义优先级方式一:\n(priority_queue<int,vector<int>,cmp>que;)\n");  

    printf("Queue 1:\n");  

    while(!que1.empty()){  

        printf("%3d",que1.top());  

        que1.pop();  

    }  

    puts("");  

    printf("Queue 2:\n");  

    while(!que2.empty()){  

        printf("%3d",que2.top());  

        que2.pop();  

    }  

    puts("");  

    puts("");  

    printf("采用头文件\"functional\"内定义优先级:\n(priority_queue<int,vector<int>,greater<int>/less<int> >que;)\n");  

    printf("Queue 3:\n");  

    while(!que3.empty()){  

        printf("%3d",que3.top());  

        que3.pop();  

    }  

    puts("");  

    printf("Queue 4:\n");  

    while(!que4.empty()){  

        printf("%3d",que4.top());  

        que4.pop();  

    }  

    puts("");  

    puts("");  

    printf("采用结构体自定义优先级方式二:\n(priority_queue<number>que)\n");  

    printf("Queue 5:\n");  

    while(!que5.empty()){  

        printf("%3d",que5.top());  

        que5.pop();  

    }  

    puts("");  

    printf("Queue 6:\n");  

    while(!que6.empty()){  

        printf("%3d",que6.top());  

        que6.pop();  

    }  

    puts("");  

    return 0;  

}  

/* 

运行结果 ： 

采用默认优先关系: 

(priority_queue<int>que;) 

Queue 0: 

 91 83 72 56 47 36 22 14 10  7  3 

 

采用结构体自定义优先级方式一: 

(priority_queue<int,vector<int>,cmp>que;) 

Queue 1: 

  3  7 10 14 22 36 47 56 72 83 91 

Queue 2: 

 91 83 72 56 47 36 22 14 10  7  3 

 

采用头文件"functional"内定义优先级: 

(priority_queue<int,vector<int>,greater<int>/less<int> >que;) 

Queue 3: 

  3  7 10 14 22 36 47 56 72 83 91 

Queue 4: 

 91 83 72 56 47 36 22 14 10  7  3 

 

采用结构体自定义优先级方式二: 

(priority_queue<number>que) 

Queue 5: 

  3  7 10 14 22 36 47 56 72 83 91 

Queue 6: 

 91 83 72 56 47 36 22 14 10  7  3 

*/  

运行结果：

采用默认优先关系:

(priority_queue<int>que;)

Queue 0:

 91 83 72 56 47 36 22 14 10  7  3

采用结构体自定义优先级方式一:

(priority_queue<int,vector<int>,cmp>que;)

Queue 1:

  3  7 10 14 22 36 47 56 72 83 91

Queue 2:

 91 83 72 56 47 36 22 14 10  7  3

采用头文件"functional"内定义优先级:

(priority_queue<int,vector<int>,greater<int>/less<int> >que;)

Queue 3:

  3  7 10 14 22 36 47 56 72 83 91

Queue 4:

 91 83 72 56 47 36 22 14 10  7  3

采用结构体自定义优先级方式二:

(priority_queue<number>que)

Queue 5:

  3  7 10 14 22 36 47 56 72 83 91

Queue 6:

 91 83 72 56 47 36 22 14 10  7  3

如果看懂了上面的代码，那么就去找几个优先队列的题目试试手吧

http://acm.sdut.edu.cn/sdutoj/problem.php?action=showproblem&problemid=2168

附上代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std ;
#define LL long long
priority_queue <LL,vector<LL>,greater<LL> > que ;//you xian dui lie an zhao jie gou ti pai xu 
struct node
{
    LL x , y ;
}p[110000];
LL a[11000] , dis[11000] ;
int cmp(node a,node b) {
    return a.x < b.x ;
}
int main() 
{
    int t,n,m;
    LL ans;
    int i,j;
    scanf("%d",&t);
    while(t--) 
	{
        ans = 0;
        scanf("%d %d", &n,&m) ;
        for(i = 0; i < n; i++) 
		{
            scanf("%lld", &a[i]) ;
            if( i ) 
			dis[i] = a[i] - a[i-1];
        }
        for(i = 0 ; i < m ; i++)
            scanf("%lld %lld", &p[i].x, &p[i].y) ;
        sort(dis+1,dis+n);
        sort(p,p+m,cmp);
        while( !que.empty()) 
		que.pop();
        j = m-1;
        for(i = n-1 ; i >= 1 ; i--) 
		{
            while( j >= 0 && p[j].x >= dis[i] ) 
			{
                que.push(p[j].y) ;
                j--;
            }
            if( que.empty() ) break ;
            ans += que.top() ;//每个点都有m种方式即可重复使用，每次队首元素即是单步最优解。 
        }
        if( i >= 1 )
            printf("Impossible\n") ;
        else
            printf("%lld\n", ans) ;
    }
    return 0 ;
}