一、矩阵中的局部最大值
给你一个大小为 n x n 的整数矩阵 grid 。
生成一个大小为 (n - 2) x (n - 2) 的整数矩阵 maxLocal ，并满足：
maxLocal[i][j]等于grid中以i + 1行和j + 1列为中心的3 x 3矩阵中的 最大值 。
换句话说，我们希望找出 grid 中每个 3 x 3 矩阵中的最大值。
返回生成的矩阵。
示例 1：
输入： grid = [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]]
输出： [[9,9],[8,6]]
解释： 原矩阵和生成的矩阵如上图所示。
注意，生成的矩阵中，每个值都对应 grid 中一个相接的 3 x 3 矩阵的最大值。
示例 2：
输入： grid = [[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]]
输出： [[2,2,2],[2,2,2],[2,2,2]]
解释： 注意，2 包含在 grid 中每个 3 x 3 的矩阵中。
提示：
n == grid.length == grid[i].length3 <= n <= 1001 <= grid[i][j] <= 100
解析
根据题意，直接模拟操作过程即可，因为数组最大也就是100x100，不大
解答
class Solution:
def largestLocal(self, grid: List[List[int]]) -> List[List[int]]:
n = len(grid)
res = []
for i in range(n-2):
l = []
for k in range(n-2):
tmp = []
tmp.extend(grid[i][k:k+3])
tmp.extend(grid[i+1][k:k+3])
tmp.extend(grid[i+2][k:k+3])
l.append(max(tmp))
res.append(l)
# print(res)
return res
二、边积分最高的节点
给你一个有向图，图中有 n 个节点，节点编号从 0 到 n - 1 ，其中每个节点都 恰有一条 出边。
图由一个下标从 0 开始、长度为 n 的整数数组 edges 表示，其中 edges[i] 表示存在一条从节点 i 到节点 edges[i] 的 有向 边。
节点 i 的 边积分 定义为：所有存在一条指向节点 i 的边的节点的 编号 总和。
返回 边积分 最高的节点。如果多个节点的 边积分 相同，返回编号 最小 的那个。
示例 1：
输入： edges = [1,0,0,0,0,7,7,5]
输出： 7
解释：
- 节点 1、2、3 和 4 都有指向节点 0 的边，节点 0 的边积分等于 1 + 2 + 3 + 4 = 10 。
- 节点 0 有一条指向节点 1 的边，节点 1 的边积分等于 0 。
- 节点 7 有一条指向节点 5 的边，节点 5 的边积分等于 7 。
- 节点 5 和 6 都有指向节点 7 的边，节点 7 的边积分等于 5 + 6 = 11 。
节点 7 的边积分最高，所以返回 7 。
示例 2：
输入： edges = [2,0,0,2]
输出： 0
解释： - 节点 1 和 2 都有指向节点 0 的边，节点 0 的边积分等于 1 + 2 = 3 。
- 节点 0 和 3 都有指向节点 2 的边，节点 2 的边积分等于 0 + 3 = 3 。
节点 0 和 2 的边积分都是 3 。由于节点 0 的编号更小，返回 0 。
提示：
n == edges.length2 <= n <= 10^50 <= edges[i] < nedges[i] != i
解析
看到又是边又是图的，就很烦，不过这道题并没有使用到DFS之类的算法，还是比较简单的。
因为要求边积分的最大值，其实就是看原来这个edges数组当中，哪个数字出现的次数多，对应出现的位置分别是几，他们的和最大就可以了，其实跟图、边什么的没有关系。
代码
from collections import defaultdict
class Solution:
def edgeScore(self, edges: List[int]) -> int:
d = defaultdict(list)
for index, v in enumerate(edges):
d[v].append(index)
keys = sorted(d.keys())
m = 0
res = 0
for k in keys:
s = sum(d[k])
if s > m:
m = s
res = k
print(res)
return res
三、根据模式串构造最小数字
给你下标从 0 开始、长度为 n 的字符串 pattern ，它包含两种字符，'I' 表示 上升 ，'D' 表示 下降 。
你需要构造一个下标从 0 开始长度为 n + 1 的字符串，且它要满足以下条件：
num包含数字'1'到'9'，其中每个数字 至多 使用一次。- 如果
pattern[i] == 'I'，那么num[i] < num[i + 1]。 - 如果
pattern[i] == 'D'，那么num[i] > num[i + 1]。
请你返回满足上述条件字典序 最小 的字符串 **num。
示例 1：
输入： pattern = "IIIDIDDD"
输出： "123549876"
解释： 下标 0 ，1 ，2 和 4 处，我们需要使 num[i] < num[i+1] 。
下标 3 ，5 ，6 和 7 处，我们需要使 num[i] > num[i+1] 。
一些可能的 num 的值为 "245639871" ，"135749862" 和 "123849765" 。
"123549876" 是满足条件最小的数字。
注意，"123414321" 不是可行解因为数字 '1' 使用次数超过 1 次。
示例 2：
输入： pattern = "DDD"
输出： "4321"
解释：
一些可能的 num 的值为 "9876" ，"7321" 和 "8742" 。
"4321" 是满足条件最小的数字。
提示：
1 <= pattern.length <= 8pattern只包含字符'I'和'D'。
解析
本题因为pattern长度很短，因此可以直接计算出来结果，并不需要像leetcode题解和周赛题解他们那样使用DFS。只需要将简单的数学方法给用代码实现出来即可。
首先将pattern分组，相邻的I或者相邻的D给分成一组。先把1~9写成一个数组，遇到相邻的I就从数组里取出来最小的几个，遇到相邻的D，就先跳过最小的一个数字，把剩下的取出来最小的几个倒序一下，如果是以相邻的D结尾的，就不用跳过了直接取出来即可。
代码
class Solution:
def smallestNumber(self, pattern: str) -> str:
pattern+=pattern[-1]
nums = [1, 2, 3, 4, 5, 6, 7, 8, 9]
group_stack = []
s = []
for index, p in enumerate(pattern):
if not group_stack:
group_stack.append([p, 1])
else:
if p == group_stack[-1][0]:
group_stack[-1][1] += 1
else:
group_stack.append([p, 1])
print(group_stack)
for index, (p, length) in enumerate(group_stack):
if p == "I":
s.extend(nums[0: length])
for n in nums[0: length]:
nums.remove(n)
else:
if index < len(group_stack)-1:
s.extend(nums[1: length+1][::-1])
for n in nums[1: length+1]:
nums.remove(n)
else:
s.extend(nums[0: length][::-1])
for n in nums[0: length]:
nums.remove(n)
print(s)
return "".join([str(i) for i in s])
相比于DFS的方法，快了很多
