class WordDictionary:
    def __init__(self):
        self.root = {}

    def addWord(self, word):
        k = len(word)
        if k in self.root.keys():
            self.root.get(k).add(word)
        else:
            self.root.setdefault(k, set([word]))

    def search(self, word):
        k = len(word)
        if k in self.root.keys():
            ls = list(self.root.get(k))

            if word in ls:
                return True
            for i, w in enumerate(word):
                if w == '.':
                    continue
                ls = [words for words in ls if words[i] == w]
                if not ls:
                    return False
            return True

        else:
            return False

import collections
class Solution:
    def findOrder(self, numCourses, prerequisites):
        self.graph = collections.defaultdict(list)
        self.res = []
        for pair in prerequisites:
            self.graph[pair[0]].append(pair[1]) 
        self.visited = [0 for x in range(numCourses)]
        for x in range(numCourses):
            if not self.dfs(x):
                return []
        return self.res
    
    def dfs(self, node):
        if self.visited[node] == -1:
            return False
        if self.visited[node] == 1:
            return True 
        self.visited[node] = -1 
        for x in self.graph[node]:
            if not self.dfs(x):
                return False
        self.visited[node] = 1 # mark as finished
        self.res.append(node) 
        return True

import sys
sys.setrecursionlimit(10000)
def solveSudo(board):
    helper(board)

def helper(board):
#step1， 获取一个空格, 如果没找到，说明已经填满。
    row,col = getUnsignedOne(board)
    if row == -1:
        return True
    #Step2： 从1-9 分别填上棋盘
    for num in range(1,10):
        if isValid(board,row,col,num):
        #step2.1 生成部分解，递归调用
            board[row][col] = num
            #step2.2
            if helper(board):
                return True
        #Step2.3 回溯
        board[row][col] = 0
    return False

def getUnsignedOne(board):
    for i in range(9):
        for j in range(9):
            if board[i][j] == 0:
                return i,j
    return -1,-1

def isValid(board,row,col,num):
    for i in range(9):
        if board[i][col] == num:
            return False
    
    for i in range(9):
        if board[row][i] == num:
            return False
    
    startRow = row - row%3
    startCol = col - col%3
    for i in range(3):
        for j in range(3):
            if board[startRow+i][startCol+j] == num:
                return False
    return True

board = [[8,0,0,5,6,4,2,0,1],[0,4,2,0,0,0,0,0,9],[0,0,0,0,0,0,0,0,0],[0,0,7,6,0,0,8,0,0],[1,0,0,0,0,8,0,9,7],[3,0,0,4,0,0,0,0,0],[5,7,0,1,0,0,0,0,0],[4,0,0,0,0,0,9,0,8],[0,0,8,0,0,2,0,0,0]]
solveSudo(board)
print(board)

class Solution:
    def minSubArrayLen(self, s, nums):
        """
        :type s: int
        :type nums: List[int]
        :rtype: int
        """
        if not nums:return 0
        if len(nums) == 1:
            if nums[0] >= s:return 1
            else:return 0
        if sum(nums) < s:return 0
        res = len(nums)
        left ,right = 0,0
        totalNum = 0
        while right<len(nums):
            totalNum += nums[right]
            while totalNum >= s:
                res = min(res,right-left+1)
                if res == 1:return 1
                totalNum -= nums[left]
                left += 1
            right += 1
        return res

class TrieNode:
    def __init__(self):
        self.child = {}
        self.end = False
        
class Trie:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.root = TrieNode()
        

    def insert(self, word):
        """
        Inserts a word into the trie.
        :type word: str
        :rtype: void
        """
        current = self.root
        for ch in word:
            node = current.child.get(ch)
            if not node:
                node = TrieNode()
                current.child[ch] = node
            current = node
        current.end = True

    def search(self, word):
        """
        Returns if the word is in the trie.
        :type word: str
        :rtype: bool
        """
        curr = self.root
        for ch in word:
            if ch not in curr.child.keys():
                return False
            curr = curr.child[ch]
        return curr.end

    def startsWith(self, prefix):
        """
        Returns if there is any word in the trie that starts with the given prefix.
        :type prefix: str
        :rtype: bool
        """
        curr = self.root
        for ch in prefix:
            if ch not in curr.child.keys():
                return False
            curr = curr.child[ch]
        return True


# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

import collections
class Solution(object):
    def canFinish(self, numCourses, prerequisites):
        """
        :type numCourses: int
        :type prerequisites: List[List[int]]
        :rtype: bool
        """
        def movev(v,set1,set2):
            set1.discard(v)
            set2.add(v)
            
        def dfs(v,white,grey,black):
            movev(v,white,grey)
            for i in d[v].keys():
                if i in black:
                    continue
                if i in grey:
                    return False
                if not dfs(i,white,grey,black):
                    return False
            movev(v,grey,black)
            return True
        
        d = collections.defaultdict(dict)
        for i,j in prerequisites:
            d[i][j] = 1
        white = set(range(numCourses))
        grey = set()
        black = set()
        for i in range(numCourses):
            if not dfs(i,white,grey,black):return False
        return True

class Solution(object):
    def isHappy(self, n):
        #解决周期循环的问题可以使用快慢指针
        def helper(n):
            result = 0
            while n != 0:
                result += pow(n%10,2)
                n = n//10
            return result
        
        r1 = helper(n)
        r2 = helper(r1)
        while r1 != 1:
            if r1 == r2:
                return False
            r1 = helper(r1)
            r2 = helper(helper(r2))
        return True

class Solution(object):
    def rangeBitwiseAnd(self, m, n):
        """
        :type m: int
        :type n: int
        :rtype: int
        """
        i = 0
        while n != m:
            m >>= 1
            n >>= 1
            i += 1
        return m << i

class Codec:
    def __init__(self):
        self.traversal = ""
        self.index = 0
    
    def _serialize(self, node):
        if node is None:
            self.traversal += 'null '
            return
        
        self.traversal += str(node.val) + ' '
        self._serialize(node.left)
        self._serialize(node.right)
        
    
    def serialize(self, root):
        """Encodes a tree to a single string.
        
        :type root: TreeNode
        :rtype: str
        """          
        self._serialize(root)
        return self.traversal
        

    def _deserialize(self, data):
        if self.index == len(data):
            return None
        
        if data[self.index] == 'null':
            self.index += 1
            return None
        
        root = TreeNode(data[self.index])
        self.index += 1
        root.left = self._deserialize(data)
        root.right = self._deserialize(data)
        return root
        
        
    def deserialize(self, data):
        """Decodes your encoded data to tree.
        
        :type data: str
        :rtype: TreeNode
        """
        data = data.split(' ')
        return self._deserialize(data)

class Solution(object):
    def gameOfLife(self, board):
        if not board or not board[0]:
            return
        def getaliveneighbours(row,col):
            return sum([1 for i,j in [(0,1),(0,-1),(1,0),(1,1),(1,-1),(-1,-1),(-1,1),(-1,0)] if (0<=row+i<len(board) and 0<=col+j<len(board[0]) ) and (board[row+i][col+j]==1 or board[row+i][col+j]==3)])
        
        for i in range(len(board)):
            for j in range(len(board[0])):
                n = getaliveneighbours(i,j)
                if board[i][j]==1 and 1<n<4:board[i][j]+=2
                elif board[i][j]==0 and n==3:board[i][j]+=2
        print(board)
        for i in range(len(board)):
            for j in range(len(board[0])):
                board[i][j] = 1 if board[i][j]>1 else 0
        print(board)