数据结构——图——最短路径

系统管理员 2022-04-12 02:08 230阅读 0赞

### **Dijkstra单源最短路径算法** ###

给定一个带权[有向图][Link 1]G=（V,E），其中每条边的权是一个实数。另外，还给定V中的一个顶点，称为源。现在要计算从源到其他所有各顶点的[最短路径][Link 2]长度。这里的长度就是指路上各边权之和。这个问题通常称为单源最短路径问题。

**思路：**将图G中所有的顶点V分成两个顶点集合S和T。以v为源点已经确定了最短路径的终点并入S[集合][Link 3]中，S初始时只含顶点v,T则是尚未确定到源点v最短路径的顶点集合。然后每次从T集合中选择S集合点中到T路径最短的那个点，并加入到集合S中，并把这个点从集合T删除。直到T集合为空为止。

第一步：  
初始化点集Ｓ，将起点ｖ收入Ｓ中。初始化数组Ｄ：Ｄ\[k\]=a\[v\]\[k\];

第二步：找寻次短路径。即查找数组D找出观测域中最短路径（v，j）：D\[j\]=min(D\[k\]|k不属于S)。将j压入点集S中

第三步：将j的邻接点并入观测域，即用j的邻接点更新数组D：

如果D\[k\]>D\[j\]+a\[j\]\[k\] (k为j邻接点，k不属于S)  
令D\[k\]=D\[j\]+a\[j\]\[k\]  
如果D\[k\]>D\[j\]+a\[j\]\[k\] (k为j邻接点，k不属于S)  
不做操作

不断重复第二步和第三步直到找到全部节点为止。

/*代码是我摘的一个大佬的*/
     
    #include <iostream>
    #include<stack>
    #define M 100
    #define N 100
    using namespace std;
    
    typedef struct node
    {
        int matrix[N][M];      //邻接矩阵 
        int n;                 //顶点数 
        int e;                 //边数 
    }MGraph; 
    
    void DijkstraPath(MGraph g,int *dist,int *path,int v0)   //v0表示源顶点 
    {
        int i,j,k;
        bool *visited=(bool *)malloc(sizeof(bool)*g.n);
        for(i=0;i<g.n;i++)     //初始化 
        {
            if(g.matrix[v0][i]>0&&i!=v0)
            {
                dist[i]=g.matrix[v0][i];
                path[i]=v0;     //path记录最短路径上从v0到i的前一个顶点 
            }
            else
            {
                dist[i]=INT_MAX;    //若i不与v0直接相邻，则权值置为无穷大 
                path[i]=-1;
            }
            visited[i]=false;
            path[v0]=v0;
            dist[v0]=0;
        }
        visited[v0]=true;
        for(i=1;i<g.n;i++)     //循环扩展n-1次 
        {
            int min=INT_MAX;
            int u;
            for(j=0;j<g.n;j++)    //寻找未被扩展的权值最小的顶点 
            {
                if(visited[j]==false&&dist[j]<min)
                {
                    min=dist[j];
                    u=j;        
                }
            } 
            visited[u]=true;
            for(k=0;k<g.n;k++)   //更新dist数组的值和路径的值 
            {
                if(visited[k]==false&&g.matrix[u][k]>0&&min+g.matrix[u][k]<dist[k])
                {
                    dist[k]=min+g.matrix[u][k];
                    path[k]=u; 
                }
            }        
        }    
    }
    
    void showPath(int *path,int v,int v0)   //打印最短路径上的各个顶点 
    {
        stack<int> s;
        int u=v;
        while(v!=v0)
        {
            s.push(v);
            v=path[v];
        }
        s.push(v);
        while(!s.empty())
        {
            cout<<s.top()<<" ";
            s.pop();
        }
    } 
    
    int main(int argc, char *argv[])
    {
        int n,e;     //表示输入的顶点数和边数 
        while(cin>>n>>e&&e!=0)
        {
            int i,j;
            int s,t,w;      //表示存在一条边s->t,权值为w
            MGraph g;
            int v0;
            int *dist=(int *)malloc(sizeof(int)*n);
            int *path=(int *)malloc(sizeof(int)*n);
            for(i=0;i<N;i++)
                for(j=0;j<M;j++)
                    g.matrix[i][j]=0;
            g.n=n;
            g.e=e;
            for(i=0;i<e;i++)
            {
                cin>>s>>t>>w;
                g.matrix[s][t]=w;
            }
            cin>>v0;        //输入源顶点 
            DijkstraPath(g,dist,path,v0);
            for(i=0;i<n;i++)
            {
                if(i!=v0)
                {
                    showPath(path,i,v0);
                    cout<<dist[i]<<endl;
                }
            }
        }
        return 0;
    }

[实例：城市间紧急救援][Link 4]

### **Floyd算法多源路径算法:** ###

Floyd-Warshall算法是一种在具有正或负边缘权重（但没有负周期）的加权图中找到最短路径的算法。算法的单个执行将找到所有顶点对之间的最短路径的长度（加权）。

**算法过程**

1，从任意一条单边路径开始。所有两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大。

2，对于每一对顶点 u 和 v，看看是否存在一个顶点 w 使得从 u 到 w 再到 v 比已知的路径更短。如果是更新它。

把图用邻接矩阵G表示出来，如果从Vi到Vj有路可达，则G\[i\]\[j\]=d，d表示该路的长度；否则G\[i\]\[j\]=无穷大。定义一个矩阵D用来记录所插入点的信息，D\[i\]\[j\]表示从Vi到Vj需要经过的点，初始化D\[i\]\[j\]=j。把各个顶点插入图中，比较插点后的距离与原来的距离，G\[i\]\[j\] = min( G\[i\]\[j\], G\[i\]\[k\]+G\[k\]\[j\] )，如果G\[i\]\[j\]的值变小，则D\[i\]\[j\]=k。在G中包含有两点之间最短道路的信息，而在D中则包含了最短通路径的信息。

**时间复杂度与空间复杂度**

[时间复杂度][Link 5]:O(n^3)；

[空间复杂度][Link 6]:O(n^2)

#include <bits/stdc++.h>
    
    typedef long long LL;
    const int MAXN = 100;
    const int INF = 0x3f3f3f3f;
    using namespace std;
    
    int pre[MAXN + 3][MAXN + 3], dist[MAXN + 3][MAXN + 3]; //pre 储存路径; dist 存储最短距离
    void floyd(int n, int gra[][MAXN + 3]) {
        for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) dist[i][j] = gra[i][j], pre[i][j] = j;  //初始化
        for(int k = 1; k <= n; k++) {   //尝试经过 k 个点对每对顶点之间的距离进行更新
            for(int i = 1; i <= n; i++) {
                for(int j = 1; j <= n; j++) {
                    if(dist[i][k] != INF && dist[k][j] != INF && dist[i][k] + dist[k][j] < dist[i][j]) {
                        dist[i][j] = dist[i][k] + dist[k][j];
                        pre[i][j] = pre[i][k];
                    }
                }
            }
        }
    }
    
    int pfpath(int u, int v) { //打印最短路径
        while(u != v) {
            cout << u  << " ";
            u = pre[u][v];
        }
        cout << u << endl;
    }
    
    int gra[MAXN + 3][MAXN + 3];
    int main() {
        int n, m;
        while(cin >> n >> m){ // n 个点,  m 条边
            for(int i = 0; i <= n; i++) for(int j = -1; j <= n; j++){
                gra[i][j] = (i == j ? 0 : INF);
            }
            for(int i = 0; i < m; i++) {
                int u, v, w; cin >> u >> v >> w;
                gra[u][v] = gra[v][u] = w;  //无向图
            }
            floyd(n, gra);
        }
        return 0;
    }

[实例：天梯地图][Link 7]

[Link 1]: https://baike.baidu.com/item/%E6%9C%89%E5%90%91%E5%9B%BE/1852743
[Link 2]: https://baike.baidu.com/item/%E6%9C%80%E7%9F%AD%E8%B7%AF%E5%BE%84/6334920
[Link 3]: https://baike.baidu.com/item/%E9%9B%86%E5%90%88
[Link 4]: https://blog.csdn.net/qq_42623428/article/details/83098065
[Link 5]: https://baike.baidu.com/item/%E6%97%B6%E9%97%B4%E5%A4%8D%E6%9D%82%E5%BA%A6
[Link 6]: https://baike.baidu.com/item/%E7%A9%BA%E9%97%B4%E5%A4%8D%E6%9D%82%E5%BA%A6
[Link 7]: https://blog.csdn.net/qq_42623428/article/details/84198015