数据结构高频面试题-图

class Node(object):
    def __init__(self, val, neighbors):
        self.val = val
        self.neighbors = neighbors


class Solution(object):
    def cloneGraph(self, node: Node):
        """
        :type node: Node
        :rtype: Node
        """
        # 存储新旧结点的映射关系
        graph = {}
        visited = set()
        if node not in graph:
            graph[node] = Node(node.val, [])

        def dfs(node, visited, graph):
            if node in visited:
                return
            visited |= node

            for neighbor in node.neighbors:
                if neighbor not in graph:
                    graph[neighbor] = Node(neighbor.val, [])
                # 像新图的node结点添加一个映射后邻居结点
                graph[node].neighbors.append(graph[neighbor])
                dfs(neighbor, visited, graph)
            return graph[node]

        return dfs(node, visited, graph)

输入: 2, [[1,0]] 
输出: [0,1]
解释: 总共有 2 门课程。要学习课程 1，你需要先完成课程 0。因此，正确的课程顺序为 [0,1] 。

输入: 4, [[1,0],[2,0],[3,1],[3,2]]
输出: [0,1,2,3] or [0,2,1,3]
解释: 总共有 4 门课程。要学习课程 3，你应该先完成课程 1 和课程 2。并且课程 1 和课程 2 都应该排在课程 0 之后。
因此，一个正确的课程顺序是 [0,1,2,3] 。另一个正确的排序是 [0,2,1,3] 。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedList;

/**
 * 使用拓扑排序来完成
 */
public class Solution {

    public int[] findOrder(int numCourses, int[][] prerequisites) {
        // 先处理极端情况
        if (numCourses <= 0) {
            return new int[0];
        }
        // 邻接表表示
        HashSet<Integer>[] graph = new HashSet[numCourses];
        for (int i = 0; i < numCourses; i++) {
            graph[i] = new HashSet<>();
        }
        // 入度表
        int[] inDegree = new int[numCourses];
        // 遍历 prerequisites 的时候，把 邻接表 和 入度表 都填上
        for (int[] p : prerequisites) {
            graph[p[1]].add(p[0]);
            inDegree[p[0]]++;
        }
        LinkedList<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inDegree[i] == 0) {
                queue.addLast(i);
            }
        }
        ArrayList<Integer> res = new ArrayList<>();
        while (!queue.isEmpty()) {
            // 当前入度为 0 的结点
            Integer inDegreeNode = queue.removeFirst();
            // 加入结果集中
            res.add(inDegreeNode);
            // 下面从图中删去
            // 得到所有的后继课程，接下来把它们的入度全部减去 1
            HashSet<Integer> nextCourses = graph[inDegreeNode];
            for (Integer nextCourse : nextCourses) {
                inDegree[nextCourse]--;
                // 马上检测该结点的入度是否为 0，如果为 0，马上加入队列
                if (inDegree[nextCourse] == 0) {
                    queue.addLast(nextCourse);
                }
            }
        }
        // 如果结果集中的数量不等于结点的数量，就不能完成课程任务，这一点是拓扑排序的结论
        int resLen = res.size();
        if (resLen == numCourses) {
            int[] ret = new int[numCourses];
            for (int i = 0; i < numCourses; i++) {
                ret[i] = res.get(i);
            }
            return ret;
        } else {
            return new int[0];
        }
    }
}

class Solution {
    public int networkDelayTime(int[][] times, int N, int K) {
        if (times == null || times.length == 0 || times[0].length == 0) {
            return -1;
        }

        // 使用邻接矩阵 Adjacency matrices 存储图结构
        int[][] adj = new int[N + 1][N + 1];
        for (int[] arr : adj) {
            Arrays.fill(arr, Integer.MAX_VALUE);
        }

        // 有权图
        for (int[] edge : times) {
            adj[edge[0]][edge[1]] = edge[2];
        }

        // res[i] 表示顶点 K 到顶点 i 的时间
        int[] res = new int[N + 1];
        Arrays.fill(res, Integer.MAX_VALUE);
        res[K] = 0;

        Queue<Integer> queue = new LinkedList<Integer>();
        queue.offer(K);

        while (!queue.isEmpty()) {
            Integer start = queue.poll();

            for (int i = 1; i <= N; i++) {
                int weight = adj[start][i];

                // DP 动态规划
                if (weight != Integer.MAX_VALUE && res[i] > res[start] + weight) {
                    res[i] = res[start] + weight;
                    queue.offer(i);
                }
            }
        }

        int count = 0;
        for (int i = 1; i <= N; i++) {
            if (res[i] == Integer.MAX_VALUE) {
                return -1;
            }

            count = Math.max(count, res[i]);
        }

        return count;
    }
}

equations(方程式) = [ ["a", "b"], ["b", "c"] ],
values(方程式结果) = [2.0, 3.0],
queries(问题方程式) = [ ["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"] ]. 

def calcEquation(self, equations: List[List[str]], values: List[float], queries: List[List[str]]) -> List[float]:
        # 构造图，equations的第一项除以第二项等于value里的对应值，第二项除以第一项等于其倒数
        graph = {}
        for (x, y), v in zip(equations, values):
            if x in graph:
                graph[x][y] = v
            else:
                graph[x] = {y: v}
            if y in graph:
                graph[y][x] = 1/v
            else:
                graph[y] = {x: 1/v}

        # dfs找寻从s到t的路径并返回结果叠乘后的边权重即结果
        def dfs(s, t) -> int:
            if s not in graph:
                return -1
            if t == s:
                return 1
            for node in graph[s].keys():
                if node == t:
                    return graph[s][node]
                elif node not in visited:
                    visited.add(node)  # 添加到已访问避免重复遍历
                    v = dfs(node, t)
                    if v != -1:
                        return graph[s][node]*v
            return -1

        # 逐个计算query的值
        res = []
        for qs, qt in queries:
            visited = set()
            res.append(dfs(qs, qt))
        return res

输入: n = 4, edges = [[1, 0], [1, 2], [1, 3]]

     0
     |
     1
    / 
   2   3 

输出: [1]

输入: n = 6, edges = [[0, 3], [1, 3], [2, 3], [4, 3], [5, 4]]

  0  1  2
    | /
     3
     |
     4
     |
     5 

输出: [3, 4]

  0  1  2
    | /
     3
     |
     4
     |
     5 

class Solution:
    def findMinHeightTrees(self, n: int, edges: List[List[int]]) -> List[int]:
        # 初始判断
        if not edges:
            return [] if n == 0 else [0]
        # 构建图
        graph = {}
        for v1, v2 in edges:
            graph[v1] = graph.get(v1, []) + [v2]
            graph[v2] = graph.get(v2, []) + [v1]
        # 逐层删除叶子结点
        while len(graph) > 2:
            leaf = [i for i in graph if len(graph[i])== 1]
            parent = [graph[i][0] for i in leaf]
            for i, j in zip(parent, leaf):
                graph[i].remove(j)
            for i in leaf:
                del graph[i]
        return list(graph.keys())

输入: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
输出: ["JFK", "MUC", "LHR", "SFO", "SJC"]

输入: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
输出: ["JFK","ATL","JFK","SFO","ATL","SFO"]
解释: 另一种有效的行程是 ["JFK","SFO","ATL","JFK","ATL","SFO"]。但是它自然排序更大更靠后。

class Solution(object):
    def findItinerary(self, tickets):
        """
        :type tickets: List[List[str]]
        :rtype: List[str]
        """
        graph = collections.defaultdict(list)
        for frm, to in tickets:
            graph[frm].append(to)
        for frm, tos in graph.items():
            tos.sort()
        res = []
        self.dfs(graph, "JFK", res)
        return res[::-1]

    def dfs(self, graph, source, res):
        while graph[source]:
            v = graph[source].pop(0)
            self.dfs(graph, v, res)
        res.append(source)

输入: [[1,2], [1,3], [2,3]]
输出: [2,3]
解释: 给定的无向图为:
1
/ 
2 - 3

输入: [[1,2], [2,3], [3,4], [1,4], [1,5]]
输出: [1,4]
解释: 给定的无向图为:
5 - 1 - 2
 |   |
 4 - 3

def find(node):
    # 不断向上层查找根结点，根结点特点：结点索引和索引值相同
    while node != parent[node]:
        node = parent[node]
    return node

def union(node1, node2):
    root1 = find(node1)
    root2 = find(node2)
    # 两个结点属于同一组，即已经连通
    if root1 == root2:
        return
    else:
        # 将第一组划入第二组中，只需改根结点的组号即可
        parent[root1] = root2

public int[] findRedundantConnection(int[][] edges) {
        int[] parent = new int[edges.length + 1];
        for (int i = 0; i < edges.length + 1; i++) {
            parent[i] = i;
        }
        int[] res = null;

        for (int[] is : edges) {
            int x = is[0];
            int y = is[1];

            while (x != parent[x]) {
                x = parent[x];
            }
            while (y != parent[y]) {
                y = parent[y];
            }

            if (x == y) {
                res = is;
            } else {
                parent[x] = y;
            }

        }

        return res;
    }

class Solution:
    def findRedundantConnection(self, edges: List[List[int]]) -> List[int]:
        # 存储每个结点的父节点
        parent = list(range(len(edges) + 1))
        # 存储根结点所代表树的尺寸（结点个数）
        size = [1] * (len(edges) + 1)

        # 查找根结点
        def find(node):
            while node != parent[node]:
                # 路径压缩:parent[node]更新为其爷爷结点
                parent[node] = parent[parent[node]]
                node = parent[node]
            return node

        # 连接两个结点
        def union(node1, node2):
            root1 = find(node1)
            root2 = find(node2)
            if root1 == root2:
                return False
            else:
                # 尺寸小的树向尺寸大的树合并。树越平衡，find时复杂度越低。
                size1 = size[root1]
                size2 = size[root2]
                if size1 < size2:
                    parent[root1] = root2
                else:
                    parent[root2] = root1
                return True

        for edge in edges:
            if not union(edge[0], edge[1]):
                return edge