#892199 (Java21) No.5017 Tool-assisted Shooting

提出ソース

結果

問題	No.5017 Tool-assisted Shooting
ユーザー	Yu_212
提出日時	2023-07-16 16:36:19
言語	Java21 (openjdk 21)
結果	AC
実行時間	337 ms / 2,000 ms
コード長	10,859 bytes
コンパイル時間	3,355 ms
コンパイル使用メモリ	96,920 KB
実行使用メモリ	77,592 KB
スコア	3,696,320
平均クエリ数	993.73
最終ジャッジ日時	2023-07-16 16:37:03
合計ジャッジ時間	39,885 ms
ジャッジサーバーID （参考情報）	judge17 / judge16
	純コード判定しない問題か言語

このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示

入力	結果	実行時間実行使用メモリ
testcase_00	AC	301 ms 73,972 KB
testcase_01	AC	324 ms 74,488 KB
testcase_02	AC	284 ms 72,916 KB
testcase_03	AC	293 ms 74,404 KB
testcase_04	AC	291 ms 73,684 KB
testcase_05	AC	288 ms 75,572 KB
testcase_06	AC	297 ms 75,580 KB
testcase_07	AC	187 ms 70,264 KB
testcase_08	AC	320 ms 73,272 KB
testcase_09	AC	293 ms 75,168 KB
testcase_10	AC	290 ms 76,684 KB
testcase_11	AC	283 ms 74,652 KB
testcase_12	AC	323 ms 75,240 KB
testcase_13	AC	303 ms 74,844 KB
testcase_14	AC	297 ms 76,808 KB
testcase_15	AC	292 ms 74,076 KB
testcase_16	AC	324 ms 75,604 KB
testcase_17	AC	297 ms 76,544 KB
testcase_18	AC	296 ms 76,500 KB
testcase_19	AC	305 ms 74,416 KB
testcase_20	AC	311 ms 76,116 KB
testcase_21	AC	310 ms 76,428 KB
testcase_22	AC	292 ms 75,308 KB
testcase_23	AC	318 ms 75,504 KB
testcase_24	AC	296 ms 75,108 KB
testcase_25	AC	297 ms 75,660 KB
testcase_26	AC	309 ms 75,220 KB
testcase_27	AC	301 ms 77,264 KB
testcase_28	AC	306 ms 75,404 KB
testcase_29	AC	293 ms 74,912 KB
testcase_30	AC	323 ms 75,660 KB
testcase_31	AC	292 ms 75,820 KB
testcase_32	AC	299 ms 75,040 KB
testcase_33	AC	299 ms 76,344 KB
testcase_34	AC	319 ms 76,308 KB
testcase_35	AC	302 ms 75,916 KB
testcase_36	AC	291 ms 74,160 KB
testcase_37	AC	293 ms 76,012 KB
testcase_38	AC	311 ms 75,948 KB
testcase_39	AC	300 ms 76,108 KB
testcase_40	AC	302 ms 76,184 KB
testcase_41	AC	318 ms 74,984 KB
testcase_42	AC	309 ms 76,896 KB
testcase_43	AC	292 ms 75,480 KB
testcase_44	AC	300 ms 76,096 KB
testcase_45	AC	326 ms 76,612 KB
testcase_46	AC	297 ms 76,144 KB
testcase_47	AC	288 ms 75,572 KB
testcase_48	AC	323 ms 76,468 KB
testcase_49	AC	303 ms 75,788 KB
testcase_50	AC	295 ms 76,024 KB
testcase_51	AC	311 ms 76,212 KB
testcase_52	AC	324 ms 75,988 KB
testcase_53	AC	298 ms 73,396 KB
testcase_54	AC	304 ms 76,952 KB
testcase_55	AC	311 ms 76,104 KB
testcase_56	AC	296 ms 76,400 KB
testcase_57	AC	299 ms 75,776 KB
testcase_58	AC	295 ms 75,968 KB
testcase_59	AC	337 ms 73,240 KB
testcase_60	AC	302 ms 76,664 KB
testcase_61	AC	291 ms 75,136 KB
testcase_62	AC	303 ms 75,144 KB
testcase_63	AC	327 ms 76,480 KB
testcase_64	AC	305 ms 75,128 KB
testcase_65	AC	309 ms 76,952 KB
testcase_66	AC	333 ms 75,476 KB
testcase_67	AC	293 ms 73,680 KB
testcase_68	AC	290 ms 76,504 KB
testcase_69	AC	292 ms 75,412 KB
testcase_70	AC	334 ms 73,376 KB
testcase_71	AC	300 ms 75,536 KB
testcase_72	AC	290 ms 74,884 KB
testcase_73	AC	311 ms 74,992 KB
testcase_74	AC	289 ms 76,912 KB
testcase_75	AC	301 ms 75,084 KB
testcase_76	AC	295 ms 77,592 KB
testcase_77	AC	328 ms 75,884 KB
testcase_78	AC	289 ms 75,068 KB
testcase_79	AC	289 ms 74,116 KB
testcase_80	AC	301 ms 76,472 KB
testcase_81	AC	307 ms 75,892 KB
testcase_82	AC	287 ms 75,324 KB
testcase_83	AC	298 ms 74,804 KB
testcase_84	AC	330 ms 76,760 KB
testcase_85	AC	305 ms 75,348 KB
testcase_86	AC	299 ms 74,252 KB
testcase_87	AC	291 ms 75,228 KB
testcase_88	AC	329 ms 75,492 KB
testcase_89	AC	299 ms 73,264 KB
testcase_90	AC	301 ms 75,920 KB
testcase_91	AC	320 ms 75,468 KB
testcase_92	AC	290 ms 75,956 KB
testcase_93	AC	305 ms 75,080 KB
testcase_94	AC	294 ms 75,336 KB
testcase_95	AC	326 ms 74,388 KB
testcase_96	AC	304 ms 74,204 KB
testcase_97	AC	304 ms 76,180 KB
testcase_98	AC	297 ms 74,248 KB
testcase_99	AC	305 ms 75,620 KB

権限があれば一括ダウンロードができます

ソースコード

raw source code

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 dist(int a, int b, int n) {
        return Math.min(Math.abs(a - b), n - Math.abs(a - b));
    }

    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 lv = 1;
        int pc = 0;
        int x = 12;
        Monster[] monsters = new Monster[5000];
        Map<Integer, Monster> remain = new HashMap<>();
        int mid = 0;
        int score = 0;
        for (int t = 0; t < 1000; t++) {
            double sw = ((7.5+0.15*t)+(1.5+0.03*t)) / lv;
            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();
                monsters[mid] = new Monster(mid, mx, 59, mh, mp);
                remain.put(mid, monsters[mid]);
                mid++;
            }
            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;
            for (Monster monster : remain.values()) {
                int dist = dist(monster.x, x, 25);
                int turn = dist + (monster.r + lv - 1) / lv;
                if (monster.y - turn <= 0 || miny[monster.x] != monster.y) {
                    continue;
                }
//                double al = (monster.y + dist*10)*(i/1000.+0.25) - ((double)monster.p / turn)*(1-i/1000.) * 1000;
                double val;
//                val = turn - Math.max(sw-1, 0) * ((double)monster.p / turn);
                if (sw < 2) {
                    val = turn;
                } else {
                    val = -((double)monster.p / turn);
                }
//                int val = monster.y + dist*10;// + monster.h * 100 / (monster.p + 1);
                if (target == null || md > val) {
                    target = monster;
                    md = val;
                }
            }
//            if (isLocal && target != null) {
//                debug(Arrays.toString(miny));
//                debug(i, target.x, x, dist(target.x, x, 25), md, remain.size());
//            }
            if (target == null) {
                if (miny[x] == 1 && miny[(x+1)%25]>=2) {
                    x = (x + 1) % 25;
                    out.println("R");
                } else if (miny[x] == 1 && miny[(x+24)%25]>=2) {
                    x = (x + 24) % 25;
                    out.println("L");
                } else {
                    out.println("S");
                }
            } else if (miny[(x+24)%25]>=2 && (Math.abs(target.x - x) < 12 ? target.x < x : target.x > x)) {
                x = (x + 24) % 25;
                out.println("L");
            } else if (miny[(x+1)%25]>=2 && target.x != x) {
                x = (x + 1) % 25;
                out.println("R");
            } else if (miny[x] == 1 && miny[(x+1)%25]>=2) {
                x = (x + 1) % 25;
                out.println("R");
            } else if (miny[x] == 1 && miny[(x+24)%25]>=2) {
                x = (x + 24) % 25;
                out.println("L");
            } else {
                out.println("S");
            }
            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;
        }
    }
}

yukicoder

結果

テストケース

ソースコード