【图论】最短路径Floyd和Dijkstra算法

今天两个算法加上一个洛谷的DP题给我心态搞崩了。废话没有，开始写吧

Floyd算法（邻接矩阵实现）

适用性：邻接矩阵大小200*200以内的图==

优点：
1.能处理权值是负数的情况
2.代码简洁
3.处理所有点之间的最短路径

缺点:
由于使用了邻接矩阵计算过程中的大量无法避免的无效运算导致时间复杂度是立方级。

采用思想：动态规划（偏向 0-1背包一点）

模拟思想：

1.第一步，假设我们有一张含有n个点，m条边的图，每个边都有权值。
2.第二步，初始化第i个点直接到第j个点的花费（有边则花费是边的权值，没有边花费就是无穷）
3.第三步，设第一个点是中转节点k，我们的起点是i终点是j
那么有dp[i][j]=min(dp[i][k]+dp[k][j],dp[i][j])；
4.第四步，循环让每个点都以终点，起点，中转点的身份出现一次

以此推出核心代码
注意,上面说的i和j我在代码里换v和w了

 for(k = 0; k < vexnum; k++)
        for(v = 0 ; v < vexnum; v++)
            for(w =0; w < vexnum; w++)
                if(DP[v][w] > (DP[v][k] + DP[k][w]))
                    DP[v][w] = DP[v][k] + DP[k][w];

别的修饰等写完Dijkstra一起看

Dijkstra算法

适用性:边的权值都是正数的图

优点：
1.理解简单
2.每次处理一个点的所有路径，能减少不必要的计算，时间复杂度相对于Floyd降到了平方级别

缺点:不能处理边权值是负数的图

模拟思想

1.第一步，假设我们有一张含有n个点，m条边的图，每个边都有正数权值。
edge[i][j]作为从i到j的花费（边权值）
2.第二步，我们要找点v到所有点的最短路径，那么一开始存储下来和v直接到所有点的花费（有边则花费是边的权值，没有边花费就是无穷）
3.第三步，找到目前存储的花费中最小值，记录下这是v到哪个点的花费
比如最小花费是5，是v到1的花费，那么就记录下了5

4.第四步，对于除了1以外的所有点（假设为k），如果有从v到1的花费+从1到k的花费,小于,从v直接到该点的花费，则替换原本第二步所存储的直接到达该点的花费，替换成，从v到1的花费+从1到k的花费。
DP[k]=min(DP[k],DP[1]+edge[1][k])

由此写出核心代码

void Dijkstra(int v)
{
    int dis[1000];
    for(int i=0;i<n;i++)
    {
        dis[i]=edge[v][i];
    }
    for(int num=1;num<n;num++)
    {
        int k=mymin(dis);
        for(int i=0;i<n;i++)
        {
            if(dis[i]>dis[i]+edge[k][i])
            {
                dis[i]=dis[k]+edge[k][i];
            }
        }
        dis[k]=0;
    }
}

修饰后的Floyd和Dijkstra算法
Floyd

#include <bits/stdc++.h>
using namespace std;
#define INF 1000
struct graph
{
    int vexnum,edgnum,matirx[10][10];//邻接矩阵
};
int P[10][10];//记录对应点的最小路径的前驱点，例如p(1,3) = 2 说明顶点1到顶点3的最小路径要经过2
int D[10][10];//记录顶点间的最小路径值
void Floyd(graph G)
{
    int v, w, k;
    //初始化floyd算法的两个矩阵
    for(v = 0; v < G.vexnum; v++)
        for(w = 0; w < G.vexnum; w++)
        {
            D[v][w] = G.matirx[v][w];
            P[v][w] = w;
        }
    //k为中间点
    for(k = 0; k < G.vexnum; k++)
        //v为起点
        for(v = 0 ; v < G.vexnum; v++)
            //w为终点
            for(w =0; w < G.vexnum; w++)
                if(D[v][w] > (D[v][k] + D[k][w]))
                {
                    D[v][w] = D[v][k] + D[k][w];//更新最小路径
                    P[v][w] = P[v][k];//更新最小路径中间顶点
                }
}
int main()
{
    graph g;
    cin>>g.vexnum>>g.edgnum;
    for(int i=0;i<g.vexnum;i++)
        for(int j=0;j<g.vexnum;j++)
            g.matirx[i][j]=INF;
    for(int i=0;i<g.vexnum;i++)
        for(int j=0;j<g.vexnum;j++)
            cin>>g.matirx[i][j];
    Floyd(g);
}

Dijkstra

#include <iostream>

using namespace std;
int n,edge[1000][1000];
string vertex[1000];
int mymin(int dis[])
{
    int min1=0x7fffffff,pos=0;
    for(int i=0;i<n;i++)
    {
        if(dis[i]<min1)
        {
            pos=i;
            min1=dis[i];
        }
    }
    return pos;
}
void Dijkstra(int v)
{
    int dis[1000];
    string path[1000];
    for(int i=0;i<n;i++)
    {
        dis[i]=edge[v][i];
        if(dis[i]==0x7fffffff)
        {
            path[i]="";
        }
        else
            path[i]=vertex[i]+vertex[v];
    }
    for(int num=1;num<n;num++)
    {
        int k=mymin(dis);
        cout<<path[k]<<dis[k];
        for(int i=0;i<n;i++)
        {
            if(dis[i]>dis[i]+edge[k][i])
            {
                dis[i]=dis[k]+edge[k][i];
                path[i]=path[k]+vertex[i];
            }
        }
        dis[k]=0;
    }
}
int main()
{
    cout << "Hello world!" << endl;
    return 0;
}