建图与链式前向星

建图与链式前向星

一、图的存储方式概览

图由节点和边组成,建图的核心问题就是:如何高效地存储边,并快速访问某个节点的所有邻居。

常见的三种方式:

  1. 邻接矩阵 — 简单但空间大
  2. 邻接表 — 最常用,工程和笔试首选
  3. 链式前向星 — 空间最省,比赛必用

二、邻接矩阵(简略)

用二维数组 graph[n][n] 存储边:

// graph[u][v] = w 表示 u -> v 有一条权值为 w 的边
// graph[u][v] = INF 表示没有边

特点:

  • 查询 (u, v) 是否有边:O(1)
  • 空间:O(n²)
  • 适用场景:节点数少(一般 n ≤ 1000~2000)的稠密图

对于 n = 10^5 的稀疏图,邻接矩阵需要 10^10 的空间,直接爆掉。

三、邻接表(简略)

用 vector 给每个节点维护一个“邻居列表”:

vector<vector<int>> adj(n + 1);              // 无权图
vector<vector<pair<int, int>>> adj(n + 1);   // 带权图:{邻居, 权值}

特点:

  • 空间:O(n + m)
  • 最常用的方式,适合绝大多数场景
  • 缺点是删除边不方便,某些高性能场景下不如链式前向星

四、链式前向星(重点)

4.1 为什么需要链式前向星

邻接表用 vector 虽然方便,但在空间要求严苛或需要高效删边、建反边的场景下会显得吃力。链式前向星用静态数组 + 链表头插法实现邻接表,空间紧凑、遍历高效,是算法竞赛中的标准做法。

4.2 三个核心数组

int head[N];    // head[u]:以 u 为起点的第一条边的编号
int to[M];      // to[i]:第 i 条边的终点
int nxt[M];     // nxt[i]:与第 i 条边同起点的下一条边
int cnt;        // 边的计数器,从 1 开始

如果边带权,再加一个数组:

int w[M];       // w[i]:第 i 条边的权值

关键理解:head[u] 指向的是一条“链表”的头部,这个链表串起了所有以 u 为起点的边。遍历 u 的出边,就是沿着 nxt 一路走。

4.3 加边:头插法

以有向边 u -> v 为例:

void add(int u, int v, int weight) {
    to[cnt] = v;          // 这条边的终点是 v
    w[cnt] = weight;      // 权值
    nxt[cnt] = head[u];   // 新边的下一条指向原来的“第一条边”
    head[u] = cnt;        // 更新“第一条边”为这条新边
    cnt++;
}

为什么是“头插法”:新加入的边直接成为链表头部,原来的第一条边被“挤”到后面。这样每次加边只需 O(1),不需要遍历。

4.4 遍历:访问 u 的所有出边

for (int i = head[u]; i != -1; i = nxt[i]) {
    int v = to[i];      // 边的终点
    int weight = w[i];  // 边的权值(如果有)
    // 处理这条边
}

注意:head 数组要初始化为 -1,表示“没有边”。遍历时从 head[u] 开始,沿着 nxt 一路走,直到 -1 结束。

4.5 无向图怎么办

无向图的一条边等于两条有向边,加两次即可:

add(u, v, w);
add(v, u, w);

技巧:如果 cnt 从 1 开始,那么第 i 条边和第 i^1 条边互为反向边。这个性质在网络流中非常有用。

五、三种方式对比

方式 空间 适用场景 特点
邻接矩阵 O(n²) 稠密图、n 小 查询快,浪费空间
邻接表 O(n+m) 通用,最常用 简单灵活,工程首选
链式前向星 O(n+m) 竞赛、高性能场景 空间省、遍历快、支持删边/反边

建议:笔试面试用邻接表,比赛用链式前向星,因为比赛平台可能卡空间。

六、模板代码(链式前向星)

#include<bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5;   // 最大节点数
const int M = 2e5 + 5;   // 最大边数(无向图要乘 2)

int head[N];
int to[M], nxt[M], w[M];
int cnt = 1;              // 边编号从 1 开始

void add(int u, int v, int weight) {
    to[cnt] = v;
    w[cnt] = weight;
    nxt[cnt] = head[u];
    head[u] = cnt;
    cnt++;
}

void init(int n) {
    cnt = 1;
    memset(head, -1, sizeof(int) * (n + 1));
}

int main() {
    int n, m;
    cin >> n >> m;
    init(n);
    for (int i = 0; i < m; i++) {
        int u, v, weight;
        cin >> u >> v >> weight;
        add(u, v, weight);      // 有向图
        // add(v, u, weight);   // 无向图再加一次
    }

    // 遍历节点 u 的所有出边
    int u = 1;
    for (int i = head[u]; i != -1; i = nxt[i]) {
        cout << u << " -> " << to[i] << " (w=" << w[i] << ")\n";
    }
    return 0;
}

七、易错点

  • head 数组必须初始化为 -1,不是 0
  • 无向图边数要开两倍:M = 2 * m + 5
  • 遍历终止条件是 i != -1,不是 i != 0
  • 如果边带权,w 数组不要忘记存
  • cnt 从 1 开始是为了让 i ^ 1 能取到反向边(网络流常用)

八、总结

链式前向星的核心就是 head + to + nxt 三个数组,用头插法模拟邻接表。

  • 加边:O(1),头插
  • 遍历出边:O(出度)
  • 空间:O(n + m),非常紧凑

记住模板,比赛时直接套用即可。

posted @ 2026-10-03 11:06  leaderling  阅读(33)  评论(0)    收藏  举报