"""
# Definition for a Node.
class Node:
    def __init__(self, val, prev, next, child):
        self.val = val
        self.prev = prev
        self.next = next
        self.child = child
"""
class Solution:
    def flatten(self, head):
        """
        :type head: Node
        :rtype: Node
        """
        stack,cur = [],head
        while cur:
            if cur.child:
                if cur.next:
                    stack.append(cur.next)
                cur.next,cur.child.prev,cur.child = cur.child,cur,None
            if not cur.next and len(stack) >0:
                tmp = stack.pop()
                tmp.prev,cur.next = cur,tmp
            cur = cur.next
        return head

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def reorderList(self, head):
        """
        :type head: ListNode
        :rtype: void Do not return anything, modify head in-place instead.
        """
        if not head:return None
        slow = node = head
        fast = slow.next
        stack=[]
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        new_slow = slow.next
        slow.next = None
        while new_slow:
            stack.append(new_slow)
            new_slow = new_slow.next
        while node:
            next_node = node.next
            if stack:
                node.next=stack.pop()
                node.next.next = next_node
            node = next_node

class Solution(object):
    def wordBreak(self, s, wordDict):
        """
        :type s: str
        :type wordDict: List[str]
        :rtype: bool
        """
        d = {}
        dp = [False]*len(s)
        for word in wordDict:
            if word not in d:
                d[word] = 1
        dp[0] = True if s[0] in d else False
        for i in range(1,len(s)):
            if s[:i+1] in d:
                dp[i] = True
                continue
            for j in range(i):
                if dp[j] and s[j+1:i+1] in d:
                    dp[i] = True
                    break
        return dp[-1]

# Definition for singly-linked list with a random pointer.
# class RandomListNode(object):
#     def __init__(self, x):
#         self.label = x
#         self.next = None
#         self.random = None

class Solution(object):
    def copyRandomList(self, head):
        """
        :type head: RandomListNode
        :rtype: RandomListNode
        """
        if not head:
            return None
        
        p = head
        newhead = q = RandomListNode(head.label)
        
        while p:
            q.next = None if not p.next else RandomListNode(p.next.label)
            q.random = None if not p.random else RandomListNode(p.random.label)
            p = p.next
            q = q.next
        return newhead

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        ones = twos = threes= 0
        for num in nums:
            ones = (ones ^ num) & ~twos 
            twos = (twos ^ num) & ~ones 
        return ones
print(Solution().singleNumber([1,1,1,2,2,2,3]))

class Solution(object):
    def canCompleteCircuit(self, gas, cost):        
        n = len(gas)
        dp = [gas[0] - cost[0]]
        for i in range(1,n):
            dp.append(dp[-1] + gas[i] - cost[i])
        if dp[-1] < 0:
            return -1
        return (dp.index(min(dp)) + 1 )%n

class Solution(object):
    def canCompleteCircuit(self, gas, cost):
        """
        :type gas: List[int]
        :type cost: List[int]
        :rtype: int
        """
        start, cur_sum, total_sum = 0, 0, 0
        
        for i in range(len(gas)):
          diff = gas[i]-cost[i]
          cur_sum += diff
          total_sum += diff
          
          if cur_sum < 0:
            start = i+1
            cur_sum = 0
        
        if total_sum >= 0:
          return start
        return -1

from collections import deque
class Solution:
    # @param node, a undirected graph node
    # @return a undirected graph node
    def cloneGraph(self, node):
        if node == None:
            return 
        root = UndirectedGraphNode(node.label)
        q = deque([(node, root)]) # node to complete neighbors       
        visited = set()
        while q:
            n, tobe = q.popleft()                        
            visited.add(n)
            for neighbor in n.neighbors:
                neighbor_tobe = UndirectedGraphNode(neighbor.label)
                tobe.neighbors.append(neighbor_tobe)
                if neighbor not in visited:
                    q.append((neighbor, neighbor_tobe))
        return root