【思特奇杯•云上蓝桥--算法训练营】第2周作业 蓝桥杯真题（Python）

第一题 带分数

问题描述

100 可以表示为带分数的形式：100 = 3 + 69258 / 714。
还可以表示为：100 = 82 + 3546 / 197。
注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。
类似这样的带分数，100 有 11 种表示法。
输入格式：
从标准输入读入一个正整数N (N<1000*1000)
输出格式：
程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。
注意：不要求输出每个表示，只统计有多少表示法！
样例输入1
100
样例输出1
11
样例输入2
105
样例输出2
6

代码

a = input('')
a_num = int(a)
count = 0
# print(int('9'*(5-len(a)))+int('9'*(6-len(a))))
for i in range(int('9'*(5-len(a))), int('9'*(6-len(a)))):
    # print(i)
    for n in range(1, a_num):
        stra = str(n) + str((a_num - n)*i) + str(i)
        # print(n, (a_num - n)*i, i)
        for j in range(9):
            if str(j+1) not in stra:
                j = 7
                break
        if j == 8 and len(stra) == 9:
            # print(stra)
            # print(n, (a_num - n)*i, i)
            count += 1
        # print(stra)
print(count)

结果

解析

N=A+B/C

• B=(N-A)C，B可以整除C，B可以整除(N-A)
• ABC中不能有重复数字
先遍历A，得到一个数字M=N-A
比如：
N=100，遍历到A=3，那么M=97
B=MC，即B=97*C
此时A是一位数字3，那么其他8位数字是可能出现在B和C之中，B又需要大于C，所以B的位数应该大于等于C，那么B至少应该是4位数字，反过来说C至多是4位数字。用B的所有排列，利用排列8个中选4个，8个中选5个，8个中选6个，8个中选7个，得到所有B的可能，此时B是可以整除C得到97的，那么反过来B可以整除97得到C的，那么首先判断B的候选数是否可以整除M(在这里是97)，如果可以，那么相除得到C，判断得到的C是否出现和B或者和A相同的数字，如果没有，那么这一组数字便是需要的A、B、C，否则继续遍历。

第二题 李白打酒

问题描述

话说大诗人李白，一生好饮。幸好他从不开车。
一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：
无事街上走，提壶去打酒。
逢店加一倍，遇花喝一斗。
这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。
请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。

代码

def dajiu(s,f,a):     #s店铺,f花,a酒
    if s>0:
        dajiu(s - 1,f,a * 2)
    if f>0:
        dajiu(s,f - 1,a - 1)
    if (s == 0 and f == 1 and a == 1):
        list.append(1)
    return list
list = []
print (len(dajiu(5,10,2)))

结果

14

解析

递归

第三题 第39级台阶

问题描述

小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级!
站在台阶前，他突然又想着一个问题：
如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？
输出一个整数

代码

def count (n):
    if n==0 :
        return True
    elif n<0:
        return False
    else:
        return count(n-2)+count(n-3)*2+count(n-4)

print(count(39))

结果

51167078

解析

递归
三种形式：1+1，1+2，2+2

第四题 穿越雷区

问题描述

已知的地图是一个方阵，上面用字母标出了A，B区，其它区都标了正号或负号分别表示正负能量辐射区。
例如：

坦克车只能水平或垂直方向上移动到相邻的区。
数据格式要求：
输入第一行是一个整数n，表示方阵的大小， 4<=n<100
接下来是n行，每行有n个数据，可能是A，B，+，-中的某一个，中间用空格分开。
A，B都只出现一次。
要求输出一个整数，表示坦克从A区到B区的最少移动步数。
如果没有方案，则输出-1
例如：
用户输入：

则程序应该输出：
10
资源约定：
峰值内存消耗 < 512M
CPU消耗 < 1000ms

答案提交

请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include ， 不能通过工程

代码

n = int(input())
#模拟地图
mMap = [list(input().split()) for _ in range(n)]
#标记是否访问过、访问过为True未访问过为False
mVis = [[False for _ in range(n)] for _ in range(n) ]
mVis[0][0] = True
#模拟在图中上下左右走
xMove = [-1,1,0,0]
yMove = [0,0,1,-1]
#队列记录坐标和走到的次数
queue = [[0,0,0]]
while queue:
    #当走到了b点退出广搜、打印走的次数
    if mMap[queue[0][0]][queue[0][1]] == 'B':
        print(queue[0][2])
        break
    for i in range(4):
        dx = queue[0][0] + xMove[i]
        dy = queue[0][1] + yMove[i]
        if dx>=0 and dx<=n-1 and dy>=0 and dy<=n-1:
            if not mVis[dx][dy] and mMap[queue[0][0]][queue[0][1]] != mMap[dx][dy]:
                """没有访问过并且不是连续的走-和+就可以将点加入队列"""
                queue.append([dx,dy,queue[0][2]+1])
                mVis[dx][dy] = True
    queue.pop(0)
 
if len(queue) == 0:
    """队列为空说明走不到B点"""
    print("-1")

结果

第五题 迷宫

问题描述

下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。（如果你把以下文字复制到文本文件中，请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt， 内容与下面的文本相同）
文件内容：
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

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个字符串，包含四种字母 D、U、L、R，在提交答案时只填写这个字符串，填 写多余的内容将无法得分

代码

class Node(object):
    def __init__(self, x, y, c):
        self.x = x
        self.y = y
        self.c = c

    def __str__(self):
        return self.c


def up(node):
    return Node(node.x - 1, node.y, node.c + 'U')


def down(node):
    return Node(node.x + 1, node.y, node.c + 'D')


def left(node):
    return Node(node.x, node.y - 1, node.c + 'L')


def right(node):
    return Node(node.x, node.y + 1, node.c + 'R')


if __name__ == '__main__':
    m = 0
    n = 0
    visited = set()
    map_int = []
    queen = []
    with open('maze.txt', mode='r', encoding='utf-8') as fp:
        data = fp.readlines()
        for line in data:
            map_int.append(list(line.strip()))
        m = len(map_int)
        n = len(map_int[0])
        node = Node(0, 0, '')
        queen.append(node)
        while len(queen) != 0:
            move_node = queen[0]
            queen.pop(0)
            move_str = str(move_node.x) + ' ' + str(move_node.y)
            if move_str not in visited:
                visited.add(move_str)
                if move_node.x == m - 1 and move_node.y == n - 1:
                    print(move_node)
                    print(len(move_node.__str__()))
                    break
                if move_node.x < m - 1 and map_int[move_node.x + 1][move_node.y] == '0':
                    queen.append(down(move_node))
                if move_node.y > 0 and map_int[move_node.x][move_node.y - 1] == '0':
                    queen.append(left(move_node))
                if move_node.y < n - 1 and map_int[move_node.x][move_node.y + 1] == '0':
                    queen.append(right(move_node))
                if move_node.x > 0 and map_int[move_node.x - 1][move_node.y] == '0':
                    queen.append(up(move_node))

结果

解析

BFS：广度优先搜索
python实现BFS（广度优先搜索）& DFS（深度优先搜索）

第六题 跳马

问题描述

时间限制：1.0s 内存限制：256.0MB
一个8×8的棋盘上有一个马初始位置为(a,b)，他想跳到(c,d)，问是否可以？如果可以，最少要跳几步？
输入格式：
一行四个数字a,b,c,d
输出格式：
如果跳不到，输出-1；否则输出最少跳到的步数。
样例输入：
1 1 2 3
样例输出：
1
数据规模和约定：
0<a,b,c,d≤8且都是整数

代码

a,b,c,d=list(map(int,input().split()))
dir=[[1,2],[1,-2],[2,1],[-2,1],[-2,-1],[2,-1],[-1,-2],[-1,2]]
visited=[]
for i in range(9):
    visited.append([0]*9)
minnum=float('inf')
 
def dfs(x,y,step):
    global visited,minnum
    if step>=minnum:
        return
    if x==c and y==d:
        minnum=step
        return
    for i in range(8):
        nx=x+dir[i][0]
        ny=y+dir[i][1]
        if nx > 0 and nx <= 8 and ny > 0 and ny <= 8:
            if visited[nx][ny]==0:
                visited[nx][ny]=1
                dfs(nx,ny,step+1)
                visited[nx][ny]=0
 
visited[a][b]=1
dfs(a,b,0)
if minnum==float('inf'):
    print(-1)
else:
    print(minnum)

结果

第七题 路径之谜

问题描述

小明冒充X星球的骑士，进入了一个奇怪的城堡。
城堡里边什么都没有，只有方形石头铺成的地面。
假设城堡地面是 n x n 个方格。【如图1.png】所示。

按习俗，骑士要从西北角走到东南角。
可以横向或纵向移动，但不能斜着走，也不能跳跃。
每走到一个新方格，就要向正北方和正西方各射一箭。
（城堡的西墙和北墙内各有 n 个靶子）
同一个方格只允许经过一次。但不必做完所有的方格。
如果只给出靶子上箭的数目，你能推断出骑士的行走路线吗？
有时是可以的，比如图1.png中的例子。
本题的要求就是已知箭靶数字，求骑士的行走路径（测试数据保证路径唯一）
输入：
第一行一个整数N(0<N<20)，表示地面有 N x N 个方格
第二行N个整数，空格分开，表示北边的箭靶上的数字（自西向东）
第三行N个整数，空格分开，表示西边的箭靶上的数字（自北向南）
输出：
一行若干个整数，表示骑士路径。
为了方便表示，我们约定每个小格子用一个数字代表，从西北角开始编号: 0,1,2,3…
比如，图1.png中的方块编号为：
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
示例：
用户输入：
4
2 4 3 4
4 3 3 3
程序应该输出：
0 4 5 1 2 3 7 11 10 9 13 14 15
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

路径之谜

第八题 未名湖边的烦恼

问题描述

每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。
　　每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法）
输入格式
　　两个整数，表示m和n
输出格式
　　一个整数，表示队伍的排法的方案数。
样例输入
3 2
样例输出
5
数据规模和约定
　　m,n∈［0,18］

代码

while 1:
    try:
        def fun_Rec(a,b):
            if b > a:
                return 0
            elif b == 0:
                return 1
            else:
                return fun_Rec(a,b-1) + fun_Rec(a-1,b)

        s = list(map(int, input().split()))
        a,b = s[0], s[1]
        print(fun_Rec(a,b))
    except:
        break

第九题 大臣的旅费

问题描述

很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。
为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。
J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。
聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。
J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？
输入格式
输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数
城市从1开始依次编号，1号城市为首都。
接下来n-1行，描述T国的高速路（T国的高速路一定是n-1条）
每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。
输出格式
输出一个整数，表示大臣J最多花费的路费是多少。
样例输入：
5
1 2 2
1 3 1
2 4 5
2 5 4
样例输出：
135
输出格式
大臣J从城市4到城市5要花费135的路费

代码

cnt=0
node=0
def dfs(v,k):   #进行dfs搜索
    global cnt
    global node
    global vis
    if k>cnt:
        cnt=k
        node=v
    for i in range(len(E[v])):
        if vis[E[v][i][0]]==False: #没访问过的点都进行一次dfs
            vis[E[v][i][0]]=True #进行标记
            dfs(E[v][i][0],k+E[v][i][1])
            vis[E[v][i][0]]=False #回溯
n=int(input())
E=[[]for i in range(n+1)]
vis=[False for i in range(n+1)]
for i in range(n-1):
    x,y,z=map(int,input().split())
    E[x].append((y,z))
    E[y].append((x,z)) #将各个点进行连接，用列表数组的方式进行
vis[1]=True
dfs(1,0)  #找到距离1最远的点node
vis[1]=False
cnt=0
vis[node]=True
dfs(node,0)  #从node出发，找到最远的点，就是所要求的最远距离
res=0
for i in range(1,cnt+1):
    res+=i+10
print(res)

第十题 2n皇后问题

问题描述

给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后
和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两
个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。
输入格式：
输入的第一行为一个整数n，表示棋盘的大小。
接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，
如果一个整数为0，表示对应的位置不可以放皇后。
输出格式：
输出一个整数，表示总共有多少种放法。
样例输入1：
No.1
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
样例输出1：
2
样例输入2：
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1

代码

n = int(input())
mapL = [list(map(int,input().split())) for _ in range(n)]   
count = 0   #计数器
def dfs(row,n,s,mapL):
    global count
    if row == n:    #判断是否是放完了最后一行，注意我的行数是从0开始，0代表第一行
        if s == 2:  #2代表黑皇后，3代表白皇后
            dfs(0,n,3,mapL) #黑皇后放完，开始放白皇后
        if s == 3:  #全部放完
            count += 1
        return
    for i in range(n):
        if mapL[row][i] != 1:   #不为1、说明放了皇后，或者不能皇后
            continue
        if check(row,i,s,mapL):
            mapL[row][i] = s    #可以放，将格子的数字变为放置对应皇后的数字
            dfs(row+1,n,s,mapL)
            mapL[row][i] = 1
 
def check(row,j,s,mapL):
    r = row - 1
    k = j - 1
    for i in range(row-1,-1,-1):
        if mapL[i][j] == s:
            return False
    while r>=0 and k>=0:
        if mapL[r][k] == s:
            return False
        r -= 1
        k -= 1
    r = row -1
    k = j + 1
    while r>=0 and k<n:
        if mapL[r][k] == s:
            return False
        r -= 1
        k += 1
    return True
dfs(0,n,2,mapL)
print(count)