hihocoder [offer收割机]编程练习赛57 C 逃离迷宫5(最短路，dp)

题目链接

逃离迷宫5

分析

其实很简单，它限制了每个点的状态并且整条路径只能够修改一次，那么我很很容易的出一个dp状态更新方程:

设 u−>v u − > v , 其中， dist[u][0/1]分别表示从起点到这里有用掉更改或者没用掉的最短距离 d i s t [ u ] [ 0 / 1 ] 分 别 表 示 从 起 点 到 这 里 有 用 掉 更 改 或 者 没 用 掉 的 最 短 距 离 ，那么我们有

if grid[v]==’#’: dist[v][1]=min(dist[v][1],dist[u][0]+1) d i s t [ v ] [ 1 ] = m i n ( d i s t [ v ] [ 1 ] , d i s t [ u ] [ 0 ] + 1 ) , 这个点必须要更改
if grid[v]==’.’: dist[v][0]=min(dist[v][0],dist[u][0]+1) d i s t [ v ] [ 0 ] = m i n ( d i s t [ v ] [ 0 ] , d i s t [ u ] [ 0 ] + 1 )
dist[v][1]=min(dist[v][1],min(dist[u][0/1])+1) d i s t [ v ] [ 1 ] = m i n ( d i s t [ v ] [ 1 ] , m i n ( d i s t [ u ] [ 0 / 1 ] ) + 1 )

总结

开始用了一个vis来记录每个点的访问情况，wa了一发，可能是由于两种不同状态的更新没有及时导致，还是应该采用 “不动点”算法，没有收敛就继续更新下一个点，反正每个点至多出队两次而已，开销不大

code

import java.io.BufferedInputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.PriorityQueue;
import java.util.Scanner;






public class Main {
    public static final int INF = 0x3f3f3f3f;
    public static Scanner in = new Scanner(new BufferedInputStream(System.in));
    public static void main(String[] args) {
        int n = in.nextInt();
        boolean[][] map = new boolean[n][n];
        while (in.nextLine()=="");
        for(int i=0 ; ichar[] tmp = in.nextLine().toCharArray();
            for(int j=0 ; j'#');
        }
        int ans = new Solution(map).solve();
        System.out.printf("%d",ans>=INF?-1:ans);
    }
}
class Solution {
    int N;
    boolean[][] map;
    int[][][] dist;
    boolean[][] vis;
    public Solution(boolean[][] map) {
        super();
        this.map = map;
        N = map.length;
        dist = new int[N][N][2];
        vis = new boolean[N][N];
        for(int i=0 ; ifor(int j=0 ; j0]=dist[i][j][1]=Main.INF;
                vis[i][j]=vis[i][j]= false;
            }
    }
    public int solve() {
        int ret=0;
        dijkstra();
        ret = Math.min(dist[N-1][N-1][0], dist[N-1][N-1][1]);
        return ret;
    }
    class Node implements Comparable{
        int x,y;
        int val;
        public Node(int x, int y,int val) {
            super();
            this.x = x;
            this.y = y;
            this.val = val;
        }
        @Override
        public int compareTo(Node o) {
            // TODO Auto-generated method stub
            return val - o.val;
        }

    }
    int[] dx = new int[]{1,-1,0,0};
    int[] dy = new int[]{0,0,1,-1};
    private boolean isLegal(int x,int y) {
        return x >=0 && x =0 && yprivate void dijkstra() {
        PriorityQueue Q = new PriorityQueue<>();
        Q.add(new Node(0, 0,0));
        dist[0][0][0] = dist[0][0][1] =0;
//      vis[0][0] = true;
        while (!Q.isEmpty()) {
            Node now = Q.remove();
//          if(vis[now.x][now.y])continue;
//          vis[now.x][now.y] = true;
            if(dist[now.x][now.y][0]1]continue;
            for(int i=0 ; i<4 ; ++i){
                int nx = now.x + dx[i];
                int ny = now.y + dy[i];
                if(!isLegal(nx, ny))continue;
                if(map[nx][ny]){//有障碍
                    if(dist[nx][ny][1] > dist[now.x][now.y][0]+1){
                        dist[nx][ny][1] = dist[now.x][now.y][0]+1;
                        Q.add(new Node(nx,ny,dist[nx][ny][1]));
                    }
                }else{
                    int nv = Math.min(dist[now.x][now.y][0], dist[now.x][now.y][1]);
                    if(dist[nx][ny][1]>nv+1){
                        dist[nx][ny][1] = nv+1;
                        Q.add(new Node(nx, ny,dist[nx][ny][1]));
                    }
                    if(dist[nx][ny][0]>dist[now.x][now.y][0]+1){
                        dist[nx][ny][0]=dist[now.x][now.y][0]+1;
                        Q.add(new Node(nx, ny, dist[nx][ny][0]));
                    }
                }
            }
        }
    }
}