图论巧妙基础题：找到小镇的法官

Shawxing精讲算法

已于 2024-06-30 21:16:13 修改

阅读量1.2k

点赞数 39

文章标签：图论

于 2024-06-29 10:51:50 首次发布

本文链接：https://blog.csdn.net/qq_64892278/article/details/140060229

版权

在这里插入图片描述
Leetcode 题目链接

思路

我们可以将其抽象为图结构，如下所示。顶点 3 表示法官，其余为百姓。信任关系用边表示，比如边 $\rightarrow 3$ 表示 1 信任 3。
1718423325-dVaLMt-Screenshot 2024-06-15 at 11.40.28 AM.png

顶点 1245 之间可能也存在边，我们先不用管。

此处补充一下出度入度的概念：

出度：从某点出发的边数
入度：指向某点的边数

根据题意，如果小镇法官存在，那么：

小镇法官不会信任任何人。
每个人（除了小镇法官）都信任这位小镇法官。
只有一个人同时满足属性 1 和属性 2。

记 $n$ 为点数。所以在图结构中，如果存在小镇法官，只有他对应的顶点满足：

出度为 $0$
入度为 $n - 1$

综上，我们遍历边集，对每条边的起点和终点统计出度入度就可以了。

代码

C++

class Solution {
public:
    int findJudge(int n, vector<vector<int>>& trust) {
        // 多存储一个顶点 0，方便处理。    
        vector<int> outDegrees(n + 1); // 出度
        vector<int> inDegrees(n + 1); // 入度

        for (auto& edge : trust) {
            int from = edge[0], to = edge[1]; // 起点和终点
            outDegrees[from]++; // 起点出度 + 1
            inDegrees[to]++; // 终点入度 + 1
        }

        // 忽略顶点 0，寻找出度为 0，入度为 n-1 的顶点。
        for (int i = 1; i <= n; ++i) {
            if (outDegrees[i] == 0 && inDegrees[i] == n - 1){
                return i;
            }
        }

        return -1;
    }
};

int findJudge(int n, int** trust, int trustSize, int* trustColSize){
    // 多存储一个顶点 0，方便处理。    
    int* outDegrees = (int *)malloc(sizeof(int)*(n+1)); // 出度
    int* inDegrees = (int *)malloc(sizeof(int)*(n+1)); // 入度
    memset(inDegrees, 0, sizeof(int)*(n+1));
    memset(outDegrees, 0, sizeof(int)*(n+1));

    for (int i = 0; i < trustSize; ++i) {
        int from = trust[i][0], to = trust[i][1]; // 起点和终点
        outDegrees[from]++; // 起点出度 + 1
        inDegrees[to]++; // 终点入度 + 1
    }
    
    // 忽略顶点 0，寻找出度为 0，入度为 n-1 的顶点。
    for (int i = 1; i <= n; ++i) {
        if (outDegrees[i] == 0 && inDegrees[i] == n - 1) {
            return i;
        }
    }
    
    return -1;
}

Python3

class Solution:
    def findJudge(self, n: int, trust: List[List[int]]) -> int:
        # 多存储一个顶点 0，方便处理。
        out_degrees = [0] * (n + 1) # 出度
        in_degrees = [0] * (n + 1) # 入度

        for start, end in trust: # 遍历每条边的起点和终点
            out_degrees[start] += 1 # 起点出度 + 1
            in_degrees[end] += 1 # 终点入度 + 1

        # 忽略顶点 0，寻找出度为 0，入度为 n-1 的顶点。
        for i in range(1, n + 1):
            if out_degrees[i] == 0 and in_degrees[i] == n - 1:
                return i

        return -1

Python3 +语法糖

class Solution:
    def findJudge(self, n: int, trust: List[List[int]]) -> int:
        outDegrees = Counter(start for start, _ in trust)
        inDegrees = Counter(end for _, end in trust)
        return next((i for i in range(1, n + 1) if outDegrees[i] == 0 and inDegrees[i] == n - 1), -1)

Java

class Solution {
    public int findJudge(int n, int[][] trust) {
        // 多存储一个顶点 0，方便处理。
        int[] outDegrees = new int[n + 1]; // 出度
        int[] inDegrees = new int[n + 1]; // 入度

        for (int[] edge : trust) {
            int from = edge[0]; // 起点
            int to = edge[1]; // 终点
            outDegrees[from]++; // 起点出度 + 1
            inDegrees[to]++; // 终点入度 + 1
        }

        // 忽略顶点 0，寻找出度为 0，入度为 n-1 的顶点。
        for (int i = 1; i <= n; i++) {
            if (outDegrees[i] == 0 && inDegrees[i] == n - 1) {
                return i;
            }
        }

        return -1;
    }
}

Kotlin

class Solution {
    fun findJudge(n: Int, trust: Array<IntArray>): Int {
        // 多存储一个顶点 0，方便处理。    
        val outDegrees = IntArray(n+1) // 出度
        val inDegrees = IntArray(n+1) // 入度

        for((from, to) in trust){ // 遍历每条边的起点和终点
            outDegrees[from]++ // 起点出度 + 1
            inDegrees[to]++ // 终点入度 + 1
        }

        // 忽略顶点 0，寻找出度为 0，入度为 n-1 的顶点。
        return (1..n).firstOrNull{ 
                outDegrees[it] == 0 && inDegrees[it] == n-1 
            }
            ?: -1
    }
}