leedcode

栈

496. 下一个更大元素 I

题目描述
给定两个没有重复元素的数组 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每个元素在 nums2 中的下一个比其大的值。

nums1 中数字 x 的下一个更大元素是指 x 在 nums2 中对应位置的右边的第一个比 x 大的元素。如果不存在，对应位置输出-1。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/next-greater-element-i
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解题思路

1. 暴力算法
   复杂度$O(n^2)$
2. 通过Stack、HashMap解决
   复杂度$O(n)$
   1、先遍历大数组nums2，首先将第一个元素入栈；
   2、继续遍历，当当前元素小于栈顶元素时，继续将它入栈；当当前元素大于栈顶元素时，栈顶元素出栈，此时应将该出栈的元素与当前元素形成key-value键值对，存入HashMap中；
   3、当遍历完nums2后，得到nums2中元素所对应的下一个更大元素的hash表；
   4、遍历nums1的元素在hashMap中去查找‘下一个更大元素’，当找不到时则为-1。

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        stack = []
        hash_highernumber = {}
        for num2 in nums2:
            while stack and num2>stack[-1]:
                hash_highernumber[stack[-1]]=num2
                stack.pop()
            stack.append(num2)

        return [hash_highernumber.get(num1, -1) for num1 in nums1]

1021. 删除最外层的括号

题目描述
有效括号字符串为空 ("")、"(" + A + “)” 或 A + B，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。例如，""，"()"，"(())()" 和 “(()(()))” 都是有效的括号字符串。

如果有效字符串 S 非空，且不存在将其拆分为 S = A+B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。

给出一个非空有效字符串 S，考虑将其进行原语化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。

对 S 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 S 。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-outermost-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解题思路

1. stack

class Solution:
    def removeOuterParentheses(self, S: str) -> str:
        stack = []
        temp = []
        res = []
        for char in S:
            if char == "(":
                stack.append(")")
            else:
                stack.pop()
            temp.append(char)
            if not stack:
                res.extend(temp[1:-1])
                temp.clear()
        return "".join(res)

2. 不使用stack，理念相同

class Solution:
    def removeOuterParentheses(self, S: str) -> str:
        count = 0
        res = []
        for char in S:
            if char == "(":
                if count > 0:
                    res.append(char)
                count += 1   
            else:
                count -= 1
                if count > 0:
                    res.append(char)

        return "".join(res)

1047. 删除字符串中的所有相邻重复项

题目描述
给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例
输入：“abbaca”
输出：“ca”
输入：“aaaaaaa”
输出：“a”
输入：“aaaaaa”
输出：“a”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-all-adjacent-duplicates-in-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解题思路

class Solution:
    def removeDuplicates(self, S: str) -> str:
        stack = []
        for char in S:
            if not stack or stack[-1]!=char:
                stack.append(char)
            else:
                stack.pop()

        return "".join(stack)

堆

import heapq
nums = [1,3,52,5,2,45,45]
heap = heapq.nlargest(4, nums)
print(type(heap)) # list

heapq.heapify(heap) #建立heap , heap=[5, 45, 45, 52]
heapq.heappush(heap, 3) #[3, 5, 45, 52, 45]
heapq.heappop(heap) #[5, 45, 45, 52]
heapq.heapreplace(heap, 6) #[6, 45, 45, 52]
heap[0] #6

队列

from collection import deque # 双端队列
queue = deque()
queue.popleft()
queue.append()

import queue
queue1 = queue.Queue() # FIFO
queue2 = queue.LifoQueue() # LIFO
queue2 = queue.PriorityQueue() # 

字符串

图

1042、不邻接植花

题目描述
有 N 个花园，按从 1 到 N 标记。在每个花园中，你打算种下四种花之一。

paths[i] = [x, y] 描述了花园 x 到花园 y 的双向路径。

另外，没有花园有 3 条以上的路径可以进入或者离开。

你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。

以数组形式返回选择的方案作为答案 answer，其中 answer[i] 为在第 (i+1) 个花园中种植的花的种类。花的种类用 1, 2, 3, 4 表示。保证存在答案。
示例
输入：N = 4, paths = [[1,2],[2,3],[3,4],[4,1],[1,3],[2,4]]
输出：[1,2,3,4]
解题思路

• 首先用邻接表path_map构建地图，这里采用的是列表中的下表表示花园，列表中的元素还是列表，表示和这个列表相连接的花园。
• res存放结果，下标是花园，值是花的种类。
• 从花园1开始为每个花园种花，在当前花园i中，与它相邻的花园中编号i大的先不用管，该花园还没有种花；对于编号比i小的花园，需要将他们中的花的种类放到s中，因为与i相连的花园可能种相同的花。
• 最后从1到4开始遍历，花园i就种植不在s中的最小的数字。

class Solution:
    def gardenNoAdj(self, N: int, paths):
        # 构建地图
        path_map = [[] for _ in range(N+1)]
        for num in paths:
            path_map[num[0]].append(num[1])
            path_map[num[1]].append(num[0])

        res = [0 for _ in range(N+1)]
        s = set()  # 存储该花园相邻的花园种植的花
        for i in range(1, N + 1):
            s.clear()
            # 收集已经种植的邻接花园的花
            for j in path_map[i]:
                if j < i:
                    s.add(res[j])  
            #最后从1到4开始遍历，花园i就种植不在s中的最小的数字。
            for c in range(1, 5):
                if c not in s:
                    res[i] = c
                    break
        return res[1:]

广度优先搜索算法BFS

107、二叉树的层次遍历 II

给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution:
    def levelOrderBottom(self, root: TreeNode) -> List[List[int]]:
        if not root:
            return []
        res = []
        cur_layer_tree = [root]
        while cur_layer_tree:
            current_layer_val = []
            next_layer_tree = []
            for node in cur_layer_tree:
                if node:
                    current_layer_val.append(node.val)
                    next_layer_tree.extend([node.left, node.right])
            if current_layer_val:
                res.append(current_layer_val)
            cur_layer_tree = next_layer_tree
        return res[::-1]

DFS

993. 二叉树的堂兄弟节点

在二叉树中，根节点位于深度 0 处，每个深度为 k 的节点的子节点位于深度 k+1 处。

如果二叉树的两个节点深度相同，但父节点不同，则它们是一对堂兄弟节点。

我们给出了具有唯一值的二叉树的根节点 root，以及树中两个不同节点的值 x 和 y。

只有与值 x 和 y 对应的节点是堂兄弟节点时，才返回 true。否则，返回 false。。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isCousins(self, root: TreeNode, x: int, y: int) -> bool:
        # 使用列表作为栈
        self.x = x
        self.y = y
        self.visited = set([None])
        self.parent = {root:None}
        self.depth = {root:0}
        self.dfs(root)
        return self.depth[self.node_x]==self.depth[self.node_y] and self.parent[self.node_x]!=self.parent[self.node_y]
    def dfs(self,root):
        if root.val==self.x:
            self.node_x = root
        if root.val==self.y:
            self.node_y = root
        self.visited.add(root)
        for n in [root.left, root.right]:
            if not n in self.visited:
                self.depth[n]=self.depth[root]+1
                self.parent[n]=root
                self.dfs(n)
                if n.val==self.x:
                    self.node_x = n
                if n.val==self.y:
                    self.node_y = n

AVL V.S. RB-Tree

问题描述
RB-Tree和AVL树作为BBST，其实现的算法时间复杂度相同，AVL作为最先提出的BBST，貌似RB-tree实现的功能都可以用AVL树是代替，那么为什么还需要引入RB-Tree呢？
回答

1. RB-Tree不追求"完全平衡"，即不像AVL那样要求节点的 |balFact| <= 1，它只要求部分达到平衡，但是提出了为节点增加颜色，RB-Tree是用非严格的平衡来换取增删节点时候旋转次数的降低，任何不平衡都会在三次旋转之内解决，而AVL是严格平衡树，因此在增加或者删除节点的时候，根据不同情况，旋转的次数比红黑树要多。
2. 插入节点导致树失衡的情况，AVL和RB-Tree都是最多两次树旋转来实现复衡rebalance，旋转的量级是O(1)
   删除节点导致树失衡的情况，AVL需要维护从被删除节点到根节点root这条路径上所有节点的平衡，旋转的量级为O(logN)，而RB-Tree最多只需要旋转3次实现复衡，只需O(1)，所以说RB-Tree删除节点的rebalance的效率更高，开销更小！
   搜索节点导致树失衡的情况， AVL的结构相较于RB-Tree更为平衡，因此AVL的Search效率更高啦。RB-Tree的查询性能略微逊色于AVL树，因为其比AVL树会稍微不平衡最多一层，也就是说RB-Tree的查询性能只比相同内容的AVL树最多多一次比较。
3. 针对插入和删除节点导致失衡后的rebalance操作，RB-Tree能够提供一个比较"便宜"的解决方案，降低开销，是对search，insert ，以及delete效率的折衷，总体来说，RB-Tree的统计性能高于AVL ，故引入RB-Tree是功能、性能、空间开销的折中结果。
   • AVL更平衡，结构上更加直观，时间效能针对读取而言更高；维护稍慢，空间开销较大。
   • RB-Tree，读取略逊于AVL，维护强于AVL，空间开销与AVL类似，内容极多时略优于AVL，维护优于AVL。
4. 若搜索的次数远远大于插入和删除，那么选择AVL，如果搜索，插入删除次数几乎差不多，应该选择RB-Tree

动态规划

121. 买卖股票的最佳时机

题目描述
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
注意你不能在买入股票前卖出股票。
示例
示例 1:
输入: [7,1,5,3,6,4]
输出: 5

示例 2:
输入: [7,6,4,3,1]
输出: 0

class Solution:
    def maxProfit(self, prices: List[int]) -> int:        
        res = 0
        low = prices[0]
        for i in prices:
            low = min(low, i)
            res = max(res, i-low)
        return res     

746. 使用最小花费爬楼梯

题目描述
数组的每个索引做为一个阶梯，第 i个阶梯对应着一个非负数的体力花费值 costi。

每当你爬上一个阶梯你都要花费对应的体力花费值，然后你可以选择继续爬一个阶梯或者爬两个阶梯。

您需要找到达到楼层顶部的最低花费。在开始时，你可以选择从索引为 0 或 1 的元素作为初始阶梯
示例
示例 1:
输入: cost = [10, 15, 20]
输出: 15

示例 2:
输入: cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
输出: 6

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        if not cost:
            return 0
        length = len(cost)
        for i in range(2, length):
            cost[i] += min(cost[i-1], cost[i-2])
        return min(cost[length-1], cost[length-2])

1025、除数博弈

题目描述
爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。

最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作：

选出任一 x，满足 0 < x < N 且 N % x == 0 。
用 N - x 替换黑板上的数字 N 。
如果玩家无法执行这些操作，就会输掉游戏。

只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 false。假设两个玩家都以最佳状态参与游戏
示例
示例 1：
输入：2
输出：true
解释：爱丽丝选择 1，鲍勃无法进行操作。

示例 2：
输入：3
输出：false
解释：爱丽丝选择 1，鲍勃也选择 1，然后爱丽丝无法进行操作。

class Solution:
    def divisorGame(self, N: int) -> bool:
        return N%2==0