Merge repository 'geemaple/leetcode'

Author: geemaple

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 渴望越狱的猫
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,4 +1,110 @@
 # Algorithms
+
 Algorithms written in python 
 
-# [Sortings](https://github.com/geemaple/algorithm/tree/master/Sorting)
+# [Sortings](https://github.com/geemaple/algorithm/tree/master/Sorting)
+
+# Leetcode
+My personal leetcode answer in python<br/>
+This is a **continually updated, open source** project.
+
+
+🎉🎉🎉 Finished 100 questions on 2018-05-28
+
+# Algorithms
+
+- [Leetcode](#leetcode)
+- [Algorithms](#algorithms)
+    - [Array](#array)
+    - [Two Pointers](#two-pointers)
+    - [Linked List](#linked-list)
+    - [Binary Search](#binary-search)
+    - [Tree Traversal](#tree-traversal)
+    - [Graph Traversal](#graph-traversal)
+    - [Divide and Conquer](#divide-and-conquer)
+    - [Backtracking](#backtracking)
+    - [Topological Sort](#topological-sort)
+    - [Dynamic Programming](#dynamic-programming)
+
+## Array
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+| 88.merge-sorted-array | [python](./algorithm/88.merge-sorted-array.py) | O(N + M) | Easy |
+| 349.intersection-of-two-arrays | [python](./algorithm/349.intersection-of-two-arrays.py) O(N + M) |Easy
+| 350.intersection-of-two-arrays-ii | [python](./algorithm/350.intersection-of-two-arrays-ii.py) O(N * logN) |Easy
+
+## Two Pointers
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+| 19.remove-nth-node-from-end-of-list | [python](./algorithm/19.remove-nth-node-from-end-of-list.py) | O(N) | Medium
+| 141.linked-list-cycle | [python](./algorithm/141.linked-list-cycle.py) | O(N) | Easy | linked-list
+| 142.linked-list-cycle-ii | [python](./algorithm/142.linked-list-cycle-ii.py) | O(N) | Medium | linked-list
+| 160.intersection-of-two-linked-lists | [python](./algorithm/160.intersection-of-two-linked-lists.py) | O(N + M) | Easy | linked-list
+
+
+## Linked List
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+| 21.merge-two-sorted-lists | [python](./algorithm/21.merge-two-sorted-lists.py) | O(N) | Easy |
+| 25.reverse-nodes-in-k-group | [python](./algorithm/25.reverse-nodes-in-k-group.py) | O(N) | Hard |
+| 61.rotate-list | [python](./algorithm/61.rotate-list.py) | O(N) | Medium |
+| 86.partition-list | [python](./algorithm/86.partition-list.py) | O(N) | Medium |
+| 92.reverse-linked-list-ii | [python](./algorithm/92.reverse-linked-list-ii.py) | O(N) | Medium |
+| 138.copy-list-with-random-pointer | [python](./algorithm/138.copy-list-with-random-pointer.py) | O(N) | Medium
+| 143.reorder-list | [python](./algorithm/143.reorder-list.py) | O(N) | Medium |
+| 148.sort-list | [python](./algorithm/148.sort-list.py) | O(N * logN) | Medium |
+| 203.remove-linked-list-elements | [python](./algorithm/203.remove-linked-list-elements.py) | O(N) | Easy
+| 206.reverse-linked-list | [python](./algorithm/206.reverse-linked-list.py) | O(N) | Easy |
+| 237.delete-node-in-a-linked-list | [python](./algorithm/237.delete-node-in-a-linked-list.py) | O(1) | Easy
+
+## Binary Search
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+| 278.first-bad-version | [python](./algorithm/278.first-bad-version.py) | O(LogN) | Easy
+
+## Divide and Conquer
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+
+
+## Tree Traversal
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+
+
+## Graph Traversal
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+| 127.word-ladder | [python](./algorithm/127.word-ladder.py) | O(N * L^2) | Medium | BFS |
+| 200.number-of-islands | [python](./algorithm/200.number-of-islands.py) | O(ROW x COL) | Medium | BFS/DFS | union-find
+
+## Backtracking
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+| 39.combination-sum | [python](./algorithm/39.combination-sum.py) | ??? | Medium | DFS |
+| 40.combination-sum-ii | [python](./algorithm/40.combination-sum-ii.py) | ??? | Medium | DFS |
+| 46.permutations | [python](./algorithm/46.permutations.py) | ??? | Medium | DFS |
+| 47.permutations-ii | [python](./algorithm/47.permutations-ii.py) | ??? | Medium | DFS |
+| 51.n-queens | [python](./algorithm/51.n-queens.py) | ??? | Hard | DFS |
+| 52.n-queens-ii | [python](./algorithm/52.n-queens-ii.py) | ??? | Hard | DFS |
+| 78.subsets | [python](./algorithm/78.subsets.py) | ??? | Medium | DFS | bit-manipulation
+| 90.subsets-ii | [python](./algorithm/90.subsets-ii.py) | ??? | Medium | DFS |  bit-manipulation
+| 126.word-ladder-ii | [python](./algorithm/126.word-ladder-ii.py) | O((V+E) * L^2) | Hard | BFS+DFS |
+| 131.palindrome-partitioning | [python](./algorithm/131.palindrome-partitioning.py) | ??? | Medium | DFS | dynamic-programming
+
+## Topological Sort
+
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|
+| 444.sequence-reconstruction | [python](./algorithm/444.sequence-reconstruction.py) | O(V+E) | Medium | BFS/DFS |
+
+## Dynamic Programming
+|  Problem          |  Solution       |  Time           | Difficulty    | Tag          | Note| 
+| ----------------- | --------------- | --------------- | ------------- |--------------|-----|

algorithm/126.word-ladder-ii.py

@@ -0,0 +1,91 @@
+class Solution(object):
+    def findLadders(self, beginWord, endWord, wordList):
+        """
+        :type beginWord: str
+        :type endWord: str
+        :type wordList: List[str]
+        :rtype: List[List[str]]
+        """
+
+        distant_map = {}
+        for word in wordList:
+            distant_map[word] = 0
+
+        if endWord not in distant_map:
+            return []
+
+        # using BFS to get each word distancd to endWord
+        self.bfs_traversal(endWord, distant_map)
+
+        results = []
+        tmp = [beginWord]
+        visted = set()
+        self.dfs_traversal(beginWord, endWord, tmp, results, visted, distant_map)
+        return results
+
+    def dfs_traversal(self, word, endWord, tmp, results, visted, distant_map):
+        if word == endWord:
+            results.append(list(tmp))
+            return
+
+        distance = distant_map.get(word, float('inf'))
+        neighbors = self.get_neighbors(word, visted, distant_map)
+    
+        print word, neighbors
+        for neighbor in neighbors:
+            if distant_map[neighbor] >= distance:
+                continue
+
+            visted.add(neighbor)
+
+            tmp.append(neighbor)
+            self.dfs_traversal(neighbor, endWord, tmp, results, visted, distant_map)
+            tmp.pop()
+
+            visted.remove(neighbor)
+
+        
+    def bfs_traversal(self, endWord, distant_map):
+
+        visted = set()
+        queue = [endWord]
+        visted.add(endWord)
+        count = 0
+
+        while(len(queue) > 0):
+            
+            size = len(queue)
+
+            for _ in range(size):
+                word = queue.pop(0)
+
+                distant_map[word] = count
+
+                neighbors = self.get_neighbors(word, visted, distant_map)
+                for neighbor in neighbors:
+                    queue.append(neighbor)
+                    visted.add(neighbor)
+            
+            count += 1
+
+
+    def get_neighbors(self, word, visted, distant_map):
+        
+        results = []
+
+        for i in range(len(word)):
+            for letter in 'abcdefghijklmnopqrstuvwxyz':
+                if letter == word[i]:
+                    continue
+
+                neighbor = word[:i] + letter + word[(i + 1):]
+
+                if neighbor not in distant_map:
+                    continue
+
+                if neighbor in visted:
+                    continue
+
+                results.append(neighbor)
+
+        return results

algorithm/127.word-ladder.py

@@ -0,0 +1,55 @@
+class Solution(object):
+    def ladderLength(self, beginWord, endWord, wordList):
+        """
+        :type beginWord: str
+        :type endWord: str
+        :type wordList: List[str]
+        :rtype: int
+        """
+        count = 0
+        word_set = set(wordList)
+
+        if endWord not in word_set:
+            return 0
+
+        queue = [beginWord]
+
+        while(len(queue) > 0):
+            
+            size = len(queue)
+            count += 1
+
+            for _i in range(size):
+                node  = queue.pop(0)
+            
+                if node == endWord:
+                    return count
+
+                neighbors = self.get_neighbors(node, word_set)
+                for neighbor in neighbors:
+                    queue.append(neighbor)
+
+        return 0
+
+    # using 26 letters is better than check every nodes in wordList
+    # l = length of word
+    # 26 letters = O(l * 25 * l)
+    # each word has l * 25 variation, and to check or change each attempt using l
+    #
+    # check every nodes in wordlist = O(l * N * N)
+    # to check neighbors of every word in the list needs l * N, and there are N such words
+    def get_neighbors(self, word, word_set):
+        results = []
+        for i in range(len(word)):
+            for letter in 'abcdefghijklmnopqrstuvwxyz':
+                if letter == word[i]:
+                    continue
+
+                neighbor = word[:i] + letter + word[(i + 1):]
+                if neighbor not in word_set:
+                    continue
+                    
+                results.append(neighbor)
+                word_set.remove(neighbor) #this is important
+
+        return results

algorithm/131.palindrome-partitioning.py

@@ -0,0 +1,64 @@
+class Solution(object):
+    def partition(self, s):
+        """
+        :type s: str
+        :rtype: List[List[str]]
+        """
+
+        if s is None:
+            return []    
+
+        results = []
+        partitions = []
+        self.helper(s, partitions, results, 0)
+        return results
+
+    def helper(self, s, partitions, results, start):
+        
+        if start == len(s):
+            results.append(list(partitions))
+
+        for i in range(start, len(s)):
+            sub = s[start: i + 1]
+            if not self.is_palindrome(sub):
+                continue
+
+            partitions.append(sub)
+            self.helper(s, partitions, results, i + 1)
+            partitions.pop()
+
+
+    def is_palindrome(self, part):
+        length = len(part)
+        if length <= 1:
+            return True
+        
+        for i in range(length):
+            if part[i] != part[length - 1 - i]:
+                return False
+
+        return True
+
+    # since is_palindrome func is called most,
+    # we can optimize this with a prebuit matrix
+    def build_matrix(self, s):
+
+        def expand(matrix, begin, end):
+            # A palindrome added the SAME char to both sides is aslo a valid palindrome
+            while (begin - 1 >= 0 and end + 1 <= size):
+                matrix[begin - 1][end + 1] = matrix[begin][end] & int(s[begin - 1] == s[end])
+                begin = begin - 1
+                end = end + 1
+ 
+        size = len(s)
+        # (n + 1) * n
+        matrix = [[0 for _ in range(size + 1)] for _ in range(size)]
+
+        for i in range(size):
+            # s[i:i] = '' 
+            matrix[i][i] = 1
+            expand(matrix, i, i)
+            if i + 1 <= size:
+                # s[i: i + 1] = 'a single char' 
+                matrix[i][i + 1] = 1
+                expand(matrix, i, i + 1)