1 容量单位
【问题描述】
在计算机存储中，12.5MB是多少字节？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
答案
13107200
2 最多边数
【问题描述】
一个包含有2019个结点的有向图，最多包含多少条边？（不允许有重边）
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
任意两点组成边，边有向，一来一回算两条边
所以是n中选2的组合数乘以2级n*(n-1)
答案
4074342
3 单词重排
【问题描述】
将LANQIAO中的字母重新排列，可以得到不同的单词，如LANQIAO、AAILNOQ等，注意这7个字母都要被用上，单词不一定有具体的英文意义。
请问，总共能排列如多少个不同的单词。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
求全排列，去重，计数
代码
from itertools import permutations
p = permutations('LANQIAO')
print(len(set(p)))
答案
2520
4 括号序列
【问题描述】
由1对括号，可以组成一种合法括号序列：()。
由2对括号，可以组成两种合法括号序列：()()、(())。
由4对括号组成的合法括号序列一共有多少种？
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
解析
典型的递归结构，每个位置有两种选择，要么左括号，要么右括号。
选左括号的条件：可选数>0 且 变化后存在的左括号数量始终大于等于已存在的右括号数量。
选右括号类似。
代码
def solve(n, l, r):
'''
:param n:对的数量
:param l: 剩余左括号数量
:param r: 剩余右括号的数量
:return:
'''
if l == 0 and r == 0:
return 1
ans = 0
# 要么选左括号，要么选右括号
# 选左括号的条件：l>0 且 变化后存在的左括号数量始终大于等于已存在的右括号数量
if l > 0 and n - (l - 1) >= n - r:
ans += solve(n, l - 1, r)
if r > 0 and n - l >= n - (r - 1):
ans += solve(n, l, r - 1)
return ans
print(solve(4, 4, 4))
答案
14
5 反倍数
【问题描述】
给定三个整数 a, b, c，如果一个整数既不是 a 的整数倍也不是 b 的整数倍还不是 c 的整数倍，则这个数称为反倍数。
请问在 1 至 n 中有多少个反倍数。
【输入格式】
输入的第一行包含一个整数 n。
第二行包含三个整数 a, b, c，相邻两个数之间用一个空格分隔。
【输出格式】
输出一行包含一个整数，表示答案。
【样例输入】
30
2 3 6
【样例输出】
10
【样例说明】
以下这些数满足要求：1, 5, 7, 11, 13, 17, 19, 23, 25, 29。
【评测用例规模与约定】
对于 40% 的评测用例，1 <= n <= 10000。
对于 80% 的评测用例，1 <= n <= 100000。
对于所有评测用例，1 <= n <= 1000000，1 <= a <= n，1 <= b <= n，1 <= c <= n。
解析
迭代+check
代码
n = int(input())
a, b, c = (int(x) for x in input().split(' '))
# 过滤出合规的数据，得到一个生成器
res_arr = (1 for x in range(1, n + 1) if x % a != 0 and x % b != 0 and x % c != 0)
# 加总
print(sum(res_arr))
6 凯撒密码
【问题描述】
给定一个单词，请使用凯撒密码将这个单词加密。
凯撒密码是一种替换加密的技术，单词中的所有字母都在字母表上向后偏移3位后被替换成密文。即a变为d，b变为e，...，w变为z，x变为a，y变为b，z变为c。
例如，lanqiao会变成odqtldr。
【输入格式】
输入一行，包含一个单词，单词中只包含小写英文字母。
【输出格式】
输出一行，表示加密后的密文。
【样例输入】
lanqiao
【样例输出】
odqtldr
【评测用例规模与约定】
对于所有评测用例，单词中的字母个数不超过100。
解析
遍历+转换，再拼成字符串
代码
def add(letter):
if letter < 'x':
return chr(ord(letter) + 3)
elif letter == 'x':
return 'a'
elif letter == 'y':
return 'b'
else:
return 'c'
print(''.join(map(add, input().strip())))
7 螺旋
【问题描述】
对于一个 n 行 m 列的表格，我们可以使用螺旋的方式给表格依次填上正整数，我们称填好的表格为一个螺旋矩阵。
例如，一个 4 行 5 列的螺旋矩阵如下：
1 2 3 4 5
14 15 16 17 6
13 20 19 18 7
12 11 10 9 8
【输入格式】
输入的第一行包含两个整数 n, m，分别表示螺旋矩阵的行数和列数。
第二行包含两个整数 r, c，表示要求的行号和列号。
【输出格式】
输出一个整数，表示螺旋矩阵中第 r 行第 c 列的元素的值。
【样例输入】
4 5
2 2
【样例输出】
15
【评测用例规模与约定】
对于 30% 的评测用例，2 <= n, m <= 20。
对于 70% 的评测用例，2 <= n, m <= 100。
对于所有评测用例，2 <= n, m <= 1000，1 <= r <= n，1 <= c <= m。
解析
按题意生成网格，再取单元格中的数据
代码
n, m = (int(x) for x in input().strip().split(' '))
r, c = (int(x) for x in input().strip().split(' '))
grid = [[0] * m for _ in range(n)]
num = 1
up, down, left, right = 0, n, 0, m
while 1:
for col in range(left, right):
grid[up][col] = num
num += 1
up += 1
if up == down:
break
for row in range(up, down):
grid[row][right - 1] = num
num += 1
right -= 1
if left == right:
break
for col in range(right - 1, left - 1, -1):
grid[down - 1][col] = num
num += 1
down -= 1
if up == down:
break
for row in range(down - 1, up - 1, -1):
grid[row][left] = num
num += 1
left += 1
if left == right:
break
print(grid[r - 1][c - 1])
8 摆动序列
【问题描述】
如果一个序列的奇数项都比前一项大，偶数项都比前一项小，则称为一个摆动序列。即 a[2i]<a[2i-1], a[2i+1]>a[2i]。
小明想知道，长度为 m，每个数都是 1 到 n 之间的正整数的摆动序列一共有多少个。
【输入格式】
输入一行包含两个整数 m，n。
【输出格式】
输出一个整数，表示答案。答案可能很大，请输出答案除以10000的余数。
【样例输入】
3 4
【样例输出】
14
【样例说明】
以下是符合要求的摆动序列：
2 1 2
2 1 3
2 1 4
3 1 2
3 1 3
3 1 4
3 2 3
3 2 4
4 1 2
4 1 3
4 1 4
4 2 3
4 2 4
4 3 4
【评测用例规模与约定】
对于 20% 的评测用例，1 <= n, m <= 5；
对于 50% 的评测用例，1 <= n, m <= 10；
对于 80% 的评测用例，1 <= n, m <= 100；
对于所有评测用例，1 <= n, m <= 1000。
解法1：dfs
多数人都能想到：第1位，可选为[2,n]
选定第1位（last1），开始选第2位，可选为[1,last1-1]，对所有last1结果求和
选定第2位（last2），开始选第3位，可选为[last2+1,n]，对所有last2结果求和
……
选定奇数位（last），开始选下一个偶数位，可选为[1,last-1]，对所有last结果求和
选定偶数位（last），开始选下一个奇数位，可选为[last+1,n]，对所有last结果求和
……
递归式为：
dfs(last, k) = Σdfs(i, k + 1) | k为奇数，i from 1 to last-1
dfs(last, k) = Σdfs(i, k + 1) | k为偶数，i from last+1 to n
而递归起点（选定第一位，可选是2 to n）也是一个循环：
for i in range(2, n + 1):
ans = (ans + dfs(i, 1)) % MOD
这里面有大量重复子问题，所以可以记忆型递归；但只能过80%的数据，因为复杂度是O(N³)
代码1
MOD = 10000
m, n = (int(x) for x in input().strip().split(' '))
mem = [[0] * 1000 for _ in range(1000)]
def dfs(last, k):
'''
第k个数确定为last时，序列总数是多少？
:param last:确定的最后一个数
:param k: last是第k个
:return:
'''
if k == m:
return 1
if mem[last][k] != 0:
return mem[last][k]
# k是奇数，k+1是偶数，偶数位比前一个小
if k & 1:
for i in range(1, last):
mem[last][k] = (mem[last][k] + dfs(i, k + 1)) % MOD
else:
for i in range(last + 1, n + 1):
mem[last][k] = (mem[last][k] + dfs(i, k + 1)) % MOD
return mem[last][k]
ans = 0
for i in range(2, n + 1):
ans = (ans + dfs(i, 1)) % MOD
print(ans)
优化1：修改递归式
这种在递归中加总的递归形态，往往可以通过优化递归式来改进，将递归式变成有汇总 or 集合的意义，就可以减少一层循环，从而把复杂度变为O(N²)
可以从递归起点的那个循环考虑，我们既然要加总第1位选2到n的这若干种情况的结果，为什么不用dfs(2,1)直接表示第一位选[2,n]这所有情况的和呢？这就是集合的概念了。
更通用地：
k为奇数时，dfs(x,k)表示第k位选[x,n]这若干种情况的种数和；
k为偶数时，dfs(x,k)表示第k位选[1,x]这若干种情况的种数和；
但是怎么拆呢？技巧是拆成一个元素+一个（少了该元素的）小集合，小集合动一个变量（往往代表规模），那拆出来的元素往往可以转换成另外一个集合。
就本题来说，k为奇数时，dfs(x,k)可以这样拆：
k为偶数时，dfs(x,k)可以这样拆：
那么可得递归式：
dfs(x, k) = dfs(x+1, k) + dfs(x-1,k+1) | k为奇数
dfs(x, k) = dfs(x-1, k) + dfs(x+1,k+1) | k为偶数
递归起点为：ans = dfs(2, 1)
代码2
MOD = 10000
m, n = (int(x) for x in input().strip().split(' '))
mem = [[0] * 1000 for _ in range(1000)]
def dfs(x, k):
'''
k为偶数时，含义为：第k个数小于等于last的序列总数
k为奇数时，含义为：第k个数大于等于last的序列总数
:param x:确定的最后一个数
:param k: 当前确认的数字是第k个
:return:
'''
if x < 1 or x > n:
return 0
if k == m:
# 奇数，return 大于等于last的个数；偶数，小于等于last的个数
mem[x][k] = n - x + 1 if k & 1 else x
return mem[x][k]
if mem[x][k] != 0:
return mem[x][k]
# k为奇数
if k & 1:
# 注意看这里的拆解：当前函数的含义是第k位选last~n的序列数总和，切成两块
# 1：第k位选(last+1)到n的序列数总和，函数含义不变，第一个参数变为last+1==》dfs(last + 1, k)
# 2：第k位固定为last，那么第k+1位的选择是从1到last-1（因k+1是偶数）==》dfs(last - 1, k + 1)
mem[x][k] = (dfs(x + 1, k) + dfs(x - 1, k + 1)) % MOD
# k为偶数
else:
mem[x][k] = (dfs(x - 1, k) + dfs(x + 1, k + 1)) % MOD
return mem[x][k]
# 第1个数大于等于2，这样的序列总数
ans = dfs(2, 1)
print(ans)
优化2：改为递推
为什么还要优化呢？因为这样递归层次太深，会超出栈空间限制。
递推是递归的逆过程，因此我们观察上述递归函数的出口，就知道怎么初始化dp数组，再按照与递归相逆的顺序逐步生成递推数组。
递归出口：
if k == m:
# 奇数，return 大于等于last的个数；偶数，小于等于last的个数
mem[x][k] = n - x + 1 if k & 1 else x
转变为数组初始化：
# 初始化最后一列
for last in range(1, n + 1):
dp[last][m] = n - last + 1 if m & 1 else last
递归中，列数k是逐渐增大，直至最后一列，那么递推中，应该从最后一列反推到第一列。
代码3
MOD = 10000
m, n = (int(x) for x in input().strip().split(' '))
dp = [[0] * (m + 1) for _ in range(n + 1)]
# 初始化最后一列
for x in range(1, n + 1):
dp[x][m] = n - x + 1 if m & 1 else x
for k in range(m - 1, 0, -1):
# 奇数，x从大到小遍历
if k & 1:
for x in range(n, 0, -1):
dp[x][k] = ((dp[x + 1][k] if x + 1 <= n else 0) + dp[x - 1][k + 1]) % MOD
# 偶数，x从小到大遍历
else:
for x in range(1, n + 1):
dp[x][k] = (dp[x - 1][k] + (dp[x + 1][k + 1] if x + 1 <= n else 0)) % MOD
print(dp[2][1])
9 通电
【问题描述】
2015年，全中国实现了户户通电。作为一名电力建设者，小明正在帮助一带一路上的国家通电。
这一次，小明要帮助 n 个村庄通电，其中 1 号村庄正好可以建立一个发电站，所发的电足够所有村庄使用。
现在，这 n 个村庄之间都没有电线相连，小明主要要做的是架设电线连接这些村庄，使得所有村庄都直接或间接的与发电站相通。
小明测量了所有村庄的位置（坐标）和高度，如果要连接两个村庄，小明需要花费两个村庄之间的坐标距离加上高度差的平方，形式化描述为坐标为 (x_1, y_1) 高度为 h_1 的村庄与坐标为 (x_2, y_2) 高度为 h_2 的村庄之间连接的费用为
sqrt((x_1-x_2)*(x_1-x_2)+(y_1-y_2)*(y_1-y_2))+(h_1-h_2)*(h_1-h_2)。
在上式中 sqrt 表示取括号内的平方根。请注意括号的位置，高度的计算方式与横纵坐标的计算方式不同。
由于经费有限，请帮助小明计算他至少要花费多少费用才能使这 n 个村庄都通电。
【输入格式】
输入的第一行包含一个整数 n ，表示村庄的数量。
接下来 n 行，每个三个整数 x, y, h，分别表示一个村庄的横、纵坐标和高度，其中第一个村庄可以建立发电站。
【输出格式】
输出一行，包含一个实数，四舍五入保留 2 位小数，表示答案。
【样例输入】
4
1 1 3
9 9 7
8 8 6
4 5 4
【样例输出】
17.41
【评测用例规模与约定】
对于 30% 的评测用例，1 <= n <= 10；
对于 60% 的评测用例，1 <= n <= 100；
对于所有评测用例，1 <= n <= 1000，0 <= x, y, h <= 10000。
解析
可以说是最小生成树的裸题了——连通==树，代价最小==最小生成
用Kruskal算法一气呵成。
不过要进行一些处理：
每个村庄看做是一个顶点，编号存储
两两组成边，用费用做边的权重
做好数据处理，然后就是排序，从小到大把边添加到最小生成树的边集（也不用真正添加，符合的边把代价累加就行，不符合的边忽略）
符合与不符合，当然要用并查集了。
代码
from math import sqrt
class Edge:
def __init__(self, b, e, _cost):
self.begin, self.end, self.cost = b, e, _cost
def __eq__(self, other):
return self.begin == other.begin and self.end == self.end and self.cost == other.cost
def __lt__(self, other):
return self.cost < other.cost
def cost(a, b):
'''
:param a: 村庄a是横纵高三元组
:param b: 村庄b是横纵高三元组
:return:
'''
return sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) + (a[2] - b[2]) ** 2
n = int(input().strip())
data = [None, ]
for _ in range(n):
data.append(tuple(int(x) for x in input().split(' ')))
# 将原始数据处理成边集，每两个点一条边，计算代价
edges = []
for i in range(1, n):
for j in range(i, n + 1):
edges.append(Edge(i, j, cost(data[i], data[j])))
# 选入最小生成树的边的数量，最终应为n-1；edges_index记录遍历边集的下标
edge_cnt, edges_index = 0, 0
# 记录结果
ans = 0
# 排序
edges.sort()
# ==========并查集 begin==========
parent = [x for x in range(n + 1)]
def find(x):
if parent[x] == x:
return x
path = set()
while parent[x] != x:
path.add(x)
x = parent[x]
# 路径上的点的parent全部指向x
for xx in path:
parent[xx] = x
return x
def merge(x, y):
parent[find(y)] = find(x)
# ==========并查集 end==========
def ok(e):
# 在同一个集中
if find(e.begin) == find(e.end):
return False
else:
merge(e.begin, e.end)
return True
while edge_cnt < n - 1:
e = edges[edges_index]
edges_index += 1
if ok(e):
edge_cnt += 1
ans += e.cost
print('{:.2f}'.format(ans))
10 植树
【问题描述】
小明和朋友们一起去郊外植树，他们带了一些在自己实验室精心研究出的小树苗。
小明和朋友们一共有 n 个人，他们经过精心挑选，在一块空地上每个人挑选了一个适合植树的位置，总共 n 个。他们准备把自己带的树苗都植下去。
然而，他们遇到了一个困难：有的树苗比较大，而有的位置挨太近，导致两棵树植下去后会撞在一起。
他们将树看成一个圆，圆心在他们找的位置上。如果两棵树对应的圆相交，这两棵树就不适合同时植下（相切不受影响），称为两棵树冲突。
小明和朋友们决定先合计合计，只将其中的一部分树植下去，保证没有互相冲突的树。他们同时希望这些树所能覆盖的面积和（圆面积和）最大。
【输入格式】
输入的第一行包含一个整数 n ，表示人数，即准备植树的位置数。
接下来 n 行，每行三个整数 x, y, r，表示一棵树在空地上的横、纵坐标和半径。
【输出格式】
输出一行包含一个整数，表示在不冲突下可以植树的面积和。由于每棵树的面积都是圆周率的整数倍，请输出答案除以圆周率后的值（应当是一个整数）。
【样例输入】
6
1 1 2
1 4 2
1 7 2
4 1 2
4 4 2
4 7 2
【样例输出】
12
【评测用例规模与约定】
对于 30% 的评测用例，1 <= n <= 10；
对于 60% 的评测用例，1 <= n <= 20；
对于所有评测用例，1 <= n <= 30，0 <= x, y <= 1000，1 <= r <= 1000。
解析
每个圆可以选也可以不选，但不知道哪种决策结果最大，只能先考虑暴力搜索每种情况，总可选数为2的n次方的深度优先搜索。
某1个圆在准备选入的时候，可以判断是否与之前已入选的圆冲突，如果冲突了，这条分支就可以不继续了，这可以视为剪枝；但是判断是否冲突的check函数要遍历已入选的圆，复杂度依然高；
代码1在n等于30的时候会吃不消。
代码1
class Tree:
def __init__(self, x, y, r):
self.x, self.y, self.r = x, y, r
def __eq__(self, other):
return self.x, self.y, self.r == other.x, other.y, other.r
def __lt__(self, other):
return self.r < other.r
def __repr__(self):
return f'Tree[{self.x},{self.y},{self.r}]'
def intersected(a: Tree, b: Tree) -> bool:
"""
:param a:
:param b:
:return:两个圆是否相交，相交返回True
"""
dis = (a.x - b.x) ** 2 + (a.y - b.y) ** 2
return dis < (a.r + b.r) ** 2
n = int(input())
trees = []
for _ in range(n):
trees.append(Tree(*(int(x) for x in input().split(' '))))
# 邻接矩阵
adja_table = [[0] * n for _ in range(n)]
# 两两组合，看是否交叉，平方级
for i in range(n - 1):
for j in range(i + 1, n):
if intersected(trees[i], trees[j]):
adja_table[i][j] = 1
adja_table[j][i] = 1
ans = 0
# 将选择的点标注为1
selected = [0] * n
def ok(index):
"""
对于既定的选择列表，index这个点能否加入
:param index:
:return:
"""
for i in range(index):
if selected[i] and adja_table[i][index]:
return False
return True
def dfs(sum, index):
# 边界
if index == n:
global ans
ans = max(ans, sum)
return
# 1.不选当前这棵树
selected[index] = 0
dfs(sum, index + 1)
# 2.选这棵树（是有条件的）
if ok(index):
selected[index] = 1
dfs(sum + trees[index].r ** 2, index + 1)
selected[index] = 0
dfs(0, 0)
print(ans)
优化
优化的关键点在于用类似贪心的办法（但不是贪心）：将圆按半径从大到小排序，这样优先考虑半径大的圆的选与不选问题；另外把“选”这个分支放在“不选”这个分支前面执行，这样我们相信会尽早地遇到最优解。
基于这个假设，在递归之前我们可以以O(N)的复杂度存储所有圆的“半径的平方”的后缀和，计为数组s；在递归函数dfs中，参数sum代表index之前的选择策略所得到的sum，s[index]代表包括index索引及之后续所有圆的半径的平方和，如果sum+s[index]小于等于已经求得的ans，那就不必进行任何后续的选择试探了，可立即退出递归。
实测，代码2在n=30时能秒出结果。
代码
class Tree:
def __init__(self, x, y, r):
self.x, self.y, self.r = x, y, r
def __eq__(self, other):
return self.x, self.y, self.r == other.x, other.y, other.r
def __lt__(self, other):
return self.r > other.r
def __repr__(self):
return f'Tree[{self.x},{self.y},{self.r}]'
def intersected(a: Tree, b: Tree) -> bool:
"""
:param a:
:param b:
:return:两个圆是否相交，相交返回True
"""
dis = (a.x - b.x) ** 2 + (a.y - b.y) ** 2
return dis < (a.r + b.r) ** 2
n = int(input())
trees = []
for _ in range(n):
trees.append(Tree(*(int(x) for x in input().split(' '))))
# 排序
trees.sort()
# 计算后缀和
s = [0] * n
s[n - 1] = trees[n - 1].r ** 2
for i in range(1, n):
s[n - 1 - i] = s[n - i] + trees[n - 1 - i].r ** 2
# 邻接矩阵
adja_table = [[0] * n for _ in range(n)]
# 两两组合，看是否交叉，平方级
for i in range(n - 1):
for j in range(i + 1, n):
if intersected(trees[i], trees[j]):
adja_table[i][j] = 1
adja_table[j][i] = 1
ans = 0
# 将选择的点标注为1
selected = [0] * n
def ok(index):
"""
对于既定的选择列表，index这个点能否加入
:param index:
:return:
"""
for i in range(index):
if selected[i] and adja_table[i][index]:
return False
return True
def dfs(sum, index):
global ans
# 边界
if index == n:
ans = max(ans, sum)
return
if sum + s[index] <= ans:
return
# 2.选这棵树（是有条件的）
if ok(index):
selected[index] = 1
dfs(sum + trees[index].r ** 2, index + 1)
selected[index] = 0
# 1.不选当前这棵树
selected[index] = 0
dfs(sum, index + 1)
dfs(0, 0)
print(ans)