【ACWing】860. 染色法判定二分图

题目地址：

https://www.acwing.com/problem/content/862/

给定一个$n$个点$m$条边的无向图，图中可能存在重边和自环。请你判断这个图是否是二分图。

输入格式：
第一行包含两个整数$n$和$m$。接下来$m$行，每行包含两个整数$u$和$v$，表示点$u$和点$v$之间存在一条边。

输出格式：
如果给定图是二分图，则输出“Yes”，否则输出“No”。

数据范围：
$1\le n,m\le 10^5$

法1：DFS，即染色法。每次对一个没颜色的点进行染色，一共只染两种颜色。如果在染色（DFS）的过程中发现了矛盾，则说明不存在合法的二染色（二染色的意思是可以将图中的顶点只染成两种颜色，使得对于任意边，其两个端点的颜色不同），说明不是二分图。代码如下：

#include <iostream>
#include <cstring>
using namespace std;

const int N = 100010, M = 2 * N;
int h[N], e[M], ne[M], idx;
int col[N];

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

bool dfs(int v, int c) {
    col[v] = c;
    for (int i = h[v]; ~i; i = ne[i]) {
        int j = e[i];
        // 有个邻接点已染色并且颜色和v一样，则矛盾
        if (col[j] == c) return false;
        // 遇到还未染色的点，则对其染不同于c的颜色，并继续DFS
        if (col[j] == -1 && !dfs(j, c ^ 1)) return false; 
    }

    return true;
}

int main() {
    int n, m;
    cin >> n >> m;

    memset(h, -1, sizeof h);
    // 初始颜色是-1，表示还未染色
    memset(col, -1, sizeof col);

    while (m--) {
        int a, b;
        cin >> a >> b;
        add(a, b), add(b, a);
    }

    bool res = true;
    for (int i = 1; i <= n; i++) 
        if (col[i] == -1 && !dfs(i, 0)) {
            res = false;
            break;
        }

    cout << (res ? "Yes" : "No") << endl;
    return 0;
}

时间复杂度$O(n+m)$，空间$O(n)$。

法2：BFS。思路和上面一样。代码如下：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

const int N = 1e5 + 10, M = 2 * N;
int n, m;
int h[N], e[M], ne[M], idx;
int col[N];

void add(int a, int b) {
  e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

// u是当前点，c是u应该要染成的颜色
bool bfs(int u) {
  col[u] = 0;
  queue<int> q;
  q.push(u);
  while (q.size()) {
    int t = q.front(); q.pop();
    for (int i = h[t]; ~i; i = ne[i]) {
      int v = e[i];
      if (col[v] == col[t]) return false;
      if (col[v] == -1) {
        col[v] = col[t] ^ 1;
        q.push(v);
      }
    }
  }
  
  return true;
}

int main() {
  scanf("%d%d", &n, &m);
  memset(h, -1, sizeof h);
  while (m--) {
    int a, b;
    scanf("%d%d", &a, &b);
    add(a, b), add(b, a);
  }
  
  memset(col, -1, sizeof col);
  bool res = true;
  for (int i = 1; i <= n; i++) {
    if (~col[i]) continue;
    if (!bfs(i)) {
      res = false;
      break;
    }
  }
  
  if (res) puts("Yes");
  else puts("No");
  return 0;
}

时空复杂度与上同。

法3：并查集。遍历所有点，对每个点，看一下它和它邻居是否在同一个集合里，如果在，说明有矛盾，不是二分图；同时，把所有邻居都union起来。代码如下：

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;

const int N = 1e5 + 10, M = 2 * N;
int n, m;
int h[N], e[M], ne[M], idx;
int p[N];

void add(int a, int b) {
  e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

int find(int x) {
  if (x != p[x]) p[x] = find(p[x]);
  return p[x];
}

int main() {
  scanf("%d%d", &n, &m);
  memset(h, -1, sizeof h);
  while (m--) {
    int a, b;
    scanf("%d%d", &a, &b);
    add(a, b), add(b, a);
  }
  
  for (int i = 1; i <= n; i++) p[i] = i;
  
  bool res = true;
  // 遍历所有的点
  for (int u = 1; u <= n; u++) {
    int t, pu = find(u);
    // 遍历u的所有邻居
    for (int j = h[u]; ~j; j = ne[j]) {
      int v = e[j], pv = find(v);
      if (pu == pv) {
        res = false;
        break;
      }
      // 如果j是第一条边，则t取第一个邻居的祖宗，
      // 否则将该邻居和第一个邻居合并起来
      if (j == h[u]) t = find(v);
      else p[pv] = t;
    }
  }
  
  cout << (res ? "Yes" : "No") << endl;
  return 0;
}

时间复杂度$O((n+m){\log }^{\ast }n)$，空间$O(n)$。