import collections
class Solution:
  def numIslands(self, grid) -> int:
    rows = len(grid)
    if not rows:
      return 0
    cols = len(grid[0])
    islands = 0
    for r in range(rows):
      for l in range(cols):
        if grid[r][l] == '1':
          islands += 1
          grid[r][l] = '0'
          neighbors = collections.deque([(r, l)])
          while neighbors:
            x, y = neighbors.popleft()
            for x_, y_ in [[x-1, y], [x+1, y], [x, y-1], [x, y+1]]:
              if 0<=x_<rows and 0<=y_<cols and grid[x_][y_] == '1':
                neighbors.append([x_, y_])
                grid[x_][y_] = '0'
    return islands

class Solution:
  def myAtoi(self, str: str) -> int:
    p = ''
    str = str.lstrip()
    n = ''
    min_int = -2**31
    max_int = 2**31-1
    isnumeric = False
    for x in str:
      if not isnumeric and x == '-':
        p = '-'
        isnumeric = True
        continue
      if not isnumeric and x == '+':
        isnumeric = True
        continue
      if x.isnumeric():
        n += x
        isnumeric = True
      else:
        break
    if not n:
      return 0
    if int(n) > max_int:
      if p:
        return min_int
      else:
        return max_int
    p += n
    return int(p)
# 32 ms13.6 MB

class Solution:
  def merge(self, intervals):
    if not intervals:
      return []
    intervals.sort()
    merged = []
    l = len(intervals)
    m = intervals[0]
    for x in range(l-1):
      j = intervals[x+1]
      if m[1] >= j[0]:
        if m[1] <= j[1]:
          m = [m[0], j[1]]
        else:
          continue
      else:
        merged.append(m)
        m = j
    if m:
      merged.append(m)
    return merged

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class Solution:
  def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
    def _reverse(l):
      if l.next:
        last = _reverse(l.next)
        l.next.next = l
        l.next = None
        return last
      return l

    l1e = _reverse(l1)
    l2e = _reverse(l2)
    new_l = ListNode(0)
    head = new_l
    c = 0
    import ipdb; ipdb.set_trace()
    while l1e and l2e:
      new_val = l1e.val + l2e.val
      if c==1:
        new_val += 1
      c = 0
      if new_val >= 10:
        new_val -= 10
        c = 1

      new_l.val = new_val
      next_n = None
      if l1e.next and l2e.next or c:
        next_n = ListNode(c)
        new_l.next = next_n
        new_l = next_n
      l1e = l1e.next
      l2e = l2e.next
    if l2e:
      l1e = l2e
    if not l1e and c:
      l1e = ListNode(0)
    while l1e:
      new_l.val = l1e.val
      new_l.val += c
      c = 0
      if new_l.val >= 10:
        c = 1
        new_l.val -= 10
      l1e = l1e.next
      if l1e:
        new_l.next = ListNode(0)
        new_l = new_l.next
      else:
        new_l.next = ListNode(1)

    return _reverse(head)

 # 84 ms13.9 MB

class Solution:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        s1, s2 = [], []
        while l1:
            s1.append(l1.val)
            l1 = l1.next
        while l2:
            s2.append(l2.val)
            l2 = l2.next
        ans = None
        carry = 0
        while s1 or s2 or carry != 0:
            a = 0 if not s1 else s1.pop()
            b = 0 if not s2 else s2.pop()
            cur = a + b + carry
            carry = cur // 10
            cur %= 10
            curnode = ListNode(cur)
            curnode.next = ans
            ans = curnode
        return ans

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/add-two-numbers-ii/solution/liang-shu-xiang-jia-ii-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Twitter:

  def __init__(self):
    """
    Initialize your data structure here.
    """
    self.tweets = {}
    self.followers = {}
    self._tid = 0


  def postTweet(self, userId: int, tweetId: int) -> None:
    """
    Compose a new tweet.
    """
    if not self.tweets.get(userId):
      self.tweets[userId] = []
    self.tweets[userId].append((self._tid, tweetId))
    self._tid += 1


  def getNewsFeed(self, userId: int) :
    """
    Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent.
    """
    foers = self.followers.get(userId, set())
    foers = foers.union((userId,))
    tweets = []
    for fo in foers:
      tweets.extend(self.tweets.get(fo, [])[-10:])
    return [tw[1] for tw in sorted(tweets, reverse=True)[:10]]


  def follow(self, followerId: int, followeeId: int) -> None:
    """
    Follower follows a followee. If the operation is invalid, it should be a no-op.
    """
    if not self.followers.get(followerId):
      self.followers[followerId] = set()
    self.followers[followerId].add(followeeId)


  def unfollow(self, followerId: int, followeeId: int) -> None:
    """
    Follower unfollows a followee. If the operation is invalid, it should be a no-op.
    """
    if not self.followers.get(followerId):
      self.followers[followerId] = set()
    if followeeId in self.followers[followerId]:
      self.followers[followerId].remove(followeeId)

#100 ms19.2 MB

# Your Twitter object will be instantiated and called as such:
# obj = Twitter()
# obj.postTweet(userId,tweetId)
# param_2 = obj.getNewsFeed(userId)
# obj.follow(followerId,followeeId)
# obj.unfollow(followerId,followeeId)

import math
class Solution:
  def findContinuousSequence(self, target: int):
    n = int(math.sqrt(2 * target) + 1)
    if n < 2:
      return []
    sum_list = []
    a = 0
    for i in range(2, n+1):
      a = ((2 * target) / i + 1 - i) / 2
      if a and not a % 1:
        a = int(a)
        s_ = []
        for j in range(0, i):
          s_.append(a + j)
        sum_list.append(s_)
    return sorted(sum_list)
 # 60 ms13.7 MB

class Solution:
  def massage(self, nums) -> int:
    if not nums:
      return 0
    n = len(nums)
    not_choose = 0
    choose = 0
    for n in nums:
      not_choose, choose = max(not_choose, choose), not_choose+n
    return max(not_choose, choose)
 # 52 ms13.6 MB

class Solution:
  def compressString(self, S: str) -> str:
    if not S:
      return S
    c = ''
    prev = S[0]
    p_len = 1
    for w in S[1:]:
      if w != prev:
        c += '%s%s' % (prev, p_len)
        prev = w
        p_len = 1
      else:
        p_len += 1
    c += '%s%s' % (prev, p_len)
    if len(S) > len(c):
      return c
    return S
# 52 ms13.8 MB

class Solution:
  def distributeCandies(self, candies: int, num_people: int):
    total = 0
    i = 0
    # import ipdb; ipdb.set_trace()
    while total <= candies:
      t = (num_people*i)*num_people + int((1+num_people)*num_people/2)
      if total + t <= candies:
        total += t
        i += 1
      else:
        break
    remaining = candies - total
    print(total, remaining, i)
    l = []
    for n in range(1, num_people+1):
      if not total:
        current_candy = n
      else:
        current_candy = n+i*num_people

      n_count = int((0+(i-1))*(i)/2)
      print(current_candy, n_count)
      if remaining >= current_candy:
        l.append(n_count*num_people + n*i + current_candy)
        remaining -= current_candy
      else:
        l.append(n_count*num_people + n*i + remaining)
        remaining = 0
    return l
# 28 ms13.7 MB,

class Solution:
  def countCharacters(self, words, chars: str) -> int:

    words_ = ''
    for w in words:
      lchars = list(chars)
      try:
        for l in w:
          lchars.remove(l)
      except:
        continue
      words_ += w

    return len(words_)
# 152 ms14.1 MB

class Solution:
  def gcdOfStrings(self, str1: str, str2: str) -> str:
    if str1[0] != str2[0]:
      return ''

    a = len(str1)
    b = len(str2)
    print(a, b)
    if a < b:
      str1, str2 = str2, str1
      a = len(str1)
      b = len(str2)

    if not a%b:
      for x in range(0, a//b):
        if str1[x*b:(x+1)*b] != str2:
          return ''
      return str2
    else:
      for x in range(b, 0, -1):
        print(x)
        if x==b or b%x or a%x:
          continue
        for y in range(0, b//x):
          if str2[y*x:(y+1)*x] != str2[b-x:b]:
            return ''
        for y in range(0, a//x):
          if str1[y*x:(y+1)*x] != str2[0:x]:
            return ''
        return str2[0:x]
# 44 ms13.9 MB

class Solution:
  def numRookCaptures(self, board) -> int:
    i = j = 0
    for row in board:
      if 'R' in row:
        break
      i += 1
    j = row.index('R')
    count = 0
    # right
    for x in range(j + 1, 8):
      if row[x] == 'p':
        count += 1
        break
      if row[x] == 'B':
        break
    # left
    for x in range(j, 0, -1):
      if row[x] == 'p':
        count += 1
        break
      if row[x] == 'B':
        break
    # up
    for x in range(i, 0, -1):
      if board[x][j] == 'p':
        count += 1
        break
      if board[x][j] == 'B':
        break
    # down
    for x in range(i+1, 8):
      if board[x][j] == 'p':
        count += 1
        break
      if board[x][j] == 'B':
        break

    return count

#36 ms13.6 MB

class Solution:
  def hasGroupsSizeX(self, deck) -> bool:
    dc = {}
    max_d = 0
    for d in deck:
      if d not in dc:
        dc[d] = 0
      dc[d] += 1
      if max_d < d:
        max_d = d
      if max_d < dc[d]:
        max_d = dc[d]
    has_x = True
    if max_d == 1:
      max_d = 2

    for i in range(2, max_d + 1):
      has_x = True
      for k,v in dc.items():
        if v % i:
          has_x = False
          break
      if has_x and i >= 2:
        return True
    return False

#56 ms13.8 MB

class Solution:
  def canThreePartsEqualSum(self, A) -> bool:
    if not A:
      return False
    sa = sum(A)
    if sa % 3:
      return False
    s = sa // 3
    s1 = 0
    s2 = 0


    for i in range(len(A)):
      s1 += A[i]
      if s1 == s and (i+1) < len(A):
        for j in range(len(A[i+1:])):
          s2 += A[i+1+j]
          if s2 == s and j+1 < len(A[i+1:]) and sum(A[i+j+2:])== s:
            return True
    return False
#60 ms18.7 MB

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

class Solution:
  def middleNode(self, head: ListNode) -> ListNode:
    l = []
    n = head
    while n.next:
      l.append(n)
      n = n.next
    l.append(n)
    return l[len(l)//2]

 #44 ms13.7 MB

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/middle-of-the-linked-list/solution/lian-biao-de-zhong-jian-jie-dian-by-leetcode-solut/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution:
  def isRectangleOverlap(self, rec1, rec2) -> bool:
     return ((min(rec1[2], rec2[2]) > max(rec1[0], rec2[0]))
             and (min(rec1[3], rec2[3]) > max(rec1[1], rec2[1])))

s = Solution()
s.isRectangleOverlap(rec1 = [0,0,2,2], rec2 = [1,1,3,3])

#40 ms13.7 MB

class Solution:
  def longestPalindrome(self, s: str) -> int:
    d = {}
    for l in s:
      if not l in d:
        d[l] = 0
      d[l] += 1

    i = 0
    odd = False
    for k, v in d.items():
      if v % 2:
        i += (v-1)
        odd = True
      else:
        i += v
    if odd:
      i += 1
    return i

#40 ms13.6 MB

# Definition for a binary tree node.
class TreeNode:
  def __init__(self, x):
    self.val = x
    self.left = None
    self.right = None

class Solution:
  def diameterOfBinaryTree(self, root: TreeNode) -> int:
    if not root:
      return 0
    last_node = -1
    routes = []
    start = root
    node_stack = [root]
    while (start.left or start.right or node_stack):
      if start != node_stack[-1]:
        node_stack.append(start)

      if last_node == start.right:
        node_stack = node_stack[:-1]
        if not node_stack:
          break
        last_node = start
        start = node_stack[-1]
        continue

      if start.left and last_node != start.left:
        start = start.left
        last_node = start
        continue

      if start.right:
        start = start.right
        last_node = start
        continue

      routes.append(node_stack)
      node_stack = node_stack[:-1]
      if not node_stack:
        break
      last_node = start
      start = node_stack[-1]

    max_l = 0
    for route in routes:
      for route_ in routes:
        intersection = 0
        if route != route_:
          intersection = len(set(route).intersection(set(route_)))
          if intersection:
            intersection -= 1
        max_l = max(max_l, len(set(route)| set(route_)) - intersection)
    return max_l - 1

class Solution(object):
    def diameterOfBinaryTree(self, root):
        self.ans = 1
        def depth(node):
            # 访问到空节点了，返回0
            if not node: return 0
            # 左儿子为根的子树的深度
            L = depth(node.left)
            # 右儿子为根的子树的深度
            R = depth(node.right)
            # 计算d_node即L+R+1 并更新ans
            self.ans = max(self.ans, L+R+1)
            # 返回该节点为根的子树的深度
            return max(L, R) + 1

        depth(root)
        return self.ans - 1

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/diameter-of-binary-tree/solution/er-cha-shu-de-zhi-jing-by-leetcode-solution/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class MyStack:

  def __init__(self):
    """
    Initialize your data structure here.
    """
    self.data = []


  def push(self, x: int) -> None:
    """
    Push element x onto stack.
    """
    self.data.append(x)
    return


  def pop(self) -> int:
    """
    Removes the element on top of the stack and returns that element.
    """
    return self.data.pop(-1)


  def top(self) -> int:
    """
    Get the top element.
    """
    return self.data[-1]


  def empty(self) -> bool:
    """
    Returns whether the stack is empty.
    """
    return not bool(self.data)



# Your MyStack object will be instantiated and called as such:
# obj = MyStack()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.top()
# param_4 = obj.empty()

#24 ms13.5 MB