最短路问题DijKstra算法Bellman-Ford和spfa算法

DijKstra算法核心在于一个数组d[Max],d[i]表示的是i这个节点距离中央节点的距离,算法想要实现得就是一步一步的更新d[Max],知道所有的点都被访问连接过才可退出

准备阶段

int n,m,s,e;
int mp[210][210];
int d[210];
int vis[210];

n,m是有n个点,m条边,s是开始点(中央节点与d[Max]数组有关),所求最短路的点是e

mp[i][j]二维数组存放的是i点到j点的距离

输入与清空阶段

while(scanf("%d %d",&n,&m) == 2)
    {
        getchar();
        memset(vis,0,sizeof(vis));
        memset(d,0,sizeof(d));
        for(int i = 0;i < 210;i++)
        {
            for(int j = 0;j < 210;j++)
            {
                if(i == j)mp[i][j] = 0;
                else mp[i][j] = mp[j][i] = inf;
            }
        }

        for(int i = 0;i < m;i++)
        {
            scanf("%d %d %d",&a,&b,&x);
            getchar();
            if(mp[a][b] > x)mp[a][b] = mp[b][a] = x;//防止两个点之间出现多条路径的问题,只记录最短的路径
            
        }
        scanf("%d %d",&s,&e);
        getchar();
        Dijkstra(s,e);
    }

更新mp数组,除非为mp[i][i]赋值为零,其余均赋值为inf(较大的值),这是为了表示未知4距离,方便后续的输入更新mp

输入更新时要小心两点多路的情况,最后只要记录最短的一条路就好

寻找最短路dijkscar算法

 int next;
    //输入顶点s
    for(int i = 0;i < 210;i++)
    {
        d[i] = mp[s][i];
    }
    vis[s] = 1;
    for(int i = 0;i < 210;i++)
    {
        //循环找点
        int minnum = inf;
        for(int j = 0;j < 210;j++)
        {
            if(!vis[j] && d[j] < minnum)
            {
                minnum = d[j];
                next = j;
            }
        }
        if(minnum == inf)
        {
            break;
        }
        vis[next] = 1;
        //找到点相连
        for(int j = 0;j < 210;j++)
        {
            if(!vis[j] && d[j] > mp[next][j] + d[next])//可以松弛
            {
                d[j] = mp[next][j] + d[next];
            }
        }
    }
if(d[e] != inf)
    printf("%d\n",d[e]);
else
    printf("-1\n");

先根据中央节点s所连接的边,更新一波d[i]数组,这样你有了一个点一组线,接着去寻找这组线中最短的然后走过去(更新vis数组)这样你有了两个点一组线,其中一个线还已经走过了(强烈建议画一下)根据你刚刚找到的那个点所连接的边,更新一波d[i]数组(这里专业一点叫松弛),对于每一个线,需要判断的是——它所下接的点有没有访问过,这条线的开头(s中央节点)到结尾(第一个下接的点)的距离,是不是比当前d[
]数组里存的小,只有小才有更新的必要嘛(这也是为什么一开始mp二维数组初始化为inf的原因)

就这样直到循环到没点可寻~~

但是对于dijkscar算法有一个致命性的弱点,就是如果有负权回路的情况出现呢,由于你的vis数组导致你求出的最短路错误,因为负权回路的出现,会导致没有最短路

在这里要特别注意一下,应为平常我们考虑的都是双向边,所以只要你输入的边值为负就已经是一条负权回路了。

这里以hdu2544经典模板题为例

首先进行准备阶段

int N,M;
struct edge
{
    int from;
    int to;
    int cost;
}e[10010];
int d[110];
void init()
{
    memset(e,0,sizeof(e));
}

相信这些的含义你都能看懂的,和bijkscar算法的差不多

接下来是输入与清空阶段

while(scanf("%d %d",&N,&M) == 2)
    {
        getchar();
        if(!N && !M)break;
        init();
        for(int i = 1;i <= M * 2;i ++)
        {
            scanf("%d%d%d",&e[i].from,&e[i].to,&e[i].cost);
            i++;
            e[i].from = e[i - 1].to;//双向边
            e[i].to = e[i - 1].from;
            e[i].cost = e[i - 1].cost;
            getchar();
        }
        if(Bellman(1,N))
        {
            printf("%d\n",d[N]);
        }
        else
        {
            cout<<"no way,there is a negetive circle"<<endl;
        }
    }

注意一下双向边的输入问题就好了

接下来是Bellman-Ford算法

for(int i = 1;i <= N;i++)
    {
        if(i != s)d[i] = inf;
        else d[i] = 0;
    }

开头一个独立的for循环仅有d[s]会被更新为0

for(int i = 2;i <= N;i++)
    {
        for(int j = 1; j <= M * 2;j++)
        {
            if(d[e[j].to] > d[e[j].from] + e[j].cost)
            {
                d[e[j].to] = d[e[j].from] + e[j].cost;
            }
        }
    }

然后第二个独立的for循环

i所控制的是你的更新次数,因为每一次更新你肯定都会确定一个点的最短路,n个点我们需要n次更新

j所控制的就是遍历所有的边

就下来的松弛(优化)判断思想和dijkscar算类似

    int flag = 1;
    for(int j = 1; j <= M * 2;j++)
    {
        if(  d[e[j].to] > d[e[j].from] + e[j].cost  )
        {
            flag = 0;
            break;
        }
    }
    return flag;

接下来是负权回路的判断

你再进行更新一次,如果还能更新,那就肯定存在负权回路了

其实你可以发现,这一个for循环明显就是从上一个for循环了拆出来的一个小分之嘛,把上面for循环的i初始值设为1,内部加一个判断,这里就可以省去了,方便理解~~

仍然是2544这个题,接下来是spfa算法,最常用的算法

spfa是针对点来进行操作的(针对点有没有让你联想到prim算法——针对点求最小生成树)

对于针对点的算法,我们就会分为两种思路——第一种是链式前向星,第二种是二维结构体动态数组

先来在回顾一遍链式前向星的应用

准备阶段

using namespace std;
struct edge{
    //int from;
    int to;
    int cost;
    int reid;
}e[20010];
int N,M,cnt;
int vis[110];
int id[110];
int time[110];
int d[110];

reid是用来将这个点所包含的边前后链接起来的变量

time数组是用来判断有没有负权回路的情况

输入与清空

while(scanf("%d %d",&N,&M) != EOF)
    {
        getchar();
        if(!N && !M)break;
        init();
        for(int i = 1;i <= M;i++)
        {
            int a,b,x;
            scanf("%d%d%d",&a,&b,&x);
            getchar();
            add(a,b,x);//我这里默认为双向边,所以一旦有一个负数边的出现就是负环的出现
            add(b,a,x);
void add(int from,int to,int cost)
{
    e[cnt].to = to;
    e[cnt].cost = cost;
    e[cnt].reid = id[from];
    id[from] = cnt;
    cnt++;
}
void init()
{
    for(int i = 0;i < 110;i++)
    {
        d[i] = inf;
        id[i] = -1;
    }
    cnt = 0;
    memset(e,0,sizeof(e));
    memset(vis,0,sizeof(vis));
    memset(time,0,sizeof(time));
}

先来看看init()函数的初始化,d[i]数组仍然初始化为最大值,id[i]数组初始化为-1——代表的含义是i点所连接边的下标是-1就是还未知所连接的下标,cnt初始化为0,它是所有边得下标变量

 然后spfa算法

queue<int> q;
    q.push(S);
    vis[S] = 1;
    d[S] = 0;
    int flag = 0;

先把中央节点push进去,判断找过该点,flag为有无负权回路得情况

while(q.size())
    {
        int now = q.front();//q是整数队列,怎么用的结构体类型去接受呢:?
        q.pop();
        for(int i = id[now];~i;i = e[i].reid)
        {
            if(d[e[i].to] > d[now] + e[i].cost)
            {
                d[e[i].to] = d[now] + e[i].cost;

                if(!vis[e[i].to])
                {
                    vis[e[i].to] = 1;
                    time[e[i].to]++;
                    if(time[e[i].to] > N)
                    {
                        flag = 1;
                        break;
                    }
                    q.push(e[i].to);
                }
            }
        }
        if(flag)break;
        vis[now] = 0;//来检查环的情况,如果没有负数环是不会回去的,判断有没有负环才会这么回溯!
    }

就受弹出来的第一个点,遍历第一个点所连接得所有的边,更新d[i]数组,然后观察边所连接得点,更新拜访状态,拜访次数,

如果一个点的拜访次数大于N了得话,那就代表存在负权回路,原理和Bellman-Ford算法差不多,最后要注意得一点是vis[i]
要重新更新其状态为0,也是为了判断负权回路。
queue不能有优先级,因为按照给定得顺序,就是从中央节点bfs往外拜访,一旦打乱那么d[i]还没有更新好,你的下一步
更新就进行了。

接下来是队列的实现 看看准备工作

int dis[maxn];
int v,e;//点,边
queue<int> q;
int flag[maxn];//表示所有的点都不在队列中
int times[maxn];//表示每一个点的入队次数
//边集
struct graph
{
    int s,e,w;
}es[maxn];

输入的就略过了 接下来进入spfa

for(i=1;i<=v;i++)
    {
        dis[i]=info;
        flag[i]=0;
        times[i]=0;
    }
    dis[s]=0;
    q.push(s);
    times[s]++;

还是先初始化一波,然后针对中央节点初始化一波

while(!q.empty())
    {
        int t = q.front();
        q.pop();
        flag[t]=0;
        for(i=1;i<=e;i++)
        {
            if(dis[es[i].e]>dis[es[i].s]+es[i].w)
            {
                dis[es[i].e]=dis[es[i].s]+es[i].w;
                if(flag[es[i].e]==0)
                {
                    q.push(es[i].e);
                    flag[es[i].e]=1;
                    times[es[i].e]++;
                    if(times[es[i].e]==v)
                        return false;//存在负环//双向就已经是负环了!!
                }
            }
        }
    }

取出队列中的第一个点,这里的flag就是vis

然后优化所有的边,差不多的原理,在这里就不缀述了

    原文作者:Bellman - ford算法
    原文地址: https://blog.csdn.net/Df_cjc/article/details/79197026
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞