【骗分】2021年第十二届蓝桥杯省赛第一场 C++ B组

本文主要是介绍【骗分】2021年第十二届蓝桥杯省赛第一场 C++ B组，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

2021年第十二届蓝桥杯省赛第一场 C++ B组

• • 试题 A：空间
  • • 【问题描述】
    • 【答案提交】
    • 【答案】：67108864
  • 试题 B：卡片
  • • 【问题描述】
    • 【答案提交】
    • 【答案】：3181
  • 试题 C：直线
  • • 【问题描述】
    • 【答案提交】
    • 【答案】：40257
  • 试题 D：货物摆放
  • • 【问题描述】
    • 【答案提交】
    • 【答案】：2430
  • 试题 E：路径
  • • 【问题描述】
    • 【答案提交】
    • 【答案】：10266837
  • 试题 F：时间显示
  • • 【问题描述】
    • 【输入格式】
    • 【输出格式】
    • 【样例输入 1 】
    • 【样例输出 1 】
    • 【样例输入 2 】
    • 【样例输出 2 】
    • 【评测用例规模与约定】
    • 【答案】
  • 试题 G：砝码称重
  • • 【问题描述】
    • 【输入格式】
    • 【输出格式】
    • 【样例输入】
    • 【样例输出】
    • 【样例说明】
    • 【评测用例规模与约定】
    • 【答案】
  • 试题 H：杨辉三角形
  • • 【问题描述】
    • 【输入格式】
    • 【输出格式】
    • 【样例输入】
    • 【样例输出】
    • 【评测用例规模与约定】
    • 【答案】
  • 试题 I：双向排序
  • • 【问题描述】
    • 【输入格式】
    • 【输出格式】
    • 【样例输入】
    • 【样例输出】
    • 【样例说明】
    • 【评测用例规模与约定】
    • 【答案】
  • 试题 J：括号序列
  • • 【问题描述】
    • 【输入格式】
    • 【输出格式】
    • 【样例输入】
    • 【样例输出】
    • 【评测用例规模与约定】
    • 【答案】
  • 【总结】

试题 A：空间

【问题描述】

小蓝准备用256MB的内存空间开一个数组，数组的每个元素都是32位 二进制整数，如果不考虑程序占用的空间和维护内存需要的辅助空间，请问256MB的空间可以存储多少个32位二进制整数？

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【答案】：67108864

#include <iostream>

using namespace std;

int main()
{
    cout<<256/32*1024*1024*8;
    return 0;
}

很简单，没什么好说的。

试题 B：卡片

【问题描述】

小蓝有很多数字卡片，每张卡片上都是数字0到9。
小蓝准备用这些卡片来拼一些数。他想从1开始拼出正整数，每拼一个，就保存起来，卡片就不能用来拼其他数了。
小蓝想知道自己能从1拼到多少。
例如，当小蓝有30张卡片，其中0到9各3张，则小蓝可以拼出1到10，但是拼到11时卡片只有一张了，不够拼出11。
现在小蓝手里有0到9的卡片各2021张，共20210张，请问小蓝可以从1 拼到多少？
提示：建议使用计算机编程解决问题。

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【答案】：3181

#include <iostream>
#include <vector>

using namespace std;

vector<int> num(10,2021);

bool check(int i)
{
    while(i)
    {
        if(--num[i%10]<0){return true;}
        i /= 10;
    }
    return false;
}

int main()
{
    int i=1;
    while(true)
    {
        if(check(i)){break;}
        i++;
    }
    cout<<--i;
    return 0;
}

模拟一下就出来了，结果记得减1。

试题 C：直线

【问题描述】

在平面直角坐标系中，两点可以确定一条直线。如果有多点在一条直线上，那么这些点中任意两点确定的直线是同一条。
给定平面上2 × \times × 3个整点 { ( x , y ) ∣ 0 ≤ x < 2 , 0 ≤ y < 3 , x ∈ Z , y ∈ Z } \{(x,y)|0 \le x \lt 2,0 \le y \lt 3,x \in Z,y \in Z\} {(x,y)∣0≤x<2,0≤y<3,x∈Z,y∈Z} ，即横坐标是0到1（包含0和1）之间的整数，纵坐标是0到2（包含0和2）之间的整数的点。这些点一共确定了11条不同的线。
给定平面上20 × \times × 21个整点 { ( x , y ) ∣ 0 ≤ x < 20 , 0 ≤ y < 21 , x ∈ Z , y ∈ Z } \{(x,y)|0 \le x \lt 20,0 \le y \lt 21,x \in Z,y \in Z\} {(x,y)∣0≤x<20,0≤y<21,x∈Z,y∈Z} ，即横坐标是0到19（包含0和19）之间的整数，纵坐标是0到20（包含0和20）之间的整数的点。请问这些点一共确定了多少条不同的直线。

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【答案】：40257

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

int w=20,h=21;
vector<vector<int> > points;
vector<vector<int> > k;

int main()
{
    for(int i=0;i<w;i++)
    {
        for(int j=0;j<h;j++)
        {
            vector<int> temp;temp.push_back(i);temp.push_back(j);
            points.push_back(temp);
        }
    }

    for(int i=0;i<points.size();i++)
    {
        for(int j=i+1;j<points.size();j++)
        {
            bool ex = false;
            int x1, y1, x2, y2;
            x1 = points[i][0];y1 = points[i][1];x2 = points[j][0];y2 = points[j][1];
            vector<int> temp;
            temp.push_back(y2-y1);temp.push_back(x2-x1);temp.push_back(x1*temp[0]+y1*temp[1]);
            for(int b=0;b<k.size();b++)
            {
                if(k[b][1]*temp[0] == k[b][0]*temp[1] && x1*k[b][0] + y1*k[b][1] - k[b][2]==0){ex=true;break;}
            }
            if(ex){continue;}
            k.push_back(temp);
        }
    }
    cout<<k.size();
    return 0;
}

我做题的时候是用 y = a x + b y=ax+b y=ax+b 的形式保存的，结果不一样，应该是精度炸了。这里换了 a x + b y + c = 0 ax+by+c=0 ax+by+c=0 的形式保存，只要整型就行了，更加优雅，结果也对了，但因为不方便用哈希表直接去重，所以跑的时间稍长一点，可以优化一下。

试题 D：货物摆放

【问题描述】

小蓝有一个超大的仓库，可以摆放很多货物。
现在，小蓝有 n n n 箱货物要摆放在仓库，每箱货物都是规则的正方体。小蓝规定了长、宽、高三个互相垂直的方向，每箱货物的边都必须严格平行于长、宽、高。
小蓝希望所有的货物最终摆成一个大的立方体。即在长、宽、高的方向上分别堆 L 、 W 、 H L、W、H L、W、H 的货物，满足 n = L × W × H n=L \times W \times H n=L×W×H。
给定 n n n ，请问有多少种堆放货物的方案满足要求。
例如，当 n = 4 n=4 n=4 时，有以下6种方案： 1 × 1 × 4 1 \times 1 \times 4 1×1×4 、 1 × 2 × 2 1 \times 2 \times 2 1×2×2 、 1 × 4 × 1 1 \times 4 \times 1 1×4×1 、 2 × 1 × 2 2 \times 1 \times 2 2×1×2 、 2 × 2 × 1 2 \times 2 \times 1 2×2×1 、 4 × 1 × 1 4 \times 1 \times 1 4×1×1 。
请问，当 n = 2021041820210418 n=2021041820210418 n=2021041820210418 （注意有16位数字）时，总共有多少种方案？
提示：建议使用计算机编程解决问题。

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【答案】：2430

不会。

试题 E：路径

【问题描述】

小蓝学习了最短路径之后特别高兴，它定义了一个特别的图，希望找到图中的最短路径。
小蓝的图由2021个结点组成，依次编号1至2021。
对于两个不同的节点 a , b a,b a,b ，如果 a a a 和 b b b 的差的绝对值大于21，则两个结点之间没有边相连；如果 a a a 和 b b b 的差的绝对值小于等于21，则两个点之间有一条长度为 a a a 和 b b b 的最小公倍数的无向边相连。
例如：结点1和结点23之间没有边相连；结点3和节点24之间有一条无向边，长度为24；结点15和节点25之间有一条无向边，长度为75。
请计算，结点1和节点2021之间的最短路径长度是多少。
提示：建议使用计算机编程解决问题。

【答案提交】

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

【答案】：10266837

#include <iostream>
#include <vector>
#include <cstring>

using namespace std;

int m[2021][2021];

int gcb(int a, int b)
{
    if(b==0){ return a;}
    return gcb(b, a%b);
}

int lcm(int a, int b)
{
    return a*b/gcb(a, b);
}

int main()
{
    memset(m, 0x3f, sizeof m);
    for(int i=0;i<2021;i++)
    {
        for(int j=i+1;j<i+22;j++)
        {
            if(j>2020){break;}
            int temp = lcm(i+1, j+1);
            m[i][j] = temp;
            m[j][i] = temp;
        }
    }
    for(int i=0;i<2021;i++)
    {
        for(int j=0;j<2021;j++)
        {
            for(int k=0;k<2021;k++)
            {
                if( m[i][j]==0 || m[j][k]==0){continue;}
                m[i][k] = min(m[i][k], m[i][j]+m[j][k]);
            }
        }
    }
    cout<<m[0][2020];
    return 0;
}

去年有最大公约数，今年看到最小公倍数一下蒙了，没想到可以a*b/gcb(a, b)。然后还自己写了一长段怎么求最小公倍数。最后临结束运行成功了，但试了一下3到24，结果是错的，以为再给点时间改一下就能出来，但现在看来当时离正确结果还很远。

试题 F：时间显示

【问题描述】

小蓝要和朋友合作开发一个时间显示的网站。在服务器上，朋友已经获取了当前的时间，要用一个整数表示，值为从1970年1月1日00:00:00到当前时刻经过的毫秒数。
现在，小蓝要在客户端显示出这个时间。小蓝不用显示出年月日，只需要显示出时分秒即可，毫秒也不用显示，直接舍去即可。
给定一个用正数表示的时间，请将这个时间对应的时分秒输出。

【输入格式】

输入一行包含一个整数，表示时间。

【输出格式】

输出时分秒表示的当前时间，格式形如HH:MM:SS，其中HH表示时，值为0到23，MM表示分，值为0到59，SS表示秒，值为0到59。时、分、秒不足两位时补前导0。

【样例输入 1 】

46800999

【样例输出 1 】

13:00:00

【样例输入 2 】

1618708103123

【样例输出 2 】

01:08:23

【评测用例规模与约定】

对于所有测评用例，给定的时间为不超过 1 0 18 10^{18} 1018 的正整数。

【答案】

#include <iostream>

using namespace std;

int main()
{
    long long int t;
    cin>>t;
    t /= 1000;
    t %= 60*60*24;
    int h = t/3600;
    t %= 3600;
    int m = t/60;
    int s = t%60;
    printf("%.2d:%.2d:%.2d",h ,m ,s);
    return 0;
}

试题 G：砝码称重

【问题描述】

你有一架天平和 N N N 个砝码重量依次是 W 1 、 W 2 、 . . . 、 W N W_1、W_2、... 、W_N W1​、W2​、...、WN​ 。
请你计算一共可以称出多少种不同的重量？
注意砝码可以放在天平两边。

【输入格式】

输入的第一行包含一个整数 N N N。
第二行包含 N N N 个整数： W 1 、 W 2 、 . . . 、 W N W_1、W_2、... 、W_N W1​、W2​、...、WN​ 。

【输出格式】

输出一个整数代表答案。

【样例输入】

3

1 4 6

【样例输出】

10

【样例说明】

能称出的10种重量是：1、2、3、4、5、6、7、9、10、11。
1=1；
2=6-4（天平一边放6，另一边放4）；
3=4-1；
4=4；
5=6-1；
6=6；
7=1+6；
9=4+6-1；
10=4+6；
11=1+4+6。

【评测用例规模与约定】

对于 50 % 50\% 50% 的测评用例， 1 ≤ N ≤ 15 1 \le N \le 15 1≤N≤15。
对于所有测评用例， 1 ≤ N ≤ 100 1 \le N \le 100 1≤N≤100， N N N 个砝码总重不超过 100000 100000 100000 。

【答案】

#include <iostream>
#include <vector>

using namespace std;

int ex[100001];
vector<int> w;

int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int wi;
        cin>>wi;
        int s = w.size();
        for(int j=0;j<s;j++)
        {
            int temp1 = abs(w[j] + wi);
            int temp2 = abs(w[j] - wi);
            if(ex[temp1]==0){w.push_back(temp1);ex[temp1]=1;}
            if(ex[temp2]==0){w.push_back(temp2);ex[temp2]=1;}
        }
        if(ex[wi]==0){w.push_back(wi);ex[wi]=1;}
    }
    cout<<w.size();
    return 0;
}

没想太多，不知道能不能过所有用例。

试题 H：杨辉三角形

【问题描述】

下面的图形是著名的杨辉三角形：
　　　　　　　　　　　　1
　　　　　　　　　　　1　1
　　　　　　　　　　1　2　1
　　　　　　　　　1　3　3　1
　　　　　　　　1　4　6　4 　1
　　　　　　　1　５　10　10　5　1
　　　　　．．．　　　．．．　　　．．．

【输入格式】

输入一个整数 N N N 。

【输出格式】

输出一个整数代表答案。

【样例输入】

６

【样例输出】

1３

【评测用例规模与约定】

对于 20 % 20\% 20% 的测评用例， 1 ≤ N ≤ 10 1 \le N \le 10 1≤N≤10。
对于所有测评用例， 1 ≤ N ≤ 1000000000 1 \le N \le 1000000000 1≤N≤1000000000 。

【答案】

#include <iostream>
#include <vector>

using namespace std;

vector<int> temp1(2,1);
vector<int> temp2;

int getval(int i, int j)
{
    if(j==0 || j==i-1){return 1;}
    return temp1[j] + temp1[j-1];
}

int main()
{
    int n;
    bool ex = false;
    cin>>n;
    int i=3;
    int num = 3;
    while(true)
    {
        for(int j=0;j<i;j++)
        {
            temp2.push_back(getval(i,j));
            num++;
            if(temp2.back()==n){ex=true;break;}
        }
        if(ex){break;}
        temp1 = temp2;
        temp2.clear();
        i++;
    }
    cout<<num;
    return 0;
}

没找到太好的规律，骗分了， n n n 在 10000 10000 10000 左右就肯定超时了，不知道能骗几分。

试题 I：双向排序

【问题描述】

给定序列 ( a 1 , a 2 , ⋯   , a n ) = ( 1 , 2 , ⋯   , n ) (a_1,a_2, \cdots ,a_n)=(1,2, \cdots ,n) (a1​,a2​,⋯,an​)=(1,2,⋯,n) ，即 a i = i a_i = i ai​=i。
小蓝将对这个序列进行 m m m 次操作，每次可能是将 a 1 , a 2 , ⋯   , a q i a_1,a_2, \cdots ,a_{q_i} a1​,a2​,⋯,aqi​​ 降序排列，或者将 a q i , a q i + 1 , ⋯   , a n a_{q_i},a_{q_i+1}, \cdots ,a_n aqi​​,aqi​+1​,⋯,an​ 升序排列。
请求出操作完成后的序列。

【输入格式】

输入的第一行包含两个整数 n , m n,m n,m，分别表示序列的长度和操作次数。

接下来 m m m 行描述对序列的操作，其中第 i i i 行包含两个整数 p i , q i p_i,q_i pi​,qi​ 表示操作类型和参数。当 p i = 0 p_i=0 pi​=0 时，表示将 a 1 , a 2 , ⋯   , a q i a_1,a_2, \cdots ,a_{q_i} a1​,a2​,⋯,aqi​​ 降序排列；当 p i = 1 p_i=1 pi​=1 时，表示将将 a q i , a q i + 1 , ⋯   , a n a_{q_i},a_{q_i+1}, \cdots ,a_n aqi​​,aqi​+1​,⋯,an​ 升序排列。

【输出格式】

输出一行，包含 n n n 个整数，相邻的整数之间使用一个空格分隔，表示操作完成后的序列。

【样例输入】

3　3

0　3

1　2

0　2

【样例输出】

3　1　2

【样例说明】

原数列为 ( 1 , 2 , 3 ) (1,2,3) (1,2,3) 。

第 1 1 1 步后为 ( 3 , 2 , 1 ) (3,2,1) (3,2,1)。

第 2 2 2 步后为 ( 3 , 1 , 2 ) (3,1,2) (3,1,2)。

第 3 3 3 步后为 ( 3 , 1 , 2 ) (3,1,2) (3,1,2)。与第二步操作后相同，因为前两个数已经是降序了。

【评测用例规模与约定】

对于 30 % 30\% 30% 的测评用例，$ n,m \le 1000$;

对于 60 % 60\% 60% 的测评用例，$ n,m \le 5000$;

对于所有测评用例， n , m ≤ 100000 , 0 ≤ p i ≤ 1 , 1 ≤ q i ≤ n n,m \le 100000,0 \le p_i \le 1, 1 \le q_i \le n n,m≤100000,0≤pi​≤1,1≤qi​≤n 。

【答案】

#include <iostream>
#include <algorithm>

using namespace std;

int num[100000];

bool cmp(int a, int b)
{
    bool result;
    a<b?result=false:result=true;
    return result;
}

int main()
{
    int n, m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        num[i-1] = i;
    }
    for(int i=0;i<m;i++)
    {
        int p,q;
        cin>>p>>q;
        if(p==0)
        {sort(num,num+q, cmp);}
        else
        {sort(num+q-1,num+n);}
    }
    for(int i=0;i<n;i++){cout<<num[i]<<" ";}
    return 0;
}

不会，sort()骗分了。

试题 J：括号序列

【问题描述】

给定一个括号序列，要求尽可能少地添加若干括号使得括号序列变得合法，当添加完成后，会产生不同的添加结果，请问有多少种本质不同的添加结果。两个结果是本质不同的是指存在某个位置一个结果是左括号，而另一个是右括号。

例如，对于括号序列（（（），只需要添加两个括号就能让其合法，有以下几种不同的添加结果：（）（）（）、（）（（））、（（））（）、（（）（））和（（（）））。

【输入格式】

输入一行包含一个字符串 s s s ，表示给定的括号序列，序列中只有左括号和右括号。

【输出格式】

输出一个整数表示答案，答案可能很大，请输出答案除以1000000007（即 1 0 9 + 7 10^9+7 109+7 ）的余数。

【样例输入】

（（（）

【样例输出】

5

【评测用例规模与约定】

对于 40 % 40\% 40% 的测评用例，$ |s| \le 200$ 。

对于所有测评用例， 1 ≤ ∣ s ∣ ≤ 5000 1 \le |s| \le 5000 1≤∣s∣≤5000 。

【答案】

不会。

【总结】

数学专业，听说蓝桥杯有手就行，就想来试一试，现在我只想说：
同时还想把考场上的我拉出来打一顿，感觉没带脑子。

这篇关于【骗分】2021年第十二届蓝桥杯省赛第一场 C++ B组的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！