Update problem solving techniques for tree, heap, binary searcn, linked list, stack and queue.

Author: enginebai

leetcode/1642.furthest-building-you-can-reach.md

@@ -1,7 +1,9 @@
 ## [1642. Furthest Building You Can Reach](https://leetcode.com/problems/furthest-building-you-can-reach)
 
 ### Greedy
-We use ladder greedily first, when there is not enough ladder, we replace the shortest ladder with bricks.
+We don't know when to use ladder or bricks, so we try to use ladder first, when there is not enough ladder, we use bricks instead. We use ladder greedily first, when there is not enough ladder, we replace the shortest ladder with bricks.
+
+> 那就是我無腦用梯子，等梯子不夠用了，我們就要開始事後諸葛亮了，要是前面用磚頭就好了。 [Source](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/heap-2#ji-qiao-san-shi-hou-xiao-zhu-ge)
 
 ```js
     [6, 5, 5, 10, 12, 100, 106, 208, 207, 208], 10 bricks, 2 ladders

leetcode/560.subarray-sum-equals-k.md

@@ -80,8 +80,8 @@ s.t. pre[i] = pre[j] - k
 we can apply the same approach in problem [1. Two Sum](../leetcode/1.two-sum.md), we can iterate `j` to sum up the `prefixSum`, then check if `prefixSum - k` (that is `pre[j] - k`, we are looking for `pre[i]`) exists in the `prefixSum` map. If it exists, then we found a subarray with sum `k`, and we add the count of the subarray to the result.
 
 Here are some cruial points to note:
-1. We don't maintain the `prefixSum` array because we can iterate once to calculate the `prefixSum`.
-1. For the case `prefixSum == k`, we have to add the count of `prefixSum == k` to the result, so we initialize the `prefixSum` map with `0` as key and `1` as value.
+* We don't maintain the `prefixSum` array because we can iterate once to calculate the `prefixSum`.
+* For the case `prefixSum == k`, we have to add the count of `prefixSum == k` to the result, so we initialize the `prefixSum` map with `0` as key and `1` as value.
 
 ```js
 k = 2
@@ -90,13 +90,13 @@ prefix  =  1  2  4
               * --> prefixSum - k = 0
 ```
 
-1. If `prefixSum - k` exists, we don't increment the count by 1 because it leads to WA, there might be multiple `prefixSum - k` exists, so we sum up the count by the number of `prefixSum - k` exists. (Input `[0, 0, 0]`, k = `0`)
+* If `prefixSum - k` exists, we don't increment the count by 1 because it leads to WA, there might be multiple `prefixSum - k` exists, so we sum up the count by the number of `prefixSum - k` exists. (Input `[0, 0, 0]`, k = `0`)
 
 ```js
 input = 0, 0, 0
 prefix= 0, 0, 0
 ```
-1. This problem can't be solved by sliding window, because there is no good way to decide when to shrink the window when the number is negative (`nums = [-1, -1, 1]`) or contains `0` (`nums = [0, 1, 1, 0]` and `k = 2`). Based on the characteristics of sliding window:
+* This problem can't be solved by sliding window, because there is no good way to decide when to shrink the window when the number is negative (`nums = [-1, -1, 1]`) or contains `0` (`nums = [0, 1, 1, 0]` and `k = 2`). Based on the characteristics of sliding window:
     * If wider window is valid, then narrower window is also valid.
     ```js
     k = 3
@@ -159,9 +159,4 @@ fun subarraySum(nums: IntArray, k: Int): Int {
 ```
 
 * **Time Complexity**: `O(n)`.
-* **Space Complexity**: `O(n)`.
-
-
-k = 2
-value = [1, 1, 2]
-prefix = 1, 2, 4
+* **Space Complexity**: `O(n)`.

topics/array.md

@@ -65,24 +65,13 @@ Comparison to Linked List, see [Linked List](../topics/linked-list.md) topic.
 |--------------------------------------------------------|---------------------------------------------------------------------------------------|--------------------------------|
 | 1. Random access.<br>2. No `next` field, saving space. (vs Linked List) | 1. Bad at insert/delete. (Copy to new array)<br>2. Bad at resize. (Copy to new array) | 1. Fast access.<br>2. Fix size |
 
-## Tips for [Problem Solving](./leetcode-solutions.md#array)
-* Mind the bound or size of array. Think about empty array or with few element (1, 2, or less than the problem requirement).
-* Is the array sorted (partially)? Yes, try *binary search*. No, try to sort first?
-* Swap or ignore element (only take the element met the requirement)
-* We can iterate array from left to right, also from *right to left*.
-* `O(n)` time complexity **doesn't** mean you can only iterate the array **once**. Iterate the array several times might help solve the problem, for example, pre-computation (iterate array at least one time first) using hashing might be useful.
-* For in-place operation or `O(1)` space complexity, use array (index) itself as a hash table. For example, the value of array ranges from 1 to `n`, where `n` is the size of array, then we can use the *index* to represent.
-* Array in Kotlin:
+## Array in Kotlin
 ```kotlin
 val array = IntArray(3) { 5 } // [5, 5, 5]
 array.sliceArray(1..5)   // subarray of A[1:5]
 array.sliceArray(3 until array.size) // subarray of A[3:]
 ```
 
-## Sliding Window Approach
-The every character will enter and exit the window at most once, so the time complexity is `O(n)`.
-
-
 ## Resources
 - [X] [MIT 6.006 Introduction to Algorithm - Lecture 2: Data Structures and Dynamic Arrays](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-spring-2020/lecture-videos/lecture-2-data-structures-and-dynamic-arrays/)
 - [ ] Kotlin document

topics/binary-search.md

@@ -51,7 +51,7 @@ while (left <= right) {
 return result
 ```
 
-## Find the first (last) element that satifies the condition
+## Find the first/left-most (last/right-most) element that satifies the condition
 ```js
 X X X O O O O O
       ^ // The first element that satifies the condition

topics/dynamic-programming.md

@@ -611,19 +611,6 @@ fun printLCS(parent: Array<IntArray>, x: Int, y: Int) {
 * **Time Complexity**: `O(m * n)`, for `m`, `n` is the length of `A` and `B`.
 * **Space Complexity**: `O(m * n)` for dp 2D table.
 
-## Tips for [Problem Solving](../topics/leetcode-solutions.md#dynamic-programming)
-
-### When to use DP? 
-The problem meets the both two characteristics:
-1. Solve the optimal problem (often, but not always), for example:
-    * The minimum cost
-    * The maximum profit
-    * How many ways are there to do...
-    * What's the longest/shortest possible...
-2. The solution of original problem comes from eariler calculated solution (from the overlapping subproblems), that is, the later step will be affected by the eariler step.
-
-Sometimes, only meets the first but not the second might be the greedy algorithm, not DP. For some problems, we have to return the optimal value among DP table, not just `dp[0]` or `dp[n]` itself.
-
 ### Problem Solving Steps
 
 #### 5 Steps of Dynamic Programming

topics/greedy.md

@@ -4,7 +4,7 @@ A *greedy algorithm* always makes the choice that looks best at the moment, it m
 We shall consider a [dynamic programming](../topics/dynamic-programming.md) solution (including steps) and show that we can always make greedy choices to arrival the optimal solution.
 
 ## Steps of Greedy
-1. Cast the optimization problem as one in which we make a choice and are left with one subproblem to solve. (Top-down fashion: making a greedy choice, reduce the problems to a smaller subproblems)
+1. Making a greedy choice, reduce the problems to a smaller subproblems.
 2. Prove that making the greedy choice is always safe.
 3. We conbime an optimal solutions to the subproblems with the greedy choice, we can arrive at the optimal solution to the original problem.
 
@@ -49,9 +49,4 @@ fun knapsackFractional(): Float {
     }
     return totalValues
 }
-```
-
-## Resources
-- [X] CLRS
-- [ ] https://github.com/youngyangyang04/leetcode-master#%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95
-- [X] [Tech Interview Cheat Sheet](https://github.com/TSiege/Tech-Interview-Cheat-Sheet#greedy-algorithms)
+```

topics/heap.md

@@ -191,11 +191,11 @@ fun heapSort(A) {
 * **Time Complexity**: `buildMapHeap(A)` takes `O(n)`, and `n - 1` elements run `heapifyDown()`, which takes `O(n - 1) * O(lg n)` = `O(n lg n)`.
 
 ## Tips for [Problem Solving](../topics/leetcode-solutions.md#heap)
-* Heap is good at find the top/smallest K of xxx or median. (or using binary search if there is sorted list) We also can use **Quickselect** to find *k*th smallest item in an unordered list. (See problem [215. Kth Largest Element in an Array](../leetcode/215.kth-largest-element-in-an-array.md))
+* Heap is good at find the top/smallest K of xxx or median. (or using binary search if there is sorted list) We also can use **Quickselect** to find *k*th smallest item in an unordered list. 
 * For top k problems, you can use:
     * Build max heap from all items, and pop `k - 1` times, and the peek will be the top K result.
     * Using min heap with `k` items, we add item one by one, and pop (the min value) if heap size > `k` as adding item. The remaining heap will be top K results **but in reversed order**, make sure to reverse the result.
-* For frequency sorting, we can use *bucket sort*, see problem [347. Top K Frequent Elements](../leetcode/347.top-k-frequent-elements.md)
+* For frequency sorting, we can use *bucket sort*, see problem 
 * For some problems to find the max/min value **dynamically** (after some operations, such adding some numbers then find the max number), then it might be able to use heap to solve. ([264. Ugly Number II](https://leetcode.com/problems/ugly-number-ii/))
 * Heap in Kotlin:
 ```kotlin

topics/leetcode-solutions.md

@@ -109,6 +109,7 @@
 #### Problem Listing
 > * https://leetcode.com/problems/remove-all-adjacent-duplicates-in-string-ii/ 5k m
 > * https://leetcode.com/problems/accounts-merge/ 5k m
+> * Solved: https://leetcode.com/problems/check-if-two-string-arrays-are-equivalent/description/ 3k e
 > ----
 > * https://leetcode.com/problems/repeated-string-match/ 2k m
 > * https://leetcode.com/problems/distinct-subsequences-ii/ 2k h
@@ -308,6 +309,7 @@
 |[2265. Count Nodes Equal to Average of Subtree](../leetcode/2265.count-nodes-equal-to-average-of-subtree.md)|Medium|
 
 > * Solved: https://leetcode.com/problems/find-largest-value-in-each-tree-row/ 3k m
+> * Solved: https://leetcode.com/problems/construct-string-from-binary-tree/ 3k e
 > * https://leetcode.com/problems/count-complete-tree-nodes 8k e
 > * https://leetcode.com/problems/sum-root-to-leaf-numbers/ 7k m
 > * https://leetcode.com/problems/find-duplicate-subtrees 6k m

topics/linked-list.md

@@ -561,42 +561,7 @@ Linked list with the last node has reference to the head.
 
 > // TODO
 
-## Tips for [Problem Solving](./leetcode-solutions.md#linked-list)
-* Corner cases:
-    * **Empty linked list** (before operation or **after!**, such as deleting the only node)
-    * Linked list with **one / two nodes**
-    * Linked list has cycles. Clarify before solving problem! And pay attention to the result after performing the functions.
-
-```js
-1. head -> null
-2. head -> A -> null
-3. head -> A -> B -> null
-```
-For some cases we have to insert when head is null or deleting head and after that the head will be null, then we can introduct *sentinel node* to help.
-
-```kotlin
-fun solveProblem(head?: Node): Node? {
-    val sentinel = Node(-1)
-    var node: Node? = sentinel
-    /// do something to modify the `node`
-
-    return sentinel.next
-}
-```
-
-* Pay attention to operate on the specific node before or after, especially on head and last node or the pointer nodoe after while loop.
-* **Drawing** could be really help!!
-* Get familiar with the following operations:
-    * Reverse in-place or update the node references (be careful of cycle references)
-    * Merge (connect/chain) two linked lists
-    * Count the node number
-    * Find the middle node using two pointers technique
-* Fast/slow pointers to solve cycle or interaction problems.
-    * [876. Middle of the Linked List](../leetcode/876.middle-of-the-linked-list.md)
-    * [141. Linked List Cycle](../leetcode/141.linked-list-cycle.md)
-    * [142. Linked List Cycle II](../leetcode/142.linked-list-cycle-ii.md)
-
-* `LinkedList` in Kotlin:
+## LinkedList in Kotlin:
 ```kotlin
 val linkedList = LinkedList<Int>()
 linkedList.addFirst(1)
@@ -608,7 +573,6 @@ linkedList.removeLast()
 linkedList.first()
 linkedList.last()
 ```
-> [Nice post](https://leetcode-solution-leetcode-pp.gitbook.io/leetcode-solution/thinkings/linked-list) to read that need to keep in mind.
 
 ## Resources
 - Fundamental of Data Structure