图论-最短路-dijkstra / 0-1BFS-使网格图至少有一条有效路径的最小代价

2020-03-01 22:59:59

问题描述：

给你一个 m x n 的网格图 grid 。 grid 中每个格子都有一个数字，对应着从该格子出发下一步走的方向。 grid[i][j] 中的数字可能为以下几种情况：

• 1 ，下一步往右走，也就是你会从 grid[i][j] 走到 grid[i][j + 1]
• 2 ，下一步往左走，也就是你会从 grid[i][j] 走到 grid[i][j - 1]
• 3 ，下一步往下走，也就是你会从 grid[i][j] 走到 grid[i + 1][j]
• 4 ，下一步往上走，也就是你会从 grid[i][j] 走到 grid[i - 1][j]

注意网格图中可能会有 无效数字 ，因为它们可能指向 grid 以外的区域。

一开始，你会从最左上角的格子 (0,0) 出发。我们定义一条 有效路径 为从格子 (0,0) 出发，每一步都顺着数字对应方向走，最终在最右下角的格子 (m - 1, n - 1) 结束的路径。有效路径 不需要是最短路径 。

你可以花费 cost = 1 的代价修改一个格子中的数字，但每个格子中的数字 只能修改一次 。

请你返回让网格图至少有一条有效路径的最小代价。

示例 1：

输入：grid = [[1,1,1,1],[2,2,2,2],[1,1,1,1],[2,2,2,2]]
输出：3
解释：你将从点 (0, 0) 出发。
到达 (3, 3) 的路径为： (0, 0) --> (0, 1) --> (0, 2) --> (0, 3) 花费代价 cost = 1 使方向向下 --> (1, 3) --> (1, 2) --> (1, 1) --> (1, 0) 花费代价 cost = 1 使方向向下 --> (2, 0) --> (2, 1) --> (2, 2) --> (2, 3) 花费代价 cost = 1 使方向向下 --> (3, 3)
总花费为 cost = 3.

示例 2：

输入：grid = [[1,1,3],[3,2,2],[1,1,4]]
输出：0
解释：不修改任何数字你就可以从 (0, 0) 到达 (2, 2) 。

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 100

问题求解：

最重要的是reduce，如何将问题转成已知的知识非常重要。

本题中看似是需要求改变方向个数最少，其实是在最短路径。

如果我们将通过标示到达w = 0，那么通过修改到达的w = 1。当看到这一点之后就可以使用dijkstra进行求解了。

    int[][] dirs = new int[][]{{0, 1}, {0, -1}, {1, 0}, {-1, 0}};

    public int minCost(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        int[] dist = new int[m * n];
        Arrays.fill(dist, (int)(1e9));
        PriorityQueue<int[]> pq = new PriorityQueue<>((int[] o1, int[] o2) -> o1[1] - o2[1]);
        int[] used = new int[m * n];
        pq.add(new int[]{0, 0});
        while (!pq.isEmpty()) {
            int[] node = pq.poll();
            int from = node[0];
            int d = node[1];
            if (used[from] == 1) continue;
            used[from] = 1;
            dist[from] = d;
            int x = from / n;
            int y = from % n;
            for (int i = 1; i <= 4; i++) {
                int nx = x + dirs[i - 1][0];
                int ny = y + dirs[i - 1][1];
                if (nx >= m || nx < 0 || ny >= n || ny < 0) continue;
                int w = grid[x][y] == i ? 0 : 1;
                int to = nx * n + ny;
                if (dist[to] > dist[from] + w) {
                    dist[to] = dist[from] + w;
                    pq.add(new int[]{to, dist[to]});
                }
            }
        }
        return dist[m * n - 1];
    }

本题有个特殊的地方就是边权重只为0 / 1，在这样的图上求解最短路径的最优解是使用0-1 BFS，这个解有待更新。

原文地址：https://www.cnblogs.com/hyserendipity/p/12392885.html