AC：0/3，score=0.2

又被血虐。

第一题：

题目：

答案：

class Solution:
    def solve(self , str ):
        stack=[str[0]]
        n=len(str)
        if n==1:return str
        for i in range(1,n):
            if str[i]=="1":
                if stack and stack[-1]=="1":
                    stack.pop()
                else:
                    stack.append(str[i])
            else:
                if stack and stack[-1]=="0":
                    if len(stack)>1 and stack[-2]=="1":
                        stack.pop()
                        stack.pop()
                    else:
                        stack.pop()
                        stack.append("1")
                else:
                    stack.append(str[i])
        return "".join(stack)

思路：

模拟栈就行了，出栈的时候只会影响前一个。

第二题：

题目：

答案：

class Solution:
    def solve(self , n , m , limit ):
        # write code here
        def dfs(i):
            if i==n+1:
                for p in limit:
                    if p.x in visit and p.y in visit:
                        return
                self.ans+=1
                return 
            visit.add(i)
            dfs(i+1)
            visit.remove(i)
            dfs(i+1)
        self.ans=0
        visit=set()
        dfs(1)
        return self.ans

思路：

怎么说呢，这个回溯法，我好像怎么又像从来没写过一样，写了半天。
每次递归的时候是，选不选这个数，所以递归两次，递归的出口，我这里是n+1
当然可以对 visit 做预处理，但是这里visit只有400，我觉得不会影响复杂度。
这题的预处理也可以用位运算压缩，但是速度上还是对 visit 做预处理更快。

第三题：

题目：

答案：

class Solution:
    def solve(self , n , k , s ):
        # write code here
        from collections import Counter
        s = Counter(s)
        def judge(x):
            out = {}
            cur = 0
            for j in s:
                out[j] = s[j] // x
                cur += out[j]
            if cur < k:
                return []
            res = []
            rest = k
            for j in sorted(out):
                if out[j] >= rest:
                    res.extend([j]*rest)
                    return res
                else:
                    res.extend([j]*out[j])
                    rest -= out[j]
        for i in range(n//k, 0, -1):
            ans = judge(i)
            if ans:
                return ans

思路：

思路我和大佬是一样的，用Counter 去倒叙遍历 子集的套数，找到符合的就返回（一定会找到，只要n>=k），但是这个代码大佬写的也太好了，超越不了了。