Leetocde 算法提交

Author: Mr-wang-1

Leetcode121.py

@@ -0,0 +1,10 @@
+class Solution:
+    def maxProfit(self, prices):
+        res = 0
+        minValue = float("inf")
+        for i in range(len(prices)):
+            if prices[i] < minValue:        #更新最小值
+                minValue = prices[i]
+            if prices[i] - minValue > res:  #更新最大收益
+                res = prices[i] - minValue
+        return res

Leetcode126.py

@@ -0,0 +1,33 @@
+class Solution:
+    def findLadders(self, beginWord: str, endWord: str, wordList: List[str]) -> List[List[str]]:
+        wordList.append(beginWord)
+        ### 构建具有邻接关系的桶
+        buckets = defaultdict(list)
+        for word in wordList:
+            for i in range(len(beginWord)):
+                match = word[:i] + '_' + word[i+1:]
+                buckets[match].append(word)
+        ##### BFS遍历
+        preWords = defaultdict(list)  # 前溯词列表
+        toSeen = deque([(beginWord, 1)])  # 待遍历词及深度
+        beFound = {beginWord:1}  # 已探测词列表
+        while toSeen:
+            curWord, level = toSeen.popleft()
+            for i in range(len(beginWord)):
+                match = curWord[:i] + '_' + curWord[i+1:]
+                for word in buckets[match]:
+                    if word not in beFound:
+                        beFound[word] = level+1
+                        toSeen.append((word, level+1))
+                    if beFound[word] == level+1:  # 当前深度等于该词首次遍历深度，则仍应加入前溯词列表
+                        preWords[word].append(curWord)
+            if endWord in beFound and level+1 > beFound[endWord]:  # 已搜索到目标词，且完成当前层遍历
+                break
+        #### 列表推导式输出结果
+        if endWord in beFound:
+            res = [[endWord]]
+            while res[0][0] != beginWord:
+                res = [[word] + r for r in res for word in preWords[r[0]]] 
+            return res
+        else:
+            return []

Leetcode129.py

@@ -0,0 +1,20 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution:
+    def sumNumbers(self, root: TreeNode) -> int:
+        res = []
+        def dfs(node):
+            if not node:
+                return None
+            if not node.left and not node.right:
+                res.append(node.val)
+                return
+            dfs(node.left)
+            dfs(node.right)
+        dfs(root)
+        return res

Leetcode13.py

@@ -0,0 +1,12 @@
+class Solution:
+    def romanToInt(self, s: str) -> int:
+        roman_dic = {'I':1, 'V':5, 'X':10, 'L':50, 'C':100, 'D':500, 'M':1000}
+        str_lenth=len(s)
+        res=0
+        for i in range(str_lenth):
+            if i<str_lenth-1 and roman_dic[s[i]]<roman_dic[s[i+1]]:
+                res-=roman_dic[s[i]]
+            else:
+                res+=roman_dic[s[i]]
+        return res
+

Leetcode130.py

@@ -0,0 +1,42 @@
+class Solution:
+    def solve(self, board: List[List[str]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+        if not board or not board[0]:
+            return
+        row = len(board)
+        col = len(board[0])
+
+        def bfs(i, j):
+            from collections import deque
+            queue = deque()
+            queue.appendleft((i, j))
+            while queue:
+                i, j = queue.pop()
+                if 0 <= i < row and 0 <= j < col and board[i][j] == "O":
+                    board[i][j] = "B"
+                    for x, y in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+                        queue.appendleft((i + x, j + y))
+
+        for j in range(col):
+            # 第一行
+            if board[0][j] == "O":
+                bfs(0, j)
+            # 最后一行
+            if board[row - 1][j] == "O":
+                bfs(row - 1, j)
+
+        for i in range(row):
+
+            if board[i][0] == "O":
+                bfs(i, 0)
+            if board[i][col - 1] == "O":
+                bfs(i, col - 1)
+
+        for i in range(row):
+            for j in range(col):
+                if board[i][j] == "O":
+                    board[i][j] = "X"
+                if board[i][j] == "B":
+                    board[i][j] = "O"

Leetcode139.py

@@ -0,0 +1,12 @@
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        dp = [True, s[0] in wordDict]
+        for i in range(1, len(s)):
+            for j in range(i+1):
+                if s[j: i+1] in wordDict and dp[j]:
+                    dp.append(True)
+                    break
+            else:
+                dp.append(False)
+        return dp[-1]
+

Leetcode143.py

@@ -0,0 +1,16 @@
+class Solution:
+    def reorderList(self, head: ListNode) -> None:       
+        if not head or not head.next:
+            return head
+        # 用快慢指针把链表一分为二，前半部分长度 >= 后半部分长度
+        # first 为前半部分的头部，second 为后半部分的头部
+        first = low = fast = head
+        while fast.next and fast.next.next:
+            fast, low = fast.next.next, low.next
+        second, node, low.next, second.next = low.next, low.next.next, None, None
+        # 后半部分逆序
+        while node:
+            node.next, second, node = second, node, node.next
+        # 前后部分交替链接
+        while second:
+            first.next, second.next, first, second = second, first.next, first.next, second.next

Leetcode146.py

@@ -0,0 +1,102 @@
+class ListNode:
+    def __init__(self, key, val):
+        self.key, self.val, self.prev, self.next = key, val, None, None
+
+class MyOrderedDict:
+    """ 哈希表 + 双向链表实现有序字典
+    - 双向链表，记录键值插入顺序
+    - 哈希表，记录键与节点映射关系，以O(1)复杂度查找、删除节点
+    """
+    def __init__(self):
+        self.head, self.tail = ListNode(0, 0), ListNode(0, 0)
+        self.head.next, self.tail.prev = self.tail, self.head
+        self.lookup = {} # 记录键与节点映射关系
+
+    def delete(self, node): # 删除节点
+        self.lookup.pop(node.key)
+        node.prev.next, node.next.prev = node.next, node.prev
+
+    def append(self, node): # 插入节点
+        self.lookup[node.key] = node
+        cur, pre = self.tail, self.tail.prev
+        node.next, node.prev = cur, pre
+        pre.next, cur.prev = node, node
+
+    def move_to_end(self, key):
+        node = self.lookup[key]
+        self.delete(node)
+        self.append(node)
+
+    def pop(self, key):
+        if len(self.lookup) == 0:
+            raise Exception('Empty dict')
+        node = self.lookup[key]
+        self.delete(node)
+        return node.val
+
+    def popitem(self, last=True):
+        if len(self.lookup) == 0:
+            raise Exception('Empty dict')
+
+        if last:
+            node = self.tail.prev
+        else:
+            node = self.head.next
+        self.delete(node)
+        return node.val
+
+    def __len__(self):
+        return len(self.lookup)
+
+    def __contains__(self, key) -> bool:
+        return key in self.lookup
+
+    def __setitem__(self, key: int, value: int) -> None:
+        """ 存在更新，不存在则插入 """
+        if key in self.lookup:
+            self.lookup[key].val = value
+        else:
+            self.append(ListNode(key, value))
+
+    def __getitem__(self, key: int) -> int:
+        """ 存在返回键对应值，否则返回 -1 """
+        if key in self.lookup:
+            return self.lookup[key].val
+        else:
+            return -1
+
+    def get(self, key: int, default=None):
+        if key in self.lookup:
+            return self.lookup[key].val
+        return default
+
+    def __iter__(self):
+        cur = self.head.next
+        while cur != self.tail:
+            yield cur
+            cur = cur.next
+
+    def __str__(self):
+        res = []
+        for node in self:
+            res.append((node.key, node.val))
+        return "MyOrderedDict({})".format(str(res))
+
+class LRUCache:
+    """ 有序字典实现LruCache """
+    def __init__(self, capacity: int):
+        self.lru_cache = MyOrderedDict()
+        self.maxsize = capacity
+
+    def get(self, key: int) -> int:
+        """ 存在key 移动到末尾并返回对应值， 否则返回-1"""
+        if key in self.lru_cache:
+            self.lru_cache.move_to_end(key)
+        return self.lru_cache.get(key, -1)
+
+    def put(self, key: int, value: int) -> None:
+        if key in self.lru_cache:
+            self.lru_cache.pop(key)
+        if len(self.lru_cache) == self.maxsize: # 缓存满
+            self.lru_cache.popitem(last=False)
+        self.lru_cache[key] = value

Leetcode148.py

@@ -0,0 +1,19 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def sortList(self, head: ListNode) -> ListNode:
+        from queue import PriorityQueue
+        ptr = head
+        p_queue = PriorityQueue()
+        while ptr != None:
+            p_queue.put(ptr.val)
+            ptr = ptr.next
+            
+        ptr = head
+        while not p_queue.empty():
+            ptr.val = p_queue.get()
+            ptr = ptr.next
+        return head

Leetcode162.py

@@ -0,0 +1,22 @@
+class Solution:
+    def findPeakElement(self, nums: List[int]) -> int:
+        if len(nums) == 1: return 0
+        left, right = 0, len(nums)-1
+        while left <= right:
+            mid = (left+right) // 2
+            if mid == 0:
+                if nums[mid] > nums[mid+1]:
+                    return mid
+                else:
+                    left = mid+1
+            elif mid == len(nums)-1:
+                if nums[mid] > nums[mid-1]:
+                    return mid
+                else:
+                    right = mid-1
+            elif nums[mid-1] < nums[mid] and nums[mid] > nums[mid+1]:
+                return mid
+            elif nums[mid] > nums[mid-1]:
+                left = mid+1
+            elif nums[mid] < nums[mid-1]:
+                right = mid-1

Leetcode33.py

@@ -0,0 +1,29 @@
+class Solution:
+    def search(self, nums: List[int], target: int) -> int:
+        """用二分法，先判断左右两边哪一边是有序的，再判断是否在有序的列表之内"""
+        if len(nums) <= 0:
+            return -1
+
+        left = 0
+        right = len(nums) - 1
+        while left < right:
+            mid = (right - left) // 2 + left
+            if nums[mid] == target:
+                return mid
+            
+            # 如果中间的值大于最左边的值，说明左边有序
+            if nums[mid] > nums[left]:
+                if nums[left] <= target <= nums[mid]:
+                    right = mid
+                else:
+                    # 这里 +1，因为上面是 <= 符号
+                    left = mid + 1
+            # 否则右边有序
+            else:
+                # 注意：这里必须是 mid+1，因为根据我们的比较方式，mid属于左边的序列
+                if nums[mid+1] <= target <= nums[right]:
+                    left = mid + 1
+                else:
+                    right = mid
+                    
+        return left if nums[left] == target else -1

Leetcode387.py

@@ -0,0 +1,27 @@
+class Solution:
+    def countAndSay(self, n: int) -> str:
+        pre = ''
+        cur = '1'
+
+        # 从第 2 项开始
+        for _ in range(1, n):
+            # 这里注意要将 cur 赋值给 pre
+            # 因为当前项，就是下一项的前一项。有点绕，尝试理解下
+            pre = cur
+            # 这里 cur 初始化为空，重新拼接
+            cur = ''
+            # 定义双指针 start，end
+            start = 0
+            end = 0
+            # 开始遍历前一项，开始描述
+            while end < len(pre):
+                # 统计重复元素的次数，出现不同元素时，停止
+                # 记录出现的次数，
+                while end < len(pre) and pre[start] == pre[end]:
+                    end += 1
+                # 元素出现次数与元素进行拼接
+                cur += str(end-start) + pre[start]
+                # 这里更新 start，开始记录下一个元素
+                start = end
+        
+        return cur

Leetcode44.py

@@ -0,0 +1,35 @@
+from typing import List
+
+
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        def dfs(nums, size, depth, path, used, res):
+            if depth == size:
+                res.append(path)
+                return
+
+            for i in range(size):
+                if not used[i]:
+                    used[i] = True
+                    path.append(nums[i])
+
+                    dfs(nums, size, depth + 1, path, used, res)
+
+                    used[i] = False
+                    path.pop()
+
+        size = len(nums)
+        if len(nums) == 0:
+            return []
+
+        used = [False for _ in range(size)]
+        res = []
+        dfs(nums, size, 0, [], used, res)
+        return res
+
+
+if __name__ == '__main__':
+    nums = [1, 2, 3]
+    solution = Solution()
+    res = solution.permute(nums)
+    print(res)