【代码模板】图论

图的存储

树是一种特殊的图，与图的存储方式相同。
对于无向图中的边ab，存储两条有向边a->b, b->a。
因此我们可以只考虑有向图的存储。
(1) 邻接矩阵：g[a][b] 存储边a->b
(2) 邻接表：

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

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

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

图的遍历

时间复杂度 \(O(n+m)\), \(n\)表示点数，\(m\) 表示边数
(1) 深度优先遍历

int dfs(int u)
{
    st[u] = true; // st[u] 表示点u已经被遍历过

    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j]) dfs(j);
    }
}

(2) 宽度优先遍历

queue<int> q;
st[1] = true; // 表示1号点已经被遍历过
q.push(1);

while (q.size())
{
    int t = q.front();
    q.pop();

    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true; // 表示点j已经被遍历过
            q.push(j);
        }
    }
}

拓扑排序

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

bool topsort()
{
    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+m)\), \(n\) 表示点数，\(m\) 表示边数

int g[N][N];//边数m远大于结点数n，为稠密图，用邻接矩阵存
int dist[N];//距离数组，表示当前的从1号点走到某个点的最短距离是多少(即当前点到起点的最短距离)
bool st[N];//标志数组，表示每个点的最短路是否被确定

int dijkstra()
{
    //1.dist[1] = 0, dist[i] = 0x3f3f3f3f
    memset(dist, 0x3f, sizeof(dist)); //所有节点到起点的距离初始化为正无穷
    dist[1] = 0;// 把1号点初始化为0,即起点到自己的距离为0

    //2.循环迭代n次，找出一个不在已访问集合中的距离最小的点t
    for (int i = 0; i < n; i++)//迭代n次，每次第一步先找最小值，每次可以确定一个点到起点的最短路
    {//找到当前没有确定最短路长度的点中距离最小的那一个
        int t = -1;
        for (int j = 1; j <= n; j++)
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        //3.将t加入已访问集合
        st[t] = true;//将t加到集合里面去

        //4.用t更新其他点的距离
        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], dist[t] + g[t][j]);
    }

    if (dist[n] == 0x3f3f3f3f) return -1;//如果起点1和n不连通（它们之间的距离是正无穷）,那么返回-1
    return dist[n];//否则的话返回起点到n号节点的最短距离
}

堆优化Dijkstra

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

typedef pair<int, int> PII;

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

Bellman-Ford算法

时间复杂度 \(O(nm)\), \(n\) 表示点数，\(m\) 表示边数
用于求不超过k条边的最短路

int dist[N], backup[N];//backup是备份数组

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

void bellman_ford()
{
    memset(dist, 0x3f, sizeof dist); //初始化
    dist[1] = 0;

    for(int i = 0; i < k; i++) //不超过k条边
    {
        memcpy(backup, dist, sizeof dist);//将dist上一次的状态拷贝到备份数组中去
        for(int j = 0; j < m; j++) //m为边数
        {
            int a = edges[j].a, b = edges[j].b, w = edges[j].w;
            dist[b] = min(dist[b], backup[a] + w);
        }
    }
}

SPFA(Shortest Path Faster Algorithm)

时间复杂度 平均情况下 \(O(m)\)，最坏情况下 \(O(nm)\), \(n\)表示点数，\(m\) 表示边数
手写循环队列:

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

int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    int hh = 0, tt = 1;
    q[0] = 1; //表示0号点入队，如果起点是S,则为q[0] = S;
    st[1] = true;

    while(hh != tt)
    {
        int t = q[hh ++];
        if(hh == N) hh = 0;

        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])
                {
                    q[tt ++] = j; //入队
                    if(tt == N) tt = 0;
                    st[j] = true; //标记入队
                }
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

STL循环队列

int spfa()
{
    //1.初始化dist[1] = 0, dist[i] = 0x3f3f3f3f
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    //2.初始化队列,将1加入队列
    queue<int> q;
    q.push(1);
    st[1] = true;

    //利用宽度优先搜索框架
    while(q.size())
    {
        auto t = q.front();//将队头元素赋值给t
        q.pop();//然后弹出t

        st[t] = false;//队头元素弹出后将其st中移除，st存的是某点是否在队列中

        for(int i = h[t]; i != -1; i = ne[i])//遍历访问t的所有出边
        {
            int j = e[i];//用j来存图中节点的编号
            if(dist[j] > dist[t] + w[i])//用t更新所有的出边
            {
                dist[j] = dist[t] + w[i];
                if(!st[j])//如果该结点不在队列中
                {
                    q.push(j);//加入队列中
                    st[j] = true;//更新队列标志数组
                }
            }
        }
    }
    if(dist[n] == 0x3f3f3f3f) return -1;//如果到n结点距离为无穷，则不存在最短路
    return dist[n];//否则返回最短路
}

SPFA判负环

/*
    如果cnt[x] >= n意味着从1到x至少经过了n条边
    即表示从1~x至少经过了n+1个点
    由抽屉原理，一共n个点，而这里经过了n+1个点，所以一定有两个点的值是相同的
    即表示当前路径上存在环
    而因为spfa更新的条件是有更小的边，所以存在环一定会变小
    变小的话一定就是负环，因为一个点不可能花更长的路径去到达它自己，
    因为它自己到自己的距离最小也是0，所以能让一个点到达它自己本身的一定是负权边
    即负环
*/
int h[N], e[N], w[N], ne[N], idx;
int dist[N],cnt[N]; //cnt[x]表示当前从1~x最短路的边数,dist[x]表示当前1~x最短路的距离
bool st[N];

bool spfa()
{
    //定义循环队列
    int hh = 0, tt = 0;
    /*
    这里不能只把1号点加进去了，因为本题判断的是是否存在负环
    而不是是否存在从1号点开始的负环
    应该把所有的点都加入队列
    */
    for (int i = 1; i <= n; i ++ )
    {
        st[i] = true;
        q[tt ++ ] = i;
    }

    while(hh != tt)
    {
        int t = q[hh ++];
        if(hh == N) hh = 0;

        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[tt ++ ] = j;
                    if(tt == N) tt = 0;
                    st[j] = true;
                }
            }
        }
    }
    return false;
}

Floyd

时间复杂度\(O(n^3)\)， \(n\)表示点数

初始化：
    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 dist[N]; //存集合与点的距离
int g[N][N]; //用邻接矩阵来存图
bool st[N]; //标记某个点是否在集合中

int prim()
{
    //1.dist[t] = 0x3f3f3f3f
    memset(dist, 0x3f, sizeof dist);

    int res = 0; //res用来存最小生成树的权值
    for(int i = 0; i < n; i ++ )
    {
        //2.每次找一个距离当前集合距离最小的点
        /*这里t = -1是为了方便初始化，因为在一开始我们要先选一个点，这个点其实没什么要求，习惯上我们选编号为1的结点
        下面的if条件中写了如果t == -1就更新t，t也可以写其他负值，如-2,-3等,只需要把下面if中也写成t == 自己设置的负值即可*/
        int t = -1;
        for(int j = 1; j <= n; j ++ )
            if(!st[j] && (t == -1 || dist[t] > dist[j])) //这里&&后面的要加括号，注意优先级
                t = j;


        /*这里很巧妙，因为i是从0开始的，所以可以直接用if(i)来判断是不是第一个点
        第一个点不用向res中加边，因为它没有边，只有一个孤零零的点，其次，如果某个点不是第一个点且其到集合的距离为无穷
        那就说明图不连通*/
        if(i && dist[t] == INF) return INF; //如果不是第一个点，且到集合的距离为无穷，则说明图不连通，返回INF
        if(i) res += dist[t]; /*此时经过上面if，走到这里一定是连通图，如果不是第一个节点，则将该结点到集合的距离加入到
        最小生成树的权值中去*/

        //3.然后用t更新其他点到集合的距离
        for(int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);

        //4.将这个结点加入到集合中去
        st[t] = true;

    }
    return res;
}

Kruskal算法

时间复杂度是 \(O(mlogm)\), \(n\) 表示点数，\(m\) 表示边数

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

struct Edge     // 存储边
{
    int a, b, w;

    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

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[N], e[M], ne[M], idx;     // 邻接表存储图
int color[N];       // 表示每个点的颜色，-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, 0))
            {
                flag = false;
                break;
            }
    return flag;
}

匈牙利算法

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

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

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