单源最短路径Bellman-Ford---zoj3033

         Bellman-Ford算法的特点是能够解决带负权值的最短路径问题，并且实现起来比较简单。整个循环体循环V-1次，每次循环遍历图中的每一条边(u,v)，并对点V做松弛操作。可以证明，通过V*E次的操作，最后得到的dist[i]值就是从原点到点i的最短路径。具体的Bellman-Ford的正确性证明见《算法导论》

         但是，Bellman-Ford算法有一种情况不能处理，即图中存在从源可达的负权回路。如果出现这种情况，我们可以绕这这个环无限次，得到的最短路径即为负无穷。所以，这种情况下的最短路径问题是没有意义的。在Bellman-Ford算法中，还有一个对每条边的松弛判断，即验证上述情况。如果真的出现了从源可达的负权回路，算法返回false.

#include<iostream>
using namespace std;
class edge
{
public:
	int s,e;
	long long cost;
};
int p,n,s,e,m;
long long dist[301];
int pre[301];
long long maximum=1<<30;
bool Bellman_Ford(edge*a,int m,int s)
{
	for(int i=0;i<n;i++)
	{
		dist[i]=maximum;
		pre[i]=i;		
	}
	dist[s]=0;
	for(int i=0;i<n-1;i++)
	{
		for(int j=0;j<m;j++)
		{
			int start=a[j].s;
			int end=a[j].e;
			if(dist[start]!=maximum&&(dist[start]+a[j].cost)<dist[end])
			{
				dist[end]=dist[start]+a[j].cost;	
			}
		}	
	}
	for(int j=0;j<m;j++)
	{
		int start=a[j].s;
		int end=a[j].e;
		if(dist[start]!=maximum&&(dist[start]+a[j].cost)<dist[end])
			return false;
	}
	return true;	
}
int main()
{
	//cout<<maximum<<endl;
	cin>>p;
	while(p--)
	{
		cin>>n;
		cin>>s>>e;
		cin>>m;
		edge a[m];
		for(int i=0;i<m;i++)
		{
			cin>>a[i].s>>a[i].e>>a[i].cost;
		}
		if(Bellman_Ford(a,m,s))
		{
			if(dist[e]==maximum)
				cout<<"infinity"<<endl;
			else
				cout<<dist[e]<<endl;
		}
		else
			cout<<"infinity"<<endl;
	}
	return 0;
}