标签：多少 string 思路 超时 style bcg 个数 而且 栈的操作
两周了，第一次独立写完四个题目，开心（当然... 不是在考试时间内写完的，主要还是四个题知识图谱内，而且还不难吧），加油！
独一无二的出现次数
给你一个整数数组 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)）。
每次移动，蛇可以这样走：
(r, c)、(r, c+1)）移动到 （(r, c)、(r+1, c)）。
(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 判断太多了。。）
标签：多少 string 思路 超时 style bcg 个数 而且 栈的操作
原文地址：https://www.cnblogs.com/xxfna/p/11609950.html
