1.带分数
问题描述
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)
2.李白打酒
题目描述
话说大诗人李白,一生好饮。幸好他从不开车。
一天,他提着酒壶,从家里出来,酒壶中有酒2斗。他边走边唱:
无事街上走,提壶去打酒。
逢店加一倍,遇花喝一斗。
这一路上,他一共遇到店5次,遇到花10次,已知最后一次遇到的是花,他正好把酒喝光了。
请你计算李白遇到店和花的次序,可以把遇店记为a,遇花记为b。则:babaabbabbabbbb 就是合理的次序。像这样的答案一共有多少呢?请你计算出所有可能方案的个数(包含题目给出的)。
答案提交:
def dfs(a, b, c):
if a > 0:
dfs(a - 1, b, c * 2)
if b > 0:
dfs(a, b - 1, c - 1)
if a == 0 and b == 0 and c == 1:
res.append(1)
return res
res = []
print(len(dfs(5, 9, 2)))
结果:14
3.第39级台阶
题目描述:
小明刚刚看完电影《第39级台阶》,离开电影院的时候,他数了数礼堂前的台阶数,恰好是39级!
站在台阶前,他突然又想着一个问题:
如果我每一步只能迈上1个或2个台阶。先迈左脚,然后左右交替,最后一步是迈右脚,也就是说一共要走偶数步。那么,上完39级台阶,有多少种不同的上法呢?
输出格式:
输出一个整数
答案提交:
lis = [[-1] * 39 for _ in range(39)]
def walk(num, step):
if num > 39:
return 0
elif num == 39:
return 1 if step % 2 == 0 else 0
if lis[num][step] != -1:
return lis[num][step]
else:
ans = walk(num + 1, step + 1) + walk(num + 2, step + 1)
lis[num][step] = ans
return ans
print(walk(0, 0))
结果:51167078
4.穿越雷区
题目描述
已知的地图是一个方阵,上面用字母标出了A,B区,其它区都标了正号或负号分别表示正负能量辐射区。
例如:
A + - + -
- + - - +
- + + + -
+ - + - +
B + - + -
坦克车只能水平或垂直方向上移动到相邻的区。
数据格式要求:
输入第一行是一个整数n,表示方阵的大小, 4<=n<100
接下来是n行,每行有n个数据,可能是A,B,+,-中的某一个,中间用空格分开。
A,B都只出现一次。
要求输出一个整数,表示坦克从A区到B区的最少移动步数。
如果没有方案,则输出-1
例如:
用户输入:
5
A + - + -
- + - - +
- + + + -
+ - + - +
B + - + -
则程序应该输出:
10
资源约定:
峰值内存消耗 < 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)
5.迷宫
题目描述
下图给出了一个迷宫的平面图,其中标记为 1 的为障碍,标记为 0 的为可 以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角,出口为右下角,在迷宫中,只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫,从入口开始,可以按DRRURRDDDR 的顺序通过迷宫, 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫(30 行 50 列),请找出一种通过迷宫的方式, 其使用的步数最少,在步数最少的前提下,请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。(如果你把以下文字复制到文本文件中,请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt, 内容与下面的文本相同)
答案提交
这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一 个字符串,包含四种字母 D、U、L、R,在提交答案时只填写这个字符串,填 写多余的内容将无法得分
data = '''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'''
data_array = []
data_array.append([1]*52)
for i in data.split():
data_array.append([])
data_array[-1].append(1)
for j in i:
data_array[-1].append(int(j))
data_array[-1].append(1)
data_array.append([1]*52)
visited = []
queue = [[(1, 1)]]
start = (1, 1)
end = (30, 50)
visited.append(start)
def bfs(lst, queue, end):
if end in queue[-1]:
return queue
alist = []
for now in queue[-1]:
row, col = now
if lst[row+1][col] == 0 and ((row+1, col) not in visited):
alist.append((row+1, col))
visited.append((row+1, col))
if lst[row][col+1] == 0 and ((row, col+1) not in visited):
alist.append((row, col+1))
visited.append((row, col+1))
if lst[row-1][col] == 0 and ((row-1, col) not in visited):
alist.append((row-1, col))
visited.append((row-1, col))
if lst[row][col-1] == 0 and ((row, col-1) not in visited):
alist.append((row, col-1))
visited.append((row, col-1))
queue.append(alist)
return bfs(lst, queue, end)
queue = bfs(data_array, queue, end)
Stack = []
Stack.append(start)
visited_1 = [start]
while Stack[-1] != end:
now = Stack[-1]
row, col = now
i = queue[len((Stack))]
if (row+1, col) in i and (row+1, col) not in visited_1:
Stack.append((row+1, col))
visited_1.append((row+1, col))
continue
elif (row, col-1) in i and (row, col-1) not in visited_1:
Stack.append((row, col-1))
visited_1.append((row, col-1))
continue
elif (row, col+1) in i and (row, col+1) not in visited_1:
Stack.append((row, col+1))
visited_1.append((row, col+1))
continue
elif (row-1, col) in i and (row-1, col) not in visited_1:
Stack.append((row-1, col))
visited_1.append((row-1, col))
continue
else:
Stack.pop()
length_1 = len(Stack)
strstep = ""
for i in range(1,length_1):
if Stack[i][0] > Stack[i-1][0]:
strstep += "D"
elif Stack[i][0] < Stack[i-1][0]:
strstep += "U"
elif Stack[i][1] > Stack[i-1][1]:
strstep += "R"
else:
strstep += "L"
print(strstep)
6.跳马
问题描述:
中国象棋半张棋盘如图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)
结果:37
7.路径之谜
小明冒充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,否则按无效代码处理。
答案提交:
path = [0 for _ in range(401)]
dx = [1, 0, -1, 0]
dy = [0, 1, 0, -1]
cntx = [0 for _ in range(21)]
cnty = [0 for _ in range(21)]
maps = [[False for _ in range(21)]for _ in range(21)]
sun = False
tot = 0
def check():
for i in range(0, n):
if cntx[i] != 0 or cnty[i] != 0:
return False
return True
def dfs(x, y, num):
global sun
path[num] = y *n + x
maps[x][y] = True
cntx[x] -= 1
cnty[y] -= 1
if x == n and y == n and check():
sun = True
return
for i in range(4):
x1 = x + dx[i]
y1 = y + dy[i]
if not sun and not maps[x1][y1] and 0 <= x1 < n and 0 <= y1 < n:
if cntx[x1] > 0 and cnty[y1] > 0:
dfs(x1, y1, num+1)
maps[x1][y1] = False
cntx[x1] += 1
cnty[y1] += 1
n = int(input())
for i in range(0, n):
cntx[i] = int(input())
tot += cntx[i]
for i in range(0, n):
cnty[i] = int(input())
tot += cnty[i]
dfs(0, 0, 0)
print(path[:tot//2])
8.未名湖边的烦恼
问题描述
每年冬天,北大未名湖上都是滑冰的好地方。北大体育组准备了许多冰鞋,可是人太多了,每天下午收工后,常常一双冰鞋都不剩。
每天早上,租鞋窗口都会排起长龙,假设有还鞋的m个,有需要租鞋的n个。现在的问题是,这些人有多少种排法,可以避免出现体育组没有冰鞋可租的尴尬场面。(两个同样需求的人(比如都是租鞋或都是还鞋)交换位置是同一种排法)
输入格式
两个整数,表示m和n
输出格式
一个整数,表示队伍的排法的方案数。
样例输入
3 2
样例输出
5
数据规模和约定
m,n∈[0,18]
答案提交:
def Lakefannao(m,n):
if m<n:return 0
res=[]
def back(lend,use,temp):
if len(temp)==n+m:
res.append(temp)
return
if lend<m:
back(lend+1,use,temp+'+')
if lend>use and use<n:
back(lend,use+1,temp+'-')
back(0,0,'')
#print(res)
return len(res)
if __name__=='__main__':
m,n=map(int,input().split())
print(Lakefannao(m,n))
9.大臣的旅费
问题描述
很久以前,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)
10.2n皇后问题
Description
给定一个n*n的棋盘,棋盘中有一些位置不能放皇后。现在要向棋盘中放入n个黑皇后
和n个白皇后,使任意的两个黑皇后都不在同一行、同一列或同一条对角线上,任意的两
个白皇后都不在同一行、同一列或同一条对角线上。问总共有多少种放法?n小于等于8。
Input
输入的第一行为一个整数n,表示棋盘的大小。
接下来n行,每行n个0或1的整数,如果一个整数为1,表示对应的位置可以放皇后,
如果一个整数为0,表示对应的位置不可以放皇后。
Output
输出一个整数,表示总共有多少种放法。
Sample Input
No.1
4
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
No.2
4
1 0 1 1
1 1 1 1
1 1 1 1
1 1 1 1
Sample Output
No.1
2
No.2
0
答案提交:
def chick_W(nums_W, row):
if list1[row][nums_W[row]]==1:
for i in range(row):
if abs(nums_W[i] - nums_W[row])==abs(i - row) or nums_W[i]==nums_W[row]:
return False
return True
return False
def chick_B(nums_B, row):
if list1[row][nums_B[row]]==1 and nums_W[row]!=nums_B[row]:
for i in range(row):
if abs(nums_B[i] - nums_B[row])==abs(i - row) or nums_B[i]==nums_B[row]:
return False
return True
return False
def dfs_W(nums_W, row):
if row==n:
dfs_B(nums_B,0)
return
for i in range(n):
nums_W[row]=i
if chick_W(nums_W, row):
dfs_W(nums_W, row + 1)
def dfs_B(nums_B, row):
global count
if row==n:
count+=1
return
for i in range(n):
nums_B[row]=i
if chick_B(nums_B, row):
dfs_B(nums_B, row + 1)
n=int(input())
list1=[]
for i in range(n):
list1.append(list(map(eval,input().split())))
list2=[]
nums_W=[0 for i in range(n)]
nums_B=[0 for i in range(n)]
count=0
dfs_W(nums_W, 0)
print(count)