Word Ladder II/ Single Number II

Author: gavinfish

126 Word Ladder II.py

@@ -0,0 +1,80 @@
+'''
+Given two words (beginWord and endWord), and a dictionary's word list, find all shortest transformation sequence(s) from beginWord to endWord, such that:
+
+Only one letter can be changed at a time
+Each intermediate word must exist in the word list
+For example,
+
+Given:
+beginWord = "hit"
+endWord = "cog"
+wordList = ["hot","dot","dog","lot","log"]
+Return
+  [
+    ["hit","hot","dot","dog","cog"],
+    ["hit","hot","lot","log","cog"]
+  ]
+Note:
+All words have the same length.
+All words contain only lowercase alphabetic characters.
+'''
+
+class Solution(object):
+    def findLadders(self, beginWord, endWord, wordlist):
+        """
+        :type beginWord: str
+        :type endWord: str
+        :type wordlist: Set[str]
+        :rtype: List[List[int]]
+        """
+
+        def bfs(front_level, end_level, is_forward, word_set, path_dic):
+            if len(front_level) == 0:
+                return False
+            if len(front_level) > len(end_level):
+                return bfs(end_level, front_level, not is_forward, word_set, path_dic)
+            for word in (front_level | end_level):
+                word_set.discard(word)
+            next_level = set()
+            done = False
+            while front_level:
+                word = front_level.pop()
+                for c in 'abcdefghijklmnopqrstuvwxyz':
+                    for i in range(len(word)):
+                        new_word = word[:i] + c + word[i + 1:]
+                        if new_word in end_level:
+                            done = True
+                            add_path(word, new_word, is_forward, path_dic)
+                        else:
+                            if new_word in word_set:
+                                next_level.add(new_word)
+                                add_path(word, new_word, is_forward, path_dic)
+            return done or bfs(next_level, end_level, is_forward, word_set, path_dic)
+
+        def add_path(word, new_word, is_forward, path_dic):
+            if is_forward:
+                path_dic[word] = path_dic.get(word, []) + [new_word]
+            else:
+                path_dic[new_word] = path_dic.get(new_word, []) + [word]
+
+        def construct_path(word, end_word, path_dic, path, paths):
+            if word == end_word:
+                paths.append(path)
+                return
+            if word in path_dic:
+                for item in path_dic[word]:
+                    construct_path(item, end_word, path_dic, path + [item], paths)
+
+        front_level, end_level = {beginWord}, {endWord}
+        path_dic = {}
+        bfs(front_level, end_level, True, wordlist, path_dic)
+        path, paths = [beginWord], []
+        construct_path(beginWord, endWord, path_dic, path, paths)
+        return paths
+
+
+if __name__ == "__main__":
+    assert Solution().findLadders("hit", "cog", {"hot", "dot", "dog", "lot", "log"}) == [
+        ["hit", "hot", "dot", "dog", "cog"],
+        ["hit", "hot", "lot", "log", "cog"]
+    ]

137 Single Number II.py

@@ -0,0 +1,44 @@
+'''
+Given an array of integers, every element appears three times except for one. Find that single one.
+
+Note:
+Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?
+'''
+
+class Solution(object):
+    def singleNumber(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        one, two, three = 0, 0, 0
+        for num in nums:
+            # calculate the count of the each bit
+            three = two & num
+            two = two | one & num
+            one = one | num
+            # clear the count for the bit which has achieved three
+            one = one & ~three
+            two = two & ~three
+        return one
+
+    def singleNumber_normal(self, nums):
+        result = 0
+        for i in range(32):
+            count = 0
+            for num in nums:
+                count += (num >> i) & 1
+            rem = count % 3
+            # deal with the negative situation
+            if i == 31 and rem:
+                result -= 1 << 31
+            else:
+                result |= rem << i
+        return result
+
+
+if __name__ == "__main__":
+    assert Solution().singleNumber([1, 1, 1, 2, 3, 3, 3]) == 2
+    assert Solution().singleNumber([-2, -2, 1, 1, -3, 1, -3, -3, -4, -2]) == -4
+    assert Solution().singleNumber_normal([1, 1, 1, 2, 3, 3, 3]) == 2
+    assert Solution().singleNumber_normal([-2, -2, 1, 1, -3, 1, -3, -3, -4, -2]) == -4