【思特奇杯·云上蓝桥-算法集训营】第2周

最新推荐文章于 2022-03-27 20:10:53 发布

m0_66083458

最新推荐文章于 2022-03-27 20:10:53 发布

阅读量62

点赞数

文章标签：蓝桥杯 c++ 职场和发展

本文链接：https://blog.csdn.net/m0_66083458/article/details/122513697

版权

带分数

问题描述

100 可以表示为带分数的形式：100 = 3 + 69258 / 714。

还可以表示为：100 = 82 + 3546 / 197。

注意特征：带分数中，数字1~9分别出现且只出现一次（不包含0）。

类似这样的带分数，100 有 11 种表示法。

输入格式

从标准输入读入一个正整数N (N<1000*1000)

输出格式

程序输出该数字用数码1~9不重复不遗漏地组成带分数表示的全部种数。

注意：不要求输出每个表示，只统计有多少表示法！

样例输入1

100

样例输出1

样例输入2

105

样例输出2

from itertools import permutations

num = int(input())
ans = 0
for n in range(1, num+1):
    if '0' in str(n) or len(set(list(str(n)))) != len(str(n)):
        continue

    diff = num - n
    s = '123456789'
    for i in str(n):
        s = s.replace(i, '') 

    for length in range(1, len(s)//2 + 1):
        for i in permutations(s, length): 
            fenzi = str(int(''.join(i)) * diff) 
            if len(fenzi) == len(s) - length:
                if set(list(fenzi)) == set(list(s)) - set(list(''.join(i))):
                    ans += 1
            
print(ans)

李白打酒

题目描述

话说大诗人李白，一生好饮。幸好他从不开车。

一天，他提着酒壶，从家里出来，酒壶中有酒2斗。他边走边唱：

无事街上走，提壶去打酒。

逢店加一倍，遇花喝一斗。

这一路上，他一共遇到店5次，遇到花10次，已知最后一次遇到的是花，他正好把酒喝光了。

请你计算李白遇到店和花的次序，可以把遇店记为a，遇花记为b。则：babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢？请你计算出所有可能方案的个数（包含题目给出的）。

def dfs(a, b, c):
    ans = 0
    if a == 0 and b == 0 and c == 1:
        return 1
    if a > 0:
        ans += dfs(a - 1, b, c * 2)
    if b > 0:
        ans += dfs(a, b - 1, c - 1)
    return ans

print(dfs(5, 9, 2))


num = 0
def dfs(a, b, c):
    if a == 0 and b == 0 and c == 1:
        global num
        num += 1
        return
    if a > 0:
        dfs(a-1, b, c*2)
    if b > 0:
        dfs(a, b-1, c-1)
    

dfs(5, 9, 2)
print(num)

第39级台阶

题目描述：

小明刚刚看完电影《第39级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是39级!

站在台阶前，他突然又想着一个问题：

如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，也就是说一共要走偶数步。那么，上完39级台阶，有多少种不同的上法呢？

输出格式：

输出一个整数

lis = [[-1] * 39 for _ in range(39)]

def dfs(n, s):  
    if n > 39:
        return 0
    elif n == 39:
        return 1 if s % 2 == 0 else 0

    if lis[n][s] != -1:
        return lis[n][s]
    else:
        ans = dfs(n + 1, s + 1) + dfs(n + 2, s + 1)
        lis[n][s] = ans
        return ans

print(dfs(0, 0))

穿越雷区

题目描述

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

例如：

A + - + -

- + - - +

- + + + -

+ - + - +

B + - + -

坦克车只能水平或垂直方向上移动到相邻的区。

数据格式要求：

输入第一行是一个整数n，表示方阵的大小， 4<=n<100

接下来是n行，每行有n个数据，可能是A，B，+，-中的某一个，中间用空格分开。

A，B都只出现一次。

要求输出一个整数，表示坦克从A区到B区的最少移动步数。

如果没有方案，则输出-1

例如：

用户输入：

A + - + -

- + - - +

- + + + -

+ - + - +

B + - + -

则程序应该输出：

资源约定：

峰值内存消耗 < 512M

CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

注意: main函数需要返回0

注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。

注意: 所有依赖的函数必须明确地在源文件中 #include <xxx>，不能通过工程

n = int(input())

m = [input().split(' ') for _ in range(n)]

visit = [[False] * n for _ in range(n)]

step = [(0, -1), (0, 1), (-1, 0), (1, 0)]

queue = [(0, 0, 0)]

while queue:
    y, x, t = queue.pop(0)
    if m[y][x] == 'B':
        print(t)
        break
    for dy, dx in step:
        ny = y + dy
        nx = x + dx
        if -1 < nx < n and -1 < ny < n:
            if not visit[ny][nx] and m[y][x] != m[ny][nx]:
                queue.append((ny, nx, t+1))
                visit[y][x] = True
    
if not queue:
    print(-1)

迷宫

题目描述

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

010000

000100

001001

110000

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

答案提交

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

m = '''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'''

m = m.split('\n')

visit = [[False] * 50 for _ in range(30)]
visit[0][0] = True

step = [(1, 0, 'D'), (0, -1, 'L'), (0, 1, 'R'), (-1, 0, 'U')]


queue = [(0, 0, -1, 0)]
path = []
while queue:
    y, x, _, _  = cur = queue.pop(0)
    path.append(cur)

    if cur[:2] == (29, 49):
        temp = []
        i = len(path) - 1
        while i > 0:
            temp.append(path[i][3])
            i = path[i][2]
        temp.reverse() 
        print(''.join(temp))
        break

    for dy, dx, dir in step: 
        ny, nx = y+dy, x+dx
        if -1 < nx < 50  and -1 < ny < 30 and m[ny][nx] == '0' and not visit[ny][nx]:          
            queue.append((ny, nx, len(path)-1, dir))
            visit[ny][nx] = True

跳马

问题描述：

中国象棋半张棋盘如图1所示。马自左下角(0,0)向右上角（m，n）跳。规定只能往右跳，不准往左跳。比如图1中所示为一种跳行路线，并将路径总数打印出来。

输入格式：

只有一行：两个数n，m

输出格式：

只有一个数：总方案数total。

a, b, c, d = map(int, input().split(' '))

step = [(1, 2), (1, -2), (-1, 2), (-1, -2), (2, 1), (2, -1), (-2, 1), (-2, -1)]

visit = [[False]*8 for _ in range(8)]


queue = [(a, b, 0)]

while queue:
    y, x, t = queue.pop(0)

    if y == c and x == d:
        print(t)
        break

    for dy, dx in step:
        ny = y + dy
        nx = x + dx
        if -1 < ny < 8 and -1 < nx < 8 and not visit[ny][nx]:
            queue.append((ny, nx, t+1))
            visit[ny][nx] = True
    
if not queue:
    print(-1)

路径之谜

小明冒充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

示例：

用户输入：

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，否则按无效代码处理。

n = int(input())

nums = [list(map(int, input().split(' '))) for _ in range(2)] 
visit = [[False]*n for _ in range(n)]
visit[0][0] = True

ans = [0]

record = [[0]*n for _ in range(2)]
record[0][0] = record[1][0] = 1

step = [(0, -1), (0, 1), (-1, 0), (1, 0)]

def dfs(y, x):
    if y == n-1 and x == n-1 and record == nums:
        print(' '.join(map(str, ans)))
        return
    for dy, dx in step:
        ny = y + dy
        nx = x + dx
        if -1 < ny < n and -1 < nx < n and not visit[ny][nx]:
            ans.append(ny*n + nx)
            visit[ny][nx] = True
            record[0][nx] += 1
            record[1][ny] += 1

            dfs(ny, nx)

            ans.pop()
            visit[ny][nx] = False
            record[0][nx] -= 1
            record[1][ny] -= 1
            
dfs(0, 0)

未名湖边的烦恼

问题描述

　　每年冬天，北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋，可是人太多了，每天下午收工后，常常一双冰鞋都不剩。

　　每天早上，租鞋窗口都会排起长龙，假设有还鞋的m个，有需要租鞋的n个。现在的问题是，这些人有多少种排法，可以避免出现体育组没有冰鞋可租的尴尬场面。（两个同样需求的人（比如都是租鞋或都是还鞋）交换位置是同一种排法）

输入格式

　　两个整数，表示m和n

输出格式

　　一个整数，表示队伍的排法的方案数。

样例输入

3 2

样例输出

数据规模和约定

m,n∈［0,18］

m, n = map(int, input().split(' '))

record = [[-1]*(n+1) for _ in range(m+1)]

def dfs(a, b):
    if a == b == 0:
        return 1
    
    if record[a][b] != -1:
        ans = record[a][b]
    else:
        ans = 0
        if a > 0:
            ans += dfs(a-1, b)
        if 0 < b <= a:
            ans += dfs(a, b-1)
        record[a][b] = ans
    
    return ans

print(dfs(m, n))

大臣的旅费

问题描述

很久以前，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最多花费的路费是多少。

样例输入1

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

样例输出1

135

输出格式

大臣J从城市4到城市5要花费135的路费。

n = int(input())
lis = [list(map(int, input().split(' '))) for _ in range(n-1)]
m = {i: [] for i in range(1, n+1)}
for i in lis:
    m[i[0]].append(i[1:])
    m[i[1]].append((i[0], i[2]))

visit = [False] * (n+1)

node = max_length = 0
def dfs(x, length):
    global max_length
    if length > max_length:
        global node
        max_length, node = length, x
    
    for nx, l in m[x]:
        if not visit[nx]:
            visit[nx] = True
            dfs(nx, length+l)
            visit[nx] = False

dfs(1, 0)

visit = [False] * (n+1)
visit[node] = True
dfs(node, 0)


print(max_length * 11 + max_length*(max_length-1)//2)

2n皇后问题

Description

给定一个n*n的棋盘，棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后

和n个白皇后，使任意的两个黑皇后都不在同一行、同一列或同一条对角线上，任意的两

个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法？n小于等于8。

Input

输入的第一行为一个整数n，表示棋盘的大小。

接下来n行，每行n个0或1的整数，如果一个整数为1，表示对应的位置可以放皇后，

如果一个整数为0，表示对应的位置不可以放皇后。

Output

输出一个整数，表示总共有多少种放法。

Sample Input

No.1

1 1 1 1

No.2

1 0 1 1

1 1 1 1

Sample Output

No.1

No.2

def check(record, i, j):
    for k in range(i): 
        if j == record[k] or abs(record[k] - j) == abs(i - k):
            return False
    return True
    

def dfs(record, i, color):
    if i == n: 
        if color == 'black':
            dfs([0]*n, 0, 'white')
        else:
            global ans
            ans += 1
        return

    for j in range(n):
        if m[i][j] == '1':
            if check(record, i, j):
                m[i][j] = '2'
                record[i] = j
                dfs(record, i+1, color)
                m[i][j] = '1'
            

n = int(input())
m = [input().split(' ') for _ in range(n)]

ans = 0
dfs([0]*n, 0, 'black')

print(ans)