Wannafly交流赛1 D （对java极度不友好）

首先声明一下、这两个都是通过55%的代码、（啊啊啊）

解题的思路大概就是（输入初始化、） 将 输入的 0的点变成 -1 将输入-1的点变为0（代表着改变这个需要付出的代价、）

要隔绝他们、（付出的代价最小）那么我们先把两个边界标记放入优先队列中、（这里我放的是左边和下边），然后遍历、直到遍历到了上边或者右边（及形成了一堵“墙”）这个过程中，不断的缩小dis的值（如果成立的话、因为优先队列）所所以直接结束while循环、然后输出、没有的话、也输出（初始化ans = -1）、、（待续、、对java真的是不友好、、）

ps：从优先队列取出来的时候注意一下、要弄一个比较器、不然会出现（cannot be cast to java.lang.Comparable）异常、

package acm_2018_03_02;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.PriorityQueue;
import java.util.Queue;

public class D {
    
    static final int MAXN = 505;
    static final int INF = 0x3f3f3f3f;
    static int T, N, M;
    static long [][] map = new long [MAXN][MAXN];
    static long [][] d = new long [MAXN][MAXN];
    static boolean [][] vis = new boolean [MAXN][MAXN];
    static long ans = 0;
    static int [][] fd = {{0,1}, {1, 0}, {0, -1}, {-1, 0}}; //向四个方向的移动、、
    static Queue<Node> queue = new PriorityQueue<>();
    public static class Node implements Comparable<Node>{
        int x, y;
        long value;
        Node(int x, int y, long v){
            this.x = x;
            this.y = y;
            this.value = v;
        }
        
        public Node() {
        }

        @Override
        public int compareTo(Node o) {
            return (int)(this.value - o.value);
        }
    }
    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
        
        in.nextToken(); T = (int)in.nval;
        in.nextToken(); N = (int)in.nval;
        in.nextToken(); M = (int)in.nval;
        while(T-- != 0){
            Init();
            for(int i = 1; i <= N; i++){
                for(int j = 1; j <= M; j++){
                    in.nextToken(); map[i][j] = (long)in.nval; //存地图的坐标、、
                    if(map[i][j] == 0){  //  不能改变的 变为 -1
                        map[i][j] = -1;
                    }else if(map[i][j] == -1){  //  不需要改变的代价设置为 0、、
                        map[i][j] = 0;
                    }
                    d[i][j] = INF;
                }
            }
            queue.clear();
            for(int i = 2; i <= N; i++){ // 最左边全部扔进优先队列中、、
                if(map[i][1] != -1){
                    queue.add(new Node(i, 1, map[i][1]));
                    d[i][1] = map[i][1];
                }
            }
            for(int i = 1; i < M; i++){ //  最下面的扔进去、、
                if(map[N][i] != -1){
                    queue.add(new Node(N, i, map[N][i]));
                    d[N][i] = map[N][i];
                }
            }
            
            ans = -1;
            while(!queue.isEmpty()){
                Node tmp = queue.poll(); // 弹出来最小的一个、、
                if(vis[tmp.x][tmp.y]) continue;
                vis[tmp.x][tmp.y] = true;
                if(tmp.x == 1 || tmp.y == M){
                    ans = tmp.value;
                    break;
                }
                for(int i = 0; i < 4; i++){
                    int x = tmp.x + fd[i][0];
                    int y = tmp.y + fd[i][1];
                    long c = d[tmp.x][tmp.y] + map[x][y];
                    if(x < 1 || x > N || y > M || y < 1 || map[x][y] == -1 || vis[x][y] || c > d[x][y]) continue;
                    d[x][y] = c;
                    queue.add(new Node(x, y, c));
                }
            }
            out.println(ans);
            out.flush();
        }
        
    }
    
    private static void Init(){
        for(int i = 1; i <= N; i++){
            for(int j = 1; j <= M; j++){
                vis[i][j] = false;
            }
        }
    }
    
}

package acm_2018_03_02;

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;

public class D_ {
    static final int MAXN = 505;
    static final int INF = 0x3f3f3f3f;
    static int T, N, M;
    static long [][] map = new long [MAXN][MAXN];
    static long [][] dis = new long [MAXN][MAXN];
    static boolean [][] vis = new boolean [MAXN][MAXN];
    static long ans = 0;
    static int [][] fd = {{0,1}, {1, 0}, {0, -1}, {-1, 0}}; //向四个方向的移动、、
    static Queue<Node> queue = new PriorityQueue<>();
    public static class Node implements Comparable<Node>{
        int x, y;
        long value;
        Node(int x, int y, long v){
            this.x = x;
            this.y = y;
            this.value = v;
        }
        
        public Node() {
        }

        @Override
        public int compareTo(Node o) {
            return (int)(this.value - o.value);
        }
    }
    
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        T = input.nextInt();
        N = input.nextInt();
        M = input.nextInt();
        while(T-- != 0){
            queue.clear();
            for(int i = 1; i <= N; i++){
                for(int j = 1; j <= M; j++){
                    map[i][j] = input.nextLong();
                    if(map[i][j] == -1){
                        map[i][j] = 0;
                    }else if(map[i][j] == 0){
                        map[i][j] = -1;
                    }
                    dis[i][j] = INF;
                }
            }
            
            for(int i = 1; i <= N; i++){
                if(map[i][1] == -1) continue;
                queue.add(new Node(i, 1, map[i][1]));
                dis[i][1] = map[i][1];
            }
            for(int i = 1; i <= M; i++){
                if(map[N][i] == -1) continue;
                queue.add(new Node(N, i, map[N][i]));
                dis[N][i] = map[N][i];
            }
            ans = -1;
            while(!queue.isEmpty()){
                Node tmp = queue.poll();
                if(tmp.x == 1 || tmp.y == M){
                    ans = tmp.value;
                    break;
                }
                for(int i = 0; i < 4; i++){
                    int nx = tmp.x + fd[i][0];
                    int ny = tmp.y + fd[i][1];
                    if(nx >= 1 && nx <= N && ny >= 1 && ny <= M
                            && map[nx][ny] + tmp.value < dis[nx][ny]
                            && map[nx][ny] != -1){
                        queue.add(new Node(nx, ny, map[nx][ny] + tmp.value));
                        dis[nx][ny] = map[nx][ny] + tmp.value;
                    }
                }
            }
            System.out.println(ans);
        }
        
    }
    
}