leetcode热题系列12

410. 分割数组的最大值

380. 常数时间插入、删除和获取随机元素

设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构。

insert(val)：当元素 val 不存在时，向集合中插入该项。
remove(val)：元素 val 存在时，从集合中移除该项。
getRandom：随机返回现有集合中的一项。每个元素应该有相同的概率被返回。
示例 :

// 初始化一个空的集合。
RandomizedSet randomSet = new RandomizedSet();
 
// 向集合中插入 1 。返回 true 表示 1 被成功地插入。
randomSet.insert(1);
 
// 返回 false ，表示集合中不存在 2 。
randomSet.remove(2);
 
// 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
randomSet.insert(2);
 
// getRandom 应随机返回 1 或 2 。
randomSet.getRandom();
 
// 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
randomSet.remove(1);
 
// 2 已在集合中，所以返回 false 。
randomSet.insert(2);
 
// 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
randomSet.getRandom();

解题思路：使用列表存储元素值，使用字典存储元素值及其在列表中的索引。重点关注删除操作：先将要删除的val对应的索引值赋给列表中最后一个元素，接下来对列表中两个元素进行交换，最后在列表和字典中分别移除val即可。

class RandomizedSet(object):
 
    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.values = []
        self.index = {}
 
    def insert(self, val):
        """
        Inserts a value to the set. Returns true if the set did not already contain the specified element.
        :type val: int
        :rtype: bool
        """
        if val in self.index:
            return False
        self.values.append(val)
        self.index[val] = len(self.values)-1
        return True
 
    def remove(self, val):
        """
        Removes a value from the set. Returns true if the set contained the specified element.
        :type val: int
        :rtype: bool
        """
        if val not in self.index:
            return False
        self.index[self.values[-1]] = self.index[val]
        self.values[-1],self.values[self.index[val]] = self.values[self.index[val]],self.values[-1]
        self.values.pop()
        self.index.pop(val)
        return True
 
    def getRandom(self):
        """
        Get a random element from the set.
        :rtype: int
        """
        return self.values[random.randint(0,len(self.values)-1)]
 
 
# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

863. 二叉树中所有距离为 K 的结点

554. 砖墙

题：画一条自顶向下的、穿过最少砖块的垂线。

法：这题极端情况，一条垂线穿过最多砖块的数目就是，整个砖墙的行数len(walls)。那么我们对每个位置都 建立index与砖块边缘数目的关系。比如题目中给的例子：行数=len(walls)=6,列数=6，对于index=0和index=6是整个砖墙的边缘，不考虑。对于index=1时，在该位置结束的砖块数有3个，index=2时，在该位置结束的砖块数仅有1个，index=3时，在该位置结束的砖块数有3个，index=4时，在该位置结束的砖块数有4个，是最多的情况，所以len(walls)-4，就是本题的答案。

注意：记录index与数目关系时，我一开始考虑用list，初始化list中每个元素为0，但发现没有用字典好，字典可以不初始化，对每个dict[key]自增1时，如果该key原来没有值，就返回0。

def leastBricks(self, wall):
        """
        :type wall: List[List[int]]
        :rtype: int
        """
        mark={}
        for x in wall:
            tmp=0
            for i in range(len(x)-1):
                tmp+=x[i]
                mark[tmp]=mark.get(tmp,0)+1
        print(mark)
        if not mark:return len(wall)
        return len(wall)-max(mark.values())

108. 将有序数组转换为二叉搜索树

6. Z 字形变换

将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “LEETCODEISHIRING” 行数为 3 时，排列如下：

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if s == "" or numRows == 1 :
            return s
        temp = ["" for _ in range(numRows)]
        flag = -1
        i = 0
        for c in s:
            temp[i] += c
            if i == 0 or i==numRows-1:
                flag = -flag
            i = i + flag 
        return "".join(temp)

528. 按权重随机选择

1044. 最长重复子串

补充题22. IP地址与整数的转换

876. 链表的中间结点

剑指 Offer 35. 复杂链表的复制

先用哈希表生成每个节点对应的新的节点，然后从头遍历原链表，根据next,random指针给新的链表设置next,random值。

class Solution:
    def copyRandomList(self, head: 'Node') -> 'Node':
        if not head:
            return 
        dic={}
        cur=head
        while cur:
            dic[cur]=Node(cur.val)
            cur=cur.next
        cur=head
        while cur:
            dic[cur].next=dic.get(cur.next)
            dic[cur].random=dic.get(cur.random)
            cur=cur.next
        return dic[head]

130. 被围绕的区域

给定一个二维的矩阵，包含 ‘X’ 和 ‘O’（字母 O）。
找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。

示例:

X X X X
X O O X
X X O X
X O X X

运行你的函数后，矩阵变为：

X X X X
X X X X
X X X X
X O X X

解释:
被围绕的区间不会存在于边界上，换句话说，任何边界上的 ‘O’ 都不会被填充为 ‘X’。 任何不在边界上，或不与边界上的 ‘O’ 相连的 ‘O’ 最终都会被填充为 ‘X’。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。

解题思路
思路：DFS、BFS
首先先看题目，给定的二维矩阵中，包含 ‘X’ 和 ‘O’（字母 O）。再看解释部分，任何边界上的 ‘O’ 不会被填充为 ‘X’，那么现在也就是说，其实有三个部分：

可形成包围的 ‘X’；
被 ‘X’ 包围的 ‘O’；
未被 ‘X’ 包围的 ‘O’。
现在题目的要求是将被包围的 ‘O’，转变为 ‘X’。前面也说了，未被包围的 ‘O’，是处于边界上的，同时侧面说明与边界 ‘O’ 相连的 ‘O’ 又不会被 ‘X’ 填充。

那么我们可以根据这个性质，我们考虑从边界开始扩散，先去标记不能被填充的 ‘O’，也就是与边界 ‘O’ 相连的部分，那么剩下的 ‘O’ 则会被包围转变为 ‘X’。具体的做法如下：

以边界的 ‘O’ 为起点，标记与之相连或者间接相连的字母 ‘O’；
当标记完上面部分的 ‘O’，此时开始遍历矩阵，去判断每个字母（注意：标记的为不会被替换的部分）：
如果该字母是被标记的部分，那么将其重新转换为 ‘O’；
如果该字母是未被标记的部门，那么将其转换为 ‘X’。
注意：题目要求的是原地修改，那么我们标记的时候，将与边界 ‘O’ 相连的部分（包括边界 ‘O’），标记为 ‘M’。

我们现在使用深度优先搜索（DFS）和广度优先搜索（BFS）的方法来解决这个问题。具体的代码如下。

#深度优先搜索（DFS）
class Solution:
    def solve(self, board: List[List[str]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        if not board or len(board)==0:
            return

        def dfs(board, i, j):
            # 不处于矩阵内，或者如果已经标记的话，直接跳过
            if not (0<=i<m) or not (0<=j<n) or board[i][j] != 'O':
                return
            
            # 当确认为未标记的，并与边界 'O' 直接间接相连的 'O' 时，标记为 'M'
            board[i][j] = 'M'
            # 向四个方位扩散
            # 上下左右
            dfs(board, i-1, j)
            dfs(board, i+1, j)
            dfs(board, i, j-1)
            dfs(board, i, j+1)
            

        m = len(board)
        n = len(board[0])

        # 从边界的 'O' 开始搜索
        for i in range(m):
            for j in range(n):
                # 先确认 i，j 是否处于边界
                is_frontier = (i == 0 or j == 0 or i == m-1 or j == n-1)
                if is_frontier and board[i][j] == 'O':
                    dfs(board, i, j)
        
        # 遍历二维数组，将被标记为 'M' 的重新转换为 'O'，未标记的，则转换为 'X'
        for i in range(m):
            for j in range(n):
                if board[i][j] == 'O':
                    board[i][j] = 'X'
                if board[i][j] == 'M':
                    board[i][j] = 'O'

# 广度优先搜索（BFS）
class Solution:
    def solve(self, board: List[List[str]]) -> None:
        """
        Do not return anything, modify board in-place instead.
        """
        if not board or len(board) == 0:
            return
        
        m = len(board)
        n = len(board[0])

        from collections import deque
        queue = deque()

        # bfs 不同于 dfs 顺着满足条件的方向继续搜索
        # bfs 满足条件的都要入队列
        # 先将边界的 'O' 入队
        for i in range(m):
            # 这里是二维矩阵的最左列与最右列
            if board[i][0] == 'O':
                queue.append((i, 0))
            if board[i][n-1] == 'O':
                queue.append((i, n-1))
        
        for j in range(n):
            # 这里是二维矩阵的第一行和最后一行
            if board[0][j] == 'O':
                queue.append((0, j))
            if board[m-1][j] == 'O':
                queue.append((m-1, j))
        
        # 现在开始出队，目前里面的都是边界的 'O'
        # 出队的同时，进行标记，同时查找与边界 'O' 相连的部分入队
        while queue:
            x, y = queue.popleft()
            board[x][y] = 'M'
            # 查找相连部分
            for nx, ny in [(x-1, y), (x+1, y), (x, y-1), (x, y+1)]:
                if 0 <= nx < m and 0 <= ny < n and board[nx][ny] == 'O':
                    queue.append((nx, ny))
        
        # 同样的，标记完后，遍历整个二维矩阵，进行转换
        for i in range(m):
            for j in range(n):
                if board[i][j] == 'O':
                    board[i][j] = 'X'
                if board[i][j] == 'M':
                    board[i][j] = 'O'

剑指 Offer 32 - III. 从上到下打印二叉树 III

class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root: return []
        from collections import deque
        res, queue = [], deque()
        queue.append(root)
        while queue:
            tmp = []
            for _ in range(len(queue)):
                p = queue.popleft()
                tmp.append(p.val)
                if p.left: 
                	queue.append(p.left)
                if p.right: 
                	queue.append(p.right)
            res.append(tmp[::-1] if len(res) % 2 else tmp)
        return res