寒假大一2.15考试

最新推荐文章于 2020-02-22 13:38:40 发布
最新推荐文章于 2020-02-22 13:38:40 发布
阅读量154 收藏
点赞数 1
分类专栏： 比赛题解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46118704/article/details/104345921
版权

A: NEFU 1295 机器人

思路：用结构体将输入数据存起来，将数据进行反转存入从小到大排的优先队列，输出时按原先数字输出。
注意：输出格式为元素之间有一个空格，末尾没有空格。

#include <bits/stdc++.h>

using namespace std;
struct sa{
int zs,fs;//分别存入原先数据和反转后的数据
};
int n,x,y;

bool operator < (const sa &a,const sa &b)
{
    return a.fs>b.fs;
}

int fan(int k)//将数据进行反转
{
    int gw=0,xs=0;
    while(k)
    {
        gw=k%10;
        xs=xs*10+gw;
        k/=10;
    }
    return xs;
}

int main()
{
    priority_queue <sa> s;
    while(cin>>n)
    {
      for(int i=1;i<=n;i++)
      {cin>>x;
      y=fan(x);
      s.push({x,y});
      }
      while(!s.empty())
      {
          s.size()==1?printf("%d\n",s.top()):printf("%d ",s.top());
          s.pop();
      }
    }
    return 0;
}

B:NEFU 1311 纸牌游戏

思路：循环队列。
注意：这题同样要注意输出格式。

#include <bits/stdc++.h>

using namespace std;
int t,n;
queue <int> s;
int main()
{
    cin>>t;
    while(t--)
    {
      cin>>n;
      for(int i=1;i<=n;i++)
      {
         s.push(i);
      }
      while(s.size()>1)//当队列中只剩1个元素时跳出
      {
          int tmp=s.front();
          s.pop();
          s.size()==1? printf("%d\n",tmp):printf("%d,",tmp);
          int u=s.front();
          s.pop();
          s.push(u);//将扔掉后的队列中第一张牌放在最后
      }
      printf("%d\n",s.front());
      while(!s.empty()){s.pop();}
    }
    return 0;
}

C:NEFU 2114 咸鱼连突刺

思路：用素数筛先将1e6范围内素数打表，然后找范围内的最大最小素数即可。
注意：
1.输出今天的伤害总值，记得用 long long 进行存储。
2.查找的是闭区间内的素数。
3.若范围内只有一个素数，则该数*2。

#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int N=1e6+1;
int n,x,cut,prime[N],h;
bool b[N];
void getprime ()//素数筛打表
{
    memset(b,1,sizeof(b));
    b[0]=b[1]=0;
    for(int i=2;i<=N;i++)
    {
        if(b[i]) prime[++cut]=i;
        for(int j=1;j<=cut&&prime[j]*i<=N;j++)
        {
            b[prime[j]*i]=0;
            if(i%prime[j]==0) break;
        }
    }
}
int main()
{
    int t,l,r;
    getprime();
    cin>>t;
    long long ans=0;//记录伤害总值
    while(t--)
    {
     cin>>l>>r;
     int minn=0,maxx=0;
     for(int i=l;i<=r;i++)//求最小素数
     {
         if(b[i])
         {minn=i;break;}
     }
     for(int i=r;i>=l;i--)//求最大素数
     {
         if(b[i])
         {maxx=i;break;}
     }
     ans+=minn+maxx;
    }
    printf("%lld\n",ans);
    return 0;
}

D:NEFU 2110 库特的合并果子

思路：简单的合并果子，贪心思想+优先队列。
注意：注意输出的是每一轮消耗的体力值。

#include <bits/stdc++.h>
int n,x,cut;
using namespace std;
priority_queue<long long,vector<long long>,greater<long long> > s;

int main()
{
   while(cin>>n)
   {for(int i=1;i<=n;i++){
    cin>>x;
    s.push(x);
   }
   cut=0;
   if(s.size()==1)printf("0\n");//如果只有一堆则输出0，不过这题貌似不需要WAW
   while(s.size()>1){
    long long t=s.top();
    s.pop();
    long long p=s.top();
    s.pop();
    long long l=t+p;
    s.push(l);
    s.size()==1?printf("%lld\n",l):printf("%lld ",l);
   }
   while(!s.empty()){
    s.pop();
   }
   }
   return 0;
}

补充：用优先队列的解法时间复杂度为O（nlogn），洛谷大犇还有为O（n）的更强解法，解法指路。

E:NEFU 2111 库特的素数队列（1）

思路：
素数筛打表。
1.用循环队列实现。
2.数组也可以，不过从个人感觉貌似效率没有优先队列高。
注意：注意考虑队列中只有一个孩子的情况。

队列实现：

#include <bits/stdc++.h>
using namespace std;
queue<int> s;
const int N=1e7+1;
int n,x,cut,prime[N],h;
bool b[N];
void getprime ()//打表
{
    memset(b,1,sizeof(b));
    b[0]=b[1]=0;
    for(int i=2;i<=N;i++)
    {
        if(b[i]) prime[++cut]=i;
        for(int j=1;j<=cut&&prime[j]*i<=N;j++)
        {
            b[prime[j]*i]=0;
            if(i%prime[j]==0) break;
        }
    }
}
int main()
{
   getprime ();
   std::ios::sync_with_stdio(0);
   cin>>n;
   while(n--)
   {cin>>x;
    for(int i=1;i<=x;i++){
    s.push(i);
   }
   while(s.size()>1)
   {
   for(int i=1;i<=x;i++)
   {
       if(i==1){h=s.back();}//记录本次循环末尾元素
       int tmp=s.front();
       s.pop();
       if(b[i]) {s.push(tmp);}//判断所报是否为素数
       if(h==tmp&&s.size()!=1){i=0;x=s.size();}//若本次循环末尾元素与队首元素相等，进入下次循环
   }
   }
   while(!s.empty())
   {
       printf("%d\n",s.front());
       s.pop();
   }
   }
   return 0;
}

数组实现：
用一个数组报数，用一个数组存剩下的小朋友。

#include <bits/stdc++.h>
using namespace std;
const int N=1e7+1;
int n,x,cut,prime[N],h,p;
bool b[N];
int a[N],c[N];
void getprime ()
{
    memset(b,1,sizeof(b));
    b[0]=b[1]=0;
    for(int i=2; i<=N; i++)
    {
        if(b[i])
            prime[++cut]=i;
        for(int j=1; j<=cut&&prime[j]*i<=N; j++)
        {
            b[prime[j]*i]=0;
            if(i%prime[j]==0)
                break;
        }
    }
}
int main()
{
    getprime ();
    std::ios::sync_with_stdio(0);
    cin>>n;
    while(n--)
    {
        cin>>x;
        memset(a,0,sizeof(a));
        memset(c,0,sizeof(c));//因为是多组循环所以要注意初始化数组
        p=0;
        for(int i=1; i<=x; i++)//存所有小朋友
        {
                a[++p]=i;
        }
        while(p>1)
        {
            int j=0;
            for(int i=1; i<=p; i++)
            {
                if(b[i])
                    c[++j]=a[i];//将报素数的小朋友存入c数组
            }
            memset(a,0,sizeof(a));
            for(int i=1; i<=j; i++)
                a[i]=c[i];//用a数组存剩下的小朋友
            memset(c,0,sizeof(c));
            p=j;
        }
        printf("%d\n",a[1]);
    }
    return 0;
}

F:NEFU 2112 纸牌游戏

大佬思路：

在线

  1. 首先我们可以得出一个结论，显然在轮数相同情况下最后剩下的人的序号是确定的。随着n增加，只有让轮数增加才能使最后答案变化，那什么时候轮数会增加呢？我们不难发现只有当多了一个人并且他站到了之前的最后一轮，使最后一轮的人数从一个变成两个才能增加轮数，那怎么确定每增加一个人他是否能站到最后一轮呢？我们递推记录一下每个点的答案，如果n的因子数对应的答案和n-1对应的答案相同了，可以看出n变到n的因子需要一轮，所以可以看出此时n比n-1多一轮了，而n又是在最后一轮两个数的时候处于第二个数的位置，所以n点对应输出的答案就是n。
  2. 我们通过上面（1）这个版本也很容易看出最后可能成为输出答案的数并不多，那么我们每次二分找每次答案的第一次变化时的值迭代递推过去就行，但是这种方法其实是带2个log的（一个是二分的log，一个是迭代次数的log，两个log相乘关系），但是对于t=3e4也可以轻松过的。

离线
既然我们知道答案不多而且每个数x对应的答案都是答案组里小于等于x的最大值，我们只要找到答案组就ok了。提供三种找答案组的方法。

  1. 手动找 我们输入上限1e7可以得到一个答案x，然后我们输入x-1得到答案y，重复11次就可以找到所有答案组。2. 二分 手动二分或者用程序二分找答案第一次变化的位置即可，也是反复找11次即可
  2. 二分 手动二分或者用程序二分找答案第一次变化的位置即可，也是反复找11次即可
  3. 找规律，也可以把前100个数打个表，我们就可以发现答案组有如下规律： 答案组第一个成员是1，然后下一个成员是第一个素数2，然后下一个成员是第2个素数3，然后下一个成员是第3个素数5，然后下一个成员是第5个素数11，然后下一个成员是第11个素数31…找到了这个规律直接把答案组直接递归输出出来即可。

菜鸡（即本人）思路：
打表找规律，你会发现当数据越来越大时，答案数几乎不变了，再看看与之相对应的输出数据，哇！你会发现某个范围内都是一个答案耶，而且刚好是从这个数出现开始直到下个数之间的范围耶，剩下的事情就是找范围啦。
注意：范围的确定。

附上一小部分打表数据：

1=1，
2=2,
3=3,
4=3,
5=5,
6=5,
7=5,
8=5,
9=5,
10=5,
11=11,
12=11,
13=11,
14=11,
15=11,
16=11,
17=11,
18=11,
19=11,
20=11,
21=11,
22=11,
23=11,
24=11,
25=11,
26=11,
27=11,
28=11,
29=11,
30=11,
31=31,
32=31,
33=31,
34=31,
35=31,
36=31,
37=31,
38=31,
39=31,
40=31,
41=31,
42=31,
43=31,
44=31,
45=31,
46=31,
47=31,
48=31,
49=31,
50=31,
51=31,
52=31,
53=31,
54=31,
55=31,
56=31,
57=31,
58=31,
59=31,
60=31,
61=31,
62=31,
63=31,
64=31,
65=31,
66=31,
67=31,
68=31,
69=31,
70=31,
71=31,
72=31,
73=31,
74=31,
75=31,
76=31,
77=31,
78=31,
79=31,
80=31,
81=31,
82=31,
83=31,
84=31,
85=31,
86=31,
87=31,
88=31,
89=31,
90=31,
91=31,
92=31,
93=31,
94=31,
95=31,
96=31,
97=31,
98=31,
99=31,
100=31,
101=31,
102=31,
103=31,
104=31,
105=31,
106=31,
107=31,
108=31,
109=31,
110=31,
111=31,
112=31,
113=31,
114=31,
115=31,
116=31,
117=31,
118=31,
119=31,
120=31,
121=31,
122=31,
123=31,
124=31,
125=31,
126=31,
127=127,
128=127,
129=127,
130=127,
131=127,
132=127,
133=127,
134=127,

因数据太多就只列这一部分啦，如果有兴趣可以自己打打表玩玩啦。
简洁写法：
看这里看这里

在e上面改进的写法：
（本人当时提交的代码，其实当n比较小的时候，变化比较快，列范围有些麻烦，所以本人只写了5381之后的情况，也是能ac的）

#include <bits/stdc++.h>
using namespace std;
queue<int> s;
const int N=1e7+1;
int n,x,cut,prime[N],h;
bool b[N];
void getprime ()
{
    memset(b,1,sizeof(b));
    b[0]=b[1]=0;
    for(int i=2;i<=N;i++)
    {
        if(b[i]) prime[++cut]=i;
        for(int j=1;j<=cut&&prime[j]*i<=N;j++)
        {
            b[prime[j]*i]=0;
            if(i%prime[j]==0) break;
        }
    }
}
int main()
{
   getprime ();
   std::ios::sync_with_stdio(0);
   cin>>n;
   while(n--)
   {cin>>x;
   //printf("%d=",x);
   if(x==1) {printf("1\n");}
   else if(x>=5381&&x<52711){printf("5381\n");}
   else if(x>=52711&&x<648391){printf("52711\n");}
   else if(x>=648391&&x<9737333){printf("648391\n");}
   else if(x>9737333){printf("9737333\n");}
   else{
    for(int i=1;i<=x;i++){
    if(b[i])s.push(i);
   }
   x=s.size();
   while(s.size()>1)
   {
   for(int i=1;i<=x;i++)
   {
       if(i==1){h=s.back();
       //printf("%d %d\n",h,x);
       }
       int tmp=s.front();
       s.pop();
       if(b[i]) {s.push(tmp);
       //printf("%d %d\n",i,tmp);
       }
       if(h==tmp&&s.size()!=1){i=0;x=s.size();}
   }
   }
   while(!s.empty())
   {
       printf("%d\n",s.front());
       s.pop();
   }
   }
   }
   return 0;
}

G:NEFU 2023 库特的绳子

思路：贪心的思想+优先队列
这题算是序列合并-优先队列这题的变形，当然此题也是洛谷上的一道经典题洛谷 P1631 序列合并。
用两个从小到大排列的优先队列分别存储绳子长度和钉子间隔，对于钉子间隔，先把每个紧邻的钉子的间隔以及钉子位置用存入队列，如果这个间隔可以挂上绳子，则这个区间被利用，右钉子向右移动一个位置获取信息存入数组，重复操作直到所有绳子都被挂上。

#include <bits/stdc++.h>
using namespace std;
const int N=5e5+10;
int n,m,a[N],x;
struct sa {
int jg;//间隔
int ldz;//左钉子的位置
int rdz;//右钉子的位置
};

bool operator < (const sa &a,const sa &b)
{
  return a.jg>b.jg;
}
priority_queue <int,vector<int>,greater<int> > sz;
priority_queue <sa> dz;
int main()
{
    while(~scanf("%d%d",&n,&m))
    {
        for(int i=1;i<=n;i++)
        {
         scanf("%d",&a[i]);//接收钉子位置
        }
        for(int i=1;i<=m;i++)
        {
         scanf("%d",&x);
         sz.push(x);//接收绳子长度
        }
        for(int i=1;i<n;i++)
        {
            dz.push({a[i+1]-a[i],i,i+1});//将钉子间隔压入队列
        }
        int f=1;
        while(!sz.empty())
        {
            int tmp=sz.top();
            sz.pop();
            if(dz.empty()||dz.top().jg>tmp)//若没有间隔或绳子长度小于间隔，不符合，跳出
            {
                f=0;break;
            }
            else//默认绳子长度大于间隔
            {
                sa tm=dz.top();
                dz.pop();
                if(tm.rdz+1<=n)//左钉子不为最后一个钉子
                {
                    dz.push({a[tm.rdz+1]-a[tm.ldz],tm.ldz,tm.rdz+1});//右钉子向右移动一位，获取其长度；
                }
            }
        }
        f==1?printf("yes\n"):printf("no\n");
    }
    return 0;
}
groperr
关注
专栏目录
c++stl之优先队列（priority_queue）
zhoucheng_123的博客
02-13 396
1.大跟堆：从小到大，最小的优先级最高定义方法： priority_queue<int,vector<int>,greater<int> >vis; 注意vis左边> >这两个">"中间有个空格，不能少 2.小跟堆：从大到小，最大的优先级最高 定义方法： priority_queue<int>vis; 基本跟队列相同，不同的是：...
大一寒假总结一
weixin_43690480的博客
01-18 937
        期末考试过去一周了，但是只能查到部分成绩，看到成绩的那一刻，有惊喜，有失望，有后悔，有难受，但是考试已经结束，怎样想都已是定局，无法改变，唯一能做的就是继续向前，知道了自己的缺点和遗憾，就要去改正和弥补。回想考试前的几天，自己是有点浮躁，各科都很担心，但是又没有制定合理的复习计划，哪科先考就先复习哪科，复习的时候却又没有方向，很是迷茫，把往年的题拿来做做，多练几遍，Java考试的题...
优先队列
hhhcbw的博客，欢迎各位来访
02-22 421
优先队列(priority queue) 普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （first in, largest out）的行为特征。通常采用堆数据结构来实现。//摘自百度百科 简单的来说，优先队列作为一个容器，保证按照规定的顺序，最‘大’的元素优先删除。（这里的...
NEFU 大一寒假2.15考试 2020.02.15
果光的博客
02-15 1026
Summary 昨天的 题目预测 准确率 1/7=14.29%，也算是意料之中吧。 毕竟是个考试嘛，而且似乎可能差不多已经暴露了预测吧。 什么？你没看到昨天的题目预测？再仔细观察一下那个 peach 吧， 难道你就没有怀疑过我为啥要把它扔进 CTF 专栏吗？ 我会真的发一个 peach 吗？Of course not！ 好吧，如果你实在没有发现，请看本文末尾的彩蛋 ~ 至于这个官方题解里的六花嘛...
队列+素数
mantou_riji的博客
02-17 355
problem A:机器人 机器人Bo很聪明，会做许多事情。惟独对自然数的理解与人类不一样,它是从右往左读数。比如，它看到123时，会理解成321.让它比较23与15哪一个大，它说15大。原因是它的大脑会以为是32与51在进行比较.再比如让它比较29与30，它说29大。 当然对于像90，它会把它当成9处理。给定Bo N个自然数x，让它将这N个数按从小到大排序出来。你会认为它如何排序？ Input...
2020.2.15 寒假大一2.15考试
Kingrrr的博客行程
02-15 429
大一线上集训第一次考试
ACM.大一寒假2.15考试
abysswatcher1的博客
02-16 252
机器人 Problem:A Time Limit:1000ms Memory Limit:65535K Description 机器人Bo很聪明，会做许多事情。惟独对自然数的理解与人类不一样,它是从右往左读数。比如，它看到123时，会理解成321.让它比较23与15哪一个大，它说15大。原因是它的大脑会以为是32与51在进行比较.再比如让它比较29与30，它说29大。 当然对于像90，它会把它当成...
NEFU 大一寒假2.15考试 题目预测
果光的博客
02-14 995
嘘！内含明天考试题目
2022年大一寒假的计算机社会实践报告.docx
07-13
计算机社会实践报告反映了大学生在2022年大一寒假期间对计算机应用的探索与实践，主要涉及了互联网的发展、网站建设、计算机技术的进步以及网络技术在日常生活中的应用。以下是相关知识点的详细说明： 1. **互联网...
大一寒假学习方案书.docx
11-05
【大一寒假学习方案书】 寒假对于大一学生来说，是一个宝贵的自我提升和休息调整的时期。合理规划寒假学习和生活，既能确保休息充分，又能有效地提升自我能力，为接下来的学年做好准备。以下是一些针对大一学生寒假...
湖北省襄阳市第五中学2020届高三英语寒假远程授课考试试题一
09-08
这篇内容是湖北省襄阳市第五中学2020届高三英语寒假远程授课考试试题的一部分，主要考察学生的英语听力理解能力。听力部分通常包括日常生活对话、信息获取、推理判断等多个方面，对于提高学生的实际语言运用能力和...
大一寒假实践报告书.docx
11-21
在大一寒假实践报告书中，我们关注的主题是如何有效地利用大学的第一个长假，即寒假。大一新生在经历了高中阶段的高强度学习后，进入大学生活，压力骤减，时间变得更为自由。寒假不再像高中那样被作业和家长的督促填...
大一寒假实践报告书.doc
02-19
【大一寒假实践报告书】 在大学的第一个寒假，学生们面临的是一个全新的生活阶段，摆脱了高中的繁重学业和家长的直接监督。这个假期既漫长又自由，如何有效利用这段时间成为了许多大一新生关注的问题。通过对两组...
Microsoft Office Professional Plus 2007 Datasheet_CN_Final.doc
10-11
Microsoft Office Professional Plus 2007 Datasheet_CN_Final.doc
ProPlus2007 SuiteComparison.doc
10-11
ProPlus2007 SuiteComparison.doc
Unity动态加载外部3D模型的插件TriLib1.8.7-TriLib2.2.0
10-11
1.8-1.9直接导入，支持2018.4.9 2.0以上版本 当创建一个标准渲染管道项目时，从包中导入“TriLibCore”文件夹。 当创建HDRP项目时，从包中导入“TriLibHDRP”和“TriLibCore”文件夹。 在创建UniversalRP项目时，从包中导入“TriLibUniversalRP”和“TriLibCore”文件夹。 当使用自定义渲染管道时，你应该扩展“MaterialMapper”类。 FBX, OBJ, GLTF2, STL, PLY, 3MF, DAE*和ZIP文件支持跨平台:Windows, Mac, Linux, UWP, Android, WebGL和ioSImport模型从文件系统，web，或任何自定义源trilib可以帮助您添加建模功能，创建关卡/场景编辑器，创建AR/VR可视化
扫描电子显微镜（SEM），全球前9强生产商排名及市场份额（by QYResearch）.pdf
10-11
QYResearch是全球知名的大型咨询公司，行业涵盖各高科技行业产业链细分市场，横跨如半导体产业链（半导体设备及零部件、半导体材料、集成电路、制造、封测、分立器件、传感器、光电器件）、光伏产业链（设备、硅料/硅片、电池片、组件、辅料支架、逆变器、电站终端）、新能源汽车产业链（动力电池及材料、电驱电控、汽车半导体/电子、整车、充电桩）、通信产业链（通信系统设备、终端设备、电子元器件、射频前端、光模块、4G/5G/6G、宽带、IoT、数字经济、AI）、先进材料产业链（金属材料、高分子材料、陶瓷材料、纳米材料等）、机械制造产业链（数控机床、工程机械、电气机械、3C自动化、工业机器人、激光、工控、无人机）、食品药品、医疗器械、农业等。 邮箱：market@qyresearch.com
DiscuzX3.4模板W!简论坛风格 适合于资源站
最新发布
10-11
DiscuzX3.4模板W!简论坛风格 适合于资源站等 此模板使用程序是Discuz!X3.4 应用介绍： 【升级提示】因20180808升级新增了论坛首页边栏调用内容，所以在导入论坛首页diy的时候，需要开启边栏，管理中心--界面--界面设置--论坛首页--开启边栏（是）。老用户如果想更新请先清空论坛首页diy，再重新导入新diy文件。 --模板介绍-- ->模板名称：W!"简"论坛风格。 ->模板无门户页面，开启门户无任何效果。 ->无DIY免费版没有diy文件，需要diy文件的请先购买相应带diy版本。 ->模板部分数据采用DIY数据数据调用方式，前台操作简单易用。 >模板论坛列表页开启边栏，再进行diy的导入。 ->模板论坛页面支持宽窄屏切换，支持discuz自带图片列表模式（瀑布流）。 安装教程：下载模板-----把模板上传到网站根目录的/template文件夹------解压
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值