1.单词替换
在英语中，我们有一个叫做 词根(root) 的概念，可以词根 后面 添加其他一些词组成另一个较长的单词——我们称这个词为 衍生词 (derivative)。例如，词根 help，跟随着 继承词 “ful”，可以形成新的单词 “helpful”。
现在，给定一个由许多 词根 组成的词典 dictionary 和一个用空格分隔单词形成的句子 sentence。你需要将句子中的所有 衍生词 用 词根 替换掉。如果 衍生词 有许多可以形成它的 词根，则用 最短 的 词根 替换它。
你需要输出替换之后的句子。
'''
注意下面的两种注释二选一，不加非常的影响性能表现
'''
from typing import List
class Solution:
def replaceWords(self,dictionary:List[str],sentence:str)->str:
#dictionary=set(dictionary)
#dictionary = {word: True for word in dictionary}
sentence_list=sentence.split()
for i in range(len(sentence_list)):
for j in range(1,len(sentence_list[i])):
if sentence_list[i][:j] in dictionary:
sentence_list[i]=sentence_list[i][:j]
break
return ' '.join(sentence_list)
这个题很简单，但是这里需要注意的是，中间注释的部分，二选一即可，在字典中，还有在set中找东西都是O(1)的时间复杂度，所以使用set还有dictionary的性能表现会非常的好，当然不加也行，想累死编译器也成。
2.优美的排列 II
给你两个整数 n 和 k ，请你构造一个答案列表 answer ，该列表应当包含从 1 到 n 的 n 个不同正整数，并同时满足下述条件：
假设该列表是 answer = [a1, a2, a3, … , an] ，那么列表 [|a1 - a2|, |a2 - a3|, |a3 - a4|, … , |an-1 - an|] 中应该有且仅有 k 个不同整数。
返回列表 answer 。如果存在多种答案，只需返回其中 任意一种 。
示例 1：
输入：n = 3, k = 1
输出：[1, 2, 3]
解释：[1, 2, 3] 包含 3 个范围在 1-3 的不同整数，并且 [1, 1] 中有且仅有 1 个不同整数：1
示例 2：
输入：n = 3, k = 2
输出：[1, 3, 2]
解释：[1, 3, 2] 包含 3 个范围在 1-3 的不同整数，并且 [2, 1] 中有且仅有 2 个不同整数：1 和 2
class Solution:
def constructArray(self, n: int, k: int) -> List[int]:
nums=[i for i in range(1,n+1)]
index=1
while k>1:
if k==2:
num=nums.pop()
nums.insert(-1,num)
break
num=nums.pop()
nums.insert(index,num)
index+=2
k-=2
return nums
应该是目前做力扣以来最自豪的一次，完全是全新的逻辑，从摸索规律到修改，中间修改过while里的可能性，k==2的时候的插入逻辑，之前的是提前到第一个，但是这种情况会导致k不增加了，所以要修改这种可能性，我发现和最后一位进行交换可以只加一种可能性，所以我就直接-1，然后index的设定也很好。这个题绝了。
3.前K个高频单词
给定一个单词列表 words 和一个整数 k ，返回前 k 个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。
示例 1：
输入: words = [“i”, “love”, “leetcode”, “i”, “love”, “coding”], k = 2
输出: [“i”, “love”]
解析: “i” 和 “love” 为出现次数最多的两个单词，均为2次。
注意，按字母顺序 “i” 在 “love” 之前。
示例 2：
输入: [“the”, “day”, “is”, “sunny”, “the”, “the”, “the”, “sunny”, “is”, “is”], k = 4
输出: [“the”, “is”, “sunny”, “day”]
解析: “the”, “is”, “sunny” 和 “day” 是出现次数最多的四个单词，
出现次数依次为 4, 3, 2 和 1 次。
from collections import Counter
class Solution:
def topKFrequent(self, words: List[str], k: int) -> List[str]:
dic=Counter(words)
nums=[]
for x,y in dic.items():
nums.append([x,y])
nums.sort(key=lambda x: (-x[1], x[0]))
#nums.sort(key=lambda x:(x[1]),reverse=True)
res=[]
for i in range(k):
res.append(nums[i][0])
return res
这个题的难点在于，这个sort的编写，这个竟然是大头，sort(key=lambda x:(x[1]),reverse=True)相等于sort(key=lambda x:(-x[1]))，这个题也基本上是我独立做出来的。
4.腐烂的橘子
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：
值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。
返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。
示例 1：
输入：grid = [[2,1,1],[1,1,0],[0,1,1]]
输出：4
示例 2：
输入：grid = [[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。
示例 3：
输入：grid = [[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。
class Solution:
def orangesRotting(self, grid: List[List[int]]) -> int:
ans=0
nr=len(grid)
if nr==0:
return 0
nc=len(grid[0])
rotated=[]
for i in range(nr):
for j in range(nc):
if grid[i][j]==2:
rotated.append([i,j])
while rotated:
tmp=rotated.copy()
rotated=[]
changed=False
for i in range(len(tmp)):
r,c=tmp.pop()
for x,y in (r-1,c),(r+1,c),(r,c-1),(r,c+1):
if 0<=x<nr and 0<=y<nc and grid[x][y]==1:
changed=True
grid[x][y]=2
rotated.append([x,y])
if changed==True:
ans+=1
for i in range(nr):
for j in range(nc):
if grid[i][j]==1:
return -1
return ans
就错了一次，几乎是一遍过，就错了个赋值号。夸夸自己，而且没有使用deque因为没必要
现在讨论一下为什么要用deque呢，就是说，我没有要计算层数的时候，我就可以使用deque来一鼓作气的把所有的相关项全部算完，而且动态队列也不会特别的大，但是如果把所有的相关量一股脑的全部存进去再取，那就没有列表的性能好了，就没有必要这样子了。