最短路径Floyed算法

使用有向图的邻接矩阵的概念，代码如下：

struct Graph
{
    int vertex[vertexnum];/*?¨μ?±í*/
    int edges[vertexnum][vertexnum];/*áú?ó???ó*/
    int n,e/*í??Dμ??￥μ?êyoí±?êy*/
}g;

void Floyd()
{
    int A[mxav][mxav];
    int path[maxv][maxv];
    int n=g.n;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            A[i][j]=g.edges[i][j];
            path[i][j]=-1;
        }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n;j++)
        {
            for(int k=0;k<n;k++)
            {
                if(A[j][k]>A[j][i]+A[i][k])
                {
                    A[j][k]=A[j][i]+A[i][k];
                    path[j][k]=i;
                }
            }
        }
    }
}

这是只过一个中继点的情况（应该是吧。。。），对其进行优化后发现可以进行动态规划，代码如下：

#include<bits\stdc++.h>
using namespace std;
const int maxn=100;

int main()
{
    int n,m;
    int t1,t2,t3;
    int e[maxn][maxn];
    int inf=0x3fffffff;
    scanf("%d %d",&n,&m);
    /*3?ê??ˉ*/
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            if(i==j)
            {
                e[i][j]=0;
            }
            else
            {
                e[i][j]=inf;
            }
        }
    }
    /*?áè?±?*/
    for(int i=1;i<=m;i++)
    {
        scanf("%d %d %d",&t1,&t2,&t3);
        e[t1][t2]=t3;
    }
    /*o?D???·¨ó???*/
    for(int k=1;k<=n;k++)
    {
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(e[i][k]<inf&&e[k][j]<inf&&e[i][j]>e[i][k]+e[k][j])
                {
                    e[i][j]=e[i][k]+e[k][j];
                }
            }
        }
    }
    //ê?3?×???μ??á1?
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=n;j++)
        {
            printf("%10d",e[i][j]);
        }
        printf("\n");
    }
    return 0;
}

抽象理解就是先算u，v只经过第1个点的最短路径，然后在此基础上再算过第1，2个点的最短路径，动态方程为a[i][j]=min(a[i][j],a[i][k]+a[k][j]),之后矩阵中存的即为第i个点到第j个点的最短路径；

原文地址：https://www.cnblogs.com/KasenBob/p/10274870.html