add new solutions

Author: DSXiangLi

script/[1047]删除字符串中的所有相邻重复项.py

@@ -0,0 +1,40 @@
+# 给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。 
+# 
+#  在 S 上反复执行重复项删除操作，直到无法继续删除。 
+# 
+#  在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。 
+# 
+#  
+# 
+#  示例： 
+# 
+#  输入："abbaca"
+# 输出："ca"
+# 解释：
+# 例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又
+# 只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  1 <= S.length <= 20000 
+#  S 仅由小写英文字母组成。 
+#  
+#  Related Topics 栈 字符串 
+#  👍 410 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def removeDuplicates(self, s: str) -> str:
+        stack = []
+        for i in s:
+            if stack and stack[-1]==i:
+                stack.pop()
+            else:
+                stack.append(i)
+        return ''.join(stack)
+# leetcode submit region end(Prohibit modification and deletion)

script/[130]被围绕的区域.py

@@ -0,0 +1,72 @@
+# 给你一个 m x n 的矩阵 board ，由若干字符 'X' 和 'O' ，找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充
+# 。
+#  
+#  
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 输入：board = [["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'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 输入：board = [["X"]]
+# 输出：[["X"]]
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  m == board.length 
+#  n == board[i].length 
+#  1 <= m, n <= 200 
+#  board[i][j] 为 'X' 或 'O' 
+#  
+#  
+#  
+#  Related Topics 深度优先搜索 广度优先搜索 并查集 数组 矩阵 
+#  👍 830 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+class Solution:
+    def solve(self, board: List[List[str]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+        nrow = len(board)
+        ncol = len(board[0])
+        stack = []
+        for i in range(ncol):
+            if board[0][i] == 'O':
+                stack.append((0, i))
+            if board[nrow - 1][i] == 'O':
+                stack.append((nrow - 1, i))
+        for i in range(nrow):
+            if board[i][0] == 'O':
+                stack.append((i, 0))
+            if board[i][ncol - 1] == 'O':
+                stack.append(((i, ncol - 1)))
+        while stack:
+            node = stack.pop()
+            board[node[0]][node[1]] = 'M'
+            for nr,nc in [(node[0]+1, node[1]),(node[0]-1,node[1]), (node[0],node[1]+1), (node[0],node[1]-1)]:
+                if nr < nrow and nr>=0 and nc<ncol and nc>=0 and board[nr][nc]=='O':
+                    stack.append((nr,nc))
+
+        for i in range(nrow):
+            for j in range(ncol):
+                if board[i][j] =='M':
+                    board[i][j] = 'O'
+                elif board[i][j]=='O':
+                    board[i][j] = 'X'
+# leetcode submit region end(Prohibit modification and deletion)

script/[138]复制带随机指针的链表.py

@@ -0,0 +1,89 @@
+# 给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。 
+# 
+#  构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 
+# 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。 
+# 
+#  例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random 
+# --> y 。 
+# 
+#  返回复制链表的头节点。 
+# 
+#  用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示： 
+# 
+#  
+#  val：一个表示 Node.val 的整数。 
+#  random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。 
+#  
+# 
+#  你的代码 只 接受原链表的头节点 head 作为传入参数。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 
+#  
+# 输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
+# 输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 
+#  
+# 输入：head = [[1,1],[2,1]]
+# 输出：[[1,1],[2,1]]
+#  
+# 
+#  示例 3： 
+# 
+#  
+# 
+#  
+# 输入：head = [[3,null],[3,0],[3,null]]
+# 输出：[[3,null],[3,0],[3,null]]
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  0 <= n <= 1000 
+#  -104 <= Node.val <= 104 
+#  Node.random 为 null 或指向链表中的节点。 
+#  
+#  Related Topics 哈希表 链表 
+#  👍 944 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+"""
+# Definition for a Node.
+class Node:
+    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+"""
+
+class Solution:
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        hash = dict()
+        ptr = head
+        while ptr:
+            hash[ptr] = ListNode(ptr.val)
+            ptr = ptr.next
+        ptr = head
+        hash[None] = None
+        while ptr:
+            hash[ptr].next = hash[ptr.next]
+            hash[ptr].random = hash[ptr.random]
+            ptr = ptr.next
+        return hash[head]
+
+
+        
+# leetcode submit region end(Prohibit modification and deletion)

script/[141]环形链表.py

@@ -0,0 +1,74 @@
+# 给你一个链表的头节点 head ，判断链表中是否有环。 
+# 
+#  如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到
+# 链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。 
+# 
+#  如果链表中存在环 ，则返回 true 。 否则，返回 false 。 
+# 
+#  
+# 
+#  示例 1： 
+# 
+#  
+# 
+#  
+# 输入：head = [3,2,0,-4], pos = 1
+# 输出：true
+# 解释：链表中有一个环，其尾部连接到第二个节点。
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 
+#  
+# 输入：head = [1,2], pos = 0
+# 输出：true
+# 解释：链表中有一个环，其尾部连接到第一个节点。
+#  
+# 
+#  示例 3： 
+# 
+#  
+# 
+#  
+# 输入：head = [1], pos = -1
+# 输出：false
+# 解释：链表中没有环。
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  链表中节点的数目范围是 [0, 104] 
+#  -105 <= Node.val <= 105 
+#  pos 为 -1 或者链表中的一个 有效索引 。 
+#  
+# 
+#  
+# 
+#  进阶：你能用 O(1)（即，常量）内存解决此问题吗？ 
+#  Related Topics 哈希表 链表 双指针 
+#  👍 1553 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        fast, slow = head, head
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+            if slow==fast:
+                return True
+        return False
+        
+# leetcode submit region end(Prohibit modification and deletion)

script/[142]环形链表 II.py

@@ -0,0 +1,81 @@
+# 给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 
+# 
+#  如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到
+# 链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 
+# 
+#  不允许修改 链表。 
+# 
+#  
+#  
+# 
+#
+
+# 
+#  示例 1： 
+# 
+#  
+# 
+#  
+# 输入：head = [3,2,0,-4], pos = 1
+# 输出：返回索引为 1 的链表节点
+# 解释：链表中有一个环，其尾部连接到第二个节点。
+#  
+# 
+#  示例 2： 
+# 
+#  
+# 
+#  
+# 输入：head = [1,2], pos = 0
+# 输出：返回索引为 0 的链表节点
+# 解释：链表中有一个环，其尾部连接到第一个节点。
+#  
+# 
+#  示例 3： 
+# 
+#  
+# 
+#  
+# 输入：head = [1], pos = -1
+# 输出：返回 null
+# 解释：链表中没有环。
+#  
+# 
+#  
+# 
+#  提示： 
+# 
+#  
+#  链表中节点的数目范围在范围 [0, 104] 内 
+#  -105 <= Node.val <= 105 
+#  pos 的值为 -1 或者链表中的一个有效索引 
+#  
+# 
+#  
+# 
+#  进阶：你是否可以使用 O(1) 空间解决此题？ 
+#  Related Topics 哈希表 链表 双指针 
+#  👍 1685 👎 0
+
+
+# leetcode submit region begin(Prohibit modification and deletion)
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    def detectCycle(self, head: ListNode) -> ListNode:
+        slow, fast = head,head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+            if slow == fast:
+                fast = head
+                while slow!=fast:
+                    slow = slow.next
+                    fast = fast.next
+                return slow
+        return None
+# leetcode submit region end(Prohibit modification and deletion)