精华内容
下载资源
问答
  • 2021-04-09 18:06:46

    提交

    题解:先把编号从小到大排列,如果编号相同就把时间从小到大进行排列。两层for循环暴力、剪枝、book数组进行标记、点赞个数等于k,跳出、编号不相等跳出。

    AC代码:

    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    #include<queue>
    #include<stack>
    #include<map>
    #include<stdlib.h>
    #include<algorithm>
    using namespace std;
    int n,d,k;
    int book[100010];
    struct note
    {
    	int ts,id;
    } q[100010];
    bool cmp(note x,note y)
    {
    	if(x.id==y.id)
    		return x.ts<y.ts;
    	return x.id<y.id;
    }
    int main()
    {
    	scanf("%d%d%d",&n,&d,&k);
    	int i,j,s;
    	for(i=0; i<n; i++)
    		scanf("%d%d",&q[i].ts,&q[i].id);
    	sort(q,q+n,cmp);
    	for(i=0; i<n; i++)
    	{
    		s=1;
    		if(book[q[i].id]==0)
    		{
    			for(j=i+1; j<n; j++)
    			{
    				if((q[i].id==q[j].id)&&(q[j].ts<(q[i].ts+d)))
    					s++;
    				if(s==k||q[i].id!=q[j].id)//剪枝
    					break;
    			}
    			if(s==k)
    			{
    				book[q[i].id]=1;
    				printf("%d\n",q[i].id);
    			}
    		}
    	}
    	return 0;
    }
    
    更多相关内容
  • 第九届蓝桥杯省赛C语言b组.zip
  • 2018年第九届蓝桥杯省赛真题 C/C++ 语言大学B组原题。
  • 2018省赛第九届蓝桥杯真题C语言B组;2018省赛第九届蓝桥杯真题C语言B组;2018省赛第九届蓝桥杯真题C语言B组;2018省赛第九届蓝桥杯真题C语言B组;2018省赛第九届蓝桥杯真题C语言B组;2018省赛第九届蓝桥杯真题C语言B...
  • 这是2018年省赛第九届蓝桥杯真题C/C++(B组),新鲜出炉。。
  • 这是2018年省赛第九届蓝桥杯真题Java(B组),新鲜出炉。。
  • 蓝桥杯结果填空几天程序设计 结果填空 几天 问题描述 2000年的1月1日,是那一年的1天。 那么,2000年的5月4日,是那一年的几天? 答案提交 注意:需要提交的是一个整数,不要填写任何多余内容。 程序设计 ...

    结果填空

    第几天

    问题描述

    2000年的1月1日,是那一年的第1天。
    那么,2000年的5月4日,是那一年的第几天?

    答案提交
    注意:需要提交的是一个整数,不要填写任何多余内容。

    口算或者excel大法都行,答案:125

    明码

    问题描述
    汉字的字形存在于字库中,即便在今天,16 点阵的字库也仍然使用广泛。

    16 点阵的字库把每个汉字看成是16 x 16个像素信息,并把这些信息记录在字节中。

    一个字节可以存储 8 位信息,用 32 个字节就可以存一个汉字的字形了。

    把每个字节转为 2 进制表示,1 表示墨迹,0 表示底色。

    每行 2 个 字节,一共 16 行,布局是:

    第 1 字节,第 2 字节
    第 3 字节,第 4 字节

    第 31 字节, 第 32 字节

    这道题目是给你一段多个汉字组成的信息,每个汉字用 32 个字节表示,这里给出了字节作为有符号整数的值。

    题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形,从中看出题目的要求,并根据要求填写答案。

    这段信息是(一共 10 个汉字):

    4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0 
    16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16 
    4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0 
    0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4 
    4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64 
    16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128 
    0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0 
    2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0 
    1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0 
    0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0 
    

    答案提交
    注意:需要提交的是一个整数,不要填写任何多余内容。

    这里稍微有点问题的是负数转二进制,直接转是不行的,这里应该要的是补码形式,实现方法:

    bin(x&0xffffffff)  #x即为要转的数
    

    每一行有32个数,2个数分为一组,分别转为二进制后拼在一起,得到16*16的字符串来表示一个汉字

    lt = [4, 0, 4, 0, 4, 0, 4, 32, -1, -16, 4, 32, 4, 32, 4, 32, 4, 32, 4, 32, 8, 32, 8, 32, 16, 34, 16, 34, 32, 30, -64, 0]
    for i in range(32):
        s = bin(lt[i]&0xffffffff)[-8:]
        s = s.replace('0b',"")
        x = s.zfill(8).replace('0',' ').replace('1','*')
        if i%2 == 0:
            print(x,end="")
        else:
            print(x)
    '''
         *          
         *          
         *          
         *    *     
    ************    
         *    *     
         *    *     
         *    *     
         *    *     
         *    *     
        *     *     
        *     *     
       *      *   * 
       *      *   * 
      *        **** 
    ** 
    '''            
    

    把所有数都输进去就可以得到结果:九的九次方等于多少?

    所以答案:387420489

    for j in range(10):
        lt = []
        for item in map(int,input().split()):
            lt.append(item)
    
        for i in range(32):
            if lt[i] < 0:
                s = bin(lt[i]&0xffffffff)[-8:]
            else:
                s = bin(lt[i])
            s = s.replace('0b',"")
            x = s.zfill(8).replace('0',' ').replace('1','*')
            if i%2 == 0:
                print(x,end="")
            else:
                print(x)
        print()
    

    乘积尾零

    问题描述

    如下的10行数据,每行有10个整数,请你求出它们的乘积的末尾有多少个零?

    5650 4542 3554 473 946 4114 3871 9073 90 4329
    2758 7949 6113 5659 5245 7432 3051 4434 6704 3594
    9937 1173 6866 3397 4759 7557 3070 2287 1453 9899
    1486 5722 3135 1170 4014 5510 5120 729 2880 9019
    2049 698 4582 4346 4427 646 9742 7340 1230 7683
    5693 7015 6887 7381 4172 4341 2909 2027 7355 5649
    6701 6645 1671 5978 2704 9926 295 3125 3878 6785
    2066 4247 4800 1578 6652 4616 1113 6205 3264 2915
    3966 5291 2904 1285 2193 1428 2265 8730 9436 7074
    689 5510 8243 6114 337 4096 8199 7313 3685 211
    

    答案提交
    注意: 需要提交的是一个整数,表示末尾零的个数。不要填写任何多余内容。

    相乘之后数一下就行,答案:31

    测试次数

    问题描述

    x星球的居民脾气不太好,但好在他们生气的时候唯一的异常举动是:摔手机。

    各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试,并且评定出一个耐摔指数来,之后才允许上市流通。

    x星球有很多高耸入云的高塔,刚好可以用来做耐摔测试。
    塔的每一层高度都是一样的,与地球上稍有不同的是,他们的第一层不是地面,而是相当于我们的2楼。

    如果手机从第 7 层扔下去没摔坏,但第 8 层摔坏了,则手机耐摔指数 = 7。

    特别地,如果手机从第 1 层扔下去就坏了,则耐摔指数 = 0。

    如果到了塔的最高层第 n 层扔没摔坏,则耐摔指数 = n

    为了减少测试次数,从每个厂家抽样3部手机参加测试。

    某次测试的塔高为1000层,如果我们总是采用最佳策略,在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢?

    请填写这个最多测试次数。

    答案提交
    注意:需要填写的是一个整数,不要填写任何多余内容。

    思路

    首先要弄清最佳策略最坏的运气

    如果只有一部手机,只能从第一层开始试,最坏的情况是到最高层才得到结果。
    
    当有两部手机,塔高为3时,有三种方案:
    1、从第一层开始,那么最坏的情况是测试32、从第二层开始,可能摔坏也可能部摔坏,最坏的情况是测试23、从第三层开始,最坏的情况也是测试3(3-1-2)
    所以最优策略是从第二层开始,至少要测试2

    这里可以用DP的方法,f[i][j]代表有i部手机、塔高为j层时,最坏运气下的最小测试次数。
    从一部手机的例子可以得知,最坏的情况是测试次数等于楼层总高度,所以要初始化:f[i][j] = j

    从x层开始测试,会有两种情况
    1、摔坏了
    则手机的数量-1,要去更低的楼层测试,最多再测x-1次
    即总测试次数为 f[i-1][x-1]+1
    2、没摔坏
    则去更高的楼层测试,最多再测j-x次
    即总测试次数为 f[i][j-x]+1
    
    那么当前方案(从x层开始)最坏运气下所需测试次数为max(f[i-1][x-1],f[i][j-x]) + 1
    从所有方案中取最小值即为最佳策略
    

    答案:19

    high = 1005 
    
    f=[[0] * 1005 for i in range(3)] 
    
    for i in range(3): #初始化
        for j in range(1005):
            f[i][j] = j
    
    for i in range(1,3):
        for j in range(1,high):
            for k in range(1,j):
                f[i][j] = min(f[i][j], max(f[i-1][k-1], f[i][j-k])+1)
    
    #一维数组下标为0、1、2,对应1、2、3部手机                            
    print(f[2][1000])
    

    程序设计

    递增三元组

    	给定三个整数数组
      A = [A1, A2, ... AN],
      B = [B1, B2, ... BN],
      C = [C1, C2, ... CN],
      请你统计有多少个三元组(i, j, k) 满足:
      1. 1 <= i, j, k <= N
      2. Ai < Bj < Ck
    

    输入格式

    	第一行包含一个整数N。
      第二行包含N个整数A1, A2, ... AN。
      第三行包含N个整数B1, B2, ... BN。
      第四行包含N个整数C1, C2, ... CN。
    
      对于30%的数据,1 <= N <= 100
      对于60%的数据,1 <= N <= 1000
      对于100%的数据,1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000
    

    输出格式
    一个整数表示答案

    样例输入

    3
    1 1 1
    2 2 2
    3 3 3
    

    样例输出

    27
    

    直接暴力的话会超时,只能拿37分,需要换一个更简洁的思路。

    需要满足Ai < Bj < Ck,可以拆分为Ai < BjBj < Ck分开判断,将三个数组中所有元素排序后,遍历b数组,得出满足Ai < Bj 的有x个,满足Bj < Ck有y个,二者相乘之后累加。

    n = int(input())
    a = sorted(list(map(int,input().split())))
    b = sorted(list(map(int,input().split())))
    c = sorted(list(map(int,input().split())))
    
    out = 0
    x = 0
    y = 0
    
    for j in range(n):
        while x < n and a[x] < b[j]:
            x += 1
        while y < n and b[j] >= c[y]:
            y += 1
        out += x*(n-y)
    
    print(out)
    

    螺旋折线

    如图所示的螺旋折线经过平面上所有整点恰好一次。
    在这里插入图片描述
    对于整点(X, Y),我们定义它到原点的距离dis(X, Y)是从原点到(X, Y)的螺旋折线段的长度。
    例如dis(0, 1)=3, dis(-2, -1)=9
    给出整点坐标(X, Y),你能计算出dis(X, Y)吗?
      
    输入格式

    X和Y

    对于40%的数据,-1000 <= X, Y <= 1000   
    对于70%的数据,-100000 <= X, Y <= 100000
    对于100%的数据, -1000000000 <= X, Y <= 1000000000

    输出格式

    输出dis(X, Y)

    样例输入

    0 1
    

    样例输出

    3
    

    思路

    当输入的点为(-3,1)时,可以认定它在第三个正方形上,这里的正方形是在原图形基础上稍加改动得到的,例如点A(0,0)、点B(-1,0),令线段AB绕点B顺时针旋转90°,就得到了第一个正方形。

    此时所求的dis(-3,1)就可以分解为:前3-1个正方形周长和+点(-3,1)到点(-3,-3)的距离

    所以需要知道(X,Y)在第几个正方形的哪一个边上

    代码实现

    X,Y = map(int,input().split())
    
    n = max(abs(X),abs(Y)) #第几个正方形
    if X < 0 and  X == Y: #特殊情况
        print(4*n*(n+1))
    else:
        out = 4*n*(n-1) #前n-1个正方形的周长和
    	#(X,Y)与(-n,-n)的距离
        if X == -n:
            d = Y + n
        elif Y == n:
            d = X + 3*n
        elif X == n:
            d = 5*n - Y
        else:
            d = 7*n - X
        print(out + d)
    

    日志统计

    小明维护着一个程序员论坛。现在他收集了一份"点赞"日志,日志共有N行。其中每一行的格式是:

    ts id
    

    表示在ts时刻编号id的帖子收到一个"赞"。

    现在小明想统计有哪些帖子曾经是"热帖"。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞,小明就认为这个帖子曾是"热帖"。

    具体来说,如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞,该帖就曾是"热帖"。

    给定日志,请你帮助小明统计出所有曾是"热帖"的帖子编号。

    输入格式

    第一行包含三个整数N、D和K。   
    以下N行每行一条日志,包含两个整数ts和id。
    对于50%的数据,1 <= K <= N <= 1000   
    对于100%的数据,1 <= K <= N <= 100000 0 <=ts <= 100000 0 <= id <= 100000

    输出格式

    按从小到大的顺序输出热帖id。每个id一行。

    样例输入

    7 10 2
    0 1
    0 10
    10 10
    10 1
    9 1
    100 3
    100 3
    

    样例输出

    1
    3
    

    不难,把握最小区间就行

    n,d,k = map(int,input().split())
    
    dic = {} #存放id以及对应的ts
    out = []
    
    for i in range(n):
        ts,id = map(int,input().split())
        if id in dic:
            lt = dic[id]
        else:
            lt = []
        lt.append(ts)
        dic[id] = lt
    
    for key in dic:
        value = sorted(dic[key])
        if len(value) < k:
            pass
        else:
            for i in range(len(value)-k+1):
                if value[i+k-1]-value[i] < d:
                    out.append(key)
                    break
    for i in sorted(out):
        print(i)
    

    全球变暖

    你有一张某海域NxN像素的照片,".“表示海洋、”#"表示陆地,如下所示:

    .......
    .##....
    .##....
    ....##.
    ..####.
    ...###.
    .......
    

    其中"上下左右"四个方向上连在一起的一片陆地组成一座岛屿。例如上图就有2座岛屿。

    由于全球变暖导致了海面上升,科学家预测未来几十年,岛屿边缘一个像素的范围会被海水淹没。具体来说如果一块陆地像素与海洋相邻(上下左右四个相邻像素中有海洋),它就会被淹没。

    例如上图中的海域未来会变成如下样子:

    .......
    .......
    .......
    .......
    ....#..
    .......
    .......
    

    请你计算:依照科学家的预测,照片中有多少岛屿会被完全淹没。

    输入格式

    第一行包含一个整数N。 (1 <= N <= 1000)   
    以下N行N列代表一张海域照片。
    照片保证第1行、第1列、第N行、第N列的像素都是海洋。

    输出格式

    一个整数表示答案。

    样例输入

    7
    .......
    .##....
    .##....
    ....##.
    ..####.
    ...###.
    .......
    

    样例输出

    1
    

    开始的思路是先模拟出海域未来的样子,后面发现判断岛屿数量会比较繁琐,所以改变思路,依次对岛屿进行遍历,总岛屿数-不被淹没的岛屿数就是答案。

    n = int(input())
    
    lt = [] #存放像素数据
    out = 0 #不被淹没的岛屿数
    all = 0 #总岛屿数
    
    for i in range(n):
        l = list(input())
        lt .append(l)
    #坐标对应值为1则为遍历过
    flag = [[0]*n for i in range(n)] 
    
    dirs = [
        lambda x,y:(x+1,y), #向右
        lambda x,y:(x,y+1), #向下
        lambda x,y:(x-1,y), #向左
        lambda x,y:(x,y-1) #向上
    ] 
    
    for i in range(n):
        for j in range(n):
            if lt[i][j] == '#' and flag[i][j] == 0:
                ls = [] #存放陆地像素对应坐标
                stack = []
                stack.append((i,j))
                flag[i][j] = 1
                k = 1 #标记 避免重复计算
                all += 1
                while len(stack) != 0:
                    now = stack[-1] #当前点坐标
                    if k:
                        #判断是否会被淹没
                        try:
                            m = 1 #标记
                            for dir in dirs:
                                x,y = dir(now[0],now[1])
                                if lt[x][y] == '.':
                                    m = 0
                            if m:
                                out += 1
                                k = 0
                        except:
                            pass
                    #遍历
                    try:
                        for dir in dirs:
                            x,y = dir(now[0],now[1])#下一个点的坐标
                            if lt[x][y] == '#' and flag[x][y] == 0:
                                flag[x][y] = 1
                                stack.append((x,y))
                                break
                        else:
                            stack.pop()
                    except:
                        pass
    print(all-out)
    

    乘积最大

    给定N个整数A1, A2, … AN。请你从中选出K个数,使其乘积最大。

    请你求出最大的乘积,由于乘积可能超出整型范围,你只需输出乘积除以1000000009的余数。

    注意,如果X<0, 我们定义X除以1000000009的余数是负(-X)除以1000000009的余数。
    即:0-((0-x) % 1000000009)

    输入格式

    第一行包含两个整数N和K。   
    以下N行每行一个整数Ai。

    对于40%的数据,1 <= K <= N <= 100   
    对于60%的数据,1 <= K <= 1000   
    对于100%的数据,1<= K <= N <= 100000 -100000 <= Ai <= 100000

    输出格式

    一个整数,表示答案。

    样例输入1

    5 3
    -100000
    -10000
    2
    100000
    10000
    

    样例输出1

    999100009
    

    样例输入2

    5 3
    -100000
    -100000
    -2
    -100000
    -100000
    

    样例输出2

    -999999829
    

    情况有点多,后续会把能AC的代码放出来

    展开全文
  • 题目提交 题解:利用广搜,记录没有淹没的时候一座岛屿的#的个数(ys)。再记录淹没之后一座岛屿的#的个数(ym)。如果两者相等就说明,一座岛屿被完全淹没,就s++,则s就是完全被淹没的岛屿的个数。...

    题目提交

    题解:利用广搜,记录没有淹没的时候一座岛屿的#的个数(ys)。再记录淹没之后一座岛屿的#的个数(ym)。如果两者相等就说明,一座岛屿被完全淹没,就s++,则s就是完全被淹没的岛屿的个数。

    AC代码:

    #include<stdio.h>
    #include<string.h>
    #include<math.h>
    #include<stdlib.h>
    #include<queue>
    #include<algorithm>
    using namespace std;
    int n,book[1010][1010];
    int to[4][2]= {0,1,1,0,0,-1,-1,0};
    int sx,sy;
    char m[1010][1010];
    struct note
    {
    	int x,y;
    } t,head;
    queue<note>q;
    int bfs(int ym,int ys)
    {
    	int k;
    	t.x=sx,t.y=sy;
    	q.push(t);
    	book[sx][sy]=1;
    	while(!q.empty())
    	{
    		head=q.front();
    		q.pop();
    		for(k=0; k<4; k++)
    		{
    			t.x=head.x+to[k][0];
    			t.y=head.y+to[k][1];
    			if(t.x>=0&&t.y>=0&&t.x<n&&t.y<n&&book[t.x][t.y]==0&&m[t.x][t.y]=='#')
    			{
    				ys++;
    				book[t.x][t.y]=1;
    				q.push(t);
    				if(m[t.x-1][t.y]=='.'||m[t.x][t.y+1]=='.'||m[t.x+1][t.y]=='.'||m[t.x][t.y-1]=='.')
    					ym++;
    			}
    		}
    	}
    	if(ym==ys)
    		return 1;
    	return 0;
    }
    int main()
    {
    	scanf("%d",&n);
    	int i,j,k;
    	int s=0;
    	for(i=0; i<n; i++)
    		scanf("%s",m[i]);
    	for(i=0; i<n; i++)
    	{
    		for(j=0; j<n; j++)
    		{
    			if(m[i][j]=='#'&&book[i][j]==0)
    			{
    				sx=i,sy=j;
    				k=bfs(0,0);
    				if(k)
    					s++;
    			}
    		}
    	}
    	printf("%d\n",s);
    	return 0;
    }
    
    展开全文
  • 2018年第九届蓝桥杯省赛C++B组和javaB组题目,c++B组的部分题解可以看我的博客:https://blog.csdn.net/zuzhiang/article/details/79825178
  • 2018年第九届蓝桥杯省赛B组C/C++部分答案

    千次阅读 热门讨论 2018-04-01 20:14:17
    一题:几天这题压根不用写代码,打开系统日历,加一加就知道,是31+29+31+30+4=125天二题:看字符回答数字这道题目是给你一段多个汉字组成的信息,每个汉字用32个字节表示,这里给出了字节作为有符号整数的...

    第一题:第几天

    这题压根不用写代码,打开系统日历,加一加就知道,是第31+29+31+30+4=125天

    第二题:看字符回答数字

    这道题目是给你一段多个汉字组成的信息,每个汉字用32个字节表示,这里给出了字节作为有符号整数的值。
    题目的要求隐藏在这些信息中。你的任务是复原这些汉字的字形,从中看出题目的要求,并根据要求填写答案。
    这段信息是(一共10个汉字):
    4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
    16 64 16 64 34 68 127 126 66 -124 67 4 66 4 66 -124 126 100 66 36 66 4 66 4 66 4 126 4 66 40 0 16
    4 0 4 0 4 0 4 32 -1 -16 4 32 4 32 4 32 4 32 4 32 8 32 8 32 16 34 16 34 32 30 -64 0
    0 -128 64 -128 48 -128 17 8 1 -4 2 8 8 80 16 64 32 64 -32 64 32 -96 32 -96 33 16 34 8 36 14 40 4
    4 0 3 0 1 0 0 4 -1 -2 4 0 4 16 7 -8 4 16 4 16 4 16 8 16 8 16 16 16 32 -96 64 64
    16 64 20 72 62 -4 73 32 5 16 1 0 63 -8 1 0 -1 -2 0 64 0 80 63 -8 8 64 4 64 1 64 0 -128
    0 16 63 -8 1 0 1 0 1 0 1 4 -1 -2 1 0 1 0 1 0 1 0 1 0 1 0 1 0 5 0 2 0
    2 0 2 0 7 -16 8 32 24 64 37 -128 2 -128 12 -128 113 -4 2 8 12 16 18 32 33 -64 1 0 14 0 112 0
    1 0 1 0 1 0 9 32 9 16 17 12 17 4 33 16 65 16 1 32 1 64 0 -128 1 0 2 0 12 0 112 0
    0 0 0 0 7 -16 24 24 48 12 56 12 0 56 0 -32 0 -64 0 -128 0 0 0 0 1 -128 3 -64 1 -128 0 0

    其实这题很有意思,把每个数转成二进制,三个for循环就能搞定了。

    我贴一下我的代码:

    #include<iostream>
    using namespace std;
    
    int main()
    {
        int m,n,w[16];
        while(cin>>m>>n)
        {
            for(int i=7;i>=0;i--){w[i]=m&1;m>>=1;}
            for(int i=15;i>=8;i--){w[i]=n&1;n>>=1;}
            for(int i=0;i<=15;i++){cout<<w[i]<<" ";}
            cout<<endl;
        }
    }

    最后显示的内容是“九的九次方等于多少?”简直就是编程之美啊,有没有感觉到!

    点阵结果

    这个时候就简单了,打开系统计算器,马上知道结果是387420489

    第三题:乘积尾部0个数

    如下的10行数据,每行有10个整数,请你求出它们的乘积的末尾有多少个零?

    5650 4542 3554 473 946 4114 3871 9073 90 4329
    2758 7949 6113 5659 5245 7432 3051 4434 6704 3594
    9937 1173 6866 3397 4759 7557 3070 2287 1453 9899
    1486 5722 3135 1170 4014 5510 5120 729 2880 9019
    2049 698 4582 4346 4427 646 9742 7340 1230 7683
    5693 7015 6887 7381 4172 4341 2909 2027 7355 5649
    6701 6645 1671 5978 2704 9926 295 3125 3878 6785
    2066 4247 4800 1578 6652 4616 1113 6205 3264 2915
    3966 5291 2904 1285 2193 1428 2265 8730 9436 7074
    689 5510 8243 6114 337 4096 8199 7313 3685 211

    我比赛的时候,投机取巧地用了JAVA的BigInteger来写,结果为

    112142221918653666702449201125076321480831896827506427440731023870278025729017605653056978504625081950967446934475613782859722081655293509714201067451491601144000940085173776751705443818861349991600968912829674368417898694508188364854988187881792613763161458365648071883922054736261940944120399031297726871056069331318210560000000000000000000000000000000

    显然,能得出答案是31个0。

    但如果正常一点来写,我们应该想到,应该先去掉所有数的结尾的0,并把0的个数先存起来,然后统计2因子和5因子的个数和数值,相乘后取出0,然后看乘积是否为2或者5因子,如果是因子数就加到因子数统计区,否则丢弃。

    第四题:摔手机

    这题不会,很奇怪的题目

    第五题:代码填空--快查

    其实这题按照前面的条件可以找出提示

    答案是quick_select(a,i+1,r,k-i+l-1)

    第六题:忘了

    第七题:螺旋线

    这题,刚开始看到数据规模为10亿,我是拒绝的,因为线性时间也会超时

    但是最后我一想,既然是10亿,肯定是O(1)左右的时间就能算出来,那么,就肯定是跟数学公式有关,结果发现,只要是在刚好第三象限,x和y的值相等的情况下,到这个点的距离是4*k(k+1),k为当前的圈数。

    #include<iostream>
    using namespace std;
    
    int main()
    {
        long long m,n;cin>>m>>n;
        long long a_m=m>=0?m:-m;
        long long a_n=n>=0?n:-n;
        long long circle_num=max(a_m,a_n)-1;
        long long result=4*circle_num*(circle_num+1);
        if(circle_num<0){cout<<0<<endl;return 0;}
        if(m==n&&m<0){result=4*a_m*(a_m+1);cout<<result<<endl;return 0;}
        int i=-circle_num-1,j=-circle_num;result++;
    
        if(i<0&&i!=m){result+=2*circle_num+1;j+=2*circle_num+1;}else if(i<0&&i==m){result+=n-j;j=n;}
        //第三象限
        if(j>0&&j!=n){result+=2*circle_num+2;i+=2*circle_num+2;}else if(j>0&&j==n){result+=m-i;i=m;}
        //第二象限
        if(i>0&&i!=m){result+=2*circle_num+2;j-=2*circle_num+2;}else if(i>0&&i==m){result+=j-n;j=n;}
        //第一象限
        if(j<0&&j!=n){result+=2*circle_num+2;i-=2*circle_num+2;}else if(j<0&&j==n){result+=i-m;i=m;}
        //第四象限
        cout<<result<<endl;
        return 0;
    }
    只可惜比赛的时候不够时间写出来了[/(ㄒoㄒ)/~~]

    第八题:水漫金山

    (具体题名忘了,我觉得这个更符合意境),这个太骚了,想不出来

    第九题:忘了

    第十题:最大乘积

    这题我用了贪心的方案,感觉不靠谱,还是不贴代码了


    展开全文
  • 2018年4月1日省赛第九届蓝桥杯真题Java(B组),新鲜出炉
  • 第九届蓝桥杯省赛b组c/c++ 第一题 标题:第几天 2000年的1月1日,是那一年的第1天。 那么,2000年的5月4日,是那一年的第几天? 注意:需要提交的是一个整数,不要填写任何多余内容。 第二题 #include &...
  • 题目来源:第九届蓝桥杯省赛C++B组 算法标签:位运算 题目描述:明码 汉字的字形存在于字库中,即便在今天,16点阵的字库也仍然使用广泛。 16点阵的字库把每个汉字看成是16x16个像素信息。并把这些信息记录在字节中...
  • 2018第九届蓝桥杯C++省赛B组题目汇总

    千次阅读 2019-06-19 21:39:33
    一题 标题:几天 2000年的1月1日,是那一年的1天。 那么,2000年的5月4日,是那一年的几天? 注意:需要提交的是一个整数,不要填写任何多余内容。 题解: 所以5.4号是124+1=...
  • 思路:一次不是元音字母的时候,找到结束位置记录,并break掉,后面从上次结束的下一个位置开始,遍历找到一次不是辅音的字母…如此四次,注意中间判断是否达到字符串长度 8.正整数序列 思路:这个题是啥来着,想...
  • b数组位于中间,先固定b数组,计算一下a数组<b数组有多少个(sa),再计算一下b数组<c数组有多少个(sc),然后累加s=sa*sc。 AC代码: #include<stdio.h> #include<string.h> #include<math.h...
  • 递增三元题目描述输入输出题目分析题解7.螺旋折线题目描述输入输出题目分析题解8.日志统计题目描述输入输出题目分析题解9.全球变暖题目描述输入输出题目分析题解10.堆的计数(无题解,超出能力范围了)题目描述...
  • 2020十一届蓝桥杯省赛B组第一场

    万次阅读 多人点赞 2020-07-06 21:52:24
    2020十一届蓝桥杯省赛B组第一场明日更新答案试题 A: 跑步训练问题描述题解试题 B: 纪念日问题描述题解试题 C: 合并检测问题描述题解试题 D: REPEAT 程序问题描述题解试题 E: 矩阵问题描述题解试题 F: 整除序列问题...
  • 文章目录1、几天2、明码 1、几天 【题目描述】 2000年的1月1日,是那一年的1天。 那么,2000年的5月4日,是那一年的几天? 【输出】 输出一个整数表示答案 31+29+31+30+4=125 2、明码 汉字的字形存在于...
  • 蓝桥杯结果填空门牌制作既约分数蛇形填数跑步锻炼七段码程序设计成绩统计回文日期子串分值和 结果填空 门牌制作 问题描述 小蓝要为一条街的住户制作门牌号。 这条街一共有 2020 位住户,门牌号从 1 到 2020 编号。 ...
  • 内含第九届蓝桥杯省赛软件类C语言B组原题及参考答案,欢迎下载
  • 第九届蓝桥杯省赛B组—— 全球变暖 你有一张某海域$N×N$像素的照片,”.”表示海洋、”#”表示陆地,如下所示: ``` ....... .##.... .##.... ....##. ..####. ...###. ....... ``` 其中”上下左右”四个方向上连...
  • 题目 切面条来源:届蓝桥杯省赛C++B组算法标签 递推题目描述:题目答案:题目思路:题目代码:3.题目 李白打酒算法标签:dfs题目描述:题目答案:题目思路:题目代码:dfs二进制4.题目 史丰收运算算法标签:...
  • 贪心:2018年第九届蓝桥杯C/C++A组省(最后一题) - MXR_alone - 博客园 #include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<algorithm> #define ...
  • 2018年第九届蓝桥杯c/c++省赛B组真题

    千次阅读 2020-09-10 21:01:39
    A 几天 分值: 5 2000年的1月1日,是那一年的1天。 那么,2000年的5月4日,是那一年的几天? 注意:需要提交的是一个整数,不要填写任何多余内容。 答案:125 B 明码 分值:7 汉字的字形存在于字库中,即便在...
  • 2021年十二届蓝桥杯省赛B组C/C++题解

    万次阅读 多人点赞 2021-04-20 21:21:56
    2021年十二届蓝桥杯省赛B组C/C++题解 这次蓝桥杯总的来说要比前几年会难一些,因为大多数涉及到思维,所以普遍分低,希望今年自己还能有一。 这里是我自己写的一些题解,答案核对后一般是争取的给大家讲讲我的...
  • 第九届蓝桥杯省赛C++B组 测试次数

    千次阅读 多人点赞 2018-04-03 23:03:46
    标题:测试次数 x星球的居民脾气不太好,但好在他们生气的时候唯一的异常举动是:摔手机。 各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试,...如果手机从7层扔下去没摔坏,但...
  • 自己写的非正确答案 。2018第九届蓝桥杯Java语言C&答案
  • 试题 G: 解码 问题描述 时间限制: 1.0s 内存限制: 256.0MB 本题总分:20 分 【问题描述】 小明有一串很长的英文字母,可能包含大写和小写。...为了方便,小明不会将连续的超过 9 个相同的字符写成简写的形式。 现在
  • 2018年 第九届 蓝桥杯省赛 C/C++ B 第几天 明码 乘积尾零 测试次数 快速排序 递增三元 螺旋折线 日志统计 全球变暖 乘积最大

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,517
精华内容 2,206
关键字:

第九届蓝桥杯省赛b组

友情链接: Keystone_SDK_Packet.zip