码迷,mamicode.com
首页 > 其他好文 > 详细

Dijkstra和Floyd_warshall

时间:2014-08-04 17:42:37      阅读:181      评论:0      收藏:0      [点我收藏+]

标签:java   dijkstra   floyd   最短路径   

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

/*题目描述:
 有n个城市,城市间有m条道路,每条道路都有长度d,给你起点城市s终点终点t,要求输出起点到终点的最短距离
 输入:
 输入n,m,城市的编号是1~n,然后是m行,每行3个数 a,b,d,表示a城市和b城市之间有一条道路,且其长度为d。假设a与b之间若有道路,则只

 有一条道路。最后一行是两个数 s,t;起点s,终点t。n和m为0时输入结束。(1<n<=1000, 0<m<100000, s != t)
 输出:
 输出一行有一个数, 表示最短距离。
 样例输入:
 3 2
 1 2 5
 2 3 4
 1 3
 0 0
 样例输出:
 9*/

/*
 * 起点s,终点t
 * map[a][b]表示a点与b点直接连通的距离,没有直接连通则为无限大
 * d[i]表示s点到i点的距离
 * fa[i]表示i点是否已经更新过了最短距离,true表示没有被使用,false表示已经被使用
 * 
 * 大致过程如下:
 * 1.先从d数组里找到一个离起点最近的点k,而且fa[k]必须为true,距离为d[k]
 * 2.将fa[k]赋值为false,接下来将用k来更新最短距离
 * 3.任意一点j,且fa[j]为false,若d[k] + map[k][j]比d[j]小则将d[k] + map[k][j]赋值给d[j]
 * 	换句话说就是先从起点走到k点(d[k]),再从k点走到j(map[k][j]),若比从起点
 * 	到j的距离(d[j])短,则d[j]应该变为d[k] + map[k][j]
 * 4.回到步骤1,直到所有fa数组里所有点都为false。
 * 5.d[t]就是起点s到终点t的最短距离
 */
public class Dijkstra {

	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		int n = cin.nextInt();
		int m = cin.nextInt();
		while (n != 0 && m != 0) {
			int[][] map = new int[n + 5][n + 5];
			for (int i = 0; i < map.length; i++) {
				// 将map任意两点的初值设置一个很大的值,表示两点间的距离无限大,即没有通路
				// 除以3是因为后面有加的地方,我害怕两个值加会超过Integer.MAX_VALUE
				Arrays.fill(map[i], Integer.MAX_VALUE / 3);
			}
			for (int i = 1; i <= m; i++) {
				int a = cin.nextInt();
				int b = cin.nextInt();
				int c = cin.nextInt();
				// a点到b点的距离是c
				map[a][b] = c;// a到b的距离赋为c
				map[b][a] = c;// b到a的距离赋为c
			}
			int s = cin.nextInt();// 起点
			int t = cin.nextInt();// 终点
			// d数组:d[i]表示起点s到i点的最短距离
			int[] d = new int[n + 5];
			Arrays.fill(d, Integer.MAX_VALUE);
			// fa数组:fa[i]表示i点是否已经更新过了最短距离,true表示没有被使用,false表示已经被使用
			boolean[] fa = new boolean[n + 5];
			Arrays.fill(fa, true);// 初始值都为true,表示所有点都可以用
			fa[s] = false;// 起点不能更新自己,所以为false
			for (int i = 1; i <= n; i++) {
				d[i] = map[s][i];// d[i]的为题目给出的map[s][i]
			}
			// 将所有点的fa的值都变为false,因为s点已经为false,所以我这里写i<n而不是i<=n
			for (int i = 1; i < n; i++) {
				int min = Integer.MAX_VALUE;
				int k = 0;
				for (int j = 1; j <= n; j++) {
					if (fa[j] && min > d[j]) {
						min = d[j];// 找到一个最小的d[j]
						k = j;// 并记录下标为k

					}

				}
				fa[k] = false;// 这样接下来就不会出现d[k] + map[k][k]的情况了,k点在i增加时被抛弃
				for (int j = 1; j <= n; j++) {
					// if(j点可用 && 当前起点s到k的最短距离+k到j直接连通的距离<当前起点s到j的最短距离)
					if (fa[j] && d[k] + map[k][j] < d[j]) {
						d[j] = d[k] + map[k][j];// 找到了更优的s到j的最短距离
					}
				}

			}
			System.out.println(d[t]);// 整个过程之后d[t]就是s到t的最短距离了

			n = cin.nextInt();
			m = cin.nextInt();
		}

	}

}



import java.util.Arrays;
import java.util.Scanner;
/*题目描述和那道Dijkstra的题一样,不过这个时间复杂度是O(n^3),
 如果和上一道题一样,n要是最多1000的话,这个算法就会超时
看完了这个算法可以看看九度1447,分别用这两种算法都做一下
 这里有一篇别人写的博客可以参考一下:http://blog.csdn.net/jdplus/article/details/19816375
 */
 
/*
 * 起点s,终点t
 * map[a][b]表示a点与b点直接连通的距离,没有直接连通则为无限大
 * 这个代码很简单大致思路:
 * 分别把所有节点都当做媒介节点
 */
public class Floyd_warshall{
 
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int m = cin.nextInt();
        while (n != 0 && m != 0) {
            int[][] map = new int[n + 5][n + 5];
            for (int i = 0; i < n + 5; i++){
                //和Dijkstra的算法一样我害怕会超过范围就除以了3
                Arrays.fill(map[i], Integer.MAX_VALUE / 3);
            }
            for (int i = 1; i <= m; i++) {
                int a = cin.nextInt();
                int b = cin.nextInt();
                int c = cin.nextInt();
                map[a][b] = c;
                map[b][a] = c;
            }
            //这个代码很简单,下面两段分割线之间就是最核心的代码
            //----------------------------------
            for (int k = 1; k <= n; k++)//k为媒介节点
                for (int i = 1; i <= n; i++)//i为所有的起点
                    for (int j = 1; j <= n; j++)//j为所有的终点
                    	/*
                    	 * 下面是最关键的两句:
                    	 * 如果i到k的距离加上k到j的距离比i到j的距离小,
                    	 * 则更新map[i][j]为map[i][k] + map[k][j]
                    	 * 就是不断把k当做中间节点来更新其他的两点的距离
                    	 */
                        if (map[i][k] + map[k][j] < map[i][j]) {//如果i到k的距离加上k到j的距离比i到j的距离小
                            map[i][j] = map[i][k] + map[k][j];//更新map[i][j]
                        }
            //----------------------------------
            int s = cin.nextInt();
            int t = cin.nextInt();
            System.out.println(map[s][t]);//更新后的map[s][t]已经是s到t的最短里的
 
            n = cin.nextInt();
            m = cin.nextInt();
        }
 
    }
 
}


九度1447可以两种方法都可以,九度1008只能用第一种方法


Dijkstra和Floyd_warshall,布布扣,bubuko.com

Dijkstra和Floyd_warshall

标签:java   dijkstra   floyd   最短路径   

原文地址:http://blog.csdn.net/ieayoio/article/details/38371989

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!