7.12 - medium总结13

249. Group Shifted Strings: 记录一下每一个字符和第一个字符之间的距离，然后形成一个tuple，再利用tuple做key，用hashtable比较一下就可以了
250. Count Univalue Subtrees：比较典型的divide and conquer的题目
251. Flatten 2D Vector: design的题目，找到合适的数据结构，存储合适的东西就可以了，还算是简单吧。
253. Meeting Rooms II：这道题的思想好像是和第一次leetcode竞赛中的那个想法差不多，用heap做greedy，套路啊全是套路。

# Definition for an interval.
# class Interval(object):
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution(object):
    def minMeetingRooms(self, intervals):
        """
        :type intervals: List[Interval]
        :rtype: int
        """
        # 先按照开始时间排序，然后按照结束时间放大小进heap里
        # 没次新进来一个，就是比当前栈顶的开始时间晚，而这个栈顶是结束时间也最早的
        # 所以如果新进来的开始时间能够比栈顶结束时间晚的话，那么就replace这个栈顶，并且把当前的放进去
        # 否则就直接放进去，因为不会有比这个栈顶时间更早结束的meeting了
        # 最后数数栈里元素的个数
        heap = []
        intervals = sorted(intervals, key=lambda x: (x.start, x.end))
        
        for interval in intervals:
            if not heap:
                heapq.heappush(heap, interval.end)
            else:
                endtime = heap[0]
                if interval.start >= endtime:
                    heapq.heappop(heap)
                heapq.heappush(heap, interval.end)
        return len(heap)

254. Factor Combinations：这题没做出来，大概的思想知道，就是不停的递归，但是递归的条件没太想好。有点像backtracking，先针对一个factor不停得取这个值，直到n里不在有这个factor，然后在进入下一个值，嗯，其实就是一道backtracking的题目，记录好index位置和循环条件就好
255. Verify Preorder Sequence in Binary Search Tree: 做出了一个TLE的版本，这题看答案后感觉解法还挺奇妙的，preorder中的左子树都是保持递减序列的，所以遇到一个比较大的值，就是当前树的右子树，就把左边的pop出来，这是preorder的一个新特性，也是树的题目的一个新考虑方向，以前从来没遇到过这种思想

class Solution(object):
    def verifyPreorder(self, preorder):
        stack = []
        inorder = []
        for v in preorder:
            if inorder and v < inorder[-1]:
                return False;
            while stack and v > stack[-1]:
                inorder.append(stack.pop());
            stack.append(v);
        return True;

解法2，利用preorder本身做为stack，来降低空间复杂度。lower表示inorder的最后一个值
def verifyPreorder(self, preorder):
    # stack = preorder[:i], reuse preorder as stack
    lower = -1 << 31
    i = 0
    for x in preorder:
        if x < lower:
            return False
        while i > 0 and x > preorder[i - 1]: # 等于上面逻辑中的pop
            lower = preorder[i - 1]
            i -= 1
        preorder[i] = x # 这一行和下一行等于上面逻辑中的append
        i += 1
    return True

259. 3Sum Smaller：固定一个值，然后对另两个值做two pointer，只是在计数的时候要把 count += end - start，因为所有比end小的数都可以和固定值以及start形成一个解。
260. Single Number III：把所有的数xor后找到最低位的1，x = xor & (xor ^ (xor-1))， 然后把所有数分成两组，分别再xor就可以了。
261. Graph Valid Tree: 本质就是在graph找环或者找分散的subgraph，手写出来的，虽然code长相不是很好看，但是也AC了。这题还可以用union-find做

def validTree(self, n, edges):
    parent = range(n)
    def find(x):
        return x if parent[x] == x else find(parent[x])
    for e in edges:
        x, y = map(find, e)
        if x == y:
            return False
        parent[x] = y
    return len(edges) == n - 1

264. Ugly Number II：这道题好像还有好多的衍生题目，基本思想是对于ugly里的每一位数，都应该乘以2，3，5并加入到ugly里去，所以要记录一下当前base所到达的index, 当弹出一个base值后，要加入baseugly[index+1]*