queue/prioity_queue

queue/prioity_queue

uva,144

1-25个学生,每人每年领40美元。一个防盗的atm机按照1.2...k的方式依次吐出硬币。

例如:第一次吐出1coin,第二次吐出2 coins 直到限制k。然后循环从1开始吐。学生插卡取钱,当达到限额就离开队列。

注意:只有当output store没钱了,才会向里面吐钱。所以每次学生最大领的钱数为k。没领到40继续排在末尾。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <queue>
 4 using namespace std;
 5
 6 struct Student
 7 {
 8     int id,need;
 9 };
10
11 queue<Student> mp;
12
13 int main()
14 {
15     int N,k;
16     while(scanf("%d %d",&N,&k) && N+k)
17     {
18         int i;
19         for(i=1;i<=N;i++)
20             mp.push((Student){i,40});
21         while(!mp.empty())
22         {
23             for(i=1;i<=k;i++)
24             {
25                 int remain=i;
26                 while(remain && !mp.empty())
27                 {
28                     Student now=mp.front();
29                     mp.pop();
30                     if(now.need > remain)
31                     {
32                         now.need-=remain;
33                         remain=0;
34                         mp.push(now);
35                     }
36                     else
37                     {
38                         remain-=now.need;
39                         printf("%3d",now.id);
40                     }
41                 }
42             }
43         }
44         puts("");
45     }
46     return 0;
47 }

uva,170

从上到下为栈思维。从左到右代表顺序是逆序的。即第一列为第13pile也就是中间片。

所以程序的输入如下。

有几个想法:输入可以直接输入一个字符串,用ch==‘ ‘使单词数加1,但是gets或scanf()非法。。。

用queue实现的话。注意pile的顺序。与栈正好相反。但是我实现了,输出时对的,但是老是wa。所以就没写了。

 1 #include <iostream>
 2 #include <algorithm>
 3 #include <stack>
 4
 5 using namespace std;
 6
 7 typedef struct _qnode{
 8   int value;
 9   char color;
10   _qnode(int v,char c){value=v;color=c;}
11   _qnode(){}
12 }qnode;
13
14 qnode retain[54];
15
16 int value(char ch)
17 {
18   if(ch>=‘2‘ && ch<=‘9‘)
19     return ch-‘1‘;
20   if(ch==‘A‘) return 0;
21   if(ch==‘T‘) return 9;
22   if(ch==‘J‘) return 10;
23   if(ch==‘Q‘) return 11;
24   if(ch==‘K‘) return 12;
25 }
26
27 char Maps[]="A23456789TJQK";
28
29 stack<qnode> mp[13];
30 int main()
31 {
32   char V,C;
33   while(cin>>V && V!=‘#‘)
34   {
35     cin>>C;
36     retain[0]=qnode(value(V),C);
37     for(int i=1;i<52;i++)
38     {
39       cin>>V>>C;
40       retain[i]=qnode(value(V),C);
41     }
42
43     for(int i=51;i>=0;i--)
44       mp[12-i%13].push(retain[i]);
45     int count=0,index=12;
46     qnode now;
47     while(!mp[index].empty())
48     {
49       now=mp[index].top();
50       mp[index].pop();
51       index=now.value;
52       ++count;
53     }
54     if(count<10) cout<<"0";
55     cout<<count<<","<<Maps[now.value]<<now.color<<endl;
56   }
57   return 0;
58 }

花了一下午时间用queue实现了。原来是queue要放在main函数里面要不然每次值都被保存下来了。

 1 #include <iostream>
 2 #include <algorithm>
 3 #include <queue>
 4
 5 using namespace std;
 6
 7 typedef struct _qnode{
 8   int value;
 9   char color;
10   _qnode(int v,char c){value=v;color=c;}
11   _qnode(){}
12 }qnode;
13
14 qnode retain[54];
15
16 int value(char ch)
17 {
18   if(ch>=‘2‘ && ch<=‘9‘)
19     return ch-‘1‘;
20   if(ch==‘A‘) return 0;
21   if(ch==‘T‘) return 9;
22   if(ch==‘J‘) return 10;
23   if(ch==‘Q‘) return 11;
24   if(ch==‘K‘) return 12;
25 }
26
27 char Maps[]="A23456789TJQK";
28
29 int main()
30 {
31   char V,C;
32   while(cin>>V && V!=‘#‘)
33   {
34     queue<qnode> mp[13];
35     cin>>C;
36     retain[0]=qnode(value(V),C);
37     for(int i=1;i<52;i++)
38     {
39       cin>>V>>C;
40       retain[i]=qnode(value(V),C);
41     }
42
43     for(int i=0;i<=51;i++)
44       mp[12-i%13].push(retain[i]);
45     int count=0,index=12;
46     qnode now;
47     while(!mp[index].empty())
48     {
49       now=mp[index].front();
50       mp[index].pop();
51       index=now.value;
52       count++;
53     }
54     if(count<10) cout<<"0";
55     cout<<count<<","<<Maps[now.value]<<now.color<<endl;
56   }
57   return 0;
58 }

uva,10142

  1 #include <algorithm>
  2 #include <cstdio>
  3 #include <cstring>
  4 #include <cstdlib>
  5 #include <iostream>
  6
  7 using namespace std;
  8
  9 char candidate[21][81];
 10 char buf[1001];
 11 int choice[1001][21];
 12 int vote[21][1001];
 13 int vote_size[21];
 14
 15 int main()
 16 {
 17     int t,n;
 18     while(~scanf("%d",&t))
 19     while(t--)
 20         {
 21             scanf("%d",&n);
 22             getchar();
 23
 24             int i,j;
 25
 26             for(i=0;i<n;++i)
 27             {
 28                 gets(candidate[i]);
 29                 vote_size[i]=0;
 30             }
 31
 32             int number=0;
 33             while(gets(buf) && buf[0])
 34             {
 35                 int count=0,value=0;
 36
 37                 for(i=0;buf[i];++i)
 38                 {
 39                     if(buf[i]>=‘0‘ && buf[i]<=‘9‘)
 40                     {
 41                         value*=10;
 42                         value+=buf[i]-‘0‘;
 43                     }
 44                     else
 45                     {
 46                         choice[number][count++]=value-1;
 47                         value=0;
 48                     }
 49                 }
 50                 choice[number++][count++]=value-1;
 51             }
 52
 53             for(i=0;i<number;++i)
 54             {
 55                 int can=choice[i][0];
 56                 vote[can][vote_size[can]++]=i;
 57             }
 58
 59             while(1)
 60             {
 61                 int max=0,min=1001,max_space,min_space;
 62                 for(i=0;i<n;i++)
 63                 {
 64                     if(vote_size[i]){   //不加的话,多扫多次会tle
 65                     if(max<vote_size[i])
 66                     {
 67                         max=vote_size[i];
 68                         max_space=i;
 69                     }
 70                     if(min>vote_size[i])
 71                     {
 72                         min=vote_size[i];
 73                         min_space=i;
 74                     }
 75                     }
 76                 }
 77
 78                 if(2*max>=number) break;
 79                 if(max==min) break;
 80
 81                 for(int k=0;k<n;++k)
 82                 {
 83                     if(vote_size[k]!=min) continue;
 84
 85                     for(i=0;i<vote_size[k];++i)
 86                     {
 87                         int per=vote[k][i];
 88
 89                         for(j=0;j<n;j++)
 90                         {
 91                             int can=choice[per][j];
 92
 93                             if(vote_size[can]!=min && vote_size[can])
 94                             {
 95                                 vote[can][vote_size[can]++]=per;
 96                                 break;
 97                             }
 98                         }
 99                     }
100                     vote_size[k]=0;
101                 }
102             }
103
104             int max_space=0;
105
106             for(i=0;i<n;++i)
107                 if(vote_size[max_space]<vote_size[i])
108                     max_space=i;
109             for(i=0;i<n;++i)
110                 if(vote_size[i]==vote_size[max_space])
111                     puts(candidate[i]);
112
113             if(t) puts("");
114         }
115     return 0;
116 }

Poj,2051

 1 #include <cstdio>
 2 #include <iostream>
 3 #include <cstring>
 4 #include <queue>
 5
 6 using namespace std;
 7
 8 struct Register
 9 {
10     int id;
11     int period;
12     Register(int _id,int _period)
13     {
14         id=_id;
15         period=_period;
16     }
17     bool operator< (const Register& x)const
18     {
19         if(x.period==period)
20             return id>x.id;
21         return period>x.period;
22     }
23 };
24
25 priority_queue<Register> mp;
26 char ch[20];
27 int np[3001]={0};
28
29 int main()
30 {
31     int ID,PERIOD;
32     while(~scanf("%s",ch))
33     {
34         if(ch[0]==‘#‘)
35             break;
36         scanf("%d %d",&ID,&PERIOD);
37         np[ID]=PERIOD;
38         mp.push(Register(ID,PERIOD));
39     }
40
41     int k;
42     scanf("%d",&k);
43     for(int i=0;i<k;i++)
44     {
45         Register now=mp.top();
46         mp.pop();
47         printf("%d\n",now.id);  //中间这里犯糊涂了,其实就是寡的优先队列
48         now.period+=np[now.id];
49         mp.push(now);
50     }
51     return 0;
52 }

时间: 2024-10-06 10:45:45

queue/prioity_queue的相关文章

UVALive-7304 - Queue of Soldiers 【动态规划】【组合函数】【好题】

UVALive- 7304 - Queue of Soldiers 题目链接:7304 题目大意:士兵过山洞,必须以类似7 6 5 4 3 2 1顺序过.在第i个人之后,比i高的人都会被杀死,问如果要杀死k个人,有几种排队方法. 题目思路:先将士兵的身高离散化.假设N表示不同身高的数目.cnt[i] 表示i这个身高的人有多少个.(i的范围为1~N)sum[i]表示小于等于该身高段的士兵数目 然后开始dp,dp[i][j]表示已经到第i个士兵,已经死了j个人的方法数. 第三维遍历,q表示,第i+1

Java集合类: Set、List、Map、Queue使用

目录 1. Java集合类基本概念 2. Java集合类架构层次关系 3. Java集合类的应用场景代码 1. Java集合类基本概念 在编程中,常常需要集中存放多个数据.从传统意义上讲,数组是我们的一个很好的选择,前提是我们事先已经明确知道我们将要保存的对象的数量.一旦在数组初始化时指定了这个数组长度,这个数组长度就是不可变的,如果我们需要保存一个可以动态增长的数据(在编译时无法确定具体的数量),java的集合类就是一个很好的设计方案了. 集合类主要负责保存.盛装其他数据,因此集合类也被称为容

【译】RabbitMQ:工作队列(Work Queue)

在第一篇我们写了两个程序通过一个命名的队列分别发送和接收消息.在这一篇,我们将创建一个工作队列在多个工作线程间分发耗时的工作任务. 工作队列的核心思想是避免立刻处理资源密集型任务导致必须等待其执行完成.相反的,我们安排这些任务在稍晚的时间完成.我们将一个任务封装为一个消息并把它发送到队列中.一个后台的工作线程将从队列中取出任务并最终执行.当你运行多个工作线程,这些任务将在这些工作线程间共享. 这个概念对于在一个HTTP请求中处理复杂任务的Web应用尤其有用. 准备工作 在前一篇中,我们发送了一条

HDU 1908 Double Queue&lt;Set&gt;

Problem Description The new founded Balkan Investment Group Bank (BIG-Bank) opened a new office in Bucharest, equipped with a modern computing environment provided by IBM Romania, and using modern information technologies. As usual, each client of th

UVa 133 The Dole Queue

 The Dole Queue  In a serious attempt to downsize (reduce) the dole queue, The New National Green Labour Rhinoceros Party has decided on the following strategy. Every day all dole applicants will be placed in a large circle, facing inwards. Someone i

python线程队列---queue

queue队列 :使用import queue,用法与进程Queue一样 用法介绍: class queue.Queue(maxsize=0) #先进先出 import queue q=queue.Queue() q.put('first') q.put('second') q.put('third') print(q.get()) print(q.get()) print(q.get()) ''' 结果(先进先出): first second third ''' class queue.Lif

queue

queue是一种先进先出的数据结构.以下由简入繁引入queue. queue的操作主要有:入队,出队,空满判断等. 1. 数组实现简单队列 #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MAX 10 int arr[MAX]; int head = 0; int tail = 0; int counter = 0; void enqueue(int value) { arr[tai

queue队列

今天有一个需求需要随时更新数据需要及时删除过期数据,就用到队列了.每执行一次定时任务就往queue中加一次数据,所以需要在一个独立于定时任务的类中加静态属性: public static Queue<CB_SingleDolaryToday> queue = new LinkedList<>() 因为需要求元素和所以加静态属性   public static double sumDolary = 0.0; 在定时任务中需要更新队列并删除过期元素 /*** 循环检测队列头元素,如果超

Deque 和Queue

概述 接口,一个线性结合,支持在集合首尾add , remove , deque 是double  ended queue 的缩写,意味双端队列,接口提供的方法有两种类型,如果失败,一种抛出异常,一种返回特殊值(null, false)   第一个元素(头部) 最后一个元素(尾部)   抛出异常 特殊值 抛出异常 特殊值 插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e) 移除 removeFirst() pollFirst() remove