python
import datetime
a=datetime.date(1900,1,1)
count=0
while True:
if '2'in str(a):
count+=1
if a==datetime.date(9999,12,31)
break
a+=datetime.timedelta(days=1)
print(count)
python
# 1. 初始化卡片数组
cards = [2021] * 10
# 2. 从数字1开始拼
n = 1
# 3. 无限循环，直到拼不出数字为止
while True:
# 4. 把当前数字n转成字符串，方便逐位取数字
s = str(n)
# 5. 标记：当前数字是否能拼出来，默认是True（能拼）
can_make = True
# ========== 第一阶段：完整检查卡片是否足够 ==========
# 6. 遍历当前数字的每一位
for c in s:
# 7. 把字符转成整数（比如'1'→1）
num = int(c)
# 8. 检查对应数字的卡片是否用完了
if cards[num] == 0:
# 9. 只要有一位卡片不够，就标记为"不能拼"
can_make = False
# 10. 直接跳出检查循环，不用再看后面的位
break
# ========== 第二阶段：判断是否能拼 ==========
# 11. 如果不能拼，直接终止整个循环
if not can_make:
break
# ========== 第三阶段：消耗卡片 ==========
# 12. 能拼的话，遍历每一位，消耗对应卡片
for c in s:
num = int(c)
cards[num] -= 1
# ========== 第四阶段：检查下一个数 ==========
# 13. 数字+1，准备拼下一个
n += 1
# 14. 输出结果：n是第一个拼不出来的数，所以答案是n-1
print(n - 1)
python
import datetime
a=datetime.datetime(1970,1,1)
n=int(input())
sec=n//1000
b=a+datetime.timedelta(seconds=sec)
print(b.strftime("%H:%M:%S"))
python
s=set()
for x1 in range(20):
for y1 in range(21):
for x2 in range(20):
for y2 in range(21):
if x1==x2 or y1==y2:
continue
if x1==x2:
s.add(f'x={x1}')
else:
dy=y2-y1
dx=x2-x1
A=dy
B=-dx
C=dx*y1-dy*x1
s.add((A,B,C))
print(len(s))
python
n=2021041820210418
cnt=0
for L in range(1,n+1):
if n%L!=0:
continue
for W in range(1,n+1):
if n%(W*L)==0:
cnt+=1
print(cnt)
python
n=2021041820210418
factor=[]
for i in range(1,n+1):
if n%i==0:
factor.append(i)
cnt=0
for L in factor:
for W in factor:
if n%(L*W) ==0:
cnt+=1
print(cnt)
python
import math
def lcm(a, b):
return a * b // math.gcd(a, b)
n = 2021
dp = [float('inf')] * (n + 1)
dp[1] = 0
for i in range(2, n + 1):
for j in range(max(1, i - 21), i):
dp[i] = min(dp[i], dp[j] + lcm(j, i))
print(dp[2021])题意：给定一个 n*m 的二维整数数组，用来表示一个迷宫，数组中只包含.或#，其中.表示
可以走的路，#表示不可通过的墙壁。
最初，有一个人位于左上角(0, 0)处，已知该人每次可以向上、下、左、右任意一个方向移
动一个位置。
请问，该人从左上角移动至右下角处，至少需要移动多少次。
数据保证(0, 0)处和(n-1, m-1)处的数字为 0，且一定至少存在一条通路。
输入格式
第一行包含两个整数 n 和 m。
接下来 n 行，每行包含 m（.或#），表示完整的二维数组迷宫。
输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。
数据范围
1≤n,m≤100
输入样例：
5 5
.#...
.#..#.
.....
.###.
...#.
输出样例：
8
求最短路径 → 必用 BFS
迷宫、走地图、最少步数 → BFS 又快又稳
求所有路径数 / 能不能到达 / 枚举方案 → DFS（一条路走到黑，适合枚举）
BFS：一圈圈扩散，第一次到就是最短
迷宫最少步数 → 永远优先 BFS
python
n,m=int(input())
a=[]
for _ in range(n):
a.append(input().strip())
vis=[[False]*m for _ in range(n)]
ans=10000
dir=[(1,0),(0,1),(-1,0),(0,-1)]
def dfs(x,y,step):
global ans
for dx,dy in dir:
xx=x+dx
yy=y+dy
if 0<=xx<n and 0<=yy<m and not vis[xx][yy]and a[xx][yy]=='.':
if xx == n-1 and yy ==m-1:
ans=min(ans,step+1)
vis[xx][yy]=True
dfs(xx,yy,step+1)
vis[xx][yy]=False
vis[0][0]=True
dfs(0,0,0)
print(ans)
python
from collections import deque
def short():
n, m = map(int, input().strip().split())
maze = []
for _ in range(n):
maze.append(list(input().strip()))
dirs = [(-1, 0), (1, 0), (0, 1), (0, -1)]
visited = [[False] * m for _ in range(n)]
q = deque()
q.append((0, 0, 0))
visited[0][0] = True
while q:
x, y, steps = q.popleft()
# 到达终点
if x == n - 1 and y == m - 1:
print(steps)
return
# 四个方向
for dx, dy in dirs:
nx = x + dx
ny = y + dy
if 0 <= nx < n and 0 <= ny < m:
if not visited[nx][ny] and maze[nx][ny] == '.':
visited[nx][ny] = True
# append 必须包成元组 (nx,ny,steps+1)
q.append((nx, ny, steps + 1))
print(-1)
if __name__ == "__main__":
short()有 n 个货物和一艘最大载重量为 m 的船，每个货物有一个重量。每个货物要么装，要么不装 。请你求出在不超过最大载重 的前提下，船能装载的最大重量。
输入格式
第一行：两个整数 n,m第二行：n 个整数，表示每个货物的重量
输出格式
一个整数，表示能装载的最大重量
python
n, m = map(int, input().split())
w=list(map(int,input().split()))
max_weight=0
def dfs(idx,current):
global max_weight
if current > m:
return
if idx==n:
if current>max_weight:
max_weight=current
return
dfs(idx+1,current+w[idx])
dfs(idx+1,current)
dfs(0,0)
print(max_weight)
python
n,m=map(int,input().split())
w=list(map(int,input().split()))
ans=0
def dfs(i,s):
global ans
if s>m:return
if i==n:
ans=max(ans,s)
return
dfs(i+1,s+w[i])
dfs(i+1,s)
dfs(0,0)
print(ans)DFS
python
def dfs(参数):
# 递归出口
if 满足结束条件:
更新答案
return
# 剪枝（可选，提速）
if 非法情况:
return
# 选择分支1
dfs(下一层参数)
# 选择分支2
dfs(下一层参数)BFS
python
from collections import deque
q = deque()
q.append(起点)
vis[起点] = True
while q:
出队
到达终点就返回答案
四个方向扩展
合法就入队 + 标记问题描述
某石油勘探区域被划分成若干个正方形的地块，勘探队通过探测得知每个地块是否含有石油。含有石油的地块记为
@，不含石油的地块记为*。如果两个含有石油的地块相邻 （上、下、左、右、左上、左下、右上、右下），则它们属于同一个油藏。请你计算给定区域中有多少个油藏。输入格式
输入包含多组数据。每组数据第一行包含两个整数 m,n，分别表示区域的行数和列数。当 m=0 时，输入结束。接下来 m 行，每行包含 n 个字符（
*或@）。输出格式
对于每组数据，输出一个整数，表示油藏的数量。
输入样例
plaintext
1 1 * 3 5 *@*@* **@** *@*@* 0 0输出样例
plaintext
0 2
python
dirs=[(-1,-1),(-1,0),(-1,1),
(0,-1), (0,1),
(1,-1), (1,0), (1,1)]
def dfs(x,y,grid,vis,m,n):
vis[x][y]=True
for dx,dy in dirs:
nx=x+dx
ny=y+dy
if 0<=nx<m and 0<=ny<n and not vis[nx][ny] and grid[nx][ny]=='@':
dfs(nx,ny,grid,vis,m,n)
# 必须加循环！多组输入直到 m=0 停止
while True:
m,n=map(int,input().split())
if m==0:
break
grid=[]
for _ in range(m):
grid.append(input().strip())
vis=[[False]*n for _ in range(m)]
cnt=0
for i in range(m):
for j in range(n):
if grid[i][j]=='@'and not vis[i][j]:
cnt+=1
dfs(i,j,grid,vis,m,n)
print(cnt)