矩阵从左上到右下的最短距离问题

1、问题：只允许向下或者向右，求从左上到右下的最短距离，动态规划法

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

public int minPathSum(int[][] grid) {
    if(grid==null || grid.length==0) return 0;
    int m = grid.length;
    int n = grid[0].length;
    int[][] p = new int[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (i == 0 && j == 0)
                p[i][j] = grid[i][j];
            else if (i == 0 && j > 0)
                p[i][j] = p[i][j-1] + grid[i][j];
            else if (i > 0 && j == 0)
                p[i][j] = p[i-1][j] + grid[i][j];
            else
                p[i][j] = Math.min(p[i-1][j], p[i][j-1]) + grid[i][j];
        }
    }
    return p[m-1][n-1];
}

2、问题：允许上下左右走，求从左上到右下的最短距离

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

每个方格看成是一个点，可以构造N*M+2（源点和目标点）个点的图，然后用最短路径算法求解

法1：下面是dijkstra算法

public void dijkstra(int[][] graph, int source){
    int n = graph.length;
    int[] dis = new int[n];
    boolean[] set = new boolean[n];
    // 初始化
    for(int i=0; i<n; i++){
        // -1表示不可达
        dis[i] = graph[source][i];
    }
    dis[source] = 0;
    set[source] = true;

    for(int i=0; i<n-1; i++){
        // 找到V中距离源点最近的点
        int mindis = Integer.MAX_VALUE;
        int minIndex=0;
        for(int v=0; v<n; v++){
            if(!set[v] && dis[v]<mindis && dis[v]!=-1){
                mindis = dis[v];
                minIndex = v;
            }
        }

        // 更新源点到V中每个点的距离
        set[minIndex] = true;
        for(int v=0; v<n; v++){
            if(!set[v] && graph[minIndex][v]>0 && dis[v] > dis[minIndex]+graph[minIndex][v]){
                dis[v] = dis[minIndex]+graph[minIndex][v];
            }
        }
    }
}

法2：用优先队列方法，广度优先搜索

优先队列存点v和源点到v的最短路径。

代码

package hihocoder;

import java.util.*;

public class WaterCity2{

    private PriorityQueue<Point> queue = new PriorityQueue<>();
    private Set<Integer> visited = new HashSet<>();
    private int n, m;
    private int[] distN, distM;
    private Point[][] street;

    private class Point implements Comparable<Point>{
        int r;
        int c;
        int dis;
        boolean blocked = false;
        boolean visited = false;

        private Point(int r, int c) {
            this.r = r;
            this.c = c;
        }

        private void visitNeighbors(){
            if(r!=0)    update(street[r-1][c], distN[r-1]);
            if(r!=n-1)  update(street[r+1][c], distN[r]);
            if(c!=0)    update(street[r][c-1], distM[c-1]);
            if(c!=m-1)  update(street[r][c+1], distM[c]);
        }

        private void update(Point p, int len){
            if(!p.blocked && !p.visited && p.dis > dis + len){
                queue.remove(p);
                p.dis = dis + len;
                queue.add(p);
            }
        }

        @Override
        public int compareTo(Point p){
            return dis-p.dis;
        }
    }

    private int minPath(int r0, int c0, int r1, int c1){
        Point start = street[r0][c0];
        Point end = street[r1][c1];
        queue.clear();
        visited.clear();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                street[i][j].visited = false;
                street[i][j].dis = Integer.MAX_VALUE;
            }
        }

        start.dis = 0;
        queue.add(start);
        while(!queue.isEmpty()){
            Point cur = queue.poll();
            if(cur == end) return cur.dis;
            cur.visited = true;
            cur.visitNeighbors();
        }
        return -1;
    }

    public void deal() {
        try(Scanner scanner = new Scanner(System.in)) {
            while (scanner.hasNextInt()) {
                n = scanner.nextInt();
                m = scanner.nextInt();
                distN = new int[n-1];
                distM = new int[m-1];
                for (int i = 0; i < n - 1; i++) {
                    distN[i] = scanner.nextInt();
                }
                for (int i = 0; i < m - 1; i++) {
                    distM[i] = scanner.nextInt();
                }

                street = new Point[n][m];
                for (int i = 0; i < n; i++) {
                    for (int j = 0; j < m; j++) {
                        street[i][j] = new Point(i, j);
                    }
                }

                int k = scanner.nextInt();
                for (int i = 0; i < k; i++) {
                    street[scanner.nextInt()-1][scanner.nextInt() - 1].blocked = true;
                }

                int q = scanner.nextInt();
                for (int i = 0; i < q; i++) {
                    System.out.println(minPath(scanner.nextInt()-1, scanner.nextInt()-1,
                            scanner.nextInt()-1, scanner.nextInt()-1));
                }
            }
        }
    }

    public static void main(String[] args){
        new WaterCity2().deal();
    }
}