图论知识点合集

本文主要内容来自acwing，增加了一些我的个人理解。（不包含dfs、bfs和最小生成树算法）

一、存储方式：

1.邻接表：

需注意，如果是无向图，需要正反使用两次add函数，且注意边数是否超标

/*
对于每个点k，开一个单链表，存储k所有可以走到的点；
此处使用数组模拟链表的方式，每次插入都在表头进行。
h[k]存储节点k对应单链表的头节点（位置）；
e[N]存储数据；
ne[N]表示next指针；
idx是一个计数器，表示当前总共用过了多少个节点，只会单调递增，用于添加边。
*/
int h[N], e[N], ne[N], idx;

// 添加一条边a->b
void add(int a, int b) {
	/*
	模拟链表的存储方式：
	首先新建一个节点并存储数据，然后将这个节点接在头节点下：
	先将这个节点的ne指向头节点的ne，然后将头节点的ne指向这个节点
	idx++为下一次新建节点做准备
	*/
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx;
	idx++;
}

// 初始化
void init() {
	idx = 0;
	memset(h, -1, sizeof h);//用-1表示空指针
}

2.邻接矩阵（略）

 二、最短路算法：

1.朴素dijkstra算法：

时间复杂度O(n^2+m)，适合少节点的稠密图，不适合用于存在负数权值的图。

从某一个节点出发，开始循环：每一次循环找到一个能到达的、未被连接的、到达路径最短的节点，并将其标记为已连接，再从这个节点出发遍历其所有相邻的节点，如果新到达的节点能获得比之前更短的路径，就更新到它的当前最短路径。

有多少个节点循环多少次，即可找到起始点到达所有节点的最短路径。

int g[N][N];  // 存储每条边，也可以用邻接表，但是此题中邻接矩阵更简单
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定
int n;  // 节点数

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

 2.堆优化dijkstra算法：

时间复杂度O(mlogn)，可用于多节点的稀疏图（少结点稠密图也可）。

相对于朴素dijkstra算法，优化了每次循环中找最短路节点的过程：使用小顶堆（代码中使用了优先队列，本质上与小顶堆相同）进行节点距离存储，从而可以快速地找到最短路节点。

#include<queue>
typedef pair<int, int> PII;
const int N = 100010;

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

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    /*
    优先队列，与队列相似，但是使用了堆排序的方式对数据进行了排序，
    定义方式：priority_queue<数据类型, 数据存储方式（一般用vector）<数据类型>, 升序或降序<数据类型>>
    */
    priority_queue<PII, vector<PII>, greater<PII>> heap;

    heap.push({ 0, 1 });      // first存储距离，second存储节点编号

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

 3.Bellman-Ford算法：

时间复杂度 O(nm)

可以用来解决限制路径长度的有负环问题：
限制路径长度为多少就循环多少次（不限制长度就有多少点循环多少次）；
每次循环遍历所有边，因此可以用最简单的方法（结构体或类）存储边，如果这条边可以使得它指向的点路径变短，就刷新对应点的路径长度。
实例：对于一条a指向b的权重为w的边，遍历到此条边的时候执行dist[b]=min(diat[b],dist[a]+w)

需要特别注意：当解决限制路径长度的问题时，为了避免串联（单次遍历所有边的过程中，先遍历的边对后遍历的边产生影响，从而导致超出路径长度限制），可以使用备份dist的方式：每次遍历所有边之前，将当前的dist备份至另一数组back中，然后接下来的所有对dist[a]的操作全部改为对back[a]的操作。

int n, m;       // n表示点数，m表示边数
int dist[N];        // dist[x]存储1到x的最短路距离

struct Edge     // 边，a表示出点，b表示入点，w表示边的权重
{
    int a, b, w;
}
edges[M];

// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
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[j].a, b = edges[j].b, w = edges[j].w;
            if (dist[b] > dist[a] + w)
                dist[b] = dist[a] + w;
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return -1;
    return dist[n];
}

4.spfa 算法：

时间复杂度：平均情况下 O(m)，最坏情况下 O(nm)

是优化后的Bellman-Ford算法：对于Bellman-Ford算法，dist[b] = dist[a] + w;语句有意义的前提是上一次遍历中dist[a]发生了改变（dist[a]不发生改变则dist[b]不可能发生改变），因此，只需要考虑那些前置节点发生了路径长度改变的节点：

使用宽搜思路实现：首先将一号节点存入队列，接下来进行循环（直到队列为空）：从队列中取出一个节点，遍历此节点所有的后继节点，如果能使得到达某一个后继节点的最短距离减小，就将此后继节点存至队列中。

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

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;
    q.push(1);
    st[1] = 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];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

5.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]);
}

三、最小生成树算法（略）

四、判断二分图：

在一张图中，如果能够把全部的点分到 两个集合 中，保证两个集合内部没有 任何边 ，图中的边 只存在于两个集合之间，这张图就是二分图

1.染色法：使用dfs（推荐）或bfs对所有的点进行染色（要考虑非连通图的情况），一个点与其所有相邻的点必是不同颜色，如果发生冲突则可说明不是二分图。

2.匈牙利算法：

时间复杂度是 O(nm)

作用是求二分图的最大匹配（将二分图的节点分为左右两边，有性质可知所有的边都连接了左边的点和右边的点，选择其中一些边（匹配），使得所有节点最多只有一条边与之连接，此即为最最大匹配）。

思路：每次选择左边中的一个点n1（右边也可），访问可与其相连（有边）的第一个右边的点r1，如果这个点未被其他左边的点（记为n2）相连，直接连接，否则进行回溯：看n2是否可以连接其他未被相连的点（如果不行就继续向上回溯，最终还是不行就表示n1连接失败），如果可以，就更改n2（多层回溯就是更改其他的点）的连接，并将n1连接到r1上。

int n1, n2;     // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx;     // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过（主函数中每次循环需要重新初始化一次，作用是保证主函数每次调用find函数时，第二个集合中的点最多只能被遍历一次）
void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
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 <= n1; i++){
    memset(st, false, sizeof st);
    if (find(i)) res++;
}