Description#
There is an undirected graph with n nodes, where each node is numbered between 0 and n - 1. You are given a 2D array graph, where graph[u] is an array of nodes that node u is adjacent to. More formally, for each v in graph[u], there is an undirected edge between node u and node v. The graph has the following properties:
- There are no self-edges (
graph[u] does not contain u). - There are no parallel edges (
graph[u] does not contain duplicate values). - If
v is in graph[u], then u is in graph[v] (the graph is undirected). - The graph may not be connected, meaning there may be two nodes
u and v such that there is no path between them.
A graph is bipartite if the nodes can be partitioned into two independent sets A and B such that every edge in the graph connects a node in set A and a node in set B.
Return true if and only if it is bipartite.
Example 1:
Input: graph = [[1,2,3],[0,2],[0,1,3],[0,2]]
Output: false
Explanation: There is no way to partition the nodes into two independent sets such that every edge connects a node in one and a node in the other.
Example 2:
Input: graph = [[1,3],[0,2],[1,3],[0,2]]
Output: true
Explanation: We can partition the nodes into two sets: {0, 2} and {1, 3}.
Constraints:
graph.length == n1 <= n <= 1000 <= graph[u].length < n0 <= graph[u][i] <= n - 1graph[u] does not contain u.- All the values of
graph[u] are unique. - If
graph[u] contains v, then graph[v] contains u.
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| class Solution:
def isBipartite(self, graph: List[List[int]]) -> bool:
def dfs(u, c):
color[u] = c
for v in graph[u]:
if not color[v]:
if not dfs(v, 3 - c):
return False
elif color[v] == c:
return False
return True
n = len(graph)
color = [0] * n
for i in range(n):
if not color[i] and not dfs(i, 1):
return False
return True
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| class Solution {
private int[] color;
private int[][] g;
public boolean isBipartite(int[][] graph) {
int n = graph.length;
color = new int[n];
g = graph;
for (int i = 0; i < n; ++i) {
if (color[i] == 0 && !dfs(i, 1)) {
return false;
}
}
return true;
}
private boolean dfs(int u, int c) {
color[u] = c;
for (int v : g[u]) {
if (color[v] == 0) {
if (!dfs(v, 3 - c)) {
return false;
}
} else if (color[v] == c) {
return false;
}
}
return true;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class Solution {
public:
bool isBipartite(vector<vector<int>>& graph) {
int n = graph.size();
vector<int> color(n);
for (int i = 0; i < n; ++i)
if (!color[i] && !dfs(i, 1, color, graph))
return false;
return true;
}
bool dfs(int u, int c, vector<int>& color, vector<vector<int>>& g) {
color[u] = c;
for (int& v : g[u]) {
if (!color[v]) {
if (!dfs(v, 3 - c, color, g)) return false;
} else if (color[v] == c)
return false;
}
return true;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| func isBipartite(graph [][]int) bool {
n := len(graph)
color := make([]int, n)
var dfs func(u, c int) bool
dfs = func(u, c int) bool {
color[u] = c
for _, v := range graph[u] {
if color[v] == 0 {
if !dfs(v, 3-c) {
return false
}
} else if color[v] == c {
return false
}
}
return true
}
for i := range graph {
if color[i] == 0 && !dfs(i, 1) {
return false
}
}
return true
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| function isBipartite(graph: number[][]): boolean {
const n = graph.length;
let valid = true;
// 0 未遍历， 1 红色标记， 2 绿色标记
let colors = new Array(n).fill(0);
function dfs(idx: number, color: number, graph: number[][]) {
colors[idx] = color;
const nextColor = 3 - color;
for (let j of graph[idx]) {
if (!colors[j]) {
dfs(j, nextColor, graph);
if (!valid) return;
} else if (colors[j] != nextColor) {
valid = false;
return;
}
}
}
for (let i = 0; i < n && valid; i++) {
if (!colors[i]) {
dfs(i, 1, graph);
}
}
return valid;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
| impl Solution {
#[allow(dead_code)]
pub fn is_bipartite(graph: Vec<Vec<i32>>) -> bool {
let mut graph = graph;
let n = graph.len();
let mut color_vec: Vec<usize> = vec![0; n];
for i in 0..n {
if color_vec[i] == 0 && !Self::traverse(i, 1, &mut color_vec, &mut graph) {
return false;
}
}
true
}
#[allow(dead_code)]
fn traverse(
v: usize,
color: usize,
color_vec: &mut Vec<usize>,
graph: &mut Vec<Vec<i32>>
) -> bool {
color_vec[v] = color;
for n in graph[v].clone() {
if color_vec[n as usize] == 0 {
// This node hasn't been colored
if !Self::traverse(n as usize, 3 - color, color_vec, graph) {
return false;
}
} else if color_vec[n as usize] == color {
// The color is the same
return false;
}
}
true
}
}
|
Solution 2#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| class Solution:
def isBipartite(self, graph: List[List[int]]) -> bool:
def find(x):
if p[x] != x:
p[x] = find(p[x])
return p[x]
p = list(range(len(graph)))
for u, g in enumerate(graph):
for v in g:
if find(u) == find(v):
return False
p[find(v)] = find(g[0])
return True
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| class Solution {
private int[] p;
public boolean isBipartite(int[][] graph) {
int n = graph.length;
p = new int[n];
for (int i = 0; i < n; ++i) {
p[i] = i;
}
for (int u = 0; u < n; ++u) {
int[] g = graph[u];
for (int v : g) {
if (find(u) == find(v)) {
return false;
}
p[find(v)] = find(g[0]);
}
}
return true;
}
private int find(int x) {
if (p[x] != x) {
p[x] = find(p[x]);
}
return p[x];
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| class Solution {
public:
vector<int> p;
bool isBipartite(vector<vector<int>>& graph) {
int n = graph.size();
p.resize(n);
for (int i = 0; i < n; ++i) p[i] = i;
for (int u = 0; u < n; ++u) {
auto& g = graph[u];
for (int v : g) {
if (find(u) == find(v)) return 0;
p[find(v)] = find(g[0]);
}
}
return 1;
}
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| func isBipartite(graph [][]int) bool {
n := len(graph)
p := make([]int, n)
for i := range p {
p[i] = i
}
var find func(x int) int
find = func(x int) int {
if p[x] != x {
p[x] = find(p[x])
}
return p[x]
}
for u, g := range graph {
for _, v := range g {
if find(u) == find(v) {
return false
}
p[find(v)] = find(g[0])
}
}
return true
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| function isBipartite(graph: number[][]): boolean {
const n = graph.length;
let p = new Array(n);
for (let i = 0; i < n; ++i) {
p[i] = i;
}
function find(x) {
if (p[x] != x) {
p[x] = find(p[x]);
}
return p[x];
}
for (let u = 0; u < n; ++u) {
for (let v of graph[u]) {
if (find(u) == find(v)) {
return false;
}
p[find(v)] = find(graph[u][0]);
}
}
return true;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| impl Solution {
#[allow(dead_code)]
pub fn is_bipartite(graph: Vec<Vec<i32>>) -> bool {
let n = graph.len();
let mut disjoint_set: Vec<usize> = vec![0; n];
// Initialize the disjoint set
for i in 0..n {
disjoint_set[i] = i;
}
// Traverse the graph
for i in 0..n {
if graph[i].is_empty() {
continue;
}
let first = graph[i][0] as usize;
for v in &graph[i] {
let v = *v as usize;
let i_p = Self::find(i, &mut disjoint_set);
let v_p = Self::find(v, &mut disjoint_set);
if i_p == v_p {
return false;
}
// Otherwise, union the node
Self::union(first, v, &mut disjoint_set);
}
}
true
}
#[allow(dead_code)]
fn find(x: usize, d_set: &mut Vec<usize>) -> usize {
if d_set[x] != x {
d_set[x] = Self::find(d_set[x], d_set);
}
d_set[x]
}
#[allow(dead_code)]
fn union(x: usize, y: usize, d_set: &mut Vec<usize>) {
let p_x = Self::find(x, d_set);
let p_y = Self::find(y, d_set);
d_set[p_x] = p_y;
}
}
|
