提出 #73258252

---

ソースコード 拡げる

import java.io.*;
import java.util.*;

public class Main {

    static int N, M, T, U;
    static int[][] value;
    static int[][] owner;
    static int[][] level;

    static int myX, myY;

    static int[] dx = {1, -1, 0, 0};
    static int[] dy = {0, 0, 1, -1};

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        N = Integer.parseInt(br.readLine());
        M = Integer.parseInt(br.readLine());
        T = Integer.parseInt(br.readLine());
        U = Integer.parseInt(br.readLine());

        value = new int[N][N];
        owner = new int[N][N];
        level = new int[N][N];

        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                value[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        int[] sx = new int[M];
        int[] sy = new int[M];

        for (int i = 0; i < M; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            sx[i] = Integer.parseInt(st.nextToken());
            sy[i] = Integer.parseInt(st.nextToken());
        }

        myX = sx[0];
        myY = sy[0];

        for (int turn = 0; turn < T; turn++) {

            // Choose move
            int[] move = chooseMove();
            out.println(move[0] + " " + move[1]);
            out.flush();

            // Read turn result
            readTurn(br);

            myX = getMyPieceX();
            myY = getMyPieceY();
        }

        out.flush();
    }

    static int[] chooseMove() {
        boolean[][] reachable = getReachable();
        List<int[]> candidates = new ArrayList<>();

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (reachable[i][j] || isAdjacentToReachable(i, j, reachable)) {
                    candidates.add(new int[]{i, j});
                }
            }
        }

        double bestScore = -1e18;
        int[] bestMove = {myX, myY};

        for (int[] cell : candidates) {
            int x = cell[0], y = cell[1];
            double score = evaluate(x, y);

            if (score > bestScore) {
                bestScore = score;
                bestMove = cell;
            }
        }

        return bestMove;
    }

    static double evaluate(int x, int y) {

        int v = value[x][y];

        // Empty
        if (owner[x][y] == -1) {
            return v * 3.0;
        }

        // Own cell
        if (owner[x][y] == 0) {
            if (level[x][y] < U)
                return v * 2.0;
            else
                return -1000;
        }

        // Enemy cell
        if (level[x][y] == 1) {
            return v * 4.0;
        }

        return -v; // Avoid attacking strong cells
    }

    static boolean[][] getReachable() {
        boolean[][] visited = new boolean[N][N];
        Queue<int[]> q = new LinkedList<>();
        q.add(new int[]{myX, myY});
        visited[myX][myY] = true;

        while (!q.isEmpty()) {
            int[] cur = q.poll();
            int x = cur[0], y = cur[1];

            for (int d = 0; d < 4; d++) {
                int nx = x + dx[d];
                int ny = y + dy[d];

                if (inBounds(nx, ny) && !visited[nx][ny] && owner[nx][ny] == 0) {
                    visited[nx][ny] = true;
                    q.add(new int[]{nx, ny});
                }
            }
        }

        return visited;
    }

    static boolean isAdjacentToReachable(int x, int y, boolean[][] reachable) {
        for (int d = 0; d < 4; d++) {
            int nx = x + dx[d];
            int ny = y + dy[d];
            if (inBounds(nx, ny) && reachable[nx][ny]) return true;
        }
        return false;
    }

    static boolean inBounds(int x, int y) {
        return x >= 0 && x < N && y >= 0 && y < N;
    }

    static void readTurn(BufferedReader br) throws Exception {

        // read move destinations
        for (int i = 0; i < M; i++) br.readLine();

        // read piece end positions
        for (int i = 0; i < M; i++) br.readLine();

        // read owner
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                owner[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        // read level
        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            for (int j = 0; j < N; j++) {
                level[i][j] = Integer.parseInt(st.nextToken());
            }
        }
    }

    static int getMyPieceX() {
        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
                if (owner[i][j] == 0 && level[i][j] >= 1)
                    return i;
        return myX;
    }

    static int getMyPieceY() {
        for (int i = 0; i < N; i++)
            for (int j = 0; j < N; j++)
                if (owner[i][j] == 0 && level[i][j] >= 1)
                    return j;
        return myY;
    }
}

提出情報

ジャッジ結果