检查是否有负循环（Bellman Ford， Floyd-Warshall）

 负循环：循环的环的循环总和为负的情况。（如图情况）

思路：1.将从源点到其他各点的最短路设为无穷大， 源点处的距离为0；

           2.利用Bellman-Ford求到各个点的最短路，需要循环n-1次（有n个顶点）

原因：如果假设该图没有负环存在，则最短经过每个点一次（即n-1条边），因此最多循环n-1次

                         设图中的某两个点u 和v ，G[u, v]  =  dist; 如果 d[u] > d[v] + dist; 则需要更新当前节点的距离。

           3.如果存在负环，则在进行第n次循环时，d的值任何会更新，如果出现这样的情况，此时可以判断该图中存在负环

 

Bellman-Ford算法：

//从0开始 
struct edge{
	int u, v, w;
};

edge es[maxn];
int d[maxn];
int V, E;

void Bellman_Frod(int s){
	for(int i = 0; i < V; i++) d[i] = INF;
	d[s] = 0;
	
	while(1){
		bool Update = false;
		for(int i = 0; i < E; i++){
			edge e = es[i];
			if(d[e.u] != INF&&d[v] > d[u] + e.w){
				d[e.v] = d[e.u] + e.w;
				Update = true;
			}
		}
		if(!Update) break;
	}
}

判断负圈

struct Node{
	int u, v, w;
};

edge es;
int d[maxn];

int V, E;   //顶点个数V，边个数E 

void isCycleBellman_Ford(int s){
	//初始化距离 
	for(int i = 0; i < V; i++) d[i] = INF;
	d[s] = 0;
	
	/* 
	*** 2
	*放松所有的边V-1次
	*从源点到各点的最短路
	*/
	for(int i = 1; i < V; i++){
		for(int j = 0; j < E; j++){
			edge e = es[j];
			if(d[e.u] != INF&&d[e.v] > d[e.u] + e.w)
				d[e.v] = d[e.u] + e.w;
		}
	} 
	
	/*
	*** 3
	*如果d的值更新则为负环 
	*/
	for(int i = 0; i < E; i++){
		edge e = es[j];
		if(d[e.u] != INF&&d[e.u] > d[e.v] + e.w)
			return true;
	}
	return false;
} 

 

         1
 (0) --------------->(1)
 /|\                  |
  |                   |
  |                   |
-1|                   |-1
  |                   |
  |                  \|/
 (3)<----------------(2)

如这样一个图：可以肯定的是任何节点与其自身的距离始终为0，如果当我们从第0点遍历都第0点时，结果确是-2，显然这样的结果是不正确的。而这样的环一定是负环。因此我们只需判断任意点到自身的距离是否存在负数的情况即可。

int d[maxn][maxn];
int maze[maxn][maxn];

int V, E;   //顶点个数V，边个数E 
/*以有向图为例*/
void init(){
	for(int i = 0; i < V; i++){
		for(int j = 0; j < V; j++){
			if(i == j) d[i][j] = 0;
			else d[i][j] = INF;	
		}
	}
			
	for(int i = 0; i < E; i++){
		int u, v, w;
		scanf("%d%d%d", &u, &v, &w);
		d[u][v] = w;
	}
} 

bool iscycleFloyd(){
	init();
	
	for(int k = 0; k < V; k++){
		//逐个选择所有的顶点作为源点
		for(int i = 0; i < V; i++){
			//选择所有顶点作为目标
			for(int j = 0; j < V; j++){
				if(d[i][k] + d[k][j] < d[i][j]){
					d[i][j] = d[i][k] + d[k][j];
				}
			}
		} 	
	}
	
	//判断负环
	for(int i = 0; i < V; i++)
		if(d[i][i] < 0) return true;
	return false; 
}