結果
| 問題 | No.5015 Escape from Labyrinth |
| ユーザー |
 Yu_212
|
| 提出日時 | 2023-04-16 15:13:37 |
| 言語 | Java21 (openjdk 21) |
| 結果 |
WA
|
| 実行時間 | - |
| コード長 | 19,476 bytes |
| コンパイル時間 | 3,262 ms |
| コンパイル使用メモリ | 101,516 KB |
| 実行使用メモリ | 71,400 KB |
| スコア | 95,980 |
| 最終ジャッジ日時 | 2023-04-16 15:15:15 |
| 合計ジャッジ時間 | 85,906 ms |
|
ジャッジサーバーID （参考情報） |
judge15 / judge12 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 707 ms
69,260 KB |
| testcase_01 | AC | 776 ms
69,088 KB |
| testcase_02 | AC | 776 ms
71,020 KB |
| testcase_03 | AC | 736 ms
68,924 KB |
| testcase_04 | AC | 751 ms
67,340 KB |
| testcase_05 | AC | 723 ms
69,188 KB |
| testcase_06 | AC | 758 ms
68,664 KB |
| testcase_07 | AC | 766 ms
68,760 KB |
| testcase_08 | AC | 781 ms
68,944 KB |
| testcase_09 | AC | 782 ms
69,152 KB |
| testcase_10 | AC | 714 ms
67,220 KB |
| testcase_11 | AC | 781 ms
69,560 KB |
| testcase_12 | AC | 778 ms
69,112 KB |
| testcase_13 | AC | 757 ms
68,940 KB |
| testcase_14 | WA | - |
| testcase_15 | AC | 738 ms
69,272 KB |
| testcase_16 | AC | 736 ms
69,040 KB |
| testcase_17 | AC | 742 ms
69,612 KB |
| testcase_18 | AC | 747 ms
68,888 KB |
| testcase_19 | AC | 755 ms
69,736 KB |
| testcase_20 | AC | 715 ms
68,956 KB |
| testcase_21 | AC | 815 ms
69,352 KB |
| testcase_22 | AC | 772 ms
69,124 KB |
| testcase_23 | AC | 763 ms
69,092 KB |
| testcase_24 | AC | 726 ms
68,924 KB |
| testcase_25 | AC | 731 ms
68,804 KB |
| testcase_26 | AC | 713 ms
68,868 KB |
| testcase_27 | AC | 820 ms
69,088 KB |
| testcase_28 | AC | 740 ms
69,012 KB |
| testcase_29 | AC | 778 ms
68,888 KB |
| testcase_30 | AC | 746 ms
69,360 KB |
| testcase_31 | AC | 781 ms
69,120 KB |
| testcase_32 | AC | 738 ms
68,288 KB |
| testcase_33 | AC | 830 ms
69,196 KB |
| testcase_34 | WA | - |
| testcase_35 | AC | 812 ms
69,124 KB |
| testcase_36 | AC | 796 ms
68,740 KB |
| testcase_37 | AC | 765 ms
68,896 KB |
| testcase_38 | AC | 751 ms
69,060 KB |
| testcase_39 | AC | 753 ms
69,120 KB |
| testcase_40 | AC | 709 ms
69,260 KB |
| testcase_41 | AC | 786 ms
71,240 KB |
| testcase_42 | AC | 754 ms
65,680 KB |
| testcase_43 | AC | 771 ms
68,952 KB |
| testcase_44 | AC | 760 ms
69,236 KB |
| testcase_45 | AC | 762 ms
69,124 KB |
| testcase_46 | AC | 722 ms
68,768 KB |
| testcase_47 | AC | 799 ms
69,140 KB |
| testcase_48 | AC | 726 ms
69,172 KB |
| testcase_49 | WA | - |
| testcase_50 | AC | 721 ms
69,156 KB |
| testcase_51 | AC | 784 ms
67,772 KB |
| testcase_52 | AC | 832 ms
68,428 KB |
| testcase_53 | AC | 789 ms
69,168 KB |
| testcase_54 | WA | - |
| testcase_55 | AC | 729 ms
69,220 KB |
| testcase_56 | AC | 728 ms
68,544 KB |
| testcase_57 | AC | 784 ms
69,228 KB |
| testcase_58 | AC | 741 ms
69,380 KB |
| testcase_59 | AC | 770 ms
71,172 KB |
| testcase_60 | AC | 771 ms
69,372 KB |
| testcase_61 | AC | 727 ms
69,112 KB |
| testcase_62 | AC | 755 ms
69,076 KB |
| testcase_63 | AC | 793 ms
68,964 KB |
| testcase_64 | WA | - |
| testcase_65 | AC | 772 ms
68,660 KB |
| testcase_66 | AC | 745 ms
68,792 KB |
| testcase_67 | AC | 746 ms
69,420 KB |
| testcase_68 | AC | 870 ms
69,652 KB |
| testcase_69 | AC | 767 ms
70,872 KB |
| testcase_70 | AC | 728 ms
68,976 KB |
| testcase_71 | AC | 766 ms
69,100 KB |
| testcase_72 | AC | 723 ms
67,492 KB |
| testcase_73 | AC | 739 ms
68,940 KB |
| testcase_74 | AC | 776 ms
71,400 KB |
| testcase_75 | AC | 736 ms
69,712 KB |
| testcase_76 | AC | 793 ms
67,852 KB |
| testcase_77 | AC | 749 ms
69,156 KB |
| testcase_78 | AC | 749 ms
69,052 KB |
| testcase_79 | AC | 739 ms
68,828 KB |
| testcase_80 | AC | 715 ms
68,924 KB |
| testcase_81 | AC | 734 ms
69,376 KB |
| testcase_82 | AC | 691 ms
69,420 KB |
| testcase_83 | AC | 774 ms
69,184 KB |
| testcase_84 | AC | 792 ms
69,104 KB |
| testcase_85 | AC | 715 ms
69,100 KB |
| testcase_86 | AC | 721 ms
69,004 KB |
| testcase_87 | AC | 795 ms
69,088 KB |
| testcase_88 | AC | 774 ms
69,560 KB |
| testcase_89 | AC | 827 ms
69,412 KB |
| testcase_90 | AC | 723 ms
69,268 KB |
| testcase_91 | AC | 747 ms
69,004 KB |
| testcase_92 | AC | 768 ms
69,128 KB |
| testcase_93 | AC | 726 ms
69,064 KB |
| testcase_94 | AC | 798 ms
69,256 KB |
| testcase_95 | AC | 773 ms
69,128 KB |
| testcase_96 | AC | 792 ms
68,920 KB |
| testcase_97 | AC | 775 ms
69,316 KB |
| testcase_98 | AC | 732 ms
69,064 KB |
| testcase_99 | WA | - |
ソースコード
import java.io.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
import java.util.stream.Collectors;
public class Main {
static boolean isLocal;
Random rand = new Random();
In in = new In(System.in);
PrintStream out = System.out;
long inf = 0x1fffffffffffffffL;
int iinf = 0x3fffffff;
long startTime;
public static final int N = 60;
public int D;
public static final int H = 1500;
public int M;
public int J;
public char[] grid;
public Pos[] ps;
public int[] ds;
public Pos[] jps;
int[][] distances;
boolean[][] beam = new boolean[60][N * N];
int[] avgWait = new int[N * N];
int[] jid = new int[N * N];
public static final String[] ss = {"M L", "M U", "M R", "M D", "S"};
long solve(int seed) {
startTime = System.currentTimeMillis();
in();
distances = new int[J+3][J+3];
for (int i = 0; i < J + 3; i++) {
Arrays.fill(distances[i], iinf);
}
for (int i = 0; i < M; i++) {
for (int d = 0; d < 4; d++) {
Pos cur = ps[i];
while (true) {
cur = cur.moved((d+2)%4);
if (cur == null || grid[cur.z] == '#') {
break;
}
for (int j = 0; j < 60; j += ds[i]) {
beam[j][cur.z] = true;
}
}
}
}
for (int i = 0; i < N * N; i++) {
int c = 1;
for (int j = 0; j < 60; j++) {
if (beam[j][i]) {
c++;
} else {
c = 1;
}
avgWait[i] += c;
}
}
for (int i = 0; i < J + 3; i++) {
calcDist(i);
}
BitSet visited = new BitSet(J + 3);
visited.set(J);
visited.set(J + 1);
visited.set(J + 2);
List<Integer> routes = new ArrayList<>();
routes.add(J);
routes.add(J + 1);
routes.add(J + 2);
int dsum = distances[J][J+1] + distances[J+1][J+2];
double[] mul = {0, 0, 0, 1.25, 1.33, 1.4, 1.6, 1.8};
while (true) {
int p;
do {
p = rand.next(0, J);
} while (visited.get(p));
int bi = -1;
int bd = iinf;
for (int i = 1; i < routes.size(); i++) {
int f = routes.get(i - 1);
int t = routes.get(i);
int diff = distances[f][p] + distances[p][t] - distances[f][t];
if (bd > diff) {
bd = diff;
bi = i;
}
}
if (bi == -1) {
continue;
}
// debug(p, bi, bd, dsum);
if (dsum + bd * mul[D] >= 60 * 750) {
break;
}
visited.set(p);
dsum += bd;
routes.add(bi, p);
}
Pos p = jps[J];
int tt = 0;
int ds1 = 0;
int ds2 = 0;
for (int i = 1; i < routes.size(); i++) {
Result res = route(jps[routes.get(i - 1)], jps[routes.get(i)], tt);
// debug(distances[routes.get(i - 1)][routes.get(i)], res.damage * 60);
ds1 += distances[routes.get(i - 1)][routes.get(i)];
ds2 += res.damage;
// debug(p, res.from, res.to);
res.out(p, tt);
tt = (tt + res.time) % 60;
p = res.to;
}
debug(D, dsum, ds1, dsum/60, ds1/60, ds2, ds2*60./dsum);
if (ds2 > 1500) {
debug("!");
}
// List<Result> routes = new ArrayList<>();
// routes.add(route(jps[J], jps[J + 1], 0));
// routes.add(route(jps[J + 1], jps[J + 2], routes.get(0).time));
// int dsum = routes.get(0).damage + routes.get(1).damage;
// while (true) {
// int p;
// do {
// p = rand.next(0, J);
// } while (visited.get(p));
// int tt = 0;
// int bi = 0;
// int bd = iinf;
// Result br1 = null, br2 = null;
// for (int i = 0; i < routes.size(); i++) {
// Result r = routes.get(i);
// Result r1 = route(r.from, jps[p], tt);
// Result r2 = route(jps[p], r.to, (tt + r.time) % 60);
// int diff = r1.damage + r2.damage - r.damage;
// if (bd > diff) {
// bd = diff;
// bi = i;
// br1 = r1;
// br2 = r2;
// }
// tt = (tt + r.time) % 60;
// }
// debug(p, bi, bd, dsum);
// if (dsum + bd >= 700) {
// break;
// }
// visited.set(p);
// dsum += bd;
// routes.set(bi, br1);
// routes.add(bi + 1, br2);
// }
// Pos p = jps[J];
// int tt = 0;
// for (Result res : routes) {
// debug(p, res.from, res.to);
// res.out(p, tt);
// tt = (tt + res.time) % 60;
// p = res.to;
// }
// visited.set(J + 2);
// visited.set(J);
// tt = moveTo(J, J+1, tt, visited);
// visited.clear(J + 2);
// tt = moveTo(J+1, J+2, tt, visited);
debug(totalCost);
return 0;
}
int totalCost = 0;
// int moveTo(int s, int g, int tt, BitSet visited) {
// int cur = s;
// int ds = 0;
// while (cur != g) {
// int md = iinf;
// int mi = -1;
// for (int i = 0; i < J + 3; i++) {
// if (visited.get(i)) {
// continue;
// }
//// debug(i, cur, jps[i].dist(jps[g]), distances[cur * (J + 3) + i]);
// int d = distances[cur * (J + 3) + i] + jps[i].dist(jps[g]) * 50;
// if (md > d) {
// md = d;
// mi = i;
// }
// }
// ds += distances[cur * (J + 3) + mi];
// visited.set(mi);
// tt = moveStraight(cur, mi, tt);
// cur = mi;
// }
// debug(ds, totalCost);
// return tt;
// }
class Result {
List<Integer> route;
int damage;
int time;
Pos from;
Pos to;
public Result(List<Integer> route, int damage, Pos from, Pos to) {
this.route = route;
this.damage = damage;
this.time = route.size() % 60;
this.from = from;
this.to = to;
}
public void out(Pos p, int tt) {
for (int v : route) {
if (v < 4) p = p.moved(v);
tt = (tt + 1) % 60;
if (beam[tt][p.z]) {
totalCost += D;
}
totalCost++;
out.println(ss[v]);
}
}
}
Result route(Pos s, Pos g, int tt) {
class S {
private final Pos p;
private final int t;
private final int d;
public S(Pos p, int t, int d) {
this.p = p;
this.t = t;
this.d = d;
}
}
PriorityQueue<S> queue = new PriorityQueue<>(Comparator.comparingInt(v -> v.d));
queue.add(new S(s, tt, 0));
int[][] dist = new int[60][N * N];
int[][] prev = new int[60][N * N];
for (int i = 0; i < 60; i++) {
Arrays.fill(dist[i], iinf);
Arrays.fill(prev[i], -1);
}
dist[tt][s.z] = 0;
while (!queue.isEmpty()) {
S v = queue.remove();
if (dist[v.t][v.p.z] < v.d) {
continue;
}
if (v.p.z == g.z) {
List<Integer> route = new ArrayList<>();
Pos cur = v.p;
int ct = v.t;
int damage = dist[ct][cur.z];
while (prev[ct][cur.z] != -1) {
route.add(prev[ct][cur.z]);
if (prev[ct][cur.z] < 4) {
cur = cur.moved((prev[ct][cur.z] + 2) % 4);
}
ct = (ct + 59) % 60;
}
Collections.reverse(route);
return new Result(route, damage, s, g);
}
int nt = (v.t + 1) % 60;
for (int d = 0; d < 4; d++) {
Pos q = v.p.moved(d);
if (q == null || grid[q.z] == '#') {
continue;
}
int cost = dist[v.t][v.p.z] + 1 + (beam[nt][q.z] ? D : 0);
if (dist[nt][q.z] > cost) {
dist[nt][q.z] = cost;
prev[nt][q.z] = d;
queue.add(new S(q, nt, cost));
}
}
int cost = dist[v.t][v.p.z] + 1 + (beam[nt][v.p.z] ? D : 0);
if (dist[nt][v.p.z] > cost) {
dist[nt][v.p.z] = cost;
prev[nt][v.p.z] = 4;
queue.add(new S(v.p, nt, cost));
}
}
throw new RuntimeException();
}
void calcDist(int s) {
class S {
private final Pos p;
private final int d;
public S(Pos p, int d) {
this.p = p;
this.d = d;
}
}
PriorityQueue<S> queue = new PriorityQueue<>(Comparator.comparingInt(v -> v.d));
queue.add(new S(jps[s], 0));
int[] dist = new int[N * N];
Arrays.fill(dist, iinf);
dist[jps[s].z] = 0;
while (!queue.isEmpty()) {
S v = queue.remove();
if (dist[v.p.z] < v.d) {
continue;
}
if (jid[v.p.z] != -1) {
distances[s][jid[v.p.z]] = v.d;
}
for (int d = 0; d < 4; d++) {
Pos q = v.p.moved(d);
if (q == null || grid[q.z] == '#') {
continue;
}
int cost = dist[v.p.z] + avgWait[q.z];
if (dist[q.z] > cost) {
dist[q.z] = cost;
queue.add(new S(q, cost));
}
}
}
}
void in() {
in.nextInt();
D = in.nextInt();
in.nextInt();
grid = new char[N * N];
int jc = 0;
for (int i = 0; i < N; i++) {
char[] s = in.nextCharArray();
for (int j = 0; j < N; j++) {
grid[i * N + j] = s[j];
if (grid[i * N + j] == 'J') {
jc++;
}
}
}
M = in.nextInt();
J = jc;
jps = new Pos[J + 3];
ps = new Pos[M];
ds = new int[M];
for (int i = 0; i < M; i++) {
int y = in.nextInt();
int x = in.nextInt();
int d = in.nextInt();
ps[i] = pos(x, y);
ds[i] = d;
}
jc = 0;
Arrays.fill(jid, -1);
for (int i = 0; i < N * N; i++) {
if (grid[i] == 'S') {
jps[J] = pos(i);
jid[i] = J;
grid[i] = '.';
} else if (grid[i] == 'K') {
jps[J + 1] = pos(i);
jid[i] = J + 1;
grid[i] = '.';
} else if (grid[i] == 'G') {
jps[J + 2] = pos(i);
jid[i] = J + 2;
grid[i] = '.';
} else if (grid[i] == 'J') {
jid[i] = jc;
jps[jc++] = pos(i);
} else if (grid[i] == 'E') {
grid[i] = '#';
}
}
}
static Pos pos(int x, int y) {
return Pos.instances[y * N + x];
}
static Pos pos(int z) {
return Pos.instances[z];
}
static class Timing {
Pos p;
int t, z;
public Timing(Pos p, int t) {
this.p = p;
this.t = t;
this.z = p.z * 60 + t;
}
}
static class Pos implements Comparable<Pos> {
static Pos[] instances;
static Pos[] moved;
static {
instances = new Pos[N * N];
moved = new Pos[4 * N * N];
for (int i = 0; i < N * N; i++) {
instances[i] = new Pos(i % N, i / N, i);
}
for (int i = 0; i < N * N; i++) {
for (int d = 0; d < 4; d++) { // LURD
int nx = i % N + (d - 1) % 2;
int ny = i / N + (d - 2) % 2;
if (0 <= nx && nx < N && 0 <= ny && ny < N) {
moved[i * 4 + d] = instances[ny * N + nx];
}
}
}
}
final int x, y, z;
private Pos(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
Pos moved(int d) {
return moved[z * 4 + d];
}
int dist(Pos o) {
return Math.abs(x - o.x) + Math.abs(y - o.y);
}
Pos[] neighbors() {
Pos[] p = new Pos[4];
int i = 0;
if ((p[i] = moved(0)) != null) i++;
if ((p[i] = moved(1)) != null) i++;
if ((p[i] = moved(2)) != null) i++;
if ((p[i] = moved(3)) != null) i++;
return i == 4 ? p : Arrays.copyOf(p, i);
}
@Override
public int compareTo(Pos o) {
return Integer.compare(z, o.z);
}
@Override
public boolean equals(Object o) {
return o instanceof Pos && z == ((Pos)o).z;
}
@Override
public int hashCode() {
return z;
}
@Override
public String toString() {
return String.format("(%d, %d)", x, y);
}
}
static void debug(Object... args) {
if (!isLocal) {
return;
}
if (args == null || args.getClass() != Object[].class) {
args = new Object[] {args};
}
System.err.println(Arrays.stream(args).map(obj -> {
Class<?> clazz = obj == null ? null : obj.getClass();
return clazz == byte[].class ? Arrays.toString((byte[])obj) :
clazz == short[].class ? Arrays.toString((short[])obj) :
clazz == int[].class ? Arrays.toString((int[])obj) :
clazz == long[].class ? Arrays.toString((long[])obj) :
clazz == char[].class ? Arrays.toString((char[])obj) :
clazz == float[].class ? Arrays.toString((float[])obj) :
clazz == double[].class ? Arrays.toString((double[])obj) :
clazz == boolean[].class ? Arrays.toString((boolean[])obj) :
obj instanceof Object[] ? Arrays.deepToString((Object[])obj) :
String.valueOf(obj);
}).collect(Collectors.joining(" ")));
}
long elapsed() {
return (long)((System.currentTimeMillis() - startTime) * (isLocal ? 1.7 : 1));
}
boolean elapsed(long timeLimit) {
return elapsed() >= timeLimit;
}
public static void main(String[] args) {
new Main().solve(0);
}
static class Random {
private long x, y, z, w;
Random() {
this(ThreadLocalRandom.current().nextLong());
}
Random(long seed) {
this.x = seed;
for (int i = 0; i < 20; i++) {
rand();
}
}
private long rand() {
long t = x ^ (x << 11);
x = y;
y = z;
z = w;
w = w ^ (w >>> 19) ^ t ^ (t >>> 8);
return x & 0x7fffffff;
}
long next() {
return rand() << 31 | rand();
}
int next(int n) {
return (int)(rand() % n);
}
int next(int l, int r) {
return (int)(rand() % (r - l) + l);
}
double nextDouble() {
return rand() / 2147483647.0;
}
}
static class In {
private final BufferedReader reader;
private StringTokenizer tokenizer;
In(InputStream input) {
this.reader = new BufferedReader(new InputStreamReader(input), 0x10000);
}
String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException ignored) {
}
return tokenizer.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
char[] nextCharArray() {
return next().toCharArray();
}
String[] nextStringArray(int n) {
String[] s = new String[n];
for (int i = 0; i < n; i++) {
s[i] = next();
}
return s;
}
char[][] nextCharGrid(int n, int m) {
char[][] a = new char[n][m];
for (int i = 0; i < n; i++) {
a[i] = next().toCharArray();
}
return a;
}
int[] nextIntArray(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
int[] nextIntArray(int n, IntUnaryOperator op) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsInt(nextInt());
}
return a;
}
int[][] nextIntMatrix(int h, int w) {
int[][] a = new int[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextIntArray(w);
}
return a;
}
long[] nextLongArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
long[] nextLongArray(int n, LongUnaryOperator op) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = op.applyAsLong(nextLong());
}
return a;
}
long[][] nextLongMatrix(int h, int w) {
long[][] a = new long[h][w];
for (int i = 0; i < h; i++) {
a[i] = nextLongArray(w);
}
return a;
}
List<List<Integer>> nextEdges(int n, int m, boolean directed) {
List<List<Integer>> res = new ArrayList<>();
for (int i = 0; i < n; i++) {
res.add(new ArrayList<>());
}
for (int i = 0; i < m; i++) {
int u = nextInt() - 1;
int v = nextInt() - 1;
res.get(u).add(v);
if (!directed) {
res.get(v).add(u);
}
}
return res;
}
}
}