結果

問題 No.5017 Tool-assisted Shooting
ユーザー Yu_212Yu_212
提出日時 2023-07-16 18:02:21
言語 Java21
(openjdk 21)
結果
AC  
実行時間 349 ms / 2,000 ms
コード長 10,873 bytes
コンパイル時間 3,770 ms
コンパイル使用メモリ 96,312 KB
実行使用メモリ 73,340 KB
スコア 3,992,366
平均クエリ数 1000.00
最終ジャッジ日時 2023-07-16 18:03:03
合計ジャッジ時間 41,088 ms
ジャッジサーバーID
（参考情報） 		judge15 / judge17
純コード判定しない問題か言語
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 320 ms
71,224 KB
testcase_01 AC 314 ms
71,300 KB
testcase_02 AC 296 ms
71,916 KB
testcase_03 AC 311 ms
71,136 KB
testcase_04 AC 309 ms
70,772 KB
testcase_05 AC 328 ms
71,432 KB
testcase_06 AC 337 ms
71,376 KB
testcase_07 AC 310 ms
70,756 KB
testcase_08 AC 303 ms
71,108 KB
testcase_09 AC 304 ms
70,764 KB
testcase_10 AC 318 ms
71,264 KB
testcase_11 AC 331 ms
69,084 KB
testcase_12 AC 309 ms
71,068 KB
testcase_13 AC 309 ms
71,460 KB
testcase_14 AC 341 ms
71,512 KB
testcase_15 AC 315 ms
71,520 KB
testcase_16 AC 306 ms
68,992 KB
testcase_17 AC 314 ms
71,268 KB
testcase_18 AC 346 ms
70,796 KB
testcase_19 AC 318 ms
71,164 KB
testcase_20 AC 308 ms
71,560 KB
testcase_21 AC 341 ms
70,736 KB
testcase_22 AC 303 ms
69,152 KB
testcase_23 AC 295 ms
71,660 KB
testcase_24 AC 317 ms
71,292 KB
testcase_25 AC 314 ms
71,924 KB
testcase_26 AC 312 ms
71,740 KB
testcase_27 AC 310 ms
72,300 KB
testcase_28 AC 349 ms
69,472 KB
testcase_29 AC 302 ms
70,860 KB
testcase_30 AC 299 ms
71,424 KB
testcase_31 AC 319 ms
71,356 KB
testcase_32 AC 317 ms
69,904 KB
testcase_33 AC 324 ms
71,216 KB
testcase_34 AC 310 ms
71,040 KB
testcase_35 AC 318 ms
71,524 KB
testcase_36 AC 305 ms
71,080 KB
testcase_37 AC 309 ms
70,820 KB
testcase_38 AC 341 ms
71,524 KB
testcase_39 AC 311 ms
71,304 KB
testcase_40 AC 312 ms
71,388 KB
testcase_41 AC 310 ms
70,756 KB
testcase_42 AC 342 ms
70,888 KB
testcase_43 AC 311 ms
71,084 KB
testcase_44 AC 316 ms
71,028 KB
testcase_45 AC 323 ms
71,328 KB
testcase_46 AC 314 ms
70,832 KB
testcase_47 AC 302 ms
70,900 KB
testcase_48 AC 320 ms
71,972 KB
testcase_49 AC 313 ms
71,572 KB
testcase_50 AC 317 ms
71,080 KB
testcase_51 AC 313 ms
69,672 KB
testcase_52 AC 319 ms
70,980 KB
testcase_53 AC 302 ms
71,604 KB
testcase_54 AC 324 ms
71,328 KB
testcase_55 AC 323 ms
69,692 KB
testcase_56 AC 316 ms
69,688 KB
testcase_57 AC 300 ms
71,136 KB
testcase_58 AC 317 ms
70,808 KB
testcase_59 AC 325 ms
69,696 KB
testcase_60 AC 316 ms
71,088 KB
testcase_61 AC 315 ms
70,168 KB
testcase_62 AC 312 ms
71,100 KB
testcase_63 AC 315 ms
71,296 KB
testcase_64 AC 324 ms
71,084 KB
testcase_65 AC 326 ms
72,156 KB
testcase_66 AC 322 ms
71,264 KB
testcase_67 AC 315 ms
70,676 KB
testcase_68 AC 306 ms
71,256 KB
testcase_69 AC 323 ms
71,772 KB
testcase_70 AC 317 ms
72,784 KB
testcase_71 AC 324 ms
71,660 KB
testcase_72 AC 304 ms
69,712 KB
testcase_73 AC 315 ms
71,804 KB
testcase_74 AC 303 ms
71,320 KB
testcase_75 AC 300 ms
69,128 KB
testcase_76 AC 321 ms
71,008 KB
testcase_77 AC 312 ms
71,364 KB
testcase_78 AC 314 ms
71,844 KB
testcase_79 AC 302 ms
71,532 KB
testcase_80 AC 313 ms
70,976 KB
testcase_81 AC 294 ms
71,452 KB
testcase_82 AC 299 ms
71,164 KB
testcase_83 AC 319 ms
73,340 KB
testcase_84 AC 315 ms
71,536 KB
testcase_85 AC 310 ms
71,548 KB
testcase_86 AC 311 ms
69,072 KB
testcase_87 AC 308 ms
70,696 KB
testcase_88 AC 317 ms
71,600 KB
testcase_89 AC 313 ms
71,724 KB
testcase_90 AC 325 ms
71,088 KB
testcase_91 AC 314 ms
71,072 KB
testcase_92 AC 306 ms
70,684 KB
testcase_93 AC 319 ms
70,924 KB
testcase_94 AC 298 ms
70,776 KB
testcase_95 AC 314 ms
71,208 KB
testcase_96 AC 313 ms
72,032 KB
testcase_97 AC 323 ms
70,972 KB
testcase_98 AC 312 ms
70,552 KB
testcase_99 AC 316 ms
70,940 KB
権限があれば一括ダウンロードができます

ソースコード

diff # 

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;

    int distLeft(int a, int b) {
        return a < b ? 25 + a - b : a - b;
    }

    int distRight(int a, int b) {
        return a < b ? b - a : 25 + b - a;
    }

    boolean sw = false;
    int act(int t) {
        double str = ((7.5+0.15*t)+(1.5+0.03*t)) / lv;
        if (str < 2) {
            sw = true;
        }
        int[] miny = new int[25];
        Arrays.fill(miny, 60);
        for (Monster monster : remain.values()) {
            miny[monster.x] = Math.min(miny[monster.x], monster.y);
        }
        Monster target = null;
        double md = iinf;
        boolean canMoveLeft = miny[(x+24)%25]>=2;
        boolean canMoveRight = miny[(x+1)%25]>=2;
        for (Monster monster : remain.values()) {
            int dist = x == monster.x ? 0 : iinf;
            if (canMoveLeft) {
                dist = Math.min(dist, distLeft(x, monster.x));
            }
            if (canMoveRight) {
                dist = Math.min(dist, distRight(x, monster.x));
            }
            int turn = dist + (monster.r + lv - 1) / lv;
            if (monster.y - turn <= 0 || miny[monster.x] != monster.y) {
                continue;
            }
            double val;
            if (sw) {
                val = turn;
//                    val = -((double)monster.h / turn);
            } else {
                val = -((double)monster.p / turn);
            }
            if (target == null || md > val) {
                target = monster;
                md = val;
            }
        }
//        cout << turn << " " << tai.first << " " << tai.second << " " << md << " " << sw << endl;

//        debug(t, target.x, target.y, md, sw, target.r);
        if (target != null) {
            if (miny[x] >= 2 && target.x == x) {
                return 0;
            } else if (canMoveLeft && (!canMoveRight || distLeft(x, target.x) < distRight(x, target.x))) {
                return -1;
            } else {
                return 1;
            }
        } else {
            if (miny[x] >= 2) {
                return 0;
            } else if (canMoveLeft && !canMoveRight) {
                return -1;
            } else {
                return 1;
            }
        }
    }

    int lv = 1;
    int pc = 0;
    int x = 12;
    Map<Integer, Monster> remain = new HashMap<>();
    long solve(int seed) {
//        Trial tr = ((NormalDebugger)this).trial;
//        double aa = tr.getParameterDouble("aa");
//        double bb = tr.getParameterDouble("bb");
//        double cc = tr.getParameterDouble("cc");
        startTime = System.currentTimeMillis();
        if (isLocal) {
            int[] p = in.nextIntArray(25);
        }
        int mid = 0;
        int score = 0;
        for (int t = 0; t < 1000; t++) {
            System.out.flush();
            int n = in.nextInt();
            if (n == -1) {
                break;
            }
            remain.values().removeIf(monster -> {
                monster.y--;
                return monster.y < 0;
            });
            for (Monster monster : remain.values()) {
                if (monster.y ==0 && monster.x == x) {
                    debug("!");
                    if (isLocal) {
                        return score;
                    }
//                    throw new RuntimeException();
                }
            }
            for (int j = 0; j < n; j++) {
                int mh = in.nextInt();
                int mp = in.nextInt();
                int mx = in.nextInt();
                remain.put(mid, new Monster(mid, mx, 59, mh, mp));
                mid++;
            }
            int dir = act(t);
            if (dir == 0) {
                out.println("S");
            } else if (dir == -1) {
                out.println("L");
                x = (x + 24) % 25;
            } else {
                out.println("R");
                x = (x + 1) % 25;
            }
//            if (isLocal && target != null) {
//                debug(Arrays.toString(miny));
//                debug(i, target.x, x, dist(target.x, x, 25), md, remain.size());
//            }
            Monster attack = null;
            for (Monster monster : remain.values()) {
                if (monster.x != x) {
                    continue;
                }
                if (attack == null || monster.y < attack.y) {
                    attack = monster;
                }
            }
            if (attack != null) {
                attack.r -= lv;
                if (attack.r <= 0) {
                    pc += attack.p;
                    lv = 1 + pc / 100;
                    score += attack.h;
                    remain.remove(attack.id);
                }
            }
        }
        return score;
    }

    static class Monster {
        int id;
        int x;
        int y;
        int h;
        int r;
        int p;

        public Monster(int id, int x, int y, int h, int p) {
            this.id = id;
            this.x = x;
            this.y = y;
            this.h = h;
            this.r = h;
            this.p = p;
        }
    }

    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;
        }
    }
}
0