from collections import deque
class Solution(object):
    def removeInvalidParentheses(self, s):
        self.solution_found = False
        self.visited_potential_solutions = set()
        self.results = set()
        self.bfs(s,0)
        return list(self.results)

    def bfs(self, s, characters_removed):
        if s is "" or s is None:
            return
        queue = deque()
        queue.append(s)
        while queue:
            current = queue.popleft()
            if self.is_valid(current):
                self.solution_found = True
                self.results.add(current)
                continue
            if self.solution_found:
                continue
            for i,c in enumerate(current):
                if not self.is_parenthesis(c):
                    continue
                potential_solution = current[:i]+current[i+1:]
                if potential_solution not in self.visited_potential_solutions:
                    self.visited_potential_solutions.add(potential_solution)
                    queue.append(potential_solution)
    
    def is_valid(self, s):
        summatory = 0
        for c in s:
            if c == '(':
                summatory += 1
            if c == ')':
                summatory -= 1
                if summatory < 0:
                    return False
        return summatory == 0

    def is_parenthesis(self, c):
        return c in ['(', ')']

class Solution(object):
    def removeInvalidParentheses(self, s):
        self.ans = []
        self.dfs(s, 0, 0, ['(',')'])
        if len(self.ans) == 0:
            return [""]
        return self.ans
    
    def dfs(self, s, last_i, last_j, par):
        count = 0
        for i in range(last_i, len(s)):
            if s[i] == par[0]: count +=1
            if s[i] == par[1]: count -=1
            if count >=0:
                continue
            for j in range ( last_j, i+1):
                if s[j] == par[1] and (j == last_j or s[j-1] != par[1]):
                    self.dfs(s[:j] + s[j+1:], i, j, par )
            return
        
        s_reversed = s[::-1]
        if par[0] == '(':
            self.dfs(s_reversed, 0, 0, [')','('])
        else:
            self.ans.append(s_reversed)

class Solution(object):
    def isAdditiveNumber(self, num):
        """
        :type num: str
        :rtype: bool
        """
        def dfs(numstr,res):
            if len(res) >= 3 and res[-2] + res[-3] != res[-1]:return False
            if not numstr and len(res) >= 3:return True
            for i in range(len(numstr)):
                curr = numstr[:i+1]
                if curr[0] == '0' and len(curr) != 1:continue
                if dfs(numstr[i+1:],res+[int(curr)]):return True
            return False
        return dfs(num,[])

class Solution(object):
    def maxProfit(self, k, prices):
        """
        :type k: int
        :type prices: List[int]
        :rtype: int
        """
        n = len(prices)
        if n < 2:return 0
        if n <= 2*k:
            return sum(i-j for i,j in zip(prices[1:],prices[:-1]) if i-j > 0)
        dp = [[0]*n for _ in range(k+1)]
        for i in range(1,k+1):
            tmp = [0]*n
            for j in range(1,n):
                profit = prices[j] - prices[j-1]
                tmp[j] = max(tmp[j-1]+profit,dp[i-1][j-1]+profit,dp[i-1][j-1])
                dp[i][j] = max(tmp[j],dp[i][j-1])
        return dp[k][-1]

class NumArray(object):
    def __init__(self, nums):
        """
        initialize your data structure here.
        :type nums: List[int]
        """
        n = len(nums)
        if n == 0: return
        max_size = 2 * pow(2, int(math.ceil(math.log(n, 2)))) - 1
        self.seg_tree = [0 for i in xrange(max_size)]
        self.nums = nums[:]
        self.build_tree(0, n-1, 0)
        
    def build_tree(self, start, end, curr):#构造segment tree
        if start > end: return # empty list
        if start == end:
            self.seg_tree[curr] = self.nums[start]
        else:
            mid = start + (end - start)/2
            self.seg_tree[curr] = self.build_tree(start, mid, curr*2+1) + self.build_tree(mid+1, end, curr*2+2)
        return self.seg_tree[curr]        
        
    def update(self, i, val):
        """
        :type i: int
        :type val: int
        :rtype: int
        """
        diff = val - self.nums[i]
        self.nums[i] = val
        self.update_sum(0, len(self.nums)-1, i, 0, diff)
    
    def update_sum(self, start, end, idx, curr, diff):#更新segment tree某个元素的值
        self.seg_tree[curr] += diff
        if start == end: return
        mid = start + (end - start)/2
        if start <= idx <= mid:
            self.update_sum(start, mid, idx, curr*2+1, diff)
        else:
            self.update_sum(mid+1, end, idx, curr*2+2, diff)
        
    def sumRange(self, i, j):
        """
        sum of elements nums[i..j], inclusive.
        :type i: int
        :type j: int
        :rtype: int
        """
        return self.get_sum(0, len(self.nums)-1, i, j, 0)
        
    def get_sum(self, start, end, qstart, qend, curr):#segment tree特定区间求和
        mid = start + (end - start)/2
        if qstart > end or qend < start:
            return 0
        elif start >= qstart and end <= qend:
            return self.seg_tree[curr]
        else:
            return self.get_sum(start, mid, qstart, qend, curr*2+1) + self.get_sum(mid+1, end, qstart, qend, curr*2+2)

class NumMatrix(object):

    def __init__(self, matrix):
        """
        :type matrix: List[List[int]]
        """
        if not matrix or not matrix[0]:
            self.matrix = None
            return
        self.rows = len(matrix)
        self.cols = len(matrix[0])
        self.matrix = matrix
        self.SM = [[0]*self.cols for _ in range(self.rows)]
        self.update()
        
    def update(self):
        if self.rows > 0 and self.cols > 0:self.SM[0][0] = self.matrix[0][0]
        for i in range(1,self.rows):
            self.SM[i][0] = self.SM[i-1][0] + self.matrix[i][0] 
        for j in range(1,self.cols):
            self.SM[0][j] = self.SM[0][j-1] + self.matrix[0][j]
        for i in range(1,self.rows):
            for j in range(1,self.cols):
                self.SM[i][j] = self.SM[i-1][j] + self.SM[i][j-1] - self.SM[i-1][j-1] + self.matrix[i][j]
            
    def sumRegion(self, row1, col1, row2, col2):
        if self.matrix == None or (self.rows == self.cols and self.rows == 0) or row1<0 or row1>=self.rows or row2<0 or row2>=self.rows or col1<0 or col1>=self.cols or col2<0 or col2>=self.cols:return 0
        up = self.SM[row1-1][col2] if row1 >= 1 else 0
        diag = self.SM[row1-1][col1-1] if row1 >= 1 and col1 >= 1 else 0
        left = self.SM[row2][col1-1] if col1 >= 1 else 0
        return self.SM[row2][col2]- up - left + diag


# Your NumMatrix object will be instantiated and called as such:
# obj = NumMatrix(matrix)
# param_1 = obj.sumRegion(row1,col1,row2,col2)

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        n = len(prices)
        if n == 0:return 0
        buy = [0]*n
        sell = [0]*n
        cool = [0]*n
        buy[0] = -prices[0]
        for i in range(1,n):
            buy[i] = max(buy[i-1],cool[i-1]-prices[i])
            sell[i] = max(sell[i-1],buy[i-1]+prices[i])
            cool[i] = max(cool[i-1],sell[i-1])
        return sell[-1]

class Solution:
    def findMinHeightTrees(self, n, edges):
        if n == 1: return [0] 
        adj = [set() for _ in xrange(n)]
        for i, j in edges:
            adj[i].add(j)
            adj[j].add(i)

        leaves = [i for i in xrange(n) if len(adj[i]) == 1]

        while n > 2:
            n -= len(leaves)
            newLeaves = []
            for i in leaves:
                j = adj[i].pop()
                adj[j].remove(i)
                if len(adj[j]) == 1: newLeaves.append(j)
            leaves = newLeaves
        return leaves

class Solution:
    def maxCoins(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #dp[i][j] = max(dp[i][j], nums[i] * nums[k] * nums[j] + dp[i][k] + dp[k][j]) # i < k < j
        nums = [1] + nums + [1]
        n = len(nums)
        dp = [[0]*n for _ in range(n)]
        for gap in range(2,n):
            for i in range(n-gap):
                j = gap+i
                for k in range(i+1,j):
                    dp[i][j] = max(dp[i][j], nums[i] * nums[k] * nums[j] + dp[i][k] + dp[k][j])
        return dp[0][n-1]

class Solution:
    def maxCoins(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #dp[i][j] = max(dp[i][j], nums[i] * nums[k] * nums[j] + dp[i][k] + dp[k][j]) # i < k < j
        nums = [1] + nums + [1]
        n = len(nums)
        dp = [[0]*n for _ in range(n)]
        def cal(i,j):
            if dp[i][j] or j == i+1:
                return dp[i][j]
            coins = 0
            for k in range(i+1,j):
                coins = max(coins,nums[i]*nums[k]*nums[j] + cal(i,k)+cal(k,j))
            dp[i][j] = coins
            return coins
        return cal(0,n-1)

class Solution(object):
    def nthSuperUglyNumber(self, n, primes):
        """
        :type n: int
        :type primes: List[int]
        :rtype: int
        """
        res = [1]
        idx = [0]*len(primes)
        for i in range(n-1):
            minv = min([res[idx[k]]*primes[k] for k in range(len(primes))])
            for j in range(len(primes)):
                if minv == res[idx[j]]*primes[j]:
                    idx[j] += 1
            res.append(minv)
        return res[-1]

from heapq import heappush, heappop

class Solution:
    def nthSuperUglyNumber(self, n, primes):
        """
        :type n: int
        :type primes: List[int]
        :rtype: int
        """
        res, idx, ugly_by_last_prime = [1] * n, [0] * len(primes), [0] * n

        heap = [(p, k) for k, p in enumerate(primes)]
        print(heap)
        for i in range(1, n):
            res[i], k = heappop(heap)
            print(res[i],k)
            ugly_by_last_prime[i] = k
            idx[k] += 1
            while ugly_by_last_prime[idx[k]] > k:
                idx[k] += 1
            heappush(heap, (primes[k] * res[idx[k]], k))

        return res[-1]