Datawhale 1月leetcode

AC 榜

Nick	Link	1.10	1.11	1.12	1.13	1.14	1.15	1.16	1.17	1.19	1.20	1.21	1.22
lance	https://leetcode-cn.com/u/lance-b9/	3	4	2	3	4	2	2	3	1	1	1	2
一个胖毛	https://leetcode-cn.com/u/yi-ge-pang-mao/	3	3	3	2	2	3	1	1	1	2	2	2
我	https://leetcode-cn.com/u/BgKiVttrYV/	3	4	3	3	3	3	3	3	3	3	2	2
Luna	https://leetcode-cn.com/u/yuelongzou/	1	1	1	1	1	1	1	1	1	1	1	1
呃，嗯	https://leetcode-cn.com/u/e-ng-b/	1	4	5	2	1	1	1	2	1	1	1	1
余柳成荫	https://leetcode-cn.com/u/yu-liu-cheng-yin-1/	3	7	4	4	7	2	3	7	4	4	1	1
跫音	https://leetcode-cn.com/u/qyqy-3/	2	1	1	3	6	0	3	0	3	1	1	0
哆来咪	https://leetcode-cn.com/u/chi-lai-mi-fa-suo-la-xi-3/	3	1	1	0	1	1	1	-	1	1	1	1

日期	题目	难度	描述	类型	思路	完成
1.4	234. 回文链表	简单	给你一个单链表的头节点 `head` ，请你判断该链表是否为回文链表。如果是，返回 `true` ；否则，返回 `false` 。	链表
1.4	86. 分隔链表	中等	给你一个链表的头节点 `head` 和一个特定值 `x` ，请你对链表进行分隔，使得所有小于 `x` 的节点都出现在大于或等于 `x` 的节点之前。	链表
1.4	138. 复制带随机指针的链表	中等	rand指针指向任意一个节点，保证无环单链表，实现链表复制	链表
1.4	142. 环形链表 II	中等	给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 `null`。	链表
1.7	662. 二叉树最大宽度	中等	给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/maximum-width-of-binary-tree 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。	二叉树
1.7	297. 二叉树的序列化与反序列化	困难	请设计一个算法来实现二叉树的序列化与反序列化	二叉树
1.8	剑指 Offer 32 - III. 从上到下打印二叉树 III	中等	请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印	二叉树
1.8	110. 平衡二叉树	简单	给定一个二叉树，判断它是否是高度平衡的二叉树。	二叉树
1.8	543. 二叉树的直径	简单	给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。	二叉树
1.8	1373. 二叉搜索子树的最大键值和	困难	给你一棵以 `root` 为根的二叉树，请你返回任意二叉搜索子树的最大键值和。	二叉树
1.8	派对的最大快乐值	牛客	1.如果某个员工来了，那么这个员工的所有直接下级都不能来。	二叉树
1.9	707. 设计链表	中等	设计链表的实现。	链表	a. 扣index 下标	✅
1.9	206. 反转链表	简单	给你单链表的头节点 `head` ，请你反转链表，并返回反转后的链表。	链表	a. pre, cur记录下表	✅
1.9	160. 相交链表	简单	给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 `null` 。	链表	a. 抠细节，先计算长度 b. 拼接两列表	✅
1.9	203. 移除链表元素	简单	请你删除链表中所有满足 `Node.val == val` 的节点，并返回新的头节点。	链表	a. 递归 b. 迭代 c. 双指针	✅
1.9	6. Z 字形变换	中等	将一个给定字符串 `s` 根据给定的行数 `numRows` ，以从上往下、从左到右进行 Z 字形排列。	矩阵处理
1.9	剑指 Offer 29. 顺时针打印矩阵	简单	输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。	矩阵处理
1.9	面试题 01.07. 旋转矩阵	中等	给你一幅由 `N × N` 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。	矩阵处理
1.9	1353. 最多可以参加的会议数目	中等	给你一个数组 `events`，其中 `events[i] = [startDayi, endDayi]` ，表示会议 `i` 开始于 `startDayi` ，结束于 `endDayi` 。安排会议室，每个项目开始结束时间，要宣讲次数最多	贪心算法
1.9	剑指 Offer 14- I. 剪绳子	中等	给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m-1] 。请问 k[0]k[1]…*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。	贪心算法
1.9	502. IPO	困难	从给定项目中选择最多 `k` 个不同项目的列表，以最大化最终资本，并输出最终可获得的最多资本。	贪心算法
1.10	721. 账户合并	中等	给定一个列表 accounts，每个元素 accounts[i] 是一个字符串列表，其中第一个元素 accounts[i][0] 是名称 (name)，其余元素是 emails 表示该账户的邮箱地址。一共有多少用户	并查集
1.10	133. 克隆图	中等	给你无向连通图中一个节点的引用，请你返回该图的深拷贝（克隆）	图
1.10	207. 课程表	中等	在选修某些课程之前需要一些先修课程，你判断是否可能完成所有课程的学习	图
1.10	1584. 连接所有点的最小费用	中等	请你返回将所有点连接的最小总费用。只有任意两点之间有且仅有一条简单路径时	图
1.10	876. 链表的中间结点	简单	给定一个头结点为 `head` 的非空单链表，返回链表的中间结点	链表	a. 遍历 b. 快慢指针	✅
1.10	328. 奇偶链表	中等	定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。	链表
1.10	234. 回文链表	简单	请你判断该链表是否为回文链表。如果是，返回 `true` ；否则，返回 `false` 。	链表
1.11	743. 网络延迟时间	中等	从某个节点 `K` 发出一个信号。需要多久才能使所有节点都收到信号？如果不能使所有节点收到信号，返回 `-1` 。	图
1.11	面试题 08.06. 汉诺塔问题	简单		暴力递归
1.11	用递归逆序一个栈	中等		暴力递归
1.11	430. 扁平化多级双向链表	中等	给你位于列表第一级的头节点，请你扁平化列表，使所有结点出现在单级双链表中。	链表	==a.==链表递归	✅
1.11	138. 复制带随机指针的链表	中等	构造这个链表的深拷贝	链表	a. 旧节点后面紧跟新节点	✅
1.11	61. 旋转链表	中等	给你一个链表的头节点 `head` ，旋转链表，将链表每个节点向右移动 `k` 个位置。	链表	a. 抠细节	✅
1.12	148. 排序链表	中等	给你链表的头结点 `head` ，请将其按升序排列并返回排序后的链表。	链表	a. 递归 ==b.==迭代	✅
1.12	21. 合并两个有序链表	简单	将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。	链表	a. 递归 ==b.==迭代	✅
1.13	147. 对链表进行插入排序	中等	对链表进行插入排序。	链表	a. 反转链表硬推	✅
1.13	23. 合并K个升序链表	困难	给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。	链表
1.13	. 环形链表	简单	给你一个链表的头节点 `head` ，判断链表中是否有环。	链表	a. 快慢指针	✅
1.13	142. 环形链表 II	中等	给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 `null`。	链表	==a.==快慢指针，重置慢指针	✅
1.14	19. 删除链表的倒数第 N 个结点	中等	给你一个链表，删除链表的倒数第 `n` 个结点，并且返回链表的头结点。	链表	a. 快慢指针	✅
1.14	155. 最小栈	简单	并能在常数时间内检索到最小元素的栈。	栈	a. 双栈	✅
	20. 有效的括号	简单	判断字符串是否有效。	栈	a. 压入与弹出	✅
1.15	剑指 Offer 06. 从尾到头打印链表	简单	输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。	栈	a. 列表索引	✅
1.15	232. 用栈实现队列	简单	请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（`push`、`pop`、`peek`、`empty`）：	栈	a. 简单实现	✅
1.16	47. 全排列 II	中等
1.16	剑指 Offer 45. 把数组排成最小的数	中等
1.16	52. N皇后 II	困难
1.16	200. 岛屿数量	中等	给你一个由 `'1'`（陆地）和 `'0'`（水）组成的的二维网格，请你计算网格中岛屿的数量。	搜索	a. 栈搜索 b. bfs	✅
1.16	133. 克隆图	中等	给你无向连通图中一个节点的引用，请你返回该图的深拷贝（克隆）。	Bfs, dfs，图	a. dfs b. bfs	✅
1.17	494. 目标和	中等	通过上述方法构造的、运算结果等于 `target` 的不同表达式的数目。	Dfs, dp		✅
1.17	841. 钥匙和房间	中等	给你一个数组 `rooms` 其中 `rooms[i]` 是你进入 `i` 号房间可以获得的钥匙集合。如果能进入所有房间返回 `true`，否则返回 `false`。	深度优先搜索、图	==	✅
1.17	129. 求根节点到叶节点数字之和	中等	从根节点到叶节点的路径 `1 -> 2 -> 3` 表示数字 `123` 。	树、深度优先搜索、二叉树	a. dfs	✅
1.18	417. 太平洋大西洋水流问题	中等	请找出那些水流既可以流动到“太平洋”，又能流动到“大西洋”的陆地单元的坐标。	深度优先搜索、广度优先搜索、数组、矩阵	a. 找两个重叠部分	✅
1.19	739. 每日温度	中等	请根据每日 `气温` 列表 `temperatures` ，请计算在每一天需要等几天才会有更高的温度。如果气温在这之后都不会升高，请在该位置用 `0` 来代替。	单调栈	==a.==维护一个单调栈	✅

707. 设计链表

class Node:def __init__(self, x):self.val = xself.next = Noneclass MyLinkedList:def __init__(self):self.size = 0self.head = Node(0)def get(self, index: int) -> int:if index < 0 or index >= self.size:return -1cur = self.headfor _ in range(index + 1):cur = cur.nextreturn cur.valdef addAtHead(self, val: int) -> None:self.addAtIndex(0, val)def addAtTail(self, val: int) -> None:self.addAtIndex(self.size, val)def addAtIndex(self, index: int, val: int) -> None:if index > self.size:return if index < 0:index = 0self.size += 1pre = self.headtmp = Node(val)for _ in range(index):pre = pre.nexttmp.next = pre.nextpre.next = tmpdef deleteAtIndex(self, index: int) -> None:if index < 0 or index >= self.size:return pre = self.headfor _ in range(index):pre = pre.nextpre.next = pre.next.nextself.size -= 1

206. 反转链表

class Solution:def reverseList(self, head: ListNode) -> ListNode:pre = Nonecur = headwhile cur != None:tmp = cur.nextcur.next = prepre = curcur = tmpreturn pre

160. 相交链表

class Solution:def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:tag = 0tmpA = headAtmpB = headBwhile tmpA.next != None:tmpA = tmpA.nexttag += 1while tmpB.next != None:tmpB = tmpB.nexttag -= 1if tmpA != tmpB:return NonetmpA = headAtmpB = headBif tag < 0:tmp = tmpBtmpB = tmpAtmpA = tmpfor _ in range(abs(tag)):tmpA = tmpA.nextwhile True:if tmpA == tmpB:return tmpAtmpA = tmpA.nexttmpB = tmpB.next

class Solution:def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:A, B = headA, headBwhile A != B:A = A.next if A else headBB = B.next if B else headAreturn A

203. 移除链表元素

# 递归
class Solution:def removeElements(self, head: ListNode, val: int) -> ListNode:if head == None:return headres = self.removeElements(head.next, val)if head.val == val:return reselse:head.next = resreturn head

# 迭代
class Solution:def removeElements(self, head: ListNode, val: int) -> ListNode:while head and head.val == val:head = head.nextif not head:return Nonepre = headwhile pre.next != None:if pre.next.val == val:pre.next = pre.next.nextelse:pre = pre.nextreturn head

328. 奇偶链表

class Solution:def oddEvenList(self, head: ListNode) -> ListNode:if not head :return headevenhead = head.nextodd, even = head, evenheadwhile even and even.next:odd.next = even.nextodd = odd.nexteven.next = odd.nexteven = even.nextodd.next = evenheadreturn head

430. 扁平化多级双向链表

class Solution:def childflatten(self, head: 'Node'):if not head:return headcur = headpre = headwhile cur:pre = curif not cur.next and cur.child:childhead, childtail = self.childflatten(cur.child)cur.next = childheadcur.next.prev = curcur.child = Noneelif cur.child:childhead, childtail = self.childflatten(cur.child)childtail.next = cur.nextchildtail.next.prev = childtailcur.next = childheadcur.next.prev = curcur.child = Nonecur = childtail.nextelse:cur = cur.nextreturn head, predef flatten(self, head: 'Node') -> 'Node':if not head:return headself.childflatten(head)return head

138. 复制带随机指针的链表

class Solution:def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':if not head:return headcur = headwhile cur:new = Node(cur.val)new.next = cur.nextcur.next = newcur = cur.next.nextcur = headwhile cur:if cur.random:cur.next.random = cur.random.nextelse:cur.next.random = cur.randomcur = cur.next.nextcur = head.nextwhile cur and cur.next:cur.next = cur.next.nextcur = cur.nextreturn head.next

61. 旋转链表

class Solution:def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:if not head or not head.next or k == 0:return headcur = headpre = headsize = 0while cur:size += 1cur = cur.nextcur = headif k % size == 0:return headsize = size - k if size >= k else size - (k % size)for _ in range(size):pre = curcur = cur.nextpre.next = Nonedummy = curwhile cur.next:cur = cur.nextcur.next = headreturn dummy

148. 排序链表

# 递归
class Solution:def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:if not head or not head.next:return headslow, fast = head, head.nextwhile fast and fast.next:slow = slow.nextfast = fast.next.nexttmp = slow.nextslow.next = Noneslow = tmpleft, right = self.sortList(head), self.sortList(slow)newhead = result = ListNode(0)while left and right:if left.val <= right.val:newhead.next = leftnewhead = newhead.nextleft = left.nextelse:newhead.next = rightnewhead = newhead.nextright = right.nextif left:newhead.next = leftif right:newhead.next = rightreturn result.next

# 迭代
class Solution:def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:h, size, intv = head, 0, 1while h:h = h.nextsize += 1result = ListNode(0)result.next = headwhile intv < size:pre, h = result, result.nextwhile h:h1 = hi = intvwhile i and h:h = h.nexti -= 1if i:breakh2 = hi = intvwhile i and h:h = h.nexti -= 1c1, c2 = intv, intv - iwhile c1 and c2:if h1.val < h2.val:pre.next = h1h1 = h1.nextc1 -= 1else:pre.next = h2h2 = h2.nextc2 -= 1pre = pre.nextif c1:pre.next = h1else:pre.next = h2c1 = c2while c1:pre = pre.nextc1 -= 1pre.next = hintv *= 2return result.next

21. 合并两个有序链表

# 迭代
class Solution:def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:result = newhead = ListNode(0)while list1 and list2:if list1.val <= list2.val:newhead.next = list1newhead = newhead.nextlist1 = list1.nextelse:newhead.next = list2newhead = newhead.nextlist2 = list2.nextif list1:newhead.next = list1if list2:newhead.next = list2return result.next

# 递归
class Solution:def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:if not list1:return list2if not list2:return list1l1, l2 = list1, list2if l1.val < l2.val:l1.next = self.mergeTwoLists(l1.next, l2)return l1else:l2.next = self.mergeTwoLists(l1, l2.next)return l2

147. 对链表进行插入排序

class Solution:def insert(self, cur: ListNode, pre) -> ListNode:tmp = cur.nextcur.next = pre.nextpre.next = curreturn tmpdef insertionSortList(self, head: ListNode) -> ListNode:pre = ListNode(0)pre.next, cur = None, head# pre.next.next = Nonewhile cur:# tmp = cur.nextcur.next toPre, to = pre, pre.nextif not pre.next:cur = self.insert(cur, pre)continuewhile to:if to.val < cur.val:toPre = toto = to.nextelse:cur = self.insert(cur, toPre)breakif not to:cur = self.insert(cur, toPre)return pre.next

141. 环形链表

class Solution:def hasCycle(self, head: Optional[ListNode]) -> bool:if not head or not head.next:return Falseslow, fast = head, head.nextwhile slow != fast:if not fast or not fast.next:return Falseslow = slow.nextfast = fast.next.nextreturn True

142. 环形链表 II

class Solution(object):def detectCycle(self, head):fast, slow = head, headwhile True:if not (fast and fast.next): returnfast, slow = fast.next.next, slow.nextif fast == slow: breakfast = headwhile fast != slow:fast, slow = fast.next, slow.nextreturn fast

19. 删除链表的倒数第 N 个结点

class Solution:def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:fast = headfor i in range(n+1):if not fast:return head.nextfast = fast.nextslow = headwhile slow and fast:slow, fast = slow.next, fast.nextslow.next = slow.next.nextreturn head

155. 最小栈

class MinStack:def __init__(self):self.stack = []self.minstack = []def push(self, val: int) -> None:self.stack.append(val)if self.minstack == []:self.minstack.append(val)return if val < self.minstack[-1]:self.minstack.append(val)else:self.minstack.append(self.minstack[-1])def pop(self) -> None:self.stack.pop()self.minstack.pop()def top(self) -> int:return self.stack[-1]def getMin(self) -> int:return self.minstack[-1]

20. 有效的括号

class Solution:def isValid(self, s: str) -> bool:char = {'(':')', '{':'}', '[':']'}stack = []for i in s:if i in char:stack.append(i)else:if stack == []:return Falseif i == char[stack[-1]]:stack.pop()else:return Falseif stack == []:return Trueelse:return False

剑指 Offer 06. 从尾到头打印链表

class Solution(object):def reversePrint(self, head):""":type head: ListNode:rtype: List[int]"""stack = []while head:stack.append(head.val)head = head.nextreturn stack[::-1]

232. 用栈实现队列

class MyQueue:def __init__(self):self.stack = []self.help = []def push(self, x: int) -> None:self.stack.append(x)def pop(self) -> int:if self.help:return self.help.pop()if not self.stack:return -1else:while self.stack:self.help.append(self.stack.pop())return self.help.pop()def peek(self) -> int:if self.help:return self.help[-1]if not self.stack:return -1else:while self.stack:self.help.append(self.stack.pop())return self.help[-1

200. 岛屿数量

# 栈 循环
class Solution:def numIslands(self, grid: List[List[str]]) -> int:if not grid:return 0m = len(grid)n = len(grid[0])tag = [[0] * n for _ in range(m)]count = 0for i in range(m):for j in range(n):if tag[i][j]:continueneightbor = []if grid[i][j] == '1':neightbor.append((i, j))count += 1  while len(neightbor):i_, j_ = neightbor.pop()tag[i_][j_] = 1if i_ + 1 < m and not tag[i_ + 1][j_] and grid[i_ + 1][j_] == '1':neightbor.append((i_ + 1, j_)) if i_ - 1 >= 0 and not tag[i_ - 1][j_] and grid[i_ - 1][j_] == '1':neightbor.append((i_ - 1, j_)) if j_ + 1 < n and not tag[i_][j_ + 1] and grid[i_][j_ + 1] == '1':neightbor.append((i_, j_ + 1)) if j_ - 1 >= 0 and not tag[i_][j_ - 1] and grid[i_][j_ - 1] == '1':neightbor.append((i_, j_ - 1)) return count

# bfs
class Solution:def dfs(self,grid, i, j):grid[i][j] = 0m = len(grid)n = len(grid[0])for x, y in [(i - 1, j), (i + 1, j), (i, j - 1), (i, j + 1)]:if 0 <= x < m and 0 <= y < n and grid[x][y] == "1":self.dfs(grid, x, y)def numIslands(self, grid: List[List[str]]) -> int:m = len(grid)if m == 0:return 0n = len(grid[0])count = 0for i in range(m):for j in range(n):if grid[i][j] == '1':count += 1self.dfs(grid, i, j)return count

133. 克隆图

# dfs
class Solution:def __init__(self):self.visited = {}def cloneGraph(self, node: 'Node') -> 'Node':if not node:return nodeif node in self.visited:return self.visited[node]new_node = Node(node.val, [])self.visited[node] = new_nodeif node.neighbors:self.visited[node].neighbors = [self.cloneGraph(n) for n in node.neighbors]return self.visited[node]

# bfs
from collections import deque
class Solution:def cloneGraph(self, node: 'Node') -> 'Node':if not node:return nodevisited = {}visited[node] = Node(node.val, [])queue = deque([node])while queue:n = queue.popleft()for neighbor in n.neighbors:if neighbor not in visited:visited[neighbor] = Node(neighbor.val, [])queue.append(neighbor)visited[n].neighbors.append(visited[neighbor])return visited[node]

494. 目标和

class Solution:def findTargetSumWays(self, nums: List[int], target: int) -> int:target = abs(target)allsum = sum(nums)if allsum < target or (allsum + target)%2:return 0target_ = (allsum + target) // 2dp = [0] * (target_ + 1)dp[0] = 1for num in nums:for j in range(target_, num-1, -1):dp[j] = dp[j] + dp[j-num]return dp[-1]

841. 钥匙和房间

class Solution:def canVisitAllRooms(self, rooms: List[List[int]]) -> bool:keys = [0] * len(rooms)keys[0] = 1stack = []for k in rooms[0]:stack.append(k)while stack:cur = stack.pop()if keys[cur] == 0:keys[cur] = 1for k in rooms[cur]:stack.append(k)else:continueif 0 not in keys:return Truereturn False

129. 求根节点到叶节点数字之和

class Solution:def sumNumbers(self, root: TreeNode) -> int:def dfs(node, prevNode):if not node:return 0total = prevNode * 10 + node.valif not node.left and not node.right:return totalelse:return dfs(node.left, total) + dfs(node.right, total)return dfs(root, 0)

417. 太平洋大西洋水流问题

class Solution:def pacificAtlantic(self, heights: List[List[int]]) -> List[List[int]]:m, n = len(heights), len(heights[0])pacific = [[0]*n for _ in range(m)]atlantic = [[0]*n for _ in range(m)]pos = [(0, 1), (0, -1), (1, 0), (-1, 0)]def dfs(x, y, area):area[x][y] = 1for dx, dy in pos:xx, yy = dx + x, dy + yif 0<=xx<m and 0<=yy<n and heights[xx][yy] >= heights[x][y] and not area[xx][yy]:dfs(xx, yy, area)for i in range(n):dfs(0,i,pacific)dfs(m-1,i, atlantic)for j in range(m):dfs(j, 0, pacific)dfs(j, n-1, atlantic)return [[i, j] for i in range(m) for j in range(n) if atlantic[i][j] and pacific[i][j]]

739. 每日温度

class Solution:def dailyTemperatures(self, temperatures: List[int]) -> List[int]:length = len(temperatures)ans = [0] * lengthstack = []for i in range(length):temperature = temperatures[i]while stack and temperature > temperatures[stack[-1]]:prev = stack.pop()ans[prev] = i - prevstack.append(i)return ans

322. 零钱兑换

class Solution:def coinChange(self, coins: List[int], amount: int) -> int:@functools.lru_cache(amount)def dp(rem) -> int:if rem < 0: return -1if rem == 0: return 0mini = int(1e9)for coin in self.coins:res = dp(rem - coin)if res >= 0 and res < mini:mini = res + 1return mini if mini < int(1e9) else -1self.coins = coinsif amount < 1: return 0return dp(amount)

理论

复杂度

时间复杂度

常数时间操作

执行时间是固定时间

位运算符

&

|

~

^

<<

>>

int 32

排序

数据状况不影响排序流程
选择排序

选择最小的放在第0位置

冒泡排序
通过交换让最大的值放在第N位

数据状况影响排序流程（算法表现）
插入排序

打牌的例子

小牌往左移动

如果数组有序，飞速排好

总操作数量–样本数量关系

最差情况考虑数据情况

拆分基本动作

基本动作数量和N的关系

算法流程和语言无关

算法时间复杂度需要对流程非常熟悉

额外空间复杂度

不考虑输入输出空间的大小

常数项时间

实现细节

最优解

先满足时间复杂度最低，使用最少的空间的算法流程

线性时间 O(N^2)

递归展开时间 O(2^N)

全排列时间 O(N!)

对数器

怎么算的算法

怎么试的代码

想测的方法 a

复杂度不好、容易实现的方法 b

实现随机样本产生器（可控）

对比方法 a 和方法 b 是否一致

打印错误例子，debug

二分法

有序数组中，某数是否存在

有序数组中，>= 某数最左侧的位置

二分找指针

有序数组中，<= 某数最右侧的位置

局部最小值问题

首尾中部

无序，相邻不等

排他性出现，就可以二分

L + ((R- L) >> 1) ==(L + R) / 2

N / 2 == N>>1

N * 2 + 1 == ((N<<1) | 1)

异或运算

定义

无进位相加

0 ^ N == N

N ^ N == 0

满足交换律，结合律，同一批数异或不考虑顺序

如何不用额外变量交换两个数

a = a ^ b

b = a ^ b

a = a ^ b

一个数组中一种数出现了奇数次，其他数出现了偶数词，怎么找到并打印这种数

异或上所有的数 == 出现这个出现了奇数次的数

怎么把一个int 类型的数提取出最右侧的1

N & ((~N) + 1)

一个数组中两种数出现了奇数次，其他数出现了偶数词，怎么找到并打印这种数

eor = a ^ b != 0 在某个位上有 1，a，b在这个位上不同，整个数组分为两大类，只需要找一类

一个数中1的个数

整理——12.28

有序数组中，某数是否存在

有序数组中，>= 某数最左侧的位置

有序数组中，<= 某数最右侧的位置

局部最小值问题

如何不用额外变量交换两个数

一个数组中一种数出现了奇数次，其他数出现了偶数词，怎么找到并打印这种数

怎么把一个int 类型的数提取出最右侧的1

一个数组中两种数出现了奇数次，其他数出现了偶数词，怎么找到并打印这种数

一个数中1的个数

链表结构

单向链表，双向链表

单链表和双链表如何翻转

next, pre

把给定值删除

head 位置处理

cur, pre

栈和队列

双向链表实现

提供头部进头部出尾部进尾部出

数组实现
队列循环使用数组

ring buffer

putindex, pollindex, size, limit

nextIndex

Pop, push, getMin操作复杂度都是O(1)
两个栈min和data栈

可以用现成的栈结构

栈结构实现队列结构

队列结构实现栈结构
data help

Push pop

图的广度优先遍历 – 先进先出（队列）

图的深度优先遍历 – 先进后出（栈）

递归

思想上理解递归

实现上理解递归

求数组arr上的最大值

递归画脑图

f(0,3) = max(f(0,1), f(2,3))

系统栈

伪递归

递归的时间复杂度–master 公式

T(N)=aT(T/b) + o(N^d)

log_b^a > d: O(N^(log_ba))

log_b^a < d: O(N^d))

log_b^a == d: O(N^d * log N)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HPoSqEqK-1642863777262)(/Users/a/Library/Application Support/typora-user-images/image-20211229201426935.png)]

哈希表

按引用传递和按值传递

有序表

整理——12.29

单链表和双链表如何翻转

链表把给定值删除

双向链表实现队列栈

数组实现队列栈

新栈Pop, push, getMin操作复杂度都是O(1)

栈结构实现队列结构

队列结构实现栈结构

图的广度优先遍历 – 先进先出（队列）

图的深度优先遍历 – 先进后出（栈）

递归的时间复杂度–master 公式

归并排序

递归

非递归

k=2-》k>=N

Mergesize，一组是两个mergesize

加mergesize > N/2 break 防止溢出

本质上原因

归并排序将比较行为变成了有序信息传递

没有大量浪费比较行为

求

求数组小和

归并过程中，保存比较结果

心路历程

求数组降序对

随机快排

Partition 过程

空间 O(1) 时间 O(N)

荷兰国旗问题

Less more index

快拍1.0

快拍2.0

快拍3.0

时间复杂度O(N*logN),空间复杂度O(logN)

整理——12.30

求数组小和

求数组降序对

荷兰国旗问题

堆排序

堆

完全二叉树

从0开始的数组：*2 + 1, *2 + 2, -1)/2

从1开始的数组：<<2, <<2|1, >>2

大根堆，小根堆

大根堆删除最大值

heapify: 两孩子和我最大的pk

堆排序

heapify构造大根堆时间复杂度O(n)

手写堆

优先队列，底层是堆

几乎有序的数组，进行排序

比较器

重载比较运算符

整理——12.31

几乎有序的数组，进行排序

时间复杂度测试：样本数量扩充一倍数，看时间复杂度

trie：前缀树

字符串，字符加到多叉树

功能1: 查询字符串出现过几次

功能2: 有多少字符串以某字符串为前缀迹只？？

不基于比较的排序

桶排序–大思想（容器）——对数据状况有要求

计数排序

基数排序：权重大放最后
count,

O(N*log10Max) 有数据约束 O(N)

排序算法的稳定性

时间：O(N*logN),空间复杂度<O(N),还稳定的比较排序不存在

常见的坑，不要碰

归并排序的额外空间复杂度变为O(1)

原地归并排序不要碰

快速排序稳定性改进，得对数据做限制，那干啥不用桶排序

奇数左边，偶数右边，时间O(n)，空间 O(1)（0-1标准partition）(做不到稳定）

工程上对排序的改进

是否考虑稳定性

N较小时调度插入排序

链表相关面试题

笔试：主要考虑时间复杂度

面试：时间复杂度外还要考虑空间复杂度

快慢指针

奇数长度返回中点，偶数长度返回上中点

奇数长度返回中点，偶数长度返回下中点

奇数长度返回中点的前一个，偶数长度返回上中点的前一个

奇数长度返回中点的前一个，偶数长度返回下中点的前一个

面试两个变量

笔试用容器，找位置

常见面试题

给定一个单链表，判断是否是回文结构
笔试

栈

用快慢指针，只把右半部分加入栈

面试
改原链表逆序后改回来

将单链表按照小等大的形式
笔试

链表放数组，饭后partition

面试
分成三个部分，然后串起来

rand指针指向任意一个节点，保证无环单链表，实现链表复制
笔试

hash表

面试
链表coding，间隔放后，依次拿出一对

对两个可能有环的单链表，若两链表相交，返回相交的第一个节点时间O(N)空间 O(1)
找第一个环节点

hashset找

快慢指针找

两个链表都无环
hashset找

遍历找

一个链表有环，另一个没环（不存在）

两个链表都有环(一定公用环)
独立

同一节点入环，看第一个环节点是否相等

非同一节点入环

只给想删除的节点，在链表上把这个点删掉
抖机灵：借尸还魂

不提供拷贝

无法拷贝

删不了最后一个节点，null是在系统上特定的区域

二叉树

树形dp解决二叉树问题

二叉树的先序中序后序

递归树，递归序

压栈实现非递归

头右左

头左右

h c 标记前后两节点，左树搞完了，搞右树，最后搞自己

二叉树的按层遍历

统计二叉树最大宽度

flag 发现层结束

levelMap

curEnd, nextEnd

队列

二叉树的序列化和反序列化

二叉树按层序列化

二叉树面试题

如何设计一个打印整棵树的打印函数

节点可以往上指，给某个节点，返回该节点的后继节点（中序遍历的下一个几点）（前驱节点）

纸条对折，折痕方向

二叉树的递归套路

解决二叉树问题（树形dp问题）

利用递归遍历二叉树的遍历性

给定二叉树的头结点，判断这棵树是不是平衡二叉树

给定头结点head，返回整棵二叉树的最大距离

给定一颗二叉树的头结点，返回这可二叉树最大二叉搜索子树的头结点

派对的最大快乐值

x来和x不来

打表技巧

打表找规律：输入输出都是简单数字，暴力打印找规律，优化code

买苹果，只有两种塑料袋，装6 / 8,使用最少袋子且装满

打表找规律

(apple - 18)/8 + 3kp

N份青草轮流吃4的某次方，先吃完胜

一个数可以表示若干连续正数和的数

num 是不是2 的某次方（num&(num-1))==0则是2的某次方

谁先打开所有开关就赢

矩阵处理技巧

存在宏观的coding调度

zigzag 打印矩阵

转圈打印矩阵

原地旋转正方形矩阵

贪心算法

不用纠结贪心策略的证明

笔试 60%-70% 有没有写过code

面试 20% 区分度

安排会议室，每个项目开始结束时间，要宣讲次数最多

‘X’,’.'组成的str，X是墙，.是居民，灯可以照亮，返回至少需要几盏灯

暴力做法

贪心做法

总在当前步做出最优决定

切金条，承担自己长度的代价

堆和排序

哈夫曼树

每做完一个项目，马上获得下一个项目，不能并行做项目，最大钱数

一个小根堆一个大根堆

并查集

method

isSameSet

union

attribute

nodes

parents

sizeMap

每个实例多个id字段，给定多个实例，有一个重复字段，是一个人，一共几个人

图

数据结构比较复杂

转化图结构

createGrapt

weight， from， to

图的宽度深度

队列+set结构（保证只进一次）

图的优先遍历

图的拓扑排序（不能有环）

最小生成树 Kruskal - 并查集 - k 算法

边排序

prim 算法 - P算法

指定一个出发点

Dijsktral 算法：出发点到所有点的最短距离

TSP 问题完全是两个问题

小根堆
insertheapify

heapify

暴力递归

暴力，不记录每个子问题IDE解

汉诺塔问题 2^n - 1

仰望一个好的尝试：用递归逆序一个栈

从小规模试答案

人过鱼河问题

海盗分硬币问题

欧拉信封问题

动态规划

（中序遍历无法做到序列化和反序列化）

打印字符串的全部子序列

深度优先遍历

打印字符串的全部子序列，要求不出现重复字面值的子序列

如果只求个数，动态规划

打印一个字符串的全部排列

按位置来依次选

打印字符全部排列要求不重复

从左到右的尝试模型

按范围上的尝试模型

多样本位置对应的尝试模型

寻找业务限制的尝试模型

动态规划2

N皇后问题

普通方法

位运算优化方法

limit

collim

leftdialim

rightdialim

暴力递归到动态规划

斐波那契数列问题

暴力递归：大量重复计算

dp[cur][rest] 走k步到指定位置有多少种方法

Datawhale 1月leetcode相关推荐

一个算法笨蛋的12月leetCode刷题日记
类似文章一个算法笨蛋的2021年11月leetCode刷题日记一个算法笨蛋的2021年12月leetCode刷题日记一个算法笨蛋的2022年1月leetCode刷题日记一个算法笨蛋的2022年 ...
datawhale 8月学习——NLP之Transformers：编写BERT模型
前情回顾 1.attention和transformers 2.BERT和GPT 结论速递跟着教程,阅读了HuggingFace的BERT模型,分为tokenizer和model两大部分,而mode ...
【Datawhale】之LeetCode分类练习（分治）
分治介绍主要思想分治算法的主要思想是将原问题递归地分成若干个子问题,直到子问题满足边界条件,停止递归.将子问题逐个击破(一般是同种方法),将已经解决的子问题合并,最后,算法会层层合并得到原问题的答 ...
Datawhale 10月学习-Free excel 学习笔记--excel函数3--FILTER,SUMIF,SUBTOTAL
学习目标:了解excel函数中高级筛选,并进行求和等操作学习内容: 1.单条件筛选:[FILTER]函数=FILTER(数据区域,筛选条件,[无满足条件的记录时返回的值]) 举例:想从区域中选出湖北 ...
Datawhale 6月学习——图神经网络：超大图上的节点表征学习
前情回顾图神经网络:图数据表示及应用图神经网络:消息传递图神经网络图神经网络:基于GNN的节点表征学习图神经网络:基于GNN的节点预测任务及边预测任务 1 超大图上的节点表征学习 1.1 简述 ...
2019年9月Leetcode每日训练日志
2019-09-16 #1171 从链表中删去总和值为零的连续节点 #1170 比较字符串最小字母出现频次 #1169 查询无效交易 #226 翻转二叉树 2019-09-15 #1190 反转每对括 ...
Datawhale 7月学习——李弘毅深度学习：卷积神经网络
前情回顾机器学习简介回归误差与梯度下降深度学习介绍和反向传播机制网络的优化 1 卷积神经网络 1.1 为什么要有卷积神经网络我们希望hidden layer每一层都挖掘到新的信息,但是对于 ...
datawhale 10月学习——树模型与集成学习：两种并行集成的树模型
前情回顾决策树 CART树的实现集成模式结论速递本次学习了两种并行集成的树模型,随机森林和孤立森林,并进行了相应的代码实践.其中对孤立森林的学习比较简略,有待后续补充. 这里写自定义目录标题 ...
Datawhale 7月学习——李弘毅深度学习：回归
前情回顾机器学习简介 1 回归模型 1.1 回归的概念及例子回归(Regression)的意思就是找到一个函数 functionfunctionfunction ,通过输入特征 xxx,输出一个数 ...

Datawhale 1月leetcode

AC 榜

理论

复杂度

对数器

二分法

异或运算

整理——12.28

链表结构

栈和队列

递归

哈希表

有序表

整理——12.29

归并排序

随机快排

整理——12.30

堆排序

整理——12.31

trie：前缀树

不基于比较的排序

排序算法的稳定性

工程上对排序的改进

链表相关面试题

二叉树

二叉树面试题

二叉树的递归套路

打表技巧

矩阵处理技巧

贪心算法

并查集

图

暴力递归

Datawhale 1月leetcode相关推荐

最新文章

热门文章