两周了，第一次独立写完四个题目，开心（当然... 不是在考试时间内写完的，主要还是四个题知识图谱内，而且还不难吧），加油！
独一无二的出现次数
给你一个整数数组 arr，请你帮忙统计数组中每个数的出现次数。
如果每个数的出现次数都是独一无二的，就返回 true；否则返回 false。
示例 1：
输入：arr = [1,2,2,1,1,3] 输出：true 解释：在该数组中，1 出现了 3 次，2 出现了 2 次，3 只出现了 1 次。没有两个数的出现次数相同。
提示：
1 <= arr.length <= 1000-1000 <= arr[i] <= 1000
看到范围，直接暴力（经过这两周...我的理解是10^10以内都可以暴力求解）
class Solution:
def uniqueOccurrences(self, arr: List[int]) -> bool:
d = dict()
for i in arr:
if i in d:
d[i] += 1
else:
d[i] = 1for key,val in d.items():
for key2,val2 in d.items():
if key == key2:
continue
if val == val2:
return False
return True
尽可能使字符串相等
给你两个长度相同的字符串，s 和 t。
将 s 中的第 i 个字符变到 t 中的第 i 个字符需要 |s[i] - t[i]| 的开销（开销可能为 0），也就是两个字符的 ASCII 码值的差的绝对值。
用于变更字符串的最大预算是 maxCost。在转化字符串时，总开销应当小于等于该预算，这也意味着字符串的转化可能是不完全的。
如果你可以将 s 的子字符串转化为它在 t 中对应的子字符串，则返回可以转化的最大长度。
如果 s 中没有子字符串可以转化成 t 中对应的子字符串，则返回 0。
示例 ：
输入：s = "abcd", t = "bcdf", cost = 3 输出：3 解释：s 中的 "abc" 可以变为 "bcd"。开销为 3，所以最大长度为 3。 输入：s = "abcd", t = "cdef", cost = 3 输出：1 解释：s 中的任一字符要想变成 t 中对应的字符，其开销都是 2。因此，最大长度为 1。
提示：
1 <= s.length, t.length <= 10^50 <= maxCost <= 10^6s和t都只含小写英文字母。
如之前所说O(n^2) 会是 10^10要超时，所以换种思路，滑动窗口。
# 写的比较笨拙，见谅哈
class Solution:
def equalSubstring(self, s: str, t: str, maxCost: int) -> int:
len_s = len(s)
num = [0 for i in range(len_s)]
# 记录次数
for i in range(len_s):
num[i] = abs(ord(s[i]) - ord(t[i]))
# 扫描出初始窗口
tmp = maxCost
cnt = 0
for i in range(len_s):
if tmp - num[i] >= 0:
tmp -= num[i]
cnt += 1
else:
break
# 从初始窗口开始扫描，每次删掉窗口头部结点，加入尾部结点
i = cnt
while i < len_s:
tmp += num[i-cnt] # 删掉头部结点
tmp -= num[i] # 加入尾部结点
if tmp >= 0: # 如果还可以扩张
j = i + 1
while j < len_s: # 扩张
if tmp - num[j] >= 0:
tmp -= num[j]
cnt += 1
else:
break
j += 1
i = j
else:
i += 1
return cnt
删除字符串中的所有相邻重复项 II
给你一个字符串 s，「k 倍重复项删除操作」将会从 s 中选择 k 个相邻且相等的字母，并删除它们，使被删去的字符串的左侧和右侧连在一起。
你需要对 s 重复进行无限次这样的删除操作，直到无法继续为止。
在执行完所有删除操作后，返回最终得到的字符串。
本题答案保证唯一。
示例：
输入：s = "abcd", k = 2 输出："abcd" 解释：没有要删除的内容。 输入：s = "deeedbbcccbdaa", k = 3 输出："aa" 解释： 先删除 "eee" 和 "ccc"，得到 "ddbbbdaa" 再删除 "bbb"，得到 "dddaa" 最后删除 "ddd"，得到 "aa" 输入：s = "pbbcggttciiippooaais", k = 2 输出："ps"
提示：
1 <= s.length <= 10^52 <= k <= 10^4s中只含有小写英文字母。
看到题目第一反应是模拟栈 ，看到10^5...我就怕了... 然后...想不出啥来，抱着试一试的态度用了一个list去标记每一轮要删除的数组位置，
然后逐个删除（并不比模拟栈复杂度低，我心里想着至少这个没有压栈出栈的操作），但是居然过了... 交的时候还双手合十祈祷来着~
class Solution:
def removeDuplicates(self, s: str, k: int) -> str:
s = list(s)
while True:
len_s = len(s)
if len_s < k:
return ‘‘.join(s)
i = 0
de = [] # 重复字符的索引标记数组
while i < len(s) - k + 1:
flag = 1 # 用来标记是否找到k个重复字符
j = 1
while j < k:
if s[i] != s[i + j]:
flag = 0
break
j += 1
if flag:
de.append([i, i + j])
i += j
cnt = 0 # 标记删除了多少个
for st, ed in de:
s = s[:st - cnt] + s[ed - cnt:]
cnt += ed - st
if not de: # 没有找到一个k重复字符
return ‘‘.join(s)
穿过迷宫的最少移动次数
你还记得那条风靡全球的贪吃蛇吗？
我们在一个 n*n 的网格上构建了新的迷宫地图，蛇的长度为 2，也就是说它会占去两个单元格。蛇会从左上角（(0, 0) 和 (0, 1)）开始移动。我们用 0 表示空单元格，用 1 表示障碍物。蛇需要移动到迷宫的右下角（(n-1, n-2) 和 (n-1, n-1)）。
每次移动，蛇可以这样走：
- 如果没有障碍，则向右移动一个单元格。并仍然保持身体的水平／竖直状态。
- 如果没有障碍，则向下移动一个单元格。并仍然保持身体的水平／竖直状态。
- 如果它处于水平状态并且其下面的两个单元都是空的，就顺时针旋转 90 度。蛇从（
(r, c)、(r, c+1)）移动到 （(r, c)、(r+1, c)）。
- 如果它处于竖直状态并且其右面的两个单元都是空的，就逆时针旋转 90 度。蛇从（
(r, c)、(r+1, c)）移动到（(r, c)、(r, c+1)）。
返回蛇抵达目的地所需的最少移动次数。
如果无法到达目的地，请返回 -1。
示例
输入：grid = [[0,0,0,0,0,1],
[1,1,0,0,1,0],
[0,0,0,0,1,1],
[0,0,1,0,1,0],
[0,1,1,0,0,0],
[0,1,1,0,0,0]]
输出：11
解释：
一种可能的解决方案是 [右, 右, 顺时针旋转, 右, 下, 下, 下, 下, 逆时针旋转, 右, 下]。
这个题目看到的第一反应就是大一懵懵懂懂遇到的走迷宫了，BFS。 注意两个格子、只会右、下、旋转。
import queue
class Solution:
def minimumMoves(self, grid: List[List[int]]) -> int:
# 横 -- 0 竖 | 1
n = len(grid)
q = queue.Queue()
vis = {} # 标记是否访问过
#[point1, point2, 状态, 步数]
q.put([(0,0),(0,1), False, 0])
status = count = 0
while not q.empty():
[p1, p2, status, count] = q.get()
if (p1,p2) in vis: # 如果访问过比较一下。
vis[p1,p2] = min(count, vis[p1,p2])
continue
else:
vis[p1, p2] = count
if not status: # 横着的
if p2[1] + 1 < n and grid[p2[0]][p2[1]+1] == 0: # 右移
q.put([p2,(p2[0],p2[1]+1), status, count+1])
if p1[0] + 1 < n and grid[p1[0]+1][p1[1]] == 0 and grid[p2[0]+1][p2[1]] == 0:
q.put([p1, (p1[0]+1,p1[1]), not status, count+1]) # 旋转
q.put([(p1[0]+1,p1[1]), (p2[0]+1,p2[1]), status, count+1]) # 下移
else: # 竖着的
if p2[0] + 1 < n and grid[p2[0]+1][p2[1]] == 0:
q.put([p2,(p2[0]+1,p2[1]), status, count+1]) # 下移
if p1[1] + 1 < n and grid[p1[0]][p1[1]+1] == 0 and grid[p2[0]][p2[1]+1] == 0:
q.put([p1, (p1[0],p1[1]+1), not status, count+1]) # 旋转
q.put([(p1[0],p1[1]+1), (p2[0],p2[1]+1), status, count+1]) # 右移
if ((n-1,n-2),(n-1,n-1)) in vis:
return vis[(n-1,n-2),(n-1,n-1)]
else:
return -1
总结：
代母写的还是不够节俭，有时候思路很乱。 稍微复杂的题目脑袋瓜子在DFS的时候 回不到原点了~
最后一题完全可以在规定时间内写出来，在判断是否已经访问过的时候，居然在for循环内部判断，
想着队列里的点都是没访问过的结点，结果超时了。。（if 判断太多了。。）
原文地址：https://www.cnblogs.com/xxfna/p/11609950.html