Ideal Path理想路径，BFS与DFS（Java版）

非常经典的一个题目，

public class IdealPath {

    public static int[] value;    //最短路径长度
    public static int[][] g;      //矩阵图
    public static List result = new ArrayList();

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String line = scan.nextLine().trim();
        String[] params = line.split(" ");
        int n = Integer.valueOf(params[0]);
        int m = Integer.valueOf(params[1]);
        value = new int[n];
        g = new int[n][n];
        for (int i=0; i<m; i++) {
            line = scan.nextLine().trim();
            params = line.split(" ");
            int start = Integer.valueOf(params[0]) - 1;
            int end = Integer.valueOf(params[1]) - 1;
            g[start][end] = Integer.valueOf(params[2]);
        }
        for (int[] tmp: g) {
            System.out.println(Arrays.toString(tmp));
        }
        System.out.println("Original Value:" + Arrays.toString(value));

        dfs(0);
        System.out.println("Target Value:" + Arrays.toString(value));
        result.add(1);
        bfs(0, true);
        System.out.println(result);
    }

    /*
    bfs函数有两个用处，以flag来区分：
    true:选择最短路径；false:选择颜色最小序
     */
    public static int bfs(int n, boolean flag) {
        if (n == value.length-1)
            return 0;
        int next = -1;
        for (int i=0; i<value.length; i++) {
            if (value[i] == value[n] -1 && g[n][i] != 0) {
                if (next== -1 || g[n][i] < g[n][next]) {
                    next = i;
                } else if (g[n][i] == g[n][next]) {
                    int a = bfs(next, false);
                    int b = bfs(i, false);
                    next = a < b ? next : i;
                }
            }
        }
        if (flag)
            result.add(next+1);
        return g[n][next] + bfs(next, flag);
    }

    public static int dfs(int n) {
        if (n == value.length - 1)
            return 0;
        value[n] = -1;
        for (int i=0; i<value.length; i++) {
            if (g[n][i] > 0 && value[i] != -1) {
                int val = dfs(i) + 1;
                if (val < value[n] || value[n] == -1) {
                    value[n] = val;
                }
            }
        }
        return value[n];
    }



}

Java版实现如下，如果有bug或需要改进的地方，及时指出哟。可读性可能并不是很好，主要是为了秀。