2021-08-17：拓扑有向图，回溯dfs，差分数组，栈

本文链接：https://blog.csdn.net/qq_41179957/article/details/119745255

拓扑有向图：

class Solution:
    def minimumSemesters(self, n: int, relations: List[List[int]]) -> int:
        degree = [0]*n
        adjancy = [[] for _ in range(n)]
        for pre,cur in relations:
            adjancy[pre-1].append(cur-1)
            degree[cur-1] += 1
        queue = []
        for i in range(n):
            if degree[i] == 0:
                queue.append(i)
        count = 0
        level = 0
        while len(queue)>0:
            nextlevel = []
            len1 = len(queue)
            level += 1
            for i in range(len1):
                point = queue.pop()
                count += 1
                for point1 in adjancy[point]:
                    degree[point1] -= 1
                    if degree[point1] == 0 :
                        nextlevel.append(point1)
            queue = nextlevel
        if count != n:
            return -1
        else: 
            return level

class Solution:
    def canFinish(self, numCourses: int, prerequisites: List[List[int]]) -> bool:
        degree = [0]*numCourses
        adjancy = [[] for _ in range(numCourses)]
        for cur,pre in prerequisites:
            adjancy[pre].append(cur)
            degree[cur] += 1
        queue = []
        for i in range(numCourses):
            if degree[i] == 0:
                queue.append(i)
        count = 0
        while len(queue)>0:
            point = queue.pop()
            count += 1
            for point1 in adjancy[point]:
                degree[point1] -= 1
                if degree[point1] == 0 :
                    queue.append(point1)
        return count == numCourses

class Solution:
    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
        lis = []
        for start,end in intervals:
            lis.append([start,1])
            lis.append([end,-1])
        lis.sort()
        print(lis)
        count = 0
        for _,value in lis:
            count = count +value
            if count > 1:
                return False
        return True

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

759

"""
# Definition for an Interval.
class Interval:
    def __init__(self, start: int = None, end: int = None):
        self.start = start
        self.end = end
"""

class Solution:
    def employeeFreeTime(self, schedule: '[[Interval]]') -> '[Interval]':
        lis = []
        ans = []
        for person in schedule:
            for interval in person:
                start = interval.start
                end = interval.end
                lis.append((start,-1))
                lis.append((end,1))  
        lis.sort()
        print(lis)
        count = 0
        start = 0
        end = 0
        for key,value in lis:
            count += value
            if value == 1 and count == 0:
                start = key
            if value == -1 and count == -1:
                end = key
                if start != 0:
                    ans.append(Interval(start,end))
        return ans

作业：

class Solution:
    def findOrder(self, numCourses: int, prerequisites: List[List[int]]) -> List[int]:
        adjancy = [[] for _ in range(numCourses)]
        degree = [0]*numCourses
        ans = []
        for cur,pre in prerequisites:
            adjancy[pre].append(cur)
            degree[cur] += 1
        queue = []
        count = 0
        for n in range(numCourses):
            if degree[n] == 0:
                queue.append(n)

        while len(queue)>0:
            length = len(queue)
            nextlevel = []
            for i in range(length):
                point = queue.pop()
                ans.append(point)
                count += 1
                for point1 in adjancy[point]:
                    degree[point1] -= 1
                    if degree[point1] == 0:
                        nextlevel.append(point1)
            queue = nextlevel
        if count != numCourses:
            return []
        else:
            return ans

class Solution:
    def findMinHeightTrees(self, n: int, edges: List[List[int]]) -> List[int]:
        adjancy = [[]for _ in range(n)]
        degree = [0]*n
        if n == 1:
            return [0]
        if n == 2:
            return [0,1]
        for point1, point2 in edges:
            adjancy[point1].append(point2)
            adjancy[point2].append(point1) 
            degree[point1] += 1
            degree[point2] += 1
        queue = deque()
        for i in range(n):
            if degree[i] == 1:
                queue.append(i)
        lastlevel =  []
        while queue:
            length = len(queue)
            lastlevel.clear()
            for _ in range(length):
                point = queue.popleft()
                lastlevel.append(point)
                for adjpoint in adjancy[point]:
                    degree[point] -= 1
                    degree[adjpoint] -= 1
                    if degree[adjpoint] ==1:
                        queue.append(adjpoint)
        return lastlevel

class Solution:
    def simplifyPath(self, path: str) -> str:
        n = len(path)
        newpath = ""
        for i in range(n-1):
            if path[i] == '/' and path[i] == path[i+1]:
                continue
            newpath += path[i]
        newpath += path[-1]
        print(newpath)
        s = newpath.split("/")
        print(s)
        ans = []
        for sub in s:
            if sub =='..':
                if len(ans):
                    ans.pop()
            elif sub =='.' or sub == '':
                continue
            else:
                ans.append(sub)
        print(ans)
        result = ""
        for sub in ans:
            result += '/'
            result += sub
        if result == "":
            return "/"
        else:
            return result

错误思路：

这里 + 就是operator 为 1

- 就是operator 为 -1

res + operator* num

return res

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if digits == "":
            return []
        table = [['a','b','c'],['d','e','f'],['g','h','i'],['j','k','l'],['m','n','o'],['p','q','r','s'],['t','u','v'],['w','x','y','z']]
        ans = []
        nextans = []
        for num in digits:
            nextans = []
            index = int(num) - 2
            print(index)
            if not ans:
                for character in table[index]:
                    nextans.append(character)
            else:
                while ans:
                    string = ans.pop()
                    for nextstring in table[index]:
                        newstring = string+nextstring
                        nextans.append(newstring)
            ans = nextans
        return ans

dfs:

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        self.ans = []
        self.dfs(0,0,n,'')
        return self.ans
    def dfs(self,l,r,n,cur):
        if l == n and r == n-1:
            self.ans.append(cur+')')
            return
        if l < n:
            self.dfs(l+1,r,n,cur+'(')
        if l>r:
            self.dfs(l,r+1,n,cur+')')

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        self.m = len(board)
        self.n = len(board[0])
        condition = [[0]*self.n for _ in range(self.m)]
        for i in range(self.m):
            for j in range(self.n):
                if len(word) ==1 :
                    if word[0] == board[i][j]:
                        return True
                if board[i][j] == word[0]:
                    condition[i][j] = 1
                    print(word[0],i,j)
                    if self.dfs(board,word,1,condition,i+1,j) or  self.dfs(board,word,1,condition,i-1,j) or  self.dfs(board,word,1,condition,i,j+1) or  self.dfs(board,word,1,condition,i,j-1):
                        return True
                    else:
                        condition[i][j] = 0
        return False
    def dfs(self,board,word,cur,condition,i,j):
        if i < 0 or i >= self.m or j < 0 or j >= self.n or condition[i][j] == 1:
            return False 
        character = word[cur]
        if cur == len(word) -1:
            if character == board[i][j]:
                return True
        if character == board[i][j]:
            print(character)
            condition[i][j] = 1
            if self.dfs(board,word,cur +1,condition,i+1,j) or  self.dfs(board,word,cur +1,condition,i-1,j) or  self.dfs(board,word,cur +1,condition,i,j+1) or  self.dfs(board,word,cur +1,condition,i,j-1):
                return True
            else: condition[i][j] = 0
        return False

如果是往一个空的集合里存东西，那么直接path+[num]，

class Solution:
    def combinationSum(self, candidates: List[int], target: int) -> List[List[int]]:
        path = []
        self.res = []
        self.length = len(candidates)
        self.dfs(candidates,path,target,0)
        return self.res
    def dfs(self,candidates,path,target,start):
        if target < 0:
            return 
        if target == 0:
            self.res.append(path)
        for index in range(start, self.length):
            num = candidates[index]
            self.dfs(candidates,path+[num],target-num,index)

class Solution:
    def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]:
        path = []
        self.res = []
        candidates.sort()
        self.length = len(candidates)
        self.dfs(candidates,target,path,0)
        return self.res
    def dfs(self,candidates,target,path,start):
        if target < 0:
            return
        if  target == 0:
            self.res.append(path)
        for index in range(start,self.length):
            if index > start and candidates[index] == candidates[index-1]: #这里判断 index > start 且不重复，是不重复加入同样的数
                continue
            num = candidates[index]
            self.dfs(candidates,target-num,path+[num],index+1)#这里的index + 1 是不重复选它自己