結果

問題 No.20 砂漠のオアシス
ユーザー 37zigen37zigen
提出日時 2016-03-27 02:57:37
言語 Java21
(openjdk 21)
結果
WA  
実行時間 -
コード長 2,483 bytes
コンパイル時間 2,351 ms
コンパイル使用メモリ 79,400 KB
実行使用メモリ 65,900 KB
最終ジャッジ日時 2024-10-13 05:35:48
合計ジャッジ時間 8,886 ms
ジャッジサーバーID
（参考情報） 		judge5 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 129 ms
53,972 KB
testcase_01 AC 137 ms
54,308 KB
testcase_02 AC 133 ms
54,176 KB
testcase_03 WA -
testcase_04 AC 206 ms
56,780 KB
testcase_05 AC 451 ms
65,688 KB
testcase_06 AC 505 ms
65,900 KB
testcase_07 AC 477 ms
65,692 KB
testcase_08 AC 477 ms
63,876 KB
testcase_09 AC 511 ms
65,828 KB
testcase_10 AC 112 ms
53,220 KB
testcase_11 AC 112 ms
52,764 KB
testcase_12 AC 203 ms
56,836 KB
testcase_13 AC 211 ms
56,840 KB
testcase_14 AC 228 ms
57,436 KB
testcase_15 AC 214 ms
57,444 KB
testcase_16 AC 264 ms
57,844 KB
testcase_17 AC 251 ms
58,108 KB
testcase_18 AC 257 ms
58,820 KB
testcase_19 AC 274 ms
58,600 KB
testcase_20 AC 197 ms
54,952 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

package yukicoder020;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int v=sc.nextInt();
		int ox=sc.nextInt()-1;
		int oy=sc.nextInt()-1;
		int[][] map=new int[n][n];
		for(int i=0;i<n;i++){
			for(int j=0;j<n;j++){
				map[i][j]=sc.nextInt();
			}
		}
		int[] dx={1,-1,0,0};
		int[] dy={0,0,1,-1};
		Dijkstra di=new Dijkstra(n*n);

		for(int i=0;i<n*n;i++){
			int y=i/n;
			int x=i%n;
			for(int j=0;j<4;j++){
				int ny=y+dy[j];
				int nx=x+dx[j];
				if(0<=nx&&nx<n&&0<=ny&&ny<n){
					int vv=ny*n+nx;
					di.addEdge(vv,i,map[y][x]);
				}
			}
		}
		if(di.getShortestPath(0, n*n-1)<v){
			System.out.println("YES");
		}else if(ox>=0&&oy>=0){
			long tmp=di.getShortestPath(0, ox+oy*n);
			if(tmp<v&&di.getShortestPath(ox+oy*n, n*n-1)<2*(v-tmp)){
				System.out.println("YES");
			}else{
				System.out.println("NO");
			}
		}

	}

	private static class Dijkstra{
		long[] d;
		List<Edge>[] edges;
		PriorityQueue<Vertex> pq;
		int n;
		int s;
		final long INF=Long.MAX_VALUE;

		Dijkstra(int n){
			this.n=n;
			edges=new List[n];
			for(int ii=0;ii<n;ii++){
				edges[ii]=new ArrayList<Edge>();
			}
			s=-1;
		}
		public void addEdge(int i,int j,int c){
			edges[i].add(new Edge(i,j,c));
		}
		public long getShortestPath(int i,int j){
			if(s!=i){
				d=new long[n];
				Arrays.fill(d, INF);
				d[i]=0;//the min total cost to go to i
				pq=new PriorityQueue<Vertex>();
				pq.add(new Vertex(i,d[i]));
				while(!pq.isEmpty()){
					Vertex u=pq.poll();
					if(d[u.me]<u.d){
						continue;//skip the old vertx
					}
					for(int ii=0;ii<edges[u.me].size();ii++){
						Edge v=edges[u.me].get(ii);
						if(d[u.me]!=INF&&d[v.v]>d[u.me]+v.w){
							d[v.v]=d[u.me]+v.w;
							pq.add(new Vertex(v.v,d[v.v]));
						}
					}
				}
				s=i;
			}
			return d[j];
		}
		private static class Edge{
			//int u;//from
			int v;//to
			int w;//cost
			Edge(int u,int v,int w){
				//			u=this.u;
				this.v=v;
				this.w=w;
			}
		}
		public static class Vertex implements Comparable<Vertex>{
			int me;//me
			long d;//cost(the min total cost to arrive here)

			Vertex(int me,long d){
				this.me=me;
				this.d=d;
			}

			@Override
			public int compareTo(Vertex o){
				return Long.compare(this.d, o.d);
				//				return this.d>o.d?1:this.d<o.d?-1:0;
			}
		}
	}
}
0