Submission #18993138


Source Code Expand

Copy
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayDeque;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.List;
import java.io.FileInputStream;
import java.util.Arrays;
import java.util.Queue;
import java.io.InputStream;
import java.io.FileNotFoundException;
import java.util.Random;

public class Main {
    private static final String LOG_FILE_NAME = "/Users/hiro116s/IdeaProjects/AtCoder/src/main/java/log/out.txt";
    public static Logger LOGGER;

    InputStream is;

    int __t__ = 1;
    int __f__ = 0;
    int __LOCAL_TEST_FLAG__ = __f__;
    int __FILE_DEBUG_FLAG__ = __f__;
    static String __DEBUG_FILE_NAME__ = "src/main/java/toolkit_A_v20201218_2/testcase.in";

    FastScanner in;
    PrintWriter out;

    public void solve() {
        localInputIngore();
        final WorldA world = WorldA.createFromStdin(in);
        final SolverA solver = new NaiveSolverA();
        solver.initialize(world);
        for (int turn = 0; turn < world.tMax; turn++) {
            final PowerResult[] powerResults = new PowerResult[world.getGridN()];
            for (int i = 0; i < world.getGridN(); i++) {
                final int x = in.nextInt() - 1;
                final int y = in.nextInt();
                final int powerActual = in.nextInt();
                final int powerExcess = in.nextInt();
                final int powerBuy = in.nextInt();
                powerResults[i] = new PowerResult(x, y, powerActual, powerExcess, powerBuy);
            }
            final EvInfo[] carInfos = new EvInfo[world.getEvN()];
            for (int i = 0; i < world.getEvN(); i++) {
                final int charge = in.nextInt();
                final int u = in.nextInt() - 1;
                final int v = in.nextInt() - 1;
                final int distFromU = in.nextInt();
                final int distFromV = in.nextInt();

                final int nAdj = in.nextInt();
                final int[] a = in.nextIntArray(nAdj);
                final EvPosition evPosition = new EvPosition(u, v, distFromU, distFromV);
                carInfos[i] = new EvInfo(charge, evPosition, a);
            }
            final TurnInfoA turnInfo = new TurnInfoA(powerResults, carInfos);
            final Commands commands = solver.solve(turnInfo);
            if (__LOCAL_TEST_FLAG__ == __t__) {
                LOGGER.log(turnInfo);
                LOGGER.log(commands.toAnswer());
            }
            out.println(commands.toAnswer());
            out.flush();
        }
        out.close();
    }

    private void localInputIngore() {
        if (__LOCAL_TEST_FLAG__ == __t__) {
            int pxN = in.nextInt();
            double[] x = new double[pxN];
            double[] y = new double[pxN];
            for (int i = 0; i < pxN; i++) {
                x[i] = in.nextDouble();
                y[i] = in.nextDouble();
            }
        }
    }

    public void run(String[] args) {
        if (__FILE_DEBUG_FLAG__ == __t__ || args.length == 1) {
            String fileName = __FILE_DEBUG_FLAG__ == __t__ ? __DEBUG_FILE_NAME__ : "testcase/testCase_" + args[0] + ".txt";
            try {
                is = new FileInputStream(fileName);
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
            System.out.println("FILE_INPUT!");
        } else {
            is = System.in;
        }
        in = new FastScanner(is);
        out = new PrintWriter(System.out);
        if (__LOCAL_TEST_FLAG__ == __t__) {
            try {
                LOGGER = Logger.create(LOG_FILE_NAME);
                solve();
            } catch (Throwable e) {
                LOGGER.logError(e);
                throw new RuntimeException(e);
            } finally {
                LOGGER.close();
            }
        } else {
            solve();
        }
    }

    public static void main(final String[] args) {
        new Main().run(args);
    }
}


class Logger {
    private static final boolean FLAG = false;

    final PrintWriter printWriter;

    private Logger(PrintWriter printWriter) {
        this.printWriter = printWriter;
    }

    public static Logger create(final String path) throws FileNotFoundException {
        return new Logger(new PrintWriter(path));
    }

    public void log(Object s) {
        printWriter.println(s);
    }

    void flush() {
        printWriter.flush();
    }

    public void close() {
        printWriter.close();
    }

    public void logError(Throwable e) {
        e.printStackTrace(printWriter);
    }
}


class EvInfo {
    public final int charge;
    public final EvPosition evPosition;
    public final int[] a;

    public EvInfo(int charge, EvPosition evPosition, int[] a) {
        this.charge = charge;
        this.evPosition = evPosition;
        this.a = a;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(charge).append("\n");
        res.append(evPosition.toString()).append("\n");
        res.append(a.length).append(" ");
        for (int v : a) {
            res.append(v).append(" ");
        }
        return res.deleteCharAt(res.length() - 1).toString();
    }
}


class TurnInfoA {
    public final PowerResult[] powerResults;
    public final EvInfo[] evInfos;

    public TurnInfoA(PowerResult[] powerResults, EvInfo[] evInfos) {
        this.powerResults = powerResults;
        this.evInfos = evInfos;
    }

    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        for (PowerResult pr : powerResults) {
            res.append(pr.toString()).append("\n");
        }
        for (EvInfo evInfo : evInfos) {
            res.append(evInfo.toString()).append("\n");
        }
        return res.deleteCharAt(res.length() - 1).toString();
    }
}

class PowerResult {
    final int x;
    final int y;
    final int powerActual;
    final int powerExcess;
    final int powerBuy;

    public PowerResult(int x, int y, int powerActual, int powerExcess, int powerBuy) {
        this.x = x;
        this.y = y;
        this.powerActual = powerActual;
        this.powerExcess = powerExcess;
        this.powerBuy = powerBuy;
    }

    @Override
    public String toString() {
        return x + " " + y + " " + powerActual + " " + powerExcess + " " + powerBuy;
    }
}


interface SolverA {
    void initialize(final WorldA worldA);

    Commands solve(final TurnInfoA turnInfoA);
}



class NaiveSolverA implements SolverA {
    private WorldA worldA;

    @Override
    public void initialize(final WorldA worldA) {
        this.worldA = worldA;
    }

    @Override
    public Commands solve(final TurnInfoA turnInfoA) {
        final Random rnd = new Random();
        final Commands commands = new Commands(new ArrayList<>());
        for (int i = 0; i < worldA.getEvN(); i++) {
            int[] a = turnInfoA.evInfos[i].a;
            commands.add(StayCommand.SINGLETON);
            // commands.add(new MoveCommand(a[rnd.nextInt(a.length)]));
        }
        return commands;
    }
}

interface Command {
    String toAnswer();
}

class ChargeToGrid implements Command {
    final int chargeDelta;

    public ChargeToGrid(int chargeDelta) {
        this.chargeDelta = chargeDelta;
    }

    @Override
    public String toAnswer() {
        return "charge_to_grid " + chargeDelta;
    }
}


class Commands {
    private final List<Command> commands;

    public Commands(List<Command> commands) {
        this.commands = commands;
    }

    public String toAnswer() {
        return commands.stream()
                .map(Command::toAnswer)
                .collect(Collectors.joining("\n"));
    }

    public void add(final Command command) {
        commands.add(command);
    }
}

class StayCommand implements Command {
    public static StayCommand SINGLETON = new StayCommand();

    private StayCommand() {
    }

    @Override
    public String toAnswer() {
        return "stay";
    }
}

class ChargeFromGridCommand implements Command {
    final int deltaCharge;

    public ChargeFromGridCommand(int deltaCharge) {
        this.deltaCharge = deltaCharge;
    }

    @Override
    public String toAnswer() {
        return "charge_from_grid " + deltaCharge;
    }
}

class MoveCommand implements Command {
    private final int w;

    public MoveCommand(int w) {
        this.w = w;
    }

    @Override
    public String toAnswer() {
        return "move " + w;
    }
}


class Grids {
    final Grid[] grids;
    final int cGridInit;
    final int cGridMax;
    final int vGridMax;

    private Grids(Grid[] grids, int cGridInit, int cGridMax, int vGridMax) {
        this.grids = grids;
        this.cGridInit = cGridInit;
        this.cGridMax = cGridMax;
        this.vGridMax = vGridMax;
    }

    public static Grids createFromStdin(final FastScanner in) {
        final int nGrid = in.nextInt();
        final int cGridInit = in.nextInt();
        final int cGridMax = in.nextInt();
        final int vGridMax = in.nextInt();

        final Grid[] grid = new Grid[nGrid];
        for (int i = 0; i < nGrid; i++) {
            final int x = in.nextInt();
            final int patternId = in.nextInt();
            grid[i] = new Grid(x, patternId);
        }
        return new Grids(grid, cGridInit, cGridMax, vGridMax);
    }

    public int size() {
        return grids.length;
    }
}


class WorldA {
    private final Graph<Edge> g;
    private final PowerPrediction powerPrediction;
    private final Grids grids;
    private final EVs evs;

    public final double gamma;
    public final int tMax;

    public WorldA(Graph<Edge> g, PowerPrediction powerPrediction, Grids grids, EVs evs, double gamma, int tMax) {
        this.g = g;
        this.powerPrediction = powerPrediction;
        this.grids = grids;
        this.evs = evs;
        this.gamma = gamma;
        this.tMax = tMax;
    }

    public static WorldA createFromStdin(final FastScanner in) {
        final Graph<Edge> g = GraphUtil.createFromStdIn(in);
        final PowerPrediction powerPrediction = PowerPrediction.createFromStdin(in);
        final Grids grids = Grids.createFromStdin(in);
        final EVs evs = EVs.createFromStdin(in);
        final double gamma = in.nextDouble();
        final int tMax = in.nextInt();
        return new WorldA(g, powerPrediction, grids, evs, gamma, tMax);
    }

    public int getGridN() {
        return grids.size();
    }

    public int getEvN() {
        return evs.size();
    }
}

enum DayType {
    SUNNY(0),
    SUNNY_GUERRILLA(1),
    RAINY(2),
    RAINY_WITH_SUNNY(3);

    final int id;

    DayType(int id) {
        this.id = id;
    }

    public static DayType fromId(int id) {
        for (DayType dayType: values()) {
            if (dayType.id == id) {
                return dayType;
            }
        }
        throw new IllegalArgumentException();
    }
}

class Grid {
    final int x;
    final int patternId;

    public Grid(int x, int patternId) {
        this.x = x;
        this.patternId = patternId;
    }
}


class EVs {
    final int cEvInit;
    final int cEvMax;
    final int vEvMax;
    final int deltaEvMove;
    final EV[] evs;

    public EVs(int cEvInit, int cEvMax, int vEvMax, int deltaEvMove, EV[] evs) {
        this.cEvInit = cEvInit;
        this.cEvMax = cEvMax;
        this.vEvMax = vEvMax;
        this.deltaEvMove = deltaEvMove;
        this.evs = evs;
    }

    public static EVs createFromStdin(final FastScanner in) {
        final int nEv = in.nextInt();
        final int cEvInit = in.nextInt();
        final int cEvMax = in.nextInt();
        final int vEvMax = in.nextInt();
        final int deltaEvMove = in.nextInt();
        final EV[] evs = new EV[nEv];
        for (int i = 0; i < nEv; i++) {
            final int pos = in.nextInt();
            evs[i] = new EV(pos);
        }
        return new EVs(cEvInit, cEvMax, vEvMax, deltaEvMove, evs);
    }

    public int size() {
        return evs.length;
    }
}

class EvPosition {
    final int u;
    final int v;
    final int distFromU;
    final int distFromV;

    public EvPosition(int u, int v, int distFromU, int distFromV) {
        this.u = u;
        this.v = v;
        this.distFromU = distFromU;
        this.distFromV = distFromV;
    }

    @Override
    public String toString() {
        return u + " " + v + " " + distFromU + " " + distFromV;
    }
}

class EV {
    final int pos;

    public EV(int pos) {
        this.pos = pos;
    }
}


class FastScanner {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public FastScanner(InputStream stream) {
        this.stream = stream;
        // stream = new FileInputStream(new File("dec.in"));
    }

    int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public boolean isEndline(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public int[] nextIntArray(int n) {
        int[] array = new int[n];
        for (int i = 0; i < n; i++)
            array[i] = nextInt();

        return array;
    }

    public int[][] nextIntMap(int n, int m) {
        int[][] map = new int[n][m];
        for (int i = 0; i < n; i++) {
            map[i] = nextIntArray(m);
        }
        return map;
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public long[] nextLongArray(int n) {
        long[] array = new long[n];
        for (int i = 0; i < n; i++)
            array[i] = nextLong();

        return array;
    }

    public long[][] nextLongMap(int n, int m) {
        long[][] map = new long[n][m];
        for (int i = 0; i < n; i++) {
            map[i] = nextLongArray(m);
        }
        return map;
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

    public double[] nextDoubleArray(int n) {
        double[] array = new double[n];
        for (int i = 0; i < n; i++)
            array[i] = nextDouble();

        return array;
    }

    public double[][] nextDoubleMap(int n, int m) {
        double[][] map = new double[n][m];
        for (int i = 0; i < n; i++) {
            map[i] = nextDoubleArray(m);
        }
        return map;
    }

    public String next() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String[] nextStringArray(int n) {
        String[] array = new String[n];
        for (int i = 0; i < n; i++)
            array[i] = next();

        return array;
    }

    public String nextLine() {
        int c = read();
        while (isEndline(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndline(c));
        return res.toString();
    }

    public int[][] nextPackedIntArrays(int packN, int size) {
        int[][] res = new int[packN][size];
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < packN; j++) {
                res[j][i] = nextInt();
            }
        }
        return res;
    }
}


class PowerPrediction {
    final DayType dayType;
    final int nDiv;
    final int nPattern;
    final int electricSupplySigma;
    final double pEvent;
    final int deltaEvent;
    final int[][] powerPredict;

    private PowerPrediction(DayType dayType, int nDiv, int nPattern, int electricSupplySigma, double pEvent, int deltaEvent, int[][] powerPredict) {
        this.dayType = dayType;
        this.nDiv = nDiv;
        this.nPattern = nPattern;
        this.electricSupplySigma = electricSupplySigma;
        this.pEvent = pEvent;
        this.deltaEvent = deltaEvent;
        this.powerPredict = powerPredict;
    }

    public static PowerPrediction createFromStdin(final FastScanner in) {
        final DayType dayType = DayType.fromId(in.nextInt());
        final int nDiv = in.nextInt();
        final int nPattern = in.nextInt();
        final int electricSupplySigma = in.nextInt();
        final double pEvent = in.nextDouble();
        final int deltaEvent = in.nextInt();
        final int[][] powerPredict = in.nextIntMap(nPattern, nDiv);
        return new PowerPrediction(dayType, nDiv, nPattern, electricSupplySigma, pEvent, deltaEvent, powerPredict);
    }
}

class SimpleEdge implements Edge {
    private final int to;

    public SimpleEdge(int to) {
        this.to = to;
    }

    @Override
    public int to() {
        return to;
    }

    @Override
    public long cost() {
        return 1;
    }
}

interface CappedEdge extends Edge {
    long cap();

    CappedEdge rev();

    void addCap(long cap);
}


class Graph<E extends Edge> {
    private final int n;
    private final List<E>[] g;

    public static <E extends Edge> Graph<E> create(int n) {
        @SuppressWarnings("unchecked")
        ArrayList<E>[] l = new ArrayList[n];
        for (int i = 0; i < n; i++) {
            l[i] = new ArrayList<>();
        }
        return new Graph<>(n, l);
    }

    public Graph(int n, List<E>[] g) {
        this.n = n;
        this.g = g;
    }

    public static Graph<SimpleEdge> createDirectionalTree(int[] a, int[] b) {
        if (a.length != b.length) {
            throw new IllegalArgumentException("len(a) != len(b)");
        }
        int n = a.length + 1;
        Graph<SimpleEdge> g = create(n);
        for (int i = 0; i < n - 1; i++) {
            g.addDirectionalEdge(a[i], new SimpleEdge(b[i]));
        }
        return g;
    }

    public static Graph<SimpleEdge> createUndirectionalTree(int[] a, int[] b, boolean oneOrigin) {
        if (a.length != b.length) {
            throw new IllegalArgumentException("len(a) != len(b)");
        }
        int n = a.length + 1;
        Graph<SimpleEdge> g = create(n);

        int adjust = oneOrigin ? 1 : 0;
        for (int i = 0; i < n - 1; i++) {
            g.addDirectionalEdge(a[i] - adjust, new SimpleEdge(b[i] - adjust));
            g.addDirectionalEdge(b[i] - adjust, new SimpleEdge(a[i] - adjust));
        }
        return g;
    }

    public void addDirectionalEdge(int u, E e) {
        g[u].add(e);
    }

    public List<E> edges(int u) {
        return g[u];
    }

    public int edgeNum(int u) {
        return g[u].size();
    }

    public int totalEndgeNum() {
        return Arrays.stream(g)
                .map(List::size)
                .reduce(0, Integer::sum) / 2;
    }

    public int size() {
        return n;
    }

    /**
     *
     * @param start
     * @return The cost of node v is:
     * <ul>
     *     <li>-(1L << 62) if a node is under negative loop</li>
     *     <li>(1L << 62) if there is no edge to v</li>
     *     <li>otherwise minimum cost from node u to a node</li>
     * </ul>
     */
    public long[] bellmanford(int start) {
        final long INF = 1L << 62;
        long[] dist = new long[n];
        Arrays.fill(dist, INF);
        dist[start] = 0;
        for (int i = 0; i < n - 1; i++) {
            for (int u = 0; u < n; u++) {
                for (Edge e : edges(u)) {
                    dist[e.to()] = Math.min(dist[e.to()], dist[u] + e.cost());
                }
            }
        }

        long[] res = Arrays.copyOf(dist, dist.length);
        for (int i = 0; i < n; i++) {
            for (int u = 0; u < n; u++) {
                for (Edge e : edges(u)) {
                    int v = e.to();
                    if (res[u] + e.cost() < res[v]) {
                        res[v] = -INF;
                    }
                }
            }
        }
        return res;
    }

    /**
     *
     * @param start
     * @return For each v, true if a node v can be arrived from start node, otherwise false.
     */
    public boolean[] canArrive(int start) {
        boolean[] res = new boolean[size()];
        canArriveInternal(start, res);
        return res;
    }

    private void canArriveInternal(int u, boolean[] visited) {
        visited[u] = true;
        for (Edge e : edges(u)) {
            if (visited[e.to()]) {
                continue;
            }
            canArriveInternal(e.to(), visited);
        }
    }

    public DiameterResult diameter() {
        if (totalEndgeNum() != n - 1) {
            throw new IllegalArgumentException("Graph should be tree");
        }
        int[] parents = new int[size()];
        int[] dist = new int[size()];
        Arrays.fill(dist, -1);
        dfs(0, dist, parents, 0);

        int x = 0;
        for (int i = 1; i < size(); i++) {
            if (dist[x] < dist[i]) {
                x = i;
            }
        }

        int[] dist2 = new int[size()];
        Arrays.fill(dist2, -1);
        parents[x] = x;
        dfs(x, dist2, parents, 0);

        int best = 0;
        for (int i = 0; i < n; i++) {
            if (dist2[best] < dist2[i]) {
                best = i;
            }
        }
        return new DiameterResult(restore(x, best, parents), dist2[best] + 1);
    }

    private int[] restore(int from, int to, int[] parents) {
        List<Integer> pathL = new ArrayList<>();
        int cur = to;
        while (cur != from) {
            pathL.add(cur);
            cur = parents[cur];
        }
        pathL.add(from);

        int[] res = new int[pathL.size()];
        for (int i = 0; i < pathL.size(); i++) {
            res[i] = pathL.get(pathL.size() - i - 1);
        }
        return res;
    }

    private void dfs(int u, int[] dist, int[] parent, int depth) {
        dist[u] = depth;
        for (Edge e : g[u]) {
            if (dist[e.to()] != -1) {
                continue;
            }
            parent[e.to()] = u;
            dfs(e.to(), dist, parent, depth + 1);
        }
    }

    public static class DiameterResult {
        public final int[] path;
        public final int dist;

        public DiameterResult(int[] path, int dist) {
            this.path = path;
            this.dist = dist;
        }

        @Override
        public String toString() {
            return "DiameterResult{" +
                    "path=" + Arrays.toString(path) +
                    ", dist=" + dist +
                    '}';
        }
    }

    /**
     * Assuming edge is SimpleEdge
     * @param start
     * @return
     */
    public int[] bfs(int start) {
        int n = g.length;
        int[] dist = new int[n];
        Arrays.fill(dist, 1 << 30);
        dist[start] = 0;

        Queue<Integer> q = new ArrayDeque<>();
        q.add(start);
        while (!q.isEmpty()) {
            int u = q.poll();
            for (Edge e : g[u]) {
                if (dist[e.to()] == 1 << 30) {
                    dist[e.to()] = dist[u] + 1;
                    q.add(e.to());
                }
            }
        }
        return dist;
    }
}

class EdgeImpl implements Edge {
    private final int to;
    private final long cost;

    public EdgeImpl(int to, long cost) {
        this.to = to;
        this.cost = cost;
    }

    @Override
    public int to() {
        return to;
    }

    @Override
    public long cost() {
        return cost;
    }
}

interface EdgeGenerator<E extends Edge> {
    E generate(int to, E originalEdge);
}

class CappedEdgeImpl implements CappedEdge {
    final int to;
    final long cost;

    private long cap;
    private CappedEdge rev;

    private CappedEdgeImpl(int to, long cost, long cap) {
        this.to = to;
        this.cost = cost;
        this.cap = cap;
    }

    public static class CappedEdgePair {
        public final CappedEdge normal;
        public final CappedEdge rev;

        public CappedEdgePair(CappedEdge normal, CappedEdge rev) {
            this.normal = normal;
            this.rev = rev;
        }
    }

    public static CappedEdgePair pairedEdges(int from, int to, long cap, long cost) {
        CappedEdgeImpl e = new CappedEdgeImpl(to, cost, cap);
        CappedEdgeImpl revE = new CappedEdgeImpl(from, -cost, 0);
        e.rev = revE;
        revE.rev = e;
        return new CappedEdgePair(e, revE);
    }

    public static CappedEdgePair pairedEdgesForMaxFlow(int from, int to, long cap) {
        return pairedEdges(from, to, cap, Long.MAX_VALUE);
    }

    @Override
    public int to() {
        return to;
    }

    @Override
    public long cost() {
        return cost;
    }

    @Override
    public long cap() {
        return cap;
    }

    @Override
    public CappedEdge rev() {
        return rev;
    }

    @Override
    public void addCap(long cap) {
        this.cap += cap;
    }
}

interface Edge {
    int to();

    long cost();
}


class GraphUtil {
    private GraphUtil() {
    }

    public static Graph<Edge> createFromStdIn(final FastScanner in) {
        final int V = in.nextInt();
        final int E = in.nextInt();
        final Graph<Edge> g = Graph.create(V);
        for (int i = 0; i < E; i++) {
            int u = in.nextInt() - 1;
            int v = in.nextInt() - 1;
            int d = in.nextInt();
            g.addDirectionalEdge(u, new EdgeImpl(v, d));
            g.addDirectionalEdge(v, new EdgeImpl(u, d));
        }
        return g;
    }
}

Submission Info

Submission Time
Task A - hokudai_hitachi2020_a
User hiro116s
Language Java (OpenJDK 11.0.6)
Score 0
Code Size 26974 Byte
Status RE
Exec Time 129 ms
Memory 13772 KB

Judge Result

Set Name All
Score / Max Score 0 / 9999999999999
Status
RE × 16
Set Name Test Cases
All test_case_1, test_case_10, test_case_11, test_case_12, test_case_13, test_case_14, test_case_15, test_case_16, test_case_2, test_case_3, test_case_4, test_case_5, test_case_6, test_case_7, test_case_8, test_case_9
Case Name Status Exec Time Memory
test_case_1 RE 123 ms 4808 KB
test_case_10 RE 124 ms 4880 KB
test_case_11 RE 121 ms 4804 KB
test_case_12 RE 123 ms 4812 KB
test_case_13 RE 125 ms 4892 KB
test_case_14 RE 123 ms 4836 KB
test_case_15 RE 129 ms 4964 KB
test_case_16 RE 34 ms 13772 KB
test_case_2 RE 123 ms 4864 KB
test_case_3 RE 125 ms 4884 KB
test_case_4 RE 124 ms 4872 KB
test_case_5 RE 123 ms 4896 KB
test_case_6 RE 122 ms 4844 KB
test_case_7 RE 122 ms 4876 KB
test_case_8 RE 125 ms 4908 KB
test_case_9 RE 123 ms 4948 KB