数据结构与算法学习(2)——BFS(广度优先搜索)

BFS基础

BFS会从根节点开始搜索，在每一个路口面临分叉的时候，先把每个岔路记录下来，然后再去一个一个的往前走一步。

节点进行广度优先搜索的顺序

题目

PS:下列题目均来自leetcode中灵神题单

1311. 获取你好友已观看的视频

# 官方解答
class Solution:
    def watchedVideosByFriends(self, watchedVideos: List[List[str]], friends: List[List[int]], id: int, level: int) -> List[str]:
        n = len(friends)
        used = [False] * n
        q = collections.deque([id])
        used[id] = True
        for _ in range(level):
            span = len(q)
            for i in range(span):
                u = q.popleft()
                for v in friends[u]:
                    if not used[v]:
                        q.append(v)
                        used[v] = True
        
        freq = collections.Counter()
        for _ in range(len(q)):
            u = q.pop()
            for watched in watchedVideos[u]:
                freq[watched] += 1

        videos = list(freq.items())
        videos.sort(key=lambda x: (x[1], x[0]))

        ans = [video[0] for video in videos]
        return ans

1129. 颜色交替的最短路径

# 首先是DFS的做法
class Solution:
    from collections import defaultdict

    def shortestAlternatingPaths(self,n, redEdges, blueEdges):
        graph = defaultdict(lambda: defaultdict(list))
        for u, v in redEdges:
            graph[u]['red'].append(v)
        for u, v in blueEdges:
            graph[u]['blue'].append(v)
        
        def dfs(node, color, length, visited):
            if visited[node][color] <= length:
                return
            visited[node][color] = length
            
            for next_node in graph[node][color]:
                dfs(next_node, 'red' if color == 'blue' else 'blue', length + 1, visited)
        
        answer = [-1] * n
        visited = [{ 'red': float('inf'), 'blue': float('inf') } for _ in range(n)]
        
        dfs(0, 'red', 0, visited)
        dfs(0, 'blue', 0, visited)
        
        for i in range(n):
            min_length = min(visited[i].values())
            answer[i] = min_length if min_length != float('inf') else -1
        
        return answer

# BFS
class Solution:
    def shortestAlternatingPaths(self,n, redEdges, blueEdges):
        G=defaultdict(lambda: defaultdict(list))
        for u, v in redEdges:
            G[u]['red'].append(v)
        for u, v in blueEdges:
            G[u]['blue'].append(v)
        
        answer = [-1] * n
        visited = set()
        queue = deque([(0, 'red', 0), (0, 'blue', 0)])
        while queue:
            node, color, length = queue.popleft()
            if (node, color) in visited:
                continue
            visited.add((node, color))
        
            if answer[node] == -1 or length < answer[node]:
                answer[node] = length
        
            next_color = 'blue' if color == 'red' else 'red'
            for next_node in G[node][next_color]:
                queue.append((next_node, next_color, length + 1))
    
        return answer

1298. 你能从盒子里获得的最大糖果数

暂时不会()