diff --git a/C++/add-and-search-word-data-structure-design.cpp b/C++/add-and-search-word-data-structure-design.cpp
new file mode 100644
index 000000000..053516acd
--- /dev/null
+++ b/C++/add-and-search-word-data-structure-design.cpp
@@ -0,0 +1,57 @@
+// Time:  O(min(n, h)), per operation
+// Space: O(min(n, h))
+
+class WordDictionary {
+public:
+    struct TrieNode{
+    public:
+        bool isString = false;
+        unordered_map<char, TrieNode *> leaves;
+    };
+
+    WordDictionary(){
+        root_ = new TrieNode();
+        root_->isString = true;
+    }
+    
+    // Adds a word into the data structure.
+    void addWord(string word) {
+            auto* p = root_;
+            for (const auto& c : word) {
+                if (p->leaves.find(c) == p->leaves.cend()) {
+                    p->leaves[c] = new TrieNode;
+                }
+                p = p->leaves[c];
+            }
+            p->isString = true;
+    }
+
+    // Returns if the word is in the data structure. A word could
+    // contain the dot character '.' to represent any one letter.
+    bool search(string word) {
+        return searchWord(word, root_, 0);
+    }
+
+    bool searchWord(string word, TrieNode* node, int s) {
+        if (s == word.length()) {
+            return node->isString;
+        }
+        if (node->leaves.find(word[s]) != node->leaves.end()){ // Match the char.
+            return searchWord(word, node->leaves[word[s]], s + 1);
+        } else if (word[s] == '.') { // Skip the char.
+            for (const auto& i : node->leaves) {
+                if (searchWord(word, i.second, s + 1)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+private:
+    TrieNode *root_;
+};
+
+// Your WordDictionary object will be instantiated and called as such:
+// WordDictionary wordDictionary;
+// wordDictionary.addWord("word");
+// wordDictionary.search("pattern");
diff --git a/C++/combination-sum-iii.cpp b/C++/combination-sum-iii.cpp
new file mode 100644
index 000000000..ff297a253
--- /dev/null
+++ b/C++/combination-sum-iii.cpp
@@ -0,0 +1,27 @@
+// Time:  O(C(n, k))
+// Space: O(k)
+
+class Solution {
+public:
+    vector<vector<int> > combinationSum3(int k, int n) {
+        vector<vector<int>> res;
+        vector<int> combination;
+        combinationSum3(res, combination, 1, k, n);
+        return res;
+    }
+private:
+    void combinationSum3(vector<vector<int> > &res, vector<int> &combination, int start, int k, int n) {
+        if (!k && !n) {
+            res.push_back(combination);
+            return;
+        } else if (k < 0) {
+            return;
+        }
+
+        for (int i = start; i < 10 && n >=  k * i + k * (k - 1) / 2; ++i) {
+            combination.push_back(i);
+            combinationSum3(res, combination, i + 1, k - 1, n - i);
+            combination.pop_back();
+        }
+    }
+};
diff --git a/C++/contains-duplicate-ii.cpp b/C++/contains-duplicate-ii.cpp
new file mode 100644
index 000000000..b70ad1928
--- /dev/null
+++ b/C++/contains-duplicate-ii.cpp
@@ -0,0 +1,22 @@
+// Time:  O(n)
+// Space: O(n)
+
+class Solution {
+public:
+    bool containsNearbyDuplicate(vector<int>& nums, int k) {
+        unordered_map<int, int> lookup;
+        for (int i = 0; i < nums.size(); ++i) {
+            if (lookup.find(nums[i]) == lookup.end()) {
+                lookup[nums[i]] = i;
+            } else {
+                // It the value occurs before, check the difference.
+                if (i - lookup[nums[i]] <= k) {
+                    return true;
+                }
+                // Update the index of the value.
+                lookup[nums[i]] = i;
+            }
+        }
+        return false;
+    }
+};
diff --git a/C++/contains-duplicate-iii.cpp b/C++/contains-duplicate-iii.cpp
new file mode 100644
index 000000000..0231eb157
--- /dev/null
+++ b/C++/contains-duplicate-iii.cpp
@@ -0,0 +1,32 @@
+// Time:  O(nlogk)
+// Space: O(k)
+
+class Solution {
+public:
+    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
+        if (k < 0 || t < 0) {
+            return false;
+        }
+        
+        queue<int64_t> window;
+        multiset<int64_t> bst;
+        for (int i = 0; i < nums.size(); ++i) {
+            // Only keep at most k elements.
+            if (bst.size() > k) {
+                int num = window.front();
+                window.pop();
+                bst.erase(bst.find(num));
+            }
+            // Every search costs time: O(logn).
+            const auto it = bst.lower_bound(nums[i] - t);
+            if (it == bst.cend() || (*it - nums[i]) > t) {
+                // Not found.
+                window.emplace(nums[i]);
+                bst.emplace(nums[i]);
+            } else {
+                return true;
+            }
+        }
+        return false;
+    }
+};
diff --git a/C++/contains-duplicate.cpp b/C++/contains-duplicate.cpp
new file mode 100644
index 000000000..524f4067c
--- /dev/null
+++ b/C++/contains-duplicate.cpp
@@ -0,0 +1,20 @@
+// Time:  O(n)
+// Space: O(n)
+
+class Solution {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        unordered_set<int> nums_set(nums.begin(), nums.end());
+        return nums_set.size() != nums.size();
+    }
+};
+
+// Time:  O(nlogn)
+// Space: O(1)
+class Solution2 {
+public:
+    bool containsDuplicate(vector<int>& nums) {
+        sort(nums.begin(), nums.end());
+        return unique(nums.begin(), nums.end()) != nums.end();
+    }
+};
diff --git a/C++/count-primes.cpp b/C++/count-primes.cpp
new file mode 100644
index 000000000..dcafc14bf
--- /dev/null
+++ b/C++/count-primes.cpp
@@ -0,0 +1,36 @@
+// Time:  O(n)
+// Space: O(n)
+//
+// Description:
+//
+// Count the number of prime numbers less than a non-negative number, n
+//
+// Hint: The number n could be in the order of 100,000 to 5,000,000.
+//
+
+class Solution {
+public:
+    int countPrimes(int n) {
+        if (2 >= n) {
+            return 0;
+        }
+        bool* primes = new bool[n];
+        for (int i = 2; i < n; ++i)
+            primes[i] = true;
+
+        int sqr = sqrt(n - 1);
+        int sum = 0;
+        for (int i = 2; i < n; ++i) {
+            if (primes[i]) {
+                ++sum;
+                for (int j = i + i; j < n; j += i) {
+                    primes[j] = false;
+                }
+            }
+        }
+
+        delete[] primes;
+
+        return sum;
+    }
+};
diff --git a/C++/course-schedule-ii.cpp b/C++/course-schedule-ii.cpp
new file mode 100644
index 000000000..198122315
--- /dev/null
+++ b/C++/course-schedule-ii.cpp
@@ -0,0 +1,52 @@
+// Time:  O(|V| + |E||)
+// Space: O(|E|)
+
+// Topological sort solution.
+class Solution {
+public:
+    vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
+        vector<int> res;
+        // Store courses with in-degree zero.
+        queue<int> zeroInDegree;
+        
+        // in-degree, out-degree
+        unordered_map<int, unordered_set<int>> inDegree;
+        unordered_map<int, unordered_set<int>> outDegree;
+        for (int i = 0; i < prerequisites.size(); ++i) {
+            inDegree[prerequisites[i].first].insert(prerequisites[i].second);
+            outDegree[prerequisites[i].second].insert(prerequisites[i].first);
+        }
+        
+        // Put all the courses with in-degree zero into queue.
+        for(int i = 0; i < numCourses; ++i) {
+            if(inDegree.find(i) == inDegree.end()) {
+                zeroInDegree.push(i);
+            }
+        }
+        
+        // V+E
+        while(!zeroInDegree.empty()) {
+            // Take the course which prerequisites are all taken.
+            int prerequisite = zeroInDegree.front();
+            res.emplace_back(prerequisite);
+            zeroInDegree.pop();
+            for (const auto & course: outDegree[prerequisite]) {
+                // Update info of all the courses with the taken prerequisite.
+                inDegree[course].erase(prerequisite);
+                // If all the prerequisites are taken, add the course to the queue.
+                if (inDegree[course].empty()) {
+                    zeroInDegree.push(course);
+                }
+            }
+            // Mark the course as taken.
+            outDegree.erase(prerequisite);
+        }
+        
+        // All of the courses have been taken.
+        if (!outDegree.empty()) {
+            return {};
+        }
+        
+        return res;
+    }
+};
diff --git a/C++/course-schedule.cpp b/C++/course-schedule.cpp
new file mode 100644
index 000000000..2cf78f602
--- /dev/null
+++ b/C++/course-schedule.cpp
@@ -0,0 +1,50 @@
+// Time:  O(|V| + |E|)
+// Space: O(|E|)
+
+// Topological sort solution.
+class Solution {
+public:
+    bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
+        // Store courses with in-degree zero.
+        queue<int> zeroInDegree;
+        
+        // in-degree, out-degree
+        unordered_map<int, unordered_set<int>> inDegree;
+        unordered_map<int, unordered_set<int>> outDegree;
+        for (int i = 0; i < prerequisites.size(); ++i) {
+            inDegree[prerequisites[i][0]].insert(prerequisites[i][1]);
+            outDegree[prerequisites[i][1]].insert(prerequisites[i][0]);
+        }
+        
+        // Put all the courses with in-degree zero into queue.
+        for(int i = 0; i < numCourses; ++i) {
+            if(inDegree.find(i) == inDegree.end()) {
+                zeroInDegree.push(i);
+            }
+        }
+        
+        // V+E
+        while(!zeroInDegree.empty()) {
+            // Take the course which prerequisites are all taken.
+            int prerequisite = zeroInDegree.front();
+            zeroInDegree.pop();
+            for (const auto & course: outDegree[prerequisite]) {
+                // Update info of all the courses with the taken prerequisite.
+                inDegree[course].erase(prerequisite);
+                // If all the prerequisites are taken, add the course to the queue.
+                if (inDegree[course].empty()) {
+                    zeroInDegree.push(course);
+                }
+            }
+            // Mark the course as taken.
+            outDegree.erase(prerequisite);
+        }
+        
+        // All of the courses have been taken.
+        if (!outDegree.empty()) {
+            return false;
+        }
+        
+        return true;
+    }
+};
diff --git a/C++/house-robber-ii.cpp b/C++/house-robber-ii.cpp
new file mode 100644
index 000000000..5050a55f2
--- /dev/null
+++ b/C++/house-robber-ii.cpp
@@ -0,0 +1,27 @@
+// Time:  O(n)
+// Space: O(1)
+
+class Solution {
+public:
+    int rob(vector<int>& nums) {
+        if (nums.size() == 0) {
+            return 0;
+        }
+        if (nums.size() == 1) {
+            return nums[0];
+        }
+        
+        return max(robRange(nums, 0, nums.size() - 1), // Include the first one of nums without the last one.
+                   robRange(nums, 1, nums.size()));    // Include the last one of nums without the first one.
+    }
+    
+    int robRange(vector<int>& nums, int start, int end) {
+        int num_i = nums[start], num_i_1 = 0, num_i_2 = 0;
+        for (int i = start + 1; i < end; ++i) {
+            num_i_2 = num_i_1;
+            num_i_1 = num_i;
+            num_i = max(nums[i] + num_i_2, num_i_1);
+        }
+        return num_i;
+    }
+};
diff --git a/C++/isomorphic-strings.cpp b/C++/isomorphic-strings.cpp
new file mode 100644
index 000000000..de37015b8
--- /dev/null
+++ b/C++/isomorphic-strings.cpp
@@ -0,0 +1,17 @@
+class Solution {
+public:
+    bool isIsomorphic(string s, string t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        vector<int> m1(256, 0);
+        vector<int> m2(256, 0);
+        int n = s.size();
+        for (int i = 0; i < n; ++i) {
+            if (m1[s[i]] != m2[t[i]]) return false;
+            m1[s[i]] = i + 1;
+            m2[t[i]] = i + 1;
+        }
+        return true;
+    }
+};
diff --git a/C++/kth-largest-element-in-an-array.cpp b/C++/kth-largest-element-in-an-array.cpp
new file mode 100644
index 000000000..095b917e6
--- /dev/null
+++ b/C++/kth-largest-element-in-an-array.cpp
@@ -0,0 +1,47 @@
+// Time:  O(n)
+// Space: O(1)
+
+class Solution {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        int left = 0, right = nums.size() - 1;
+        default_random_engine gen((random_device())());
+        while (left <= right) {
+            // Generates a random int in [left, right].
+            uniform_int_distribution<int> dis(left, right);
+            int pivot_idx = dis(gen);
+            int new_pivot_idx = PartitionAroundPivot(left, right, pivot_idx, &nums);
+            if (new_pivot_idx == k - 1) {
+                return nums[new_pivot_idx];
+            } else if (new_pivot_idx > k - 1) {
+                right = new_pivot_idx - 1;
+            } else {  // new_pivot_idx < k - 1.
+                left = new_pivot_idx + 1;
+            }
+        }
+    }
+    
+    int PartitionAroundPivot(int left, int right, int pivot_idx, vector<int>* nums) {
+        auto& nums_ref = *nums;
+        int pivot_value = nums_ref[pivot_idx];
+        int new_pivot_idx = left;
+        swap(nums_ref[pivot_idx], nums_ref[right]);
+        for (int i = left; i < right; ++i) {
+            if (nums_ref[i] > pivot_value) {
+                swap(nums_ref[i], nums_ref[new_pivot_idx++]);
+            }
+        }
+        swap(nums_ref[right], nums_ref[new_pivot_idx]);
+        return new_pivot_idx;
+    }
+};
+
+// Time:  O(n)
+// Space: O(1)
+class Solution2 {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        nth_element(nums.begin(), next(nums.begin(), k - 1), nums.end(), greater<int>());
+        return *next(nums.begin(), k - 1);
+    }
+};
diff --git a/C++/shortest-palindrome.cpp b/C++/shortest-palindrome.cpp
new file mode 100644
index 000000000..083c21e11
--- /dev/null
+++ b/C++/shortest-palindrome.cpp
@@ -0,0 +1,91 @@
+// Time:  O(n)
+// Space: O(n)
+
+// KMP Algorithm
+class Solution {
+public:
+    string shortestPalindrome(string s) {
+            if (s.empty()) {
+                return s;
+            }
+            string rev_s(s.crbegin(), s.crend());
+            string A = s + rev_s;
+            vector<int> pattern(move(getPrefix(A)));
+            string non_palindrome = s.substr(pattern.back() + 1);
+            reverse(non_palindrome.begin(), non_palindrome.end());
+            return non_palindrome + s;
+        }
+        
+private:
+    vector<int> getPrefix(const string& pattern) {
+        vector<int> prefix(pattern.length(), -1);
+        int j = -1;
+        for (int i = 1; i < pattern.length(); ++i) {
+            while (j > -1 && pattern[j + 1] != pattern[i]) {
+                j = prefix[j];
+            }
+            if (pattern[j + 1] == pattern[i]) {
+                ++j;
+            }
+            prefix[i] = j;
+        }
+        return prefix;
+    }
+};
+
+// Time:  O(n)
+// Space: O(n)
+// Manacher's Algorithm
+class Solution2 {
+public:
+    string shortestPalindrome(string s) {
+            string T = preProcess(s);
+            int n = T.length();
+            vector<int> P(n);
+            int C = 0, R = 0;
+            for (int i = 1; i < n - 1; ++i) {
+                int i_mirror = 2*C-i; // equals to i' = C - (i-C)
+
+                P[i] = (R > i) ? min(R - i, P[i_mirror]) : 0;
+
+                // Attempt to expand palindrome centered at i
+                while (T[i + 1 + P[i]] == T[i - 1 - P[i]]) {
+                    ++P[i];
+                }
+
+                // If palindrome centered at i expand past R,
+                // adjust center based on expanded palindrome.
+                if (i + P[i] > R) {
+                    C = i;
+                    R = i + P[i];
+                }
+            }
+
+            // Find the max len of palindrome which starts with the first char of s.
+            int max_len = 0;
+            for (int i = 1; i < n - 1; ++i) {
+                if (i - P[i] == 1) {
+                    max_len = P[i];
+                }
+            }
+            
+            // Assume s is (Palindrome)abc
+            string ans = s.substr(max_len); // abc.
+            reverse(ans.begin(), ans.end()); // cba.
+            ans.append(s); // cba(Palindrome)abc.
+            return ans;
+        }
+private:
+    string preProcess(string s) {
+        int n = s.length();
+        if (n == 0) {
+            return "^$";
+        }
+        string ret = "^";
+        for (int i = 0; i < n; ++i) {
+            ret += "#" + s.substr(i, 1);
+        }
+        ret += "#$";
+        return ret;
+    }
+};
diff --git a/C++/the-skyline-problem.cpp b/C++/the-skyline-problem.cpp
new file mode 100644
index 000000000..55cb51376
--- /dev/null
+++ b/C++/the-skyline-problem.cpp
@@ -0,0 +1,145 @@
+// Time:  O(nlogn)
+// Space: O(n)
+
+// BST solution.
+class Solution {
+public:
+    enum {start, end, height};
+    
+    struct Endpoint {
+        int height;
+        bool isStart;
+    };
+    
+    vector<pair<int, int> > getSkyline(vector<vector<int> >& buildings) {
+        map<int, vector<Endpoint>> point_to_height; // Ordered, no duplicates.
+        for (const auto& building : buildings) {
+            point_to_height[building[start]].emplace_back(Endpoint{building[height], true});
+            point_to_height[building[end]].emplace_back(Endpoint{building[height], false});
+        }
+
+        vector<pair<int, int>> res;
+        map<int, int> height_to_count; // BST.
+        int curr_max = 0;
+        // Enumerate each point in increasing order.
+        for (auto& kvp : point_to_height) {
+            auto& point = kvp.first;
+            auto& heights = kvp.second;
+
+            for (const auto& h : heights) {
+                if (h.isStart) {
+                    ++height_to_count[h.height];
+                } else {
+                    --height_to_count[h.height];
+                    if (height_to_count[h.height] == 0) {
+                        height_to_count.erase(h.height);
+                    }
+                }
+            }
+
+            if (height_to_count.empty() || curr_max != height_to_count.crbegin()->first) {
+                curr_max = height_to_count.empty() ? 0 : height_to_count.crbegin()->first;
+                res.emplace_back(point, curr_max);
+            }
+        }
+        return res;
+    }
+};
+
+// Time:  O(nlogn)
+// Space: O(n)
+// Divide and conquer solution.
+class Solution2 {
+public:
+    enum {start, end, height};
+    
+    vector<pair<int, int>> getSkyline(vector<vector<int>>& buildings) {
+        const auto intervals = move(ComputeSkylineInInterval(buildings, 0, buildings.size()));
+        
+        vector<pair<int, int>> res;
+        int last_end = -1;
+        for (const auto& interval : intervals) {
+            if (last_end != -1 && last_end < interval[start]) {
+                res.emplace_back(last_end, 0);
+            }
+            res.emplace_back(interval[start], interval[height]);
+            last_end = interval[end];
+        }
+        if (last_end != -1) {
+            res.emplace_back(last_end, 0);
+        }
+        return res;
+    }
+    
+    // Divide and Conquer.
+    vector<vector<int>> ComputeSkylineInInterval(const vector<vector<int>>& buildings,
+                                                 int left_endpoint, int right_endpoint) {
+        if (right_endpoint - left_endpoint <= 1) {  // 0 or 1 skyline, just copy it.
+            return {buildings.cbegin() + left_endpoint, 
+                    buildings.cbegin() + right_endpoint};
+        }
+        int mid = left_endpoint + ((right_endpoint - left_endpoint) / 2);
+        auto left_skyline = move(ComputeSkylineInInterval(buildings, left_endpoint, mid));
+        auto right_skyline = move(ComputeSkylineInInterval(buildings, mid, right_endpoint));
+        return MergeSkylines(left_skyline, right_skyline);
+    }
+    
+    // Merge Sort
+    vector<vector<int>> MergeSkylines(vector<vector<int>>& left_skyline, vector<vector<int>>& right_skyline) {
+        int i = 0, j = 0;
+        vector<vector<int>> merged;
+        
+        while (i < left_skyline.size() && j < right_skyline.size()) {
+            if (left_skyline[i][end] < right_skyline[j][start]) {
+                merged.emplace_back(move(left_skyline[i++]));
+            } else if (right_skyline[j][end] < left_skyline[i][start]) {
+                merged.emplace_back(move(right_skyline[j++]));
+            } else if (left_skyline[i][start] <= right_skyline[j][start]) {
+                MergeIntersectSkylines(merged, left_skyline[i], i,
+                                       right_skyline[j], j);
+            } else {  // left_skyline[i][start] > right_skyline[j][start].
+                MergeIntersectSkylines(merged, right_skyline[j], j,
+                                       left_skyline[i], i);
+            }
+        }
+        
+        // Insert the remaining skylines.
+        merged.insert(merged.end(), left_skyline.begin() + i, left_skyline.end());
+        merged.insert(merged.end(), right_skyline.begin() + j, right_skyline.end());
+        return merged;
+    }
+    
+    // a[start] <= b[start]
+    void MergeIntersectSkylines(vector<vector<int>>& merged, vector<int>& a, int& a_idx,
+                                vector<int>& b, int& b_idx) {
+        if (a[end] <= b[end]) {
+            if (a[height] > b[height]) {  // |aaa|
+                if (b[end] != a[end]) {   // |abb|b
+                    b[start] = a[end];
+                    merged.emplace_back(move(a)), ++a_idx;
+                } else {        // aaa
+                    ++b_idx;    // abb
+                }
+            } else if (a[height] == b[height]) { // abb
+                b[start] = a[start], ++a_idx;    // abb
+            } else {  // a[height] < b[height].
+                if (a[start] != b[start]) {                                                 //    bb
+                    merged.emplace_back(move(vector<int>{a[start], b[start], a[height]}));  // |a|bb
+                }
+                ++a_idx;
+            }
+        } else {  // a[end] > b[end].
+            if (a[height] >= b[height]) {  // aaaa
+                ++b_idx;                   // abba
+            } else {
+                //    |bb|
+                // |a||bb|a
+                if (a[start] != b[start]) {
+                    merged.emplace_back(move(vector<int>{a[start], b[start], a[height]}));
+                }
+                a[start] = b[end];
+                merged.emplace_back(move(b)), ++b_idx;
+            }
+        }
+    }
+};
diff --git a/C++/word-search-ii.cpp b/C++/word-search-ii.cpp
new file mode 100644
index 000000000..768f0264d
--- /dev/null
+++ b/C++/word-search-ii.cpp
@@ -0,0 +1,101 @@
+// Time:  O(m * n * h), h is height of trie
+// Space: O(26^h)
+
+class Solution {
+private:
+    struct TrieNode {
+        bool isString = false;
+        unordered_map<char, TrieNode *> leaves;
+        
+        bool Insert(const string& s) {
+            auto* p = this;
+            for (const auto& c : s) {
+                if (p->leaves.find(c) == p->leaves.cend()) {
+                    p->leaves[c] = new TrieNode;
+                }
+                p = p->leaves[c];
+            }
+            
+            // s already existed in this trie.
+            if (p->isString) {
+                return false;
+            } else {
+                p->isString = true;
+                return true;
+            }
+        }
+        
+        ~TrieNode() {
+            for (auto& kv : leaves) {
+                if (kv.second) {
+                    kv.second->~TrieNode();
+                }
+            }
+        }
+    };
+    
+public:
+    /**
+     * @param board: A list of lists of character
+     * @param words: A list of string
+     * @return: A list of string
+     */
+    vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {
+        unordered_set<string> ret;
+        vector<vector<bool>> visited(board.size(), vector<bool>(board[0].size(), false));
+        string curr;
+        TrieNode trie;
+        for (const auto& word : words) {
+            trie.Insert(word);
+        }
+        
+        for (int i = 0; i < board.size(); ++i) {
+            for (int j = 0; j < board[0].size(); ++j) {
+                findWordsDFS(board, visited, &trie, i, j, curr,  ret);
+            }
+        }
+        
+        return vector<string>(ret.begin(), ret.end());
+    }
+    
+    void findWordsDFS(vector<vector<char>> &grid,
+             vector<vector<bool>> &visited,
+             TrieNode *trie,
+             int i,
+             int j,
+             string curr,
+             unordered_set<string> &ret) {
+        // Invalid state.
+        if (!trie || i < 0 || i >= grid.size() || j < 0 || j >= grid[0].size()) {
+            return;
+        }
+        
+        // Not in trie or visited.
+        if (!trie->leaves[grid[i][j] ] || visited[i][j]) {
+            return;
+        }
+        
+        // Get next trie nodes.
+        TrieNode *nextNode = trie->leaves[grid[i][j]];
+        
+        // Update current string.
+        curr.push_back(grid[i][j]);
+        
+        // Find the string, add to the answers.
+        if (nextNode->isString) {
+            ret.insert(curr);
+        }
+        
+        // Marked as visited.
+        visited[i][j] = true;
+        
+        // Try each direction.
+        vector<pair<int, int>> direction{{0, -1}, {0, 1}, {-1, 0}, {1, 0}};
+        for (int k = 0; k < 4; ++k) {
+            findWordsDFS(grid, visited, nextNode,
+                          i + direction[k].first, j + direction[k].second, curr, ret);
+        }
+        
+        visited[i][j] = false;
+    }
+};
diff --git a/MySQL/delete-duplicate-emails.sql b/MySQL/delete-duplicate-emails.sql
new file mode 100644
index 000000000..b098426ca
--- /dev/null
+++ b/MySQL/delete-duplicate-emails.sql
@@ -0,0 +1,28 @@
+# Time:  O(n^2)
+# Space: O(n)
+#
+# Write a SQL query to delete all duplicate email entries in a table named Person, 
+# keeping only unique emails based on its smallest Id.
+#
+# +----+------------------+
+# | Id | Email            |
+# +----+------------------+
+# | 1  | john@example.com |
+# | 2  | bob@example.com  |
+# | 3  | john@example.com |
+# +----+------------------+
+# Id is the primary key column for this table.
+# For example, after running your query, the above Person table should have the following rows:
+#
+# +----+------------------+
+# | Id | Email            |
+# +----+------------------+
+# | 1  | john@example.com |
+# | 2  | bob@example.com  |
+# +----+------------------+
+#
+
+# Write your MySQL query statement below
+DELETE p1
+FROM Person p1, Person p2
+WHERE p1.Email = p2.Email AND p1.Id > p2.Id
diff --git a/MySQL/rising-temperature.sql b/MySQL/rising-temperature.sql
new file mode 100644
index 000000000..91c25d228
--- /dev/null
+++ b/MySQL/rising-temperature.sql
@@ -0,0 +1,28 @@
+# Time:  O(n^2)
+# Space: O(n)
+#
+# Given a Weather table, write a SQL query to find all dates' 
+# Ids with higher temperature compared to its previous (yesterday's) dates.
+# 
+# +---------+------------+------------------+
+# | Id(INT) | Date(DATE) | Temperature(INT) |
+# +---------+------------+------------------+
+# |       1 | 2015-01-01 |               10 |
+# |       2 | 2015-01-02 |               25 |
+# |       3 | 2015-01-03 |               20 |
+# |       4 | 2015-01-04 |               30 |
+# +---------+------------+------------------+
+# For example, return the following Ids for the above Weather table:
+# +----+
+# | Id |
+# +----+
+# |  2 |
+# |  4 |
+# +----+
+#
+
+# Write your MySQL query statement below
+SELECT wt1.Id 
+FROM Weather wt1, Weather wt2
+WHERE wt1.Temperature > wt2.Temperature AND 
+      TO_DAYS(wt1.DATE)-TO_DAYS(wt2.DATE)=1;
diff --git a/Python/4sum.py b/Python/4sum.py
index c049c577c..a1a77ef20 100644
--- a/Python/4sum.py
+++ b/Python/4sum.py
@@ -1,5 +1,5 @@
-# Time:  O(n^2) ~ O(n^4)
-# Space: O(n^2)
+# Time:  O(n^2 * p)
+# Space: O(n^2 * p)
 #
 # Given an array S of n integers, 
 # are there elements a, b, c, and d in S such that a + b + c + d = target?
@@ -17,6 +17,36 @@
 #
 
 class Solution:
+    # @return a list of lists of length 4, [[val1,val2,val3,val4]]
+    def fourSum(self, nums, target):
+        nums, result, lookup = sorted(nums), [], {}
+        for i in xrange(0, len(nums) - 1):
+            for j in xrange(i + 1, len(nums)): 
+                if nums[i] + nums[j] not in lookup:
+                    lookup[nums[i] + nums[j]] = []
+                is_duplicated = False
+                for [x, y] in lookup[nums[i] + nums[j]]:
+                    if nums[x] == nums[i]:
+                        is_duplicated = True
+                        break
+                if not is_duplicated:
+                    lookup[nums[i] + nums[j]].append([i, j])
+        ans = {}
+        for c in xrange(2, len(nums)):
+            for d in xrange(c+1, len(nums)):
+                if target - nums[c] - nums[d] in lookup:
+                    for [a, b] in lookup[target - nums[c] - nums[d]]:
+                        if b < c:
+                            quad = [nums[a], nums[b], nums[c], nums[d]]
+                            quad_hash = " ".join(str(quad))
+                            if quad_hash not in ans:
+                                ans[quad_hash] = True
+                                result.append(quad)
+        return result
+
+# Time:  O(n^2 * p) ~ O(n^4)
+# Space: O(n^2)
+class Solution2:
     # @return a list of lists of length 4, [[val1,val2,val3,val4]]
     def fourSum(self, nums, target):
         nums, result, lookup = sorted(nums), [], {}
diff --git a/Python/add-and-search-word-data-structure-design.py b/Python/add-and-search-word-data-structure-design.py
new file mode 100644
index 000000000..384b97d64
--- /dev/null
+++ b/Python/add-and-search-word-data-structure-design.py
@@ -0,0 +1,67 @@
+# Time:  O(min(n, h)), per operation
+# Space: O(min(n, h))
+#
+# Design a data structure that supports the following two operations:
+#
+# void addWord(word)
+# bool search(word)
+# search(word) can search a literal word or a regular expression string containing only letters a-z or .. 
+# A . means it can represent any one letter.
+#
+# For example:
+#
+# addWord("bad")
+# addWord("dad")
+# addWord("mad")
+# search("pad") -> false
+# search("bad") -> true
+# search(".ad") -> true
+# search("b..") -> true
+# Note:
+# You may assume that all words are consist of lowercase letters a-z.
+#
+
+class TrieNode:
+    # Initialize your data structure here.
+    def __init__(self):
+        self.is_string = False
+        self.leaves = {}
+        
+class WordDictionary:
+    def __init__(self):
+        self.root = TrieNode()
+        
+    # @param {string} word
+    # @return {void}
+    # Adds a word into the data structure.
+    def addWord(self, word):
+        curr = self.root
+        for c in word:
+            if not c in curr.leaves:
+                curr.leaves[c] = TrieNode()
+            curr = curr.leaves[c]
+        curr.is_string = True
+
+    # @param {string} word
+    # @return {boolean}
+    # Returns if the word is in the data structure. A word could
+    # contain the dot character '.' to represent any one letter.
+    def search(self, word):
+        return self.searchHelper(word, 0, self.root)
+        
+    def searchHelper(self, word, start, curr):
+        if start == len(word):
+            return curr.is_string
+        if word[start] in curr.leaves:
+            return self.searchHelper(word, start+1, curr.leaves[word[start]])
+        elif word[start] == '.':
+            for c in curr.leaves:
+                if self.searchHelper(word, start+1, curr.leaves[c]):
+                    return True
+       
+        return False
+
+# Your WordDictionary object will be instantiated and called as such:
+# wordDictionary = WordDictionary()
+# wordDictionary.addWord("word")
+# wordDictionary.search("pattern")
diff --git a/Python/binary-tree-right-side-view.py b/Python/binary-tree-right-side-view.py
new file mode 100644
index 000000000..56d5e3db2
--- /dev/null
+++ b/Python/binary-tree-right-side-view.py
@@ -0,0 +1,73 @@
+# Time:  O(n)
+# Space: O(h)
+#
+# Given a binary tree, imagine yourself standing on the right side of it, 
+# return the values of the nodes you can see ordered from top to bottom.
+#
+# For example:
+# Given the following binary tree,
+#    1            <---
+#  /   \
+# 2     3         <---
+#  \     \
+#   5     4       <---
+# You should return [1, 3, 4].
+#
+
+# Definition for a  binary tree node
+class TreeNode:
+    def __init__(self, x):
+        self.val = x
+        self.left = None
+        self.right = None
+
+class Solution:
+    # @param root, a tree node
+    # @return a list of integers
+    def rightSideView(self, root):
+        result = []
+        self.rightSideViewDFS(root, 1, result)
+        return result
+    
+    def rightSideViewDFS(self, node, depth, result):
+        if not node:
+            return
+        
+        if depth > len(result):
+            result.append(node.val)
+        
+        self.rightSideViewDFS(node.right, depth+1, result)
+        self.rightSideViewDFS(node.left, depth+1, result)
+
+# BFS solution
+# Time:  O(n)
+# Space: O(n)        
+class Solution2:
+    # @param root, a tree node
+    # @return a list of integers
+    def rightSideView(self, root):
+        if root is None:
+            return []
+            
+        result, current = [], [root]
+        while current:
+            next_level = []
+            for i, node in enumerate(current):
+                if node.left:
+                    next_level.append(node.left)
+                if node.right:
+                    next_level.append(node.right)
+                if i == len(current) - 1:
+                    result.append(node.val)
+            current = next_level
+            
+        return result
+
+if __name__ == "__main__":
+    root = TreeNode(1)
+    root.left = TreeNode(2)
+    root.right = TreeNode(3)
+    root.left.right = TreeNode(5)
+    root.right.right = TreeNode(4)
+    result = Solution().rightSideView(root)
+    print result
diff --git a/Python/bitwise-and-of-numbers-range.py b/Python/bitwise-and-of-numbers-range.py
new file mode 100644
index 000000000..f8b269d22
--- /dev/null
+++ b/Python/bitwise-and-of-numbers-range.py
@@ -0,0 +1,22 @@
+# Time:  O(1)
+# Space: O(1)
+#
+# Given a range [m, n] where 0 <= m <= n <= 2147483647, 
+# return the bitwise AND of all numbers in this range, inclusive.
+#
+# For example, given the range [5, 7], you should return 4.
+#
+
+class Solution:
+    # @param m, an integer
+    # @param n, an integer
+    # @return an integer
+    def rangeBitwiseAnd(self, m, n):
+        i, diff = 0, n-m
+        while diff:
+            diff >>= 1
+            i += 1
+        return n&m >> i << i
+
+if __name__ == '__main__':
+    print Solution().rangeBitwiseAnd(5, 7)
diff --git a/Python/combination-sum-iii.py b/Python/combination-sum-iii.py
new file mode 100644
index 000000000..eb2ce4407
--- /dev/null
+++ b/Python/combination-sum-iii.py
@@ -0,0 +1,45 @@
+# Time:  O(C(n, k))
+# Space: O(k)
+#
+# Find all possible combinations of k numbers that add up to a number n,
+# given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.
+#
+# Ensure that numbers within the set are sorted in ascending order.
+#
+#
+# Example 1:
+#
+# Input: k = 3, n = 7
+#
+# Output:
+#
+# [[1,2,4]]
+#
+# Example 2:
+#
+# Input: k = 3, n = 9
+#
+# Output:
+#
+# [[1,2,6], [1,3,5], [2,3,4]]
+#
+
+class Solution:
+    # @param {integer} k
+    # @param {integer} n
+    # @return {integer[][]}
+    def combinationSum3(self, k, n):
+        result = []
+        self.combinationSumRecu(result, [], 1, k, n)
+        return result
+    
+    def combinationSumRecu(self, result, intermediate, start, k, target):
+        if k == 0 and target == 0:
+            result.append(list(intermediate))
+        elif k < 0:
+            return
+        while start < 10 and start * k + k * (k - 1) / 2 <= target:
+            intermediate.append(start)
+            self.combinationSumRecu(result, intermediate, start + 1, k - 1, target - start)
+            intermediate.pop()
+            start += 1
diff --git a/Python/contains-duplicate-ii.py b/Python/contains-duplicate-ii.py
new file mode 100644
index 000000000..451a6bdde
--- /dev/null
+++ b/Python/contains-duplicate-ii.py
@@ -0,0 +1,24 @@
+# Time:  O(n)
+# Space: O(n)
+#
+# Given an array of integers and an integer k, return true if 
+# and only if there are two distinct indices i and j in the array 
+# such that nums[i] = nums[j] and the difference between i and j is at most k.
+#
+
+class Solution:
+    # @param {integer[]} nums
+    # @param {integer} k
+    # @return {boolean}
+    def containsNearbyDuplicate(self, nums, k):
+        lookup = {}
+        for i, num in enumerate(nums):
+            if num not in lookup:
+                lookup[num] = i
+            else:
+                # It the value occurs before, check the difference.
+                if i - lookup[num] <= k:
+                    return True
+                # Update the index of the value.
+                lookup[num] = i
+        return False
diff --git a/Python/contains-duplicate-iii.py b/Python/contains-duplicate-iii.py
new file mode 100644
index 000000000..42841b948
--- /dev/null
+++ b/Python/contains-duplicate-iii.py
@@ -0,0 +1,34 @@
+# Time:  O(n * t)
+# Space: O(max(k, t))
+#
+# Given an array of integers, find out whether there 
+# are two distinct inwindowes i and j in the array such 
+# that the difference between nums[i] and nums[j] is 
+# at most t and the difference between i and j is at 
+# most k.
+#
+
+# This is not the best solution 
+# since there is no built-in bst structure in Python.
+# The better solution could be found in C++ solution.
+class Solution:
+    # @param {integer[]} nums
+    # @param {integer} k
+    # @param {integer} t
+    # @return {boolean}
+    def containsNearbyAlmostDuplicate(self, nums, k, t):
+        if k < 0 or t < 0:
+            return False
+        window = collections.OrderedDict()
+        for n in nums:
+            # Make sure window size
+            if len(window) > k:
+                window.popitem(False)
+                
+            bucket = n if not t else n // t
+            # At most 2t items.
+            for m in (window.get(bucket - 1), window.get(bucket), window.get(bucket + 1)):
+                if m is not None and abs(n - m) <= t:
+                    return True
+            window[bucket] = n
+        return False
diff --git a/Python/contains-duplicate.py b/Python/contains-duplicate.py
new file mode 100644
index 000000000..16c26a3c3
--- /dev/null
+++ b/Python/contains-duplicate.py
@@ -0,0 +1,13 @@
+# Time:  O(n)
+# Space: O(n)
+#
+# Given an array of integers, find if the array contains any duplicates.
+# Your function should return true if any value appears at least twice in the array, 
+# and it should return false if every element is distinct.
+#
+
+class Solution:
+    # @param {integer[]} nums
+    # @return {boolean}
+    def containsDuplicate(self, nums):
+        return len(nums) > len(set(nums))
diff --git a/Python/count-primes.py b/Python/count-primes.py
new file mode 100644
index 000000000..8c3337efd
--- /dev/null
+++ b/Python/count-primes.py
@@ -0,0 +1,30 @@
+# Time:  O(n)
+# Space: O(n)
+# Description:
+#
+# Count the number of prime numbers less than a non-negative number, n
+#
+# Hint: The number n could be in the order of 100,000 to 5,000,000.
+#
+
+from math import sqrt
+
+class Solution:
+    # @param {integer} n
+    # @return {integer}
+    def countPrimes(self, n):
+        if n <= 2:
+            return 0
+        
+        is_prime = [True] * n
+        sqr = sqrt(n - 1)
+        
+        num = 0
+        for i in xrange(2, n):
+            if is_prime[i]:
+               num += 1
+               for j in xrange(i+i, n, i):
+                   is_prime[j] = False
+                   
+        return num
+                
diff --git a/Python/course-schedule-ii.py b/Python/course-schedule-ii.py
new file mode 100644
index 000000000..d6701a084
--- /dev/null
+++ b/Python/course-schedule-ii.py
@@ -0,0 +1,72 @@
+# Time:  O(|V| + |E|)
+# Space: O(|E|)
+
+# There are a total of n courses you have to take, labeled from 0 to n - 1.
+# 
+# Some courses may have prerequisites, for example to take course 0 you have to first take course 1, 
+# which is expressed as a pair: [0,1]
+# 
+# Given the total number of courses and a list of prerequisite pairs, return the ordering of courses 
+# you should take to finish all courses.
+# 
+# There may be multiple correct orders, you just need to return one of them. If it is impossible 
+# to finish all courses, return an empty array.
+# 
+# For example:
+# 
+# 2, [[1,0]]
+# There are a total of 2 courses to take. To take course 1 you should have finished course 0.
+# So the correct course order is [0,1]
+# 
+# 4, [[1,0],[2,0],[3,1],[3,2]]
+# There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2.
+# Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. 
+# Another correct ordering is[0,2,1,3].
+# 
+# Note:
+# The input prerequisites is a graph represented by a list of edges, not adjacency matrices. 
+# Read more about how a graph is represented.
+# 
+# Hints:
+# This problem is equivalent to finding the topological order in a directed graph. 
+# If a cycle exists, no topological ordering exists and therefore it will be impossible to take all courses.
+# Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera explaining 
+# the basic concepts of Topological Sort.
+# Topological sort could also be done via BFS.
+# 
+
+class Solution:
+    # @param {integer} numCourses
+    # @param {integer[][]} prerequisites
+    # @return {integer[]}
+    def findOrder(self, numCourses, prerequisites):
+        res, zero_in_degree_queue, in_degree, out_degree = [], [], {}, {}
+        
+        for i, j in prerequisites:
+            if i not in in_degree:
+                in_degree[i] = {}
+            if j not in out_degree:
+                out_degree[j] = {}
+            in_degree[i][j] = True
+            out_degree[j][i] = True
+        
+        for i in xrange(numCourses):
+            if i not in in_degree:
+                zero_in_degree_queue.append(i)
+        
+        while zero_in_degree_queue:
+            prerequisite = zero_in_degree_queue.pop()
+            res.append(prerequisite)
+            
+            if prerequisite in out_degree:
+                for course in out_degree[prerequisite]:
+                    del in_degree[course][prerequisite]
+                    if not in_degree[course]:
+                        zero_in_degree_queue.append(course)
+            
+                del out_degree[prerequisite]
+        
+        if len(out_degree):
+            return []
+        
+        return res
diff --git a/Python/course-schedule.py b/Python/course-schedule.py
new file mode 100644
index 000000000..80542d46f
--- /dev/null
+++ b/Python/course-schedule.py
@@ -0,0 +1,69 @@
+# Time:  O(|V| + |E|)
+# Space: O(|E|)
+#
+# There are a total of n courses you have to take, labeled from 0 to n - 1.
+# 
+# Some courses may have prerequisites, for example to take course 0 
+# you have to first take course 1, which is expressed as a pair: [0,1]
+# 
+# Given the total number of courses and a list of prerequisite pairs,
+#  is it possible for you to finish all courses?
+# 
+# For example:
+# 
+# 2, [[1,0]]
+# There are a total of 2 courses to take. To take course 1 
+# you should have finished course 0. So it is possible.
+# 
+# 2, [[1,0],[0,1]]
+# There are a total of 2 courses to take. To take course 1 you should have 
+# finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.
+# 
+# click to show more hints.
+# 
+# Hints:
+# This problem is equivalent to finding if a cycle exists in a directed graph. 
+# If a cycle exists, no topological ordering exists and therefore it will be impossible to take all courses.
+# There are several ways to represent a graph. For example, the input prerequisites is a graph represented by
+#  a list of edges. Is this graph representation appropriate?
+# Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera explaining the basic concepts
+#  of Topological Sort.
+# Topological sort could also be done via BFS.
+#
+class Solution:
+    # @param {integer} numCourses
+    # @param {integer[][]} prerequisites
+    # @return {boolean}
+    def canFinish(self, numCourses, prerequisites):
+        zero_in_degree_queue, in_degree, out_degree = [], {}, {}
+        
+        for i, j in prerequisites:
+            if i not in in_degree:
+                in_degree[i] = {}
+            if j not in out_degree:
+                out_degree[j] = {}
+            in_degree[i][j] = True
+            out_degree[j][i] = True
+        
+        for i in xrange(numCourses):
+            if i not in in_degree:
+                zero_in_degree_queue.append(i)
+        
+        while zero_in_degree_queue:
+            prerequisite = zero_in_degree_queue.pop()
+            
+            if prerequisite in out_degree:
+                for course in out_degree[prerequisite]:
+                    del in_degree[course][prerequisite]
+                    if not in_degree[course]:
+                        zero_in_degree_queue.append(course)
+            
+                del out_degree[prerequisite]
+        
+        if len(out_degree):
+            return False
+        
+        return True
+
+if __name__ == "__main__":
+    print Solution().canFinish(1, [])
\ No newline at end of file
diff --git a/Python/find-peak-element.py b/Python/find-peak-element.py
index 84eb19221..1fe1ac83b 100644
--- a/Python/find-peak-element.py
+++ b/Python/find-peak-element.py
@@ -30,10 +30,9 @@ def findPeakElement(self, num):
                 high = mid - 1
             else:
                 low = mid + 1
-            mid = low + (high - low) / 2
        
         return low
 
 if __name__ == "__main__":
    # print Solution().findPeakElement([1,2,1])
-    print Solution().findPeakElement([1,2,3, 1])
\ No newline at end of file
+    print Solution().findPeakElement([1,2,3, 1])
diff --git a/Python/happy-number.py b/Python/happy-number.py
new file mode 100644
index 000000000..7ea4a5675
--- /dev/null
+++ b/Python/happy-number.py
@@ -0,0 +1,34 @@
+# Time:  O(k), where k is the steps to be happy number
+# Space: O(k)
+#
+# Write an algorithm to determine if a number is "happy".
+#
+# A happy number is a number defined by the following process: 
+# Starting with any positive integer, replace the number by the sum 
+# of the squares of its digits, and repeat the process until 
+# the number equals 1 (where it will stay), or it loops endlessly 
+# in a cycle which does not include 1. Those numbers for which 
+# this process ends in 1 are happy numbers.
+#
+# Example: 19 is a happy number
+#
+# 1^2 + 9^2 = 82
+# 8^2 + 2^2 = 68
+# 6^2 + 8^2 = 100
+# 1^2 + 0^2 + 0^2 = 1
+#
+class Solution:
+    # @param {integer} n
+    # @return {boolean}
+    def isHappy(self, n):
+        lookup = {}
+        while n != 1 and n not in lookup:
+            lookup[n] = True
+            n = self.nextNumber(n)
+        return n == 1
+    
+    def nextNumber(self, n):
+        new = 0
+        for char in str(n):
+            new += int(char)**2
+        return new
diff --git a/Python/house-robber-ii.py b/Python/house-robber-ii.py
new file mode 100644
index 000000000..554ed4828
--- /dev/null
+++ b/Python/house-robber-ii.py
@@ -0,0 +1,37 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# Note: This is an extension of House Robber.
+#
+# After robbing those houses on that street, the thief has found himself a new place 
+# for his thievery so that he will not get too much attention. This time, all houses 
+# at this place are arranged in a circle. That means the first house is the neighbor 
+# of the last one. Meanwhile, the security system for these houses remain the same as 
+# for those in the previous street.
+#
+# Given a list of non-negative integers representing the amount of money of each house, 
+# determine the maximum amount of money you can rob tonight without alerting the police.
+#
+class Solution:
+    # @param {integer[]} nums
+    # @return {integer}
+    def rob(self, nums):
+        if len(nums) == 0:
+            return 0
+            
+        if len(nums) == 1:
+            return nums[0]
+        
+        return max(self.robRange(nums, 0, len(nums) - 1),\
+                   self.robRange(nums, 1, len(nums)))
+    
+    def robRange(self, nums, start, end):
+        num_i, num_i_1 = nums[start], 0
+        for i in xrange(start + 1, end):
+            num_i_1, num_i_2 = num_i, num_i_1
+            num_i = max(nums[i] + num_i_2, num_i_1);
+        
+        return num_i
+
+if __name__ == '__main__':
+        print Solution().rob([8,4,8,5,9,6,5,4,4,10])
diff --git a/Python/house-robber.py b/Python/house-robber.py
new file mode 100644
index 000000000..db2379811
--- /dev/null
+++ b/Python/house-robber.py
@@ -0,0 +1,30 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# You are a professional robber planning to rob houses along a street. 
+# Each house has a certain amount of money stashed, the only constraint stopping you 
+# from robbing each of them is that adjacent houses have security system connected
+# and it will automatically contact the police if two adjacent houses were broken into on the same night.
+#
+# Given a list of non-negative integers representing the amount of money of each house, 
+# determine the maximum amount of money you can rob tonight without alerting the police.
+#
+class Solution:
+    # @param num, a list of integer
+    # @return an integer
+    def rob(self, num):
+        if len(num) == 0:
+            return 0
+            
+        if len(num) == 1:
+            return num[0]
+        
+        num_i, num_i_1 = max(num[1], num[0]), num[0]
+        for i in xrange(2, len(num)):
+            num_i_1, num_i_2 = num_i, num_i_1
+            num_i = max(num[i] + num_i_2, num_i_1);
+        
+        return num_i
+
+if __name__ == '__main__':
+        print Solution().rob([8,4,8,5,9,6,5,4,4,10])
diff --git a/Python/implement-strstr.py b/Python/implement-strstr.py
index 9b7149b10..b57b11261 100644
--- a/Python/implement-strstr.py
+++ b/Python/implement-strstr.py
@@ -40,7 +40,7 @@ def KMP(self, text, pattern):
     
     def getPrefix(self, pattern):
         prefix = [-1] * len(pattern)
-        j = - 1
+        j = -1
         for i in xrange(1, len(pattern)):
             while j > -1 and pattern[j + 1] != pattern[i]:
                 j = prefix[j]
diff --git a/Python/implement-trie-prefix-tree.py b/Python/implement-trie-prefix-tree.py
new file mode 100644
index 000000000..c52003ae3
--- /dev/null
+++ b/Python/implement-trie-prefix-tree.py
@@ -0,0 +1,61 @@
+# Time:  O(n), per operation
+# Space: O(1)
+#
+# Implement a trie with insert, search, and startsWith methods.
+#
+# Note:
+# You may assume that all inputs are consist of lowercase letters a-z.
+#
+
+class TrieNode:
+    # Initialize your data structure here.
+    def __init__(self):
+        self.is_string = False
+        self.leaves = {}
+        
+
+class Trie:
+
+    def __init__(self):
+        self.root = TrieNode()
+
+    # @param {string} word
+    # @return {void}
+    # Inserts a word into the trie.
+    def insert(self, word):
+        cur = self.root
+        for c in word:
+            if not c in cur.leaves:
+                cur.leaves[c] = TrieNode()
+            cur = cur.leaves[c]
+        cur.is_string = True
+
+    # @param {string} word
+    # @return {boolean}
+    # Returns if the word is in the trie.
+    def search(self, word):
+        res, node = self.childSearch(word)
+        if res:
+            return node.is_string
+        return False        
+
+    # @param {string} prefix
+    # @return {boolean}
+    # Returns if there is any word in the trie
+    # that starts with the given prefix.
+    def startsWith(self, prefix):
+        return self.childSearch(prefix)[0]
+
+    def childSearch(self, word):
+        cur = self.root
+        for c in word:
+            if c in cur.leaves:
+                cur = cur.leaves[c]
+            else:
+                return False, None
+        return True, cur
+
+# Your Trie object will be instantiated and called as such:
+# trie = Trie()
+# trie.insert("somestring")
+# trie.search("key")
diff --git a/Python/isomorphic-strings.py b/Python/isomorphic-strings.py
new file mode 100644
index 000000000..d65bdb00d
--- /dev/null
+++ b/Python/isomorphic-strings.py
@@ -0,0 +1,40 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# Given two strings s and t, determine if they are isomorphic.
+#
+# Two strings are isomorphic if the characters in s can be replaced to get t.
+#
+# All occurrences of a character must be replaced with another character 
+# while preserving the order of characters. No two characters may map to 
+# the same character but a character may map to itself.
+#
+# For example,
+# Given "egg", "add", return true.
+#
+# Given "foo", "bar", return false.
+#
+# Given "paper", "title", return true.
+#
+# Note:
+# You may assume both s and t have the same length.
+#
+
+class Solution:
+    # @param {string} s
+    # @param {string} t
+    # @return {boolean}
+    def isIsomorphic(self, s, t):
+        if len(s) != len(t):
+            return False
+    
+        return self.halfIsom(s, t) and self.halfIsom(t, s)
+
+    def halfIsom(self, s, t):
+        res = {}
+        for i in xrange(len(s)):
+            if s[i] not in res:
+                res[s[i]] = t[i]
+            elif res[s[i]] != t[i]:
+                return False
+        return True
diff --git a/Python/jump-game-ii.py b/Python/jump-game-ii.py
index 6a660882e..bd771dabf 100644
--- a/Python/jump-game-ii.py
+++ b/Python/jump-game-ii.py
@@ -1,4 +1,4 @@
-# Time:  O(n^2)
+# Time:  O(n)
 # Space: O(1)
 #
 # Given an array of non-negative integers, you are initially positioned at the first index of the array.
@@ -14,6 +14,24 @@
 #
 
 class Solution:
+    # @param A, a list of integers
+    # @return an integer
+    def jump(self, A):
+        jump_count = 0
+        reachable = 0
+        curr_reachable = 0
+        for i, length in enumerate(A):
+            if i > reachable:
+                return -1
+            if i > curr_reachable:
+                curr_reachable = reachable
+                jump_count += 1
+            reachable = max(reachable, i + length)
+        return jump_count
+
+# Time:  O(n^2)
+# Space: O(1)     
+class Solution2:
     # @param A, a list of integers
     # @return an integer
     def jump(self, A):
diff --git a/Python/kth-largest-element-in-an-array.py b/Python/kth-largest-element-in-an-array.py
new file mode 100644
index 000000000..fe6b8d9c0
--- /dev/null
+++ b/Python/kth-largest-element-in-an-array.py
@@ -0,0 +1,33 @@
+# Time:  O(n)
+# Space: O(1)
+
+from random import randint
+
+class Solution:
+    # @param {integer[]} nums
+    # @param {integer} k
+    # @return {integer}
+    def findKthLargest(self, nums, k):
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            pivot_idx = randint(left, right)
+            new_pivot_idx = self.PartitionAroundPivot(left, right, pivot_idx, nums)
+            if new_pivot_idx == k - 1:
+                return nums[new_pivot_idx]
+            elif new_pivot_idx > k - 1:
+                right = new_pivot_idx - 1
+            else:  # new_pivot_idx < k - 1.
+                left = new_pivot_idx + 1
+        
+    def PartitionAroundPivot(self, left, right, pivot_idx, nums):
+        pivot_value = nums[pivot_idx]
+        new_pivot_idx = left
+        nums[pivot_idx], nums[right] = nums[right], nums[pivot_idx]
+        for i in xrange(left, right):
+            if nums[i] > pivot_value:
+                nums[i], nums[new_pivot_idx] =  nums[new_pivot_idx], nums[i]
+                new_pivot_idx += 1
+            
+        nums[right], nums[new_pivot_idx] = nums[new_pivot_idx], nums[right]
+        return new_pivot_idx
+        
diff --git a/Python/largest-number.py b/Python/largest-number.py
index ab28367cf..8317a617b 100644
--- a/Python/largest-number.py
+++ b/Python/largest-number.py
@@ -1,5 +1,5 @@
-# Time:  O(n^2)
-# Space: O(n)
+# Time:  O(nlogn)
+# Space: O(1)
 #
 # Given a list of non negative integers, arrange them such that they form the largest number.
 # 
diff --git a/Python/letter-combinations-of-a-phone-number.py b/Python/letter-combinations-of-a-phone-number.py
index c3d5e7779..f25d8bcc8 100644
--- a/Python/letter-combinations-of-a-phone-number.py
+++ b/Python/letter-combinations-of-a-phone-number.py
@@ -17,25 +17,33 @@
 class Solution:
     # @return a list of strings, [s1, s2]
     def letterCombinations(self, digits):
-        lookup, result = ["", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"], [""]
+        if not digits:
+            return []
+            
+        lookup, result = ["", "", "abc", "def", "ghi", "jkl", "mno", \
+                          "pqrs", "tuv", "wxyz"], [""]
 
-        for digit in digits:
+        for digit in reversed(digits):
             choices = lookup[int(digit)]
             m, n = len(choices), len(result)
             result.extend([result[i % n] for i in xrange(n, m * n)])    
 
             for i in xrange(m * n):
-                result[i] += choices[i / n]
+                result[i] = choices[i / n] + result[i] 
             
         return result
 
+
 # Time:  O(n * 4^n)
 # Space: O(n)
 # Recursive Solution
 class Solution2:
     # @return a list of strings, [s1, s2]
     def letterCombinations(self, digits):
-        lookup, result = ["", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"], []
+        if not digits:
+            return []
+        lookup, result = ["", "", "abc", "def", "ghi", "jkl", "mno", \
+                          "pqrs", "tuv", "wxyz"], []
         self.letterCombinationsRecu(result, digits, lookup, "", 0)
         return result
     
diff --git a/Python/maximum-gap.py b/Python/maximum-gap.py
index 6bc30d14f..fd574a9ac 100644
--- a/Python/maximum-gap.py
+++ b/Python/maximum-gap.py
@@ -15,47 +15,47 @@
 #
 
 # bucket sort
+# Time:  O(n)
+# Space: O(n)
+
 class Solution:
-    # @param num, a list of integer
-    # @return an integer
-    def maximumGap(self, num):
-        if len(num) < 2:
+     # @param numss: a list of integers
+     # @return: the maximum difference
+    def maximumGap(self, nums):
+        if len(nums) < 2:
             return 0
         
-        unique_num = self.removeDuplicate(num)
-        
-        max_val, min_val = max(unique_num), min(unique_num)
-        gap = (max_val - min_val) / (len(unique_num) - 1)
+        # Init bucket.
+        max_val, min_val = max(nums), min(nums)
+        gap = max(1, (max_val - min_val) / (len(nums) - 1))
         bucket_size = (max_val - min_val) / gap + 1
-        max_bucket = [float("-inf") for _ in xrange(bucket_size)]
-        min_bucket = [float("inf") for _ in xrange(bucket_size)]
+        bucket = [{'min':float("inf"), 'max':float("-inf")} \
+                    for _ in xrange(bucket_size)]
 
-        for i in unique_num:
-            if i in (max_val, min_val):
+        # Find the bucket where the n should be put.
+        for n in nums:
+            # min_val / max_val is in the first / last bucket.
+            if n in (max_val, min_val):
                 continue      
-            idx = (i - min_val) / gap
-            max_bucket[idx] = max(max_bucket[idx], i)
-            min_bucket[idx] = min(min_bucket[idx], i)
+            i = (n - min_val) / gap
+            bucket[i]['min'] = min(bucket[i]['min'], n)
+            bucket[i]['max'] = max(bucket[i]['max'], n)
         
-        max_gap = 0
-        pre = min_val
+        # Count each bucket gap between the first and the last bucket.
+        max_gap, pre_bucket_max = 0, min_val
         for i in xrange(bucket_size):
-            if max_bucket[i] == float("-inf") and min_bucket[i] == float("inf"):
+            # Skip the bucket it empty.
+            if bucket[i]['min'] == float("inf") and \
+                bucket[i]['max'] == float("-inf"):
                 continue
-            max_gap = max(max_gap, min_bucket[i] - pre)
-            pre = max_bucket[i]
-        max_gap = max(max_gap, max_val - pre)
+            max_gap = max(max_gap, bucket[i]['min'] - pre_bucket_max)
+            pre_bucket_max = bucket[i]['max']
+        # Count the last bucket.
+        max_gap = max(max_gap, max_val - pre_bucket_max) 
         
         return max_gap
-    
-    def removeDuplicate(self, num):
-        dict = {}
-        unique_num = []
-        for i in num:
-            if i not in dict:
-                unique_num.append(i)
-                dict[i] = True
-        return unique_num
+
+
 
 # Time:  O(nlogn)
 # Space: O(n)
diff --git a/Python/median-of-two-sorted-arrays.py b/Python/median-of-two-sorted-arrays.py
index 644f74927..e9708c058 100644
--- a/Python/median-of-two-sorted-arrays.py
+++ b/Python/median-of-two-sorted-arrays.py
@@ -14,6 +14,39 @@ def findMedianSortedArrays(self, A, B):
         else:
             return (self.getKth(A, B, (lenA + lenB)/2) + self.getKth(A, B, (lenA + lenB)/2 + 1)) * 0.5
             
+    def getKth(self, A, B, k):
+        m, n = len(A), len(B)
+        if m > n:
+            return self.getKth(B, A, k)
+            
+        left, right = 0, m    
+        while left < right:
+            mid = left + (right - left) / 2
+            j = k - 1 - mid
+            if 0 <= j and j < n and A[mid] >= B[j]:
+                right = mid
+            else:
+                left = mid + 1
+            
+        Ai_minus_1, Bj = float("-inf"), float("-inf")
+        if left - 1 >= 0:
+            Ai_minus_1 = A[left - 1]
+        if k - 1 - left >= 0:
+            Bj = B[k - 1 - left]
+        
+        return max(Ai_minus_1, Bj)
+            
+# Time:  O(log(m + n))
+# Space: O(1)
+class Solution2:
+    # @return a float
+    def findMedianSortedArrays(self, A, B):
+        lenA, lenB = len(A), len(B)
+        if (lenA + lenB) % 2 == 1: 
+            return self.getKth(A, B, (lenA + lenB)/2 + 1)
+        else:
+            return (self.getKth(A, B, (lenA + lenB)/2) + self.getKth(A, B, (lenA + lenB)/2 + 1)) * 0.5
+            
     def getKth(self, A, B, k):
         b = max(0, k - len(B))
         t = min(len(A), k)
@@ -46,7 +79,7 @@ def getKth(self, A, B, k):
 
 # Time:  O(log(m + n))
 # Space: O(log(m + n))
-class Solution2:
+class Solution3:
     # @return a float
     def findMedianSortedArrays(self, A, B):
         lenA, lenB = len(A), len(B)
@@ -77,7 +110,7 @@ def getKth(self, A, i, B, j, k):
             return A[i + pa - 1]
 
 # using list slicing (O(k)) may be slower than solution1
-class Solution3:
+class Solution4:
     # @return a float
     def findMedianSortedArrays(self, A, B):
         lenA, lenB = len(A), len(B)
diff --git a/Python/merge-k-sorted-lists.py b/Python/merge-k-sorted-lists.py
index 0cd4e311b..8003ec215 100644
--- a/Python/merge-k-sorted-lists.py
+++ b/Python/merge-k-sorted-lists.py
@@ -1,5 +1,5 @@
 # Time:  O(nlogk)
-# Space: O(1)
+# Space: O(k)
 #
 # Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
 import heapq
@@ -41,4 +41,4 @@ def mergeKLists(self, lists):
     list2 = ListNode(2)
     list2.next = ListNode(4)
     
-    print Solution().mergeKLists([list1, list2])
\ No newline at end of file
+    print Solution().mergeKLists([list1, list2])
diff --git a/Python/minimum-size-subarray-sum.py b/Python/minimum-size-subarray-sum.py
new file mode 100644
index 000000000..229e07aa3
--- /dev/null
+++ b/Python/minimum-size-subarray-sum.py
@@ -0,0 +1,62 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# Given an array of n positive integers and a positive integer s, 
+# find the minimal length of a subarray of which the sum ≥ s. If there isn't one, return 0 instead.
+#
+# For example, given the array [2,3,1,2,4,3] and s = 7,
+# the subarray [4,3] has the minimal length under the problem constraint.
+#
+# More practice:
+# If you have figured out the O(n) solution, try coding another solution of which the time complexity is O(n log n).
+#
+
+# Sliding window solution.
+class Solution:
+    # @param {integer} s
+    # @param {integer[]} nums
+    # @return {integer}
+    def minSubArrayLen(self, s, nums):
+        start = 0
+        sum = 0
+        min_len = float("inf")
+        for i in xrange(len(nums)):
+            sum += nums[i]
+            while sum >= s:
+                min_len = min(min_len, i - start + 1)
+                sum -= nums[start]
+                start += 1
+        if min_len == float("inf"):
+            return 0
+        return min_len
+
+# Time:  O(nlogn)
+# Space: O(n)
+# Binary search solution.
+class Solution2:
+    # @param {integer} s
+    # @param {integer[]} nums
+    # @return {integer}
+    def minSubArrayLen(self, s, nums):
+        min_size = float("inf")
+        sum_from_start = [n for n in nums]
+        for i in xrange(len(sum_from_start) - 1):
+            sum_from_start[i + 1] += sum_from_start[i]
+        for i in xrange(len(sum_from_start)):
+            end = self.binarySearch(lambda x, y: x <= y, sum_from_start, \
+                                    i, len(sum_from_start), \
+                                    sum_from_start[i] - nums[i] + s)
+            if end < len(sum_from_start):
+                min_size = min(min_size, end - i + 1)
+        if min_size == float("inf"):
+            return 0
+        return min_size
+    
+    def binarySearch(self, compare, A, start, end, target):
+        while start < end:
+            mid = start + (end - start) / 2
+            if compare(target, A[mid]):
+                end = mid
+            else:
+                start = mid + 1
+        return start
diff --git a/Python/number-of-1-bits.py b/Python/number-of-1-bits.py
new file mode 100644
index 000000000..2b34a304f
--- /dev/null
+++ b/Python/number-of-1-bits.py
@@ -0,0 +1,24 @@
+# Time:  O(m)
+# Space: O(1)
+#
+# Write a function that takes an unsigned integer 
+# and returns the number of '1' bits it has (also known as the Hamming weight).
+# 
+# For example, the 32-bit integer '11' has binary representation 00000000000000000000000000001011, 
+# so the function should return 3.
+#
+# Credits:
+# Special thanks to @ts for adding this problem and creating all test cases.
+#
+class Solution:
+    # @param n, an integer
+    # @return an integer
+    def hammingWeight(self, n):
+        result = 0
+        while n:
+            n &= n - 1
+            result += 1
+        return result
+
+if __name__ == '__main__':
+  print Solution().hammingWeight(11)
diff --git a/Python/number-of-islands.py b/Python/number-of-islands.py
new file mode 100644
index 000000000..2528d6887
--- /dev/null
+++ b/Python/number-of-islands.py
@@ -0,0 +1,56 @@
+# Time:  O(m * n)
+# Space: O(m * n)
+#
+# Given a 2d grid map of '1's (land) and '0's (water), count the number of islands. 
+# An island is surrounded by water and is formed by connecting adjacent lands horizontally 
+# or vertically. You may assume all four edges of the grid are all surrounded by water.
+#
+# Example 1:
+#
+# 11110
+# 11010
+# 11000
+# 00000
+# Answer: 1
+#
+# Example 2:
+#
+# 11000
+# 11000
+# 00100
+# 00011
+# Answer: 3
+#
+
+class Solution:
+    # @param grid, a list of list of characters
+    # @return an integer
+    def numIslands(self, grid):
+        if grid == []:
+            return 0
+    
+        row = len(grid)
+        col = len(grid[0])
+        used = [[False for j in xrange(col)] for i in xrange(row)]
+    
+        count = 0
+        for i in xrange(row):
+            for j in xrange(col):
+                if grid[i][j] == '1' and not used[i][j]:
+                    self.dfs(grid, used, row, col, i, j)
+                    count += 1
+        return count
+
+    def dfs(self, grid, used, row, col, x, y):
+        if grid[x][y] == '0' or used[x][y]:
+            return 0
+        used[x][y] = True
+    
+        if x != 0:
+            self.dfs(grid, used, row, col, x - 1, y)
+        if x != row - 1:
+            self.dfs(grid, used, row, col, x + 1, y)
+        if y != 0:
+            self.dfs(grid, used, row, col, x, y - 1)
+        if y != col - 1:
+            self.dfs(grid, used, row, col, x, y + 1)
diff --git a/Python/permutation-sequence.py b/Python/permutation-sequence.py
index 2252f26ad..a3b5e1158 100644
--- a/Python/permutation-sequence.py
+++ b/Python/permutation-sequence.py
@@ -1,5 +1,5 @@
-# Time:  O(n)
-# Space: O(1)
+# Time:  O(n^2)
+# Space: O(n)
 #
 # The set [1,2,3,...,n] contains a total of n! unique permutations.
 # 
diff --git a/Python/regular-expression-matching.py b/Python/regular-expression-matching.py
index 969a92981..194fd2f25 100644
--- a/Python/regular-expression-matching.py
+++ b/Python/regular-expression-matching.py
@@ -66,8 +66,42 @@ def isMatch(self, s, p):
                     
         return result[len(s)][len(p)]
 
-# recursive
+# iteration
 class Solution3:
+    # @return a boolean
+    def isMatch(self, s, p):
+        p_ptr, s_ptr, last_s_ptr, last_p_ptr = 0, 0, -1, -1
+        last_ptr = []
+        while s_ptr < len(s):
+            if p_ptr < len(p) and (p_ptr == len(p) - 1 or p[p_ptr + 1] != '*') and \
+            (s_ptr < len(s) and (p[p_ptr] == s[s_ptr] or p[p_ptr] == '.')):
+                    s_ptr += 1
+                    p_ptr += 1
+            elif p_ptr < len(p) - 1 and (p_ptr != len(p) - 1 and p[p_ptr + 1] == '*'):
+                p_ptr += 2
+                last_ptr.append([s_ptr, p_ptr])
+            elif  last_ptr:
+                [last_s_ptr, last_p_ptr] = last_ptr.pop()
+                while last_ptr and p[last_p_ptr - 2] != s[last_s_ptr] and p[last_p_ptr - 2] != '.':
+                    [last_s_ptr, last_p_ptr] = last_ptr.pop()
+                
+                if p[last_p_ptr - 2] == s[last_s_ptr] or p[last_p_ptr - 2] == '.':
+                    last_s_ptr += 1
+                    s_ptr = last_s_ptr
+                    p_ptr = last_p_ptr
+                    last_ptr.append([s_ptr, p_ptr])
+                else:
+                    return False
+            else:
+                return False
+            
+        while p_ptr < len(p) - 1 and p[p_ptr] == '.' and p[p_ptr + 1] == '*':
+            p_ptr += 2
+        
+        return p_ptr == len(p)
+    
+# recursive
+class Solution4:
     # @return a boolean
     def isMatch(self, s, p):
         if not p:
@@ -86,7 +120,7 @@ def isMatch(self, s, p):
             return self.isMatch(s, p[2:])
 
 if __name__ == "__main__":
-    print Solution().isMatch("abcd","d*")
+    print Solution3().isMatch("abab", "a*b*")
     print Solution().isMatch("aaaaaaaaaaaaab", "a*a*a*a*a*a*a*a*a*a*c")
     print Solution().isMatch("aa","a")
     print Solution().isMatch("aa","aa")
diff --git a/Python/remove-linked-list-elements.py b/Python/remove-linked-list-elements.py
new file mode 100644
index 000000000..347370e88
--- /dev/null
+++ b/Python/remove-linked-list-elements.py
@@ -0,0 +1,35 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# Remove all elements from a linked list of integers that have value val.
+#
+# Example
+# Given: 1 --> 2 --> 6 --> 3 --> 4 --> 5 --> 6, val = 6
+# Return: 1 --> 2 --> 3 --> 4 --> 5
+#
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution:
+    # @param {ListNode} head
+    # @param {integer} val
+    # @return {ListNode}
+    def removeElements(self, head, val):
+        dummy = ListNode(float("-inf"))
+        dummy.next = head
+        prev, curr = dummy, dummy.next
+        
+        while curr:
+            if curr.val == val:
+                prev.next = curr.next
+            else:
+                prev = curr
+            
+            curr = curr.next
+        
+        return dummy.next
+            
+        
diff --git a/Python/reverse-bits.py b/Python/reverse-bits.py
new file mode 100644
index 000000000..4c8a0f36d
--- /dev/null
+++ b/Python/reverse-bits.py
@@ -0,0 +1,29 @@
+# Time : O(n)
+# Space: O(1)
+#
+# Reverse bits of a given 32 bits unsigned integer.
+#
+# For example, given input 43261596 (represented in binary as 00000010100101000001111010011100), return 964176192 (represented in binary as 00111001011110000010100101000000).
+#
+# Follow up:
+# If this function is called many times, how would you optimize it?
+# 
+# Related problem: Reverse Integer
+#
+# Credits:
+# Special thanks to @ts for adding this problem and creating all test cases.
+#
+
+class Solution:
+    # @param n, an integer
+    # @return an integer
+    def reverseBits(self, n):
+        result = 0
+        for i in xrange(32):
+            result <<= 1
+            result |= n & 1
+            n >>= 1
+        return result
+            
+if __name__ == '__main__':
+  print Solution().reverseBits(1)
diff --git a/Python/reverse-linked-list.py b/Python/reverse-linked-list.py
new file mode 100644
index 000000000..8e8441ddc
--- /dev/null
+++ b/Python/reverse-linked-list.py
@@ -0,0 +1,61 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# Reverse a singly linked list.
+#
+# click to show more hints.
+#
+# Hint:
+# A linked list can be reversed either iteratively or recursively. Could you implement both?
+#
+
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+    
+    def __repr__(self):
+        if self:
+            return "{} -> {}".format(self.val, repr(self.next))
+
+# Iterative solution.
+class Solution:
+    # @param {ListNode} head
+    # @return {ListNode}
+    def reverseList(self, head):
+        dummy = ListNode(float("-inf"))
+        while head:
+            dummy.next, head.next, head = head, dummy.next, head.next
+        return dummy.next
+
+# Time:  O(n)
+# Space: O(n)
+# Recursive solution.  
+class Solution2:
+    # @param {ListNode} head
+    # @return {ListNode}
+    def reverseList(self, head):
+        [begin, end] = self.reverseListRecu(head)
+        return begin
+    
+    def reverseListRecu(self, head):
+        if not head:
+            return [None, None]
+            
+        [begin, end] = self.reverseListRecu(head.next)
+        
+        if end:
+            end.next = head
+            head.next = None
+            return [begin, head]
+        else:
+            return [head, head]
+        
+if __name__ == "__main__":
+    head = ListNode(1)
+    head.next = ListNode(2)
+    head.next.next = ListNode(3)
+    head.next.next.next = ListNode(4)
+    head.next.next.next.next = ListNode(5)
+    print Solution2().reverseList(head)
\ No newline at end of file
diff --git a/Python/rotate-image.py b/Python/rotate-image.py
index c434dffa5..dabc2734f 100644
--- a/Python/rotate-image.py
+++ b/Python/rotate-image.py
@@ -20,12 +20,12 @@ def rotate(self, matrix):
         # anti-diagonal mirror
         for i in xrange(n):
             for j in xrange(n - i):
-                matrix[i][j], matrix[n - 1 - j][n - 1 -i] = matrix[n - 1 - j][n - 1 -i], matrix[i][j]
+                matrix[i][j], matrix[n-1-j][n-1-i] = matrix[n-1-j][n-1-i], matrix[i][j]
         
         # horizontal mirror
         for i in xrange(n / 2):
             for j in xrange(n):
-                matrix[i][j], matrix[n - 1 - i][j] = matrix[n - 1 - i][j], matrix[i][j]
+                matrix[i][j], matrix[n-1-i][j] = matrix[n-1-i][j], matrix[i][j]
                 
         return matrix
                 
diff --git a/Python/search-for-a-range.py b/Python/search-for-a-range.py
index 505961eed..6e6c84d7b 100644
--- a/Python/search-for-a-range.py
+++ b/Python/search-for-a-range.py
@@ -17,10 +17,12 @@ class Solution:
     # @param target, an integer to be searched
     # @return a list of length 2, [index1, index2]
     def searchRange(self, A, target):
-        left = self.binarySearch(lambda x, y: x > y, A, target)
+        # Find the first index where target <= A[idx]
+        left = self.binarySearch(lambda x, y: x <= y, A, target)
         if left >= len(A) or A[left] != target:
             return [-1, -1]
-        right = self.binarySearch(lambda x, y: x >= y, A, target)
+        # Find the first index where target < A[idx]
+        right = self.binarySearch(lambda x, y: x < y, A, target)
         return [left, right - 1]
     
     def binarySearch(self, compare, A, target):
@@ -28,11 +30,31 @@ def binarySearch(self, compare, A, target):
         while start < end:
             mid = start + (end - start) / 2
             if compare(target, A[mid]):
+                end = mid
+            else:
                 start = mid + 1
+        return start
+    
+    def binarySearch2(self, compare, A, target):
+        start, end = 0, len(A) - 1
+        while start <= end:
+            mid = start + (end - start) / 2
+            if compare(target, A[mid]):
+                end = mid - 1
             else:
-                end = mid
+                start = mid + 1
         return start
+    
+    def binarySearch3(self, compare, A, target):
+        start, end = -1, len(A)
+        while end - start > 1:
+            mid = start + (end - start) / 2
+            if compare(target, A[mid]):
+                end = mid
+            else:
+                start = mid
+        return end
 
 if __name__ == "__main__":
     print Solution().searchRange([2, 2], 3)
-    print Solution().searchRange([5, 7, 7, 8, 8, 10], 8)
\ No newline at end of file
+    print Solution().searchRange([5, 7, 7, 8, 8, 10], 8)
diff --git a/Python/shortest-palindrome.py b/Python/shortest-palindrome.py
new file mode 100644
index 000000000..f43dada73
--- /dev/null
+++ b/Python/shortest-palindrome.py
@@ -0,0 +1,63 @@
+# Time:  O(n)
+# Space: O(n)
+
+# KMP Algorithm
+class Solution:
+    # @param {string} s
+    # @return {string}
+    def shortestPalindrome(self, s):
+        if not s:
+            return s
+            
+        A = s + s[::-1]
+        prefix = self.getPrefix(A)
+            
+        return s[prefix[-1]+1:][::-1] + s
+        
+    def getPrefix(self, pattern):
+        prefix = [-1] * len(pattern)
+        j = -1
+        for i in xrange(1, len(pattern)):
+            while j > -1 and pattern[j+1] != pattern[i]:
+                j = prefix[j]
+            if pattern[j+1] == pattern[i]:
+                j += 1
+            prefix[i] = j
+        return prefix
+
+# Manacher's Algorithm
+class Solution_TLE:
+    # @param {string} s
+    # @return {string}
+    def shortestPalindrome(self, s):
+        string = self.preProcess(s)
+        palindrome = [0] * len(string) 
+        center, right = 0, 0
+        for i in xrange(1, len(string) - 1):
+            i_mirror = 2 * center - i
+            if right > i:
+                palindrome[i] = min(right - i, palindrome[i_mirror])
+            else:
+                palindrome[i] = 0
+
+            while string[i + 1 + palindrome[i]] == string[i - 1 - palindrome[i]]:
+                palindrome[i] += 1
+
+            if i + palindrome[i] > right:
+                center, right = i, i + palindrome[i]       
+        
+        max_len = 0
+        for i in xrange(1, len(string) - 1):
+            if i - palindrome[i] == 1:
+                max_len = palindrome[i]
+        return s[len(s)-1:max_len-1:-1] + s
+        
+    def preProcess(self, s):
+        if not s:
+            return "^$"
+        string = "^"
+        for i in s:
+            string +=  "#" + i
+        string += "#$"
+        return string
+        
diff --git a/Python/the-skyline-problem.py b/Python/the-skyline-problem.py
new file mode 100644
index 000000000..d7e17a89c
--- /dev/null
+++ b/Python/the-skyline-problem.py
@@ -0,0 +1,115 @@
+# Time:  O(nlogn)
+# Space: O(n)
+#
+# A city's skyline is the outer contour of the silhouette formed 
+# by all the buildings in that city when viewed from a distance. 
+# Now suppose you are given the locations and height of all the 
+# buildings as shown on a cityscape photo (Figure A), write a
+# program to output the skyline formed by these buildings 
+# collectively (Figure B).
+# 
+# The geometric information of each building is represented by a 
+# triplet of integers [Li, Ri, Hi], where Li and Ri are the x 
+# coordinates of the left and right edge of the ith building, 
+# respectively, and Hi is its height. It is guaranteed that 0 <= Li, 
+# Ri <= INT_MAX, 0 < Hi <= INT_MAX, and Ri - Li > 0. You may assume 
+# all buildings are perfect rectangles grounded on an absolutely 
+# flat surface at height 0.
+# 
+# Notes:
+# 
+# The number of buildings in any input list is guaranteed to be 
+# in the range [0, 10000].
+# The input list is already sorted in ascending order by the 
+# left x position Li.
+# The output list must be sorted by the x position.
+# There must be no consecutive horizontal lines of equal height 
+# in the output skyline. 
+# For instance, [...[2 3], [4 5], [7 5], [11 5], [12 7]...] is 
+# not acceptable; 
+# the three lines of height 5 should be merged into one 
+# in the final output as such: [...[2 3], [4 5], [12 7], ...]
+#
+
+# Divide and conquer solution.
+start, end, height = 0, 1, 2
+class Solution:
+    # @param {integer[][]} buildings
+    # @return {integer[][]}
+    def getSkyline(self, buildings):
+        intervals = self.ComputeSkylineInInterval(buildings, 0, len(buildings))
+        
+        res = []
+        last_end = -1
+        for interval in intervals:
+            if last_end != -1 and last_end < interval[start]:
+                res.append([last_end, 0])
+            res.append([interval[start], interval[height]])
+            last_end = interval[end]
+        if last_end != -1:
+            res.append([last_end, 0])
+            
+        return res
+    
+    # Divide and Conquer.
+    def ComputeSkylineInInterval(self, buildings, left_endpoint, right_endpoint):
+        if right_endpoint - left_endpoint <= 1:
+            return buildings[left_endpoint:right_endpoint]
+        mid = left_endpoint + ((right_endpoint - left_endpoint) / 2)
+        left_skyline = self.ComputeSkylineInInterval(buildings, left_endpoint, mid)
+        right_skyline = self.ComputeSkylineInInterval(buildings, mid, right_endpoint)
+        return self.MergeSkylines(left_skyline, right_skyline)
+    
+    # Merge Sort.
+    def MergeSkylines(self, left_skyline, right_skyline):
+        i, j = 0, 0
+        merged = []
+        
+        while i < len(left_skyline) and j < len(right_skyline):
+            if left_skyline[i][end] < right_skyline[j][start]:
+                merged.append(left_skyline[i])
+                i += 1
+            elif right_skyline[j][end] < left_skyline[i][start]:
+                merged.append(right_skyline[j])
+                j += 1
+            elif left_skyline[i][start] <= right_skyline[j][start]:
+                i, j = self.MergeIntersectSkylines(merged, left_skyline[i], i,\
+                                                   right_skyline[j], j)
+            else: # left_skyline[i][start] > right_skyline[j][start].
+                j, i = self.MergeIntersectSkylines(merged, right_skyline[j], j, \
+                                                   left_skyline[i], i)
+        
+        # Insert the remaining skylines.
+        merged += left_skyline[i:]
+        merged += right_skyline[j:]
+        return merged
+    
+    # a[start] <= b[start]
+    def MergeIntersectSkylines(self, merged, a, a_idx, b, b_idx):
+        if a[end] <= b[end]:
+            if a[height] > b[height]:   # |aaa|
+                if b[end] != a[end]:    # |abb|b
+                    b[start] = a[end]
+                    merged.append(a)
+                    a_idx += 1
+                else:             # aaa
+                    b_idx += 1    # abb
+            elif a[height] == b[height]:  # abb
+                b[start] = a[start]       # abb
+                a_idx += 1
+            else:  # a[height] < b[height].
+                if a[start] != b[start]:                            #    bb
+                    merged.append([a[start], b[start], a[height]])  # |a|bb
+                a_idx += 1
+        else:  # a[end] > b[end].
+            if a[height] >= b[height]:  # aaaa
+                b_idx += 1              # abba
+            else:
+                #    |bb|
+                # |a||bb|a
+                if a[start] != b[start]:
+                    merged.append([a[start], b[start], a[height]])
+                a[start] = b[end]
+                merged.append(b)
+                b_idx += 1
+        return a_idx, b_idx
diff --git a/Python/valid-number.py b/Python/valid-number.py
index c45fbaab7..8a5c744e7 100644
--- a/Python/valid-number.py
+++ b/Python/valid-number.py
@@ -21,7 +21,7 @@ class InputType:
     DOT        = 4
     EXPONENT   = 5
 
-# regular expression: "^\s*[\+\-]?((\d+(\.\d*)?)|\.\d+)([eE][+-]?\d+)?\s*$"
+# regular expression: "^\s*[\+-]?((\d+(\.\d*)?)|\.\d+)([eE][\+-]?\d+)?\s*$"
 # automata: http://images.cnitblog.com/i/627993/201405/012016243309923.png
 class Solution:
     # @param s, a string
@@ -63,11 +63,11 @@ class Solution2:
     # @return a boolean
     def isNumber(self, s):
         import re
-        return bool(re.match("^\s*[\+\-]?((\d+(\.\d*)?)|\.\d+)([eE][+-]?\d+)?\s*$", s))
+        return bool(re.match("^\s*[\+-]?((\d+(\.\d*)?)|\.\d+)([eE][\+-]?\d+)?\s*$", s))
     
 if __name__ == "__main__":
     print Solution().isNumber(" 0.1 ")
     print Solution().isNumber("abc")
     print Solution().isNumber("1 a")
     print Solution().isNumber("2e10")
-        
\ No newline at end of file
+        
diff --git a/Python/valid-palindrome.py b/Python/valid-palindrome.py
index b9abbfc9b..c0c562059 100644
--- a/Python/valid-palindrome.py
+++ b/Python/valid-palindrome.py
@@ -19,9 +19,9 @@ class Solution:
     def isPalindrome(self, s):
         i, j = 0, len(s) - 1
         while i < j:
-            while i < j and not (s[i].isalpha() or s[i].isdigit()):
+            while i < j and not s[i].isalnum():
                 i += 1
-            while i < j and not (s[j].isalpha() or s[j].isdigit()):
+            while i < j and not s[j].isalnum():
                 j -= 1
             if s[i].lower() != s[j].lower():
                 return False
@@ -29,4 +29,4 @@ def isPalindrome(self, s):
         return True
 
 if __name__ == "__main__":
-    print Solution().isPalindrome("A man, a plan, a canal: Panama")
\ No newline at end of file
+    print Solution().isPalindrome("A man, a plan, a canal: Panama")
diff --git a/Python/wildcard-matching.py b/Python/wildcard-matching.py
index d930727d7..7965368aa 100644
--- a/Python/wildcard-matching.py
+++ b/Python/wildcard-matching.py
@@ -94,15 +94,15 @@ def isMatch(self, s, p):
         return result[len(s)][len(p)]
 
 
-# recursive, slowest
+# recursive, slowest, TLE
 class Solution4:
     # @return a boolean
     def isMatch(self, s, p):
-        if not p:
-            return not s
+        if not p or not s:
+            return not s and not p
         
         if p[0] != '*':
-            if not s or (p[0] == s[0] or p[0] == '?'):
+            if p[0] == s[0] or p[0] == '?':
                 return self.isMatch(s[1:], p[1:])
             else:
                 return False
diff --git a/Python/word-break.py b/Python/word-break.py
index bd39ed955..b1f9ad9ee 100644
--- a/Python/word-break.py
+++ b/Python/word-break.py
@@ -12,6 +12,34 @@
 #
 
 class Solution:
+    # @param s: A string s
+    # @param dict: A dictionary of words dict
+    def wordSegmentation(self, s, dict):
+        if not s:
+            return True
+            
+        cnt = {}
+        for w in dict:
+            for c in w:
+                if c not in cnt:
+                    cnt[c] = 0
+                cnt[c] += 1
+        for c in s:
+            if c not in cnt:
+                return False
+                
+        n = len(s)
+        possible = [False for _ in xrange(n)]
+        for i in xrange(n):
+            for j in reversed(xrange(i + 1)):
+                if (j == 0 or possible[j-1]) and s[j:i+1] in dict:
+                    possible[i] = True
+                    break
+                
+        return possible[n-1]
+
+# slower
+class Solution2:
     # @param s, a string
     # @param dict, a set of string
     # @return a boolean
@@ -29,4 +57,4 @@ def wordBreak(self, s, dict):
         return possible[n-1]
     
 if __name__ == "__main__":
-    print Solution().wordBreak("leetcode", ["leet", "code"])
\ No newline at end of file
+    print Solution().wordBreak("leetcode", ["leet", "code"])
diff --git a/Python/word-search-ii.py b/Python/word-search-ii.py
new file mode 100644
index 000000000..36b7afe93
--- /dev/null
+++ b/Python/word-search-ii.py
@@ -0,0 +1,74 @@
+# Time:  O(m * n * l)
+# Space: O(l)
+#
+# Given a 2D board and a list of words from the dictionary, find all words in the board.
+#
+# Each word must be constructed from letters of sequentially adjacent cell, where "adjacent" cells 
+# are those horizontally or vertically neighboring. The same letter cell may not be used more than once in a word.
+#
+# For example,
+# Given words = ["oath","pea","eat","rain"] and board =
+#
+# [
+#   ['o','a','a','n'],
+#   ['e','t','a','e'],
+#   ['i','h','k','r'],
+#   ['i','f','l','v']
+# ]
+# Return ["eat","oath"].
+# Note:
+# You may assume that all inputs are consist of lowercase letters a-z.
+#
+class TrieNode:
+    # Initialize your data structure here.
+    def __init__(self):
+        self.is_string = False
+        self.leaves = {}
+
+    # Inserts a word into the trie.
+    def insert(self, word):
+        cur = self
+        for c in word:
+            if not c in cur.leaves:
+                cur.leaves[c] = TrieNode()
+            cur = cur.leaves[c]
+        cur.is_string = True
+
+class Solution:
+    # @param {character[][]} board
+    # @param {string[]} words
+    # @return {string[]}
+    def findWords(self, board, words):
+        visited = [[False for j in xrange(len(board[0]))] for i in xrange(len(board))]
+        result = {}
+        trie = TrieNode()
+        for word in words:
+            trie.insert(word)
+            
+        for i in xrange(len(board)):
+            for j in xrange(len(board[0])):
+                if self.findWordsRecu(board, trie, 0, i, j, visited, [], result):
+                    return True
+        
+        return result.keys()
+    
+    def findWordsRecu(self, board, trie, cur, i, j, visited, cur_word, result):
+        if not trie or i < 0 or i >= len(board) or j < 0 or j >= len(board[0]) or visited[i][j]:
+            return
+        
+        if board[i][j] not in trie.leaves:
+            return
+        
+        cur_word.append(board[i][j])
+        next_node = trie.leaves[board[i][j]]
+        if next_node.is_string:
+            result["".join(cur_word)] = True
+        
+        visited[i][j] = True
+        self.findWordsRecu(board, next_node, cur + 1, i + 1, j, visited, cur_word, result)
+        self.findWordsRecu(board, next_node, cur + 1, i - 1, j, visited, cur_word, result)
+        self.findWordsRecu(board, next_node, cur + 1, i, j + 1, visited, cur_word, result)
+        self.findWordsRecu(board, next_node, cur + 1, i, j - 1, visited, cur_word, result)     
+        visited[i][j] = False
+        cur_word.pop()
+        
diff --git a/Python/word-search.py b/Python/word-search.py
index 434f5dbda..3166d0b00 100644
--- a/Python/word-search.py
+++ b/Python/word-search.py
@@ -1,5 +1,5 @@
-# Time:  O(m * n * 3^p)
-# Space: O(m * n + p)
+# Time:  O(m * n * l)
+# Space: O(l)
 #
 # Given a 2D board and a word, find if the word exists in the grid.
 # 
diff --git a/README.md b/README.md
index 9ef16ae91..fc6b4178c 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,15 @@
 LeetCode
 ======== 
 
-Up to date (2015-02-24), there are total `189` problems on [LeetCode Online Judge](https://oj.leetcode.com/).
+Up to date (2015-06-01), there are `204` Algorithms / `12` Database / `4` Shell problems on [LeetCode Online Judge](https://leetcode.com/).
 The number of problems is increasing recently.
-Here is the classification of all `189` problems.
+Here is the classification of all `220` problems.
+For extra problems and solutions, you can see my [LintCode](https://github.com/kamyu104/LintCode) repository.
 I'll keep updating for full summary and better solutions. Stay tuned for updates.
+(Notes: "📖" means you have to buy the book from LeetCode. )
 
 --- 
-Algorithm
+Algorithms
 ====
 
 * [Bit Manipulation](https://github.com/kamyu104/LeetCode#bit-manipulation)
@@ -25,6 +27,7 @@ Algorithm
 * [Brute Force Search](https://github.com/kamyu104/LeetCode#brute-force-search)
 * [Divide and Conquer](https://github.com/kamyu104/LeetCode#divide-and-conquer)
 * [Binary Search](https://github.com/kamyu104/LeetCode#binary-search)
+* [Binary Search Tree](https://github.com/kamyu104/LeetCode#binary-search-tree)
 * [Breadth-First Search](https://github.com/kamyu104/LeetCode#breadth-first-search)
 * [Depth-First Search](https://github.com/kamyu104/LeetCode#depth-first-search)
 * [Dynamic Programming](https://github.com/kamyu104/LeetCode#dynamic-programming)
@@ -37,725 +40,366 @@ Database
 
 * [SQL](https://github.com/kamyu104/LeetCode#sql)
 
+
+Shell
+===
+
+* [Shell Script](https://github.com/kamyu104/LeetCode#shell-script)
+
 ---
 
 ##Bit Manipulation
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Single Number] | [single-number.py] | _O(n)_       | _O(1)_          | Medium         |
-[Single Number II] | [single-number-ii.py] | _O(n)_ | _O(1)_          | Medium         |
-
-[Single Number]: https://oj.leetcode.com/problems/single-number/
-[single-number.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/single-number.py
-[Single Number II]: https://oj.leetcode.com/problems/single-number-ii/
-[single-number-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/single-number-ii.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+136 | [Single Number](https://leetcode.com/problems/single-number/) | [Python](./Python/single-number.py) | _O(n)_       | _O(1)_          | Medium         ||
+137 | [Single Number II](https://leetcode.com/problems/single-number-ii/) | [Python](./Python/single-number-ii.py) | _O(n)_ | _O(1)_          | Medium         ||
+190 | [Reverse Bits](https://leetcode.com/problems/reverse-bits/)  | [Python](./Python/reverse-bits.py) | _O(n)_        | _O(1)_          | Easy           ||
+191  |[Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/) | [Python](./Python/number-of-1-bits.py) | _O(m)_ | _O(1)_          | Easy           ||
+201 | [Bitwise AND of Numbers Range](https://leetcode.com/problems/bitwise-and-of-numbers-range/) | [Python](./Python/bitwise-and-of-numbers-range.py) | _O(1)_ | _O(1)_ | Medium ||
 
 --- 
 
 ##Array
 
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[3 Sum]         | [3sum.py]       | _O(n^2)_        | _O(1)_          | Medium         |
-[3 Sum Closest] | [3sum-closest.py]| _O(n^2)_       | _O(1)_          | Medium         |
-[Best Time to Buy and Sell Stock]| [best-time-to-buy-and-sell-stock.py] | _O(n)_ | _O(1)_ | Medium |
-[First Missing Positive]| [first-missing-positive.py] | _O(n)_ | _O(1)_ | Hard         | Tricky
-[Longest Consecutive Sequence]| [longest-consecutive-sequence.py] | _O(n)_ | _O(n)_ | Hard         | Tricky
-[Majority Element] | [majority-element.py] | _O(n)_ | _O(1)_          | Easy           |
-[Missing Ranges]| [missing-ranges.py] | _O(n)_      | _O(1)_          | Medium         |
-[Next Permutation]| [next-permutation.py] | _O(n)_  | _O(1)_          | Medium         | Tricky
-[Pascal's Triangle]| [pascals-triangle.py] | _O(n^2)_ | _O(n)_        | Easy           | 
-[Pascal's Triangle II]| [pascals-triangle-ii.py] | _O(n^2)_ | _O(n)_  | Easy           | 
-[Plus One]      | [plus-one.py]   | _O(n)_           | _O(1)_         | Easy           | 
-[Read N Characters Given Read4] | [read-n-characters-given-read4.py] | _O(n)_ | _O(1)_ | Easy           |
-[Read N Characters Given Read4 II - Call multiple times] | [read-n-characters-given-read4-ii-call-multiple-times.py] | _O(n)_ | _O(1)_ | Hard |
-[Remove Duplicates from Sorted Array]| [remove-duplicates-from-sorted-array.py] | _O(n)_       | _O(1)_         | Easy           |
-[Remove Duplicates from Sorted Array II]| [remove-duplicates-from-sorted-array-ii.py] | _O(n)_       | _O(1)_         | Medium         | 
-[Remove Element] | [remove-element.py] | _O(n)_      | _O(1)_         | Easy           | 
-[Rotate Array]   | [rotate-array.py] | _O(n)_        | _O(1)_         | Easy           | 
-[Rotate Image]   | [rotate-image.py] | _O(n^2)_      | _O(1)_         | Medium         | 
-[Set Matrix Zeroes] | [set-matrix-zeroes.py] | _O(m * n)_ | _O(1)_    | Medium         | 
-[Spiral Matrix] | [spiral-matrix.py] | _O(m * n)_    | _O(1)_         | Medium         |
-[Spiral Matrix II] | [spiral-matrix-ii.py] | _O(m * n)_ | _O(1)_      | Medium         | 
-
-
-[3 Sum]: https://oj.leetcode.com/problems/3sum/
-[3sum.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/3sum.py
-[3 Sum Closest]: https://oj.leetcode.com/problems/3sum-closest/
-[3sum-closest.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/3sum-closest.py
-[Best Time to Buy and Sell Stock]:https://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock/
-[best-time-to-buy-and-sell-stock.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/best-time-to-buy-and-sell-stock.py
-[First Missing Positive]:https://oj.leetcode.com/problems/first-missing-positive/
-[first-missing-positive.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/first-missing-positive.py
-[Longest Consecutive Sequence]:https://oj.leetcode.com/problems/longest-consecutive-sequence/
-[longest-consecutive-sequence.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/longest-consecutive-sequence.py
-[Majority Element]: https://oj.leetcode.com/problems/majority-element/
-[majority-element.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/majority-element.py
-[Missing Ranges]:https://oj.leetcode.com/problems/missing-ranges/
-[missing-ranges.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/missing-ranges.py
-[Next Permutation]:https://oj.leetcode.com/problems/next-permutation/
-[next-permutation.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/next-permutation.py
-[Pascal's Triangle]:https://oj.leetcode.com/problems/pascals-triangle/
-[pascals-triangle.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/pascals-triangle.py
-[Pascal's Triangle II]:https://oj.leetcode.com/problems/pascals-triangle-ii/
-[pascals-triangle-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/pascals-triangle-ii.py
-[Plus One]:https://oj.leetcode.com/problems/plus-one/
-[plus-one.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/plus-one.py
-[Read N Characters Given Read4]:https://oj.leetcode.com/problems/read-n-characters-given-read4/
-[read-n-characters-given-read4.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/read-n-characters-given-read4.py
-[Read N Characters Given Read4 II - Call multiple times]:https://oj.leetcode.com/problems/read-n-characters-given-read4-ii-call-multiple-times/
-[read-n-characters-given-read4-ii-call-multiple-times.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/read-n-characters-given-read4-ii-call-multiple-times.py
-[Remove Duplicates from Sorted Array]:https://oj.leetcode.com/problems/remove-duplicates-from-sorted-array/
-[remove-duplicates-from-sorted-array.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/remove-duplicates-from-sorted-array.py
-[Remove Duplicates from Sorted Array II]:https://oj.leetcode.com/problems/remove-duplicates-from-sorted-array-ii/
-[remove-duplicates-from-sorted-array-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/remove-duplicates-from-sorted-array-ii.py
-[Remove Element]:https://oj.leetcode.com/problems/remove-element/
-[remove-element.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/remove-element.py
-[Rotate Array]:https://oj.leetcode.com/problems/rotate-array/
-[rotate-array.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/rotate-array.py
-[Rotate Image]:https://oj.leetcode.com/problems/rotate-image/
-[rotate-image.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/rotate-image.py
-[Set Matrix Zeroes]:https://oj.leetcode.com/problems/set-matrix-zeroes/
-[set-matrix-zeroes.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/set-matrix-zeroes.py
-[Spiral Matrix]:https://oj.leetcode.com/problems/spiral-matrix/
-[spiral-matrix.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/spiral-matrix.py
-[Spiral Matrix II]:https://oj.leetcode.com/problems/spiral-matrix-ii/
-[spiral-matrix-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/spiral-matrix-ii.py
-
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+15 | [3 Sum](https://leetcode.com/problems/3sum/)         | [Python](./Python/3sum.py)       | _O(n^2)_        | _O(1)_          | Medium         ||
+16 | [3 Sum Closest](https://leetcode.com/problems/3sum-closest/) | [Python](./Python/3sum-closest.py)| _O(n^2)_       | _O(1)_          | Medium         ||
+26 | [Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/)| [Python](./Python/remove-duplicates-from-sorted-array.py) | _O(n)_       | _O(1)_         | Easy           ||
+27 | [Remove Element](https://leetcode.com/problems/remove-element/) | [Python](./Python/remove-element.py) | _O(n)_      | _O(1)_         | Easy           ||
+31 | [Next Permutation](https://leetcode.com/problems/next-permutation/)| [Python](./Python/next-permutation.py) | _O(n)_  | _O(1)_          | Medium         || Tricky
+41 | [First Missing Positive](https://leetcode.com/problems/first-missing-positive/)| [Python](./Python/first-missing-positive.py) | _O(n)_ | _O(1)_ | Hard         || Tricky
+48 | [Rotate Image](https://leetcode.com/problems/rotate-image/)   | [Python](./Python/rotate-image.py) | _O(n^2)_      | _O(1)_         | Medium         ||
+54 | [Spiral Matrix](https://leetcode.com/problems/spiral-matrix/) | [Python](./Python/spiral-matrix.py) | _O(m * n)_    | _O(1)_         | Medium         ||
+59 | [Spiral Matrix II](https://leetcode.com/problems/spiral-matrix-ii/) | [Python](./Python/spiral-matrix-ii.py) | _O(m * n)_ | _O(1)_      | Medium         ||
+66 | [Plus One](https://leetcode.com/problems/plus-one/)      | [Python](./Python/plus-one.py)   | _O(n)_           | _O(1)_         | Easy           || 
+73 | [Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/) | [Python](./Python/set-matrix-zeroes.py) | _O(m * n)_ | _O(1)_    | Medium         ||
+80 | [Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/)| [Python](./Python/remove-duplicates-from-sorted-array-ii.py) | _O(n)_       | _O(1)_         | Medium         ||
+118 | [Pascal's Triangle](https://leetcode.com/problems/pascals-triangle/)| [Python](./Python/pascals-triangle.py) | _O(n^2)_ | _O(n)_        | Easy           || 
+119 | [Pascal's Triangle II](https://leetcode.com/problems/pascals-triangle-ii/)| [Python](./Python/pascals-triangle-ii.py) | _O(n^2)_ | _O(n)_  | Easy           ||
+121 | [Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/)| [Python](./Python/best-time-to-buy-and-sell-stock.py) | _O(n)_ | _O(1)_ | Medium ||
+128 | [Longest Consecutive Sequence](https://leetcode.com/problems/longest-consecutive-sequence/)| [Python](./Python/longest-consecutive-sequence.py) | _O(n)_ | _O(n)_ | Hard         || Tricky
+157 | [Read N Characters Given Read4](https://leetcode.com/problems/read-n-characters-given-read4/) | [Python](./Python/read-n-characters-given-read4.py) | _O(n)_ | _O(1)_ | Easy           |📖|
+158 | [Read N Characters Given Read4 II - Call multiple times](https://leetcode.com/problems/read-n-characters-given-read4-ii-call-multiple-times/) | [Python](./Python/read-n-characters-given-read4-ii-call-multiple-times.py) | _O(n)_ | _O(1)_ | Hard |📖|
+163 | [Missing Ranges](https://leetcode.com/problems/missing-ranges/)| [Python](./Python/missing-ranges.py) | _O(n)_      | _O(1)_          | Medium         | 📖 |
+169 | [Majority Element](https://leetcode.com/problems/majority-element/) | [Python](./Python/majority-element.py) | _O(n)_ | _O(1)_          | Easy           |
+189 | [Rotate Array](https://leetcode.com/problems/rotate-array/)   | [Python](./Python/rotate-array.py) | _O(n)_        | _O(1)_         | Easy           ||
+209 | [Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum/) | [Python] (./Python/minimum-size-subarray-sum.py) | _O(n)_ | _O(1)_ |  Medium | | Binary Search
+215 | [Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/) | [C++] (./C++/kth-largest-element-in-an-array.cpp) [Python] (./Python/kth-largest-element-in-an-array.py)| _O(n)_ | _O(1)_ |  Medium | EPI|
 
 --- 
 
 ##String
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Add Binary]    | [add-binary.py] | _O(n)_          | _O(1)_          | Easy           |
-[Compare Version Numbers] | [compare-version-numbers.py] | _O(n)_ | _O(1)_ | Easy     |
-[Count and Say] | [count-and-say.py]| _O(n * 2^n)_  | _O(2^n)_        | Easy           |
-[Implement strStr()] | [implement-strstr.py] | _O(n + m)_   | _O(m)_  | Easy           | `KMP Algorithm`
-[Length of Last Word] | [length-of-last-word.py] | _O(n)_   | _O(1)_  | Easy           |
-[Longest Common Prefix] | [longest-common-prefix.py] | _O(n1 + n2 + ...)_   | _O(1)_  | Easy           |
-[Longest Palindromic Substring] | [longest-palindromic-substring.py] | _O(n)_ | _O(n)_ |  Medium | `Manacher's Algorithm`
-[Multiply Strings] | [multiply-strings.py] | _O(m * n)_ | _O(m + n)_  | Medium         |
-[One Edit Distance] | [one-edit-distance.py] | _O(m + n)_ | _O(1)_    | Medium         |
-[Reverse Words in a String] | [reverse-words-in-a-string.py] | _O(n)_ | _O(n)_ | Medium         |
-[Reverse Words in a String II] | [reverse-words-in-a-string-ii.py] | _O(n)_ | _O(1)_ | Medium         |
-[String to Integer (atoi)] | [string-to-integer-atoi.py] | _O(n)_ | _O(1)_ | Easy      |
-[Text Justification] | [text-justification.py] | _O(n)_ | _O(1)_      | Hard           |
-[Valid Palindrome] | [valid-palindrome.py] | _O(n)_  | _O(1)_         | Easy           |
-[ZigZag Conversion] | [zigzag-conversion.py] | _O(n)_ | _O(1)_        | Easy           |
-
-[Add Binary]:https://oj.leetcode.com/problems/add-binary/
-[add-binary.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/add-binary.py
-[Count and Say]:https://oj.leetcode.com/problems/count-and-say/
-[count-and-say.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/count-and-say.py
-[Compare Version Numbers]:https://oj.leetcode.com/problems/compare-version-numbers/
-[compare-version-numbers.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/compare-version-numbers.py
-[Implement strStr()]:https://oj.leetcode.com/problems/implement-strstr/
-[implement-strstr.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/implement-strstr.py
-[Length of Last Word]:https://oj.leetcode.com/problems/length-of-last-word/
-[length-of-last-word.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/length-of-last-word.py
-[Longest Common Prefix]:https://oj.leetcode.com/problems/longest-common-prefix/
-[longest-common-prefix.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/longest-common-prefix.py
-[Longest Palindromic Substring]:https://oj.leetcode.com/problems/longest-palindromic-substring/
-[longest-palindromic-substring.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/longest-palindromic-substring.py
-[Multiply Strings]:https://oj.leetcode.com/problems/multiply-strings/
-[multiply-strings.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/multiply-strings.py
-
-[One Edit Distance]:https://oj.leetcode.com/problems/one-edit-distance/
-[one-edit-distance.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/one-edit-distance.py
-[Reverse Words in a String]:https://oj.leetcode.com/problems/reverse-words-in-a-string/
-[reverse-words-in-a-string.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/reverse-words-in-a-string.py
-[Reverse Words in a String II]:https://oj.leetcode.com/problems/reverse-words-in-a-string-ii/
-[reverse-words-in-a-string-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/reverse-words-in-a-string-ii.py
-[String to Integer (atoi)]:https://oj.leetcode.com/problems/string-to-integer-atoi/
-[string-to-integer-atoi.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/string-to-integer-atoi.py
-[Text Justification]:https://oj.leetcode.com/problems/text-justification/
-[text-justification.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/text-justification.py
-[Valid Palindrome]:https://oj.leetcode.com/problems/valid-palindrome/
-[valid-palindrome.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/valid-palindrome.py
-[ZigZag Conversion]:https://oj.leetcode.com/problems/zigzag-conversion/
-[zigzag-conversion.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/zigzag-conversion.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+5| [Longest Palindromic Substring](https://leetcode.com/problems/longest-palindromic-substring/) | [Python](./Python/longest-palindromic-substring.py) | _O(n)_ | _O(n)_ |  Medium || `Manacher's Algorithm`
+6| [ZigZag Conversion](https://leetcode.com/problems/zigzag-conversion/) | [Python](./Python/zigzag-conversion.py) | _O(n)_ | _O(1)_        | Easy           ||
+8| [String to Integer (atoi)](https://leetcode.com/problems/string-to-integer-atoi/) | [Python](./Python/string-to-integer-atoi.py) | _O(n)_ | _O(1)_ | Easy      ||
+14| [Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/) | [Python](./Python/longest-common-prefix.py) | _O(n1 + n2 + ...)_   | _O(1)_  | Easy           ||
+28| [Implement strStr()](https://leetcode.com/problems/implement-strstr/) | [Python](./Python/implement-strstr.py) | _O(n + m)_   | _O(m)_  | Easy           || `KMP Algorithm`
+38| [Count and Say](https://leetcode.com/problems/count-and-say/) | [Python](./Python/count-and-say.py)| _O(n * 2^n)_  | _O(2^n)_        | Easy           ||
+43| [Multiply Strings](https://leetcode.com/problems/multiply-strings/) | [Python](./Python/multiply-strings.py) | _O(m * n)_ | _O(m + n)_  | Medium         ||
+58| [Length of Last Word](https://leetcode.com/problems/length-of-last-word/) | [Python](./Python/length-of-last-word.py) | _O(n)_   | _O(1)_  | Easy           ||
+67| [Add Binary](https://leetcode.com/problems/add-binary/)    | [Python](./Python/add-binary.py) | _O(n)_          | _O(1)_          | Easy           ||
+68| [Text Justification](https://leetcode.com/problems/text-justification/) | [Python](./Python/text-justification.py) | _O(n)_ | _O(1)_      | Hard           ||
+125| [Valid Palindrome](https://leetcode.com/problems/valid-palindrome/) | [Python](./Python/valid-palindrome.py) | _O(n)_  | _O(1)_         | Easy           ||
+151| [Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/) | [Python](./Python/reverse-words-in-a-string.py) | _O(n)_ | _O(n)_ | Medium         ||
+161| [One Edit Distance](https://leetcode.com/problems/one-edit-distance/) | [Python](./Python/one-edit-distance.py) | _O(m + n)_ | _O(1)_    | Medium         |📖|
+165| [Compare Version Numbers](https://leetcode.com/problems/compare-version-numbers/) | [Python](./Python/compare-version-numbers.py) | _O(n)_ | _O(1)_ | Easy     ||
+186| [Reverse Words in a String II](https://leetcode.com/problems/reverse-words-in-a-string-ii/) | [Python](./Python/reverse-words-in-a-string-ii.py) | _O(n)_ | _O(1)_ | Medium         | 📖 |
+205| [Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/) | [Python](./Python/isomorphic-strings.py) | _O(n)_ | _O(1)_       | Easy           ||    
+214| [Shortest Palindrome](https://leetcode.com/problems/shortest-palindrome/) | [C++](./C++/shortest-palindrome.cpp) [Python](./Python/shortest-palindrome.py) | _O(n)_ | _O(n)_ |  Hard || `KMP Algorithm` `Manacher's Algorithm`
 
 --- 
 
 ##Linked List
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Add Two Numbers] | [add-two-numbers.py] | _O(n)_   | _O(1)_          | Medium         |
-[Copy List with Random Pointer] | [copy-list-with-random-pointer.py] | _O(n)_   | _O(1)_          | Hard         |
-[Intersection of Two Linked Lists]| [intersection-of-two-linked-lists.py] | _O(m + n)_ | _O(1)_         | Easy           |
-[Remove Duplicates from Sorted List]| [remove-duplicates-from-sorted-list.py] | _O(n)_       | _O(1)_         | Easy           |
-[Remove Duplicates from Sorted List II]| [remove-duplicates-from-sorted-list-ii.py] | _O(n)_       | _O(1)_         | Medium         | 
-[Reverse Linked List II]| [reverse-linked-list-ii.py] | _O(n)_       | _O(1)_         | Medium         | 
-[Reverse Nodes in k-Group]| [reverse-nodes-in-k-group.py] | _O(n)_       | _O(1)_         | Hard         |
-[Rotate List]| [rotate-list.py]   | _O(n)_          | _O(1)_          | Medium         |  
-[Swap Nodes in Pairs]| [swap-nodes-in-pairs.py]   | _O(n)_          | _O(1)_          | Medium         |  
-
-[Add Two Numbers]:https://oj.leetcode.com/problems/add-two-numbers/
-[add-two-numbers.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/add-two-numbers.py
-[Copy List with Random Pointer]:https://oj.leetcode.com/problems/copy-list-with-random-pointer/
-[copy-list-with-random-pointer.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/copy-list-with-random-pointer.py
-[Intersection of Two Linked Lists]:https://oj.leetcode.com/problems/intersection-of-two-linked-lists/
-[intersection-of-two-linked-lists.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/intersection-of-two-linked-lists.py
-[Remove Duplicates from Sorted List]:https://oj.leetcode.com/problems/remove-duplicates-from-sorted-list/
-[remove-duplicates-from-sorted-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/remove-duplicates-from-sorted-list.py
-[Remove Duplicates from Sorted List II]:https://oj.leetcode.com/problems/remove-duplicates-from-sorted-list-ii/
-[remove-duplicates-from-sorted-list-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/remove-duplicates-from-sorted-list-ii.py
-[Reverse Linked List II]:https://oj.leetcode.com/problems/reverse-linked-list-ii/
-[reverse-linked-list-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/reverse-linked-list-ii.py
-[Reverse Nodes in k-Group]:https://oj.leetcode.com/problems/reverse-nodes-in-k-group/
-[reverse-nodes-in-k-group.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/reverse-nodes-in-k-group.py
-[Rotate List]:https://oj.leetcode.com/problems/rotate-list/
-[rotate-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/rotate-list.py
-[Swap Nodes in Pairs]:https://oj.leetcode.com/problems/swap-nodes-in-pairs/
-[swap-nodes-in-pairs.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/swap-nodes-in-pairs.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+2| [Add Two Numbers](https://leetcode.com/problems/add-two-numbers/) | [Python](./Python/add-two-numbers.py) | _O(n)_   | _O(1)_          | Medium         ||
+24| [Swap Nodes in Pairs](https://leetcode.com/problems/swap-nodes-in-pairs/)| [Python](./Python/swap-nodes-in-pairs.py)   | _O(n)_          | _O(1)_          | Medium         ||
+25| [Reverse Nodes in k-Group](https://leetcode.com/problems/reverse-nodes-in-k-group/)| [Python](./Python/reverse-nodes-in-k-group.py) | _O(n)_       | _O(1)_         | Hard         ||
+61| [Rotate List](https://leetcode.com/problems/rotate-list/)| [Python](./Python/rotate-list.py)   | _O(n)_          | _O(1)_          | Medium         ||  
+82| [Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/)| [Python](./Python/remove-duplicates-from-sorted-list-ii.py) | _O(n)_       | _O(1)_         | Medium         ||
+83| [Remove Duplicates from Sorted List](https://leetcode.com/problems/remove-duplicates-from-sorted-list/)| [Python](./Python/remove-duplicates-from-sorted-list.py) | _O(n)_       | _O(1)_         | Easy           ||
+92| [Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/)| [Python](./Python/reverse-linked-list-ii.py) | _O(n)_       | _O(1)_         | Medium         || 
+138| [Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/) | [Python](./Python/copy-list-with-random-pointer.py) | _O(n)_   | _O(1)_          | Hard         ||
+160| [Intersection of Two Linked Lists](https://leetcode.com/problems/intersection-of-two-linked-lists/)| [Python](./Python/intersection-of-two-linked-lists.py) | _O(m + n)_ | _O(1)_         | Easy           ||
+203| [Remove Linked List Elements](https://leetcode.com/problems/remove-linked-list-elements/)| [Python](./Python/remove-linked-list-elements.py) | _O(n)_       | _O(1)_         | Easy         || 
+206| [Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/)| [Python](./Python/reverse-linked-list.py) | _O(n)_       | _O(1)_         | Easy         || 
 
 --- 
 
 ##Stack
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Binary Search Tree Iterator] | [binary-search-tree-iterator.py] | _O(1)_| _O(h)_| Medium   
-[Evaluate Reverse Polish Notation]| [evaluate-reverse-polish-notation.py]| _O(n)_| _O(n)_| Medium          |
-[Longest Valid Parentheses]| [longest-valid-parentheses.py] | _O(n)_ | _O(1)_ | Hard   |
-[Min Stack]     | [min-stack.py]  | _O(n)_          | _O(1)_          | Easy           |
-[Simplify Path]| [simplify-path.py] | _O(n)_        | _O(n)_          | Medium         |
-[Symmetric Tree]| [symmetric-tree.py] | _O(n)_      | _O(h)_          | Easy           |
-[Valid Parentheses]| [valid-parentheses.py] | _O(n)_        | _O(n)_          | Easy           |
-
-[Binary Search Tree Iterator]:https://oj.leetcode.com/problems/binary-search-tree-iterator/
-[binary-search-tree-iterator.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-search-tree-iterator.py
-[Evaluate Reverse Polish Notation]:https://oj.leetcode.com/problems/evaluate-reverse-polish-notation/
-[evaluate-reverse-polish-notation.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/evaluate-reverse-polish-notation.py
-[Longest Valid Parentheses]:https://oj.leetcode.com/problems/longest-valid-parentheses/
-[longest-valid-parentheses.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/longest-valid-parentheses.py
-[Min Stack]:https://oj.leetcode.com/problems/min-stack/
-[min-stack.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/min-stack.py
-[Simplify Path]:https://oj.leetcode.com/problems/simplify-path/
-[simplify-path.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/simplify-path.py
-[Symmetric Tree]:https://oj.leetcode.com/problems/symmetric-tree/
-[symmetric-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/symmetric-tree.py
-[Valid Parentheses]:https://oj.leetcode.com/problems/valid-parentheses/
-[valid-parentheses.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/valid-parentheses.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+20| [Valid Parentheses](https://leetcode.com/problems/valid-parentheses/)| [Python](./Python/valid-parentheses.py) | _O(n)_        | _O(n)_          | Easy           ||
+32| [Longest Valid Parentheses](https://leetcode.com/problems/longest-valid-parentheses/)| [Python](./Python/longest-valid-parentheses.py) | _O(n)_ | _O(1)_ | Hard   ||
+71| [Simplify Path](https://leetcode.com/problems/simplify-path/)| [Python](./Python/simplify-path.py) | _O(n)_        | _O(n)_          | Medium         ||
+101| [Symmetric Tree](https://leetcode.com/problems/symmetric-tree/)| [Python](./Python/symmetric-tree.py) | _O(n)_      | _O(h)_          | Easy           ||
+150| [Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/)| [Python](./Python/evaluate-reverse-polish-notation.py)| _O(n)_| _O(n)_| Medium          ||
+155| [Min Stack](https://leetcode.com/problems/min-stack/)     | [Python](./Python/min-stack.py)  | _O(n)_          | _O(1)_          | Easy           ||
+173| [Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/) | [Python](./Python/binary-search-tree-iterator.py) | _O(1)_| _O(h)_| Medium ||   
 
 --- 
 
 ##Heap
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Merge k Sorted Lists] | [merge-k-sorted-lists.py] | _O(nlogk)_| _O(1)_| Hard          |  
-
-[Merge k Sorted Lists]:https://oj.leetcode.com/problems/merge-k-sorted-lists/
-[merge-k-sorted-lists.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/merge-k-sorted-lists.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+23| [Merge k Sorted Lists](https://leetcode.com/problems/merge-k-sorted-lists/) | [Python](./Python/merge-k-sorted-lists.py) | _O(nlogk)_| _O(k)_| Hard          ||
 
 --- 
 
 ##Tree
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Binary Tree Preorder Traversal] | [binary-tree-preorder-traversal.py] | _O(n)_| _O(1)_| Medium | `Morris Traversal` 
-[Binary Tree Inorder Traversal]  | [binary-tree-inorder-traversal.py] | _O(n)_| _O(1)_| Medium           | `Morris Traversal` 
-[Binary Tree Postorder Traversal]| [binary-tree-postorder-traversal.py] | _O(n)_| _O(1)_| Hard  | `Morris Traversal` 
-[Recover Binary Search Tree]| [recover-binary-search-tree.py] | _O(n)_| _O(1)_| Hard  | `Morris Traversal`      
-
-[Binary Tree Preorder Traversal]:https://oj.leetcode.com/problems/binary-tree-preorder-traversal/
-[binary-tree-preorder-traversal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-preorder-traversal.py
-[Binary Tree Inorder Traversal]:https://oj.leetcode.com/problems/binary-tree-inorder-traversal/
-[binary-tree-inorder-traversal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-inorder-traversal.py
-[Binary Tree Postorder Traversal]:https://oj.leetcode.com/problems/binary-tree-postorder-traversal/
-[binary-tree-postorder-traversal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-postorder-traversal.py
-[Recover Binary Search Tree]:https://oj.leetcode.com/problems/recover-binary-search-tree/
-[recover-binary-search-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/recover-binary-search-tree.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+94 | [Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/)  | [Python](./Python/binary-tree-inorder-traversal.py) | _O(n)_| _O(1)_| Medium           || `Morris Traversal` | 
+99 | [Recover Binary Search Tree](https://leetcode.com/problems/recover-binary-search-tree/) | [Python](./Python/recover-binary-search-tree.py) | _O(n)_| _O(1)_| Hard  || `Morris Traversal` 
+144 | [Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/) | [Python](./Python/binary-tree-preorder-traversal.py) | _O(n)_| _O(1)_| Medium || `Morris Traversal` 
+145 | [Binary Tree Postorder Traversal](https://leetcode.com/problems/binary-tree-postorder-traversal/) | [Python](./Python/binary-tree-postorder-traversal.py) | _O(n)_| _O(1)_| Hard  || `Morris Traversal` 
+208 | [Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree/) | [Python](./Python/implement-trie-prefix-tree.py) | _O(n)_ | _O(1)_ | Medium || Trie
+211 | [Add and Search Word - Data structure design ](https://leetcode.com/problems/add-and-search-word-data-structure-design/) | [C++](./C++/add-and-search-word-data-structure-design.cpp) [Python](./Python/add-and-search-word-data-structure-design.py) | _O(min(n, h))_ | _O(min(n, h))_ | Medium || Trie, DFS
+212| [Word Search II](https://leetcode.com/problems/word-search-ii/) | [C++](./C++/word-search-ii.cpp) [Python](./Python/word-search-ii.py) | _O(m * n * l)_ | _O(l)_  | Hard         | LintCode | Trie, DFS
 
 --- 
 
 ##Hash Table
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[4 Sum]         |[4sum.py]        | _O(n^2)_ ~ _O(n^4)_ | _O(n^2)_    | Medium         |
-[Anagrams]      | [anagrams.py]   | _O(n)_          | _O(n)_          | Medium         |
-[Longest Substring with At Most Two Distinct Characters]| [longest-substring-with-at-most-two-distinct-characters.py] | _O(n^2)_ | _O(1)_ | Hard         |
-[Longest Substring Without Repeating Characters] | [longest-substring-without-repeating-characters.py] | _O(n)_ | _O(1)_ | Medium |
-[Max Points on a Line] | [max-points-on-a-line.py] | _O(n^2)_ | _O(n)_ | Hard          |
-[Minimum Window Substring] | [minimum-window-substring.py] | _O(n)_ | _O(k)_ | Hard          |
-[Repeated DNA Sequences] | [repeated-dna-sequences.py] | _O(n)_       | _O(n)_          | Medium         |
-[Substring with Concatenation of All Words] | [substring-with-concatenation-of-all-words.py] | _O(m * n * k)_ | _O(n * k)_ | Hard          |
-[Two Sum]      | [two-sum.py]      | _O(n)_         | _O(n)_          | Medium         |
-[Two Sum III - Data structure design] | [two-sum-iii-data-structure-design.py] | _O(n)_ | _O(n)_ | Easy |
-[Valid Sudoku] | [valid-sudoku.py] | _O(n^2)_         | _O(n)_          | Easy           |
-
-[4 Sum]: https://oj.leetcode.com/problems/4sum/
-[4sum.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/4sum.py
-[Anagrams]:https://oj.leetcode.com/problems/anagrams/
-[anagrams.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/anagrams.py
-[Longest Substring with At Most Two Distinct Characters]:https://oj.leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/
-[longest-substring-with-at-most-two-distinct-characters.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/longest-substring-with-at-most-two-distinct-characters.py
-[Longest Substring Without Repeating Characters]:https://oj.leetcode.com/problems/longest-substring-without-repeating-characters/
-[longest-substring-without-repeating-characters.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/longest-substring-without-repeating-characters.py
-[Max Points on a Line]:https://oj.leetcode.com/problems/max-points-on-a-line/
-[max-points-on-a-line.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/max-points-on-a-line.py
-[Minimum Window Substring]:https://oj.leetcode.com/problems/minimum-window-substring/
-[minimum-window-substring.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/minimum-window-substring.py
-[Repeated DNA Sequences]:https://oj.leetcode.com/problems/repeated-dna-sequences/
-[repeated-dna-sequences.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/repeated-dna-sequences.py
-[Substring with Concatenation of All Words]:https://oj.leetcode.com/problems/substring-with-concatenation-of-all-words/
-[substring-with-concatenation-of-all-words.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/substring-with-concatenation-of-all-words.py
-[Two Sum]:https://oj.leetcode.com/problems/two-sum/
-[two-sum.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/two-sum.py
-[Two Sum III - Data structure design]:https://oj.leetcode.com/problems/two-sum-iii-data-structure-design/
-[two-sum-iii-data-structure-design.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/two-sum-iii-data-structure-design.py
-[Valid Sudoku]:https://oj.leetcode.com/problems/valid-sudoku/
-[valid-sudoku.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/valid-sudoku.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+1| [Two Sum](https://leetcode.com/problems/two-sum/)      | [Python](./Python/two-sum.py)      | _O(n)_         | _O(n)_          | Medium         ||
+3| [Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/) | [Python](./Python/longest-substring-without-repeating-characters.py) | _O(n)_ | _O(1)_ | Medium ||
+18| [4 Sum](https://leetcode.com/problems/4sum/)         |[Python](./Python/4sum.py)        | _O(n^2 * p)_    | _O(n^2 * p)_    | Medium         ||
+30| [Substring with Concatenation of All Words](https://leetcode.com/problems/substring-with-concatenation-of-all-words/) | [Python](./Python/substring-with-concatenation-of-all-words.py) | _O(m * n * k)_ | _O(n * k)_ | Hard          ||
+36| [Valid Sudoku](https://leetcode.com/problems/valid-sudoku/) | [Python](./Python/valid-sudoku.py) | _O(n^2)_         | _O(n)_          | Easy           ||
+49| [Anagrams](https://leetcode.com/problems/anagrams/)     | [Python](./Python/anagrams.py)   | _O(n)_          | _O(n)_          | Medium         ||
+76| [Minimum Window Substring](https://leetcode.com/problems/minimum-window-substring/) | [Python](./Python/minimum-window-substring.py) | _O(n)_ | _O(k)_ | Hard          ||
+149| [Max Points on a Line](https://leetcode.com/problems/max-points-on-a-line/) | [Python](./Python/max-points-on-a-line.py) | _O(n^2)_ | _O(n)_ | Hard          ||
+159| [Longest Substring with At Most Two Distinct Characters](https://leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/)| [Python](./Python/longest-substring-with-at-most-two-distinct-characters.py) | _O(n^2)_ | _O(1)_ | Hard         |📖|
+170| [Two Sum III - Data structure design](https://leetcode.com/problems/two-sum-iii-data-structure-design/) | [Python](./Python/two-sum-iii-data-structure-design.py) | _O(n)_ | _O(n)_ | Easy | 📖 |
+187| [Repeated DNA Sequences](https://leetcode.com/problems/repeated-dna-sequences/) | [Python](./Python/repeated-dna-sequences.py) | _O(n)_       | _O(n)_          | Medium         ||
+202| [Happy Number](https://leetcode.com/problems/happy-number/)      | [Python](./Python/happy-number.py)   | _O(k)_  | _O(k)_          | Easy          ||
+204| [Count Primes](https://leetcode.com/problems/count-primes/)  | [Python](./Python/count-primes.py) | _O(n)_        | _O(n)_          | Easy           ||
+217| [Contains Duplicate](https://leetcode.com/problems/contains-duplicate/)  | [C++](./C++/contains-duplicate.cpp) [Python](./Python/contains-duplicate.py) | _O(n)_        | _O(n)_          | Easy           ||
+219| [Contains Duplicate II](https://leetcode.com/problems/contains-duplicate-ii/)  | [C++](./C++/contains-duplicate-ii.cpp) [Python](./Python/contains-duplicate-ii.py) | _O(n)_        | _O(n)_          | Easy           ||
 
 --- 
 
 ##Data Structure
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[LRU Cache]     | [lru-cache.py]  | _O(1)_          | _O(n)_          | Hard         |
-
-
-[LRU Cache]:https://oj.leetcode.com/problems/lru-cache/
-[lru-cache.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/lru-cache.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+146| [LRU Cache](https://leetcode.com/problems/lru-cache/)     | [Python](./Python/lru-cache.py)  | _O(1)_          | _O(n)_          | Hard         ||
 
 --- 
 
 ##Math
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Divide Two Integers] | [divide-two-integers.py]    | _O(logn)_       | _O(1)_         | Medium         |
-[Excel Sheet Column Title] | [excel-sheet-column-title.py] | _O(logn)_ | _O(1)_ | Easy |
-[Excel Sheet Column Number] | [excel-sheet-column-number.py] | _O(n)_ | _O(1)_ | Easy  |
-[Factorial Trailing Zeroes] | [factorial-trailing-zeroes.py]  | _O(logn)_ | _O(1)_ | Easy         |
-[Fraction to Recurring Decimal] | [fraction-to-recurring-decimal.py]  | _O(logn)_ | _O(1)_ | Medium         |
-[Gray Code]     | [gray-code.py]  | _O(2^n)_        | _O(1)_          | Medium         |
-[Integer to Roman] | [integer-to-roman.py] | _O(n)_ | _O(1)_          | Medium         |
-[Palindrome Number] | [palindrome-number.py] | _O(1)_ | _O(1)_        | Easy           |
-[Permutation Sequence] | [permutation-sequence.py] | _O(n)_ | _O(1)_  | Medium         | `Cantor Ordering`
-[Reverse Integer] | [reverse-integer.py] | _O(logn)_ | _O(1)_         | Easy           |
-[Roman to Integer] | [roman-to-integer.py] | _O(n)_ | _O(1)_          | Easy           |
-[Valid Number] | [valid-number.py] | _O(n)_         | _O(1)_          | Hard           | `Automata`
-
-[Divide Two Integers]:https://oj.leetcode.com/problems/divide-two-integers/
-[divide-two-integers.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/divide-two-integers.py
-[Excel Sheet Column Title]:https://oj.leetcode.com/problems/excel-sheet-column-title/
-[excel-sheet-column-title.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/excel-sheet-column-title.py
-[Excel Sheet Column Number]:https://oj.leetcode.com/problems/excel-sheet-column-number/
-[excel-sheet-column-number.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/excel-sheet-column-number.py
-[Factorial Trailing Zeroes]:https://oj.leetcode.com/problems/factorial-trailing-zeroes/
-[factorial-trailing-zeroes.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/factorial-trailing-zeroes.py
-[Fraction to Recurring Decimal]:https://oj.leetcode.com/problems/fraction-to-recurring-decimal/
-[fraction-to-recurring-decimal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/fraction-to-recurring-decimal.py
-[Gray Code]:https://oj.leetcode.com/problems/gray-code/
-[gray-code.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/gray-code.py
-[Integer to Roman]:https://oj.leetcode.com/problems/integer-to-roman/
-[integer-to-roman.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/integer-to-roman.py
-[Palindrome Number]:https://oj.leetcode.com/problems/palindrome-number/
-[palindrome-number.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/palindrome-number.py
-[Permutation Sequence]:https://oj.leetcode.com/problems/permutation-sequence/
-[permutation-sequence.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/permutation-sequence.py
-[Reverse Integer]:https://oj.leetcode.com/problems/reverse-integer/
-[reverse-integer.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/reverse-integer.py
-[Roman to Integer]:https://oj.leetcode.com/problems/roman-to-integer/
-[roman-to-integer.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/roman-to-integer.py
-[Valid Number]:https://oj.leetcode.com/problems/valid-number/
-[valid-number.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/valid-number.py
-
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+7| [Reverse Integer](https://leetcode.com/problems/reverse-integer/) | [Python](./Python/reverse-integer.py) | _O(logn)_ | _O(1)_         | Easy           ||
+9| [Palindrome Number](https://leetcode.com/problems/palindrome-number/) | [Python](./Python/palindrome-number.py) | _O(1)_ | _O(1)_        | Easy           ||
+12| [Integer to Roman](https://leetcode.com/problems/integer-to-roman/) | [Python](./Python/integer-to-roman.py) | _O(n)_ | _O(1)_          | Medium         ||
+13| [Roman to Integer](https://leetcode.com/problems/roman-to-integer/) | [Python](./Python/roman-to-integer.py) | _O(n)_ | _O(1)_          | Easy           ||
+29| [Divide Two Integers](https://leetcode.com/problems/divide-two-integers/) | [Python](./Python/divide-two-integers.py)    | _O(logn)_       | _O(1)_         | Medium         ||
+60| [Permutation Sequence](https://leetcode.com/problems/permutation-sequence/) | [Python](./Python/permutation-sequence.py) | _O(n^2)_ | _O(n)_  | Medium         || `Cantor Ordering`
+65| [Valid Number](https://leetcode.com/problems/valid-number/) | [Python](./Python/valid-number.py) | _O(n)_         | _O(1)_          | Hard           || `Automata`
+89| [Gray Code](https://leetcode.com/problems/gray-code/)     | [Python](./Python/gray-code.py)  | _O(2^n)_        | _O(1)_          | Medium         ||
+166| [Fraction to Recurring Decimal](https://leetcode.com/problems/fraction-to-recurring-decimal/) | [Python](./Python/fraction-to-recurring-decimal.py)  | _O(logn)_ | _O(1)_ | Medium         ||
+168| [Excel Sheet Column Title](https://leetcode.com/problems/excel-sheet-column-title/) | [Python](./Python/excel-sheet-column-title.py) | _O(logn)_ | _O(1)_ | Easy ||
+171| [Excel Sheet Column Number](https://leetcode.com/problems/excel-sheet-column-number/) | [Python](./Python/excel-sheet-column-number.py) | _O(n)_ | _O(1)_ | Easy  ||
+172| [Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/) | [Python](./Python/factorial-trailing-zeroes.py)  | _O(logn)_ | _O(1)_ | Easy         ||
 
 --- 
 
 ##Sort
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Insert Interval]| [insert-interval.py] | _O(n)_    | _O(1)_          | Hard           |
-[Insertion Sort List]|[insertion-sort-list.py] | _O(n^2)_ | _O(1)_    | Medium         |
-[Largest Number] | [largest-number.py] | _O(n^2)_   | _O(n)_          | Medium         |
-[Maximum Gap]   | [maximum-gap.py]| _O(n)_          | _O(n)_          | Hard           | Tricky 
-[Merge Intervals]| [merge-intervals.py] | _O(nlogn)_  | _O(1)_        | Hard           |
-[Merge Sorted Array]| [merge-sorted-array.py] | _O(n)_ | _O(1)_       | Easy           |
-[Merge Two Sorted Lists]| [merge-two-sorted-lists.py] | _O(n)_ | _O(1)_ | Easy         |
-[Sort Colors]   | [sort-colors.py] | _O(n)_         | _O(1)_          | Medium         |
-[Sort List]     | [sort-list.py]  | _O(nlogn)_      | _O(logn)_       | Medium         |
-
-[Insert Interval]:https://oj.leetcode.com/problems/insert-interval/
-[insert-interval.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/insert-interval.py
-[Insertion Sort List]:https://oj.leetcode.com/problems/insertion-sort-list/
-[insertion-sort-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/insertion-sort-list.py
-[Largest Number]:https://oj.leetcode.com/problems/largest-number/
-[largest-number.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/largest-number.py
-[Maximum Gap]:https://oj.leetcode.com/problems/maximum-gap/
-[maximum-gap.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/maximum-gap.py
-[Merge Intervals]:https://oj.leetcode.com/problems/merge-intervals/
-[merge-intervals.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/merge-intervals.py
-[Merge Sorted Array]:https://oj.leetcode.com/problems/merge-sorted-array/
-[merge-sorted-array.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/merge-sorted-array.py
-[Merge Two Sorted Lists]:https://oj.leetcode.com/problems/merge-two-sorted-lists/
-[merge-two-sorted-lists.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/merge-two-sorted-lists.py
-[Sort Colors]:https://oj.leetcode.com/problems/sort-colors/
-[sort-colors.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/sort-colors.py
-[Sort List]:https://oj.leetcode.com/problems/sort-list/
-[sort-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/sort-list.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+21| [Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/)| [Python](./Python/merge-two-sorted-lists.py) | _O(n)_ | _O(1)_ | Easy         ||
+56| [Merge Intervals](https://leetcode.com/problems/merge-intervals/)| [Python](./Python/merge-intervals.py) | _O(nlogn)_  | _O(1)_        | Hard           ||
+57| [Insert Interval](https://leetcode.com/problems/insert-interval/)| [Python](./Python/insert-interval.py) | _O(n)_    | _O(1)_          | Hard           ||
+75| [Sort Colors](https://leetcode.com/problems/sort-colors/)   | [Python](./Python/sort-colors.py) | _O(n)_         | _O(1)_          | Medium         ||
+88| [Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/)| [Python](./Python/merge-sorted-array.py) | _O(n)_ | _O(1)_       | Easy           ||
+147| [Insertion Sort List](https://leetcode.com/problems/insertion-sort-list/)|[Python](./Python/insertion-sort-list.py) | _O(n^2)_ | _O(1)_    | Medium         ||
+148| [Sort List](https://leetcode.com/problems/sort-list/)     | [Python](./Python/sort-list.py)  | _O(nlogn)_      | _O(logn)_       | Medium         ||
+164| [Maximum Gap](https://leetcode.com/problems/maximum-gap/)   | [Python](./Python/maximum-gap.py)| _O(n)_          | _O(n)_          | Hard           || Tricky 
+179| [Largest Number](https://leetcode.com/problems/largest-number/) | [Python](./Python/largest-number.py) | _O(nlogn)_   | _O(1)_        | Medium         ||
+218| [The Skyline Problem ](https://leetcode.com/problems/the-skyline-problem/) | [C++](./C++/the-skyline-problem.cpp) [Python](./Python/the-skyline-problem.py) | _O(nlogn)_   | _O(n)_        | Hard         | Sort, BST|
 
 ---
 
 ##Two Pointer
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Linked List Cycle]| [linked-list-cycle.py] | _O(n)_ | _O(1)_         | Medium         | 
-[Linked List Cycle II]| [linked-list-cycle-ii.py] | _O(n)_ | _O(1)_   | Medium         |
-[Partition List]| [partition-list.py] | _O(n)_       | _O(1)_         | Medium         | 
-[Remove Nth Node From End of List]| [remove-nth-node-from-end-of-list.py] | _O(n)_       | _O(1)_         | Easy         | 
-[Reorder List]| [reorder-list.py] | _O(n)_          |  _O(1)_         | Medium         |  
-[Two Sum II - Input array is sorted] | [two-sum-ii-input-array-is-sorted.py] | _O(n)_   | _O(1)_         | Medium         |
-
-[Linked List Cycle]:https://oj.leetcode.com/problems/linked-list-cycle/
-[linked-list-cycle.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/linked-list-cycle.py
-[Linked List Cycle II]:https://oj.leetcode.com/problems/linked-list-cycle-ii/
-[linked-list-cycle-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/linked-list-cycle-ii.py
-[Partition List]:https://oj.leetcode.com/problems/partition-list/
-[partition-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/partition-list.py
-[Remove Nth Node From End of List]:https://oj.leetcode.com/problems/remove-nth-node-from-end-of-list/
-[remove-nth-node-from-end-of-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/remove-nth-node-from-end-of-list.py
-[Reorder List]:https://oj.leetcode.com/problems/reorder-list/
-[reorder-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/reorder-list.py
-[Two Sum II - Input array is sorted]:https://oj.leetcode.com/problems/two-sum-ii-input-array-is-sorted/
-[two-sum-ii-input-array-is-sorted.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/two-sum-ii-input-array-is-sorted.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+19| [Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/)| [Python](./Python/remove-nth-node-from-end-of-list.py) | _O(n)_       | _O(1)_         | Easy         || 
+86| [Partition List](https://leetcode.com/problems/partition-list/)| [Python](./Python/partition-list.py) | _O(n)_       | _O(1)_         | Medium         || 
+141| [Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/)| [Python](./Python/linked-list-cycle.py) | _O(n)_ | _O(1)_         | Medium         || 
+142| [Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/)| [Python](./Python/linked-list-cycle-ii.py) | _O(n)_ | _O(1)_   | Medium         ||
+143| [Reorder List](https://leetcode.com/problems/reorder-list/)| [Python](./Python/reorder-list.py) | _O(n)_          |  _O(1)_         | Medium         ||  
+167| [Two Sum II - Input array is sorted](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/) | [Python](./Python/two-sum-ii-input-array-is-sorted.py) | _O(n)_   | _O(1)_         | Medium         | 📖 |
 
 ---
 
 ##Brute Force Search
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Letter Combinations of a Phone Number]| [letter-combinations-of-a-phone-number.py] | _O(n * 4^n)_ | _O(n)_ | Medium |
-[Permutations]| [permutations.py] | _O(n!)_         | _O(n)_          | Medium         |
-[Permutations II]| [permutations-ii.py] | _O(n!)_   | _O(n)_          | Hard           |
-[Subsets]       | [subsets.py]    | _O(n * 2^n)_    | _O(1)_          | Medium         |
-[Subsets II]    | [subsets-ii.py] | _O(n * 2^n)_    | _O(1)_          | Medium         |
-
-[Letter Combinations of a Phone Number]:https://oj.leetcode.com/problems/letter-combinations-of-a-phone-number/
-[letter-combinations-of-a-phone-number.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/letter-combinations-of-a-phone-number.py
-[Permutations]:https://oj.leetcode.com/problems/permutations/
-[permutations.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/permutations.py
-[Permutations II]:https://oj.leetcode.com/problems/permutations-ii/
-[permutations-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/permutations-ii.py
-[Subsets]:https://oj.leetcode.com/problems/subsets/
-[subsets.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/subsets.py
-[Subsets II]:https://oj.leetcode.com/problems/subsets-ii/
-[subsets-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/subsets-ii.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+17| [Letter Combinations of a Phone Number](https://leetcode.com/problems/letter-combinations-of-a-phone-number/)| [Python](./Python/letter-combinations-of-a-phone-number.py) | _O(n * 4^n)_ | _O(n)_ | Medium ||
+46| [Permutations](https://leetcode.com/problems/permutations/)| [Python](./Python/permutations.py) | _O(n!)_         | _O(n)_          | Medium         ||
+47| [Permutations II](https://leetcode.com/problems/permutations-ii/)| [Python](./Python/permutations-ii.py) | _O(n!)_   | _O(n)_          | Hard           ||
+78| [Subsets](https://leetcode.com/problems/subsets/)       | [Python](./Python/subsets.py)    | _O(n * 2^n)_    | _O(1)_          | Medium         ||
+90| [Subsets II](https://leetcode.com/problems/subsets-ii/)    | [Python](./Python/subsets-ii.py) | _O(n * 2^n)_    | _O(1)_          | Medium         ||
 
 --- 
 
 ##Divide and Conquer
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Balanced Binary Tree] | [balanced-binary-tree.py] | _O(n)_| _O(h)_   | Easy           |
-[Binary Tree Maximum Path Sum]| [binary-tree-maximum-path-sum.py] | _O(n)_| _O(h)_| Hard  |  
-[Binary Tree Upside Down] | [binary-tree-upside-down.py] | _O(n)_ | _O(1)_ | Medium    | 
-[Construct Binary Tree from Inorder and Postorder Traversal] | [construct-binary-tree-from-inorder-and-postorder-traversal.py] | _O(n)_        | _O(n)_          | Medium         |
-[Construct Binary Tree from Preorder and Inorder Traversal] | [construct-binary-tree-from-preorder-and-inorder-traversal.py] | _O(n)_        | _O(n)_          | Medium   
-[Convert Sorted Array to Binary Search Tree] | [convert-sorted-array-to-binary-search-tree.py] | _O(n)_        | _O(logn)_          | Medium         |
-[Convert Sorted List to Binary Search Tree] | [convert-sorted-list-to-binary-search-tree.py] | _O(n)_        | _O(logn)_          | Medium         |
-[Flatten Binary Tree to Linked List]|[flatten-binary-tree-to-linked-list.py]| _O(n)_        | _O(h)_          | Medium         |
-[Maximum Depth of Binary Tree]|[maximum-depth-of-binary-tree.py]| _O(n)_ | _O(h)_ | Easy |
-[Minimum Depth of Binary Tree]|[minimum-depth-of-binary-tree.py]| _O(n)_ | _O(h)_ | Easy |
-[Populating Next Right Pointers in Each Node]|[populating-next-right-pointers-in-each-node.py]| _O(n)_ | _O(1)_ | Medium |
-[Same Tree]      |[same-tree.py]  | _O(n)_          | _O(h)_        | Easy          |
-[Sum Root to Leaf Numbers] | [sum-root-to-leaf-numbers.py] | _O(n)_ | _O(h)_ | Medium |
-[Unique Binary Search Trees II] | [unique-binary-search-trees-ii.py] | _O(4^n / n^(3/2)_      | _O(4^n / n^(3/2)_         | Medium         |
-[Validate Binary Search Tree]|[validate-binary-search-tree.py]| _O(n)_ | _O(1)_ | Medium |
-
-[Balanced Binary Tree]:https://oj.leetcode.com/problems/balanced-binary-tree/
-[balanced-binary-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/balanced-binary-tree.py
-[Binary Tree Maximum Path Sum]:https://oj.leetcode.com/problems/binary-tree-maximum-path-sum/
-[binary-tree-maximum-path-sum.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-maximum-path-sum.py
-[Binary Tree Upside Down]:https://oj.leetcode.com/problems/binary-tree-upside-down/
-[binary-tree-upside-down.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-upside-down.py
-[Construct Binary Tree from Inorder and Postorder Traversal]:https://oj.leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/
-[construct-binary-tree-from-inorder-and-postorder-traversal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/construct-binary-tree-from-inorder-and-postorder-traversal.py
-[Construct Binary Tree from Preorder and Inorder Traversal]:https://oj.leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/
-[construct-binary-tree-from-preorder-and-inorder-traversal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/construct-binary-tree-from-preorder-and-inorder-traversal.py
-[Convert Sorted Array to Binary Search Tree]:https://oj.leetcode.com/problems/convert-sorted-array-to-binary-search-tree/
-[convert-sorted-array-to-binary-search-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/convert-sorted-array-to-binary-search-tree.py
-[Convert Sorted List to Binary Search Tree]:https://oj.leetcode.com/problems/convert-sorted-list-to-binary-search-tree/
-[convert-sorted-list-to-binary-search-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/convert-sorted-list-to-binary-search-tree.py
-[Flatten Binary Tree to Linked List]:https://oj.leetcode.com/problems/flatten-binary-tree-to-linked-list/
-[flatten-binary-tree-to-linked-list.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/flatten-binary-tree-to-linked-list.py
-[Maximum Depth of Binary Tree]:https://oj.leetcode.com/problems/maximum-depth-of-binary-tree/
-[maximum-depth-of-binary-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/maximum-depth-of-binary-tree.py
-[Minimum Depth of Binary Tree]:https://oj.leetcode.com/problems/minimum-depth-of-binary-tree/
-[minimum-depth-of-binary-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/minimum-depth-of-binary-tree.py
-[Populating Next Right Pointers in Each Node]:https://oj.leetcode.com/problems/populating-next-right-pointers-in-each-node/
-[populating-next-right-pointers-in-each-node.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/populating-next-right-pointers-in-each-node.py
-[Same Tree]:https://oj.leetcode.com/problems/same-tree/
-[same-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/same-tree.py
-[Sum Root to Leaf Numbers]:https://oj.leetcode.com/problems/sum-root-to-leaf-numbers/
-[sum-root-to-leaf-numbers.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/sum-root-to-leaf-numbers.py
-[Unique Binary Search Trees II]:https://oj.leetcode.com/problems/unique-binary-search-trees-ii/
-[unique-binary-search-trees-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/unique-binary-search-trees-ii.py
-[Validate Binary Search Tree]:https://oj.leetcode.com/problems/validate-binary-search-tree/
-[validate-binary-search-tree.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/validate-binary-search-tree.py
-
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+95| [Unique Binary Search Trees II](https://leetcode.com/problems/unique-binary-search-trees-ii/) | [Python](./Python/unique-binary-search-trees-ii.py) | _O(4^n / n^(3/2)_      | _O(4^n / n^(3/2)_         | Medium         ||
+98| [Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/)|[Python](./Python/validate-binary-search-tree.py)| _O(n)_ | _O(1)_ | Medium ||
+100| [Same Tree](https://leetcode.com/problems/same-tree/)      |[Python](./Python/same-tree.py)  | _O(n)_          | _O(h)_        | Easy          ||
+104| [Maximum Depth of Binary Tree](https://leetcode.com/problems/maximum-depth-of-binary-tree/)|[Python](./Python/maximum-depth-of-binary-tree.py)| _O(n)_ | _O(h)_ | Easy ||
+105| [Construct Binary Tree from Preorder and Inorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/) | [Python](./Python/construct-binary-tree-from-preorder-and-inorder-traversal.py) | _O(n)_        | _O(n)_          | Medium   ||
+106| [Construct Binary Tree from Inorder and Postorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/) | [Python](./Python/construct-binary-tree-from-inorder-and-postorder-traversal.py) | _O(n)_        | _O(n)_          | Medium         ||
+108| [Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) | [Python](./Python/convert-sorted-array-to-binary-search-tree.py) | _O(n)_        | _O(logn)_          | Medium         ||
+109| [Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/) | [Python](./Python/convert-sorted-list-to-binary-search-tree.py) | _O(n)_        | _O(logn)_          | Medium         ||
+110| [Balanced Binary Tree](https://leetcode.com/problems/balanced-binary-tree/) | [Python](./Python/balanced-binary-tree.py) | _O(n)_| _O(h)_   | Easy           ||
+111| [Minimum Depth of Binary Tree](https://leetcode.com/problems/minimum-depth-of-binary-tree/)|[Python](./Python/minimum-depth-of-binary-tree.py)| _O(n)_ | _O(h)_ | Easy ||
+114| [Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/)|[Python](./Python/flatten-binary-tree-to-linked-list.py)| _O(n)_        | _O(h)_          | Medium         ||
+116| [Populating Next Right Pointers in Each Node](https://leetcode.com/problems/populating-next-right-pointers-in-each-node/)|[Python](./Python/populating-next-right-pointers-in-each-node.py)| _O(n)_ | _O(1)_ | Medium ||
+124| [Binary Tree Maximum Path Sum](https://leetcode.com/problems/binary-tree-maximum-path-sum/)| [Python](./Python/binary-tree-maximum-path-sum.py) | _O(n)_| _O(h)_| Hard  ||  
+129| [Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/) | [Python](./Python/sum-root-to-leaf-numbers.py) | _O(n)_ | _O(h)_ | Medium ||
+156| [Binary Tree Upside Down](https://leetcode.com/problems/binary-tree-upside-down/) | [Python](./Python/binary-tree-upside-down.py) | _O(n)_ | _O(1)_ | Medium    |📖| 
 
 --- 
 
 ##Binary Search
-
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Find Minimum in Rotated Sorted Array]         | [find-minimum-in-rotated-sorted-array.py]       | _O(logn)_        | _O(1)_          | Medium         |
-[Find Minimum in Rotated Sorted Array II]      | [find-minimum-in-rotated-sorted-array-ii.py]       | _O(logn)_ ~ _O(n)_        | _O(1)_          | Hard         |
-[Find Peak Element] | [find-peak-element.py]        | _O(logn)_       | _O(1)_          | Medium         |
-[Median of Two Sorted Arrays] | [median-of-two-sorted-arrays.py] | _O(log(m + n)_ | _O(1)_ | Hard         |
-[Pow(x, n)]     | [powx-n.py]     | _O(logn)_       | _O(logn)_       | Medium         |
-[Search a 2D Matrix] | [search-a-2d-matrix.py] | _O(log m + logn)_ | _O(1)_ | Medium   |
-[Search for a Range] | [search-for-a-range.py] | _O(logn)_ | _O(1)_   | Medium         |
-[Search in Rotated Sorted Array] | [search-in-rotated-sorted-array.py] | _O(logn)_ | _O(1)_   | Hard         |
-[Search in Rotated Sorted Array II] | [search-in-rotated-sorted-array-ii.py] | _O(logn)_ | _O(1)_   | Medium         |
-[Search Insert Position] | [search-insert-position.py] | _O(logn)_ | _O(1)_   | Medium         |
-[Sqrt(x)]       | [sqrtx.py]      | _O(logn)_        | _O(1)_         | Medium         |
-
-[Find Minimum in Rotated Sorted Array]:https://oj.leetcode.com/problems/find-minimum-in-rotated-sorted-array/
-[find-minimum-in-rotated-sorted-array.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/find-minimum-in-rotated-sorted-array.py
-[Find Minimum in Rotated Sorted Array II]:https://oj.leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/
-[find-minimum-in-rotated-sorted-array-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/find-minimum-in-rotated-sorted-array-ii.py
-[Find Peak Element]:https://oj.leetcode.com/problems/find-peak-element/
-[find-peak-element.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/find-peak-element.py
-[Median of Two Sorted Arrays]:https://oj.leetcode.com/problems/median-of-two-sorted-arrays/
-[median-of-two-sorted-arrays.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/median-of-two-sorted-arrays.py
-[Pow(x, n)]:https://oj.leetcode.com/problems/powx-n/
-[powx-n.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/powx-n.py
-[Search a 2D Matrix]:https://oj.leetcode.com/problems/search-a-2d-matrix/
-[search-a-2d-matrix.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/search-a-2d-matrix.py
-[Search for a Range]:https://oj.leetcode.com/problems/search-for-a-range/
-[search-for-a-range.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/search-for-a-range.py
-[Search in Rotated Sorted Array]:https://oj.leetcode.com/problems/search-in-rotated-sorted-array/
-[search-in-rotated-sorted-array.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/search-in-rotated-sorted-array.py
-[Search in Rotated Sorted Array II]:https://oj.leetcode.com/problems/search-in-rotated-sorted-array-ii/
-[search-in-rotated-sorted-array-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/search-in-rotated-sorted-array-ii.py
-[Search Insert Position]:https://oj.leetcode.com/problems/search-insert-position/
-[search-insert-position.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/search-insert-position.py
-[Sqrt(x)]:https://oj.leetcode.com/problems/sqrtx/
-[sqrtx.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/sqrtx.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+4| [Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays/) | [Python](./Python/median-of-two-sorted-arrays.py) | _O(log(m + n))_ | _O(1)_ | Hard         ||
+33| [Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/) | [Python](./Python/search-in-rotated-sorted-array.py) | _O(logn)_ | _O(1)_   | Hard         ||
+34| [Search for a Range](https://leetcode.com/problems/search-for-a-range/) | [Python](./Python/search-for-a-range.py) | _O(logn)_ | _O(1)_   | Medium         ||
+35| [Search Insert Position](https://leetcode.com/problems/search-insert-position/) | [Python](./Python/search-insert-position.py) | _O(logn)_ | _O(1)_   | Medium         ||
+50| [Pow(x, n)](https://leetcode.com/problems/powx-n/)     | [Python](./Python/powx-n.py)     | _O(logn)_       | _O(logn)_       | Medium         ||
+69| [Sqrt(x)](https://leetcode.com/problems/sqrtx/)       | [Python](./Python/sqrtx.py)      | _O(logn)_        | _O(1)_         | Medium         ||
+74| [Search a 2D Matrix](https://leetcode.com/problems/search-a-2d-matrix/) | [Python](./Python/search-a-2d-matrix.py) | _O(logm + logn)_ | _O(1)_ | Medium   ||
+81| [Search in Rotated Sorted Array II](https://leetcode.com/problems/search-in-rotated-sorted-array-ii/) | [Python](./Python/search-in-rotated-sorted-array-ii.py) | _O(logn)_ | _O(1)_   | Medium         ||
+153| [Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/)         | [Python](./Python/find-minimum-in-rotated-sorted-array.py)       | _O(logn)_        | _O(1)_          | Medium         ||
+154| [Find Minimum in Rotated Sorted Array II](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/)      | [Python](./Python/find-minimum-in-rotated-sorted-array-ii.py)       | _O(logn)_ ~ _O(n)_        | _O(1)_          | Hard         ||
+162| [Find Peak Element](https://leetcode.com/problems/find-peak-element/) | [Python](./Python/find-peak-element.py)        | _O(logn)_       | _O(1)_          | Medium         ||
+
+-- 
+##Binary Search Tree
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+220| [Contains Duplicate III](https://leetcode.com/problems/contains-duplicate-iii/)  | [C++](./C++/contains-duplicate-iii.cpp) [Python](./Python/contains-duplicate-iii.py) | _O(nlogk)_        | _O(k)_          | medium           ||
 
 --- 
 
 ##Breadth-First Search
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Binary Tree Level Order Traversal]| [binary-tree-level-order-traversal.py] | _O(n)_| _O(n)_| Easy  |  
-[Binary Tree Level Order Traversal II]| [binary-tree-level-order-traversal-ii.py] | _O(n)_| _O(n)_| Easy  |       
-[Binary Tree Zigzag Level Order Traversal]| [binary-tree-zigzag-level-order-traversal.py] | _O(n)_| _O(n)_| Medium  |  
-[Clone Graph]| [clone-graph.py]   | _O(n)_          | _O(n)_          | Medium         |
-[Populating Next Right Pointers in Each Node II]|[populating-next-right-pointers-in-each-node-ii.py]| _O(n)_ | _O(1)_ | Hard |
-[Surrounded Regions]|[surrounded-regions.py]| _O(m * n)_ | _O(m + n)_ | Medium         |
-[Word Ladder]   |[word-ladder.py] | _O(n * d)_      | _O(d)_          | Medium         |
-
-[Binary Tree Level Order Traversal]:https://oj.leetcode.com/problems/binary-tree-level-order-traversal/
-[binary-tree-level-order-traversal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-level-order-traversal.py
-[Binary Tree Level Order Traversal II]:https://oj.leetcode.com/problems/binary-tree-level-order-traversal-ii/
-[binary-tree-level-order-traversal-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-level-order-traversal-ii.py
-[Binary Tree Zigzag Level Order Traversal]:https://oj.leetcode.com/problems/binary-tree-zigzag-level-order-traversal/
-[binary-tree-zigzag-level-order-traversal.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/binary-tree-zigzag-level-order-traversal.py
-[Clone Graph]:https://oj.leetcode.com/problems/clone-graph/
-[clone-graph.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/clone-graph.py
-[Populating Next Right Pointers in Each Node II]:https://oj.leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/
-[populating-next-right-pointers-in-each-node-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/populating-next-right-pointers-in-each-node-ii.py
-[Surrounded Regions]:https://oj.leetcode.com/problems/surrounded-regions/
-[surrounded-regions.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/surrounded-regions.py
-[Word Ladder]:https://oj.leetcode.com/problems/word-ladder/
-[word-ladder.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/word-ladder.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+102| [Binary Tree Level Order Traversal](https://leetcode.com/problems/binary-tree-level-order-traversal/)| [Python](./Python/binary-tree-level-order-traversal.py)| _O(n)_| _O(n)_| Easy  || 
+107| [Binary Tree Level Order Traversal II](https://leetcode.com/problems/binary-tree-level-order-traversal-ii/)| [Python](./Python/binary-tree-level-order-traversal-ii.py) | _O(n)_| _O(n)_| Easy  ||
+103| [Binary Tree Zigzag Level Order Traversal](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)| [Python](./Python/binary-tree-zigzag-level-order-traversal.py) | _O(n)_| _O(n)_| Medium  ||  
+117| [Populating Next Right Pointers in Each Node II](https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/)|[Python](./Python/populating-next-right-pointers-in-each-node-ii.py)| _O(n)_ | _O(1)_ | Hard ||
+127| [Word Ladder](https://leetcode.com/problems/word-ladder/)|[Python](./Python/word-ladder.py) | _O(n * d)_      | _O(d)_          | Medium         ||
+130| [Surrounded Regions](https://leetcode.com/problems/surrounded-regions/)|[Python](./Python/surrounded-regions.py)| _O(m * n)_ | _O(m + n)_ | Medium         ||
+133| [Clone Graph](https://leetcode.com/problems/clone-graph/)| [Python](./Python/clone-graph.py)   | _O(n)_          | _O(n)_          | Medium         ||
+207| [Course Schedule](https://leetcode.com/problems/course-schedule/)| [Python](./Python/course-schedule.py)   | _O(\|V\| + \|E\|)_          | _O(\|E\|)_          | Medium         ||
+210| [Course Schedule II](https://leetcode.com/problems/course-schedule-ii/)| [Python](./Python/course-schedule-ii.py)   | _O(\|V\| + \|E\|)_          | _O(\|E\|)_          | Medium         ||
 
 --- 
 
 ##Depth-First Search
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Combination Sum]| [combination-sum.py] | _O(n^m)_    | _O(m)_          | Medium         |
-[Combination Sum II]| [combination-sum-ii.py]| _O(n! / m!(n-m)!)_| _O(m)_         | Medium         |
-[Combinations]  | [combinations.py] | _O(n!)_       | _O(n)_          | Medium         |
-[Generate Parentheses]| [generate-parentheses.py]| _O(4^n / n^(3/2))_ | _O(n)_   | Medium         |
-[N-Queens]      | [n-queens.py]   | _O(n!)_         | _O(n)_          | Hard           |
-[N-Queens-II]   | [n-queens-ii.py] | _O(n!)_        | _O(n)_          | Hard           |
-[Palindrome Partitioning] | [palindrome-partitioning.py] | _O(n^2)_ ~ _O(2^n)_ | _O(n^2)_ | Medium |
-[Path Sum]      | [path-sum.py]   | _O(n)_          | _O(h)_          | Easy           |
-[Path Sum II]   | [path-sum-ii.py] | _O(n)_         | _O(h)_          | Medium         |
-[Restore IP Addresses] | [restore-ip-addresses.py] | _O(n^m)_ ~ _O(3^4)_ | _O(n * m)_ ~ _O(3 * 4)_ | Medium         |
-[Sudoku Solver] | [sudoku-solver.py] | _O((9!)^9)_  | _O(1)_          | Hard           |
-[Word Search] | [word-search.py] | _O(m * n * 3^p)_ | _O(m * n * p)_  | Medium         |
-
-[Combination Sum]:https://oj.leetcode.com/problems/combination-sum/
-[combination-sum.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/combination-sum.py
-[Combination Sum II]:https://oj.leetcode.com/problems/combination-sum-ii/
-[combination-sum-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/combination-sum-ii.py
-[Combinations]:https://oj.leetcode.com/problems/combinations/
-[combinations.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/combinations.py
-[Generate Parentheses]:https://oj.leetcode.com/problems/generate-parentheses/
-[generate-parentheses.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/generate-parentheses.py
-[N-Queens]:https://oj.leetcode.com/problems/n-queens/
-[n-queens.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/n-queens.py
-[N-Queens-II]:https://oj.leetcode.com/problems/n-queens-ii/
-[n-queens-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/n-queens-ii.py
-[Palindrome Partitioning]:https://oj.leetcode.com/problems/palindrome-partitioning/
-[palindrome-partitioning.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/palindrome-partitioning.py
-[Path Sum]:https://oj.leetcode.com/problems/path-sum/
-[path-sum.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/path-sum.py
-[Path Sum II]:https://oj.leetcode.com/problems/path-sum-ii/
-[path-sum-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/path-sum-ii.py
-[Restore IP Addresses]:https://oj.leetcode.com/problems/restore-ip-addresses/
-[restore-ip-addresses.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/restore-ip-addresses.py
-[Sudoku Solver]:https://oj.leetcode.com/problems/sudoku-solver/
-[sudoku-solver.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/sudoku-solver.py
-[Word Search]:https://oj.leetcode.com/problems/word-search/
-[word-search.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/word-search.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+22| [Generate Parentheses](https://leetcode.com/problems/generate-parentheses/)| [Python](./Python/generate-parentheses.py)| _O(4^n / n^(3/2))_ | _O(n)_   | Medium         ||
+37| [Sudoku Solver](https://leetcode.com/problems/sudoku-solver/) | [Python](./Python/sudoku-solver.py) | _O((9!)^9)_  | _O(1)_          | Hard           ||
+39| [Combination Sum](https://leetcode.com/problems/combination-sum/)| [Python](./Python/combination-sum.py) | _O(n^m)_    | _O(m)_          | Medium         ||
+40| [Combination Sum II](https://leetcode.com/problems/combination-sum-ii/)| [Python](./Python/combination-sum-ii.py)| _O(n! / m!(n-m)!)_| _O(m)_         | Medium         ||
+51| [N-Queens](https://leetcode.com/problems/n-queens/)      | [Python](./Python/n-queens.py)   | _O(n!)_         | _O(n)_          | Hard           ||
+52| [N-Queens-II](https://leetcode.com/problems/n-queens-ii/)   | [Python](./Python/n-queens-ii.py) | _O(n!)_        | _O(n)_          | Hard           ||
+77| [Combinations](https://leetcode.com/problems/combinations/)  | [Python](./Python/combinations.py) | _O(n!)_       | _O(n)_          | Medium         ||
+79| [Word Search](https://leetcode.com/problems/word-search/) | [Python](./Python/word-search.py) | _O(m * n * l)_ | _O(l)_  | Medium         ||
+93| [Restore IP Addresses](https://leetcode.com/problems/restore-ip-addresses/) | [Python](./Python/restore-ip-addresses.py) | _O(n^m)_ ~ _O(3^4)_ | _O(n * m)_ ~ _O(3 * 4)_ | Medium         ||
+112| [Path Sum](https://leetcode.com/problems/path-sum/)      | [Python](./Python/path-sum.py)   | _O(n)_          | _O(h)_          | Easy           ||
+113| [Path Sum II](https://leetcode.com/problems/path-sum-ii/)   | [Python](./Python/path-sum-ii.py) | _O(n)_         | _O(h)_          | Medium         ||
+131| [Palindrome Partitioning](https://leetcode.com/problems/palindrome-partitioning/) | [Python](./Python/palindrome-partitioning.py) | _O(n^2)_ ~ _O(2^n)_ | _O(n^2)_ | Medium ||
+199| [Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/) | [Python](./Python/binary-tree-right-side-view.py) | _O(n)_     | _O(h)_ | Medium  ||
+200| [Number of Islands](https://leetcode.com/problems/number-of-islands/) | [Python](./Python/number-of-islands.py) | _O(m * n)_ | _O(m * n)_| Medium         ||
+216| [Combination Sum III](https://leetcode.com/problems/combination-sum-iii/)| [C++](./C++/combination-sum-iii.cpp) [Python](./Python/combination-sum-iii.py) | _O(C(n, k))_    | _O(k)_          | Medium         ||
 
 --- 
 
 ##Dynamic Programming
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Best Time to Buy and Sell Stock III]| [best-time-to-buy-and-sell-stock-iii.py] | _O(n)_ | _O(1)_ | Hard |
-[Best Time to Buy and Sell Stock IV]| [best-time-to-buy-and-sell-stock-iv.py] | _O(k * n)_ | _O(k)_ | Hard |
-[Climbing Stairs]| [climbing-stairs.py] | _O(n)_    | _O(1)_          | Easy           |
-[Decode Ways]   | [decode-ways.py]| _O(n)_          | _O(1)_          | Medium         |
-[Distinct Subsequences]|[distinct-subsequences.py]| _O(n^2)_ | _O(n)_ | Hard           |
-[Dungeon Game]  | [dungeon-game.py]| _O(m * n)_     | _O(m + n)_      | Hard           |
-[Edit Distance]|[edit-distance.py]| _O(m * n)_      | _O(m + n)_      | Hard           |
-[Interleaving String]|[interleaving-string.py]| _O(m * n)_ | _O(m + n)_ | Hard         |
-[Maximal Rectangle]|[maximal-rectangle.py]| _O(n^2)_ | _O(n)_         | Hard           |
-[Maximum Product Subarray]|[maximum-product-subarray.py]| _O(n)_ | _O(1)_ | Medium     |
-[Maximum Subarray]|[maximum-subarray.py]| _O(n)_     | _O(1)_         | Medium         |
-[Minimum Path Sum]|[minimum-path-sum.py]| _O(m * n)_ | _O(m + n)_     | Medium         |
-[Palindrome Partitioning II] | [palindrome-partitioning-ii.py] | _O(n^2)_ | _O(n^2)_ | Hard |
-[Regular Expression Matching] | [regular-expression-matching.py] | _O(m * n)_ | _O(n)_ | Hard |
-[Scramble String] | [scramble-string.py] | _O(n^4)_ | _O(n^3)_        | Hard           |
-[Triangle]       | [triangle.py]   | _O(m * n)_      | _O(n)_         | Medium         |
-[Unique Binary Search Trees] | [unique-binary-search-trees.py] | _O(n^2)_      | _O(n)_         | Medium         |
-[Unique Paths]    | [unique-paths.py]| _O(m * n)_      | _O(m + n)_   | Medium         |
-[Unique Paths II] | [unique-paths-ii.py] |  _O(m * n)_ | _O(m + n)_   | Medium         |
-[Word Break]     | [word-break.py] |  _O(n^2)_         | _O(n)_       | Medium         |
-[Word Break II]  | [word-break-ii.py] |  _O(n^2)_      | _O(n)_       | Hard           |
-
-[Best Time to Buy and Sell Stock III]:https://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/
-[best-time-to-buy-and-sell-stock-iii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/best-time-to-buy-and-sell-stock-iii.py
-[Best Time to Buy and Sell Stock IV]:https://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/
-[best-time-to-buy-and-sell-stock-iv.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/best-time-to-buy-and-sell-stock-iv.py
-[Climbing Stairs]:https://oj.leetcode.com/problems/climbing-stairs/
-[climbing-stairs.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/climbing-stairs.py
-[Decode Ways]:https://oj.leetcode.com/problems/decode-ways/
-[decode-ways.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/decode-ways.py
-[Distinct Subsequences]:https://oj.leetcode.com/problems/distinct-subsequences/
-[distinct-subsequences.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/distinct-subsequences.py
-[Dungeon Game]:https://oj.leetcode.com/problems/dungeon-game/
-[dungeon-game.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/dungeon-game.py
-[Edit Distance]:https://oj.leetcode.com/problems/edit-distance/
-[edit-distance.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/edit-distance.py
-[Interleaving String]:https://oj.leetcode.com/problems/interleaving-string/
-[interleaving-string.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/interleaving-string.py
-[Maximal Rectangle]:https://oj.leetcode.com/problems/maximal-rectangle/
-[maximal-rectangle.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/maximal-rectangle.py
-[Maximum Product Subarray]:https://oj.leetcode.com/problems/maximum-product-subarray/
-[maximum-product-subarray.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/maximum-product-subarray.py
-[Maximum Subarray]:https://oj.leetcode.com/problems/maximum-subarray/
-[maximum-subarray.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/maximum-subarray.py
-[Minimum Path Sum]:https://oj.leetcode.com/problems/minimum-path-sum/
-[minimum-path-sum.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/minimum-path-sum.py
-[Palindrome Partitioning II]:https://oj.leetcode.com/problems/palindrome-partitioning-ii/
-[palindrome-partitioning-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/palindrome-partitioning-ii.py
-[Regular Expression Matching]:https://oj.leetcode.com/problems/regular-expression-matching/
-[regular-expression-matching.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/regular-expression-matching.py
-[Scramble String]:https://oj.leetcode.com/problems/scramble-string/
-[scramble-string.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/scramble-string.py
-[Triangle]:https://oj.leetcode.com/problems/triangle/
-[triangle.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/triangle.py
-[Unique Binary Search Trees]:https://oj.leetcode.com/problems/unique-binary-search-trees/
-[unique-binary-search-trees.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/unique-binary-search-trees.py
-[Unique Paths]:https://oj.leetcode.com/problems/unique-paths/
-[unique-paths.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/unique-paths.py
-[Unique Paths II]:https://oj.leetcode.com/problems/unique-paths-ii/
-[unique-paths-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/unique-paths-ii.py
-[Word Break]:https://oj.leetcode.com/problems/word-break/
-[word-break.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/word-break.py
-[Word Break II]:https://oj.leetcode.com/problems/word-break-ii/
-[word-break-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/word-break-ii.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+10| [Regular Expression Matching](https://leetcode.com/problems/regular-expression-matching/) | [Python](./Python/regular-expression-matching.py) | _O(m * n)_ | _O(n)_ | Hard ||
+53| [Maximum Subarray](https://leetcode.com/problems/maximum-subarray/)|[Python](./Python/maximum-subarray.py)| _O(n)_     | _O(1)_         | Medium         ||
+62| [Unique Paths](https://leetcode.com/problems/unique-paths/)    | [Python](./Python/unique-paths.py)| _O(m * n)_      | _O(m + n)_   | Medium         ||
+63| [Unique Paths II](https://leetcode.com/problems/unique-paths-ii/) | [Python](./Python/unique-paths-ii.py) |  _O(m * n)_ | _O(m + n)_   | Medium         ||
+64| [Minimum Path Sum](https://leetcode.com/problems/minimum-path-sum/)|[Python](./Python/minimum-path-sum.py)| _O(m * n)_ | _O(m + n)_     | Medium         ||
+70| [Climbing Stairs](https://leetcode.com/problems/climbing-stairs/)| [Python](./Python/climbing-stairs.py) | _O(n)_    | _O(1)_          | Easy           ||
+72| [Edit Distance](https://leetcode.com/problems/edit-distance/)|[Python](./Python/edit-distance.py)| _O(m * n)_      | _O(m + n)_      | Hard           ||
+85| [Maximal Rectangle](https://leetcode.com/problems/maximal-rectangle/)|[Python](./Python/maximal-rectangle.py)| _O(n^2)_ | _O(n)_         | Hard           ||
+87| [Scramble String](https://leetcode.com/problems/scramble-string/) | [Python](./Python/scramble-string.py) | _O(n^4)_ | _O(n^3)_        | Hard           ||
+91| [Decode Ways](https://leetcode.com/problems/decode-ways/)   | [Python](./Python/decode-ways.py)| _O(n)_          | _O(1)_          | Medium         ||
+96| [Unique Binary Search Trees](https://leetcode.com/problems/unique-binary-search-trees/) | [Python](./Python/unique-binary-search-trees.py) | _O(n^2)_      | _O(n)_         | Medium         ||
+97| [Interleaving String](https://leetcode.com/problems/interleaving-string/)|[Python](./Python/interleaving-string.py)| _O(m * n)_ | _O(m + n)_ | Hard         ||
+115| [Distinct Subsequences](https://leetcode.com/problems/distinct-subsequences/)|[Python](./Python/distinct-subsequences.py)| _O(n^2)_ | _O(n)_ | Hard           ||
+120| [Triangle](https://leetcode.com/problems/triangle/)       | [Python](./Python/triangle.py)   | _O(m * n)_      | _O(n)_         | Medium         ||
+123| [Best Time to Buy and Sell Stock III](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iii/) | [Python](./Python/best-time-to-buy-and-sell-stock-iii.py) | _O(n)_ | _O(1)_ | Hard ||
+132| [Palindrome Partitioning II](https://leetcode.com/problems/palindrome-partitioning-ii/) | [Python](./Python/palindrome-partitioning-ii.py) | _O(n^2)_ | _O(n^2)_ | Hard ||
+139| [Word Break](https://leetcode.com/problems/word-break/)     | [Python](./Python/word-break.py) |  _O(n^2)_         | _O(n)_       | Medium         ||
+140| [Word Break II](https://leetcode.com/problems/word-break-ii/)  | [Python](./Python/word-break-ii.py) |  _O(n^2)_      | _O(n)_       | Hard           ||
+152| [Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/)|[Python](./Python/maximum-product-subarray.py)| _O(n)_ | _O(1)_ | Medium     ||
+174| [Dungeon Game](https://leetcode.com/problems/dungeon-game/)  | [Python](./Python/dungeon-game.py)| _O(m * n)_     | _O(m + n)_      | Hard           ||
+188| [Best Time to Buy and Sell Stock IV](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/)| [Python](./Python/best-time-to-buy-and-sell-stock-iv.py) | _O(k * n)_ | _O(k)_ | Hard ||
+198| [House Robber](https://leetcode.com/problems/house-robber/)| [Python](./Python/house-robber.py) | _O(n)_          | _O(1)_          | Easy           ||
+213| [House Robber II](https://leetcode.com/problems/house-robber-ii/)| [C++](./C++/house-robber-ii.cpp) [Python](./Python/house-robber-ii.py) | _O(n)_          | _O(1)_          | Medium           ||
 
 --- 
 
 ##Backtracking
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Word Ladder II]   |[word-ladder-ii.py] | _O(n * d)_ | _O(d)_         | Hard         |
-
-[Word Ladder II]:https://oj.leetcode.com/problems/word-ladder-ii/
-[word-ladder-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/word-ladder-ii.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+126| [Word Ladder II](https://leetcode.com/problems/word-ladder-ii/)   |[Python](./Python/word-ladder-ii.py) | _O(n * d)_ | _O(d)_         | Hard         ||
 
 --- 
 
 ##Greedy
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Best Time to Buy and Sell Stock II]| [best-time-to-buy-and-sell-stock-ii.py] | _O(n)_ | _O(1)_ | Medium |
-[Candy]| [candy.py] | _O(n)_ | _O(n)_ | Hard |
-[Container With Most Water]| [container-with-most-water.py] | _O(n)_ | _O(1)_ | Medium |
-[Gas Station]| [gas-station.py]   | _O(n)_          | _O(1)_          | Medium         |
-[Jump Game]     | [jump-game.py]  | _O(n)_          | _O(1)_          | Medium         |
-[Jump Game II]  | [jump-game-ii.py] | _O(n^2)_      | _O(1)_          | Hard           |
-[Largest Rectangle in Histogram] | [largest-rectangle-in-histogram.py] | _O(n)_ | _O(n)_ | Hard | Tricky
-[Trapping Rain Water] | [trapping-rain-water.py] | _O(n)_ | _O(1)_ | Hard | Tricky
-[Wildcard Matching] | [wildcard-matching.py] | _O(m + n)_ | _O(1)_    | Hard           | Tricky
-
-[Best Time to Buy and Sell Stock II]:https://oj.leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/
-[best-time-to-buy-and-sell-stock-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/best-time-to-buy-and-sell-stock-ii.py
-[Candy]:https://oj.leetcode.com/problems/candy/
-[candy.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/candy.py
-[Container With Most Water]:https://oj.leetcode.com/problems/container-with-most-water/
-[container-with-most-water.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/container-with-most-water.py
-[Gas Station]:https://oj.leetcode.com/problems/gas-station/
-[gas-station.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/gas-station.py
-[Jump Game]:https://oj.leetcode.com/problems/jump-game/
-[jump-game.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/jump-game.py
-[Jump Game II]:https://oj.leetcode.com/problems/jump-game-ii/
-[jump-game-ii.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/jump-game-ii.py
-[Largest Rectangle in Histogram]:https://oj.leetcode.com/problems/largest-rectangle-in-histogram/
-[largest-rectangle-in-histogram.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/largest-rectangle-in-histogram.py
-[Trapping Rain Water]:https://oj.leetcode.com/problems/trapping-rain-water/
-[trapping-rain-water.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/trapping-rain-water.py
-[Wildcard Matching]:https://oj.leetcode.com/problems/wildcard-matching/
-[wildcard-matching.py]:https://github.com/kamyu104/LeetCode/blob/master/Python/wildcard-matching.py
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+11| [Container With Most Water](https://leetcode.com/problems/container-with-most-water/)| [Python](./Python/container-with-most-water.py) | _O(n)_ | _O(1)_ | Medium ||
+42| [Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/) | [Python](./Python/trapping-rain-water.py) | _O(n)_ | _O(1)_ | Hard || Tricky
+44| [Wildcard Matching](https://leetcode.com/problems/wildcard-matching/) | [Python](./Python/wildcard-matching.py) | _O(m + n)_ | _O(1)_    | Hard           || Tricky
+45| [Jump Game II](https://leetcode.com/problems/jump-game-ii/)  | [Python](./Python/jump-game-ii.py) | _O(n)_        | _O(1)_          | Hard           ||
+55| [Jump Game](https://leetcode.com/problems/jump-game/)     | [Python](./Python/jump-game.py)  | _O(n)_          | _O(1)_          | Medium         ||
+84| [Largest Rectangle in Histogram](https://leetcode.com/problems/largest-rectangle-in-histogram/) | [Python](./Python/largest-rectangle-in-histogram.py) | _O(n)_ | _O(n)_ | Hard || Tricky
+122| [Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/)| [Python](./Python/best-time-to-buy-and-sell-stock-ii.py) | _O(n)_ | _O(1)_ | Medium ||
+134| [Gas Station](https://leetcode.com/problems/gas-station/)| [Python](./Python/gas-station.py)   | _O(n)_          | _O(1)_          | Medium         ||
+135| [Candy](https://leetcode.com/problems/candy/)| [Python](./Python/candy.py) | _O(n)_ | _O(n)_ | Hard ||
 
 ---
 
 ##SQL
-Problem         |  Solution       |  Time           | Space           | Difficulty     | Notes
---------------- | --------------- | --------------- | --------------- | -------------- | -----
-[Combine Two Tables] | [combine-two-tables.sql] | _O(m + n)_   | _O(m + n)_ | Easy     |
-[Consecutive Numbers] | [consecutive-numbers.sql] | _O(n)_   | _O(n)_ | Medium         |
-[Customers Who Never Order] | [customers-who-never-order.sql] | _O(n^2)_ | _O(1)_       | Easy           |
-[Department Highest Salary] | [department-highest-salary.sql] | _O(n^2)_   | _O(n)_ | Medium         |
-[Department Top Three Salaries] | [department-top-three-salaries.sql] | _O(n^2)_   | _O(n)_ | Hard         |
-[Duplicate Emails] | [duplicate-emails.sql] | _O(n^2)_ | _O(n)_       | Easy           |
-[Employees Earning More Than Their Managers] | [employees-earning-more-than-their-managers.sql] | _O(n^2)_   | _O(1)_ | Easy     |
-[Nth Highest Salary] | [nth-highest-salary.sql] | _O(n^2)_   | _O(n)_ | Medium         |
-[Rank Scores] | [rank-scores.sql] | _O(n^2)_        | _O(n)_          | Medium         |
-[Second Highest Salary] | [second-highest-salary.sql] | _O(n)_ | _O(1)_ | Easy         |
-
-[Combine Two Tables]:https://oj.leetcode.com/problems/combine-two-tables/
-[combine-two-tables.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/combine-two-tables.sql
-[Consecutive Numbers]:https://oj.leetcode.com/problems/consecutive-numbers/
-[consecutive-numbers.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/consecutive-numbers.sql
-[Customers Who Never Order]:https://oj.leetcode.com/problems/customers-who-never-order/
-[customers-who-never-order.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/customers-who-never-order.sql
-[Department Highest Salary]:https://oj.leetcode.com/problems/department-highest-salary/
-[department-highest-salary.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/department-highest-salary.sql
-[Department Top Three Salaries]:https://oj.leetcode.com/problems/department-top-three-salaries/
-[department-top-three-salaries.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/department-top-three-salaries.sql
-[Duplicate Emails]:https://oj.leetcode.com/problems/duplicate-emails/
-[duplicate-emails.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/duplicate-emails.sql
-[Employees Earning More Than Their Managers]:https://oj.leetcode.com/problems/employees-earning-more-than-their-managers/
-[employees-earning-more-than-their-managers.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/employees-earning-more-than-their-managers.sql
-[Nth Highest Salary]:https://oj.leetcode.com/problems/nth-highest-salary/
-[nth-highest-salary.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/nth-highest-salary.sql
-[Rank Scores]:https://oj.leetcode.com/problems/rank-scores/
-[rank-scores.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/rank-scores.sql
-[Second Highest Salary]:https://oj.leetcode.com/problems/second-highest-salary/
-[second-highest-salary.sql]:https://github.com/kamyu104/LeetCode/blob/master/MySQL/second-highest-salary.sql
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+175| [Combine Two Tables](https://leetcode.com/problems/combine-two-tables/) | [MySQL](./MySQL/combine-two-tables.sql) | _O(m + n)_   | _O(m + n)_ | Easy     ||
+176| [Second Highest Salary](https://leetcode.com/problems/second-highest-salary/) | [MySQL](./MySQL/second-highest-salary.sql) | _O(n)_ | _O(1)_ | Easy         ||
+177| [Nth Highest Salary](https://leetcode.com/problems/nth-highest-salary/) | [MySQL](./MySQL/nth-highest-salary.sql) | _O(n^2)_   | _O(n)_ | Medium         ||
+178| [Rank Scores](https://leetcode.com/problems/rank-scores/) | [MySQL](./MySQL/rank-scores.sql) | _O(n^2)_        | _O(n)_          | Medium         ||
+180| [Consecutive Numbers](https://leetcode.com/problems/consecutive-numbers/) | [MySQL](./MySQL/consecutive-numbers.sql) | _O(n)_   | _O(n)_ | Medium         ||
+181| [Employees Earning More Than Their Managers](https://leetcode.com/problems/employees-earning-more-than-their-managers/) | [MySQL](./MySQL/employees-earning-more-than-their-managers.sql) | _O(n^2)_   | _O(1)_ | Easy     ||
+182| [Duplicate Emails](https://leetcode.com/problems/duplicate-emails/) | [MySQL](./MySQL/duplicate-emails.sql) | _O(n^2)_ | _O(n)_       | Easy           ||
+183| [Customers Who Never Order](https://leetcode.com/problems/customers-who-never-order/) | [MySQL](./MySQL/customers-who-never-order.sql) | _O(n^2)_ | _O(1)_       | Easy           ||
+184| [Department Highest Salary](https://leetcode.com/problems/department-highest-salary/) | [MySQL](./MySQL/department-highest-salary.sql) | _O(n^2)_   | _O(n)_ | Medium         ||
+185| [Department Top Three Salaries](https://leetcode.com/problems/department-top-three-salaries/) | [MySQL](./MySQL/department-top-three-salaries.sql) | _O(n^2)_   | _O(n)_ | Hard         ||
+196| [Delete Duplicate Emails](https://leetcode.com/problems/delete-duplicate-emails/) | [MySQL](./MySQL/delete-duplicate-emails.sql) | _O(n^2)_ | _O(n)_       | Easy           ||
+197| [Rising Temperature](https://leetcode.com/problems/rising-temperature/) | [MySQL](./MySQL/rising-temperature.sql) | _O(n^2)_ | _O(n)_       | Easy           ||
+
+---
 
+##Shell Script
+  #  | Problem         |  Solution       |  Time           | Space           | Difficulty    | Tag          | Note
+-----|---------------- | --------------- | --------------- | --------------- | ------------- |--------------| -----
+192 | [Word Frequency](https://leetcode.com/problems/word-frequency/) | [Shell](./Shell/word-frequency.sh) | _O(n)_     | _O(k)_          | Medium         ||
+193 | [Valid Phone Numbers](https://leetcode.com/problems/valid-phone-numbers/) | [Shell](./Shell/valid-phone-numbers.sh) | _O(n)_ | _O(1)_    | Easy           ||
+194 | [Transpose File](https://leetcode.com/problems/transpose-file/) | [Shell](./Shell/transpose-file.sh) | _O(n^2)_   | _O(n^2)_        | Medium         ||
+195 | [Tenth Line](https://leetcode.com/problems/tenth-line/) | [Shell](./Shell/tenth-line.sh)    | _O(n)_          | _O(1)_          | Easy           ||
diff --git a/Shell/tenth-line.sh b/Shell/tenth-line.sh
new file mode 100644
index 000000000..b8ca175d2
--- /dev/null
+++ b/Shell/tenth-line.sh
@@ -0,0 +1,26 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# How would you print just the 10th line of a file?
+#
+# For example, assume that file.txt has the following content:
+# 
+# Line 1
+# Line 2
+# Line 3
+# Line 4
+# Line 5
+# Line 6
+# Line 7
+# Line 8
+# Line 9
+# Line 10
+# Your script should output the tenth line, which is:
+# Line 10
+#
+# Hint:
+# 1. If the file contains less than 10 lines, what should you output?
+# 2. There's at least three different solutions. Try to explore all possibilities.
+#
+# Read from the file file.txt and output the tenth line to stdout.
+awk '{if(NR==10) print $0}' file.txt
diff --git a/Shell/transpose-file.sh b/Shell/transpose-file.sh
new file mode 100644
index 000000000..e912f219d
--- /dev/null
+++ b/Shell/transpose-file.sh
@@ -0,0 +1,35 @@
+# Time:  O(n^2)
+# Space: O(n^2)
+#
+# Given a text file file.txt, transpose its content.
+# 
+# You may assume that each row has the same number of 
+# columns and each field is separated by the ' ' character.
+#
+# For example, if file.txt has the following content:
+#
+# name age
+# alice 21
+# ryan 30
+# Output the following:
+# 
+# name alice ryan
+# age 21 30
+#
+
+# Read from the file file.txt and print its transposed content to stdout.
+awk '
+{
+    for (i = 1; i <= NF; i++) {
+        if(NR == 1) {
+            s[i] = $i;
+        } else {
+            s[i] = s[i] " " $i;
+        }
+    }
+}
+END {
+    for (i = 1; s[i] != ""; i++) {
+        print s[i];
+    }
+}' file.txt
diff --git a/Shell/valid-phone-numbers.sh b/Shell/valid-phone-numbers.sh
new file mode 100644
index 000000000..561fde3a0
--- /dev/null
+++ b/Shell/valid-phone-numbers.sh
@@ -0,0 +1,33 @@
+# Time:  O(n)
+# Space: O(1)
+#
+# Given a text file file.txt that contains list of 
+# phone numbers (one per line), write a one liner 
+# bash script to print all valid phone numbers.
+#
+# You may assume that a valid phone number must 
+# appear in one of the following two formats: 
+# (xxx) xxx-xxxx or xxx-xxx-xxxx. (x means a digit)
+#
+# You may also assume each line in the text file 
+# must not contain leading or trailing white spaces.
+#
+#    For example, assume that file.txt has the following content:
+#
+#    987-123-4567
+#    123 456 7890
+#    (123) 456-7890
+#    Your script should output the following valid phone numbers:
+#    987-123-4567
+#    (123) 456-7890
+#
+#
+# Read from the file file.txt and output all valid phone numbers to stdout.
+# Using grep:
+grep -P '^(\d{3}-|\(\d{3}\) )\d{3}-\d{4}$' file.txt
+
+# Using sed:
+sed -n -E '/^([0-9]{3}-|\([0-9]{3}\) )[0-9]{3}-[0-9]{4}$/p' file.txt
+
+# Using awk:
+awk '/^([0-9]{3}-|\([0-9]{3}\) )[0-9]{3}-[0-9]{4}$/' file.txt
diff --git a/Shell/word-frequency.sh b/Shell/word-frequency.sh
new file mode 100644
index 000000000..1775f0504
--- /dev/null
+++ b/Shell/word-frequency.sh
@@ -0,0 +1,29 @@
+# Time:  O(n)
+# Space: O(k), k is number of words
+#
+# Write a bash script to calculate the frequency of each word in a text file words.txt.
+# 
+# For simplicity sake, you may assume:
+# 
+# words.txt contains only lowercase characters and
+# space ' ' characters.
+# Each word must consist of lowercase characters only.
+# Words are separated by one or more whitespace characters.
+# For example, assume that words.txt has the following content:
+# 
+# the day is sunny the the
+# the sunny is is
+# Your script should output the following, 
+# sorted by descending frequency:
+# the 4
+# is 3
+# sunny 2
+# day 1
+# Note:
+# Don't worry about handling ties, 
+# it is guaranteed that each word's frequency count is unique.
+#
+
+# Read from the file words.txt and output the word frequency list to stdout.
+awk '{for(i=1;i<=NF;i++) a[$i]++} END {for(k in a) print k,a[k]}' words.txt | sort -k2 -nr
+