leetcode 第 159 场周赛

1232. 缀点成线

在一个 XY 坐标系中有一些点，我们用数组 coordinates 来分别记录它们的坐标，其中 coordinates[i] = [x, y] 表示横坐标为 x、纵坐标为 y 的点。
请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 true，否则请返回 false。

水题,直接通过向量判断

class Solution(object):
    def checkStraightLine(self, coordinates):
        x = coordinates[0][0]-coordinates[1][0]
        y = coordinates[0][1]-coordinates[1][1]
        for i in range(2,len(coordinates)):
            x1 = coordinates[0][0]-coordinates[i][0]
            y1 = coordinates[0][1]-coordinates[i][1]
            if x*y1 != y*x1:
                return False
        return True

1233. 删除子文件夹

你是一位系统管理员，手里有一份文件夹列表 folder，你的任务是要删除该列表中的所有 子文件夹，并以 任意顺序 返回剩下的文件夹。

我们这样定义「子文件夹」：

• 如果文件夹 folder[i] 位于另一个文件夹 folder[j] 下，那么 folder[i] 就是 folder[j] 的子文件夹。

文件夹的「路径」是由一个或多个按以下格式串联形成的字符串：

• / 后跟一个或者多个小写英文字母。

例如，/leetcode 和 /leetcode/problems 都是有效的路径，而空字符串和 / 不是。

维护一个文件夹的树(和系统文件浏览类似的树),有效节点标记end,最终通过dfs访问遇到标记就记录并返回

class Node: 
    def __init__(self,data,isend): 
        self.Nodelist = []  
        self.data = data
        self.isend = isend  
class Tree:
    def __init__(self):
        self.ans = []
        self.root = Node("",False)
    def dfsins(self,list,root): 
    # dfsins(str.spilit('/')[1:],self.root) 
        if len(list) == 1:
            self.ins(list[0],root,True)
            return 
        tmp = self.ins(list[0],root,False)
        if tmp.isend:
            return
        self.dfsins(list[1:],tmp)
    def ins(self,str,root,isend=False):
        for i in root.Nodelist:
            if i.data == str:
                if not i.isend:
                    i.isend = isend
                return i
        tmp = Node(str,isend)
        root.Nodelist.append(tmp)
        return tmp
    def dfs(self,root,str):
        if str == "__init__":
            str = root.data
        else:
            str = str+'/'+root.data
        if root.isend:
            self.ans.append(str)
            return 
        for i in root.Nodelist:
            self.dfs(i,str)
class Solution(object):
    def removeSubfolders(self, folder):
        """
        :type folder: List[str]
        :rtype: List[str]
        """    
        tree = Tree()
        for i in folder:
            tree.dfsins(i.split('/')[1:],tree.root)
        tree.dfs(tree.root,"__init__")
        return tree.ans

1234. 替换子串得到平衡字符串

有一个只含有 'Q', 'W', 'E', 'R' 四种字符，且长度为 n 的字符串。

假如在该字符串中，这四个字符都恰好出现 n/4 次，那么它就是一个「平衡字符串」。

给你一个这样的字符串 s，请通过「替换一个子串」的方式，使原字符串 s 变成一个「平衡字符串」。

你可以用和「待替换子串」长度相同的 任何 其他字符串来完成替换。

请返回待替换子串的最小可能长度。

如果原字符串自身就是一个平衡字符串，则返回 0。

尺取法,非平衡串需要替换的位置必然包含超出的字符.
如果Q,W,E,R四种字符存在任意超出n/4 次的情况,我们只需要求出包含超出数量的指定字符的最短子串即答案

class Solution(object):
    def balancedString(self, s):
        length = len(s)
        limit = length // 4
        cnt = {'Q': 0, 'W': 0, 'E': 0, 'R': 0}
        for i in s:
            cnt[i] += 1
        print(cnt)
        for k, v in cnt.items():
            cnt[k] = v - limit if v > limit else 0
        l, r = 0, 0
        now = {'Q': 0, 'W': 0, 'E': 0, 'R': 0}
        ans = length
        while l <= r and r < length:
            if r < length and not self.check(now, cnt):
                now[s[r]] += 1;
                r += 1
            while l <= r and self.check(now, cnt):
                ans = min(ans, r - l)
                now[s[l]] -= 1;
                l += 1
        return ans

    def check(self, now, cnt):
        for k, v in cnt.items():
            if now[k] < v:
                return False
        return True

1235. 规划兼职工作

你打算利用空闲时间来做兼职工作赚些零花钱。

这里有 n 份兼职工作，每份工作预计从 startTime[i] 开始到 endTime[i] 结束，报酬为 profit[i]。

给你一份兼职工作表，包含开始时间 startTime，结束时间 endTime 和预计报酬 profit 三个数组，请你计算并返回可以获得的最大报酬。

注意，时间上出现重叠的 2 份工作不能同时进行。

如果你选择的工作在时间 X 结束，那么你可以立刻进行在时间 X 开始的下一份工作。

板子题,dp+二分(真的有点懒得写...)