精华内容
下载资源
问答
  • 2020.6.18 、王道机试指南第三章-数据结构 ...个栈被多次调用,一定要记得清空!!! 经典使用: 括号匹配: 思路: · 顺序遍历字符串,遇到左括号就压栈,遇到右括号就弹栈匹配(栈为空就意味匹配失败);

    2020.6.18
    一、王道机试指南第三章-数据结构
    1、栈:

    • 简单调用:使用C++
    #include <stack>//head file
    stack<int> S;//defien
    S.empty();//empty?True:False;
    S.push(i);
    S.pop();
    int i=S.top();
    一个栈被多次调用时,一定要记得清空!!!
    
    • 经典使用:
      • 括号匹配:

        思路:
        · 顺序遍历字符串,遇到左括号就压栈,遇到右括号就弹栈匹配(栈为空就意味匹配失败);
        · 遍历完后,栈中元素个数即为未匹配成功的左括号个数;
        · 若想标记哪些括号未匹配,可以将字符串内字符对应下标压栈;

      • 表达式计算(典型思路):
        在这里插入图片描述

    相关练习题:表达式求值

    借鉴别人的思路:
    一个栈就可以。遇到and就弹出第一个和下一个判断,下一个就不放入栈里了。
    然后遍历栈 只要有true就输出true(因为这时候只有or了)
    
    #include <stdio.h>
    #include <stack>
    #include <string>
    #include <string.h>
    #include <iostream>
    using namespace std;
    
    int main(){
        stack<string> data;
        char in[10];
        string next;
        int flag=0,ind=0,a,b;
        while(scanf("%s",in)!=EOF){
            ind++;
            if((strcmp(in,"and")==0||strcmp(in,"or")==0)&&ind%2==1){
                flag=1;break;
            }//处理错误情况
            if((strcmp(in,"true")==0||strcmp(in,"false")==0)&&ind%2==0){
                flag=1;break;
            }//处理错误情况
            if(strcmp(in,"true")==0)
                data.push("true");//值压栈
            else if(strcmp(in,"false")==0)
                data.push("false");//值压栈
            else if(strcmp(in,"or")==0)
                data.push("or");//or压栈
            else{//当遇到and时
                scanf("%s",in);
                ind++;//取下一个输入
                if((strcmp(in,"and")==0||strcmp(in,"or")==0)&&ind%2==1){
                    flag=1;break;
                }//出错情况判断
                next=data.top();data.pop();//取栈顶,出栈
                //开始计算
                if(strcmp(in,"true")==0)
                    b=1;
                else
                    b=0;
                if(next=="true")
                    a=1;
                else
                    a=0;
                if(a&&b)//结果压栈
                    data.push("true");
                else
                    data.push("false");
            }
        }
        if(flag){
            printf("error");
            return 0;
        }
        else{
            if(data.top()=="or"||data.top()=="and"){//以运算符结尾的错误情形
                printf("error");
                return 0;
            }
            while(!data.empty()){//遍历栈中元素,是否有true
                if(data.top()=="true"){
                    printf("true");
                    return 0;
                }
                data.pop();
            }
        }
        printf("false");
        return 0;
    }
    

    二、计网传输层

    1. udp传输协议(简单的差错控制,即校验和)
    2. tcp传输协议:
      1.0版:基于可靠信道,下面的版本基于不可靠信道
      2.0版:引入:ack&nak + 重传(ARQ协议)(停止-等待协议)
      2.1版:引入:序列号seq(防止ack/nak被破坏)
      2.2版:改进:去掉nak,在ack中加入序列号
      2.3版:引入:定时器
      现:引入流水线机制,即滑动窗口协议(回退N帧/GBN、选择重传/SR)

    进度有点慢,感觉有点累,但,欲戴皇冠,必承其重,既然想去名校,就要努力!

    展开全文
  • 该MAX17043 锂电池电量模块预留低电量报警中断引脚,当电池电量低于指定阈值,该引脚产生个下跳脉冲,触发主控的外部中断。 使用该MAX17043 锂电池电量模块可实时了解或记录系统的耗电状态,估算电池的续航...
  • CruiseYoung提供的带有详细书签的电子书籍目录 ... iPhone 3开发基础教程(针对iPhone SDK 3新特性全面改版) 基本信息 原书名: Beginning iPhone 3 Development: Exploring the iPhone SDK ... iPhone自发布之...
  • 2020第十届蓝桥杯省赛B组第

    千次阅读 多人点赞 2020-07-06 21:52:24
    2020第十届蓝桥杯省赛B组第场明日更新答案试题 A: 跑步训练问题描述题解试题 B: 纪念问题描述题解试题 C: 合并检测问题描述题解试题 D: REPEAT 程序问题描述题解试题 E:...初始,小明充满体力,体力值为 1000

    明日更新答案

    试题 A: 跑步训练

    问题描述

    本题总分:5 分
    【问题描述】
    小明要做一个跑步训练。
    初始时,小明充满体力,体力值计为 10000。如果小明跑步,每分钟600 的体力。如果小明休息,每分钟增加 300 的体力。体力的损耗和增加均匀变化的。
    小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如环。如果某个时刻小明的体力到达 0,他就停止锻炼。
    请问小明在多久后停止锻炼。为了使答案为整数,请以秒为单位输出答案中只填写数,不填写单位。
    【答案提交】
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    题解

    答案:3880

    
    public class Test_C {
    	public static void main(String[] args) {
    		int HP = 10000;
    		int t = 0;
    		while (true) {
    			if (HP >= 600) {
    				HP -= 600;
    				t += 60;
    			} else {
    				break;
    			}
    			if (HP > 0) {
    				HP += 300;
    				t += 60;
    			}
    		}
    		t += 60 * HP / 600;
    		System.out.println(t);
    	}
    }
    
    
    

    试题 B: 纪念日

    问题描述

    本题总分:5 分
    【问题描述】
    2020 年 7 月 1 日是中国某党成立 99 周年纪念日。
    中国某党成立于 1921 年 7 月 23 日。
    请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一含多少分钟?
    【答案提交】
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    题解

    答案:52038720

    import java.util.Date;
    
    public class Test_B {
    	public static void main(String[] args) {
    		Date date1 = new Date(21, 6, 23, 12, 0, 0);
    		System.out.println(date1);
    		Date date2 = new Date(120, 6, 1, 12, 0, 0);
    		System.out.println(date2);
    		long time = date2.getTime() - date1.getTime();
    		System.out.println(time / (60000));
    	}
    }
    
    

    在这里插入图片描述

    试题 C: 合并检测

    问题描述

    本题总分:10 分
    【问题描述】
    新冠疫情由新冠病毒引起,最近在 A 国蔓延,为了尽快控制疫情,A 国准
    备给大量民众进病毒核酸检测。
    然而,用于检测的试剂盒紧缺。
    为了解决这一困难,科学家想了一个办法:合并检测。即将从多个人(k
    个)采集的标本放到同一个试剂盒中进行检测。如果结果为阴性,则说明这 k
    个人都是阴性,用一个试剂盒完成了 k 个人的检测。如果结果为阳性,则说明
    至少有一个人为阳性,需要将这 k 个人的样本全部重新独立检测(从理论上看,
    如果检测前 k - 1 个人都是阴性可以推断出第 k 个人是阳性,但是在实际操作中
    不会利用此推断,而是将 k 个人独立检测),加上最开始的合并检测,一共使用
    了 k + 1 个试剂盒完成了 k 个人的检测。
    A 国估计被测的民众的感染率大概是 1%,呈均匀分布。请问 k 取多少能
    最节省试剂盒?
    【答案提交】
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个
    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    题解

    答案:10

    假设A国有n个人,感染者有n/100
    每k个人一组,共n/k组,共用n/k瓶试剂
    按照最坏的情况,每多出一个感染者就多用k瓶试剂,
    因此共用n/k+(n/100)*k瓶试剂
    n是定值,所以求(1/k+k/100)最小
    由于a+b>=2√ab
    当且仅当a = b时,取等号
    即1/k=k/100时,取得最小值
    解得k = 10

    试题 D: REPEAT 程序

    问题描述

    文件链接本题附件地址
    本题总分:15 分
    【问题描述】
    附件 prog.txt 中是一个用某种语言写的程序。
    其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达,
    从次行开始连续的缩进比该行多的(前面的空白更长的)为循环包含的内容。
    例如如下片段:

    REPEAT 2:
    	A = A + 4
    	REPEAT 5:
    		REPEAT 6:
    			A = A + 5
    		A = A + 7
    	A = A + 8
    A = A + 9
    

    A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的
    循环两次中。
    REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。
    A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。
    请问该程序执行完毕之后,A 的值是多少?
    【答案提交】
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个
    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    题解

    答案:241830

    这道题用python比较简单,因为python的循环也是根据缩进。
    只需这样
    在这里插入图片描述
    样例
    在这里插入图片描述
    执行
    在这里插入图片描述
    完事。

    试题 E: 矩阵

    问题描述

    本题总分:15 分
    【问题描述】
    把 1 ∼ 2020 放在 2 × 1010 的矩阵里。要求同一行中右边的比左边大,列中下边的比上边的大。一共有多少种方案?
    答案很大,你只需要给出方案数除以 2020 的余数即可。
    【答案提交】
    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    题解

    public class Test_E {
    	public static void main(String[] args) {
    		int[][] dp = new int[2021][2021];
    	    dp[1][1] = 1; // 1必然放在第一行
    	    for (int i = 2; i <= 2020; i++) {
    	        for (int j = 1; j <= i; j++) {
    	            dp[i][j] += dp[i - 1][j - 1];
    	            if (i - j <= j) {
    	                dp[i][j] += dp[i - 1][j];
    	            }
    	            dp[i][j] %= 2020;
    	        }
    	    }
    	    System.out.println(dp[2020][1010]);
    	}
    }
    

    试题 F: 整除序列

    问题描述

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:15
    【问题描述】
    有一个序列,序列的第一个数是 n,后面的每个数是前一个数整除 2,出这个序列中值为正数的项。
    【输入格式】
    输入一行包含一个整数 n。
    【输出格式】
    输出一行,包含多个整数,相邻的整数之间用一个空格分隔,表示答案。
    【样例输入】

    20
    

    【样例输出】

    20 10 5 2 1
    

    【评测用例规模与约定】
    对于 80% 的评测用例,1 ≤ n ≤ 109
    对于所有评测用例,1 ≤ n ≤ 1018

    题解

    import java.util.Scanner;
    
    public class Test_G {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		long n = sc.nextInt();
    		while (n > 0) {
    			System.out.print(n + " ");
    			n = n >> 1;
    		}
    	}
    }
    
    

    试题 G: 解码

    问题描述

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:20 分
    【问题描述】
    小明有一串很长的英文字母,可能包含大写和小写。
    在这串字母中,有很多连续的是重复的。小明想了一个办法将这串字达得更短:将连续的几个相同字母写成字母 + 出现次数的形式。
    例如,连续的 5 个 a,即 aaaaa,小明可以简写成 a5(也可能简写aa3a 等)。对于这个例子:HHHellllloo,小明可以简写成 H3el5o2。为了方达,小明不会将连续的超过 9 个相同的字符写成简写的形式。
    现在给出简写后的字符串,请帮助小明还原成原来的串。
    【输入格式】
    输入一行包含一个字符串。
    【输出格式】
    输出一个字符串,表示还原后的串。
    【样例输入】

    H3el5o2
    

    【样例输出】

    HHHellllloo
    

    【评测用例规模与约定】
    对于所有评测用例,字符串由大小写英文字母和数字组成,长度不100。
    请注意原来的串长度可能超过 100。

    题解

    import java.util.Scanner;
    
    public class Test_G {
    	public static void main(String[] args) {
    		Scanner input = new Scanner(System.in);
    		char[] s = input.next().toCharArray();
    		input.close();
    		StringBuilder newStr = new StringBuilder("");
    		for (int i = 0; i < s.length; i++) {
    			char c = s[i];
    			if (c >= '0' && c <= '9') {
    				char temp = s[i - 1];
    				int n = c - '0';
    				for (int j = 1; j < n; j++) {
    					newStr.append(temp);
    				}
    			} else {
    				newStr.append(c);
    			}
    		}
    		System.out.println(newStr);
    	}
    }
    
    

    试题 H: 走方格

    问题描述

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:20 分
    【问题描述】
    在平面上有一些二维的点阵。
    这些点的编号就像二维数组的编号一样,从上到下依次为第 1 至第 从左到右依次为第 1 至第 m 列,每一个点可以用行号和列号来表示。
    现在有个人站在第 1 行第 1 列,要走到第 n 行第 m 列。只能向右或者走。
    注意,如果行号和列数都是偶数,不能走入这一格中。
    问有多少种方案。
    【输入格式】
    输入一行包含两个整数 n, m。
    【输出格式】
    输出一个整数,表示答案。
    【样例输入】

    3 4
    

    【样例输出】

    2
    

    【样例输入】

    6 6
    

    【样例输出】

    0
    

    【评测用例规模与约定】
    对于所有评测用例,1 ≤ n ≤ 30, 1 ≤ m ≤ 30。

    题解

    import java.util.Scanner;
    
    public class Test_H {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		int n = sc.nextInt();
    		int m = sc.nextInt();
    		int[][] grid = new int[n][m];
    		for (int i = 0; i < n; i++) {
    			grid[i][0] = 1;
    		}
    		for (int i = 0; i < m; i++) {
    			grid[0][i] = 1;
    		}
    		for (int i = 1; i < n; i++) {
    			for (int j = 1; j < m; j++) {
    				if (i % 2 == 1 && j % 2 == 1) {
    					continue;
    				}
    				grid[i][j] = grid[i - 1][j] + grid[i][j - 1];
    			}
    		}
    		System.out.println(grid[n - 1][m - 1]);
    	}
    }
    
    

    试题 I: 整数拼接

    问题描述

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:25 分
    【问题描述】
    给定义个长度为 n 的数组 A1, A2, · · · , An。你可以从中选出两个数 Ai (i 不等于 j),然后将 Ai 和 Aj 一前一后拼成一个新的整数。例如 12 和 以拼成 12345 或 34512。注意交换 Ai 和 Aj 的顺序总是被视为 2 种拼法,是 Ai = Aj 时。
    请你计算有多少种拼法满足拼出的整数是 K 的倍数。
    【输入格式】
    第一行包含 2 个整数 n 和 K。
    第二行包含 n 个整数 A1, A2, · · · , An。
    【输出格式】
    一个整数代表答案。
    【样例输入】

    4 2
    1 2 3 4
    

    【样例输出】

    6
    

    【评测用例规模与约定】
    对于 30% 的评测用例,1 ≤ n ≤ 1000, 1 ≤ K ≤ 20, 1 ≤ Ai ≤ 104
    对于所有评测用例,1 ≤ n ≤ 105,1 ≤ K ≤ 105,1 ≤ Ai ≤ 109

    题解

    试题 J: 网络分析

    问题描述

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:25 分
    【问题描述】
    小明正在做一个网络实验。
    他设置了 n 台电脑,称为节点,用于收发和存储数据。
    初始时,所有节点都是独立的,不存在任何连接。
    小明可以通过网线将两个节点连接起来,连接后两个节点就可以互相了。两个节点如果存在网线连接,称为相邻。
    小明有时会测试当时的网络,他会在某个节点发送一条信息,信息会到每个相邻的节点,之后这些节点又会转发到自己相邻的节点,直到所有或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储一条信息只存储一次。
    给出小明连接和测试的过程,请计算出每个节点存储信息的大小。
    【输入格式】
    输入的第一行包含两个整数 n, m,分别表示节点数量和操作数量。节1 至 n 编号。
    接下来 m 行,每行三个整数,表示一个操作。
    如果操作为 1 a b,表示将节点 a 和节点 b 通过网线连接起来。当 时,表示连接了一个自环,对网络没有实质影响。
    如果操作为 2 p t,表示在节点 p 上发送一条大小为 t 的信息。
    【输出格式】
    输出一行,包含 n 个整数,相邻整数之间用一个空格分割,依次表示完上述操作后节点 1 至节点 n 上存储信息的大小。
    【样例输入】

    4 8
    1 1 2
    2 1 10
    2 3 5
    1 4 1
    2 2 2
    1 1 2
    1 2 4
    2 2 1
    

    【样例输出】

    13 13 5 3
    

    【评测用例规模与约定】
    对于 30% 的评测用例,1 ≤ n ≤ 20,1 ≤ m ≤ 100。
    对于 50% 的评测用例,1 ≤ n ≤ 100,1 ≤ m ≤ 1000。
    对于 70% 的评测用例,1 ≤ n ≤ 1000,1 ≤ m ≤ 10000。
    对于所有评测用例,1 ≤ n ≤ 10000,1 ≤ m ≤ 100000,1 ≤ t ≤ 100。

    题解

    展开全文
  • 第十届蓝桥杯省赛C/C++B组题目与个人解答)试题 A: 跑步训练试题B:纪念试题C:合并检测试题D:REPEAT程序试题E:矩阵试题F:整除序列试题G: 解码试题H: 走方格试题 I: 整数拼接试题 J: 网络分析 试题 A: 跑步训练 ...

    试题 A: 跑步训练

    本题总分:5 分

    【问题描述】

    小明要做一个跑步训练。

    初始时,小明充满体力,体力值计为 10000。如果小明跑步,每分钟损耗

    600 的体力。如果小明休息,每分钟增加 300 的体力。体力的损耗和增加都是

    均匀变化的。

    小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循

    环。如果某个时刻小明的体力到达 0,他就停止锻炼。

    请问小明在多久后停止锻炼。为了使答案为整数,请以秒为单位输出答案。

    答案中只填写数,不填写单位。

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分

    【我的解答】
    如果体力值减600再加300,很容易就想到直接减300。然后直接10000 / 300 …。然后很容易进入一个坑。能这样直接减300的前提时跑步前的体力值还剩下大于等于600。当跑步前的体力值小于600时,没有跑完一分钟就体力值为0了,所以也谈不上休息了。
    代码:

    #include <iostream>
    using namespace std;
    
    int main() {
        int a = 10000;
        int ans = 0;
        while(a != 0) {
            if(a >= 600) {
                a -= 300;
                ans += 120;
                continue;
            }
            else {
                ans = ans + a / 10;
                break;
            }
        }
        cout << ans << endl;
        return 0;
    
        /* 错误做法
         int ans = 10000 / 300 * 120;
         ans += (10000 % 300) / 10;  //错误的 。当还剩400时,明显不可以直接减300,因为不满足先减600再加300*
         */
    }
    

    试题B:纪念日

    本题总分:5 分

    【问题描述】

    2020 年 7 月 1 日是***(敏感字)成立 99 周年纪念日。

    ***(敏感字)成立于 1921 年 7 月 23 日。

    请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包

    含多少分钟?

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分

    【我的解答】
    可以直接利用计算器进行计算,当比赛时想不到用计算器时,则需要进行编程了。

     #include <ctime>
    #include <cstring>
    #include <cstdio>
    using namespace std;
    
    int main() {
    	long long ans = 0;
        for(int i = 1922; i < 2020; ++i) {
        	if(i % 100 == 0) {
        		if(i % 400 == 0) ans += 366;
        		else ans += 365;
        	}
        	else {
        		if(i % 4 == 0) ans += 366;
        		else ans += 365;
        	}
        }
        ans  = ans + 162;   //1921年7月23日00:00到12月21日00:00经历了162天
    	ans = ans + 182;    //2020年1月1日00:00到7月1日00:00经历了182天 
        printf("%lld\n", ans * 24 * 60);
        
        return 0;
    }
    

    试题C:合并检测

    本题总分:10 分

    【问题描述】

    即将从多个人(k个)采集的标本放到同一个试剂盒中进行检测。如果结果为阴性,则说明这 k个人都是阴性,用一个试剂盒完成了 k 个人的检测。
    如果结果为阳性,则说明至少有一个人为阳性,需要将这 k 个人的样本全部重新独立检测(从理论上看,如果检测前 k 1 个人都是阴性可以推断出第 k 个人是阳性,但是在实际操作中不会利用此推断,而是将 k 个人独立检测)
    ,加上最开始的合并检测,一共使用了 k + 1 个试剂盒完成了 k 个人的检测。
    A 国估计被测的民众的感染率大概是 1%,呈均匀分布。请问 k 取多少能最节省试剂盒?

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分
    【我的解答】
    本人数学功底不好,只能假设了A国有100人,然后感染的民众是1人。
    就是求y = floor(100 / k) + k,当k取某值时,得到的y值最大。算的是10。

    试题D:REPEAT程序

    【问题描述】

    附件 prog.txt 中是一个用某种语言写的程序。

    其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达,

    从次行开始连续的缩进比该行多的(前面的空白更长的)为循环包含的内容。

    例如如下片段:

    REPEAT 2:

    A = A + 4

    REPEAT 5:

    REPEAT 6:

    A = A + 5

    A = A + 7

    A = A + 8

    A = A + 9

    该片段中从 A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的

    循环两次中。

    REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。

    A = A + 5 实际总共的循环次数是 2 × 5 × 6 = 60 次。

    请问该程序执行完毕之后,A 的值是多少?

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
    【附件数据】

    A = 0
    REPEAT 2:
        A = A + 4
        REPEAT 5:
            REPEAT 6:
                A = A + 5
            A = A + 7
        REPEAT 6:
            A = A + 7
            REPEAT 4:
                A = A + 2
                A = A + 7
            A = A + 2
        REPEAT 7:
            REPEAT 4:
                A = A + 8
                A = A + 7
                A = A + 4
                A = A + 5
            A = A + 8
        REPEAT 8:
            A = A + 5
            REPEAT 1:
                A = A + 2
            REPEAT 7:
                A = A + 5
            A = A + 5
        REPEAT 2:
            REPEAT 3:
                A = A + 1
            A = A + 1
        REPEAT 5:
            A = A + 1
        REPEAT 9:
            REPEAT 6:
                A = A + 5
                A = A + 1
            REPEAT 6:
                A = A + 2
                A = A + 8
                A = A + 3
            REPEAT 2:
                A = A + 5
            REPEAT 3:
                A = A + 9
            REPEAT 1:
                A = A + 4
            REPEAT 2:
                A = A + 9
            REPEAT 1:
                A = A + 6
                A = A + 6
                A = A + 4
            REPEAT 3:
                A = A + 7
            A = A + 1
            REPEAT 2:
                A = A + 3
            REPEAT 5:
                A = A + 2
                A = A + 5
                A = A + 2
            A = A + 4
        A = A + 3
    REPEAT 4:
        A = A + 4
        A = A + 3
        A = A + 7
        REPEAT 5:
            REPEAT 4:
                A = A + 5
                A = A + 7
            REPEAT 5:
                A = A + 3
            REPEAT 3:
                A = A + 3
                A = A + 1
            A = A + 8
            A = A + 2
            REPEAT 9:
                A = A + 5
            REPEAT 1:
                A = A + 5
            A = A + 2
        A = A + 8
    A = A + 6
    REPEAT 3:
        REPEAT 4:
            A = A + 9
            REPEAT 5:
                A = A + 2
            A = A + 1
        REPEAT 9:
            A = A + 9
            A = A + 2
            REPEAT 1:
                A = A + 6
                A = A + 8
            REPEAT 2:
                A = A + 9
                A = A + 4
            A = A + 7
        REPEAT 2:
            REPEAT 7:
                A = A + 3
                A = A + 5
            REPEAT 3:
                A = A + 5
                A = A + 3
                A = A + 6
                A = A + 4
            REPEAT 9:
                A = A + 2
                A = A + 8
                A = A + 2
            A = A + 3
        REPEAT 2:
            REPEAT 8:
                A = A + 5
                A = A + 1
            A = A + 6
            A = A + 1
        A = A + 2
        REPEAT 6:
            REPEAT 1:
                A = A + 3
            REPEAT 1:
                A = A + 2
            REPEAT 4:
                A = A + 7
                A = A + 1
            A = A + 8
            REPEAT 6:
                A = A + 5
            REPEAT 6:
                A = A + 3
            REPEAT 2:
                A = A + 2
                A = A + 9
            A = A + 7
        REPEAT 9:
            A = A + 8
            REPEAT 9:
                A = A + 8
                A = A + 9
                A = A + 3
            A = A + 2
            REPEAT 6:
                A = A + 3
            REPEAT 9:
                A = A + 1
            A = A + 9
            A = A + 5
            REPEAT 2:
                A = A + 4
                A = A + 9
            A = A + 8
            REPEAT 5:
                A = A + 6
                A = A + 9
            A = A + 1
        REPEAT 1:
            A = A + 4
        A = A + 2
        REPEAT 9:
            REPEAT 3:
                A = A + 4
            REPEAT 7:
                A = A + 8
                A = A + 3
            REPEAT 5:
                A = A + 9
            REPEAT 8:
                A = A + 9
                A = A + 8
            REPEAT 4:
                A = A + 7
            A = A + 7
        A = A + 3
    A = A + 5
    REPEAT 6:
        A = A + 7
    REPEAT 7:
        A = A + 2
        A = A + 2
    A = A + 1
    REPEAT 8:
        REPEAT 1:
            REPEAT 4:
                A = A + 6
                A = A + 6
                A = A + 2
            REPEAT 5:
                A = A + 4
                A = A + 8
                A = A + 4
            REPEAT 1:
                A = A + 5
            REPEAT 7:
                A = A + 8
            REPEAT 6:
                A = A + 4
            A = A + 4
            A = A + 8
            REPEAT 4:
                A = A + 2
            REPEAT 2:
                A = A + 4
            REPEAT 2:
                A = A + 3
            REPEAT 1:
                A = A + 2
            A = A + 8
            REPEAT 2:
                A = A + 7
            REPEAT 8:
                A = A + 6
                A = A + 1
            A = A + 7
        REPEAT 8:
            A = A + 2
        REPEAT 8:
            REPEAT 6:
                A = A + 1
                A = A + 6
            REPEAT 2:
                A = A + 4
                A = A + 1
            A = A + 7
        A = A + 4
    REPEAT 4:
        REPEAT 9:
            A = A + 2
        REPEAT 1:
            A = A + 2
        A = A + 5
    REPEAT 8:
        REPEAT 6:
            A = A + 3
        REPEAT 4:
            A = A + 1
            A = A + 6
            A = A + 1
        REPEAT 7:
            A = A + 7
            REPEAT 7:
                A = A + 3
                A = A + 9
                A = A + 1
                A = A + 9
            REPEAT 3:
                A = A + 5
            A = A + 5
            A = A + 6
            A = A + 2
        REPEAT 1:
            A = A + 4
        REPEAT 2:
            A = A + 7
        REPEAT 1:
            A = A + 7
            REPEAT 4:
                A = A + 7
            A = A + 2
            REPEAT 5:
                A = A + 9
                A = A + 1
                A = A + 9
                A = A + 5
                A = A + 9
            REPEAT 5:
                A = A + 5
            REPEAT 1:
                A = A + 6
            REPEAT 2:
                A = A + 3
                A = A + 2
                A = A + 6
                A = A + 8
                A = A + 8
                A = A + 7
            A = A + 5
        A = A + 5
    REPEAT 2:
        A = A + 1
        A = A + 7
    A = A + 3
    REPEAT 2:
        A = A + 7
    A = A + 1
    A = A + 4
    REPEAT 1:
        REPEAT 7:
            REPEAT 2:
                A = A + 3
                A = A + 5
                A = A + 2
            A = A + 6
        A = A + 1
    A = A + 2
    A = A + 4
    A = A + 9
    REPEAT 1:
        A = A + 8
    REPEAT 8:
        REPEAT 4:
            REPEAT 8:
                A = A + 4
            REPEAT 3:
                A = A + 1
                A = A + 8
            REPEAT 7:
                A = A + 8
            REPEAT 7:
                A = A + 7
            A = A + 7
            REPEAT 7:
                A = A + 6
            REPEAT 5:
                A = A + 9
            A = A + 3
            REPEAT 4:
                A = A + 5
            A = A + 5
        A = A + 4
        REPEAT 9:
            REPEAT 3:
                A = A + 4
                A = A + 3
                A = A + 6
            REPEAT 1:
                A = A + 3
                A = A + 3
                A = A + 6
            REPEAT 6:
                A = A + 7
                A = A + 7
                A = A + 5
                A = A + 5
                A = A + 1
                A = A + 2
            A = A + 6
            A = A + 6
        REPEAT 9:
            A = A + 6
        REPEAT 1:
            REPEAT 2:
                A = A + 4
                A = A + 7
            REPEAT 3:
                A = A + 6
            REPEAT 5:
                A = A + 3
            A = A + 6
            REPEAT 9:
                A = A + 3
            A = A + 6
        REPEAT 5:
            A = A + 8
            A = A + 8
            REPEAT 3:
                A = A + 7
                A = A + 9
                A = A + 8
                A = A + 3
            A = A + 3
        A = A + 9
    REPEAT 6:
        A = A + 9
    A = A + 1
    REPEAT 4:
        REPEAT 1:
            A = A + 7
        REPEAT 9:
            A = A + 2
            A = A + 9
        A = A + 1
    A = A + 2
    A = A + 8
    A = A + 7
    A = A + 9
    A = A + 6
    REPEAT 4:
        REPEAT 2:
            A = A + 3
        REPEAT 3:
            A = A + 4
        A = A + 4
    REPEAT 6:
        A = A + 6
    A = A + 1
    A = A + 5
    A = A + 8
    REPEAT 2:
        A = A + 6
        REPEAT 1:
            REPEAT 2:
                A = A + 2
            REPEAT 3:
                A = A + 1
            REPEAT 1:
                A = A + 8
                A = A + 7
                A = A + 4
                A = A + 2
                A = A + 8
            A = A + 4
        REPEAT 5:
            REPEAT 6:
                A = A + 8
            REPEAT 9:
                A = A + 5
            A = A + 5
        REPEAT 5:
            A = A + 5
        REPEAT 3:
            REPEAT 5:
                A = A + 4
            REPEAT 4:
                A = A + 6
                A = A + 3
            REPEAT 7:
                A = A + 3
                A = A + 3
                A = A + 1
                A = A + 7
                A = A + 7
                A = A + 6
                A = A + 5
                A = A + 5
            A = A + 6
        REPEAT 1:
            A = A + 9
        A = A + 3
        REPEAT 1:
            REPEAT 1:
                A = A + 1
            REPEAT 8:
                A = A + 5
            REPEAT 8:
                A = A + 6
            REPEAT 4:
                A = A + 9
            A = A + 4
        REPEAT 2:
            A = A + 3
            A = A + 7
            REPEAT 5:
                A = A + 7
                A = A + 5
                A = A + 8
            A = A + 7
            A = A + 8
        A = A + 5
        REPEAT 2:
            A = A + 5
        A = A + 7
        A = A + 8
    A = A + 5
    A = A + 9
    REPEAT 2:
        REPEAT 6:
            A = A + 9
            A = A + 1
            A = A + 8
            A = A + 7
            A = A + 1
            A = A + 5
        REPEAT 3:
            A = A + 3
            A = A + 9
            A = A + 7
        REPEAT 3:
            A = A + 9
        A = A + 1
        REPEAT 6:
            A = A + 1
        REPEAT 9:
            REPEAT 7:
                A = A + 3
            REPEAT 5:
                A = A + 5
                A = A + 8
                A = A + 8
                A = A + 1
                A = A + 2
            REPEAT 4:
                A = A + 6
            REPEAT 3:
                A = A + 3
            A = A + 7
        REPEAT 8:
            REPEAT 1:
                A = A + 7
            A = A + 8
            A = A + 3
        A = A + 1
    A = A + 2
    A = A + 4
    A = A + 7
    REPEAT 1:
        REPEAT 1:
            REPEAT 1:
                A = A + 4
                A = A + 6
            REPEAT 1:
                A = A + 3
                A = A + 9
                A = A + 6
            REPEAT 9:
                A = A + 1
                A = A + 6
            REPEAT 5:
                A = A + 3
                A = A + 9
            A = A + 5
            A = A + 5
        A = A + 7
        A = A + 2
        REPEAT 2:
            A = A + 7
        A = A + 7
        REPEAT 7:
            REPEAT 4:
                A = A + 6
            A = A + 8
            REPEAT 6:
                A = A + 6
            REPEAT 2:
                A = A + 1
            A = A + 7
            A = A + 6
        A = A + 7
        REPEAT 4:
            REPEAT 7:
                A = A + 1
            REPEAT 2:
                A = A + 2
                A = A + 5
            A = A + 8
        A = A + 2
    A = A + 1
    A = A + 4
    REPEAT 8:
        A = A + 5
    A = A + 6
    REPEAT 7:
        REPEAT 6:
            REPEAT 9:
                A = A + 7
                A = A + 8
            REPEAT 4:
                A = A + 6
                A = A + 4
                A = A + 3
                A = A + 6
            REPEAT 9:
                A = A + 3
            REPEAT 9:
                A = A + 2
            A = A + 7
        A = A + 5
        A = A + 2
    REPEAT 7:
        REPEAT 8:
            REPEAT 6:
                A = A + 4
                A = A + 9
                A = A + 5
                A = A + 3
            A = A + 9
        REPEAT 4:
            REPEAT 1:
                A = A + 6
                A = A + 8
            REPEAT 1:
                A = A + 6
            A = A + 4
            A = A + 6
        REPEAT 3:
            A = A + 7
            REPEAT 3:
                A = A + 4
                A = A + 4
                A = A + 2
            A = A + 3
            A = A + 7
        REPEAT 5:
            A = A + 6
            A = A + 5
        REPEAT 1:
            REPEAT 8:
                A = A + 5
            REPEAT 3:
                A = A + 6
            REPEAT 9:
                A = A + 4
            A = A + 3
        REPEAT 6:
            REPEAT 2:
                A = A + 1
            A = A + 5
        A = A + 2
    A = A + 2
    A = A + 7
    REPEAT 4:
        A = A + 7
    A = A + 9
    A = A + 2
    REPEAT 8:
        A = A + 9
        REPEAT 9:
            REPEAT 2:
                A = A + 3
                A = A + 2
                A = A + 1
                A = A + 5
            REPEAT 9:
                A = A + 1
                A = A + 3
            A = A + 9
            REPEAT 7:
                A = A + 2
            REPEAT 5:
                A = A + 9
                A = A + 3
            REPEAT 2:
                A = A + 4
            REPEAT 8:
                A = A + 9
            REPEAT 5:
                A = A + 5
                A = A + 4
            A = A + 2
        A = A + 4
        REPEAT 6:
            A = A + 2
            REPEAT 5:
                A = A + 7
                A = A + 7
                A = A + 8
                A = A + 3
            REPEAT 8:
                A = A + 2
                A = A + 5
            REPEAT 1:
                A = A + 8
                A = A + 5
                A = A + 1
                A = A + 1
            A = A + 5
            REPEAT 2:
                A = A + 6
            REPEAT 6:
                A = A + 9
                A = A + 2
            A = A + 5
            REPEAT 4:
                A = A + 7
            A = A + 1
            REPEAT 6:
                A = A + 8
            A = A + 4
        REPEAT 3:
            REPEAT 2:
                A = A + 1
                A = A + 5
            REPEAT 2:
                A = A + 7
            REPEAT 9:
                A = A + 6
                A = A + 8
                A = A + 9
            A = A + 5
        REPEAT 9:
            REPEAT 3:
                A = A + 7
                A = A + 7
            A = A + 9
            A = A + 7
            REPEAT 5:
                A = A + 7
                A = A + 2
            A = A + 1
        A = A + 8
        A = A + 3
        A = A + 5
    A = A + 1
    REPEAT 8:
        A = A + 4
    A = A + 2
    A = A + 2
    A = A + 8
    REPEAT 4:
        REPEAT 4:
            A = A + 8
            REPEAT 7:
                A = A + 5
                A = A + 2
            REPEAT 2:
                A = A + 6
            REPEAT 4:
                A = A + 8
                A = A + 6
            A = A + 1
        A = A + 3
    A = A + 2
    A = A + 7
    A = A + 4
    REPEAT 8:
        A = A + 2
        A = A + 4
    REPEAT 5:
        REPEAT 3:
            REPEAT 6:
                A = A + 8
                A = A + 1
            A = A + 6
        A = A + 5
        A = A + 9
    REPEAT 8:
        A = A + 7
    REPEAT 6:
        A = A + 4
    A = A + 5
    REPEAT 3:
        A = A + 1
        REPEAT 1:
            REPEAT 5:
                A = A + 6
            A = A + 2
        REPEAT 9:
            REPEAT 5:
                A = A + 9
                A = A + 3
            REPEAT 9:
                A = A + 9
            A = A + 8
        REPEAT 8:
            REPEAT 5:
                A = A + 9
                A = A + 4
            REPEAT 9:
                A = A + 3
            A = A + 4
        A = A + 5
    REPEAT 9:
        REPEAT 7:
            A = A + 5
        REPEAT 3:
            A = A + 7
        REPEAT 9:
            REPEAT 6:
                A = A + 4
            A = A + 6
        REPEAT 5:
            REPEAT 6:
                A = A + 5
                A = A + 3
            A = A + 3
        A = A + 3
        A = A + 5
        REPEAT 7:
            A = A + 5
            REPEAT 2:
                A = A + 5
                A = A + 6
            REPEAT 2:
                A = A + 2
            A = A + 5
        A = A + 3
    A = A + 5
    A = A + 5
    REPEAT 4:
        A = A + 2
        A = A + 1
        REPEAT 9:
            A = A + 9
            A = A + 5
            A = A + 6
            A = A + 2
            A = A + 2
            A = A + 5
        REPEAT 9:
            A = A + 5
        A = A + 4
        REPEAT 4:
            REPEAT 4:
                A = A + 1
                A = A + 2
            REPEAT 6:
                A = A + 9
                A = A + 3
            REPEAT 2:
                A = A + 5
                A = A + 1
                A = A + 1
                A = A + 3
            A = A + 8
            REPEAT 7:
                A = A + 4
            REPEAT 6:
                A = A + 9
            REPEAT 5:
                A = A + 9
                A = A + 8
                A = A + 3
            A = A + 9
            A = A + 4
        A = A + 6
    REPEAT 7:
        A = A + 9
    REPEAT 9:
        A = A + 4
        A = A + 9
        A = A + 1
        A = A + 3
        REPEAT 5:
            REPEAT 1:
                A = A + 4
                A = A + 4
            REPEAT 8:
                A = A + 9
                A = A + 6
                A = A + 2
            REPEAT 3:
                A = A + 4
                A = A + 4
            REPEAT 3:
                A = A + 5
                A = A + 2
                A = A + 8
                A = A + 3
                A = A + 6
                A = A + 4
                A = A + 9
                A = A + 1
            A = A + 9
            A = A + 5
            A = A + 3
            REPEAT 3:
                A = A + 2
                A = A + 5
                A = A + 8
                A = A + 2
            A = A + 5
        REPEAT 8:
            REPEAT 2:
                A = A + 6
            A = A + 7
        A = A + 6
        A = A + 9
        A = A + 2
    REPEAT 2:
        A = A + 3
        REPEAT 8:
            A = A + 7
            A = A + 2
            A = A + 1
            A = A + 4
            A = A + 1
            A = A + 5
        A = A + 2
        A = A + 1
        REPEAT 1:
            A = A + 1
        REPEAT 6:
            A = A + 4
            A = A + 3
        A = A + 3
        REPEAT 5:
            A = A + 3
        REPEAT 6:
            REPEAT 1:
                A = A + 5
                A = A + 7
                A = A + 7
                A = A + 7
            REPEAT 5:
                A = A + 9
            A = A + 7
            REPEAT 5:
                A = A + 9
                A = A + 1
                A = A + 9
            A = A + 8
            REPEAT 1:
                A = A + 2
            REPEAT 5:
                A = A + 8
            REPEAT 3:
                A = A + 2
                A = A + 9
            A = A + 6
            A = A + 3
        REPEAT 5:
            REPEAT 6:
                A = A + 5
                A = A + 5
            REPEAT 4:
                A = A + 5
            A = A + 4
            REPEAT 8:
                A = A + 9
                A = A + 1
            REPEAT 8:
                A = A + 8
                A = A + 1
            A = A + 4
            REPEAT 6:
                A = A + 6
            REPEAT 2:
                A = A + 3
                A = A + 9
                A = A + 6
                A = A + 9
            REPEAT 1:
                A = A + 4
            REPEAT 3:
                A = A + 3
                A = A + 4
                A = A + 2
                A = A + 8
            REPEAT 2:
                A = A + 4
            A = A + 1
            REPEAT 9:
                A = A + 2
            A = A + 9
        A = A + 7
    REPEAT 7:
        REPEAT 7:
            REPEAT 5:
                A = A + 7
            REPEAT 5:
                A = A + 1
            A = A + 1
        REPEAT 5:
            A = A + 6
            REPEAT 1:
                A = A + 4
            REPEAT 9:
                A = A + 4
            A = A + 1
        REPEAT 6:
            A = A + 8
            A = A + 5
            REPEAT 1:
                A = A + 4
            REPEAT 5:
                A = A + 8
                A = A + 7
            A = A + 2
        REPEAT 3:
            A = A + 3
        REPEAT 8:
            REPEAT 8:
                A = A + 4
            A = A + 7
            REPEAT 5:
                A = A + 1
            REPEAT 8:
                A = A + 7
                A = A + 8
                A = A + 4
            A = A + 7
            A = A + 6
        A = A + 9
        A = A + 5
    REPEAT 3:
        A = A + 5
        REPEAT 9:
            A = A + 1
        A = A + 7
    REPEAT 1:
        A = A + 8
    A = A + 4
    REPEAT 8:
        REPEAT 7:
            A = A + 2
            REPEAT 4:
                A = A + 6
            A = A + 6
        REPEAT 1:
            A = A + 7
        A = A + 1
    REPEAT 9:
        REPEAT 5:
            A = A + 6
            A = A + 5
            REPEAT 7:
                A = A + 3
                A = A + 6
            A = A + 8
        REPEAT 2:
            A = A + 7
        A = A + 1
        A = A + 9
        REPEAT 3:
            REPEAT 3:
                A = A + 5
    

    【我的解答】
    参考了该位博主的想法,并且思路也很清晰。代码实现的也很巧妙。

    https://www.cnblogs.com/Angel-Demon/p/13259397.html#%E8%AF%95%E9%A2%98-d-repeat-%E7%A8%8B%E5%BA%8F

    这里附上自己的代码

    #include <cstdio>
    #include <string>
    #include <stack>
    using namespace std;
    
    int main() {
        int ans = 0;
        char str[100];
        fgets(str, 100, stdin);
        stack<int> val, blank;
        int a = 1;
        val.push(1);
        blank.push(-1);     //为了防止栈为空
        int t;
        while(fgets(str, 100, stdin)) {
            int i = 0;
            while(str[i] == ' ') ++i;
            while(i <= blank.top()) {
                a /= val.top();
                val.pop();
                blank.pop();
            }
            if(str[i] == 'R') {
                int t = str[i + 7] - '0';
                val.push(t);
                a *= t;
                blank.push(i);
            }
            else {
                int t = str[i + 8] - '0';
                ans = ans + a * t;
            }
        }
        printf("%d\n", ans);
        return 0;
    }
    

    试题E:矩阵

    本题总分:15 分

    【问题描述】

    把 1 ∼ 2020 放在 2 × 1010 的矩阵里。要求同一行中右边的比左边大,同一

    列中下边的比上边的大。一共有多少种方案?

    答案很大,你只需要给出方案数除以 2020 的余数即可。

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    【我的解答】
    我一开始第一时间想的深搜。但是想到2020个数,递归的层数太高,运行很久都运不出来。
    至于动态规划的想法参考了这位博主

    https://blog.csdn.net/weixin_46239370/article/details/107557358

    状态方程是:
    if i1>=jd[i][j]+=d[i1][j]if \ i - 1 >= j \\ d[i][j] += d[i -1][j]
    if i>j1d[i][j]+=d[i][j1]if\ i > j - 1 \\ d[i][j] += d[i][j - 1]

    第一次看到这个状态方程很难理解,觉得为什么可以这样,这个问题怎么符合动态规划的三个特征。最优子结构,子问题重叠,无后效性。本人也不太会讲解,只能够给一个想法。若当前有n个数,对于i + j = n。第一行放i个,第二行放j个,对于第n个,要不 就是在最右边,要不就在下面。
    【代码】
    代码和上面那个博主的代码有所不同

    #include <cstdio>
    #include <cstring>
    using namespace std;
    
    const int maxn = 1011;
    int d[maxn][maxn];
    
    int main() {
        for(int i = 0; i < maxn; ++i) {
            d[i][0] = 1;
        }
        for(int i = 0; i < maxn; ++i) {
            for(int j = 0; j < maxn; ++j) {
                if(j - 1 < i) {
                    d[i][j] += d[i][j - 1];
                }
                if(i - 1 >= j) {
                    d[i][j] += d[i - 1][j];
                }
                d[i][j] = d[i][j] % 2020; 
            }
        }
        printf("%d\n", d[1010][1010]);
        return 0;
    }
    

    填空题个人总结:第十一届蓝桥杯的填空题没有一个是送分的,整体难度比第十届难了许多。有坑的地方变多了。

    试题F:整除序列

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:15 分

    【问题描述】

    有一个序列,序列的第一个数是 n,后面的每个数是前一个数整除 2,请输

    出这个序列中值为正数的项。

    【输入格式】

    输入一行包含一个整数 n。

    【输出格式】

    输出一行,包含多个整数,相邻的整数之间用一个空格分隔,表示答案。

    【样例输入】

    20

    【样例输出】

    20 10 5 2 1

    【评测用例规模与约定】

    对于 80% 的评测用例,1 ≤ n ≤ 10^9。

    对于所有评测用例,1 ≤ n≤ 10^18。

    【我的解答】
    很好,终于迎来了一道签到题了。注意一下n要用long long

    #include <bits/stdc++.h>
    
    int main() {
    	long long n;
    	scanf("%lld", &n);
    	n >>= 1;
    	while(n > 0) {
    		printf(" %lld", n);
    		n >>= 1;
    	}
    	return 0;
    }
    

    试题G: 解码

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:20 分

    【问题描述】

    小明有一串很长的英文字母,可能包含大写和小写。

    在这串字母中,有很多连续的是重复的。小明想了一个办法将这串字母表

    达得更短:将连续的几个相同字母写成字母 + 出现次数的形式。

    例如,连续的 5 个 a,即 aaaaa,小明可以简写成 a5(也可能简写成 a4a、

    aa3a 等)。对于这个例子:HHHellllloo,小明可以简写成 H3el5o2。为了方便表

    达,小明不会将连续的超过 9 个相同的字符写成简写的形式。

    现在给出简写后的字符串,请帮助小明还原成原来的串。

    【输入格式】

    输入一行包含一个字符串。

    【输出格式】

    输出一个字符串,表示还原后的串。

    【样例输入】

    H3el5o2

    【样例输出】

    HHHellllloo

    【评测用例规模与约定】

    对于所有评测用例,字符串由大小写英文字母和数字组成,长度不超过

    100。

    请注意原来的串长度可能超过 100。

    【我的解答】
    题目说数字不会超过9,减轻了题目的难度。注意一下坑的地方就是一个字母之后可能不跟数字。例如a2bc
    题目样例也给了提示

    #include <bits/stdc++.h>
    
    char str[10000];
    char input[110];
    int main() {
    	memset(str, 0, sizeof(str));
    	gets(input); //
    	int len = strlen(input), index = 0;
    	char ch;
    	bool write = true;   //注意初始化为true
    	for(int i = 0; i < len; ++i) {
    		if(isdigit(input[i])) {
    			int n = input[i] - '0';
    			for(int i = 0; i < n; ++i) {
    				str[index++] = ch;      
    			}
    			write = true;
    		}
    		else {
    			if(!write) {
    				str[index++] = ch;
    			}
    			write = false;
    			ch = input[i];
    		}
    	}
    	if(!write) str[index] = ch;
    	for(int i = 0; i <= index; ++i) {
    		printf("%c", str[i]);
    	}
    	return 0;
    }
    

    试题H: 走方格

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:20 分

    【问题描述】

    在平面上有一些二维的点阵。

    这些点的编号就像二维数组的编号一样,从上到下依次为第 1 至第 n 行,

    从左到右依次为第 1 至第 m 列,每一个点可以用行号和列号来表示。

    现在有个人站在第 1 行第 1 列,要走到第 n 行第 m 列。只能向右或者向下

    走。

    注意,如果行号和列数都是偶数,不能走入这一格中。

    问有多少种方案。

    【输入格式】

    输入一行包含两个整数 n, m。

    【输出格式】

    输出一个整数,表示答案。

    【样例输入】

    3 4

    【样例输出】

    2

    【样例输入】

    6 6

    【样例输出】

    0

    【评测用例规模与约定】

    对于所有评测用例,1 ≤ n ≤ 30, 1 ≤ m ≤ 30。

    【我的解答】
    动态规划时需考虑i,j是否同为偶数

    #include <bits/stdc++.h> 
    
    const int maxn = 31;
    int d[maxn][maxn];
    
    int main() {
    	int n, m;
    	scanf("%d %d", &n, &m);
    	memset(d, 0, sizeof(d));
    	for(int i = 1; i <= n; ++i) {
    		d[i][1] = 1;
    	}
    	for(int j = 1; j <= m; ++j) {
    		d[1][j] = 1;
    	}
    	for(int i = 2; i <= n; ++i) {
    		for(int j = 2; j <= m; ++j) {
    			/*也可以 x % 2 ! = 0 || j % 2 != 0*/ 
    			if(i & 1 || j & 1) {		
    				d[i][j] = d[i - 1][j] + d[i][j - 1];
    				
    			}
    		}
    	}
    	printf("%d\n", d[n][m]);
    	return 0;
    }
    
    

    试题 I: 整数拼接

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:25 分

    【问题描述】

    给定义个长度为 n 的数组 A1, A2, · · · , An。你可以从中选出两个数 Ai 和 Aj

    (i 不等于 j),然后将 Ai 和 Aj 一前一后拼成一个新的整数。例如 12 和 345 可

    以拼成 12345 或 34512。注意交换 Ai 和 Aj 的顺序总是被视为 2 种拼法,即便

    是 Ai= Aj 时。

    请你计算有多少种拼法满足拼出的整数是 K 的倍数。

    【输入格式】

    第一行包含 2 个整数 n 和 K。

    第二行包含 n 个整数 A1,A2, · · · , An。

    【输出格式】

    一个整数代表答案。

    【样例输入】

    4 2

    1 2 3 4

    【样例输出】

    6

    【评测用例规模与约定】

    对于 30% 的评测用例,1 ≤ n≤ 1000, 1 ≤ K ≤ 20, 1 ≤ Ai ≤ 10^4。

    对于所有评测用例,1 ≤ n≤ 10^5,1 ≤ K≤ 10^5,1 ≤ Ai ≤ 10^9。

    【我的解答】
    如果暴力,应该只是过30%。
    想法参考了博主,但是该题解没有给出完整推导过程,见下面。

    https://www.cnblogs.com/Angel-Demon/p/13259397.html#%E8%AF%95%E9%A2%98-i-%E6%95%B4%E6%95%B0%E6%8B%BC%E6%8E%A5
    用 cnt[i][j] 记录在之前的数里,在后面补 i 个 0 对 K 取余结果为 j 的数的个数。 对于某个数 n,累加 cnt[len(Ai)][(K−(Ai%K))%K]

    上面引用为什么是对的?
    假设有 A + B = C
    C % k = 0
    ⇒ (A + B) % k = 0
    ⇒ (A % k + B % k) % k = 0
    ⇒ A % k + B % k = k || A % k + B % k = 0
    ⇒ k - A % k = B % k || 0 - A % k = B % k
    B%k = (k - A % k) % k 最后的%k很关键

    #include <bits/stdc++.h>
    
    const int maxn = 100001;
    const int maxk = 10001;
    
    int cnt[11][maxk];
    int numbers[maxn];
    
    int main() {
    	int n, k;
    	scanf("%d %d", &n, &k);
    	for(int i = 1; i <= n; ++i) {
    		scanf("%d", &numbers[i]);
    	}
    	long long ans = 0, t;
    	memset(cnt, 0, sizeof(cnt));
    	char str_num[20];
    	int len, temp;
    	for(int i = 1; i <= n; ++i) {
    		len = sprintf(str_num, "%d", numbers[i]);
    		temp = (k - numbers[i] % k) % k;
    		ans += cnt[len][temp];
    		t = numbers[i];
    		for(int j = 1; j <= 10; ++j) {
    			t = t * 10;
    			cnt[j][t % k]++;
    		}
    	}
    	memset(cnt, 0, sizeof(cnt));
    	for(int i = n; i >= 1; --i) {
    		len = sprintf(str_num, "%d", numbers[i]);
    		temp = (k - numbers[i] % k) % k;
    		ans += cnt[len][temp];
    		t = numbers[i];
    		for(int j = 1; j <= 10; ++j) {  应该是10而不是9
    			t = t * 10;
    			cnt[j][t % k]++;
    		}
    	}
    	printf("%lld\n", ans);
    	return 0;
    }
    

    试题 J: 网络分析

    时间限制: 1.0s 内存限制: 256.0MB 本题总分:25 分

    【问题描述】

    小明正在做一个网络实验。

    他设置了 n 台电脑,称为节点,用于收发和存储数据。

    初始时,所有节点都是独立的,不存在任何连接。

    小明可以通过网线将两个节点连接起来,连接后两个节点就可以互相通信

    了。两个节点如果存在网线连接,称为相邻。

    小明有时会测试当时的网络,他会在某个节点发送一条信息,信息会发送

    到每个相邻的节点,之后这些节点又会转发到自己相邻的节点,直到所有直接

    或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。

    一条信息只存储一次。

    给出小明连接和测试的过程,请计算出每个节点存储信息的大小。

    【输入格式】

    输入的第一行包含两个整数 n,m,分别表示节点数量和操作数量。节点从

    1 至 n 编号。

    接下来 m 行,每行三个整数,表示一个操作。

    如果操作为 1 a b,表示将节点a 和节点 b 通过网线连接起来。当 a = b

    时,表示连接了一个自环,对网络没有实质影响。

    如果操作为 2 p t,表示在节点 p 上发送一条大小为 t 的信息。

    【输出格式】

    输出一行,包含 n 个整数,相邻整数之间用一个空格分割,依次表示进行

    完上述操作后节点 1 至节点 n 上存储信息的大小。

    【样例输入】

    4 8

    1 1 2

    2 1 10

    2 3 5

    1 4 1

    2 2 2

    1 1 2

    1 2 4

    2 2 1

    【样例输出】

    13 13 5 3

    【评测用例规模与约定】

    对于 30% 的评测用例,1 ≤ n ≤ 20,1 ≤ m ≤ 100。

    对于 50% 的评测用例,1 ≤ n ≤ 100,1 ≤ m ≤ 1000。

    对于 70% 的评测用例,1 ≤ n ≤ 1000,1 ≤ m ≤ 10000。

    对于所有评测用例,1 ≤ n ≤ 10000,1 ≤ m ≤ 100000,1 ≤ t ≤ 100。

    【我的解答】
    一开始就想到直接bfs来算,直接bfs应该是只能过50%,想到了用并查集来优化。用一个map来维护主元所代表的元素。这样就不用去枚举判断 点和点之间是否同属于一个并查集。还有一个想法就是每个并查集维护一个头和尾信息,这样并查集的合并就只是将头尾合并。省去了拷贝的过程, 见第二种优化。

    第一种优化的版本,不确保能不能过100,但是也应该挺快的

    /*优化后使用并查集*/
    #include <cstdio>
    #include <vector>
    #include <set>         
    #include <map>          
    using namespace std;
    
    const int maxn = 10001;
    
    int p[maxn];
    
    map<int, set<int> > privo_set;
    map<int, int> count;
    
    int find(int x) { return p[x] == x ? x: p[x] = find(p[x]); }
    
    int main() {
        int n, m;
        scanf("%d %d", &n, &m); 
        for(int i = 1; i <= n; ++i) {
            p[i] = i;
            set<int> s;
            s.insert(i);
            privo_set.insert(pair<int, set<int> >(i, s));
            count[i] = 0;
        }
        int op, a, b;
        for(int i = 0; i < m; ++i) {
            scanf("%d %d %d", &op, &a, &b);
            if(op == 1) {
                int x = find(a), y = find(b);
                //printf("x:%d y:%d\n", x, y);
                if(x != y) {
                	//这里的拷贝如果维护的是指针,则不需要下面的拷贝。
                    for(set<int>::iterator it = privo_set[x].begin(); it != privo_set[x].end(); ++it) {
                        //printf("%d\n", *it);
                        privo_set[y].insert(*it);
                    }
                    p[x] = y;
                }
            }
            else {
                int x = find(a);
                //printf("c%d\n", privo_set[x].size());
                for(set<int>::iterator it = privo_set[x].begin(); it != privo_set[x].end(); ++it) {
                    count[*it] += b;
                    //printf("%d %d\n", count[*it], *it);
                }
            }  
        }	
        map<int, int>::iterator it = count.begin();
        printf("%d", it->second);				
        ++it;
        for(; it != count.end(); ++it) {
            printf(" %d", it->second);
        }
        return 0;
    }
    

    第二个优化的版本,算法本身没有问题,如果代码没有思考不全的地方,肯定能过100%
    用了数组来表示链表,而没有用结构体+指针

    #include <vector>
    #include <set>         
    #include <map>          
    using namespace std;
    const int maxn = 10001;
    
    
    int p[maxn], next[maxn], last[maxn], cnt[maxn]; 
    /*
     *next[i] 表示主元为i的并查集所维护的链表的头节点
     *last[i] 表示主元为i的的并查集维护的链表的尾节点,可以节省遍历整个链表。
     */
    
    int find(int x) { return x == p[x]? x: p[x] = find(p[x]);}  //查找并查集主元
    
    
    int main() {
        int n, m;
        scanf("%d %d", &n, &m); 
        for(int i = 1; i <= n; ++i) {
        	p[i] = i;
        	next[i] = -1;
        	last[i] = i;
        	cnt[i] = 0;
        }
        int op, a, b;
        for(int i = 0; i < m; ++i) {
        	scanf("%d %d %d", &op, &a, &b);
        	if(op == 1) {
        		int x = find(a), y = find(b);
        		if(x != y) {
        			p[x] = y;
        			next[last[y]] = x; //last[y]就是表示y为主元的并查集维护的链表的最后一个点
        			last[y] = last[x];
        		}
        	}
        	else {
        		int x = find(a);
        		for(int t = x; t != -1; t = next[t]) {
        			cnt[t] += b;
        		}
        	}
        }
        for(int i = 1; i <= n; ++i) {
        	if(i != 1) printf(" ");
        	printf("%d", cnt[i]);
        }
        return 0;
    }
    

    编程题总结。相比去年,今年的编程题更有算法的感觉。去年的倒数第二题和今年的倒数第二题都是数学题,需要找到其中的数学规律。

    展开全文
  • 目录试题 A: 跑步训练试题 B: 纪念试题 C: 合并检测试题 D: REPEAT 程序试题 E: 矩阵试题 F: 整除序列试题 G: 解码试题 H: 走方格试题 I: 整数拼接试题 J: 网络分析 试题 A: 跑步训练 【问题描述】 小明要做个...

    试题 A: 跑步训练

    【问题描述】

    小明要做一个跑步训练。

    初始时,小明充满体力,体力值计为 10000。如果小明跑步,每分钟损耗

    600 的体力。如果小明休息,每分钟增加 300 的体力。体力的损耗和增加都是均匀变化的。

    小明打算跑一分钟、休息一分钟、再跑一分钟、再休息一分钟……如此循

    环。如果某个时刻小明的体力到达 0,他就停止锻炼。

    请问小明在多久后停止锻炼。为了使答案为整数,请以秒为单位输出答案。

    答案中只填写数,不填写单位。

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    package 第11届蓝桥杯;
    
    public class 跑步训练 {
        public static void main(String[] args){
            int target = 10000;
            int count = 0;
            boolean flag = true;
            while (true){
                //如果体力小于600并且需要跑步,证明这一分钟跑不完
                if (target < 600 && flag){
                    break;
                }
                if (flag){
                    target -= 600;
                    flag = false;
                }else {
                    target += 300;
                    flag = true;
                }
                count++;
            }
            //最后要求秒数,一分钟花费600 体力,一秒花10 体力,体力除以10 就是剩下的跑步时间
            int time = count * 60 + target/10;
            System.out.println(time);
        }
    }
    
    

    在这里插入图片描述

    试题 B: 纪念日

    【问题描述】

    2020 年 7 月 1 日是A组织 成立 99 周年纪念日。

    A组织成立于 1921 年 7 月 23 日。

    请问从 1921 年 7 月 23 日中午 12 时到 2020 年 7 月 1 日中午 12 时一共包

    含多少分钟?

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    package 第11届蓝桥杯;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class 纪念日 {
        public static void main(String[] args) throws ParseException{
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date date1 = format.parse("1921-7-23");
            Date date2 = format.parse("2020-7-1");
            int a = (int) ((date2.getTime() - date1.getTime()) / (1000*60));
            System.out.println(a);
        }
    }
    
    

    在这里插入图片描述

    试题 C: 合并检测

    【问题描述】

    ***(敏感字)由 ***(敏感字)引起,最近在 A 国蔓延,为了尽快控制 ***(敏感字),A 国准备给大量民众进病毒核酸检测。然而,用于检测的试剂盒紧缺。为了解决这一困难,科学家想了一个办法:合并检测。即将从多个人(k个)采集的标本放到同一个试剂盒中进行检测。如果结果为阴性,则说明这 k个人都是阴性,用一个试剂盒完成了 k 个人的检测。如果结果为阳性,则说明至少有一个人为阳性,需要将这 k 个人的样本全部重新独立检测(从理论上看,如果检测前 k 1 个人都是阴性可以推断出第 k 个人是阳性,但是在实际操作中不会利用此推断,而是将 k 个人独立检测),加上最开始的合并检测,一共使用了 k + 1 个试剂盒完成了 k 个人的检测。A 国估计被测的民众的感染率大概是 1%,呈均匀分布。请问 k 取多少能最节省试剂盒?

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。
    在这里插入图片描述

    试题 D: REPEAT 程序

    【问题描述】

    附件 prog.txt 中是一个用某种语言写的程序。

    其中 REPEAT k 表示一个次数为 k 的循环。循环控制的范围由缩进表达,

    从次行开始连续的缩进比该行多的(前面的空白更长的)为循环包含的内容。

    例如如下片段:

    REPEAT 2:

    A = A + 4

    REPEAT 5:

    REPEAT 6:

    A = A + 5

    A = A + 7

    A = A + 8

    A = A + 9
    在这里插入图片描述
    该片段中从 A = A + 4 所在的行到 A = A + 8 所在的行都在第一行的

    循环两次中。

    REPEAT 6: 所在的行到 A = A + 7 所在的行都在 REPEAT 5: 循环中。

    A = A + 5 实际总共的循环次数是 2×5×6 = 60 次。

    请问该程序执行完毕之后,A 的值是多少?

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

    没有找到完整的代码,按照代码片段就是403

    package 第11届蓝桥杯;
    
    public class REPEAT程序 {
        public static void main(String[] args) {
            int A=0;
            for (int i=0;i<2;i++){
                A+=4;
                for (int j=0;j<5;j++){
                    for (int k=0;k<6;k++){
                        A+=5;
                    }
                    A+=7;
                }
                A+=8;
            }
            A+=9;
            System.out.println(A);
        }
    }
    

    在这里插入图片描述

    试题 E: 矩阵

    【问题描述】

    把 1 ∼ 2020 放在 2 × 1010 的矩阵里。要求同一行中右边的比左边大,同一

    列中下边的比上边的大。一共有多少种方案?

    答案很大,你只需要给出方案数除以 2020 的余数即可。

    【答案提交】

    这是一道结果填空题,你只需要算出结果后提交即可。本题的结果为一个

    整数,在提交答案时只填写这个整数,填写多余的内容将无法得分

    package 第11届蓝桥杯;
    
    
    public class 矩阵 {
        public static void main(String[] args) {
            int n = 2020;
            //dp[i][j]表示,从i个数选j个数
            int[][] dp = new int[3000][3000];
            dp[1][1] = 1; // 1必然放在第一行
            //只要保证第一行的数比第二行的数多就可以了,后面的数会越来越大,会符合小到大的规律
            for (int i = 2; i <= n; i++) {
                for (int j = 1; j <= i; j++) {
                    dp[i][j] += dp[i - 1][j - 1]; // 放到第一层
                    if (i - j <= j) {
                        //当进入if说明,i没有超过j的两倍了,
                        // (如果超过j的两倍,说明第一行肯定比第二行少了)
                        //本身就是取一半的数字,如果超过两倍,说明取不到一半,不能参与计算
                        dp[i][j] += dp[i - 1][j];   //放到第二层
                    }
                    dp[i][j] %= 2020;
                }
            }
            System.out.println(dp[n][n/2]);
        }
    }
    
    

    在这里插入图片描述

    试题 F: 整除序列

    【问题描述】

    有一个序列,序列的第一个数是 n,后面的每个数是前一个数整除 2,请输

    出这个序列中值为正数的项。

    【输入格式】

    输入一行包含一个整数 n。

    【输出格式】

    输出一行,包含多个整数,相邻的整数之间用一个空格分隔,表示答案。

    【样例输入】

    20

    【样例输出】

    20 10 5 2 1

    【评测用例规模与约定】

    对于 80% 的评测用例,1 ≤ n ≤ 10^9。

    对于所有评测用例,1 ≤ n≤ 10^18。

    package 第11届蓝桥杯;
    
    import java.util.Scanner;
    
    public class 整除序列 {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            sc.close();
            while (n != 0){
                System.out.print(n + "  ");
                n = n /2;
            }
        }
    }
    
    

    在这里插入图片描述

    试题 G: 解码

    【问题描述】

    小明有一串很长的英文字母,可能包含大写和小写。

    在这串字母中,有很多连续的是重复的。小明想了一个办法将这串字母表

    达得更短:将连续的几个相同字母写成字母 + 出现次数的形式。

    例如,连续的 5 个 a,即 aaaaa,小明可以简写成 a5(也可能简写成 a4a、

    aa3a 等)。对于这个例子:HHHellllloo,小明可以简写成 H3el5o2。为了方便表

    达,小明不会将连续的超过 9 个相同的字符写成简写的形式。

    现在给出简写后的字符串,请帮助小明还原成原来的串。

    【输入格式】

    输入一行包含一个字符串。

    【输出格式】

    输出一个字符串,表示还原后的串。

    【样例输入】

    H3el5o2

    【样例输出】

    HHHellllloo

    【评测用例规模与约定】

    对于所有评测用例,字符串由大小写英文字母和数字组成,长度不超过

    100。

    请注意原来的串长度可能超过 100。

    package 第11届蓝桥杯;
    
    import java.util.Scanner;
    
    public class 解码 {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            String s = sc.next();
            //sc.close();
    
            StringBuilder sb = new StringBuilder();
            char[] num = s.toCharArray();
            char temp = '0';
            int count = 0;
            int len = s.length();
            for (int i = 0; i < len; i++){
                if (Character.isDigit(num[i])){
                    count = num[i] - '0';
                    for (int j = 0; j < count; j++){
                        sb.append(temp);
                    }
                }else {
                    temp = num[i];
                    if (i < len - 1 && Character.isDigit(num[i+1])){
                        continue;
                    }else {
                        sb.append(temp);
                    }
                }
            }
            System.out.println(sb.toString());
        }
    }
    
    

    在这里插入图片描述

    试题 H: 走方格

    【问题描述】

    在平面上有一些二维的点阵。

    这些点的编号就像二维数组的编号一样,从上到下依次为第 1 至第 n 行,

    从左到右依次为第 1 至第 m 列,每一个点可以用行号和列号来表示。

    现在有个人站在第 1 行第 1 列,要走到第 n 行第 m 列。只能向右或者向下

    走。

    注意,如果行号和列数都是偶数,不能走入这一格中。

    问有多少种方案。

    【输入格式】

    输入一行包含两个整数 n, m。

    【输出格式】

    输出一个整数,表示答案。

    【样例输入】

    3 4

    【样例输出】

    2

    【样例输入】

    6 6

    【样例输出】

    0

    【评测用例规模与约定】

    对于所有评测用例,1 ≤ n ≤ 30, 1 ≤ m ≤ 30。

    package 第11届蓝桥杯;
    
    import java.util.Scanner;
    
    public class 走方格 {
        public static void main(String[] args){
            //输入矩阵的宽和高
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int m = sc.nextInt();
            sc.close();
            int[][] dp = new int[n][m];
            dp[0][0] = 1;
            //规则只能往右下走,所以只能取左上的值
            for (int i = 0; i < n; i++){
                for (int j = 0; j < m; j++){
                    //第一行一列不用处理
                    if (i == 0 && j == 0){
                        continue;
                    }
                    //只要不是第一行就可以取上面的
                    if (i > 0){
                        dp[i][j] += dp[i-1][j];
                    }
                    //只要不是第一列就可以取左面的
                    if (j > 0){
                        dp[i][j] += dp[i][j -1];
                    }
                    //如果是偶数行列不能取值,这里是奇数,因为是从0开始的,所以偶数就变成了奇数
                    if ((i & 1) == 1 && (j & 1) == 1){
                        dp[i][j] = 0;
                    }
                }
            }
            System.out.println(dp[n-1][m-1]);
        }
    }
    
    

    在这里插入图片描述

    试题 I: 整数拼接

    【问题描述】

    给定义个长度为 n 的数组 A1, A2, · · · , An。你可以从中选出两个数 Ai 和 A**j

    (i 不等于 j),然后将 Ai 和 Aj 一前一后拼成一个新的整数。例如 12 和 345 可

    以拼成 12345 或 34512。注意交换 Ai 和 Aj 的顺序总是被视为 2 种拼法,即便

    是 Ai = Aj 时。

    请你计算有多少种拼法满足拼出的整数是 K 的倍数。

    【输入格式】

    第一行包含 2 个整数 n 和 K。

    第二行包含 n 个整数 A1, A2, · · · , A**n。

    【输出格式】

    一个整数代表答案。

    【样例输入】

    4 2

    1 2 3 4

    【样例输出】

    6

    【评测用例规模与约定】

    对于 30% 的评测用例,1 ≤ n≤ 1000, 1 ≤ K ≤ 20, 1 ≤ Ai ≤ 10^4。

    对于所有评测用例,1 ≤ n≤ 10^5,1 ≤ K≤ 105,1 ≤ Ai ≤ 10^9。

    package 第11届蓝桥杯;
    
    import com.sun.org.apache.xerces.internal.impl.xpath.regex.Match;
    
    import java.util.Scanner;
    
    public class 整数拼接 {
        public static void main(String[] args){
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[] num = new int[n];
            int[][] a = new int[k][10];
            int[][] b = new int[k][10];
            int temp = 0;
    
            //记录有哪些数自己和自己拼接可以成为k倍
            int subtract = 0;
            for (int i = 0; i < n; i++){
                num[i] = sc.nextInt();
                //取余
                temp = num[i] % k;
                //余数为 temp 的,并且位数为当前数字相同的
                ++b[temp][getLen(num[i])];
                //求这个数 * 这个数的位数
                for (int j = 1;j <= 9; j++){
                    //a[i][j]代表 %k 余数为 i 的,后面带10 的j 次方,
                    ++a[((temp*((int) (Math.pow(10,j))%k))%k)][j];
                }
                //如果自身可以拼接就记录一下,最后减去自身拼接的数
                if (temp + (temp * (getLen(num[i])% k))% k == k){
                    subtract++;
                }
            }
            int count = 0;
            for (int i = 0; i < k; i++){
                for (int j = 1; j <= 9; j++){
                    count += a[i][j]*b[(k-i)%k][j];
                }
            }
            System.out.println(count - subtract);
        }
    
        //求num有几位
        public static int getLen(int num){
            int len = 1;
            while (num != 0){
                num/=10;
                len*=10;
            }
            return len/10;
        }
    }
    
    

    在这里插入图片描述

    试题 J: 网络分析

    【问题描述】

    小明正在做一个网络实验。

    他设置了 n 台电脑,称为节点,用于收发和存储数据。

    初始时,所有节点都是独立的,不存在任何连接。

    小明可以通过网线将两个节点连接起来,连接后两个节点就可以互相通信

    了。两个节点如果存在网线连接,称为相邻。

    小明有时会测试当时的网络,他会在某个节点发送一条信息,信息会发送

    到每个相邻的节点,之后这些节点又会转发到自己相邻的节点,直到所有直接

    或间接相邻的节点都收到了信息。所有发送和接收的节点都会将信息存储下来。

    一条信息只存储一次。

    给出小明连接和测试的过程,请计算出每个节点存储信息的大小。

    【输入格式】

    输入的第一行包含两个整数 n, m,分别表示节点数量和操作数量。节点从

    1 至 n 编号。

    接下来 m 行,每行三个整数,表示一个操作。

    如果操作为 1 a b,表示将节点 a 和节点 b 通过网线连接起来。当 a = b

    时,表示连接了一个自环,对网络没有实质影响。

    如果操作为 2 p t,表示在节点 p 上发送一条大小为 t 的信息。

    【输出格式】

    输出一行,包含 n 个整数,相邻整数之间用一个空格分割,依次表示进行

    完上述操作后节点 1 至节点 n 上存储信息的大小。

    试题J: 网络分析 12第十一届蓝桥杯大赛软件类省赛 C/C++ 大学 B 组

    【样例输入】

    4 8

    1 1 2

    2 1 10

    2 3 5

    1 4 1

    2 2 2

    1 1 2

    1 2 4

    2 2 1

    【样例输出】

    13 13 5 3

    【评测用例规模与约定】

    对于 30% 的评测用例,1 ≤ n ≤ 20,1 ≤ m ≤ 100。

    对于 50% 的评测用例,1 ≤ n ≤ 100,1 ≤ m ≤ 1000。

    对于 70% 的评测用例,1 ≤ n ≤ 1000,1 ≤ m ≤ 10000。

    对于所有评测用例,1 ≤ n ≤ 10000,1 ≤ m ≤ 100000,1 ≤ t ≤ 100。

    package 第11届蓝桥杯;
    
    import java.util.LinkedList;
    import java.util.Scanner;
    
    public class 网络分析 {
        static int[] data ;
        static boolean[] bool ;
        static  LinkedList<LinkedList<Integer>> list = new  LinkedList<LinkedList<Integer>>();
        public static void main(String[] args) {
    
            Scanner sc = new Scanner(System.in);
            int n = sc.nextInt();
            int m = sc.nextInt();
            data=new int[n+1];
            bool=new boolean[n+1];
            int a=0,b=0,c=0;
            for (int i =0;i<=n;i++){
                list.add(new LinkedList<>());
            }
            for (int i=0;i<m;i++){
                a=sc.nextInt();
                b=sc.nextInt();
                c=sc.nextInt();
                //网络题把他们互相联系起来
                if(a==1){
                    list.get(b).add(c);
                    list.get(c).add(b);
                } else{
    
                    bool=new boolean[n+1];
                    dfs(b,c);
                }
            }
            for (int i=1;i<=n;i++){
                System.out.println(data[i]);
            }
        }
        //dfs遍历每一个结点
        public static void dfs(int node,int num){
            bool[node]=true;
            data[node]+=num;
            LinkedList<Integer> templist=list.get(node);
            for(int i:templist){
                if(!bool[i]){
    
                    dfs(i,num);
    
                }
            }
        }
    
    }
    
    

    在这里插入图片描述

    转载自https://blog.csdn.net/weixin_43124279/article/details/107178138

    展开全文
  • 第十届蓝桥杯省赛C++ B组

    千次阅读 2020-10-16 22:34:49
    纪念C: 合并检测D: REPEAT 程序E: 矩阵F:整除序列G: 解码H: 走方格I: 整数拼接J: 网络分析 第十届蓝桥杯省赛C++ B组(7.25) A:跑步训练 题意: 本题总分:5 分 【问题描述】 小明要做个跑步训练。 初始,...
  • 题目试题 A: 跑步训练试题 B: 纪念试题 C: 合并检测试题 D: REPEAT 程序试题 E: 矩阵试题 F: 整除序列试题 G: 解码试题 H: 走方格试题 I: 整数拼接试题 J: 网络分析 试题 A: 跑步训练 本题总分:5 分 【问题描述】...
  • [0,0]表示画条高度为0的等高线,如果想画高度为i 的等高线,改为[ii],‘r’表示线条用红色显示。 其中的c表示等高线矩阵,包含定义的等到的数据。 h为等高线的句柄。 图像句柄:MATLAB创建图形对象,为该...
  • 试题下载  试题 A: 跑步训练 试题 B: 纪念 试题 C: 合并检测 试题 D: REPEAT 程序 试题 E: 矩阵 试题 F: 整除序列 ...初始,小明充满体力,体力值为 10000。如果小明跑步,每分钟损耗 600...
  • 文章目录试题A: 跑步训练试题B: 纪念试题C: 合并检测试题D: REPEAT 程序试题E: 矩阵试题F: 整除序列试题G: 解码试题H: 走方格试题I:整数拼接试题 J: 网络分析 试题A: 跑步训练 【问题描述】 小明要做个跑步训练...
  • 通过我们已经学过的知识,你可以编写个最简单的程序输出个也许是程序世界中最有名的词语: echo "Hello World!"; ?> First PHP page // Single line C++ style comment /* printing the message */ ...
  • 因此,华为云面向社会各界精英人士举办了本次垃圾分类竞赛,希望共同探索垃圾分类的AI技术,为垃圾分类这个利国利民的国家大贡献自己的份智慧。 赛题说明 本赛题采用深圳市垃圾分类标准,赛题任务是对垃圾图片...
  • 单利和复利

    2018-10-11 10:11:14
    单利是指笔资金无论存期多长,只有本金取利息,而以前各期利息在下个利息周期内不计算利息的计息方法。 单利利息的计算公式为: 利息(I)=本金(P)×利率(i)×计息期数(n) 例:某企业有一张带息期票...
  • 软件史上的10大bug

    2020-08-18 15:00:42
    在商业软件中,个小小的Bug可能造成数以百万的损失,那么在其他高科领域呢? 按照时间顺序,著名网络媒体Wired News列出了到目前为止10个最严重的软件bug。 1962年7月28, Mariner I空间探测器事件。 Mariner...
  • php高级开发教程说明

    2008-11-27 11:39:22
    当然,有了益增大的免费工具函数库,依然不能满足全部需要,也不能优化这个库 以适应特殊需求,有些库太庞大以致不能随处安装,因为每次选中都必须分析几百K字节的代 码,这将严重降低站点的性能。在这种...
  • 文号表达式

    2017-03-23 15:01:12
    {H} :表示 {I} :表示分 {S}:表示秒 {F} :表示流程名 {U} :表示用户姓名 {R}:表示角色 {FS}:表示流程分类名称 {SD}:表示短部门 {LD}:表示长部门 {RUN}:表示流水号 {N} :表示编号,通过编号计数器...
  • 它采用了拟议的三阱NMOS源极退化电压电流(V–I)转换器,而不是基于运算放大器(OPAMP)的V–I转换器,以及拟议的简单启动电路,其面积可忽略不,以节省功耗和功耗。区域。 SBPLL采用0.18μmCMOSCraft.io实现,...
  • java基础入门教程

    热门讨论 2009-04-29 21:36:10
    微 软 总 裁 比 尔 ·盖 茨 在 悄 悄 地 观 察了 间 后 ,不 无感 慨 地 说 :"Java是 长 间 以 来 最 卓 越 的 程序 设 语 言 ",并确 定 微软 整 个 软 件 开 发 的 战 略 从 PC 单 机 代 向 着 以...
  • 《数据结构 1800题》

    热门讨论 2012-12-27 16:52:03
    《数据结构 1800题》 第章 绪论 、选择题 1. 算法的计算量的大小...9. 当你为解决某问题而选择数据结构,应从哪些方面考虑?【西安电子北京科技大学 2000】 10. 若将数据结构定义为个二元组(D,R),...
  • 岳维功 ortp-realease.pdf

    2020-12-24 04:00:17
    程序询问的最后个应用程序时间戳此处应该指应用收最后个包的应用时间,是应用 按照 类型及其采样牽增长的吋间戳记录,不是系统时间,也不是包里的吋间 最后个返回的采样的时间戳,仅仅对于连续的音频而言 接收...
  • BAT文件 定时关机软件

    2011-07-20 15:00:42
    作为个完整的工具,在打包会附上shutdown.exe这个程序.单独拷贝这个程序,XP系统才能使用,WIN 2003 或VISTA系统能不能使用,我没有测试过. if exist %windir%\system32\shutdown.exe (goto :home) else (copy %temp...
  • c# 加密和解密相关代码

    热门讨论 2011-09-06 11:04:59
    数据的加密与解密 文件的加密与解密 第 章 加密与解密技术 第19章 加密与解密技术 829 ... i++) //遍历字符串中的每个字符串 { string ins = c[i].ToString(); //记录遍历到的字符 string outs...
  • 修完项工目编间号,,登维记,修维项期修目,类,故型单障,价描作)述业,分总类费,用结) 算方式,进厂时间, 派工单(7) ,工时) 员工( (8) 【问题1】( ,工种,员工类型,级别) 4 根据问题分描)述,填写...
  • 正则表达式

    2014-12-03 14:51:39
    个正则表达式成功地和目标字符串相匹配,可以从目标串中抽出和括号中的子模式相匹配 的部分.例如,假定我们正在检索的模式是个或多个字母后面跟随位或多位数字,那么我们可以使用模式 / [a-z] + \ d+/.但是...
  • 1■D1D■I■111■■DI■■1BD1D■ l■■D■■1■ ,70 7.1未使用的I/O引脚 71 7.2低I/O电压 ■■■1■■■■1 71 7.3通用I/O 71 7.4通用I/O中断 7.5通用I/ODMA 72 7.6外设I/O 72 7.6.1定时器1. ■■■■■1 1■■...
  • c++课程设计

    2012-11-26 11:14:59
    足球联赛采用主客场双循环赛制,胜场得3分,平局各得1分,负场得0分,联赛排名以积分多者在前,当两队(或多队)积分相同,则净胜球(即进球数与失球数之差)多者在前,若净胜球相同,则进球数多者在前,若仍...

空空如也

空空如也

1 2 3
收藏数 57
精华内容 22
关键字:

一时计i日