java_bellmanFord

伪代码：

例子：

代码：

import java.util.Arrays;
import java.util.Scanner;



public class BellmanFord {
	static int MAX=Integer.MAX_VALUE;

	public static void main(String[] args) {
		//System.out.println(MAX+5);
		// TODO 自动生成的方法存根
		Scanner sc=new Scanner(System.in);
		System.out.println("请输入结点的个数");
		int n=sc.nextInt();
		System.out.println("请输入边的条数");
		int edgesize=sc.nextInt();
		int a[][]=new int[n][n];              //放各个点到各个点的距离
		int d[]=new int[n];                   //放源点到各个点的最短距离
		
		System.out.println("请依次输入边的起点和终点以及边的权值");
		for(int i=0;i<n;i++) {                //初始化，点到自己的距离为0，其他先初始化为MAX
			for(int j=0;j<n;j++) {
				if(i==j) {
					a[i][j]=0;
				}else {
					a[i][j]=MAX;
				}
			}
		}
		
		for(int i=0;i<edgesize;i++) {       //键盘输入， 注意边是有方向的
			int start=sc.nextInt();
			int end=sc.nextInt();
			int weight=sc.nextInt();
			if(start!=end) {
				a[start][end]=weight;
			}	
		}
		for(int i=0;i<n;i++) {                //初始化源点到各个顶点的最短距离   
			d[i]=a[0][i];
		}
		
		
		
		if(BellmanFord(a,n,d)==true) {       //调用BellmanFord方法
			System.out.println("true");
			System.out.println(Arrays.toString(d));
		}else {
			System.out.println("false");
		}
	}

	private static boolean BellmanFord(int[][] a, int n, int[] d) {
		boolean c=true;
		for(int i=1;i<n;i++) {                     //这里必须得从下标1开始，不然假设存在负权回路，会出现死循环，出现栈溢出错误
			if(d[i]<MAX) {
				for(int j=0;j<n;j++) {
					if(d[j]>d[i]+a[i][j] && a[i][j]!=MAX) { //!=MAX必须加，因为MAX+上一个数它判为负值
						d[j]=d[i]+a[i][j];         
						for(int k=1;k<n;k++) {    //这里必须得从下标1开始
							if(d[k]<MAX) {       
								BellmanFord(a,n,d);
							}
						}
					}
				}
			}
		}
		for(int i=0;i<n;i++) {                       //检查是否有负值回路 
			for(int j=0;j<n;j++) {
				if(d[j]>d[i]+a[i][j] && a[i][j]!=MAX) {
					c=false;
					break;
				}
			}
		}
		return c;
	}

}

注意边是有方向的

0 1 6
0 4 7
1 2 5
1 3 -4
1 4 8
2 1 -2
3 0 2
3 2 7
4 2 -3
4 3 9

运行结果：

有负权回路例子