SPFA

昨天给出了蹩脚的Bellman-Ford动态规划实现，今天给出一种更快的算法，SPFA。

在编程过程中遇到了两个问题：

1.没有充分考虑数组指向；

2.没有充分考虑递归过程中的条件制约。

希望大家可以帮忙看一下上一篇博客，解决一下那个问题。如果可以改进该算法，请各位大神不吝赐教。

Have fun coding,i_human.Have fun coding ,everyone!

// SPFA.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#define a 100    //a大于点数
#define b 10000  //当作正无穷使用

using namespace std;

void improve(int k);
void prin();

int used[a];
int edge[a][a];
int cost[a];
int pre[a];
int recond[a][a];  //自我发明
int n,e;

int main()
{
int u,v,w;
cin>>n>>e;
for(int i=0;i<a;i++)
for(int j=0;j<a;j++)
edge[i][j]=b;
for(int i=1;i<=n;i++)
{
pre[i]=0;
used[i]=0;
cost[i]=b;
}
used[1]=1;  //默认1为源点
cost[1]=0;
for(int i=0;i<=n;i++)
for(int j=0;j<=n;j++)
recond[i][j]=0;
for(int i=0;i<e;i++)
{
cin>>u>>v>>w;
edge[u][v]=w;
recond[u][recond[u][0]+1]=v;
recond[u][0]++;
}
for(int i=0;i<=n;i++)
{
for(int j=0;j<=n;j++)
cout<<recond[i][j];
cout<<endl;
}
improve(1);
prin();
system("pause");
return 0;
}

void improve(int k)
{
int l=recond[k][0];
while(l>0)
{
if(used[recond[k][l]]>n)
{
cout<<"have negative circle"<<endl;
system("pause");
exit(0);
}
if(cost[recond[k][l]]>cost[k]+edge[k][recond[k][l]])
{
pre[recond[k][l]]=k;
cost[recond[k][l]]=cost[k]+edge[k][recond[k][l]];
used[recond[k][l]]++;
improve(recond[k][l]);
}
l--;
}
}

void prin()
{
for(int i=2;i<=n;i++)
{
cout<<i<<"<--";
int l=pre[i];
while(l!=1 && l!=0)
{
cout<<l<<"<--";
l=pre[l];
}
cout<<"1"<<endl;
}
}