优先队列集锦（其实都是水题啦）

最新推荐文章于 2023-04-06 18:50:16 发布
最新推荐文章于 2023-04-06 18:50:16 发布
阅读量600 收藏
点赞数
分类专栏： stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36908995/article/details/69055647
版权

1 HDU-1873   水题，基本优先队列。 

#include <iostream>
#include<stdio.h>
#include<algorithm>
#include<string>
#include<queue>
using namespace std;
struct node
{
    int lev;
    int ord;
    bool friend operator < (const node a,const node b)
    {
       if(a.lev!=b.lev)return a.lev < b.lev;
       else return a.ord > b.ord;
    }
};
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        char s[5];
        priority_queue<node> doc[4];
        for(int i=1;i<=3;i++)
        {
            while(!doc[i].empty()) doc[i].pop();
        }
        int cnt=0;
        for(int i=1;i<=n;i++)
        {
            struct node now;
            scanf("%s",s);
            if(s[0]=='I')
            {
                int a,b;
                now.ord=++cnt;
                scanf("%d%d",&a,&b);
                now.lev=b; doc[a].push(now);
            }
            else
            {
                int a;
                scanf("%d",&a);
                if(!doc[a].empty())
                {
                    now=doc[a].top();
                    doc[a].pop();
                    printf("%d\n",now.ord);
                }
                else printf("EMPTY\n");
            }
        }
    }
    return 0;
}


2 POJ-1442

用两个优先队列，一个是K个从大到小（队列首就是第K小数字），另一个队里从小到大是保存其他的数字（队列顶是其他个最小的元素）

进行如下操作

A 如果第一个队列未满K个直接扔进去

B 如果满K个则每次直接扔到另一个队列，将另一个队列的队列首和第一个队列首比较，如果小的话，pop第一个队列，把第二个队列首放进去。

#include <iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
int num[30100];
int ord[30100];
int ans[30100];

int main()
{
    priority_queue<int,vector<int>,greater<int> > res;
    priority_queue<int> aim;

    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=0;i<n;i++) scanf("%d",&num[i]);
    for(int i=0;i<m;i++) scanf("%d",&ord[i]);
    int cnt=0;
    for(int i=0;i<m;i++)
    {
        int pos=i+1;
        int temp=ord[i];
        for(;cnt<temp;cnt++)
        {
            res.push(num[cnt]);
        }
        while(aim.size()<pos)
        {
            int a; a=res.top();res.pop();
            aim.push(a);
        }
        while(!res.empty()&&!aim.empty()&&res.top()<aim.top())
        {
            int a=res.top(),b=aim.top();
            res.pop(); aim.pop();
            aim.push(a); res.push(b);
        }
        ans[i]=aim.top();
    }
    for(int i=0;i<m;i++) printf("%d\n",ans[i]);
    return 0;
}

POJ 2312. 

BFS，因为每次拓展的结果不一定是最小的，如果这块有墙，那么从这个点出发进行拓展的答案有可能错误，所以需要优先拓展步数小的节点。

#include <iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<queue>
using namespace std;

char map[350][350];
bool vis[350][350];
int dir[4][2]={1,0 ,-1,0 ,0,1, 0,-1};
int n,m;
struct node
{
    int x,y;
    int step;
    bool friend operator < (const node a,const node b)
    {
        return a.step>b.step;
    }
};

bool jud(struct node a)
{
    if(a.x<1||a.y<1||a.x>n||a.y>m) return 0;
    return 1;
}

void bfs(int sx,int sy)
{
    struct node u,v;
    u.x=sx;u.y=sy;
    u.step=0;
    vis[sx][sy]=1;
    priority_queue<node> que;
    que.push(u);
    while(!que.empty())
    {
       u=que.top();
       que.pop();
       if(map[u.x][u.y]=='T')
       {
           printf("%d\n",u.step);
           return;
       }
       for(int i=0;i<4;i++)
       {
            v.x=u.x+dir[i][0];v.y=u.y+dir[i][1];
            if(jud(v)&&!vis[v.x][v.y]&&map[v.x][v.y]!='S'&&map[v.x][v.y]!='R')
            {
                vis[v.x][v.y]=1;
                v.step=u.step+1;
                if(map[v.x][v.y]=='B') v.step++;
                que.push(v);
            }
       }
    }
    printf("-1\n");
    return;
}


int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        if(n==0||m==0) break;
        int sx,sy;
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                scanf(" %c",&map[i][j]);
                if(map[i][j]=='Y') {sx=i;sy=j;}
            }
        }
        bfs(sx,sy);
    }
    return 0;
}

HDU 4006

水题，上面讲过这种题，直接上代码了。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;

int main()
{
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        priority_queue<int ,vector<int>,greater<int> >que;
        while(!que.empty()) que.pop();
        int cnt=0;
        for(int i=0;i<n;i++)
        {
            char s[5];
            scanf("%s",s);
            if(s[0]=='I')
            {
                int a;
                scanf("%d",&a);
                if(cnt==k)
                {
                    if(que.top()<a)
                    {
                        que.pop(); que.push(a);
                    }
                    else continue;
                }
                else { que.push(a); cnt++;}
            }
            else
            {
                printf("%d\n",que.top());
            }

        }
    }
    return 0;
}

HDU 1509

水题

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
struct node
{
    char s[50];
    int date;
    int pro;
    int order;
    bool friend operator < (const node a, const node b)
    {
        if(a.pro!=b.pro) return a.pro > b.pro;
        else return a.order > b.order ;
    }
};
int main()
{
    priority_queue<node> que;
    char s[20];
    int cnt=0;
    while(scanf("%s",s)!=EOF)
    {
        if(s[0]=='P')
        {
            struct node t;
            scanf("%s%d%d",t.s,&t.date,&t.pro);
            t.order=cnt;
            cnt++;
            que.push(t);
        }
        else
        {
          if(!que.empty())
          {
              struct node t;
              t=que.top() ; que.pop();
              printf("%s %d\n",t.s,t.date);
          }
          else
          {
              printf("EMPTY QUEUE!\n");
          }
        }
    }
    return 0;
}

HDU1896

模拟一下就好。原来做过的题

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
struct node
{
    int pos;
    int trow;
    bool friend operator < (const node a,const node b)
    {
        if(a.pos!=b.pos) return a.pos>b.pos;
        else return a.trow>b.trow;
    }
};
int main()
{
    int T;
    scanf("%d",&T);
    for(int tt=0;tt<T;tt++)
    {
        int n;
        scanf("%d",&n);
        priority_queue<node> que;
        while(!que.empty()) que.pop();
        for(int i=0;i<n;i++)
        {
           struct node a;
           scanf("%d%d",&a.pos,&a.trow);
           que.push(a);
        }

        int ans=0,cnt=1;

        while(!que.empty())
        {
            if(cnt%2)
            {
               struct node x;
               x=que.top();
               x.pos+=x.trow;
               que.pop();
               que.push(x);
               ans=x.pos;
            }
            else
            {
                 ans=que.top().pos;
                 que.pop();
            }
            cnt++;
        }
        printf("%d\n",ans);
    }
    return 0;
}
HDU 1242

逆向BFS,从公主的位置出发去找最近的朋友即可

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
struct node
{
    int x,y,step;
    bool friend operator < (const node a,const node b)
    {
        return a.step > b.step;
    }
};

char  map[222][222];
bool vis[222][222];
int dir[4][2]={1,0 ,-1,0 ,0,1,0,-1};
int n,m,sx,sy;

bool j(struct node a)
{
    if(a.x<1||a.y<1||a.x>n||a.y>m) return 0;
    return 1;
}

void bfs(int sx,int sy)
{
    priority_queue<node> que;
    while(!que.empty()) que.pop();
    memset(vis,0,sizeof(vis));

    struct node u,v;
    u.x=sx; u.y=sy; u.step=0;
    vis[sx][sy]=1;
    que.push(u);
    while(!que.empty())
    {
      u=que.top();que.pop();
      if(map[u.x][u.y]=='r')
      {
          printf("%d\n",u.step);
          return;
      }
       for(int i=0;i<4;i++)
       {
          v.x=u.x+dir[i][0];
          v.y=u.y+dir[i][1];
          v.step=u.step+1;
          if(j(v)&&!vis[v.x][v.y]&&map[v.x][v.y]!='#')
          {
             vis[v.x][v.y]=1;
             if(map[v.x][v.y]=='x') v.step+=1;
             que.push(v);
          }
       }
    }
    printf("Poor ANGEL has to stay in the prison all his life.\n");
    return;
}
int main()
{
    while(scanf("%d%d",&n,&m)!=EOF)
    {
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            scanf(" %c",&map[i][j]);
            if(map[i][j]=='a') {sx=i;sy=j;}
        }
    }
    bfs(sx,sy);
    }
    return 0;
}

HDU4393

这道题刚开始一直wa，后来看了题解。直接开个speed100的优先队列（第一秒的速度优先），每次循环一遍找出最远的即可

#include <iostream>
#include<stdio.h>
#include<algorithm>
#include<queue>
#include<string.h>
using namespace std;
struct node
{
   int pos,ord;
   bool friend operator < (const node a,const node b)
   {
       if(a.pos!=b.pos ) return a.pos<b.pos;
       else return a.ord>b.ord;
   }
};

int ans[50020];
priority_queue<node> a[105];
int main()
{
    int T;
    scanf("%d",&T);
    for(int tt=1;tt<=T;tt++)
    {
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            struct node x;
            int sp;
            scanf("%d%d",&x.pos,&sp);
            x.ord=i;
            a[sp].push(x);
        }
        for(int i=0;i<n;i++)
        {
            int ma=0,pos=50001,kpos=0;
            for(int j=1;j<=100;j++)
            {
               if(a[j].empty()) continue;
               else
               {
                  if( i*j+a[j].top().pos>ma||(i*j+a[j].top().pos==ma&&pos>a[j].top().ord))
                  {
                       ma= i*j+a[j].top().pos ; pos=a[j].top().ord;kpos=j;
                  }
               }
            }
            a[kpos].pop();
            ans[i]=pos;
        }
        printf("Case #%d:\n",tt);
        printf("%d",ans[0]);
        for(int i=1;i<n;i++)
        {
            printf(" %d",ans[i]);
        }
        printf("\n");
    }
    return 0;
}

POJ 2431 思路和上面的一模一样 

#include <iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
priority_queue<int> que[102];
int n;
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        for(int i=0;i<=100;i++)
        {
            while(!que[i].empty()) que[i].pop();
        }
        for(int i=0;i<n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            que[b].push(a);
        }
        int dis,ful;
        scanf("%d%d",&dis,&ful);
        dis-=ful;ful=0;
        int ans=0;
        while(1)
        {
            if(dis<=0) break;
            int pos=-1;
            for(int i=100;i>0;i--)
            {
                if(que[i].empty()) continue;
                if(que[i].top()>=dis) {pos=i;break;}
            }
            if(pos<0) break;
            else
            {
                ans++;
                dis-=pos;
                que[pos].pop();
            }
        }
        if(dis<=0)
        {
            printf("%d\n",ans);
        }
        else printf("%d\n",-1);
    }
    return 0;
}

POJ2970

自己是用 第一优先级截止日期，第二优先级bi/ai（大到小） 第三优先级bi 来做的，优先填满最贵的。结果错了 。因为有可能两个较便宜的比一个贵的还贵

然后看了网上的思路

很明显，如果手头这个工作无法完成，那么我们就需要在已经完成的工作中（这里其实包括手头的工作）找到那个a最大的工作，然后给钱来减少那个工作所需的时间，以便以最小的花销来完成现在所有的工作。所以我们需要一个优先队列来维护当前拥有最大a的那个工作。我们可以直接调用stl里的priority_queue来完成这个工作，每次取出a最大的工作，如果这项工作已经不能再给钱了，那么就将其POP出队列，选取下一个，直到我们可以再deadline前完成手头的工作。

#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
struct node
{
    int di,ai,bi,rest;
    double val;
    bool friend operator < (const node a,const node b)
    {
        return a.ai<b.ai;
    }
}test[101000];

bool cmp (const node a,const node b )
{
    return a.di < b.di;
}

priority_queue<node> que;
int n;
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        while(!que.empty()) que.pop();
        for(int i=0;i<n;i++)
        {
            scanf("%d%d%d",&test[i].ai,&test[i].bi,&test[i].di);
            test[i].val=1.00000*test[i].bi;
            test[i].val=test[i].val/test[i].ai;
            test[i].rest=test[i].bi;
        }
        sort(test,test+n,cmp);
        int time=0;
        double ans=0;
        for(int i=0;i<n;i++)
        {
            que.push(test[i]);
            time+=test[i].bi;
            if(time<=test[i].di) continue;
            else
            {
                while(1)
                {
                    if(time<=test[i].di) break;
                    struct node a;
                    a=que.top(); que.pop();
                    int need=time-test[i].di;
                    if(need>=a.rest)
                    {
                      double temp=a.rest*1.000000;
                      temp/=(1.000000*a.ai);
                      ans+=temp; time-=a.rest; continue;
                    }
                    else
                    {
                        a.rest-=need;
                        double temp=need*1.000000;
                        temp/=(1.0000000*a.ai);
                        ans+=temp; time=test[i].di;
                        que.push(a);
                        break;
                    }
                }
            }
        }
        printf("%.2f\n",ans);
    }
    return 0;
}

总的来说这两天做的优先队列，质量都不高，以练手为主吧。（其实是因为太忙了，没时间想难题。。。。。）

 










德鸭
关注
专栏目录
BAT 大厂Java 面试题集锦之核心篇附参考答案
程序员光剑
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
2021 Java面试真题集锦
热门推荐
GL1765852966的博客
12-26 8万+
目录 … 1 大厂面试的基本流程 17 字节跳动 17 阿里 17 腾讯 18 网易游戏 18 面试前需要准备： 18 面试中可以借鉴的套路 19 用简历争取到更多的面试机会 19 自我介绍时，立即全面抛出技术栈和亮点 20 先介绍项目背景，打消面试官疑问 21 通过说项目管理工具，说明你不仅会写代码 22 用 SPRING BOOT 项目举例，说明你的技术基本面 23 用实例说明你在内存调优方面的经验 24 展示你在数据库调优方面的经验 25 总结前文说辞 26 准备项目说辞时，更可以准备后继面试官的问
优先队列例题
Sky_River_Z的博客
02-16 403
本文摘自博客，欢迎前往博客以获得更好的体验。 优先队列例题 序列合并 题目 有两个长度都是 N 的序列 A 和 B ，在 A 和 B 中各取一个数相加可以得到 N2N^2N2 个和，求这 N2N^2N2 个和中最小的 N 个。 输入格式 第一行一个正整数 N； 第二行N个整数 AiA_iAi​ , 满足 Ai≤Ai+1A_i \le A_{i+1}Ai​≤Ai+1​ 且 Ai≤109A_i \le 10^9Ai​≤109; 第三行N个整数 BiB_iBi​ , 满足 Bi≤Bi+1B_i \le B_.
优先队列习题
aoxieqian3601的博客
08-29 350
　　　　　　POJ 3614 这个题目真的是优先队列的巧解， 十分十分的巧妙哦； 转载于:https://www.cnblogs.com/lucky-light/p/11431518.html
HDU 1896
拂晓
03-31 703
题目： ***查看报名情况*** Stones Time Limit: 5000/3000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 296    Accepted Submission(s): 162 Pro
3道经典的优先队列题
South__wind的专栏
08-31 3520
优先队列是一种十分强大的数据结构，它保持了一种动态的有序性，对于不断改变有入队的操作，而又需要某种最大或最小的操作的问题是再合适不过了，通常优先队列的实现是由最小堆或者最大堆完成的，并通过堆排序保持队列的有序性，模拟队列的结构，在实际比赛中要写一个堆排序还是要一定的时间的，但是stl中queue容器中已经可以实现优先队列，下面以三道基本的题目来演示priority_queue的作用。 聪明的
优先队列 水题
e的专栏
04-21 588
看了优先队列的基础用法，
python爬虫面试题集锦及答案
AudiA6LV6的博客
09-18 6976
传统定义：分布式存储系统是大量 PC 服务器通过 Internet 互联，对外提供一个整体的服务。分布式存储系统具有以下的几个特性：可扩展 ：分布式存储系统可以扩展到几百台甚至几千台这样的一个集群规模，系统的 整体性能线性增长。低成本 ：分布式存储系统的自动容错、自动负载均衡的特性，允许分布式存储系统可 以构建在低成本的服务器上。另外，线性的扩展能力也使得增加、减少服务器的成本低， 实现分布式存储系统的自动运维。
NOIP初赛真题集锦
01232012的博客
10-02 4986
题目集锦： 1、斐波那契数列的定义如下：F_1=1,F_2=1,F_n=F1​=1,F2​=1,Fn​= F_{n-1}+Fn−1​+ F_{n-2}Fn−2​ (n \geq 3)(n≥3)。如果用下面的函数计算斐波那契数列的第$n项，则其时间复杂度为（ ）。 int F(int n) {     if (n &lt;= 2)         return 1;     else ...
前端开发必看100道大厂面试题集锦（一）
最新发布
sdasadasds的博客
04-06 1617
100道必刷前端面试题（一），持续更新中！
优先队列的使用和相关例题
weixin_44910502的博客
04-08 459
队列是一种线性表，和先进后出的栈相比，队列先进先出，深度搜素和广度搜索的算法都使用到了队列 在使用队列函数时候尽量使用offer()来加入函数，使用poll()来获取并移出元素，add()和remove()方法在失败时候会跑出异常，如果要使用队首而不移除可以使用peek()或者element()函数 ...
水题——优先队列
StubbornAccepted的博客
04-20 636
Description 因为是有关于接水的问题，便简称为水题了（。 N个人排队在M个出水口前接水，第i个人接水需时为t[i]， 请问接水的最短用时是多少？ Input 第一行一个整数 T ，代表有 T 组数据。 每组数据 第一行两个整数 N(<=100000) , M(<=10000) 代表有 N 个人 M 个出水口。 第二行N个整数，第i个数字ti代表第i个人接水用时t[i]。 Outpu
【leetcode】优先队列题目集合
littlemichelle
08-18 3170
一、在N个元素中选出前M个元素（N远大于M时） 在1,000,000个元素中选出前100名。 思路一：对N的元素进行排序，然后选出前M个元素，时间复杂度为O(NlogN)（采用快排或归并排序等高级排序算法） 思路二：使用优先队列，可以将时间复杂度降低为O(NlogM)。具体实现：使用优先队列维护M个元素，即每次向优先队列中加入一个元素时，需要将当前队列中的最小元素替换出去，保证队列中的M个元素...
经典算法题每日演练——第九题 优先队列
weixin_33898233的博客
12-03 140
        前端时间玩小爬虫的时候，我把url都是放在内存队列里面的，有时我们在抓取url的时候，通过LCS之类的相似度比较，发现某些url是很重要的， 需要后端解析服务器优先处理，针对这种优先级比较大的url，普通的队列还是苦逼的在做FIFO操作，现在我们的需求就是优先级大的优先服务，要做 优先队列，非堆莫属。 一：堆结构    1:性质       堆是一种很松散的序结构树，只...
优先队列模板题
weixin_43323647的博客
05-31 501
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Poj2431（优先队列经典题）
gq__97的博客
02-05 594
import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.io.StreamTokenizer; import java.
算法竞赛入门经典例题-优先队列（阿格斯）
冗长的专栏
07-09 997
优先队列例题： 阿格斯（Argus） 你的任务是编写一个称为Argus的系统。该系统是支持一个Register命令，Register Q_num Period 该命令注册了一个触发器，它每秒钟就会产生一次编号为Q_num的事件，你的任务是模拟出钱k个事件。如果多个事件同时发生，先处理Q_NUM小的事件#include<iostream> #include<queue> using namesp
队列水题
nuoyanli的博客
11-15 1446
队列水题（另附约瑟夫环：） 士兵队列训练问题 来源： https://cn.vjudge.net/contest/268984#problem/B 某部队进行新兵队列训练，将新兵从一开始按顺序依次编号，并排成一行横队，训练的规则如下：从头开始一至二报数，凡报到二的出列，剩下的向小序号方向靠拢，再从头开始进行一至三报数，凡报到三的出列，剩下的向小序号方向靠拢，继续从头开始进行一至二报数。。。，以后从...
Poj—2431 Expedition 优先队列使用经典例题
NotColdHeike的博客
08-08 481
就像《挑战程序设计竞赛》所说的——在到达加油站之前时，就获得一次在之后加油的权利。简单的说就是，当你经过第 i 个加油站时，先别加油，先压入优先队列，当你到达第 k 个加油站时，计算你车里的油够不够，若不够则从优先队列中选取一个在前面几站中最大的加油站，若还不够，加第二大的加油站..... 总的来说，先考虑能不能到下一站，能，则不加油；不能，就加前面几站中最大的。 这道题目： 1.给你加油站的距离是
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值