-----模板spfa+邻接表，spfa+链式前向星

最新推荐文章于 2022-01-07 11:50:01 发布

chenchenT_

最新推荐文章于 2022-01-07 11:50:01 发布

阅读量523

点赞数 2

分类专栏： ----图论

本文链接：https://blog.csdn.net/chenchenQT/article/details/73129412

版权

----图论专栏收录该内容

10 篇文章 0 订阅

订阅专栏

这篇博客详细介绍了使用SPFA（Shortest Path Faster Algorithm）最短路径算法，并结合邻接表和链式前向星两种数据结构进行实现。作者分享了个人的理解和整理，欢迎读者指正错误。

摘要由CSDN通过智能技术生成

自己胡乱整理的…有错欢迎纠正

#include<cstdio>
 #include<iostream>
 #include<cstring>
 #include<queue>
 #include<vector>
 #define INF 0x3f3f3f3f
using namespace std;

///临接表,spfa
const int maxn=1e8+10;
int n,m;
struct node
{
    int to,val;
};
vector<node>G[maxn];
int vis[maxn],dis[maxn];
node q;
void add(int u,int v,int w)///用邻接表建图
{
     q.to=v;
     q.val=w;
     G[u].push_back(q);
}
void spfa(int s)
{
    queue<int>que;
    que.push(s);
    vis[s]=1;
    while(!que.empty())
    {
        int pos=que.front();
        que.pop();
        vis[pos]=0;
        for(int i=0; i<G[pos].size(); i++) ///能够更新所有以pos为起点的边的dis值
        {
            if(dis[pos]+G[pos][i].val<dis[G[pos][i].to])
                dis[G[pos][i].to]=dis[pos]+G[pos][i].val;
            if(!vis[G[pos][i].to])
            {
                vis[G[pos][i].to]=1;
                que.push(G[pos][i].to);
            }
        }
    }
}

int main()
{

    int u,v,w;
    cin>>u>>v>>w;
    memset(vis,0,sizeof(vis));
    memset(dis,INF,sizeof(dis));
    add(u,v,w);///无向图，双向存图
    add(v,u,w);
}



#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#include<vector>
#define INF 0x3f3f3f3f
using namespace std;

///链式前向星存图,spfa
const int maxn=1e8+10;
int tot;
struct node
{
    int to,val;
    int next;
}G[maxn];
int head[maxn],vis[maxn],dis[maxn];

void add(int u,int v,int w)
{
    tot++;
    G[tot].to=v;
    G[tot].val=w;
    G[tot].next=head[u];
    head[u]=tot;
}

void spfa(int s)
{
    queue<int>que;
    vis[s]=1;
    que.push(s);
    while(!que.empty())
    {
        int pos=que.front();
        que.pop();
        vis[pos]=0;
        for(int i=head[pos];i!=-1;i=G[i].next)///i就是代表位置而以，head[pos]记录的是以pos为顶点的最后一条边的位置i，
                                                ///G[i].next记录的是其他的pos为顶点的其他的边的位置i
        {
            int v=G[i].to;///v代表以pos为起点的位置在i的边的终点
            if(dis[pos]+G[i].val<dis[G[i].to])///目的在于更新以pos为起点的边的终点v到源点s的最短距离
            {
                dis[G[i].to]=dis[pos]+G[i].val;
                 if(!vis[v])///如果更新到的点不在队列中，则把它们加入队列中
            {
                vis[v]=1;
                que.push(v);
            }
            }
        }
    }

}

int main()
{
    int u,v,w;
    memset(vis,0,sizeof(vis));
    memset(dis,INF,sizeof(vis));
    tot=0;
    cin>>u>>v>>w;
    add(u,v,w);
    add(v,u,w);
}