Review.txt

--------------------------------
---Binary Search 7, Dec 2018---
--------------------------------
def binary_search(nums, target):
    if nums == None:
       return -1 // 

    left = 0
    right = len(nums) - 1
    while i + 1 < j:
        mid = left + (right - left) / 2
        if nums[mid] < target:
            left = mid + 1
            continue
        if nums[mid] > target:
            right = mid - 1
            continue
        if nums[mid] == target:
            return mid
            continue

    if nums[i] == target:
        return left
    else:
        return right

Problem:
63:  Search in Rotated Sorted Array 
75:  Find Peak Element
140: Fast Power
159: Find Minimum inRotated Sorted Array
428: Pow(x, n) *** 
447: Search in a Big Sorted Array
458: Last Position of Target
460: Find K Closest Elements
585: Maximum Number in Mountain Sequence

----------------------------------------
Binary Search & Two Poiners 8, Dec 2018
----------------------------------------
Problem:
**:https://github.com/ZhengkaiZ/Algorithm-Record/blob/master/Try/BinarySearch.py
56: Two Sum (Sorted or Not)
160: Find Minimum in Rotated Sorted Array II (Binary Search Not Working on this case)
228: Middle of the Linked List
608: Two Sum II Input array is sorted

----------------------------------------
Two Poiners & BFS 9, Dec 2018
----------------------------------------
Two Pointer Problem:
Merge Sort, Quick Sort, Quick Search 
57: 3Sum (Time to remove duplciate) 
143: Sort Colors II ***
521. Remove Duplicate Numbers in Array
539: Move Zeroes **
587: Two Sum - Unique pairs
609: Two Sum - Less than or equal to target

----------------------------------------
Two Poiners & BFS 10, Dec 2018
----------------------------------------
Quick Select:
5: Kth Largest Element (Time Limit, Review)
69. Binary Tree Level Order Traversal
127: Toplogical Sorting
433: Number of Islands
615: Course Schedule

--------------------------------------------
 BFS, DFS, Binary Search Tree  11, Dec 2018
--------------------------------------------
31: Partition Array
120: Word Ladder
616: Course Schedule II
611: Knight Shortest Path I
624: Remove Substring (str.find)
--------------------------------------------
 EMPTY  12, Dec 2018
--------------------------------------------
--------------------------------------------
 BFS, DFS, Binary Search Tree  13, Dec 2018
--------------------------------------------
137. Clone Graph
605. Sequence Reconstruction **********
618. Search Graph Nodes 
900: Closest Binary Search Tree Value
596: Minimum Subtree
941: Sliding Puzzle (Optimization)

--------------------------------------------
DFS, Binary Search Tree  15, Dec 2018
--------------------------------------------
88. Lowest Common Ancestor of a Binary Tree
93: Balanced Binary Tree
246. Binary Tree Path Sum II
480: Binary Tree Paths
453: Flatten Binary Tree to Linked List ***
605. Sequence Reconstruction
902: Kth Smallest Element in a BST

--------------------------------------------
DFS, Trees  16, Dec 2018
--------------------------------------------
86: Binary Search Tree Iterator
901: Closest Binary Search Tree Value II (Two solution)
595: Binary Tree Longest Consecutive Sequence

--------------------------------------------
DFS, Trees  17, Dec 2018
--------------------------------------------
17: Subsets
18: Subsets II
136: Palindrome Partitioning
152: Combinations
153. Combination Sum II
135: Combination Sum
426. Restore IP Addresses
614: Binary Tree Longest Consecutive Sequence II
619: Binary Tree Longest Consecutive Sequence III
680: Split String

--------------------------------------------
Combination & Permutation DFS  18, Dec 2018
--------------------------------------------
108: Palindrome Partitioning II (Time Limit)
192: WildCard Matching
582: Word Break II


--------------------------------------------
Combination & Permutation DFS  19, Dec 2018
--------------------------------------------
Next Permutations:
def nextPermutation(array):
    end = len(array) - 1
    while end != 0 and array[end] < array[end - 1]:
        end -= 1
    if end != 0:
        start = end - 1
        right = len(array) - 1
        while array[right] < array[start]:
            right -= 1
 
        tmp = array[start]
        array[start] = array[right]
        array[right] = tmp
 
    left = end
    right = len(array) - 1
    while left <= right:
        tmp = array[right]
        array[right] = array[left]
        array[left] = tmp
        left += 1
        right -= 1

    return array
    
10. String Permutation II
15: Permutation
16: Permutations II
33: N-Queens
34: N-Queens II
52. Next Permutation
154: Regular Expression Matching

--------------------------------------------
 Permutation DFS  20, Dec 2018
--------------------------------------------
197: Permutation Index
829: Word Pattern II

--------------------------------------------
 DFS  20, Dec 2018
--------------------------------------------
121: Word Ladder II
132: Word Search II
198: Permutation Index II *** 
634: Word Squares (Better Solution Needed)

----------------------------------------------
 DFS and Advance Data Structures  21, Dec 2018
----------------------------------------------
147: Narcissistic Number (Python Time Exceed)
442. Implement Trie (Prefix Tree)
634: Word Squares (Implemented with Trie)
920. Meeting Rooms
919: Meeting Rooms II (Sweep Lines)

----------------------------------------------
 DFS and Advance Data Structures  22, Dec 2018
----------------------------------------------
35: Reverse Linked List
36: Reverse Linked List II
131: The Skyline Problem (Solution Need)
156: Merge Intervals
3Sum with Mutiplicy

----------------------------------------------
 DFS and Advance Data Structures  23, Dec 2018
----------------------------------------------
461: Kth Smallest Numbers in Unsorted Array (***)
143: Sort Colors II (***)

----------------------------------------------
Data Structures  26, Dec 2018
----------------------------------------------
51. Previous Permutation
52: Next Permutation(Review)
124: Longest Consecutive Sequence
173: Insertion Sort List
209: First Unique Character in a String
494: Implement Stack by Two Queues
642: Moving Average from Data Stream
657. Insert Delete GetRandom O(1)
1753: Doing HomeWork

----------------------------------------------
Data Structures & Leetcode  27, Dec 2018
----------------------------------------------
LeetCode:
681: Next Closest Time
904: Fruit Into Baskets
929: Unique Email Addresses

LintCode:
12: Min Stack
71. Binary Tree Zigzag Level Order Traversal
526. Load Balancer
544. Top k Largest Numbers
601. Flatten 2D Vector
612: K Closest Points (Two ways Quick Sort and Min Heap)

----------------------------------------------
Data Structures & Leetcode  28, Dec 2018
----------------------------------------------
LeetCode
159: Longest Substring with At Most Two Distinct Characters
399: Evaluate Division

LintCode
242. Convert Binary Tree to Linked Lists by Depth
----------------------------------------------
Data Structures & Leetcode  29, Dec 2018
----------------------------------------------
Union Find:

class UnionFind:
    def __init__(self, n):
        self.father = []
        for i in range(n + 1):
            self.father.append(i)

    def find(self, target):
        path = []
        while self.father[target] != target:
            path.append(target)
            target = self.father[target]

        for n in path:
            self.father[n] = target

        return target

    def union(self, a, b):
        self.father[self.find(a)] = self.find(b)

Leetcode:
683: K Empty Slots (****)
399. Evaluate Division(Union Find Optimization ***)
323: Number of Connected Components in an Undirected Graph (Union ind)

Lintcode:

----------------------------------------------
Data Structures & Leetcode  30, Dec 2018
----------------------------------------------
LeetCode:
857: Minimum Cost to Hire K Workers

LintCode:
535. House Robber III
570. Find the Missing Number II
892. Alien Dictionary
1210. Increasing Subsequences
1659: Sell or Buy Stock V

----------------------------------------------
Data Structures & Leetcode  2, Jan 2019
----------------------------------------------
124: Longest Consecutive Sequence (O(n))

----------------------------------------------
Data Structures & Leetcode  3, Jan 2019
----------------------------------------------
Union Find:
Number of Islands 
Longest Consecutive Sequence
Surrounded Regions
Most Stones Removed with Same Row or Column

LeetCode:
299: Bulls and Cows
222: Count Complete Tree Nodes

LintCode
544. Top k Largest Numbers
1029. Cheapest Flights Within K Stops

----------------------------------------------
Data Structures & Leetcode  4, Jan 2019
----------------------------------------------
LeetCode:
222: Count Complete Tree Nodes
642: Design Search Autocomplete System
833: Find And Replace in String

LintCode:
545. Top k Largest Numbers II

----------------------------------------------
Data Structures & Leetcode  5, Jan 2019
----------------------------------------------
LintCode:
134: LRU Cache
138. Subarray Sum
547: Intersection of Two Arrays
839: Merge Two Sorted Interval Lists

----------------------------------------------
Data Structures & Leetcode  6, Jan 2019
----------------------------------------------
129. Rehashing
405. Submatrix Sum
486: Merge K Sorted Arrays
577. Merge K Sorted Interval Lists
944. Maximum Submatrix

Pending:
654. Sparse Matrix Multiplication
----------------------------------------------
Data Structures & Leetcode  8, Jan 2019
----------------------------------------------
LeetCode:
11. Container With Most Water
42. Trapping Rain Water
238. Product of Array Except Self

----------------------------------------------
Data Structures & Leetcode  9, Jan 2019
----------------------------------------------
LintCode:
32. Minimum Window Substring
148. Sort Colors
406. Minimum Size Subarray Sum
625. Partition Array II

LeetCode:
35: Search Insert Position
659: Split Array into Consecutive Subsequences
777: Swap Adjacent in LR String
939: Minimum Area Rectangle

Three Pointers:
pl, pr = 0, len(nums) - 1
i = 0
while i <= pr:
    if nums[i] < low:
        nums[pl], nums[i] = nums[i], nums[pl]
        pl += 1
        i += 1
    elif nums[i] > high:
        nums[pr], nums[i] = nums[i], nums[pr]
        pr -= 1
    else:
        i += 1

----------------------------------------------
Data Structures & Leetcode  10, Jan 2019
----------------------------------------------
Pending:
508: Wiggle Sort

LeetCode:
5: Longest Palindromic Substring
Lintcode:
65. Median of two Sorted Arrays

----------------------------------------------
Data Structures & Leetcode  12, Jan 2019
----------------------------------------------
1. 跳楼方法 House Robber Decode Way
2. Merge Interval, Insert Interval 
3. Rectangle Overlap 
4. Valid Word Abbreviation