【蓝桥杯-优先队列的排序】任务系统+知识点讲解

蒜头君设计了一个任务系统。这个系统是为了定时提醒蒜头君去完成一些事情。

系统大致如下，初始的时候，蒜头君可能会注册很多任务，每一个任务的注册如下:

Register Q_num Period

表示从系统启动开始，每过 $Period$ 秒提醒蒜头君完成编号为 Q_{num}Qnum​ 的任务。

你能计算出蒜头君最先被提醒的 $k$ 个任务吗？

输入格式

第一行输入 $n(0<n\le 3000)$，$k(0<k\le 10000)$，其中 $n$ 表示蒜头君注册的任务数量。

接下来 $n$ 行，每行输入一条注册命令，其中 0 < q_{num} \le 30000<qnum​≤3000，$0\le Period\le 3000$。

输出格式

顺序输出 $k$ 行，表示依次提醒的任务的编号。如果同一时间有多个任务，最先提醒编号小的任务。

样例输入

2 5
Register 2004 200
Register 2005 300

样例输出

2004
2005
2004
2004
2005

#include<iostream>
using namespace std;
#include<queue>
#include<bits/stdc++.h>
struct node
{
    int num,period,onetime_period,times;
    bool operator<(const node&b) const
    {
        return period>b.period || (period==b.period && num>b.num);
    }
};
int main()
{
     int n,k;
    cin>>n>>k;
    int num,onetime_period;
    node s[n];
    priority_queue<node> q;
    string feihua;
    for(int i=0;i<n;i++)
    {
    	cin>>feihua;
        cin>>num>>onetime_period;
  //      s[i]=new node(num,onetime_period,onetime_period,1);
        s[i].num=num;
        s[i].period=onetime_period;
        s[i].onetime_period=onetime_period;
        s[i].times=1;
        q.push(s[i]);
    }
    node s1;
    while(k--)
    {
        printf("%d\n",q.top().num);
        s1=q.top();
        s1.times+=1;
        s1.period=s1.times*s1.onetime_period;
        q.pop();
        q.push(s1);
    }
    return 0;
}

学到的点：

①结构体的声明不用new内存。

②关于优先队列的排序：

一般来说，如果优先队列元素只有int元素，那么是默认less也就是默认从大到小的。那么也就是以下这种写法（注意> >之间空格）

priority_queue<int,vector<int>,less<int> >q; （这就等同于priority_queue<int>q）

如果想要int的优先队列从小到大排序，就是greater：

priority_queue<int,vector<int>,greater<int> >q;

如果元素不是int，比如优先队列的元素是结构体的话，一般需要对该结构体进行<运算符重载（注意形参就一个元素），比如：

1. struct number1{  
2.     int x;  
3.     bool operator < (const number1 &a) const {  
4.         return x>a.x;//最小值优先  
5.     }  
6. };  

对于<运算符重载，我的理解是“右边优先”（男左女右+lady first），比如上例，右边的小，所以最小值优先。

当然，也可以在优先队列的声明时加个cmp函数形参：

1. struct cmp1{  
2.     bool operator ()(int &a,int &b){  
3.         return a>b;//最小值优先  
4.     }  
5. };  

具体可看看以下代码，viaCSDN博主Sherlock_n

1) 优先队列的定义

包含头文件："queue.h", "functional.h"

可以使用具有默认优先级的已有数据结构；也可以再定义优先队列的时候传入自定义的优先级比较对象；或者使用自定义对象(数据结构)，但是必须重载好< 操作符。 

2) 优先队列的常用操作

优先级队列支持的操作

q.empty()         如果队列为空，则返回true，否则返回false q.size()            返回队列中元素的个数 q.pop()             删除队首元素，但不返回其值 q.top()             返回具有最高优先级的元素值，但不删除该元素 q.push(item)     在基于优先级的适当位置插入新元素

其中q.top()为查找操作，在最小优先队列中搜索优先权最小的元素，在最大优先队列中搜索优先权最大的元素。q.pop()为删除该元素。优先队列插入和删除元素的复杂度都是O(lgn)，所以很快

另外，在优先队列中，元素可以具有相同的优先权。

[cpp]  view plain  copy

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