Question

785. Is Graph Bipartite

中文文档

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 == n
• 1 <= n <= 100
• 0 <= graph[u].length < n
• 0 <= graph[u][i] <= n - 1
• graph[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

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

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;
  }
}

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;
  }
};

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
}

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;
}

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

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

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];
  }
}

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];
  }
};

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
}

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;
}

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;
  }
}