Facebook题库刷题 9/11

1. 

class Solution:
    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
        if not intervals:
            return [newInterval]
        flag = 0
        ans = []
        left = newInterval[0]
        right = newInterval[1]
        for l, r in intervals:
            if right < l:
                if flag == 0:
                    ans.append([left,right])
                flag = 1
                ans.append([l,r])
            elif r < left:
                ans.append([l,r])
            else:
                left = min(left, l)
                right = max(right, r)
        if flag == 0:
            ans.append([left,right])
        return ans

前缀和题目

思路：

用hashmap去存第一个出现的前缀和下标：【前缀和，第一次出现时的下标】

注意：初始化前缀和为0时候，此时下标为-1，这样方便遍历。

subarray长度就是 j - i, 后下标前缀和 - 前下标前缀和 = k

找不到 / 找得到这个key： 直接用 if key not in dict / if key in dict

class Solution:
    def maxSubArrayLen(self, nums: List[int], k: int) -> int:
        numsum = 0
        maxlength = 0
        dictnum = {}
        dictnum[0] = -1
        for i in range(len(nums)):
            numsum = numsum + nums[i]
            if numsum not in dictnum:
                dictnum[numsum] = i
            if numsum - k in dictnum:
                print(i,dictnum[numsum - k])
                maxlength = max(maxlength,i-dictnum[numsum - k])
        return maxlength
                
        
                    

思路，用一个count去记录高度。

注意：start 为 -1，这样sort的时候，start在前 end在后，方便同一点start end重合能很好的解决overlap

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        lis = []
        ans = []
        count = 0
        for start , end in intervals:
            lis.append([start, -1])
            lis.append([end, 1])
        
        lis.sort()
        print(lis)
        start = 0
        end = 0
        for key,value in lis:
            count += value
            if count == -1 and value == -1:
                start = key
            if count == 0 and value == 1:
                end = key
                ans.append([start,end])
        return ans
        

解法2： 类似于57题

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort()
        l = intervals[0][0]
        r = intervals[0][1]
        ans = []
        for i in range(1,len(intervals)):
            if r < intervals[i][0]:
                ans.append([l,r])
                l = intervals[i][0]
                r = intervals[i][1] 
            else:
                l = min(intervals[i][0],l)
                r = max(intervals[i][1],r)
        ans.append([l,r])
        return ans
            
            
        

注意：

python 可以用ans.append([node.val for node in queue])

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
        if not root:
            return []
        ans = []
        queue = [root]
        while queue:
            ans.append([node.val for node in queue])
            ll = []
            for node in queue:
                if node.left:
                    ll.append(node.left)
                if node.right:
                    ll.append(node.right)
            queue = ll
        return ans
            
        
        

 

class Solution:
    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
        
        length = len(intervals)
        count = 0
        ans = 0
        timelist = []
        for start,end in intervals:
            timelist.append([start,1])
            timelist.append([end,-1])
        timelist.sort()
        print(timelist)
        for time, val in timelist:
            count += val
            ans = max(abs(count),ans)
        return ans

最小堆来做：

首先进行一下排序，然后用一个小顶堆，维护当前每个会议室的结束时间，
然后当一个新的时间安排出现的时候，只需要判断一下是否需要新申请一个会议室，还是继续使用之前的会议室。

class Solution:
    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
        intervals.sort()
        heap = []
        heapq.heapify(heap)
        for start, end in intervals:
            if len(heap) == 0:
                heapq.heappush(heap,end)
            else:
                if heap[0] <= start:
                    heapq.heappop(heap)
                heapq.heappush(heap,end)
        return len(heap)

 

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        ans = set()
        for num in nums2:
            if num in nums1:
                ans.add(num)
        return ans
        

class Solution:
    def removeDuplicates(self, s: str) -> str:
        ans = []
        for char in s:
            if len(ans) == 0:
                ans.append(char)
            else:
                if ans[-1] == char:
                    ans.pop()
                else:
                    ans.append(char)
        result = ""
        for c in ans:
            result = result + c
        return result
        

问题代码：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        if not lists:
            return
        
        n = len(lists)
        return self.merge(lists,0,n-1)
    def merge(self,lists,left,right):
        if left == right:
            return lists[left]
        mid = left + (left+right) //2
        l1 = self.merge(lists,left,mid)
        l2 = self.merge(lists,mid+1,right)
        return self.mergetwolist(l1,l2)
    def mergetwolist(self,l1,l2):
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val <l2.val:
            l1.next = self.mergetwolist(l1.next,l2)
            return l1
        else:
            l2.next = self.mergetwolist(l1,l2.next)
            return l2

 错误原因： (left+right) //2

合并K个链表：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        if not lists:
            return
        
        n = len(lists)
        return self.merge(lists,0,n-1)
    def merge(self,lists,left,right):
        if left == right:
            return lists[left]
        mid = left + (right-left) //2
        l1 = self.merge(lists,left,mid)
        l2 = self.merge(lists,mid+1,right)
        return self.mergetwolist(l1,l2)
    def mergetwolist(self,l1,l2):
        if not l1:
            return l2
        if not l2:
            return l1
        if l1.val <l2.val:
            l1.next = self.mergetwolist(l1.next,l2)
            return l1
        else:
            l2.next = self.mergetwolist(l1,l2.next)
            return l2

 

class Solution:
    def numIslands(self, grid: List[List[str]]) -> int:
        m = len(grid)
        n = len(grid[0])
        self.grid = grid
        ans = 0
        for i in range(m):
            for j in range(n):
                if self.grid[i][j] == "1":
                    ans += 1
                    self.islands(i,j,m,n)
        return ans
    def islands(self,i,j,m,n):
        if i<0 or i>=m or j<0 or j>=n or self.grid[i][j] == "0":
            return
        self.grid[i][j] = "0"
        self.islands(i+1,j,m,n)
        self.islands(i-1,j,m,n)
        self.islands(i,j+1,m,n)
        self.islands(i,j-1,m,n)
        return

 

class Solution:
    def reverseWords(self, s: str) -> str:
        i=0
        
        while s[i]== " ":
            i += 1
        j = len(s)-1
        while s[j] == " ":
            j -= 1
        word= s[i]
        for x in range(i+1,j+1):
            if s[x] == " " and s[x] == s[x-1]:
                continue
            else:
                word += s[x]
        wordlist = word.split(" ")
        n = len(wordlist)
        print(wordlist)
        ans = ""
        print(wordlist[n-1],wordlist[n-2])
        for i in range(n-1,-1,-1):
            print(wordlist[i])
            ans += wordlist[i] +" "
        return ans[:-1]
        

 

class Solution:
    def validPalindrome(self, s: str) -> bool:
        if len(s) <= 2:
            return True
        n = len(s)
        i = 0
        j = n-1
        count = 0
        while i<j:
            if count >1:
                return False
            if s[i] == s[j]:
                i += 1
                j -= 1
            else:
                return self.ispalindrome(s[i+1:j+1]) or self.ispalindrome(s[i:j])
        return True
    def ispalindrome(self,s):
        return s == s[::-1]