数据结构与算法 模板 图论部分

Data Structure and Algorithm Template

Chapter3. 图论

树和图的存储

图是一群点构成的集合, 点与点直接由边连接, 边可能有方向, 也可能没有方向, 可能带有权值, 也可能没有权值

树是一种特殊的图, 存储方式与图相同

考虑使用邻接表存储

// 对于每个点k, 开一个单链表, 存储k所有可以走到的点, h[k]存储这个单链表的头节点
int h[maxn], e[maxn], ne[maxn], idx;

// 添加一条边a->b
void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}

// 初始化
void init() {
    idx = 0;
    memset(h, -1, sizeof(h));
}

树与图的DFS

int dfs(int u) {
    st[u] = true; // 标记u已经走过
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (!st[j]) dfs(j);
    }
}

树和图的BFS

queue<int> que;
st[1] = true; // 表示1号点已经走过
que.push(1);

while (!que.empty()) {
    int t = que.front();
    que.pop();
    for (int i = h[t]; i != -1; i = ne[i]) {
        int j = e[i];
        if (!st[j]) {
            st[j] = true;
            que.push(j);
        }
    }
}

拓扑排序

时间复杂度 $O(n+m)$, n表示点数， m表示边数

bool toposort() {
    int hh = 0, tt = -1;
    // d[i] 存储i点的入度
    for (int i = 1; i <= n; i++) {
        if (!d[i]) q[++tt] = i;
    }
    while (hh <= tt) {
        int t = q[hh++];
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (--d[j] == 0) {
                q[++tt] = j;
            }
        }
    }
    // 如果所有点都入队了, 说明存在拓扑序列; 否则不存在拓扑序列
    return tt == n - 1;
}

最短路算法

朴素Dijkstra算法

适用于单源最短路, 所有边权都是正数, 时间复杂度 $O(n^2)$

int g[maxn][maxn]; // 存储每条边
int dist[maxn]; // 存储1号点到每个点的最短距离
bool st[maxn]; // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路, 如果不存在就返回-1
int dijkstra() {
   memset(dist, 0x3f, sizeof(dist));
   dist[1] = 0;
   for (int i = 0; i < n - 1; i++) {
       int t = -1; // 在还未确定最短路的点中, 寻找距离最小的点
       for (int j = 1; j <= n; j++) {
           if (!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
       }
       // 用t更新其他点的距离
       for (int j = 1; j <= n; j++) {
           dist[j] = min(dist[j], dist[t] + g[t][j]);
       }
       st[t] = true;
   }
   if (dist[n] == 0x3f3f3f3f) return -1;
   return dist[n];
}

堆优化版的Dijkstra算法

适用于单源最短路, 所有边权都是正数, 时间复杂度 $O(m\log n)$

typedef pair<int, int> pii;

int n; // 点的数量
int h[maxn], w[maxn], e[maxn], ne[maxn], idx; // 邻接表存储所有边
int dist[maxn]; // 存储所有点到1号点的距离
bool st[maxn]; // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离, 如果不存在, 则返回-1
int dijkstra() {
    memset(dist, 0x3f, sizeof(dist));
    dist[1] = 0;
    priority_queue<pii, vector<pii>, greater<pii>> heap;
    heap.push({0, 1});
    
    while (heap.size()) {
        auto t = heap.top();
        heap.pop();
        int ver = t.second, distance = t.first;
        if (st[ver]) continue;
        st[ver] = true;
        for (int i = h[ver]; i != -1; i = ne[i]) {
            int j = e[i];
            if (dist[j] > distance + w[i]) {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

Bellman-Ford

适用于单源最短路, 存在负权边, 时间复杂度 $O(nm)$

int n, m;
int dist[maxn];

struct Edge {
	int a, b, w;
}edges[maxn];

int bellman_ford() {
    memset(dist, 0x3f, sizeof(dist));
    dist[1] = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int a = edges[i].a, b = edges[i].b, w = edges[i].w;
            if (dist[b] < dist[a] + w) {
                dist[b] = dist[a] + w;
            }
        }
    }
    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

SPFA

适用于单源最短路, 存在负权边, 一般情况下时间复杂度 $O(m)$, 最坏时间复杂度 $O(nm)$

int n; // 总点数
int h[maxn], w[maxn], e[maxn], ne[maxn], idx; // 邻接表存储所有边
int dist[maxn], cnt[maxn]; // dist[maxn]存储1号点到x的最短距离, cnt[x]存储1到x的最短路中经过的点数
bool st[maxn]; // 存储每个点是否在队列中

// 如果存在负环, 则返回true, 否则返回false
bool spfa() {
	// 不需要初始化dist数组
    // 原理: 如果某条最短路径上有n个点(除了自己),  那么加上自己之后一共有n+1个点, 由抽屉原理一定有两个点相同, 所有存在环
    queue<int> q;
    for (int i = 1; i <= n; i++) {
        q.push(i);
        st[i] = true;
    }
    while (q.size()) {
        auto t = q.front();
        q.pop();
        st[t] = false;
        for (int i = h[t]; i != -1; i = ne[i]) {
            int j = e[i];
            if (dist[j] > dist[t] + w[i]) {
                dist[j] = dist[t] + w[i];
                cnt[j] = cnt[t] + 1;
                if (cnt[j] >= n) return true;
                if (!st[j]) {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }
    return false;
}

Floyd

适用于多源最短路, 时间复杂度 $O(n^3)$

// 初始化:
for (int i = 1; i <= n; i++) {
    for (int j = 1; j <= n; j++) {
        if (i == j) {
            d[i][j] = 0;
        } else {
            d[i][j] = INF;
        }
    }
}

// 算法结束后, d[a][b]表示a到b最短距离
void floyd() {
    for (int k = 1; k <= n; k++) {
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
}

最小生成树

朴素版Prim算法

时间复杂度是 $O(n^2+m)$ , n表示点数, m表示边数

int n; // n表示点数
int g[maxn][maxn]; // 邻接矩阵, 存储所有边
int dist[maxn]; // 存储其他点到当前最小生成树的距离
bool st[maxn]; // 存储每个点是否已经在生成树中

// 如果图不连通, 则返回INF(0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim() {
    memset(dist, 0x3f, sizeof(dist));
    int res = 0;
    for (int i = 0; i < n; i++) {
        int t = -1;
        for (int j = 1; j <= n; j++) {
            if (!st[j] && (t == -1 || dist[t] > dist[j])) t = j;
        }
        if (i && dist[t] == INF) return INF;
        if (i) res += dist[t];
        st[t] = true;
    	for (int j = 1; j <= n; j++) dist[j] = min(dist[j], g[t][j]);
    }
    return res;
}

Kruskal算法

时间复杂度$O(m\log m)$, n表示点数, m表示边数

int n, m; // n是点数, m是边数
int p[maxn]; // 并查集的父节点数组

struct Edge {
  	int a, b, w;
    bool operator< (const Edge &W)const {
        return w < W.w;
    }
}edges[maxm];

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

int kruskal() {
    sort(edges, edges + m);
    for (int i = 1; i <= n; i++) {
        p[i] = i;
    }
    int res = 0, cnt = 0;
    for (int i = 0; i < m; i++) {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;
        a = find(a), b = find(b);
        if (a != b) {
            p[a] = b;
            res += w;
            cnt++;
        }
    }
    if (cnt < n - 1) return INF;
    return res;
}

染色法判别二分图

时间复杂度 $O(n+m)$, n表示点数, m表示边数

int n; // n表示点数
int h[maxn], e[maxn], ne[maxn], idx; // 邻接表存储图
int color[maxn]; // 表示每个点的颜色, -1表示未染色, 0表示白色, 1表示黑色

// 参数: u表示当前节点, c表示当前点的颜色
bool dfs(int u, int c) {
    color[u] = c;
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i];
        if (color[j] == -1) {
            if (!dfs(j, !c)) return false;
        } else if (color[j] == c) return false;
    }
    return true;
}

bool check() {
    memset(color, -1, sizeof(color));
    bool flag = true;
    for (int i = 1; i <= n; i++) {
        if (color[i] == -1) {
            if (!dfs(i, 1)) {
                flag = false;
                break;
            }
        }
    }
    return flag;
}

匈牙利算法

时间复杂度是 $O(nm)$, n表示点数, m表示边数

int n1, n2; // n1表示第一个集合中的点数, n2表示第二个集合中的点数
int h[maxn], e[maxm], ne[maxm], idx; // 邻接表存储所有边, 匈牙利算法中只会用到第一个集合指向第二个集合的边, 蓑衣这里只用存一个方向的边
int match[maxn]; // 存储第二个
bool st[maxn]; // 表示第二个集合中的每个点是否已经被遍历过

bool find(int x) {
    for (int i = h[x]; i != -1; i = ne[i]) {
        int j = e[i];
        if (!st[j]) {
            st[j] = true;
            if (match[j] == 0 || find(match[j])) {
                match[j] = x;
                return true;
            }
        }
    }
    return false;
}

// 求最大匹配数, 依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n; i++) {
    memset(st, false, sizeof(st));
    if (find(i)) res++;
}