Bellman变形得来的SPFA最短算法(不能含负环);Floyd求两点间最短路,求有向图的闭包;

#include <iostream>
#include <queue>
using namespace std;

const int MAXN=100;

/*********************************/
*  SPFA算法需要的空间分配
/*********************************/
queue<int> q;
bool inq[MAXN];

/*********************************/
* 构造稀疏矩阵的邻接表 表示法
* u,v:边的端点
* first：表结点
* next：弧结点
* w: 边的权值
* n:顶点数目 m:边数目
/*********************************/

int u[MAXN];
int v[MAXN];
int w[MAXN];
int first[MAXN];
int next[MAXN];
int n,m;

/*********************************/
*  读入图到邻接表中 (无向图)
/*********************************/

void readG1()
{
memset(first,-1,sizeof(first));
cin>>n>>m;
int i,j;
for(i=0,j=0;i<m;++i)
{
int a,b,c;
cin>>a>>b>>c;
u[j]=a;
w[j]=c;
next[j]=first[u[j]];
first[u[j]]=j;
v[j++]=b;
u[j]=b;
v[j]=a;
w[j]=c;
next[j]=first[u[j]];
first[u[j]]=j;
v[j++]=a;
}
}

/*********************************/
*  读入图到邻接表中 (有向图)
/*********************************/
void readG2()
{
memset(first,-1,sizeof(first));
cin>>n>>m;
int i;
for(i=0;i<m;++i)
{
int a,b,c;
cin>>a>>b>>c;
u[i]=a;
v[i]=b;
w[i]=c;
next[i]=first[u[i]];
first[u[i]]=i;
}
}

/*********************************/
* 普通队列+标记数组=SPFA
* 实际就是Bellman的一个小变形得来的
/*********************************/

int d[MAXN];

void BellmanFord_SPFA()
{
// 顶点0作为源点
for(int i=0;i<n;++i)
{
d[i]=i==0? 0:MAXN;
}
memset(inq,0,sizeof(inq));
q.push(0);
while(!q.empty())
{
int x=q.front();
q.pop();
inq[x]=false;
for(int e=first[x];e!=-1;e=next[e])
{
if(d[v[e]]>d[x]+w[e])
{
d[v[e]]=d[x]+w[e];
if(!inq[v[e]])
{
inq[v[e]]=true;
q.push(v[e]);
}
}
}
}
}

/*********************************/
* Floyd 算法的实现 (有向图)
* Floyd 实现有向图的闭包
* d[i][j] 表示i到j的最短路径
* c[i][j] =1表示i到j可以连通,=0表示不可连通
/*********************************/

int dd[MAXN][MAXN];
int c[MAXN][MAXN];

void Floyd()
{
//预处理
for(int i=0;i<n;++i)
{
for(int k=0;k<n;++k)
{
dd[i][k]= i==k ? 0:MAXN;
c[i][k]= i==k ? 1:0;
}
for(int j=first[i];j!=-1;j=next[j])
{
dd[i][v[j]]=w[j];
c[i][v[j]]=1;
}
}
//Floyd两点间最短路算法
for(int k=0;k<n;++k)
{
for(int i=0;i<n;++i)
{
for(int j=0;j<n;++j)
{
if(dd[i][k]<MAXN&&dd[k][j]<MAXN)
{
if(dd[i][j]>dd[i][k]+dd[k][j])
{
dd[i][j]=dd[i][k]+dd[k][j];
}
}
c[i][j]=c[i][j]||(c[i][k]&&c[k][j]);
}
}
}
}

int main()
{
/*测试Floyd算法
4 5
0 1 1
0 2 3
0 3 3
1 3 1
1 2 1
*/

readG2();
Floyd();
for(int i=0;i<n;++i)
{
for(int j=0;j<n;++j)
{
cout<<i<<","<<j<<"----"<<dd[i][j]<<"-----"<<c[i][j]<<endl;
}
}

/*
SPFA测试：0为源点

*/
BellmanFord_SPFA();

for(int i=0;i<n;++i)
{
cout<<i<<"--0 :"<<d[i]<<endl;
}
return 0;
}

 

 

依旧采取静态数组邻接表 来构图, 这样使用非常方便, 只要在邻接表内的边都是存在的边, 而没有的边均是不通的边, 输入起来很方便, 使用时候也很方便.

 

Bellman变形得到的就是SPFA算法, 复杂度比bellman更低一些,比迪克拉斯算法适用范围更广，边权可以有负值, 但是不能带负环,否则绕着负环无限走下去,总能变得越来越小.

 

这些最短路算法都是使用了松弛原理, 只是松弛时又做了一些小变化.

 

SPFA : 初始化源点的d[]=0,其他的d[]=INF.

源点入队, 每次取队头出队列, 标记它不在队列内, 如果可以更新它所关联的端点, 并且端点不在队列内,则加入队列.

这样,每个端点都可能重复进入队列,但是经过有限次松弛, 总会使所有的端点的最短路径都无法再次更新. Dij算法区别于使用了

优先队列, 每次出队的结点已经完美,无需再次进入,而这里使用的是普通队列. Dij只允许正权图使用.

 

还有Floyd算法, 可以求任意两点间最短路径, O(n3)复杂度, 写起来很简单, 需要做一些初始化.

d[][]=INF。

然后修正以下内容：

d[i][i]=0,c[i][i]=1. 即自身可与自身连通,到自身路径是0.

d[i][j]=w[i][j]

然后可以使用算法了.