输入与输出

输入

数组输入:
可以提前定义
a = [0 for i in range(1000)]
或者
arr = list(map(int,input().split()))

输出

import math
pi = math.pi
p = -1*pi
print(pi)
print('%.4f' % pi)
# 2,前面补充前导0表示月份
a = 2 # 2月输出02
b = 11 # 11月输出11
print('%02d' % a)
print('%02d' % b)
print('%d %d' % (a,b))

dfs与bfs

X星球的一处迷宫游乐场建在某个小山坡上。
它是由10x10相互连通的小房间组成的。
房间的地板上写着一个很大的字母。
我们假设玩家是面朝上坡的方向站立，则：
L表示走到左边的房间，
R表示走到右边的房间，
U表示走到上坡方向的房间，
D表示走到下坡方向的房间。
X星球的居民有点懒，不愿意费力思考。
他们更喜欢玩运气类的游戏。这个游戏也是如此！
开始的时候，直升机把100名玩家放入一个个小房间内。
玩家一定要按照地上的字母移动。
迷宫地图如下：
UDDLUULRULUURLLLRRRURRUURLDLRDRUDDDDUUUUURUDLLRRUUDURLRLDLRLULLURLLRDURDLULLRDDDUUDDUDUDLLULRDLUURRR
# 每个方块有一名玩家
# 大暴力不叫dfs
def dfs(x,y):global answhile True:if x>9 or x<0 or y>9 or y<0:ans += 1breakif vis[x][y]==1:breakvis[x][y]=1if mp[x][y]=='U':x-=1elif mp[x][y]=='D':x+=1elif mp[x][y]=='L':y-=1elif mp[x][y]=='R':y+=1
def init():for i in range(10):for j in range(10):vis[i][j]=0
mp = ['' for i in range(10)]
for i in range(10):mp[i] = input()
ans = 0
vis = [[0]*10 for i in range(10)]
for i in range(10):for j in range(10):init()dfs(i,j)
print(ans)

农夫约翰有一片 N∗M 的矩形土地。最近，由于降雨的原因，部分土地被水淹没了。现在用一个字符矩阵来表示他的土地。每个单元格内，如果包含雨水，则用”W”表示，如果不含雨水，则用”.”表示。现在，约翰想知道他的土地中形成了多少片池塘。每组相连的积水单元格集合可以看作是一片池塘。每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。请你输出共有多少片池塘，即矩阵中共有多少片相连的”W”块。输入格式
第一行包含两个整数 N 和 M。接下来 N 行，每行包含 M 个字符，字符为”W”或”.”，用以表示矩形土地的积水状况，字符之间没有空格。输出格式
输出一个整数，表示池塘数目。数据范围
1≤N,M≤1000
输入样例：
10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.
输出样例：
3
n,m = list(map(int,input().split()))
mp = ['' for i in range(1000)]
vis = [[0]*1000 for i in range(1000)]
dx=[0,0,1,-1,1,1,-1,-1]
dy=[1,-1,0,0,1,-1,1,-1]
def bfs(x,y):q = []t = [x,y]q.append(t)vis[x][y]=1while len(q)>0:t=q[0]q.pop(0)for i in range(8):tx = dx[i]+t[0]ty = dy[i]+t[1]if tx>=0 and tx<n and ty>=0 and ty<m and vis[tx][ty]==0 and mp[tx][ty]=='W':z = [tx,ty]q.append(z)vis[tx][ty]=1
for i in range(n):mp[i] = input()
ans = 0
for i in range(n):for j in range(m):if vis[i][j]==0 and mp[i][j]=='W':bfs(i,j)ans+=1
print(ans)

一天Extense在森林里探险的时候不小心走入了一个迷宫，迷宫可以看成是由 n∗n 的格点组成，每个格点只有2种状态，.和#，前者表示可以通行后者表示不能通行。同时当Extense处在某个格点时，他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上，Extense想要从点A走到点B，问在不走出迷宫的情况下能不能办到。如果起点或者终点有一个不能通行(为#)，则看成无法办到。注意：A、B不一定是两个不同的点。输入格式
第1行是测试数据的组数 k，后面跟着 k 组输入。每组测试数据的第1行是一个正整数 n，表示迷宫的规模是 n∗n 的。接下来是一个 n∗n 的矩阵，矩阵中的元素为.或者#。再接下来一行是 4 个整数 ha,la,hb,lb，描述 A 处在第 ha 行, 第 la 列，B 处在第 hb 行, 第 lb 列。注意到 ha,la,hb,lb 全部是从 0 开始计数的。输出格式
k行，每行输出对应一个输入。能办到则输出“YES”，否则输出“NO”。数据范围
1≤n≤100
输入样例：
2
3
.##
..#
#..
0 0 2 2
5
.....
###.#
..#..
###..
...#.
0 0 4 0
输出样例:
YES
NO
t = int(input())
mp = ['' for i in range(100)]
vis = [[0]*100 for i in range(100)]
dx = [0,0,1,-1]
dy = [1,-1,0,0]
def bfs(x,y):k = [x,y]q = []q.append(k)vis[x][y]=1while len(q)>0:k = q.pop(0)if k[0]==ex and k[1]==ey:return Truefor i in range(4):tx = dx[i]+k[0]ty = dy[i]+k[1]if tx>=0 and tx<n and ty>=0 and ty<n and vis[tx][ty]==0 and mp[tx][ty]=='.':z = [tx,ty]# print(z)q.append(z)vis[tx][ty]=1return False
def init(n):for i in range(n):for j in range(n):vis[i][j]=0for i in range(t):n = int(input())for i in range(n):mp[i] = input()x,y,ex,ey = list(map(int,input().split()))init(n)if bfs(x,y)==True and mp[x][y]!='#':print('YES')else:print('NO')t = int(input())
mp = ['' for i in range(100)]
vis = [[0]*100 for i in range(100)]
dx = [0,0,1,-1]
dy = [1,-1,0,0]
def dfs(x,y):if mp[x][y]=='#':return Falseif x==ex and y==ey:return Truevis[x][y]=1for i in range(4):tx = x+dx[i]ty = y+dy[i]if tx>=0 and tx<n and ty>=0 and ty<n and vis[tx][ty]==0 and mp[tx][ty]=='.':if dfs(tx,ty):return Truereturn False
def init(n):for i in range(n):for j in range(n):vis[i][j]=0for i in range(t):n = int(input())for i in range(n):mp[i] = input()x,y,ex,ey = list(map(int,input().split()))init(n)if dfs(x,y)==True:print('YES')else:print('NO')

并查集

问题描述
w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。
如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？输入格式
第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1<m,n<1000）。
接下来一行，一个整数k，表示下面还有k行数据(0<k<100000)
接下来k行，第2+k行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。格子的编号一行一行，从上到下，从左到右编号。
比如：5 * 4 的小格子，编号：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20样例输入
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样例输出
5def init(n):for i in range(1,n+1):f[i]=i
def find(x):if f[x]==x:return xelse:f[x]=find(f[x])return f[x]
def union(x,y):a = find(x)b = find(y)if a!=b:f[a]=b
n,m = list(map(int,input().split()))
k = int(input())
f = [0 for i in range(m*n+1)]
l = [0 for i in range(m*n+1)]
init(n*m)
for i in range(k):x,y = list(map(int,input().split()))union(x,y)
for i in range(1,m*n+1):l[find(i)]=1
ans = 0
for i in range(1,m*n+1):if l[i]==1:ans+=1
print(ans)

哈夫曼树

n = int(input())
a = list(map(int,input().split()))
ans = 0
while len(a)>1:a.sort()x = a[0]a.pop(0)y = a[0]a.pop(0)ans = ans+x+ya.append(x+y)
print(ans)

二分

# 二分查询
import bisect
a = [0,1,2,4,6,7,9,10]
# bisect_left查找a数组中第一个大于等于5的数的下标
# bisect_right找a数组中第一个大于4的数的下标
print(bisect.bisect_left(a,5))
print(bisect.bisect_left(a,4))
print(bisect.bisect_right(a,4))
# insort_left
# insort_right

lambda排序

某小学最近得到了一笔赞助，打算拿出其中一部分为学习成绩优秀的前 5 名学生发奖学金。期末，每个学生都有 3 门课的成绩:语文、数学、英语。先按总分从高到低排序，如果两个同学总分相同，再按语文成绩从高到低排序，如果两个同学总分和语文成绩都相同，那么规定学号小的同学排在前面，这样，每个学生的排序是唯一确定的。任务：先根据输入的 3 门课的成绩计算总分，然后按上述规则排序，最后按排名顺序输出前五名学生的学号和总分。注意，在前 5 名同学中，每个人的奖学金都不相同，因此，你必须严格按上述规则排序。例如，在某个正确答案中，如果前两行的输出数据(每行输出两个数:学号、总分) 是:7 279
5 279
这两行数据的含义是:总分最高的两个同学的学号依次是 7 号、5 号。这两名同学的总分都是 279 (总分等于输入的语文、数学、英语三科成绩之和)，但学号为 7 的学生语文成绩更高一些。如果你的前两名的输出数据是:5 279
7 279
则按输出错误处理。输入格式
输入文件包含 n+1 行:第 1 行为一个正整数 n，表示该校参加评选的学生人数。第 2 到 n+1 行，每行有 3 个用空格隔开的数字，每个数字都在 0 到 100 之间，第 j 行的 3 个数字依次表示学号为 j−1 的学生的语文、数学、英语的成绩。每个学生的学号按照输入顺序编号为 1∼n (恰好是输入数据的行号减 1)。所给的数据都是正确的，不必检验。输出格式
输出文件共有 5 行，每行是两个用空格隔开的正整数，依次表示前 5 名学生的学号和总分。数据范围
6≤n≤300
输入样例：
6
90 67 80
87 66 91
78 89 91
88 99 77
67 89 64
78 89 98
输出样例：
6 265
4 264
3 258
2 244
1 237n = int(input())
res = []
# chinese math english
for i in range(1,n+1):c,m,e = list(map(int,input().split()))x = [c+m+e,c,i]res.append(x)
res.sort(lambda res:(-res[0],-res[1],res[2]))
for i in range(5):print('%d %d' % (res[i][2],res[i][0]))

# 学生按成绩排名由大到小，成绩相同按姓名字母序升序，之后按照id升序
# aa 100 1
# bb 100 2
# c 100 3
# d 90 4
# aa 100 5
n = int(input())
a = []
for i in range(n):name,score,i = list(input().split())x = [name,int(score),int(i)]a.append(x)
a.sort(lambda a:(-a[1],a[0],a[2]))
for i in range(n):print('%s %d %d' %(a[i][0],a[i][1],a[i][2]))

最小生成树

import math
n,m = list(map(int,input().split()))
e = []
for i in range(m):x = list(map(int,input().split()))e.append(x)
def find(x):if f[x]==x:return xelse:f[x]=find(f[x])return f[x]
f = [0 for i in range(n+1)]
inf = 100000000000000
def kruskal():e.sort(lambda e:e[2])for i in range(n+1):f[i]=ires=0cnt=0for i in range(m):a=e[i][0]b=e[i][1]w=e[i][2]a=find(a)b=find(b)if a!=b:f[a]=bres+=wcnt+=1if cnt<n-1:return infreturn res
ans = kruskal()
if ans!=inf:print(ans)
else:print('impossible')

素数筛

import bisect
n = int(input())
prime = []
N = 1000000
st = [0 for i in range(N+1)]
for i in range(2,N+1):if st[i]==1:continueprime.append(i)for j in range(i,N+1,i):st[j]=1
p = bisect.bisect_right(prime,n)
print(p)

最短路

Bell-man

n,m = list(map(int,input().split()))
e = []
for i in range(m):x = list(map(int,input().split()))e.append(x)
e.sort(lambda e:e[2])
inf = 1000000000
dist = [inf for i in range(1500)]
dist[1] = 0
for i in range(n):for j in range(m):a = e[j][0]b = e[j][1]w = e[j][2]if dist[b]>dist[a]+w:dist[b]=dist[a]+w
if dist[n]==inf:print(-1)
else:print(dist[n])

dijkstra

n, m = map(int, input().split())
maxdist = float("inf")
g = [[maxdist] * (n+1) for _ in range(n+1)] # 由于是密集图，m>>n，因此用邻接矩阵来存储，g[x][y]表示x指向y的距离
d = [maxdist] * (n+1) # 存储每个点距离起点的距离，初始化为距离最大，d[1]=0
st = [False] * (n+1) # 判断某一点的最短距离是否已经确定，False表示未确定，True表示确定def dijkstra():d[1] = 0for i in range(1, n+1): # 因为要确定n个点的最短路，因此要循环n次t = -1for j in range(1, n+1): # 每次找到还未确定最短路的点中距离起点最短的点tif not st[j] and (t==-1 or d[t]>d[j]):t = jst[t] = Truefor j in range(1, n+1): # 用t来更新t所指向的点的距离d[j] = min(d[j], d[t] + g[t][j])if d[n] >= maxdist:return -1else:return d[n]for _ in range(m):x, y, z = map(int, input().split())g[x][y] = min(g[x][y], z) # 当出现重边时，只需取两个距离中的最小值
print(dijkstra())

python蓝桥杯从入门到~相关推荐

蓝桥杯：入门训练序列求和
蓝桥杯:入门训练序列求和问题描述求1+2+3+...+n的值. 输入格式输入包括一个整数n. 输出格式输出一行,包括一个整数,表示1+2+3+...+n的值. 样例输入 4 样例输出 10 ...
蓝桥杯：入门训练圆的面积
蓝桥杯:入门训练圆的面积问题描述给定圆的半径r,求圆的面积. 输入格式输入包含一个整数r,表示圆的半径. 输出格式输出一行,包含一个实数,四舍五入保留小数点后7位,表示圆的面积. 说明:在本 ...
Python 蓝桥杯试题基础练习特殊回文数
Python 蓝桥杯试题基础练习特殊回文数问题描述: 123321是一个非常特殊的数,它从左边读和从右边读是一样的. 输入一个正整数n, 编程求所有这样的五位和六位十进制数,满足各位数字之和等于 ...
Python 蓝桥杯试题基础练习数列排序
Python 蓝桥杯试题基础练习数列排序题目描述: 问题描述给定一个长度为n的数列,将这个数列按从小到大的顺序排列.1<=n<=200 输入格式第一行为一个整数n. 第二行包含n ...
4.python蓝桥杯模拟题一个包含有2019个结点的有向图，最多包含多少条边？（不允许有重边）
4.python蓝桥杯模拟题一个包含有2019个结点的有向图,最多包含多少条边?(不允许有重边) 1.用n表示图中顶点的数目,e表示边或者弧的数目,则对于无向图来说,e的取值范围为0-(1/2)n( ...
python 蓝桥杯习题集（部分）
python 蓝桥杯习题集(部分) python 十进制转十六进制(蓝桥杯) python 十六进制转十进制(蓝桥杯) python 区间k大数查询(蓝桥杯) python 最大最小公倍数(蓝桥杯) ...
Python 蓝桥杯试题基础练习十六进制转八进制
Python 蓝桥杯试题基础练习十六进制转八进制问题描述给定n个十六进制正整数,输出它们对应的八进制数. 输入格式输入的第一行为一个正整数n (1<=n<=10). 接下来n行, ...
python蓝桥杯真题跑步锻炼
python蓝桥杯真题跑步锻炼题目描述小蓝每天都锻炼身体. 正常情况下,小蓝每天跑1千米.如果某天是周一或者月初(1日),为了激励自己,小蓝要跑2千米.如果同时是周一或月初,小蓝也是跑2千米. ...
Python 蓝桥杯试题基础练习字母图形
Python 蓝桥杯试题基础练习字母图形问题描述: 利用字母可以组成一些美丽的图形,下面给出了一个例子: ABCDEFG BABCDEF CBABCDE DCBABCD EDCBABC 这是一个 ...

python蓝桥杯从入门到~

输入与输出

输入

输出

dfs与bfs

并查集

哈夫曼树

二分

lambda排序

最小生成树

素数筛

最短路

Bell-man

dijkstra

python蓝桥杯从入门到~相关推荐

最新文章

热门文章