713 - LeetCode Queue 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

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

暴力解的版本，會在每次的 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

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

算法說明

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

input handling

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

Boundary conditions

用 for 控制範圍

Reference

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

【Lintcode】python - [642] Moving Average from Data Stream 個人解法筆記

Fri, 29 Apr 2022 03:51:44 +0800

題目出處

642 · Moving Average from Data Stream

難度

easy

題目分類

Array, Design, Queue, Data Stream

2022-04-29 一刷

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

class MovingAverage(object):
    """
    @param: size: An integer
    """
    def __init__(self, size):
        # do intialization if necessary
        self.size = size
        self.queue = collections.deque([])
        self.sum = 0.0

    """
    @param: val: An integer
    @return:  
    """
    def next(self, val):
        # write your code here
        self.queue.append(val)
        self.sum += val
        if len(self.queue) > self.size:
            self.sum -= self.queue.popleft()
        return self.sum/len(self.queue)

# Your MovingAverage object will be instantiated and called as such
# obj = MovingAverage(size)
# param = obj.next(val)

算法說明

Data Stream 的題型，基本上看到 data stream 就要先有意識到，
現在我們要設計的是一個「動態」的數據結構，
也就是說輸入的資料不會是「一次性的」，而是「連續性的」

有這個概念之後我們就可以開始來設計了，
這題還算簡單，不需要講太多

最近在練習程式碼本身就可以自解釋的 Coding style，可以嘗試直接閱讀程式碼理解

input handling

x (題目沒有特別要求)

Boundary conditions

因為不是一次性操作，因此沒有邊界限制，
而動態的操作要注意「允許儲存的上限 = size」

Reference

数据流滑动窗口平均值 · Moving Average from Data Stream

【Leetcode】python - [232] Implement Queue using Stacks 個人筆記

Wed, 09 Mar 2022 14:47:36 +0800

題目出處

232. Implement Queue using Stacks

難度

easy

題目分類

Stack, Design, Queue

2022-03-09 一刷

個人筆記

這篇比較偏程式架構設計，我專注在分析答案，就不特別解。

算法說明

「兩個 Stack 可以拼出一個 Queue」，
對於這個問題我們可以這樣想，
Stack 作為 FILO 的資料結構，先進入的資料會放在底層
而當有兩個 Stack，FILO，再一次 FILO (此時位於底層的資料，就會被拿上來到頂層)，
總合起來就會得到 FIFO 了！

研究別人的解法

這裡我研究的解法是：Share my python solution (32ms)

class MyQueue:
    def __init__(self):
        self.inStack = []
        self.outStack = []

    def push(self, x):
        while self.outStack:
            self.inStack.append(self.outStack.pop())
        self.outStack.append(x)
        while self.inStack:
            self.outStack.append(self.inStack.pop())

    def pop(self):
        return self.outStack.pop()

    def peek(self):
        return self.outStack[-1]

    def empty(self):
        return (not self.outStack and not self.inStack)


# Your MyQueue object will be instantiated and called as such
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

初始化就是兩個 Stack，分成 in, out 兩組，
「記得我們的大概念就是要兩個 FILO + FILO = FIFO」

init：初始化兩組 inStack, outStack
push：放一個資料進入 inStack
pop：從 outStack 拿出一筆資料，在這之前應該會需要經過把 inStack 的資料全部以 FILO 放入 outStack
peek：與 pop 類似，但 pop 會需要回傳並刪除 Queue 中的內容，而 peek 只是我們想看看即將被 pop 的項目是什麼，而不做 pop 的動作。
empty：我們需要同時檢查 inStack, outStack 是否為空

移動過程：作為移動 inStack 的資料內容至 outStack 的內容使用，這裡有個重點「outStack此時必須為空」，因為我們可以將每次的 move 視為一組，而當這組的 Queue 順序順利清空前，「不能」再放新資料進去，否則會造成順序錯誤。

圖例

下圖我們做的步驟是

先放入 123
準備拿出 123，但沒一次全拿
放入 456

準備繼續拿出數字，這時我們會發現不能先移動 456，順序會亂掉，需要等待前一組「123」全部都移除完才能夠進行再次移動下一組的動作。

Reference

Share my python solution (32ms)

【Leetcode】python - [387] First Unique Character in a String 個人解法筆記

Sat, 05 Mar 2022 18:21:11 +0800

題目出處

387. First Unique Character in a String

難度

easy

題目分類

Hash Table, String, Queue, Counting

2022-03-05 一刷

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

class Solution:
    def firstUniqChar(self, s: str) -> int:
        worddict = Counter(s)
        for idx, ele in enumerate(s):
            if worddict[ele] >= 2: # has duplicate
                pass
            else:  # no duplicate
                return idx

        return -1

Time Complexity

O(n)

Space Complexity

算法說明

透過 Counter 快速完成計算數量，
只要 Counter 計算出數量大於 2 的結果，
直接回傳最早的答案。

corner case 特殊情況處理

Boundary conditions/ Edge conditions 邊際情況處理

沒有答案時，要回傳 -1