Two Pointer on 跟著 Desolve 學程式

從LeetCode學演算法 - 78 Two Pointer (4) / Binary Search (5)

Sat, 28 Dec 2019 00:00:00 +0800

0392. Is Subsequence (Easy)

Question

Given a string s and a string ** t**, check if ** s** is a subsequence of ** t**.

You may assume that there are only lower case English letters in both s and ** t**. ** t** is potentially a very long (length ~= 500,000) string, and ** s** is a short string (<=100).

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, "ace" is a subsequence of "abcde" while "aec" is not).

Example 1

s = "abc", ** t** = "ahbgdc"

Return true.

Example 2

s = "axc", ** t** = "ahbgdc"

Return false.

Follow up:
If there are lots of incoming S, say S1, S2, … , Sk where k >= 1B, and you want to check one by one to see if T has its subsequence. In this scenario, how would you change your code?

分析/解題

給定一個字串s跟一個字串t，
檢查s是否是t的subsequence(子序列)。可以假設s是一個短字串(長度≤100)且t是一個長字串(長度約500000)。

從原字串t刪除字母(也可以完全不刪)，
並保有原字串的相對位置，所構成的新字串，即為t的子序列。
後面有一個Follow up問的是，
假設這個函式會拿來檢查很多次(k次)不同的S的話(例如會處理1billion次)，
要怎麼實作這個函式比較好？

首先我們先來看看比較直觀的解法。
我們先舉個例子，如果有一個s是”abcde”的話，
s要是t的子序列的條件，就是我們要能在t當中，
依序得到 a~e這五個字母。
那麼第一個我們一定要先找a，假設從t中找到一個a以後，
按照順序的話，這個a以前的bcde就都不能用了 ！
(因為順序就不對啦XD)
同樣的，找到b以後b以前的cde也不能用，以此類推。
因此，我們要保持能確定找到可能性的方式，
就是每一次在t中都取這個順序最前面出現的字母 。

在s當中使用一個記錄index用的i ，
從頭開始找t中的s[i] 在哪，記錄為pre 。
每次找到以後，將i遞增 ，
接下來從t的pre+1處 開始尋找下一個s[i]的位置。
如果找不到的話呢？就表示沒辦法成立，應該回傳false，
否則當全部的s的字母都能找到對應的位置的話，
則代表s可以作為t的子序列。

上面描述這樣的方法，我們使用了兩個索引值，
來記錄s和t當前查找到的位置，
所以這個解法可以視為two pointer手段的一種操作。

同時，我們前面在解的時候，
每次都盡可能 去找最前面出現 的第一個s[i]，
這種概念的想法，僅在特定的題目適用。
當符合在每一個當前狀況都取當前最佳的狀況 ，
全局就會是最佳 的時候，我們就在局部的區段盡可能貪婪。
這樣子的策略被稱為貪婪演算法 (Greedy Algorithm)

請留意到，這種方式往往在很多情況下會失效，
所以在使用前請詳閱公開說明書(X)。
(開玩笑的XD，應該是使用前請確認局部最佳能推導至全局最佳 。)

這麼做基本上要掃過s跟t的字串，所以時間會是O(len(s)+len(t))，
或者說當t遠大於s的時候可以視為O(len(t))。

那麼如果搭配Follow up的條件呢？
如果有k次不同的s的檢查，
就上面的解法而言，每次仍然要各掃過一遍s跟t，
時間複雜度是O(k*(len(s)+len(t))) ，顯然當t很大的時候，
掃過k次是很不理想的，我們會希望能夠化簡一點這個部分。

那要怎麼作呢？這邊引用shuoshankou 在leetcode上的解，
我們可以先針對t建立一個HashMap ，當中的key是t上的字母 ，
而value是這個字母出現在t上面的indices (使用ArrayList來儲存)。
這個儲存過程會是O(len(t)) 。

接著要查找的過程就會變成針對s[i]來搜尋HashMap上的index，
且限定這個index要剛好是在i之後的第一個出現的位置。有沒有覺得很眼熟？沒錯， 這不就是Binary Search嗎？
我們在處理的，就跟對於某個陣列，
搜尋一個值在哪裡(或應插入在哪裡)的問題一樣！

所以就一般來說，搜尋需求是log(N)，
如果前後拆成常數的單位可以忽略不記，
所以對於k個s搜尋所需會是O(k*len(s) * log(len(t))) ，
當k大到一定程度的時候，顯然只作一次O(len(t))先建立對應表，
讓後面的搜尋相關的t的複雜度都變成對數量級 是相當划算的。

注意，以這題的測試資料而言，Binary Search速度並不會跑起來比較漂亮，
原因是測試資料的總數可能相對有限，並不像Follow up假想那樣，
所以前面吃下一整個建立HashMap的時間就會顯得拖累。

Java

Java的部分可以先檢查s和t的長度來避免一些根本不需要跑的狀況，
同時使用indexOf 來搜尋每次的si第一個出現的位置。
(搜尋不到的話indexOf會回傳-1 )

Binary Search的寫法則如註解處，
先建立起HashMap並掃過整個t並依序塞入，
後面再使用getNextIndex來寫Binary Search。
其實如果要能像Follow up那樣反覆利用的話，
應該要能將t的輸入抽離開來，題目的要求和預設寫法並沒有考慮這點，
會導致每次都需要對t建立一個HashMap。

如果要重複利用的話，應該要給定成class Solution的變數，
且建立時能先給入t才對。

Python

Python的部分則使用index 來進行查找，
請留意查找不到的話會產生exception，
所以這邊是使用try/except 來處理的。

面試實際可能會遇到的問題

「時間/空間複雜度？」
(請見上面詳述。)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

感謝大家對這系列文章的支持！這邊跟大家自我工商一下：

筆者開設的系列同名線上課程：
「從Leetcode學演算法｜基礎篇」已經上線啦！ 在這堂課中，你將學會利用十種演算法/資料結構來優化解題過程，
並實際完整練習20題 精選考古題，
進而逐漸提升到不需提示也可以突破白板題，取得工作門票！
Medium優惠(接下來快要漲成下個價格啦XD)： https://hiskio.com/courses/319?promo_code=VEQZV7E

從LeetCode學演算法 - 64 Array (12) / Two Pointer (3)

Tue, 22 Oct 2019 00:00:00 +0800

0080. Remove Duplicates from Sorted Array II (Medium)

Question

Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array ** in-place** with O(1) extra memory.

Example 1

1

Given nums = [1,1,1,2,2,3],

1

Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.

1

It doesn't matter what you leave beyond the returned length.

Example 2

1

Given nums = [0,0,1,1,1,1,2,3,3],

1

Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.

1

It doesn't matter what values are set beyond the returned length.

Clarification:

Confused why the returned value is an integer but your answer is an array?

Note that the input array is passed in by reference , which means modification to the input array will be known to the caller as well.

Internally you can think of this:

1
2


// nums is passed in by reference. (i.e., without making a copy)
int len = removeDuplicates(nums);

1
2
3
4
5


// any modification to nums in your function would be known by the caller.
// using the length returned by your function, it prints the first len elements.
for (int i = 0; i < len; i++) {
 print(nums[i]);
}

分析/解題

給定一個已排序的陣列nums，將其重復超過2次的部分捨棄掉，
且使用in-place的方式來操作(在原陣列操作)，回傳最終結果的長度。

這題算是之前的0083. Remove Duplicates from Sorted List (Easy)的延伸，說真的我認為這題不該當作Medium難度XD

再次提醒，當題目要求使用in-place的時候，
對一些語言的確是可以真的用刪掉單點 的方式來處理(例如Python)，
但刪除這件事情也是較耗時的操作，所以沒特別要求的話，
請依照題目希望你的方向來撰寫(面試則依照面試官的限制條件 )。

我們先來講筆者直觀想到的解法，再來提leetcode上另一位高手的解。

直觀而言，要怎麼能夠知道有沒有碰到3個以上的重復呢？
最直接的方式就是使用一個cnt變數來記錄。
同時，為了要確認是否是重複的數，
我們需要記錄上一次開始重復的數last。

那麼步驟就會像這樣：

如果nums長度 ≤ 2 的話，表示完全不用更動，
直接回傳nums的長度 即可。
將last設為nums[0], cnt設為1, 預計要覆蓋的** index j設為1。**
令i從1開始一個迴圈來遍歷整個nums:
3-a. 如果nums[i]不等於last 的話，表示數字不同 ，
必須將其覆蓋到j的位置 。
同時，我們必須更新last為nums[i]，j要遞增，
cnt要重設為1 (用來做下一次比較)。
3-b. 否則，如果兩者相等且cnt小於2 ，
代表重複未超過2次，同樣要進行複寫和遞增j，但cnt要遞增 。
當整個迴圈完畢以後，j 應該是位在處理過後的陣列的尾端+1 的位置。
所以回傳j即可代表新的陣列的總長 。

聽起來有點多，但其實寫起來並不困難，
但還有更厲害的解法XD

這邊提供了LeetCode上StefanPochmann 的解，
簡單來說呢，我們可以換個思路：
由於整個陣列是排序過的 ，當我們遍歷陣列時，
某個數字應不應該要覆蓋到index上 ，
(筆者之前的解法將這個index叫做j，相當於這個解裡的i)
取決於前面兩個數字是否跟它一樣 ；
都一樣的話，就產生了三個相同的數 的狀況，
自然不需要再被取用，且由於排序的關係，
我們只需要比較前面兩個數字中較前面的那個 即可。

當i小於2時，直接無條件覆蓋( 因為不可能重複超過2次)；
當遍歷到的値n大於num[i-2] 時，代表數字不一樣 或重複未超過2次 ，
則應將其值覆蓋過去並遞增i 。

各自寫成程式碼如下：

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(1)，我們需要遍歷整個陣列，且儲存用的輔助變數只有常數個)

相似及延伸

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~

從LeetCode學演算法 - 58 Two Pointer (2)

Tue, 01 Oct 2019 00:00:00 +0800

0075. Sort Colors (Medium)

(當然，Medium的拍手也可以多拍幾下啦XD)

Question

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not supposed to use the library’s sort function for this problem.

Example:

1
2


Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]

Follow up:

A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0’s, 1’s, and 2’s, then overwrite the array with the total number of 0’s, then 1’s and followed by 2’s.
Could you come up with a one-pass algorithm using only constant space?

分析/解題

給定一個陣列當中有n個物件，被著色成紅、白、藍，
請將其以in-place的方式將同顏色排序至相鄰，並順序亦為紅白藍。
這裡給定的陣列顏色紅/白/藍分別以0/1/2代表。

如果有印象的話，大家可能還記得之前有一題Move Zeroes，
差別在於這題是0, 1, 2，我們依舊可以用類似的概念來解題。

使用3個變數來分別記錄0/1/2的個數，
等到計完了，再依序覆寫到nums裡面，就可以得到答案，
這麼做會需要掃過陣列兩次，第一次用來計數，第二次用來填入新的値。

那麼，題目也問了：
有沒有辦法給出一個one-pass 的演算法來解此題呢？
(one-pass algorithm意思是指說只掃過整個資料一次，詳見wiki)

我們可以仿照先前的Two Pointer 的概念來思考。
首先，1在這個陣列當中是我們較不在意的部分，
因為它一定是排在整個陣列的中間，
然後左邊區塊最後會是0，右邊區塊最後會是2。

假設我們要排序，所要做的就是將0的部分都往左邊擺，
將2的部分都往右邊擺；最開始的時候，因為還沒排過，
我們可以將下一個要擺放的位置命名為i0和i2，
並假定應該要擺在0和n-1的位置。(陣列的最左邊和最右邊)
接下來，依序掃描整個陣列(假設迭代的index為i)，會有以下三個情況。

碰到1:
因為將0和2都擺完以後1自然在中間，所以完全不用管它XD
碰到0:
我們應該將其擺放在i0的位置 ，
但原先i0所在的値不能平白消失，所以將其和i位置的値相交換。
換完之後，i0 因為已經填入0了，
故下個要填入0的位置必須更新 ，所以將i0遞增 。
碰到2:
同理，將其擺在i2的位置，和i位置的値相交換，再遞減i2 ；
需要注意的是由於i的位置換到我們不知道值的部分 ，
(前面碰到0的時候換的應該都是1，所以沒有影響)
所以將i遞減，抵銷掉i在整個迴圈中每次加1的部分 ，
以便迴圈的下一輪能檢查相同的位置。(檢查換過來的値 )

這整個迴圈的結束時間點應該在i和i2交錯的時候 ，
因為這代表後面都是2，既然後面已經相當於排完，
就可以結束整個迴圈了！

寫成程式碼如下，
幾個需要簡單注意的地方是，
當使用第一種方法 的時候，
其實可以直接開一個長度為3的陣列 來儲存數字出現次數；
其次，使用第二種方法 時，Python當需要判定條件會改變的狀 況時，
請使用while迴圈 ，因為for in range的寫法沒辦法動態地去改變條件。
(另外別忘記Python沒有++或 — ，請用+=和-=)

Java

Python

面試實際可能會遇到的問題

「時間/空間複雜度？」
(O(N)/O(1)，不論哪個解法，最多就是掃描過2次的nums的長度，
且我們基本上只會用到三個記錄各自數量的變數或三個索引值)

相似及延伸

1.0148. Sort List (Medium) 2.0324. Wiggle Sort II (Medium)

Special Thanks suggestions/corrections from viewers:
(歡迎提供意見協助更正歐~)

從LeetCode學演算法，我們下次見囉，掰~