SPFA

昨天给出了蹩脚的Bellman-Ford动态规划实现，今天给出一种更快的算法，SPFA。
在编程过程中遇到了两个问题：
1.没有充分考虑数组指向；
2.没有充分考虑递归过程中的条件制约。
希望大家可以帮忙看一下上一篇博客，解决一下那个问题。如果可以改进该算法，请各位大神不吝赐教。

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

THE CODE:

// 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;
	}
}