714 - LeetCode Heap on 嗡嗡的隨手筆記

【Leetcode】python - [239] Sliding Window Maximum 個人解法筆記

Tue, 21 Jun 2022 18:51:23 +0800

題目出處

239. Sliding Window Maximum

難度

hard

題目分類

Array, Queue, Sliding Window, Heap (Priority Queue), Monotonic Queue

2022-06-21 一刷

個人範例程式碼

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if len(nums) < k:
            return []

        queue_idx = []
        ans = []

        # 1. if i-k == queue_idx[0] (3-3 = 0) oversize, pop oldest (0)
        # 2. if +1 nums[queue_idx[-1]] < num, remove smaller
        # 3. append new element
        # 4. nums[queue_idx[0]] will be max

        for i, num in enumerate(nums):
            # 1. if i-k == queue_idx[0] (3-3 = 0) oversize, pop oldest (0)
            if queue_idx and i - k == queue_idx[0]:
                queue_idx.pop(0)

            # 2. if +1 nums[queue_idx[-1]] < num, remove smaller
            while queue_idx and nums[queue_idx[-1]] < num:
                queue_idx.pop(-1)

            # 3. append new element
            queue_idx.append(i)

            # 4. nums[queue_idx[0]] will be max
            if i+1 >= k: # 2+1 >= 3
                ans.append(nums[queue_idx[0]])    

        return ans

算法說明

暴力解的版本，會在每次的 find max 花太多時間，
而我們會發現，sliding window 的特性，我們應該可以達成最小化的重複性更改。

基本上我們可以拆成四大步驟：

queue_idx[0] (3-3 = 0) oversize, pop oldest (0)

input handling

如果 len(nums) < k，則不可能組出 window。

Boundary conditions

用 for 控制範圍

個人範例程式碼 - 暴力解，會 TLE

class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        if len(nums) < k:
            return []

        ans = []
        slow, fast = 0, k    
        counter = defaultdict(int)
        # init counter
        for i in range(k):
            counter[nums[i]] += 1
        ans.append(self.get_counter_max(counter))

        # sliding window
        while fast < len(nums):
            counter[nums[slow]] -= 1 
            counter[nums[fast]] += 1
            ans.append(self.get_counter_max(counter))
            slow += 1 
            fast += 1

        return ans

    # O(n), if sorting O(nlogn)        
    def get_counter_max(self, counter):
        get_max = float("-inf")
        for key in counter.keys():
            if counter[key] > 0:
                get_max = max(get_max, key)

        return get_max

算法說明

暴力解的版本，最主要花時間的地方在於找最大，
如果使用 sorting 會是 O(nlogn)，單一次遍歷找最大會是 O(n)，
結合最外層的 sliding window 移動則會是 O(n^2)，
也還是會 TLE，需要另外想更快的辦法了。

input handling

如果 len(nums) < k，則不可能組出 window。

Boundary conditions

用 for 控制範圍

Reference

滑动窗口的最大值 · Sliding Window Maximum

【Leetcode】python - [621] Task Scheduler 個人解法筆記

Fri, 17 Jun 2022 17:19:38 +0800

題目出處

621. Task Scheduler

難度

medium

題目分類

Array, Hash Table, Greedy, Sorting, Heap (Priority Queue), Counting

2022-06-17 一刷

個人範例程式碼 - 一刷 (2022/06/17)

class Solution:
    def leastInterval(self, tasks: List[str], n: int) -> int:
        counter = Counter(tasks)
        collect_counts = sorted(counter.values(), reverse = True)

        # same_max_length + (max_count-1) * (1+n)
        same_max_length = collect_counts.count(collect_counts[0])
        max_length = same_max_length + (collect_counts[0] - 1) * (n + 1)

        return max(max_length, len(tasks)) # min length

算法說明

這題的答案可以直接用數學公式導出來，個人認為對面試準備的幫助比較不大。

分析答案的分佈，我們可以知道「最大數量對於結果有一定程度的影響」，
而繼續往下推，我們可以知道最小長度等於 = 「同樣的最大數量」+ 「(n+1) * (最大數量 -1)」

不懂在說什麼的話，就看下圖吧：

input handling

Boundary conditions

直接數學運算出來

Reference

任务计划 · Task Scheduler

【Leetcode】python - [692] Top K Frequent Words 個人解法筆記 | 內含自定義排序 key function 的使用方法

Fri, 10 Jun 2022 02:00:44 +0800

題目出處

692. Top K Frequent Words

難度

medium

題目分類

Array, Hash Table, String, Trie, Sorting, Heap (Priority Queue), Bucket Sort, Counting

2022-06-10 一刷

個人範例程式碼 - 單 hashtable + 自定義排序 key function

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        word_to_counter = defaultdict(int)
        counter_to_word = defaultdict(list)

        # O(N)
        for word in words: 
            word_to_counter[word] += 1

        word_list = [(word, cnt) for word, cnt in word_to_counter.items()]
        word_list.sort(key = self.key_function)

        return [word_list[i][0] for i in range(k)]

    def key_function(self, word_tuple):
        # first compare: cnt (biggest need first, so we use -cnt: 4, 5 -> -5, -4)         
        # second compare: word alphabetically first (lexicographical)
        word, cnt = word_tuple
        return (-cnt, word)

return 那行使用的 list comprehension，同義於下方程式碼

return 那行優化後，我才寫成上面一行的形式，
原本的內容長下面那樣，
基本上面試時，建議以自己較能掌握的穩定寫法為主。

ans = []
for i in range(k):    
    ans.append(word_list[i][0])

return ans

算法說明

另外一個方法是我們一樣用 hashtable 先把所有數量都數出來，
可以想像做我們把所有的 word 變成 (word, count) 的形式，
再來我們要使用自定義排序，排成我們要的順序。

自定義排序 key function

一般來說，sort 都是幫我們單純直接照「數字大小排序」或是「照字母大小排序」，
但在這題目當中，我們需要同時「先考慮數字大小，再考慮字母順序」，
因此這樣的情況我們需要去特別定義排序的規則。

我們可以自己寫一個 key_fuction 給 key 去使用，
回傳一個 tuple 給 key 參考，
依照 tuple 的順序，就是我們比較的順序。

依照題目要的，數量越大的排序要越前面，因此我們排序結果應該要是
「5,4,3,2,1」(反序)，再來「照字母順序 a,b,c 排」(升序)
相對簡單的處理方式是，我們就直接讓數字前面加一個「負號」，
這樣「-5,-4,-3,-2,-1」就是升序的排列了!

因此我們回傳 (-cnt, word) 作為我們排序的依據。

word_list.sort(key = self.key_function)

def key_function(self, word_tuple):
    # first compare: cnt (biggest need first, so we use -cnt: 4, 5 -> -5, -4)
    # second compare: word alphabetically first (lexicographical)
    word, cnt = word_tuple
    return (-cnt, word)

input handling

Boundary conditions

用 for 來控制範圍

個人範例程式碼 - 雙 hashtable 紀錄 word_to_counter, counter_to_word

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        word_to_counter = defaultdict(int)
        counter_to_word = defaultdict(list)

        # O(N)
        for word in words: 
            word_to_counter[word] += 1

            current_word_count = word_to_counter[word]
            if current_word_count > 1: # existed word
                counter_to_word[current_word_count-1].remove(word)
            counter_to_word[current_word_count].append(word)

        # O(nlogN)
        counter_keys = sorted(counter_to_word.keys(), reverse=True)

        ans = []
        cnt = 0

        for key in counter_keys:
            if cnt >= k:
                break
            ans += sorted(counter_to_word[key])
            cnt += len(counter_to_word[key])

        return ans[:k]

算法說明

第一次看到這題目，想說都要計數了，然後還要排序，直覺就想說用兩個 hashtable，
分別存 word_to_counter, counter_to_word，
當存到 k 個的時候，就輸出結果。

但我們要注意，這題目有特別說明，取前 k 的時候，「有可能同數量，這時候我們就照字母順序取」

input handling

Boundary conditions

用 for 來控制範圍

Reference

最高频的K个单词 · Top K Frequent Words

【Leetcode】python - [347] Top K Frequent Elements 個人解法筆記

Mon, 06 Jun 2022 04:15:49 +0800

題目出處

347. Top K Frequent Elements

難度

medium

題目分類

Array, Hash Table, Divide and Conquer, Sorting, Heap (Priority Queue), Bucket Sort, Counting, Quickselect

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        if not nums:
            return nums

        # O(N)
        counter = Counter(nums)
        freq_counter = defaultdict(list)

        # O(N)
        for key, value in counter.items():
            freq_counter[value].append(key)

        ans = []
        # O(NlogN)
        for key in sorted(freq_counter.keys(), reverse=True):
            ans += freq_counter[key]
            k -= len(freq_counter[key])
            if k <= 0:
                break

        return ans

直接使用 dict.items() + sorted tuple 排序

更俐落一點的寫法，直接把 dict.items() 轉作 tuple 來看後，直接排序
如果用法不熟，用上面方法即可。

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        if not nums:
            return nums

        # O(N)
        counter = Counter(nums) # key: freq

        # O(NlogN)
        sorted_tuple_by_freq = sorted(counter.items(), key=lambda x: x[1], reverse=True)

        # print(sorted_tuple_by_freq)

        ans = []
        for i in range(k):
            ans.append(sorted_tuple_by_freq[i][0])

        return ans

算法說明

我們先計算數字頻率，可以搭配內建函數 counter 快速實現，
再來針對出現次數進行排序，
然後選出前 K 個答案即可。

input handling

如果沒有 nums，return nums

Boundary conditions

用 for 來控制範圍

Reference

前K个高频元素 · Top K Frequent Elements

【Lintcode】python - [919] Meeting Rooms II 個人解法筆記

Mon, 06 Jun 2022 03:22:51 +0800

題目出處

919 · Meeting Rooms II

難度

medium

題目分類

Array, Two Pointers, Greedy, Sorting, Heap (Priority Queue), Prefix Sum

2022-06-06 一刷

個人範例程式碼 - 一刷 (2022/06/06)

from typing import (
    List,
)
from lintcode import (
    Interval,
)

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: the minimum number of conference rooms required
    """
    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
        # Write your code here
        if not intervals:
            return 0

        time_table = []
        for interval in intervals:
            time_table.append((interval.start, +1))
            time_table.append((interval.end, -1))

        time_table.sort(key=lambda x: x[0])

        ans = 0
        booked_room = 0
        for time, room_used in time_table:
            booked_room += room_used
            ans = max(ans, booked_room)

        return ans

或者，我們也可以用 hashtable 來記錄 (概念相同)

from typing import (
    List,
)
from lintcode import (
    Interval,
)

"""
Definition of Interval:
class Interval(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
"""

class Solution:
    """
    @param intervals: an array of meeting time intervals
    @return: the minimum number of conference rooms required
    """
    def min_meeting_rooms(self, intervals: List[Interval]) -> int:
        # Write your code here
        if not intervals:
            return 0

        time_table = collections.defaultdict(int)
        for interval in intervals:
            time_table[interval.start] += 1
            time_table[interval.end] -= 1


        # print(time_table)

        ans = 0
        used_room = 0
        for time in sorted(time_table.keys()):
            used_room += time_table[time]
            ans = max(ans, used_room)

        return ans

算法說明

這題目有前一題單純只判斷有沒有重複會議室，而這題是要直接計算所需要的會議室數量，上一題可參考：

https://wongwongnotes.com/posts/algorithm-practice/data-structures/python-leetcode/lintcode-python-920/

現在要安排需要的會議室數量，
我們可以直接把所有的時間點 (start, end) 都存入一個 table 裡面，排序後就可以得到我們要的答案。

儲存的方式為 (start_time, +1), (end_time, +1)，
最後我們只要將第一個欄位的 time 排序即可。

之後我們可以再使用 +1, -1 去判斷個時段的會議室增減。

input handling

如果沒有 intervals, 回傳 0 (題目沒特別要求)

Boundary conditions

用 for 迴圈控制範圍

Reference

会议室 II · Meeting Rooms II

【Leetcode】python - [332] Reconstruct Itinerary 個人解法筆記

Mon, 23 May 2022 03:00:14 +0800

題目出處

332. Reconstruct Itinerary

難度

Hard

題目分類

Array, String, Depth-First Search, Graph Theory, Sorting, Heap (Priority Queue), Eulerian Circuit

2022-05-23 一刷

個人範例程式碼 - 一刷 (2022/05/23)

class Solution:
    def findItinerary(self, tickets: List[List[str]]) -> List[str]:
        graph = self.build_graph(tickets)
        self.ans = []
        self.dfs(graph, 'JFK')

        return self.ans[::-1]

    def build_graph(self, tickets):
        graph = collections.defaultdict(list)
        for _from, _to in tickets:
            graph[_from].append(_to)

        for _from in graph:
            graph[_from].sort(reverse = True)
            # dfs get reverse lexical order (since we get ans from end to start)           

        return graph

    def dfs(self, graph, _from):
        # end of recursion, when find no route
        while graph[_from]:
            # define and split
            self.dfs(graph, graph[_from].pop())

        # append ans, from end to start
        self.ans.append(_from)

算法說明

這題要同時考到建構出一個 graph，
並 dfs 找尋路徑。

反向建立 _to 順序，正向 dfs 搜尋

因為題目希望最後我們能夠照字母大小排序，而我們建立 graph 時，
先把「名稱排序比較後面的，放到前面順位」，
這樣「dfs 搜尋時，就會先 pop()」，
而最後「我們在把 from end to start 的路徑倒過來」。

input handling

Boundary conditions

在 graph 與 bfs 中控制搜尋範圍，搜尋完全部 node 就正常結束。
(沒有全部搜尋完，就沒有結果)

Reference

重新安排行程 · Reconstruct Itinerary

【Leetcode】python - [264] Ugly Number II 個人解法筆記

Sat, 30 Apr 2022 01:49:02 +0800

題目出處

264. Ugly Number II

難度

Medium

題目分類

Hash Table, Math, Dynamic Programming, Heap (Priority Queue)

2022-04-30 一刷

個人範例程式碼 - 一刷 (2022/04/30)

class Solution:
    def nthUglyNumber(self, n: int) -> int:
        if not n:
            return -1

        visited = set([1])
        heap = [1]

        for _ in range(n):
            cur = heapq.heappop(heap)
            for factor in [2, 3, 5]:
                new = cur * factor
                if new not in visited:
                    visited.add(new)
                    heapq.heappush(heap, new)

        return cur

算法說明

這裡我們用 minheap 來解，因為要不斷的輸出最小，
透過 minheap 減少我們搜尋的時間。

input handling

如果 input 是 0，return -1 (題目沒有要求要處理)

Boundary conditions

for 迴圈控制數量

Reference

丑数 II · Ugly Number II

【Lintcode】python - [901] Closest Binary Search Tree Value II 個人解法筆記 #綜合難題

Fri, 22 Apr 2022 17:06:02 +0800

題目出處

901 · Closest Binary Search Tree Value II

難度

hard

題目分類

Two Pointers, Stack, Tree, Depth-First Search, Binary Search Tree, Heap (Priority Queue), Binary Tree

2022-04-22 一刷

個人範例程式碼 - 一刷 (2022/04/22)

from typing import (
    List,
)
from lintcode import (
    TreeNode,
)

"""
Definition of TreeNode:
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left, self.right = None, None
"""

class Solution:
    """
    @param root: the given BST
    @param target: the given target
    @param k: the given k
    @return: k values in the BST that are closest to the target
             we will sort your return value in output
    """
    def closest_k_values(self, root: TreeNode, target: float, k: int) -> List[int]:
        if not root or k == 0:
            return []

        # write your code here
        lower_stack = self.get_stack(root, target) # init to found target
        upper_stack = list(lower_stack)

        # delete duplicate closest element, change wrong lower[-1] or upper[-1]
        if lower_stack[-1].val < target:
            self.move_upper(upper_stack)
        else:
            self.move_lower(lower_stack)

        ans = []
        for i in range(k):
            if self.is_lower_closer(lower_stack, upper_stack, target):
                ans.append(lower_stack[-1].val)
                self.move_lower(lower_stack)
            else:
                ans.append(upper_stack[-1].val)
                self.move_upper(upper_stack)
        return ans

    def is_lower_closer(self, lower_stack, upper_stack, target):
        if not lower_stack: # has nothing
            return False
        if not upper_stack:
            return True

        return target - lower_stack[-1].val < upper_stack[-1].val - target

    def move_lower(self, stack):
        if stack[-1].left: # has left, move to the right bottom
            node = stack[-1].left
            while node:
                stack.append(node)
                node = node.right
        else: # no left, move to the first turn right parent
            node = stack.pop()
            while stack and stack[-1].left == node:
                node = stack.pop()

    def move_upper(self, stack):
        if stack[-1].right: # has right, move to the left bottom
            node = stack[-1].right
            while node:
                stack.append(node)
                node = node.left
        else: # no right, move to the first turn left parent
            node = stack.pop()
            while stack and stack[-1].right == node:
                node = stack.pop()

    def get_stack(self, root, target):
        stack = []
        while root:
            stack.append(root)
            if target <= root.val:
                root = root.left
            else:
                root = root.right

        return stack

算法說明

BST iteration 集大成的最難題目，能考的都考了。

這題最難的部分在於實作 iteration (當然，要重新 traverse 絕對是更簡單的方法，不過速度上會慢)，

分成兩種狀況討論：

往更小「一個」移動
往更大「一個」移動

往更小「一個」移動

說到小，就先想到 left

這裡又分成兩種情況，

如果有 left，往 left 的最右底點移動 (才會是「第一個」更小)
如果沒有 left，找第一個 edge 右彎的 parent

看不懂就看下圖可能會比較好懂… 一點點XD

往更大「一個」移動

說到大，就先想到 right

這裡又分成兩種情況，

如果有 right，往 right 的最左底點移動 (才會是「第一個」更大)
如果沒有 right，找第一個 edge 左彎的 parent

看不懂就看下圖可能會比較好懂… 一點點XD

input handling

當 k = 0 或是沒有 root 時，return []

Boundary conditions

見上述說明

Reference

二叉搜索树中最接近的值 II · Closest Binary Search Tree Value II

【演算法筆記 #4】Priority Queue (優先權佇列) 重點整理筆記，包含與常見的 Stack, Queue 的比較

Wed, 13 Apr 2022 13:10:13 +0800

前言

Priority Queue (優先權佇列) 是一種特殊的 Queue，
在特殊題型上會非常實用。

只要牽扯到「優先權」的題目，都非常適合用 Priority Queue 來快速解。

Priority Queue (優先權佇列) 的精神

Priority Queue 當初被設計的時候，就是為了解決重要性問題而設計的 Queue，
他擁有類似 Queue 能「放入任務」、「取出任務」的概念，
不過在「取出任務」的這個部分就不像我們一般認知的那種單純的 Queue。

Priority Queue 依照「重要性」，決定取出的順序，
因此在傳入 Priority Queue 時，我們常會需要「多帶一個能代表重要性的 Key」

範例程式碼

我覺得有時候理解直接閱讀程式碼會比較快啦 XDD

無 key 版本，單純以傳入數字排序

from queue import PriorityQueue

q = PriorityQueue()

q.put(4)
q.put(2)
q.put(5)
q.put(1)
q.put(3)

while not q.empty():
    next_item = q.get()
    print(next_item)

結果

有 key 版本，依照傳入 key 排序

from queue import PriorityQueue

q = PriorityQueue()

q.put((4, 'Read'))
q.put((2, 'Play'))
q.put((5, 'Write'))
q.put((1, 'Code'))
q.put((3, 'Study'))

while not q.empty():
    next_item = q.get()
    print(next_item)

結果

(1, 'Code')
(2, 'Play')
(3, 'Study')
(4, 'Read')
(5, 'Write')

Priority Queue 的底層設計

Priority Queue 是由 Heap 實做的，因此「與 Queue 在放入與取出資料時的時間複雜度並不相同」，
也是因為此原因，通常我不太把 Priority Queue 當 Queue 看，
我倒覺得他更像 Heap。

而因為是 Heap 的原因，
插入與取出的時間複雜度皆為 O(logN)，與 Queue 的 O(1) 也非常不同。

Priority Queue 與 Stack, Queue 比較

這邊我把我腦袋中所想的畫出來

而從上圖我們也可以推論

	insert	delete
Stack	O(1)	O(1)
Queue	O(1)	O(1)
Priority Queue	O(logN)	O(logN)

Reference

【Leetcode】python - [658] Find K Closest Elements 個人解法筆記

Tue, 05 Apr 2022 02:32:16 +0800

題目出處

658. Find K Closest Elements

難度

medium

題目分類

Array, Two Pointers, Binary Search, Sliding Window, Sorting, Heap (Priority Queue)

2022-04-05 一刷

個人範例程式碼 - 一刷 (2022/04/05)

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        start, end = 0, len(arr) - 1
        while(start + 1 < end):
            mid = (start + end) // 2
            if arr[mid] == x: 
                start = mid
            elif arr[mid] < x:
                start = mid
            else: # a[mid] > x
                end = mid
        else:
            return self.find_k_neighbors(arr, x, k, start, end) 


    def find_k_neighbors(self, arr, x, k, start, end):
        # print(start, end)
        ans = []
        while(k > 0):
            if((start >= 0) and (end < len(arr)) and (x - arr[start] <= arr[end] - x)): # smaller first
                ans.append(arr[start])
                start -= 1
            elif((start >= 0) and (end < len(arr)) and (x - arr[start] > arr[end] - x)):
                ans.append(arr[end])
                end += 1
            elif(start < 0):
                ans.append(arr[end])
                end += 1
            else: # end >= len(a)
                ans.append(arr[start])
                start -= 1
            k -= 1
            # print(ans)

        return sorted(ans)

算法說明

方法是一樣 binary search 找到中間後 O(logN)，往兩邊搜尋 K 個 O(K)。 = O(logN+K)

個人覺得這題 LintCode 版本出的比較好，Leetcode 出的版本最後多了一個排序，
只是我覺得光是找最近的 K 的結果就已經找到的關鍵，就不用再排序了!

LintCode 版本的題目：460 · Find K Closest Elements

Leetcode 版本的差別只差在我最後多補了一個 sorted 給他。

input handling

應該要做但我沒做XD，不過題目有保證輸入正確就是

Boundary conditions

binary search 的邊界條件

這裡有兩個 Boundary conditions 要注意，一個是一開始的 binary search 的邊界條件

find K 的邊界條件

另外一個要注意的是在找 K 個鄰近的數值時，我們需要注意「不能找到範圍之外」。

Reference

在排序数组中找最接近的K个数 · Find K Closest Elements