判断当前时间是否在两个时间之间_【Leetcode每日打卡】判断二分图

最新推荐文章于 2024-08-25 21:46:50 发布

原创最新推荐文章于 2024-08-25 21:46:50 发布 · 704 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#判断当前时间是否在两个时间之间 #邻接矩阵判断是否连通

本文介绍如何使用深度优先搜索、广度优先搜索及并查集三种方法判断无向图是否为二分图，并提供了详细的代码实现。

今天的力扣打卡题是「785. 判断二分图」，让我们一起用「深度优先搜索」、「广度优先搜索」、「并查集」三种不同的方法搞定它！

原题描述

力扣 785. 判断二分图
难度：Medium
给定一个无向图 graph，当这个图为二分图时返回 true。
如果我们能将一个图的顶点集合分割成两个独立的子集 A 和 B，并使图中的每一条边的两个顶点一个来自 A 集合，一个来自 B 集合，我们就将这个图称为二分图。
graph 将会以邻接表方式给出，graph[i] 表示图中与顶点 i 相连的所有顶点。每个顶点都是一个在 0 到 graph.length - 1 之间的整数。
图中没有自环和平行边：graph[i] 中不存在 i，并且 graph[i] 中没有重复的值。示例 1:：输入: [[1,3], [0,2], [1,3], [0,2]]输出: true解释:
无向图如下:
0----1
|      |
|      |
3----2
我们可以将节点分成两组: {0, 2} 和 {1, 3}。示例 2:：输入: [[1,2,3], [0,2], [0,1,3], [0,2]]输出: false解释:
无向图如下:
0-------1
|   \ |
|    \    |
3-------2
我们不能将节点分割成两个独立的子集。

什么是二分图

若无向图的顶点集可以分割为两个互不相交的子集，且图中每条边的两个顶点分别属于不同的子集，则称图为一个二分图。

例如上图，顶点可以分为红色和蓝色两个集合，且图中每条边的两个顶点分别属于不同的集合，因此 上图是二分图。

又如上图，顶点无法划分为红色和蓝色两个集合，使得图中每条边的两个顶点分别属于不同的集合，因此 上图不是二分图。

如何判断二分图

深度优先搜索 / 广度优先搜索

我们使用图搜索算法从各个连通域的任一顶点开始遍历整个连通域，遍历的过程中用两种不同的颜色对顶点进行染色，相邻顶点染成相反的颜色。这个过程中倘若发现相邻的顶点已经被染成了相同的颜色，说明它不是二分图；反之，如果所有的连通域都染色成功，说明它是二分图。

并查集

根据定义，如果是二分图的话，那么 图中每个顶点的所有邻接点都应该属于同一集合，且不与顶点处于同一集合。因此我们可以使用并查集来解决这个问题，我们遍历图中每个顶点，将当前顶点的所有邻接点进行合并，并判断这些邻接点中是否存在某一邻接点已经和当前顶点处于同一个集合中了，若是，则说明不是二分图。

具体实现

广度优先搜索

首先定义 int[] visited 数组，初始值为 0 表示未被访问，赋值为 1 或者 -1 表示两种不同的颜色。
对于每个连通域，任选其中一个顶点作为搜索起点，加入队列，对该连通域进行 BFS 染色，详见注释。

class Solution {
    public boolean isBipartite(int[][] graph) {
        int[] visited = new int[graph.length];
        Queue queue = new LinkedList<>();// 因为图中可能含有多个连通域，所以我们需要判断是否存在顶点未被访问，若存在则从它开始再进行一轮 bfs 染色。for (int i = 0; i             if (visited[i] != 0) {continue;
            }// 每出队一个顶点，将其所有邻接点染成相反的颜色并入队。
            queue.offer(i);
            visited[i] = 1;while (!queue.isEmpty()) {int v = queue.poll();for (int w: graph[v]) {// 如果当前顶点的某个邻接点已经被染过色了，且颜色和当前顶点相同，说明此无向图无法被正确染色，返回 false。if (visited[w] == visited[v]) {return false;
                    }if (visited[w] == 0) {
                        visited[w] = -visited[v];
                        queue.offer(w);
                    }
                }          
            }
        }return true;
    }
}

深度优先搜索

首先定义 int[] visited 数组，初始值为 0 表示未被访问，赋值为 1 或者 -1 表示两种不同的颜色。
对于每个连通域，任选其中一个顶点作为搜索起点，对该连通域进行 DFS 染色，详见注释。

class Solution {
    public boolean isBipartite(int[][] graph) {
        int[] visited = new int[graph.length];
        // 因为图中可能含有多个连通域，所以我们需要判断是否存在顶点未被访问，若存在则从它开始再进行一轮 dfs 染色。
        for (int i = 0; i             if (visited[i] == 0 && !dfs(graph, i, 1, visited)) {
                return false;
            }
        }
        return true;
    }

    private boolean dfs(int[][] graph, int v, int color, int[] visited) {
        // 如果要对某顶点染色时，发现它已经被染色了，则判断它的颜色是否与本次要染的颜色相同，如果矛盾，说明此无向图无法被正确染色，返回 false。
        if (visited[v] != 0) {
            return visited[v] == color;
        }
        
        // 对当前顶点进行染色，并将当前顶点的所有邻接点染成相反的颜色。
        visited[v] = color;
        for (int w: graph[v]) {
            if (!dfs(graph, w, -color, visited)) {
                return false;
            }
        }
        return true;
    }
}

并查集

遍历图中每个顶点：

将当前顶点的所有邻接点进行合并
判断是否存在邻接点与当前顶点已经在一个集合中了，若存在，则说明不是二分图

class Solution {
    public boolean isBipartite(int[][] graph) {
        // 初始化并查集
        UnionFind uf = new UnionFind(graph.length);
        // 遍历每个顶点
        for (int i = 0; i             int[] adjs = graph[i];
            // 遍历当前顶点的所有邻接点，将其与当前顶点的第一个邻接点合并。
            for (int w: adjs) {
                // 若某个邻接点与当前顶点已经在一个集合中了，说明不是二分图，返回 false。
                if (uf.isConnected(i, w)) {
                    return false;
                }
                uf.union(adjs[0], w);
            }
        }
        return true;
    }
}

上述代码中使用的并查集定义如下：

// 并查集
class UnionFind {
    int[] roots;
    
    // 初始化每个点指向自己
    public UnionFind(int n) {
        roots = new int[n]; 
        for (int i = 0; i             roots[i] = i;
        }
    }

    // 返回 i 的根
    public int find(int i) {
        if (roots[i] == i) {
            return i;
        }
        return roots[i] = find(roots[i]);
    }

    // 判断 p 和 q 是否在同一个集合中
    public boolean isConnected(int p, int q) {
        return find(q) == find(p);
    }

    // 合并 p 和 q 到一个集合中
    public void union(int p, int q) {
        roots[find(p)] = find(q);
    }
}

复杂度分析

上述三种方法，时间复杂度是，空间复杂度是，其中是无向图的顶点数，是无向图的边数。

知识拓展导读

在二分图上，最常见的问题是求 二分图最大匹配/最大独立集。二分图的最大匹配，简单来说就是找到尽可能多的两两匹配的关系。比如说在某场相亲现场，主持人先让所有男生女生都写好自己感兴趣的若干个异性，主持人需要尽可能多的凑一对对男女去约会。

这个问题经典的解法是 匈牙利算法，这块知识超过了面试要求，感兴趣的同学可以自行查阅资料。

说到相亲，还有一个著名的算法叫做 稳定婚姻问题。就是说，主持人的你安排男男女女相亲，如果当前是男 1 和女 2 在一起，男 2 和女 1 在一起，男1更喜欢女1，女1也更喜欢男1，那么他俩就会私奔，你的安排相亲就是 不稳定 的。对于一群男生和女生，你需要给出一个稳定的相亲方案。这个有趣的算法，感兴趣的同学可以看下 matrix67 大神对于这个故事的阐述～