六图

Vwsrenzk

于 2020-07-29 17:53:29 发布

阅读量456

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构

本文链接：https://blog.csdn.net/ayyyyy_zc/article/details/107670371

数据结构专栏收录该内容

12 篇文章

订阅专栏

本文深入解析了图论中的三种核心算法：Prim算法、Kruskal算法和Dijkstra算法，分别用于寻找最小生成树和单源最短路径。通过详细的代码示例和理论解释，帮助读者理解算法的工作原理和适用场景。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最小生成树

prim

Prim是一种增量算法，每次选择代价最小的边加入生成树，然后根据新加的节点更新备选节点的代价。
通俗来说就是从起点开始，用贪心策略每次加入一个节点到现有的集合（这个集合连通的），直到最后所有节点都加入。
时间复杂度为o（n^2）。适合稠密图

const int INF = 0x3f3f3f3f;
const int maxn = 110;
int lowcost[maxn];
int closest[maxn];
//点从 0 到 n-1
void prim(int cost[][maxn], int n, int st) {
    int MIN, k;
    for(int i = 0; i < n; i++) { //以st为起点。
        lowcost[i] = cost[st][i];
        closest[i] = st;
    }
    for(int i = 1; i < n; i++) { //找出另外n-1个点
        MIN = INF;
        for(int j = 0; j < n; j++) { //在所有备选的点中找到代价最小的
            if(lowcost[j] != 0 && lowcost[j] < MIN) {
                MIN = lowcost[j];
                k = j; //用k保存下一个入生成树的节点
            }
        }
        printf("边（%d,%d）权为：%d\n", closest[k], k, MIN);
        lowcost[k] = 0; //标记k已经在生成树
        for(int j = 0; j < n; j++) { //更新备选节点的代价
            if(lowcost[j] != 0 && cost[k][j] < lowcost[j]) {
                lowcost[j] = cost[k][j]; 
                closest[j] = k; //这时候j的上一个节点就是k
            }
        }
    }
}

Kruskal

Kruskal按照边权值大小排序，然后从小到大选择最小边加入生成树（前提是没有回路，如果变成回路就舍弃判断下一条边），与Prim不同的是当前的图不一定连通的。
下面代码是邻接表实现的，时间复杂度是o（eloge），e是边数，所以它适合稀疏图。

const int maxm = 1e4 + 10;
int F[maxn]; // 并查集FIND[]
struct Edge {
    int u, v, w;
} edge[maxm]; //存储边，起点，终点，权值
int tol; //边数
void addedge(int u, int v, int w) { //加边函数
    edge[tol].u = u;
    edge[tol].v = v;
    edge[tol++].w = w;
}
//按照权值大小排序
bool cmp(Edge a, Edge b) {
    return a.w < b.w;
}
//并查集
int find_(int x) {
    return (F[x] == -1) ? x : (F[x] = find_(F[x]));
}
//false时不是连通图
bool Kruskal(int n) {
    memset(F, -1, sizeof(F));
    sort(edge, edge + tol, cmp); //边排序
    int cnt = 0; //记录加的边数
    for(int i = 0; i < tol; i++) {
        int u = edge[i].u;
        int v = edge[i].v;
        int w = edge[i].w;
        int t1 = find_(u);
        int t2 = find_(v);
        if(t1 != t2) { //不是回路
            printf("边（%d,%d）权为：%d\n", u, v, w); 
            F[t1] = t2;
            cnt++;
        }
        if(cnt == n - 1)
            break;
    }
    return (cnt == n - 1);
}

最短路径

单源最短路Dijkstra

感觉和Prim算法思路相似，每次用贪心策略找当前最优节点k加入集合S，之后用k节点更新不在S集合的节点的最短路径长度。代码也十分相似，时间复杂度同为O(n^2)。
用到的理论是，若从源点s到顶点j的最短路径是（s…i…u,j）也就是代码中的pre[j] = u。那么（s…i…u）一定是s到u的最短路径。（反证法可以证明）

bool vis[maxn];
int pre[maxn];
int cost[maxn][maxn];
int lowcost[maxn];
void Dijkstra(int n, int st) {

    for(int i = 0; i < n; i++) { //初始化
        lowcost[i] = INF;
        vis[i] = false;
        pre[i] = -1;
    }
    lowcost[st] = 0; //源点dist

    for(int j = 0; j < n; j++) { //这份代码一开始源点也没有在集合S中，所以要循环n次

        int k = -1; //找vis[k]==false且具有最小路径长度的顶点k
        int Min = INF;
        for(int i = 0; i < n; i++) {
            if(!vis[i] && lowcost[i] < Min) {
                Min = lowcost[i];
                k = i;
            }
        }

        if(k == -1)
            break;

        vis[k] = true; //标记k已经进入S集合
        for(int i = 0; i < n; i++) {
            if(!vis[i] && lowcost[k] + cost[k][i] < lowcost[i]) { //根据新进来的k顶点修改不在S集合顶点的最小路径长度
                lowcost[i] = lowcost[k] + cost[k][i];
                pre[i] = k; //标记i顶点的路径的前一个顶点为k
            }
        }
    }

}

Floyd

思想就是用矩阵序列 $A_0,A_1...A_k...A_n$ ，其中矩阵 $A_k$ 的 $A_k[i][j]$ 表示 $i$ 到 $j$ 的路径上所经过的顶点编号不大于 $k$ 的最短路径长度。
假如 $A_k$ 已经求出，考虑加入顶点 $k + 1$ 。此时从 $i$ 到 $j$ 就有2种路径长度

$A_k[i][j]$
$A_k[i][k+1] + A_k[k+1][j]$
所以就用三重循环暴力，第一层就代表每次考虑用k顶点作为中间顶点。

int A[maxn][maxn], path[maxn][maxn];
void Floyd(int n) {
    for(int i = 0; i < n; i++) //初始化
        for(int j = 0; j < n; j++) {
            A[i][j] = cost[i][j];
            path[i][j] = ((cost[i][j] < INF) ? i : -1);
        }
    for(int i = 0; i < n; i++)
        path[i][i] = -1;
    for(int k = 0; k < n; k++) { //考虑每个顶点作为中间顶点
        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                if(A[i][j] > A[i][k] + A[k][j]) {
                    A[i][j] = A[i][k] + A[k][j]; //更新
                    path[i][j] = path[k][j];
                }
    }
}

拓扑排序

循环以下2步直到不存在入度为0的顶点

选择一个入度为0的顶点输出
从网中删除此顶点以及它的所有出边

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

const int maxn = 1e4 + 5;
vector<int> G[maxn];
int in[maxn],seq[maxn];
int n,m,cnt = 0;

void topology(){
    for(int i = 1;i <= n;i++){
        if(in[i] == 0) seq[++cnt] = i;
    }
    int head = 1;
    while(head <= cnt){
        int u = seq[head];
        for(int i = 0;i < G[u].size();i++){
            int v = G[u][i];
            in[v]--;
            if(in[v] == 0) seq[++cnt] = v;
        }
        head++;
    }
    //当cnt不等于n时，说明这图有环
}

int main(){ 
    scanf("%d %d",&n,&m);
    for(int i = 1;i <= m;i++){
        int x,y;
        scanf("%d %d",&x,&y);
        G[x].push_back(y);
        in[y]++;;
    }
    topology();
    for(int i = 1;i <= cnt;i++) printf("%d\n",seq[i]);
}