优先队列用法

最新推荐文章于 2020-12-28 22:58:34 发布
最新推荐文章于 2020-12-28 22:58:34 发布
阅读量764 收藏
点赞数
文章标签： struct list ini 数据结构 class include

 

http://blog.csdn.net/dooder_daodao/article/details/5761550

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

百度百科上这样描述的：

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

　　优先队列的类定义

　　#include <assert.h>

　　#include <iostream.h>

　　$include <stdlib.h>

　　const int maxPQSize = 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

　　{ return count == 0; }

　　int IsFull ( ) const

　　{ return count == maxPQSize; }

　　int Length ( ) const { return count; }

　　private:

　　Type *pqelements; //存放数组

　　int count; //队列元素计数

　　}

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

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

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

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

[c-sharp] view plain copy print ?
  1. /*优先队列的基本使用    2010/7/24    dooder*/ 
  2. #include<stdio.h> 
  3. #include<functional> 
  4. #include<queue> 
  5. #include<vector> 
  6. using namespace std; 
  7. //定义结构，使用运算符重载,自定义优先级1 
  8. struct cmp1{ 
  9.     bool operator ()(int &a,int &b){ 
  10.         return a>b;//最小值优先 
  11.     } 
  12. }; 
  13. struct cmp2{ 
  14.     bool operator ()(int &a,int &b){ 
  15.         return a<b;//最大值优先 
  16.     } 
  17. }; 
  18. //定义结构，使用运算符重载,自定义优先级2 
  19. struct number1{ 
  20.     int x; 
  21.     bool operator < (const number1 &a) const { 
  22.         return x>a.x;//最小值优先 
  23.     } 
  24. }; 
  25. struct number2{ 
  26.     int x; 
  27.     bool operator < (const number2 &a) const { 
  28.         return x<a.x;//最大值优先 
  29.     } 
  30. }; 
  31. int a[]={14,10,56,7,83,22,36,91,3,47,72,0}; 
  32. number1 num1[]={14,10,56,7,83,22,36,91,3,47,72,0}; 
  33. number2 num2[]={14,10,56,7,83,22,36,91,3,47,72,0}; 
  34.  
  35. int main() 
  36. {   priority_queue<int>que;//采用默认优先级构造队列 
  37.  
  38.     priority_queue<int,vector<int>,cmp1>que1;//最小值优先 
  39.     priority_queue<int,vector<int>,cmp2>que2;//最大值优先 
  40.  
  41.     priority_queue<int,vector<int>,greater<int> >que3;//注意“>>”会被认为错误， 
  42.                                                       //这是右移运算符，所以这里用空格号隔开 
  43.     priority_queue<int,vector<int>,less<int> >que4;最大值优先 
  44.  
  45.     priority_queue<number1>que5; 
  46.     priority_queue<number2>que6; 
  47.  
  48.     int i; 
  49.     for(i=0;a[i];i++){ 
  50.         que.push(a[i]); 
  51.         que1.push(a[i]); 
  52.         que2.push(a[i]); 
  53.         que3.push(a[i]); 
  54.         que4.push(a[i]); 
  55.     } 
  56.     for(i=0;num1[i].x;i++) 
  57.         que5.push(num1[i]); 
  58.     for(i=0;num2[i].x;i++) 
  59.         que6.push(num2[i]); 
  60.  
  61.  
  62.     printf("采用默认优先关系:/n(priority_queue<int>que;)/n"); 
  63.     printf("Queue 0:/n"); 
  64.     while(!que.empty()){ 
  65.         printf("%3d",que.top()); 
  66.         que.pop(); 
  67.     } 
  68.     puts(""); 
  69.     puts(""); 
  70.  
  71.     printf("采用结构体自定义优先级方式一:/n(priority_queue<int,vector<int>,cmp>que;)/n"); 
  72.     printf("Queue 1:/n"); 
  73.     while(!que1.empty()){ 
  74.         printf("%3d",que1.top()); 
  75.         que1.pop(); 
  76.     } 
  77.     puts(""); 
  78.     printf("Queue 2:/n"); 
  79.     while(!que2.empty()){ 
  80.         printf("%3d",que2.top()); 
  81.         que2.pop(); 
  82.     } 
  83.     puts(""); 
  84.     puts(""); 
  85.     printf("采用头文件/"functional/"内定义优先级:/n(priority_queue<int,vector<int>,greater<int>/less<int> >que;)/n"); 
  86.     printf("Queue 3:/n"); 
  87.     while(!que3.empty()){ 
  88.         printf("%3d",que3.top()); 
  89.         que3.pop(); 
  90.     } 
  91.     puts(""); 
  92.     printf("Queue 4:/n"); 
  93.     while(!que4.empty()){ 
  94.         printf("%3d",que4.top()); 
  95.         que4.pop(); 
  96.     } 
  97.     puts(""); 
  98.     puts(""); 
  99.     printf("采用结构体自定义优先级方式二:/n(priority_queue<number>que)/n"); 
  100.     printf("Queue 5:/n"); 
  101.     while(!que5.empty()){ 
  102.         printf("%3d",que5.top()); 
  103.         que5.pop(); 
  104.     } 
  105.     puts(""); 
  106.     printf("Queue 6:/n"); 
  107.     while(!que6.empty()){ 
  108.         printf("%3d",que6.top()); 
  109.         que6.pop(); 
  110.     } 
  111.     puts(""); 
  112.     return 0; 
  113. } 
  114. /*
  115. 运行结果 ：
  116. 采用默认优先关系:
  117. (priority_queue<int>que;)
  118. Queue 0:
  119. 91 83 72 56 47 36 22 14 10  7  3
  121. 采用结构体自定义优先级方式一:
  122. (priority_queue<int,vector<int>,cmp>que;)
  123. Queue 1:
  124.   3  7 10 14 22 36 47 56 72 83 91
  125. Queue 2:
  126. 91 83 72 56 47 36 22 14 10  7  3
  128. 采用头文件"functional"内定义优先级:
  129. (priority_queue<int,vector<int>,greater<int>/less<int> >que;)
  130. Queue 3:
  131.   3  7 10 14 22 36 47 56 72 83 91
  132. Queue 4:
  133. 91 83 72 56 47 36 22 14 10  7  3
  135. 采用结构体自定义优先级方式二:
  136. (priority_queue<number>que)
  137. Queue 5:
  138.   3  7 10 14 22 36 47 56 72 83 91
  139. Queue 6:
  140. 91 83 72 56 47 36 22 14 10  7  3
  141. */ 

运行结果：

采用默认优先关系:
(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

好了，如果你仔细看完了上面的代码，那么你就可以基本使用优先队列了，下面给出一些我做题中有过的一些应用，希望能给大家带来一些启

示~

1、先来一个我们最近做的题吧，http://acm.hdu.edu.cn/showproblem.php?pid=1242

题意：某人被关在囚笼里等待朋友解救，问能否解救成功，最少需要多少时间~

具体：可同时有几个朋友，每走一格消耗一分钟的时间 ，地图上还存在着卫兵，卫兵可以解决掉，但是要另外花费一分钟~

分析：从“a”出发，此题可以用回溯法进行深搜，但那样做的话，效率还是不能让人满意，但是广搜的话，由于入队后每次出队时，根据地

图情况的不同，出队元素所记忆的时间并不是层次递增的，因此使用简单广搜的话，同样需要全部搜索才能找到正确答案。有没有一种方法能

让某一步因为遇到士兵而多花时间的结点在队列中向后推迟一层出队呢？答案是肯定的，在这里我们可以用优先队列来实现，总体思想上是，

根据时间进行优先性选择，每次都要出队当前队列元素中记录时间最少的出队，而入队处理时，我们可以按顺序对四个方向上的各种情况按正

常处理入队就行了，出队顺序由优先队列根据预设优先性自动控制。这样，我们就可以从“a”进行基于优先队列的范围搜索了，并且在第一

次抵达有朋友的位置时得到正确结果~具体实现代码：

[cpp] view plain copy print ?
  1. /*HDU 1242  基于优先队列的范围搜索，16ms   dooder*/ 
  2.  
  3. #include<stdio.h> 
  4. #include<queue> 
  5. using namespace std; 
  6.  
  7. #define M 201 
  8. typedef struct p{ 
  9.     int x,y,t; 
  10.     bool operator < (const p &a)const 
  11.     { 
  12.         return t>a.t;//取时间最少优先 
  13.     } 
  14. }Point; 
  15.  
  16. char map[M][M]; 
  17. Point start; 
  18. int n,m; 
  19. int dir[][2]={{1,0},{-1,0},{0,1},{0,-1}}; 
  20.  
  21. int bfs() 
  22. { 
  23.     priority_queue<Point>que; 
  24.     Point cur,next; 
  25.     int i; 
  26.  
  27.     map[start.x][start.y]='#'; 
  28.     que.push(start); 
  29.     while(!que.empty()){ 
  30.         cur=que.top();//由优先队列自动完成出队时间最少的元素 
  31.         que.pop(); 
  32.         for(i=0;i<4;i++){ 
  33.             next.x=cur.x+dir[i][0]; 
  34.             next.y=cur.y+dir[i][1]; 
  35.             next.t=cur.t+1; 
  36.             if(next.x<0||next.x>=n||next.y<0||next.y>=m) 
  37.                 continue; 
  38.             if(map[next.x][next.y]=='#') 
  39.                 continue; 
  40.             if(map[next.x][next.y]=='r') 
  41.                 return next.t; 
  42.             if(map[next.x][next.y]=='.'){ 
  43.                 map[next.x][next.y]='#'; 
  44.                 que.push(next); 
  45.             } 
  46.             else if(map[next.x][next.y]=='x'){ 
  47.                 map[next.x][next.y]='#'; 
  48.                 next.t++; 
  49.                 que.push(next); 
  50.             } 
  51.         } 
  52.     } 
  53.     return -1; 
  54. } 
  55. int main() 
  56. { 
  57.     int i,ans; 
  58.     char *p; 
  59.     while(scanf("%d%d",&n,&m)!=-1){ 
  60.         for(i=0;i<n;i++){ 
  61.             scanf("%s",map[i]); 
  62.             if(p=strchr(map[i],'a')){ 
  63.                 start.x=i; 
  64.                 start.y=p-map[i]; 
  65.                 start.t=0; 
  66.             } 
  67.         } 
  68.         ans=bfs(); 
  69.         printf(ans+1?"%d/n":"Poor ANGEL has to stay in the prison all his life./n",ans); 
  70.     } 
  71.     return 0; 
  72. } 

2、http://acm.hdu.edu.cn/showproblem.php?pid=1053

题意：给出一行字符串，求出其原编码需要的编码长度和哈夫曼编码所需的长度，并求其比值

分析：根据哈夫曼生成树的生成过程可知，其生成树的权值是固定的而且这个值是最小的，而且其值根据生成树的顺序，我们可以找出规律而

不需要真的去生成一棵树然后再求出权值，其模拟过程为取出队列中权值最小的两个元素，将其值加入结果中，然后将这两个元素的权值求和

即得出其父节点的权值，将生成元素作为结点入队~~如此循环，直至取出队列中最后两个元素加入结果，实现代码如下：

[cpp] view plain copy print ?
  1. /*HDU 1053  采用广搜求哈夫曼生成树的权值 0ms   dooder*/ 
  2. #include<stdio.h> 
  3. #include<string.h> 
  4. #include<ctype.h> 
  5. #include<functional> 
  6. #include<queue> 
  7. using namespace std; 
  8. #define M 1000050 
  9. char str[M]; 
  10. int list[27]; 
  11.  
  12. priority_queue< int,vector<int>,greater<int> >que; 
  13.  
  14. int main() 
  15. { 
  16.     int ans,sum; 
  17.     int i,a,b,c; 
  18.     while(scanf("%s",str),strcmp(str,"END")){ 
  19.         memset(list,0,sizeof(list)); 
  20.         for(i=0;str[i];i++){ 
  21.             if(isalpha(str[i])) 
  22.                 list[str[i]-'A']++; 
  23.             else 
  24.                 list[26]++; 
  25.         } 
  26.         sum=i*8;ans=i;c=0; 
  27.         for(i=0;i<27;i++){ 
  28.             if(list[i]){ 
  29.                 que.push(list[i]); 
  30.                 c++; 
  31.             } 
  32.         }        
  33.         if(c>1){ans=0;//注意只有一种字符的情况 
  34.             while(que.size()!=1){ 
  35.                 a=que.top(); 
  36.                 que.pop(); 
  37.                 b=que.top(); 
  38.                 que.pop(); 
  39.                 ans+=a+b; 
  40.                 que.push(a+b); 
  41.             } 
  42.             while(!que.empty())//使用后清空队列 
  43.                 que.pop(); 
  44.         } 
  45.         printf("%d %d %.1f/n",sum,ans,1.0*sum/ans); 
  46.     } 
  47.     return 0; 
  48. } 

3、http://acm.pku.edu.cn/JudgeOnline/problem?id=2263

这是第二次练习赛时，我们做过的最后一题，这里采用优先队列进行实现，在《谁说不能这样做题》中已提到这种方法，在这里再次放出代

码，~

题意：给出各城市间道路的限制载重量，求出从一个城市到另外一个城市的贷车能够运载的最大货物重量。

分析：采用优先队列，每次取出当前队列中结点的minheavy最大值出队，对它的连接结点搜索入队,这样，从出发点开始就可以

在到达终点时求出结果，即最大载货物重，实现代码如下：
[c-sharp] view plain copy print ?
  1. /*POJ 2263  16ms  dooder*/ 
  3. #include<stdio.h> 
  4. #include<string.h> 
  5. #include<queue> 
  6. using namespace std; 
  7. #define M 201 
  8. typedef struct w{ 
  9.     int city; 
  10.     int mintons; 
  11.     bool operator < (const w &a)const { 
  12.         return mintons < a.mintons; 
  13.     }//优先性定义 
  14. }Way; 
  15. char citys[M][31]; 
  16. int map[M][M]; 
  17. bool mark[M][M]; 
  18. int n,m,from,to,ans,k; 
  19. priority_queue <Way> que; 
  20. int min(int a,int b) 
  21. { 
  22.     return a>b?b:a; 
  23. } 
  24. void bfs() 
  25. { 
  26.     Way cur,next; 
  27.     int i; 
  28.     while(!que.empty()){ 
  29.         cur=que.top(); 
  30.         que.pop(); 
  31.         if(cur.city==to){ 
  32.             if(cur.mintons>ans) 
  33.                 ans=cur.mintons; 
  34.             while(!que.empty()) 
  35.                 que.pop(); 
  36.             return ; 
  37.         } 
  38.         for(i=0;i<n;i++){ 
  39.             if(map[cur.city][i]&&!mark[cur.city][i]){ 
  40.                 next.city=i; 
  41.                 next.mintons=min(cur.mintons,map[cur.city][i]); 
  42.  
  43.                 mark[cur.city][i]=mark[i][cur.city]=1; 
  44.                 que.push(next); 
  45.             } 
  46.         } 
  47.     } 
  48. } 
  49. void run() 
  50. { 
  51.     int i,temp,index; 
  52.     Way cur; 
  53.     ans=0; 
  54.     memset(mark,0,sizeof(mark)); 
  55.     temp=0; 
  56.     for(i=0;i<n;i++){ 
  57.         if(map[from][i]>temp){ 
  58.             temp=map[from][i]; 
  59.             index=i; 
  60.         } 
  61.     } 
  62.     cur.city=index; 
  63.     cur.mintons=temp; 
  64.     que.push(cur); 
  65.     bfs(); 
  66. } 
  67. int main() 
  68. { 
  69.     int k1,k2,tons,t=1; 
  70.     char s1[31],s2[31]; 
  71.     while(scanf("%d%d",&n,&m),n||m){ 
  72.         k=0; 
  73.         while(m--){ 
  74.             scanf("%s%s%d",s1,s2,&tons); 
  75.             for(k1=0;strcmp(s1,citys[k1])&&k1<k;k1++); 
  76.             if(k1==k) 
  77.                 strcpy(citys[k++],s1); 
  78.             for(k2=0;strcmp(s2,citys[k2])&&k2<k;k2++); 
  79.             if(k2==k) 
  80.                 strcpy(citys[k++],s2); 
  81.             map[k1][k2]=map[k2][k1]=tons; 
  82.         } 
  83.         scanf("%s%s",s1,s2); 
  84.         for(from=0;strcmp(citys[from],s1);from++); 
  85.         for(to=0;strcmp(citys[to],s2);to++); 
  86.         run(); 
  87.         printf("Scenario #%d/n",t++); 
  88.         printf("%d tons/n/n",ans); 
  89.     } 
  90.     return 0; 
  91. } 
当然了，优先队列的用法决不是仅仅提到的这些，各种应用还需要大家去发现，给道题大家可以练习一下hdu 2066/
相信大家已经学到不少了，还有一点可以告诉大家，优先队列是启发式搜索的数据结构基础，希望好好理解，并逐步掌握其用法~

加：失策啊，竟然忘了说优先队列的效率了，其时间复杂度为O(logn).n为队列中元素的个数，存取都需要消耗时间~

 

凌阡陌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
探索之美——接触优先队列~
dooder_daodao的专栏
07-24 1万+
优先队列：顾名思义，首先它是一个队列，但是它强调了“优先”二字，所以，已经不能算是一般意义上的队列了，它的“优先”意指取队首元素时，有一定的选择性，即根据元素的属性选择某一项值最优的出队~百度百科上这样描述的：优先级队列 是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素 　　优先队列的类定义 　　#include 　　#include 　　$include 　　const int maxPQSize = 50; //缺省元素个数 　　template class PQueue {
c++优先队列用法知识点总结
08-25
C++优先队列用法知识点总结 C++优先队列是一种特殊的队列数据结构，它允许元素按照一定的优先级顺序出队列。优先队列的操作不仅局限于队列的先进先出，还可以按照逻辑（如最大值或最小值等）出队列。 优先队列的...
stl 优先队列
做好我自己
08-03 1165
转：http://www.cnblogs.com/vvilp/articles/1504436.htmlpriority_queue<br />在优先队列中，优先级高的元素先出队列。<br />标准库默认使用元素类型的<操作符来确定它们之间的优先级关系。<br />优先队列的第一种用法，也是最常用的用法： priority_queue<int> qi;<br />通过<操作符可知在整数中元素大的优先级高。<br />故示例1中输出结果为：9 6 5 3 2<br /><br />第二种方法：<br />在示
优先队列
flyingzc的博客
12-28 175
优先队列 优先队列: 满足收集一些元素，处理当前键值最大的元素.然后再收集更多的元素，再处理当前键值最大的元素需求. 支持两种操作：删除最大元素 和 插入元素 API 最重要的操作就是 删除最大元素delMax() 和插入元素insert(). public class MaxPQ <Key extends Comparable<Key>> { // 创建一个优先队列 public MaxPQ() // 创建一个初始容量为 max 的优先队列 pu
Python优先队列实现方法示例
09-21
优先队列是一种特殊的队列，它的特点是队列中的元素按照优先级进行排列，优先级高的元素会被优先处理。在Python中，优先队列通常...优先队列的使用能够确保关键任务或紧急任务得到及时处理，提高程序的响应速度和效率。
优先队列-java可以选择属性和升序降序
06-14
使用`add()`方法将元素添加到优先队列中： ```java queue.add(5); queue.add(3); queue.add(8); ``` 默认情况下，队列将根据元素的自然顺序进行排序。 3. **移除元素** `remove()`方法用于删除并返回优先级...
c#优先队列
12-26
在C#中，实现优先队列的方式多种多样，包括使用有序数组、无序数组、集合以及二叉堆。下面将详细介绍这四种方法。 1. **有序数组** 有序数组是最基础的实现方式，它通过维护数组的顺序来实现优先队列。通常，数组...
优先队列的用法
蚕豆儿
11-10 624
转载来源：http://www.cppblog.com/shyli/archive/2007/04/06/21366.html 在优先队列中，优先级高的元素先出队列。 标准库默认使用元素类型的 优先队列的第一种用法，也是最常用的用法： 定义： priority_queue 第二种方法： 在示例1中，如果我们要把元素从小到大输出怎么办呢？ 这时我们可以传入一个比较函数，使
优先队列使用方法
ACdream
03-15 473
优先队列使用规则
 c++ 优先队列用法
最新发布
06-22
在C++中，优先队列（priority_queue）是一个容器适配器，它实现了基于堆的数据结构，其中元素总是按照一定的优先级顺序存储。优先队列默认使用最大堆，即元素值越大，位置越靠下；如果需要最小堆，则需要显式指定。 以下是如何在C++中使用优先队列的基本步骤： 1. 包含头文件： ```cpp #include <queue> ``` 2. 定义元素类型，并声明队列： ```cpp using namespace std; typedef pair<int, int> PriorityType; // 定义优先级类型，这里以整数对为例 priority_queue<PriorityType> pq; // 创建一个最大优先队列 ``` 3. 插入元素： ```cpp pq.push(PriorityType(5, 1)); // 插入元素 (优先级, 数据) pq.push(PriorityType(3, 2)); // 可以插入多个 ``` 4. 删除并获取最大优先级元素（出队）： ```cpp PriorityType top = pq.top(); // 获取当前最高优先级元素 pq.pop(); // 删除并返回最高优先级元素 ``` 5. 选择最高优先级元素但不删除： ```cpp if (!pq.empty()) { PriorityType highestPriority = pq.top(); } ``` 6. 非模板版本（仅适用于整数优先级）： ```cpp priority_queue<int, vector<int>, greater<int>> pqInt; // 使用小于号（less）创建最小堆 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值