第十一届蓝桥杯国赛题目题解

最新推荐文章于 2024-05-09 16:24:38 发布

最新推荐文章于 2024-05-09 16:24:38 发布

分类专栏：蓝桥文章标签：蓝桥杯概率论算法

试题 A: 美丽的 2

 ans = 0
	for i in range(1, 2021):
    	i = str(i)
    	if '2' in i:
    	    ans += 1
	print(ans)

试题 B: 合数个数

<pre><code>#方法一
def heshu(x):
	for j in range(2, x):
    	for i in range(2, x):
    	    if i * j == x:
    	        return True
	return False

ans = 0
for i in range(1,2021):
	if heshu(i) is True:
	    ans += 1
print(ans)


#方法二（优化）
ans = 0
for i in range(4,2021):   		#2、3都是质数，可以直接4开始寻找
	for j in range(2,i//2+1):	#检测到i的一半就可以了
	    if i%j == 0:
	        ans += 1
	        break
print(ans)</pre></code>

试题 C: 阶乘约数

$x = p_1 ^ {a_1 }+p_2^{a_2}+...+p_k^{a_k}$
$约数个数 = (a_1 + 1) *(a_2+1)*...*(a_k+1)$

primes,cnt = [0]*110,0
minp = [0]*110
st = [False]*110
def get_primes(n):
    global cnt
    for i in range(2,n+1):
        if st[i] == False:
            minp[i] = i
            primes[cnt] = i
            cnt += 1
        j = 0
        while primes[j]*i <=n:
            t  = primes[j]*i
            st[t]  = True
            minp[t] = primes[j]
            if i%primes[j]:
                j += 1
            else:
                break
get_primes(100)
num = [0]*110
for i in range(2,101):
    while i>1:
        p = minp[i]
        while i%p==0:
            i //=p
            num[p] += 1
res = 1
for i in range(1,101):
    if num[i] != 0:
        res *= (num[i]+1)
print(res)

试题 D: 本质上升序列

str1 = 'lanqiao'
n = len(str1)
dp = [1] * n
for i in range(n):
    for j in range(i):
        if str1[j] < str1[i]:
            dp[i] += dp[j]
        elif str1[i] == str1[j]:
            dp[i] -= dp[j]
print(sum(dp))

试题 E: 玩具蛇

ml = [[-1, 0], [0, -1], [1, 0], [0, 1]]
move = [[False, False, False, False],
        [False, False, False, False],
        [False, False, False, False],
        [False, False, False, False]]
ans = 0
def DFS(x, y, step):
    global ans
    if step == 15:
        ans += 1
        return
    move[x][y] = True
    for i in range(4):
        dx = x + ml[i][0]
        dy = y + ml[i][1]
        if dx>= 0 and dx < 4 and dy >= 0 and dy < 4:
            if move[dx][dy] is False:
                DFS(dx, dy, step+1)
    move[x][y] = False

for i in range(4):
    for j in range(4):
        DFS(i, j, 0)
print(ans)

试题 F: 天干地支

t = ["","xin","ren","gui","jia","yi","bing","ding","wu","ji","geng"]
d = ["","you","xu","hai","zi","chou","yin","mao","chen","si","wu","wei","shen"]
n = int(input())
a,b = 1,1
for i in range(1,n+1):
    if a>10:
        a = a%10
    if a%10 == 0:
        a = 10
    if b>12:
        b = b%12
    if b%12 == 0:
        b = 12
    a += 1
    b += 1
print(t[a-1]+d[b-1])

#试题 G: 重复字符串
##【问题描述】
在这里插入图片描述

a a b
------------------------------------------
b a a

### 然后进行纵向比对，选择出现次数最多的字母，然后将所有其它字母变成这个字母就可以了。即 $L = n - (one_{max} + two_{max} + ... + {\frac{n}{k}}_{max})$

k=int(input())
s=input()
d, x=[], []
s1=""
m, c=len(s)//k, 0
print(len(s))
if len(s)%k!=0:
     print("1")
else:
     for i in range(m):
          for i1 in range(k):
               s1+=s[i+i1*m]
          d.append(s1)
          s1=""
     for i in d:
          a=set(i)
          for i1 in a:
               x.append(i.count(i1))
          c+=k-max(x)
          x=[]
     print(c)

试题 H: 答疑

$t_{1} = s_{1} + a_{1}$ $t_{2} = s_{2} + a_{2} + e_{1}$ ...... $t_{n} = s_{n} + a_{n} + e_{n-1}$


n = int(input())
timelist, sumlist = [], []
ci, res = 0, 0
for i in range(n):
    each = [int(i) for i in input().split()]
    timelist.append(each)

for i in range(n):
    ci += timelist[i][2]

for i in range(n):
    sum = 0
    for j in timelist[i]:
        sum += j
    sumlist.append(sum)
sumlist.sort()

for i in sumlist:
    res += n * i
    n -= 1

print(res - ci)

试题 I: 补给

试题 J: 蓝跳跳

if __name__ == '__main__':
    # 输入 k p l，空格分隔
    k, p, L = map(int, input("input k p L separated by one spaces:").split())
    # 1、生成二维数组，0层存 第一步小于p的方案数，1层存 总方案数
    # 最小数组长度
    len = k + 1
    dp = [[0 for e1 in range(2)] for e in range(len)]
    # 赋值 L=0 的情况
    dp[0][0] = 1
    dp[0][1] = 1
    i = 0  # 定义循环写入的角标
    # L为总距离数
    for l in range(1, L + 1):  # l无用
        # 循环改变数组列角标，取模
        i = (i + 1) % len
        # 临时值，用于将 第一步小于p的方案数 与
        # 第一步大于等于p的方案数相加
        sum = 0
        # 2、开始计算 第一步小于p的方案数，存储在二维数组的0层
        for j in range(1, p):
            sum += (dp[(i - j) % len][1]) % 20201114
        dp[i][0] = sum  # 记录 第一步小于p的方案数
        # 3、开始计算 第一步大于等于p的方案数
        for o in range(p, k + 1):
            # 之前sum已经是 第一步小于p的方案数
            # 这里直接相加就等于总方案数啦
            sum += dp[(i - o) % len][0] % 20201114
        dp[i][1] = sum  # 4、记录总方案数，存储在二维数组的1层
    # 5、循环结束，直接获取对应角标的1层即是 总方案数
    print((dp[i][1]) % 20201114)

写在后面（推卸责任）

0
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
第十一届蓝桥杯国赛题目题解

#mermaid-svg-DRCWXUtjV0dqOc7d .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-DRCWXUtjV0dqOc7d .label text{fill:#333}#mermaid-svg-DRCWXUtjV0dqOc7d .node rect,#mermaid-svg-DRCWXUtjV0
复制链接

扫一扫

第十一届蓝桥杯国赛题目题解

试题 A: 美丽的 2

【问题描述】

小蓝特别喜欢 2，今年是公元 2020 年，他特别高兴。他很好奇，在公元 1 年到公元 2020 年（包含）中，有多少个年份的数位中包含数字 2？

题解

简单的遍历，只需要判断2在不在里面就完事儿了。

代码

试题 B: 合数个数

【问题描述】

一个数如果除了 1 和自己还有其他约数，则称为一个合数。例如：1, 2, 3 不是合数，4, 6 是合数。请问从 1 到 2020 一共有多少个合数

题解

合数的本质就是寻找因数，遍历即可

代码

试题 C: 阶乘约数

【问题描述】

定义阶乘 n! = 1 × 2 × 3 × · · · × n。请问 100! （100 的阶乘）有多少个约数。

题解

这道题需要一点数论基础，即一个数的约数的个数和其质因数个数相关，具体如下：

其中 p 1 、 p 2 . . . p k p_1、p_2...p_k p1​、p2​...pk​为质数，现在我们需要做的就是将1到100（其实是2到100，因为1没有质因数）分解质因数，然后统计每一个质因数的个数，然后应用上面的公式即可。

代码

试题 D: 本质上升序列

【问题描述】

小蓝特别喜欢单调递增的事物。在一个字符串中，如果取出若干个字符，将这些字符按照在字符串中的顺序排列后是单调递增的，则成为这个字符串中的一个单调递增子序列。

例如，在字符串 lanqiao 中，如果取出字符 n 和 q，则 nq 组成一个单调递增子序列。类似的单调递增子序列还有 lnq、i、ano 等等。

小蓝发现，有些子序列虽然位置不同，但是字符序列是一样的，例如取第二个字符和最后一个字符可以取到 ao，取最后两个字符也可以取到 ao。小蓝认为他们并没有本质不同。

对于一个字符串，小蓝想知道，本质不同的递增子序列有多少个？

例如，对于字符串 lanqiao，本质不同的递增子序列有 21 个。它们分别是 l、a、n、q、i、o、ln、an、lq、aq、nq、ai、lo、ao、no、io、lnq、anq、lno、ano、aio。

请问对于以下字符串（共 200 个小写英文字母，分四行显示）：（如果你把以下文字复制到文本文件中，请务必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 inc.txt，内容与下面的文本相同）

tocyjkdzcieoiodfpbgcncsrjbhmugdnojjddhllnofawllbhf

iadgdcdjstemphmnjihecoapdjjrprrqnhgccevdarufmliqij

gihhfgdcmxvicfauachlifhafpdccfseflcdgjncadfclvfmad

vrnaaahahndsikzssoywakgnfjjaihtniptwoulxbaeqkqhfwl

本质不同的递增子序列有多少个？

题解

这道题的本质就是寻找递增序列，我们可以采用动态规划的方法来解决。所以我们先来了解一下动态规划。

所谓动态规划，最简单的就是我们的斐波那契数列，每一步的结果都可以由前面两步递推得到。即存在

Fibonacci[i] = Fibonacci[i-1] + Fibonacci[i-2]

以本题为例，本质上升序列是寻找每一个字母对应的不同子序列，我们采用的方式是利用固定每一个字母，然后依次搜索的方式。同时保存每一个搜索到的字符，最后再进行去重工作，计数。

于是我们思考优化我们的方案，基于一个朴素的认知，一般递归能够解决的问题都可以采用动态规划解决。所以，我们采用动态规划。

先考虑初始化，按照题意，每一个字母本身也是一个子序列，那么就是说每一个字母至少有一个子序列（如果字母不重复），所以我们初始化dp=[1]*n

找到初始条件和递推关系后，就可以写代码了。

代码

试题 E: 玩具蛇

【问题描述】

题解

这是一个往固定格子里放置物品的问题，唯一的限制就是物品是连续的，摆放时又顺序限制。当然，这只是题目写出的限制，我们要找出题目隐含条件的限制。

为了方便，我们将问题看作一个人，在十六宫格中任选一格作为起始点，其可以上下左右移动，但不能经过已经走过的格子，问这个人有多少种方法走完十六宫格。我们记其所在位置是(x,y)，每次移动记为。

那么第一个条件很明显，即，限制其不能离开十六宫格；第二个限制条件就是下一步的格子不能是已经走过的格子；而相比于前两个限制条件，第三个条件就没有那么容易想到——我们选择的行走方式一定要走完16个格子。

在弄清楚这三个条件之后，我们需要做的就是找出所有的行走方式，然后再与条件进行一一对照。即先遍历，再对照。按照这个思路，我们可以很轻易的想到回溯算法。

这里简单介绍一下回溯算法。

回溯算法有几个鲜明的特点：一、需要对所有可能进行遍历，毫不客气地说，这是一种极为低效的算法。二、记忆化，将满足条件的可能进行记忆，防止重复。三、回溯算法能够解决的问题全部都可以化作“树”的形式。

同时，它的代码也有几个特点：一、for循环横向遍历，递归纵向遍历；二、实现形式一般都是递归；三、需要明确终止条件。

在大概了解回溯算法之后，我们来看题。

如果我从A点开始走，我可以建立一个如下的树

同时，我们观察这棵树，我们会发现一个小惊喜，由于回溯算法的记忆化，那么不满足第三个条件的走法无法达到高度16，也就是说，我们真正需要在代码里添加的条件其实只有第二个——不能重复行走。

现在，我们已经有了回溯条件，只需要找到终止条件即可，很明显，观察上面那棵树，终止条件是high = 16，每一次high = 16,ans+=1即可。

代码

试题 F: 天干地支

【问题描述】

题解

没什么好说的，算就完了

代码

题解

其实这道题比较简单，只是需要思路上转一个弯就可以了。

首先n=s.length，如果n%k!=0，那直接return 1就可以了。

否则，以样例’aabbaa’，2为例，我们将其等分为’aab’,‘baa’，然后横向排列

试题 H: 答疑

【问题描述】

有 n 位同学同时找老师答疑。每位同学都预先估计了自己答疑的时间。老师可以安排答疑的顺序，同学们要依次进入老师办公室答疑。一位同学答疑的过程如下：

1.首先进入办公室，编号为 i 的同学需要 si 毫秒的时间。

2.然后同学问问题老师解答，编号为 i 的同学需要 ai 毫秒的时间。

3.答疑完成后，同学很高兴，会在课程群里面发一条消息，需要的时间可以忽略。

4.最后同学收拾东西离开办公室，需要 ei 毫秒的时间。一般需要 10 秒、20 秒或 30 秒，即 ei 取值为 10000，20000 或 30000。

一位同学离开办公室后，紧接着下一位同学就可以进入办公室了。答疑从 0 时刻开始。老师想合理的安排答疑的顺序，使得同学们在课程群里面发消息的时刻之和最小

【输入格式】

输入第一行包含一个整数 n，表示同学的数量。接下来 n 行，描述每位同学的时间。其中第 i 行包含三个整数 si, ai, ei，意义如上所述。

【输出格式】

输出一个整数，表示同学们在课程群里面发消息的时刻之和最小是多少。

【样例输入】

3

其中 $p_1、p_2...p_k$ 为质数，现在我们需要做的就是将1到100（其实是2到100，因为1没有质因数）分解质因数，然后统计每一个质因数的个数，然后应用上面的公式即可。

所以，我们可以轻易的知道，只需要对所有的 $t_{i} = s_{i} + a_{i} + e_{i}$ 进行排序即可，如果大小相等，即按照 $t_{i} = s_{i} + a_{i}$ 从小到大排序即可。