【蓝桥杯】练习题目汇总

门牌制作

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝要为一条街的住户制作门牌号。

这条街一共有 位住户，门牌号从 到 编号。

小蓝制作门牌的方法是先制作 到 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 、、、，即需要 个字符 ， 个字符 ， 个字符 。

请问要制作所有的 到 号门牌，总共需要多少个字符 ？

运行限制

  • 最大运行时间：1s
  • 最大运行内存: 128M

常规思路

1
2
3
4
5
s=[]
for i in range(1,2021):
    s.append(i)
s=str(s)
print(s.count("2"))
1
2
3
s=''
for i in range(1,2021):s+=str(i)
print(s.count("2"))

似乎熟悉了python之后，用python求解也很快。

简单方法

使用excel的功能

image-20240312203337676

使用序列

image-20240312203422558

使用快捷键CTRL+H，唤出替换，替换所有的2。

image-20240312203629711

可以快速得到结果624，准确又省时间。

迷宫

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

X 星球的一处迷宫游乐场建在某个小山坡上。它是由 相互连通的小房间组成的。

房间的地板上写着一个很大的字母。我们假设玩家是面朝上坡的方向站立，则：

  • 表示走到左边的房间，
  • 表示走到右边的房间，
  • 表示走到上坡方向的房间，
  • 表示走到下坡方向的房间。

X 星球的居民有点懒，不愿意费力思考。他们更喜欢玩运气类的游戏。这个游戏也是如此！

开始的时候，直升机把 名玩家放入一个个小房间内。玩家一定要按照地上的字母移动。

迷宫地图如下：

1
2
3
4
5
6
7
8
9
10
UDDLUULRUL  
UURLLLRRRU  
RRUURLDLRD  
RUDDDDUUUU  
URUDLLRRUU  
DURLRLDLRL  
ULLURLLRDU  
RDLULLRDDD  
UUDDUDUDLL  
ULRDLUURRR

请你计算一下，最后，有多少玩家会走出迷宫，而不是在里边兜圈子？

如果你还没明白游戏规则，可以参看下面一个简化的 4x4 迷宫的解说图：

图片描述

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

解题思路

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
str='UDDLUULRULUURLLLRRRURRUURLDLRDRUDDDDUUUUURUDLLRRUUDURLRLDLRLULLURLLRDURDLULLRDDDUUDDUDUDLLULRDLUURRR'
sum=0 #计算有几个人出来
for i in range(100):
  a=i//10 #一个点的坐标（a，b）
  b=i%10
  c = [{a:b}] #用于存放经过的点，若重复经过，说明走不出去了
  while(1):
    if(str[a*10+b]=='U'):
      a=a-1
    elif (str[a*10+b]=='D'):
      a=a+1
    elif (str[a*10+b]=='L'):
      b=b-1
    else:
      b=b+1
    if({a:b} in c):
      break
    if({a:b} not in c):
      c.append({a:b})
    if(a<0 or a>9 or b<0 or b>9):
      sum+=1
      break
print(sum)

DFS解法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
def dfs(x,y):
  if 0<=x<10 and 0<=y<10: 
    if v[x][y] == 0:
      v[x][y] = 1   #打上标识，证明此处已走过
      if map[x][y] == 'U':
        flag = dfs(x-1,y)
      elif map[x][y] == 'D':
        flag = dfs(x+1,y)
      elif map[x][y] == 'L':
        flag = dfs(x,y-1)
      elif map[x][y] == 'R':
        flag = dfs(x,y+1)
      v[x][y] = 0  #按层返回，清除标识
      return flag  
    else:  #如果回到已经走过的地方，说明发生循环，直接返回0标识走不出去
      return 0
  else:      #超限说明走出去了  返回1
    return 1

n = 0
map = [list(input()) for i in range(10)] #读入迷宫
v = [[0]*10 for i in range(10)]  #列表v用来标识该点是否重复经过，避免循环
for i in range(10):
  for j in range(10):
    n += dfs(i,j)   #对每一个人进行走出迷宫的模拟，n记录最后能走出的人的总数
print(n)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#深度dfs递归
map = ['UDDLUULRUL',
       'UURLLLRRRU',
       'RRUURLDLRD',
       'RUDDDDUUUU',
       'URUDLLRRUU',
       'DURLRLDLRL',
       'ULLURLLRDU',
       'RDLULLRDDD',
       'UUDDUDUDLL',
       'ULRDLUURRR']#这里字符串元素要用单引号括起，用双引号，后面会提示数组越界
count = 0
tablist = [[0] * 10 for i in range(10)]


def find(x, y):
    if x < 0 or x > 9 or y < 0 or y > 9:  # 走出迷宫
        global count
        count += 1
        return True

    if tablist[x][y] == 1:  # 已走过
        return False

    tablist[x][y] = 1  # 若之前没走过，则标记走过

    if map[x][y] == "U":
        find(x - 1, y)#递归
    elif map[x][y] == "D":
        find(x + 1, y)
    elif map[x][y] == "L":
        find(x, y - 1)
    elif map[x][y] == "R":
        find(x, y + 1)
    return False


for i in list(range(10)):
    for j in list(range(10)):
        tablist = [[0] * 10 for i in range(10)]#遍历每个坐标起点开始前都先清零
        find(i, j)

print(count)

星期一

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

整个 世纪（ 年 月 日至 年 月 日之间），一共有多少个星期一？(不要告诉我你不知道今天是星期几)

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

解题思路

直接用 Python datetime 库求解，第 6 行可以输出某个日期是星期几。

1
2
3
4
5
6
from datetime import* 
dt1=datetime(1901,1,1) 
dt2=datetime(2000,12,31) 
print(dt1.weekday()) # 周一为0，周二为1... 
td=dt2-dt1 
print(td.days//7)

乘积尾零

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

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

1
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

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

解题思路

将字符串转换成表格，先计算乘积，然后结果由int整数型转换成str字符型，再存入列表中，这时候使用pop方法和列表切片，简单的遍历一下，就能得到结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
s="""
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 
"""
cnt=1
for i in s.split():cnt*=int(i)
cnt,res = list(str(cnt)),0
for i in cnt[::-1]:
    if i == '0':
        cnt.pop()
        res+=1
    else:break
print(res)

当然，也可以不使用列表

图片描述

付账问题

题目描述

几个人一起出去吃饭是常有的事。但在结帐的时候，常常会出现一些争执。

现在有 个人出去吃饭，他们总共消费了 元。其中第 个人带了 元。幸运的是，所有人带的钱的总数是足够付账的，但现在问题来了：每个人分别要出多少钱呢？

为了公平起见，我们希望在总付钱量恰好为 的前提下，最后每个人付的钱的标准差最小。这里我们约定，每个人支付的钱数可以是任意非负实数，即可以不是 1 分钱的整数倍。你需要输出最小的标准差是多少。

标准差的介绍：标准差是多个数与它们平均数差值的平方平均数，一般用于刻画这些数之间的”偏差有多大”。形式化地说，设第 个人付的钱为 元，那么标准差为 :

输入描述

第一行包含两个整数 、；

第二行包含 个非负整数 。

其中， 。

输出描述

输出最小的标准差，四舍五入保留 4 位小数。

保证正确答案在加上或减去 后不会导致四舍五入的结果发生变化。

输入输出样例

示例

输入

1
2
5 2333 
666 666 666 666 666

输出

1
0.0000

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

解题思路

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from math import *
n, s = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
avg = s/n
sum = 0
for i in range(n):
     if a[i]*(n-i) < s:
          sum += pow(a[i]-avg,2)
          s -= a[i]
     else:
          cur_avg = s/(n-i);      #更新平均出钱数
          sum += pow(cur_avg-avg,2)*(n-i)
          break
print("{:.4f}".format(sqrt(sum/(n))))

数字三角形

题目描述

图片描述

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和（路径上的每一步只可沿左斜线向下或右斜线向下走）。

输入描述

输入的第一行包含一个整数 ，表示三角形的行数。

下面的 行给出数字三角形。数字三角形上的数都是 至 之间的整数。

输出描述

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

输入输出样例

示例

输入

1
2
3
4
5
6
5 
7 
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出

1
30

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

42点问题

题目描述

请你设计一个程序对该问题进行解答。

众所周知在扑克牌中，有一个老掉牙的游戏叫做 点，选取 张牌进行加减乘除，看是否能得出 这个答案。

现在小蓝同学发明了一个新游戏，他从扑克牌中依次抽出6张牌，注意不是一次抽出，进行计算，看是否能够组成 点,满足输出 YES，反之输出 NO。

最先抽出来的牌作为第一个操作数，抽出牌做第二个操作数，运算结果再当作第一个操作数，继续进行操作。

注：除不尽的情况保留整数，而且扑克牌的四张 都丢了，不会出现 。

请设计一个程序对该问题进行解答。

输入描述

输出仅一行包含 个字符。

保证字符 3 4 5 6 7 8 9 10 J Q K A 2。

输出描述

若给出到字符能够组成 点 , 满足输出 YES，反之输出 NO。

输入输出样例

示例

输入

1
K A Q 6 2 3

输出

1
YES

样例说明

  • 即
  • 保留整数

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

数的划分

题目描述

将整数 分成 份，且每份不能为空，任意两份不能相同(不考虑顺序)。

例如：，，下面三种分法被认为是相同的。

，，，，，，

问有多少种不同的分法。

输入描述

输入一行， 个整数 ，。

输出描述

输出一个整数，即不同的分法。

输入输出样例

示例 1

输入

1
7 3

输出

1
4

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

数的计算

题目描述

输入一个自然数 ，我们对此自然数按照如下方法进行处理:

  1. 不作任何处理;

  2. 在它的左边加上一个自然数,但该自然数不能超过原数的一半;

  3. 加上数后,继续按此规则进行处理,直到不能再加自然数为止。

问总共可以产生多少个数。

输入描述

输入一个正整数 。

输出描述

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

输入输出样例

示例 1

输入

1
6

输出

1
6

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

N皇后问题

题目描述

在 的方格棋盘放置了 个皇后，使得它们不相互攻击（即任意 个皇后不允许处在同一排，同一列，也不允许处在与棋盘边框成 角的斜线上。你的任务是，对于给定的 ，求出有多少种合法的放置方法。

输入描述

输入中有一个正整数 ，表示棋盘和皇后的数量

输出描述

为一个正整数，表示对应输入行的皇后的不同放置数量。

输入输出样例

示例 1

输入

1
5

输出

1
10

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

路径之谜

题目描述

小明冒充 星球的骑士，进入了一个奇怪的城堡。

城堡里边什么都没有，只有方形石头铺成的地面。

假设城堡地面是 个方格。如下图所示。

图1

按习俗，骑士要从西北角走到东南角。可以横向或纵向移动，但不能斜着走，也不能跳跃。每走到一个新方格，就要向正北方和正西方各射一箭。（城堡的西墙和北墙内各有 个靶子）同一个方格只允许经过一次。但不必走完所有的方格。如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？有时是可以的，比如上图中的例子。

本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）

输入描述

第一行一个整数 ()，表示地面有 个方格。

第二行 个整数，空格分开，表示北边的箭靶上的数字（自西向东）

第三行 个整数，空格分开，表示西边的箭靶上的数字（自北向南）

输出描述

输出一行若干个整数，表示骑士路径。

为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3

比如，上图中的方块编号为：

0 1 2 3

4 5 6 7

8 9 10 11

12 13 14 15

输入输出样例

示例

输入

1
2
3
4
2 4 3 4
4 3 3 3

输出

1
0 4 5 1 2 3 7 11 10 9 13 14 15

运行限制

语言 最大运行时间 最大运行内存
C++ 5s 256M
C 5s 256M
Python3 5s 256M
Java 5s 256M

最大数字

问题描述

给定一个正整数 。你可以对 的任意一位数字执行任意次以下 2 种操 作：

  1. 将该位数字加 1 。如果该位数字已经是 9 , 加 1 之后变成 0 。

  2. 将该位数字减 1 。如果该位数字已经是 0 , 减 1 之后变成 9 。

你现在总共可以执行 1 号操作不超过 次, 2 号操作不超过 次。 请问你最大可以将 变成多少?

输入格式

第一行包含 3 个整数: 。

输出格式

一个整数代表答案。

样例输入

1
123 1 2

样例输出

1
933

样例说明

对百位数字执行 2 次 2 号操作, 对十位数字执行 1 次 1 号操作。

评测用例规模与约定

对于 的数据, 。

对于 的数据,

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 512M
C 1s 512M
Python3 1s 512M
Java 1s 512M

长草

题目描述

小明有一块空地，他将这块空地划分为 行 列的小块，每行和每列的长度都为 1。

小明选了其中的一些小块空地，种上了草，其他小块仍然保持是空地。

这些草长得很快，每个月，草都会向外长出一些，如果一个小块种了草，则它将向自己的上、下、左、右四小块空地扩展，

这四小块空地都将变为有草的小块。请告诉小明， 个月后空地上哪些地方有草。

输入描述

输入的第一行包含两个整数 。

接下来 行，每行包含 个字母，表示初始的空地状态，字母之间没有空格。如果为小数点，表示为空地，如果字母为 ，表示种了草。

接下来包含一个整数 。 其中，，。

输出描述

输出 行，每行包含 个字母，表示 个月后空地的状态。如果为小数点，表示为空地，如果字母为 ，表示长了草。

输入输出样例

示例

输入

1
2
3
4
5
6
4 5 
.g...
.....
..g..
.....
2

输出

1
2
3
4
gggg.
gggg.
ggggg 
.ggg.

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

走迷宫

题目描述

给定一个 的网格迷宫 。 的每个格子要么是道路，要么是障碍物（道路用 表示，障碍物用 表示）。

已知迷宫的入口位置为 ，出口位置为 。问从入口走到出口，最少要走多少个格子。

输入描述

输入第 行包含两个正整数 ，分别表示迷宫的大小。

接下来输入一个 的矩阵。若 表示其为道路，否则表示其为障碍物。

最后一行输入四个整数 ，表示入口的位置和出口的位置。

，，，。

输出描述

输出仅一行，包含一个整数表示答案。

若无法从入口到出口，则输出 。

输入输出样例

示例 1

输入

1
2
3
4
5
6
7
5 5
1 0 1 1 0 
1 1 0 1 1 
0 1 0 1 1 
1 1 1 1 1 
1 0 0 0 1
1 1 5 5

输出

1
8

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

迷宫

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

下图给出了一个迷宫的平面图，其中标记为 的为障碍，标记为 的为可以通行的地方。

1
2
3
4
010000 
000100
001001 
110000

迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。

对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 步。其中 、、、 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（ 行 列），请找出一种通过迷宫的方式，其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。

请注意在字典序中 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
01010101001011001001010110010110100100001000101010 
00001000100000101010010000100000001001100110100101 
01111011010010001000001101001011100011000000010000 
01000000001010100011010000101000001010101011001011 
00011111000000101000010010100010100000101100000000 
11001000110101000010101100011010011010101011110111 
00011011010101001001001010000001000101001110000000 
10100000101000100110101010111110011000010000111010 
00111000001010100001100010000001000101001100001001 
11000110100001110010001001010101010101010001101000 
00010000100100000101001010101110100010101010000101 
11100100101001001000010000010101010100100100010100 
00000010000000101011001111010001100000101010100011 
10101010011100001000011000010110011110110100001000 
10101010100001101010100101000010100000111011101001 
10000000101100010000101100101101001011100000000100 
10101001000000010100100001000100000100011110101001 
00101001010101101001010100011010101101110000110101 
11001010000100001100000010100101000001000111000010 
00001000110000110101101000000100101001001000011101 
10100101000101000000001110110010110101101010100001 
00101000010000110101010000100010001001000100010101 
10100001000110010001000010101001010101011111010010 
00000100101000000110010100101001000001000000000010 
11010000001001110111001001000011101001011011101000 
00000110100010001000100000001000011101000000110011 
10101000101000100010001111100010101001010000001000 
10000010100101001010110000000100101010001011101000 
00111100001000010000000110111000000001000000001011 
10000001100111010111010001000110111010101101111000

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

公共抽签

题目描述

小的学校，蓝桥杯的参赛名额非常有限，只有 个名额，但是共有 个人报名。

作为老师非常苦恼，他不知道该让谁去，他在寻求一个绝对公平的方式。

于是他准备让大家抽签决定，即 个签是去，剩下的是不去。

小 非常想弄明白最后的抽签结果会有多少种不同到情况，请你设计一个程序帮帮小 ！

输入描述

输入第一行包含两个字符 ，其含义如题所述。

接下来第二行到第 行每行包含一个字符串 ，表示个人名。

。

输出描述

输出共若干行，每行包含 个字符串，表示该结果被选中到人名（需按字符串的输入顺序大小对结果进行排序）。

输入输出样例

示例

输入

1
2
3
4
3 2 
xiaowang
xiaoA 
xiaoli

输出

1
2
3
xiaowang xiaoA
xiaowang xiaoli
xiaoA xiaoli

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

座次问题

题目描述

小 的学校，老师好不容易解决了蓝桥杯的报名问题，现在老师又犯愁了。

现在有 位同学参加比赛，但是老师想给他们排座位，但是排列方式太多了。

老师非常想弄明白最后的排座次的结果是什么样子的，到底有多少种结果。

请设计一个程序帮助老师。

最后输出各种情况的人名即可，一行一种情况，每种情况的名字按照报名即输入顺序排序。

输入描述

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

接下来 行每行包含一个字符串 ，表示人名。

，。

输出描述

输出共若干行，每行输出各种情况的人名。一行一种情况，每种情况的名字按照报名即输入顺序排序。

输入输出样例

示例

输入

1
2
3
4
3 
xiaowang
xiaoA 
xiaoli

输出

1
2
3
4
5
6
xiaowang xiaoA xiaoli
xiaowang xiaoli xiaoA 
xiaoA xiaowang xiaoli
xiaoA xiaoli xiaowang 
xiaoli xiaowang xiaoA
xiaoli xiaoA xiaowang

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

CLZ银行问题

题目描述

银行只有两个接待窗口， 窗口和普通窗口， 用户进入 窗口排队，剩下的进入普通窗口排队。现有 次操作，操作有四种类型，如下：

  • IN name V：表示一名叫 name 的用户到 窗口排队
  • OUT V：表示 窗口队头的用户离开排队
  • IN name N：表示一名叫 name 的用户到普通窗口排队
  • OUT N：表示普通窗口队头的用户离开排队

求 次操作结束后 窗口队列和普通窗口队列中的姓名。

输入描述

第一行是一个整数 （），表示一共有 次操作。

第二行到第 行输入操作，格式如下：

  • IN name V
  • OUT V
  • IN name N
  • OUT N

输出描述

输出 次操作后 窗口队列和普通窗口队列中的姓名（从头到尾），先输出 窗口队列后输出普通窗口队列。

输入输出样例

示例 1

输入

1
2
3
4
5
6
5 
IN xiaoming N 
IN Adel V 
IN laozhao N
OUT N 
IN CLZ V

输出

1
2
3
Adel
CLZ
laozhao

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

费里的语言

题目描述

小发明家弗里想创造一种新的语言，众所周知，发明一门语言是非常困难的，首先你就要克服一个困难就是，有大量的单词需要处理，现在弗里求助你帮他写一款程序，判断是否出现重复的两个单词。

输入描述

第 行，输入 ，代表共计创造了多少个单词。

第 行至第 行，输入 个单词。

，保证字符串的总输入量不超过 。

输出描述

输出仅一行。若有重复的单词，就输出重复单词，没有重复单词，就输出 NO，多个重复单词输出最先出现的。

输入输出样例

示例1

输入

1
2
3
4
5
6
7
6
1fagas 
dsafa32j 
lkiuopybncv
hfgdjytr 
cncxfg 
sdhrest

输出

1
NO

示例2

输入

1
2
3
4
5
6
5 
sdfggfds
fgsdhsdf
dsfhsdhr 
sdfhdfh 
sdfggfds

输出

1
sdfggfds

运行限制

语言 最大运行时间 最大运行内存
C++ 3s 512M
C 3s 512M
Python3 3s 512M
Java 3s 512M

快递分拣

题目描述

蓝桥王国的每个快递都包含两个参数：1.快递单号 2.快递城市。

小李是蓝桥王国的一名快递员，每天的快递分拣让他苦不堪言。

于是他想要你帮他设计一个程序用于快递的分拣（将不同快递按城市信息分开）。

输入描述

输入第一行包含一个整数 ,表示快递的个数。

接下来第 行每行包含一个字符串 和一个字符串 ，分别快递单号以及快递对应的城市。

，保证数据量不超过 。

输出描述

输出共若干行。按城市的输入顺序依次输出城市的名称以及城市的快递个数，以及该城市的所有快递单号（单号按照输入顺序排序）。

输入输出样例

示例

输入

1
2
3
4
5
6
7
8
9
10
11
10 
10124214 北京
12421565 上海
sdafasdg213 天津
fasdfga124 北京 
145252 上海 
235wtdfsg 济南 
3242356fgdfsg 成都
23423 武汉 
23423565f 沈阳 
1245dfwfs 成都

输出

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
北京 2 
10124214 fasdfga124 
上海 2 
12421565 145252 
天津 1 
sdafasdg213
济南 1 
235wtdfsg 
成都 2 
3242356fgdfsg 
1245dfwfs 
武汉 1 
23423 
沈阳 1 
23423565f

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

大学里到树木要打药

题目描述

教室外有 棵树（树的编号从 ），根据不同的位置和树种，学校要对其上不同的药。

因为树的排列成线性，且非常长，我们可以将它们看作一条直线给他们编号。

对于树的药是成区间分布，比如 号的树靠近下水道，所以他们要用驱蚊虫的药， 号的树，他们排水不好，容易涝所以要给他们用点促进根系的药 诸如此类。

每种不同的药要花不同的钱。

现在已知共有 个这样的区间，并且给你每个区间花的钱，问最后这些树木要花多少药费。

输入描述

每组输入的第一行有两个整数 和 。 代表马路的共计多少棵树， 代表区间的数目， 和 之间用一个空格隔开。

接下来的 行每行包含三个不同的整数，用一个空格隔开，分别表示一个区域的起始点 和终止点 的坐标，以及花费。

，保证花费总和不超过 int 范围。

输出描述

输出包括一行，这一行只包含一个整数，所有的花费。

输入输出样例

示例

输入

1
2
3
4
500 3 
150 300 4
100 200 20 
470 471 19

输出

1
2662

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

大学里的树木要维护

题目描述

教室外有 棵树（树的编号从 ），根据不同的位置和树种，学校已经对其进行了多年的维护。

因为树的排列成线性，且非常长，我们可以将它们看作一条直线给他们编号。

由于已经维护了多年，每一个树都由学校的园艺人员进行了维护费用的统计。

每棵树的前期维护费用各不相同，但是由于未来需要要打药，所以有些树木的维护费用太高的话，就要重新种植。

由于维护费用也称区间分布，所以常常需要统一个区间里的树木的维护开销。

现给定一个长度为 的数组 以及 个查询， 表示第 棵树到维护费用。对于每个查询包含一个区间，园艺人员想知道该区间内的树木维护的开销是多少。

请你编写程序帮帮他！

输入描述

每组输入的第一行有两个整数 和 。 代表马路的共计多少棵树， 代表区间的数目， 和 之间用一个空格隔开。

接下来的一行，包含 个数 ，分别表示每棵树的维护费用，每个数之间用空格隔开。

接下来的 行每行包含两个不同的整数，用一个空格隔开，表示一个区域的起始点 和终止点 的坐标。

输出描述

输出包括 行，每一行只包含一个整数，表示维护的开销。

输入输出样例

示例

输入

1
2
3
4
5
10 3
7 5 6 4 2 5 0 8 5 3
1 5
2 6
3 7

输出

1
2
3
24
22
17

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

合根植物

题目描述

星球的一个种植园，被分成 个小格子（东西方向 行，南北方向 列）。每个格子里种了一株合根植物。

这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。

如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？

输入描述

第一行，两个整数 ，用空格分开，表示格子的行数、列数（）。

接下来一行，一个整数 ( )，表示下面还有 行数据。

接下来 行，每行两个整数 ，，表示编号为 的小格子和编号为 的小格子合根了。

格子的编号一行一行，从上到下，从左到右编号。

比如： 的小格子，编号：

1
2
3
4
5
1 2 3 4 
5 6 7 8
9 10 11 12
13 14 15 16 
17 18 19 20

输出描述

输出植物数量。

输入输出样例

示例

输入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
5 4
16 
2 3 
1 5
5 9
4 8 
7 8
9 10
10 11
11 12 
10 14
12 16 
14 18
17 18
15 19
19 20
9 13
13 17

输出

1
5

样例说明

其合根情况参考下图：

运行限制

语言 最大运行时间 最大运行内存
C++ 2s 256M
C 2s 256M
Python3 2s 256M
Java 2s 256M

修改数组

题目描述

给定一个长度为 的数组 ，数组中有可能有重复出现的整数。

现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改。

当修改 时，小明会检查 是否在 ∼ 中出现过。如果出现过，则小明会给 加上 1 ；如果新的 仍在之前出现过，小明会持续给 加 1 ，直 到 没有在 ∼ 中出现过。

当 也经过上述修改之后，显然 数组中就没有重复的整数了。

现在给定初始的 数组，请你计算出最终的 数组。

输入描述

第一行包含一个整数 。

第二行包含 个整数 。

其中，，。

输出描述

输出 个整数，依次是最终的 。

输入输出样例

示例

输入

1
2
5 
2 1 1 3 4

输出

1
2 1 3 4 5

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

分巧克力

题目描述

儿童节那天有 K 位小朋友到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。

小明一共有 块巧克力，其中第 块是 的方格组成的长方形。为了公平起见，

小明需要从这 块巧克力中切出 K 块巧克力分给小朋友们。切出的巧克力需要满足：

  1. 形状是正方形，边长是整数;

  2. 大小相同;

例如一块 6x5 的巧克力可以切出 6 块 2x2 的巧克力或者 2 块 3x3 的巧克力。

当然小朋友们都希望得到的巧克力尽可能大，你能帮小明计算出最大的边长是多少么？

输入描述

第一行包含两个整数 ()。

以下 N 行每行包含两个整数 ()。

输入保证每位小朋友至少能获得一块 1x1 的巧克力。

输出描述

输出切出的正方形巧克力最大可能的边长。

输入输出样例

示例

输入

1
2
3
2 10 
6 5
5 6

输出

1
2

运行限制

语言 最大运行时间 最大运行内存
C++ 2s 256M
C 2s 256M
Python3 2s 256M
Java 2s 256M

M次方根

题目描述

小最近在学高等数学，他发现了一道题，求三次根号下 。

现在已知，小开始计算， 的三次方得 ， 的三次方得 ， 的三次方得 ，然后他很高兴的填上了 。接着他要求 次根号下 。

然后他开始 的三次方得 ， 的三次方得 ， 的三次方得

直到他算到了秃头，也没有找到答案。

这时一旁的小看不下去了，说这题答案又不是个整数。

小震惊，原来如此。

作为程序高手的小，打算设计一个程序用于求解 次跟下 的值。

但是由于要考虑精度范围，答案必须要保留 位小数，三次根号下 都要掰手指的小又怎么会设计呢。

请你帮小设计一个程序用于求解 次根号 。

输入描述

每组输入的第一行有两个整数 和 ，数据间用空格隔开。

，，。

输出描述

输出一个实数表示答案（请保留小数点后 位）。

输入输出样例

示例

输入

1
27 3

输出

1
3.0000000

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

找零问题

题目描述

蓝桥商店的老板需要找零 元钱。

钱币的面额有： 元、 元、 元、 元、 元，问如何找零使得所需钱币的数量最少？

注意： 可能为 ，也能为几百元（别问，问就是来着里微信提现来了）

输入描述

在第一行给出测试例个数 ，代表需要找零的钱数。

。

输出描述

输出共有 行，每一行输出数据输出找零的金额与数量，详情看样例。

示例

输入

1
365

输出

1
100:3 50:1 20:0 5:3 1:0

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

小B的宿舍

题目描述

小B的宿舍楼沿着走廊南北向的两边各有 个房间，如下所示：

1
2
3
[房间1][房间3][房间5][房间7][房间9 ]...[房间399]
---------------------------------------------- 走廊 ---------------------------------------------- 
[房间2][房间4][房间6][房间8][房间10]...[房间400]

最近，由于转专业和专业分流的原因，宿舍将迎来新的调整，以便组成新的班级后方便管理。

但是由于走廊狭窄，走廊里只能通过一个搬运的物品（可以同向也可以反向），因此必须指定高效的搬运计划。

老师给了每位同学下达了以下要求，让同学们体现收拾好行李，然后给每位同学 分钟的时间搬运。

当从房间 搬运行李到 时， 与 之间的走廊都会被占用。所以， 分钟之内同一段走廊最多 个人同时搬运，不重叠的走廊也可以同时搬运。

小B的老师是个数学老师，经过运筹学一通计算他得到了最优的搬运计划。

虽然计划不唯一，但是最优值唯一，请问这个最短时间是多少？

输入描述

输入数据有 组测试例，在第一行给出测试例个数 。

每个测试例的第一行是一个整数 （)，表示要搬运行李的人数。

接下来 行，每行两个正整数 和 ，表示一个人，要将行李是从房间 移到到房间 。

输出描述

每组输入都有一行输出数据，为一整数 ，表示完成任务所花费的最小时间。

示例

输入

1
2
3
4
5
6
7
8
9
10
11
12
13
3 
4
10 20
30 40
50 60
70 80 
2
1 3
2 200
3
10 100 
20 80
30 50

输出

1
2
3
10
10
20

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

数字三角形

题目描述

图片描述

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。

路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右 边的那个数。此外，向左下走的次数与向右下走的次数相差不能超过 1。

输入描述

输入的第一行包含一个整数 ，表示三角形的行数。

下面的 行给出数字三角形。数字三角形上的数都是 0 至 100 之间的整数。

输出描述

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

输入输出样例

示例

输入

1
2
3
4
5
6
5 
7 
3 8
8 1 0
2 7 4 4 
4 5 2 6 5

输出

1
27

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

游戏中的学问

题目描述

大家应该都见过很多人手拉手围着篝火跳舞的场景吧？一般情况下，大家手拉手跳舞总是会围成一个大圈，每个人的左手拉着旁边朋友的右手，右手拉着另一侧朋友的左手。

不过，如果每一个人都随机的拉住两个不同人的手，然后再慢慢散开，事情就变得有趣多了——此时大家依旧会形成圈，不过却可能会形成多个独立的圈。当然这里我们依然要求一个人的右手只能拉另一个人的左手，反之亦然。

班里一共有 个同学，由 到 编号。Will 想知道，究竟有多少种本质不同的拉手方案，使得最终大家散开后恰好形成 个圈呢？

给定两种方案，若存在一个人和他的一只手，满足在这两种方案中，拉着这只手的人的编号不同，则这两种方案本质不同。

输入描述

输入一行包含三个正整数。

其中，，。

输出描述

输出一行一个整数，表示本质不同的方案数对 的余数。保证 一定是一个质数。

输入输出样例

示例 1

输入

1
3 1 1000000009

输出

1
2

运行限制

语言 最大运行时间 最大运行内存
C++ 2s 128M
C 2s 128M
Python3 2s 128M
Java 2s 128M

跳跃

题目描述

小蓝在一个 行 列的方格图中玩一个游戏。

开始时，小蓝站在方格图的左上角，即第 行第 列。

小蓝可以在方格图上走动，走动时，如果当前在第 行第 列，他不能走到行号比 小的行，也不能走到列号比 小的列。同时，他一步走的直线距离不超过 。

例如，如果当前小蓝在第 行第 列，他下一步可以走到第 行第 列、第 行第 列、第 行第 列、第 行第 列、第 行第 列、第 行第 列、第 行第 列、第 行第 列、第 行第 列之一。

小蓝最终要走到第 行第 列。

在图中，有的位置有奖励，走上去即可获得，有的位置有惩罚，走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值，奖励为正，惩罚为负。

小蓝希望，从第 行第 列走到第 行第 列后，总的权值和最大。请问最大是多少？

输入描述

输入的第一行包含两个整数 ，表示图的大小。

接下来 行，每行 个整数，表示方格图中每个点的权值。

其中，，权值。

输出描述

输出一个整数，表示最大权值和。

输入输出样例

示例 1

输入

1
2
3
4
3 5
-4 -5 -10 -3 1
7 5 -9 3 -10
10 -2 6 -10 -4

输出

1
15

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

小明的背包1

题目描述

小明有一个容量为 的背包。

这天他去商场购物，商场一共有 件物品，第 件物品的体积为 ，价值为 。

小明想知道在购买的物品总体积不超过 的情况下所能获得的最大价值为多少，请你帮他算算。

输入描述

输入第 行包含两个正整数 ，表示商场物品的数量和小明的背包容量。

第 行包含 个正整数 ，表示物品的体积和价值。

，，。

输出描述

输出一行整数表示小明所能获得的最大价值。

输入输出样例

示例 1

输入

1
2
3
4
5
6
5 20 
1 6
2 5
3 8
5 15
3 3

输出

1
37

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

小明的背包2

题目描述

小明有一个容量为 的背包。

这天他去商场购物，商场一共有 种物品，第 种物品的体积为 ，价值为 ，每种物品都有无限多个。

小明想知道在购买的物品总体积不超过 的情况下所能获得的最大价值为多少，请你帮他算算。

输入描述

输入第 行包含两个正整数 ，表示商场物品的数量和小明的背包容量。

第 行包含 个正整数 ，表示物品的体积和价值。

，，。

输出描述

输出一行整数表示小明所能获得的最大价值。

输入输出样例

示例 1

输入

1
2
3
4
5
6
5 20
1 6 
2 5
3 8
5 15 
3 3

输出

1
120

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

小明的背包3

题目描述

小明有一个容量为 的背包。

这天他去商场购物，商场一共有 种物品，第 种物品的体积为 ，价值为 ，数量为 。

小明想知道在购买的物品总体积不超过 的情况下所能获得的最大价值为多少，请你帮他算算。

输入描述

输入第 行包含两个正整数 ，表示商场物品的数量和小明的背包容量。

第 行包含 个正整数 ，表示物品的体积和价值。

，，。

输出描述

输出一行整数表示小明所能获得的最大价值。

输入输出样例

示例 1

输入

1
2
3
4
3 30 
1 2 3 
4 5 6
7 8 9

输出

1
39

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

蓝肽子序列

题目描述

L 星球上的生物由蛋蓝质组成，每一种蛋蓝质由一类称为蓝肽的物资首尾连接成一条长链后折叠而成。

生物学家小乔正在研究 L 星球上的蛋蓝质。她拿到两个蛋蓝质的蓝肽序列，想通过这两条蓝肽序列的共同特点来分析两种蛋蓝质的相似性。

具体的，一个蓝肽可以使用 至 个英文字母表示，其中第一个字母大写，后面的字母小写。一个蛋蓝质的蓝肽序列可以用蓝肽的表示顺序拼接而成。

在一条蓝肽序列中，如果选取其中的一些位置，把这些位置的蓝肽取出，并按照它们在原序列中的位置摆放，则称为这条蓝肽的一个子序列。蓝肽的子序列不一定在原序列中是连续的，中间可能间隔着一些未被取出的蓝肽。

如果第一条蓝肽序列可以取出一个子序列与第二条蓝肽序列中取出的某个子序列相等，则称为一个公共蓝肽子序列。

给定两条蓝肽序列，找出他们最长的那个公共蓝肽子序列的长度。

输入描述

输入两行，每行包含一个字符串，表示一个蓝肽序列。字符串中间没有空格等分隔字符。

其中有 ，两个字符串的长度均不超过 。

输出描述

输出一个整数，表示最长的那个公共蓝肽子序列的长度。

输入输出样例

示例

输入

1
2
LanQiaoBei 
LanTaiXiaoQiao

输出

1
2

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

合唱队形

题目描述

位同学站成一排，音乐老师要请其中的 位同学出列，使得剩下的 位同学排成合唱队形。

合唱队形是指这样的一种队形：设 位同学从左到右依次编号为 ，，，他们的身高分别为 ，，，， 则他们的身高满足 。

你的任务是，已知所有 位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。

输入描述

输入两行。

第一行是一个整数 ，表示同学的总数。

第二行有 个整数，用空格分隔，第 个整数 是第 位同学的身高(厘米)。

输出描述

输出一个整数，就是最少需要几位同学出列。

输入输出样例

示例 1

输入

1
2
8
186 186 150 200 160 130 197 220

输出

1
4

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

最优包含

题目描述

我们称一个字符串 包含字符串 是指 是 的一个子序列，即可以从字符串 中抽出若干个字符，它们按原来的顺序组合成一个新的字符串与 完全一样。

给定两个字符串 和 ，请问最少修改 中的多少个字符，能使 包含 ？

其中，。

输入描述

输入两行，每行一个字符串。

第一行的字符串为 ，第二行的字符串为 。

两个字符串均非空而且只包含大写英文字母。

输出描述

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

输入输出样例

示例

输入

1
2
ABCDEABCD
XAABZ

输出

1
3

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

路径

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

小蓝学习了最短路径之后特别高兴，他定义了一个特别的图，希望找到图 中的最短路径。

小蓝的图由 2021 个结点组成，依次编号 1 至 2021。

对于两个不同的结点 a, b，如果 a 和 b 的差的绝对值大于 21，则两个结点 之间没有边相连；如果 a 和 b 的差的绝对值小于等于 21，则两个点之间有一条 长度为 a 和 b 的最小公倍数的无向边相连。

例如：结点 1 和结点 23 之间没有边相连；结点 3 和结点 24 之间有一条无 向边，长度为 24；结点 15 和结点 25 之间有一条无向边，长度为 75。

请计算，结点 1 和结点 2021 之间的最短路径长度是多少。

提示：建议使用计算机编程解决问题。

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

蓝桥王国

题目描述

小明是蓝桥王国的王子，今天是他登基之日。

在即将成为国王之前，老国王给他出了道题，他想要考验小明是否有能力管理国家。

题目的内容如下：

蓝桥王国一共有 个建筑和 条单向道路，每条道路都连接着两个建筑，每个建筑都有自己编号，分别为 。（其中皇宫的编号为 ）

国王想让小明回答从皇宫到每个建筑的最短路径是多少，但紧张的小明此时已经无法思考，请你编写程序帮助小明回答国王的考核。

输入描述

输入第一行包含三个正整数 。

第 到 行每行包含三个正整数 ，表示 之间存在一条距离为 的路。

，，，。

输出描述

输出仅一行，共 个数，分别表示从皇宫到编号为 建筑的最短距离，两两之间用空格隔开。（如果无法到达则输出 ）

输入输出样例

示例 1

输入

1
2
3
4
3 3
1 2 1 
1 3 5
2 3 2

输出

1
0 1 3

运行限制

语言 最大运行时间 最大运行内存
C++ 2s 512M
C 2s 512M
Python3 2s 512M
Java 2s 512M

随机数据下的最短路问题

题目描述

给定 个点和 条单向道路，每条道路都连接着两个点，每个点都有自己编号，分别为 。

问你从 点出发，到达每个点的最短路径为多少。

输入描述

输入第一行包含三个正整数 。

第 到 行每行包含三个正整数 ，表示 之间存在一条距离为 的路。

，，，。

本题数据随机生成。

输出描述

输出仅一行，共 个数，分别表示从编号 到编号为 点的最短距离，两两之间用空格隔开。（如果无法到达则输出 ）

输入输出样例

示例 1

输入

1
2
3
4
3 3 1
1 2 1 
1 3 5
2 3 2

输出

1
0 1 3

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

出差

问题描述

国有 个城市, 编号为 。小明是编号为 1 的城市中一家公司的员 工, 今天突然接到了上级通知需要去编号为 的城市出差。

由于疫情原因, 很多直达的交通方式暂时关闭, 小明无法乘坐飞机直接从 城市 1 到达城市 , 需要通过其他城市进行陆路交通中转。小明通过交通信息 网, 查询到了 条城市之间仍然还开通的路线信息以及每一条路线需要花费的 时间。

同样由于疫情原因, 小明到达一个城市后需要隔离观察一段时间才能离开 该城市前往其他城市。通过网络, 小明也查询到了各个城市的隔离信息。(由于 小明之前在城市 1 , 因此可以直接离开城市 1 , 不需要隔离）

由于上级要求, 小明希望能够尽快赶到城市 , 因此他求助于你, 希望你 能帮他规划一条路线, 能够在最短时间内到达城市 。

输入格式

第 1 行: 两个正整数 表示 A 国的城市数量, 表示末关闭的路 线数量

第 2 行: 个正整数, 第 个整数 表示到达编号为 的城市后需要隔离 的时间

第 行: 每行 3 个正整数, , 表示有一条城市 到城市 的 双向路线仍然开通着, 通过该路线的时间为

输出格式

第 1 行: 1 个正整数, 表示小明从城市 1 出发到达城市 的最短时间（到 达城市 , 不需要计算城市 的隔离时间）

样例输入

1
2
3
4
5
6
4 4 
5 7 3 4
1 2 4 
1 3 5
2 4 3
3 4 5

样例输出

1
13

样例说明

图片描述

评测用例规模与约定

对于 的数据,

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 512M
C 1s 512M
Python3 1s 512M
Java 1s 512M

聪明的猴子

题目描述

在一个热带雨林中生存着一群猴子，它们以树上的果子为生。昨天下了一场大雨，现在雨过天晴，但整个雨林的地表还是被大水淹没着，部分植物的树冠露在水面上。猴子不会游泳，但跳跃能力比较强，它们仍然可以在露出水面的不同树冠上来回穿梭，以找到喜欢吃的果实。

现在，在这个地区露出水面的有 棵树，假设每棵树本身的直径都很小，可以忽略不计。我们在这块区域上建立直角坐标系，则每一棵树的位置由其所对应的坐标表示(任意两棵树的坐标都不相同)。

在这个地区住着的猴子有 个，下雨时，它们都躲到了茂密高大的树冠中，没有被大水冲走。由于各个猴子的年龄不同、身体素质不同，它们跳跃的能力不同。有的猴子跳跃的距离比较远(当然也可以跳到较近的树上)，而有些猴子跳跃的距离就比较近。这些猴子非常聪明，它们通过目测就可以准确地判断出自己能否跳到对面的树上。

现已知猴子的数量及每一个猴子的最大跳跃距离，还知道露出水面的每一棵树的坐标，你的任务是统计有多少个猴子可以在这个地区露出水面的所有树冠上觅食。

输入描述

第 行为一个整数，表示猴子的个数 ；

第 行为 个整数，依次表示猴子的最大跳跃距离（每个整数值在 之间）；

第 行为一个整数表示树的总棵数 ；

第 行至第 行为 棵树的坐标（横纵坐标均为整数，范围为：）。

（同一行的整数间用空格分开）

输出描述

输出一个整数，表示可以在这个地区的所有树冠上觅食的猴子数。

输入输出样例

示例 1

输入

1
2
3
4
5
6
7
8
9
4
1 2 3 4 
6
0 0 
1 0
1 2 
-1 -1
-2 0 
2 2

输出

1
3

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

通电

题目描述

2015 年，全中国实现了户户通电。作为一名电力建设者，小明正在帮助一带一路上的国家通电。

这一次，小明要帮助 个村庄通电，其中 1 号村庄正好可以建立一个发电站，所发的电足够所有村庄使用。

现在，这 个村庄之间都没有电线相连，小明主要要做的是架设电线连接这些村庄，使得所有村庄都直接或间接的与发电站相通。

小明测量了所有村庄的位置（坐标）和高度，如果要连接两个村庄，小明需要花费两个村庄之间的坐标距离加上高度差的平方，形式化描述为坐标为() 高度为 的村庄与坐标为 () 高度为 的村庄之间连接的费用为

高度的计算方式与横纵坐标的计算方式不同。

由于经费有限，请帮助小明计算他至少要花费多少费用才能使这 个村庄都通电。

输入描述

输入的第一行包含一个整数 ，表示村庄的数量。

接下来 行，每个三个整数 ，分别表示一个村庄的横、纵坐标和高度，其中第一个村庄可以建立发电站。

其中，，。

输出描述

输出一行，包含一个实数，四舍五入保留 2 位小数，表示答案。

输入输出样例

示例

输入

1
2
3
4
5
4 
1 1 3 
9 9 7 
8 8 6 
4 5 4

输出

1
17.41

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

机房

问题描述

这天, 小明在机房学习。

他发现机房里一共有 台电脑, 编号为 1 到 , 电脑和电脑之间有网线连 接, 一共有 根网线将 台电脑连接起来使得任意两台电脑都直接或者间 接地相连。

小明发现每台电脑转发、发送或者接受信息需要的时间取决于这台电脑和 多少台电脑直接相连, 而信息在网线中的传播时间可以忽略。比如如果某台电脑 用网线直接连接了另外 台电脑, 那么任何经过这台电脑的信息都会延迟 单 位时间 (发送方和接收方也会产生这样的延迟, 当然如果发送方和接收方都是 同一台电脑就只会产生一次延迟)。

小明一共产生了 个疑问: 如果电脑 向电脑 发送信息, 那么信息从 传到 的最短时间是多少?

输入格式

输入共 行, 第一行为两个正整数 。

后面 行, 每行两个正整数 表示编号为 和 的两台电脑用网线 直接相连。

后面 行, 每行两个正整数 表示小明的第 个疑问。

输出格式

输出共 行, 第 行一个正整数表示小明第 个疑问的答案。

样例输入

1
2
3
4
5
6
7
4 3 
1 2 
1 3
2 4 
2 3
3 4
3 3

样例输出

1
2
3
5
6
1

样例说明

这四台电脑各自的延迟分别为 。

对于第一个询问, 从 2 到 3 需要经过 , 所以时间和为 。

对于第二个询问, 从 3 到 4 需要经过 , 所以时间和为 。

对于第三个询问, 从 3 到 3 只会产生一次延迟, 所以时间为 1 。

评测用例规模与约定

对于 的数据, 保证 ;

对于 的数据, 保证 。

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 512M
C 1s 512M
Python3 1s 512M
Java 1s 512M

环境治理

问题描述

LQ 国拥有 个城市, 从 0 到 编号, 这 个城市两两之间都有且仅有 一条双向道路连接, 这意味着任意两个城市之间都是可达的。每条道路都有一 个属性 , 表示这条道路的灰尘度。当从一个城市 前往另一个城市 时, 可 能存在多条路线, 每条路线的灰尘度定义为这条路线所经过的所有道路的灰尘 度之和, LQ 国的人都很讨厌灰尘, 所以他们总会优先选择灰尘度最小的路线。

LQ 国很看重居民的出行环境, 他们用一个指标 来衡量 LQ 国的出行环 境, 定义为:

其中 表示城市 到城市 之间灰尘度最小的路线对应的灰尘度的值。 为了改善出行环境, 每个城市都要有所作为, 当某个城市进行道路改善时, 会将与这个城市直接相连的所有道路的灰尘度都减少 1 , 但每条道路都有一个 灰尘度的下限值 , 当灰尘度达到道路的下限值时, 无论再怎么改善, 道路的 灰尘度也不会再减小了。

具体的计划是这样的:

第 1 天, 0 号城市对与其直接相连的道路环境进行改善;

第 2 天, 1 号城市对与其直接相连的道路环境进行改善;

第 天, 号城市对与其直接相连的道路环境进行改善;

第 天, 0 号城市对与其直接相连的道路环境进行改善;

第 天, 1 号城市对与其直接相连的道路环境进行改善;

LQ 国想要使得 指标满足 。请问最少要经过多少天之后, 指标 可以满足 。如果在初始时就已经满足条件, 则输出 0 ; 如果永远不可能 满足, 则输出 。

输入格式

输入的第一行包含两个整数 , 用一个空格分隔, 分别表示城市个数和 期望达到的 指标。

接下来 行, 每行包含 个整数, 相邻两个整数之间用一个空格分隔, 其 中第 行第 列的值 表示城市 与城市 之间直接相连 的那条道路的灰尘度。

接下来 行, 每行包含 个整数, 相邻两个整数之间用一个空格分隔, 其 中第 行第 列的值 表示城市 与城市 之间直接相连的 那条道路的灰尘度的下限值。

输出格式

输出一行包含一个整数表示答条。

样例输入

1
2
3
4
5
6
7
3 10 
0 2 4 
2 0 1
4 1 0 
0 2 2
2 0 0 
2 0 0

样例输出

1
2

评测用例规模与约定

对于 的评测用例, ， ；

对于 的评测用例, ，;

对于所有评测用例, 。

运行限制

语言 最大运行时间 最大运行内存
C++ 10s 512M
C 10s 512M
Python3 10s 512M
Java 10s 512M

刷题统计

问题描述

小明决定从下周一开始努力刷题准备蓝桥杯竞赛。他计划周一至周五每天 做 道题目, 周六和周日每天做 道题目。请你帮小明计算, 按照计划他将在 第几天实现做题数大于等于 题?

输入格式

输入一行包含三个整数 和 .

输出格式

输出一个整数代表天数。

样例输入

1
10 20 99

样例输出

1
8

评测用例规模与约定

对于 的评测用例, .

对于 的评测用例, .

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

快速幂

题目描述

输入 ，， 的值，求 的值。其中 。

输入描述

三个整数 。

输出描述

输出 ， 为运算结果。

输入输出样例

示例

输入

1
2 10 9

输出

1
7

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

核桃的数量

题目描述

小张是软件项目经理，他带领 3 个开发组。工期紧，今天都在加班呢。为鼓舞士气，小张打算给每个组发一袋核桃（据传言能补脑）。他的要求是：

  1. 各组的核桃数量必须相同

  2. 各组内必须能平分核桃（当然是不能打碎的）

  3. 尽量提供满足 1,2 条件的最小数量（节约闹革命嘛）

输入描述

输入一行 ，都是正整数，表示每个组正在加班的人数，用空格分开。

输出描述

输出一个正整数，表示每袋核桃的数量。

输入输出样例

示例

输入

1
2 4 5

输出

1
20

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 64M
C 1s 64M
Python3 1s 64M
Java 1s 64M

质数

题目描述

给定一个正整数 ，请你输出 以内（不包含 ）的质数以及质数的个数。

输入描述

输入一行，包含一个正整数 。

输出描述

共两行。

第 行包含若干个素数，每两个素数之间用一个空格隔开，素数从小到大输出。

第 行包含一个整数，表示N以内质数的个数。

输入输出样例

示例

输入

1
10

输出

1
2
2 3 5 7 
4

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 128M
C 1s 128M
Python3 1s 128M
Java 1s 128M

分割立方体

题目描述

给定一个立方体，边长为 ，现将其分割成 个单位立方体。

分割后任意两个单位立方体，或者有 个公共点，或者有 个公共点，或者没有公共点。

请问，没有公共点和有 个公共点的立方体，共有多少对？

输入描述

输入一行包含一个整数 。

输出描述

输出一个整数表示答案。

输入输出样例

示例1

输入

1
1

输出

1
0

示例2

输入

1
2

输出

1
16

示例3

输入

1
3

输出

1
297

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

糊涂人寄信

题目描述

有一个糊涂人，写了 封信和 个信封，到了邮寄的时候，把所有的信都装错了信封。求装错信封可能的种类数。

输入描述

有多行读入，每行输入一个正整数 ，表示一种情况。()

输出描述

输出相应的答案。

输入输出样例

示例

输入

1
2
3
1
3
4

输出

1
2
3
0 
2
9

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M

小蓝吃糖果

题目描述

小蓝有 种糖果，每种数量已知。

小蓝不喜欢连续 次吃同样的糖果。问有没有可行的吃糖方案。

输入描述

第一行是整数 。

第二行包含 个数，表示 种糖果的数量 ，。

输出描述

输出一行，包含一个 Yes 或 No。

输入输出样例

示例

输入

1
2
3
4 1 1

输出

1
No

运行限制

语言 最大运行时间 最大运行内存
C++ 1s 256M
C 1s 256M
Python3 1s 256M
Java 1s 256M
打赏
支付宝 | Alipay
微信 | Wechat
≡