最短路

我的心愿是世界和平！

Dijkstra算法

Dijkstra算法解决的是图中单个源点到其它顶点的最短路径，只能解决权值非负。

#include<stdio.h>
#define max 0x3f3f3f3f
int m,n,i,j,min,now;
int map[110][110];//保存边权值.
int dis[110];//保存起始点到任意点之间的最短路.
int sign[110];//记录顶点是否被取到过.
void Dijkstra()
{
    for(i=1;i<=m;i++)
    {
        dis[i]=map[1][i];//起始点为1,记录起始点到任意点的直接距离.
        sign[i]=0;
    }
    sign[1]=1;
    dis[1]=0;
    for(i=1;i<m;i++)
    {
        min=max;
        now=max;
        for(j=1;j<=m;j++)
        {
            if(sign[j]==0&&dis[j]<min)
            {
                min=dis[j];
                now=j;
            }
        }
        sign[now]=1;
        for(j=1;j<=m;j++)
        {
            if(sign[j]==0&&dis[j]>dis[now]+map[now][j])//新加入一点,以其为插入点更新所有点.
                dis[j]=dis[now]+map[now][j];
        }
    }
    printf("%d\n",dis[m]);
}
int main()
{
    int x,y,z;
    while(scanf("%d%d",&m,&n))
    {
        if(m==0&&n==0)
            break;
        for(i=1;i<=m;i++)
        {
            for(j=1;j<=m;j++)
            {
                map[i][j]=max;
            }
        }
        for(i=1;i<=n;i++)
        {
            scanf("%d%d%d",&x,&y,&z);
            if(z<map[x][y])//存储最小权值.
            {
                map[x][y]=z;
                map[y][x]=z;//无向图.
            }
        }
        Dijkstra();
    }
    return 0;
}

Floyd算法

Floyd算法可以计算图中任意两点间的最短路径。

#include<stdio.h>
#define max 0x3f3f3f3f
int m,n,i,j,k;
int map[1000][1000];//最后记录任意两点间的最短路.
void Floyd()
{
    for(k=1; k<=m; k++)//枚举m个点来更新map.
    {
        for(i=1; i<=m; i++)
        {
            for(j=1; j<=m; j++)
            {
                if(map[i][j]>map[i][k]+map[k][j])
                    map[i][j]=map[i][k]+map[k][j];
            }
        }
    }
}
int main()
{
    int a,b,c;
    scanf("%d%d",&m,&n);
    for(i=1; i<=m; i++)
        for(j=1; j<=m; j++)
            map[i][j]=max;//更新为最大值.
    for(i=1;i<=n;i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        if(c<map[a][b])
            map[a][b]=map[b][a]=c;
    }
    Floyd();
    for(i=1;i<=m;i++)
    {
        for(j=1;j<=m;j++)
            printf("%d ",map[i][j]);
        printf("\n");
    }
    return 0;
}

bellman_ford算法

Bellman_Ford算法可以计算边权为负值的最短路问题，适用于有向图和无向图。用来求解源点到达任意点的最短路。

#include<stdio.h>
#define max 0x3f3f3f3f
int n,m,s,i,j,o;
struct Edge
{
    int u;
    int v;
    int cost;
} edge[210];
int dis[110];
int Bellman_Ford()
{
    for(i=1; i<=n; i++)
        dis[i]=max;//要求最大，初始化为最小值.
    dis[s]=0;//初始化结束.
    for(i=1; i<n; i++)//循环.
    {
        for(j=0; j<=m; j++)//对每条边进行松弛.
        {
            o=dis[edge[j].u]+edge[j].cost;
            if(dis[edge[j].v]>o)//松弛判断.
            {
                dis[edge[j].v]=dis[edge[j].u]+edge[j].cost;
            }
        }
    }
    for(j=0; j<=m; j++)
    {
        o=dis[edge[j].u]+edge[j].cost;
        if(dis[edge[j].v]>o)
            return 0;
    }
    return 1;
}
int main()
{
    int a,b,c;
    scanf("%d%d%d",&n,&m,&s);
    for(i=0; i<m; i++)
    {
        scanf("%d%d%d",&a,&b,&c);
        edge[i].u=edge[i+m].v=a;
        edge[i].v=edge[i+m].u=b;
        edge[i].cost=edge[i+m].cost=c;
    }
    m=2*m-1;
    if(Bellman_Ford())//如果没有负权.
        for(i=1; i<=n; i++) //每个点最短路.
        {
            printf("%d ", dis[i]);
        }
    else
        printf("have negative circle\n");
    return 0;
}