python leetcode 251-260

class Vector2D:
    def __init__(self, v: List[List[int]]):
        self.vector = v
        self.inner = 0
        self.outer = 0
    def advance_to_next(self):
        while self.outer < len(self.vector) and self.inner == len(self.vector[self.outer]):
            self.outer += 1
            self.inner = 0  
    def next(self) -> int:
        self.advance_to_next()
        result = self.vector[self.outer][self.inner]
        self.inner += 1
        return result
    def hasNext(self) -> bool:
        self.advance_to_next()
        return self.outer < len(self.vector)

# 252
class Solution:
    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
        n = len(intervals)
        if n < 2:
            return True
        A = sorted(intervals)
        for i in range(1 , n):
            if A[i][0] < A[i - 1][1]:
                return False
        return True

# 253
class Solution:
    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
        tmp = []
        for i in intervals:
            tmp.append([i[0] , 1])
            tmp.append([i[1] , -1])
        res = 0
        tmp1 = 0
        A = sorted(tmp)
        for i in A:
            tmp1 += i[1]
            res = max(tmp1 , res)
        return res

# 254
class Solution:
    def getFactors(self, n: int) -> List[List[int]]:
        if n < 0:
            return []
        res = []
        def dfs(n , i , tmp):
            for j in range(i , int(n**0.5) + 1):
                if n % j == 0:
                    res.append(tmp + [n//j , j])
                    dfs(n//j , j , tmp + [j])
        dfs(n , 2 , [])
        return res

# 255
class Solution:
    def verifyPreorder(self, preorder: List[int]) -> bool:
        stack = []
        parent = float('-inf')
        for num in preorder:
            if num < parent:
                return False
            while stack and stack[-1] < num:
                parent = stack[-1]
                stack.pop()
            stack.append(num)
        
        return True

# 256
class Solution:
    def minCost(self, costs: List[List[int]]) -> int:
        if not costs:
            return 0
        dp = costs
        for i in range(1 , len(costs)):
            dp[i][0] = min((dp[i][0] + dp[i - 1][1]) , dp[i][0] + dp[i - 1][2])
            dp[i][1] = min((dp[i][1] + dp[i - 1][0]) , dp[i][1] + dp[i - 1][2])
            dp[i][2] = min((dp[i][2] + dp[i - 1][0]) , dp[i][2] + dp[i - 1][1])
        return min(dp[-1])

# 257
class Solution:
    def binaryTreePaths(self, root: TreeNode) -> List[str]:
        if not root: 
            return []
        res = []
        def helper(root , tmp):
            if not root.right and not root.left:
                res.append(tmp + [str(root.val)])
            if root.left:
                helper(root.left , tmp + [str(root.val)])
            if root.right:
                helper(root.right , tmp + [str(root.val)])
        helper(root , [])
        return ['->'.join(a) for a in res]

# 258
class Solution:
    def addDigits(self, num: int) -> int:
        while True:
            res = 0
            for i in str(num):
                res += int(i)
            if res < 10:
                return res
            num = res

# 259
class Solution:
    def threeSumSmaller(self, nums: List[int], target: int) -> int:
        nums.sort()
        res = 0
        for i in range(len(nums)):
            l , r = i + 1 , len(nums) - 1
            t = target - nums[i]
            while l < r:
                if nums[l] + nums[r] >= t:
                    r -= 1
                else:
                    res += r - l
                    l += 1
        return res

# 260
def singleNumber(self, nums: List[int]) -> List[int]:
        A = {}
        res = []
        for i in nums:
            if i not in A:
                A[i] = 1
            else:
                A[i] += 1
        for X,Y in A.items():
            if Y == 1:
                res.append(X)
        return res