[Java] 백준 17265번 : 나의 인생에는 수학과 함께

https://www.acmicpc.net/problem/17265

17265번: 나의 인생에는 수학과 함께

---

💡 문제 풀이

그래프 탐색 문제이다. 범위가 작아서 백트래킹으로 구현했다.

 

전역적으로 연산자에 대해서 관리했다.

따라서, 연산자일 때 새롭게 연산자를 초기화해 주고,

연산자가 아니라면 기존의 연산자로 돌려주는 것이 핵심이다.

✔️ 느낀 점

자바로 푸니까 확실히 어렵지만 할만한 문제였다. 

사실 int 형으로 변환할 때 parseInt를 쓰고 싶지 않아서 char형으로 갔는데 타입은 편한 대로 하는 게 좋을 것 같다.

💻 코드

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    private static final char PLUS = '+';
    private static final char MINUS = '-';
    private static final char MULTIPLY = '*';
    static BufferedReader br = newBufferedReader();
    static int[] dx = {0, 1};
    static int[] dy = {1, 0};
    static int min = Integer.MAX_VALUE;
    static int max = Integer.MIN_VALUE;
    static int n;
    static char operator;
    static char[][] board;

    public static void main(String[] args) throws IOException {
        initStatic();
        solution(1, 1, toInt(board[1][1]));
        System.out.println(max + " " + min);
    }

    private static void solution(int x, int y, int value) {
        if (isDestination(x, y)) {
            min = Math.min(min, value);
            max = Math.max(max, value);
            return;
        }

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

            if (isInBoundary(nx, ny)) {
                if (isOperator(nx, ny)) {
                    operator = board[nx][ny];
                    solution(nx, ny, value);
                } else {
                    solution(nx, ny, calculate(nx, ny, value));
                    operator = board[x][y];
                }
            }
        }
    }

    private static boolean isOperator(int x, int y) {
        char target = board[x][y];
        return target == PLUS || target == MINUS || target == MULTIPLY;
    }

    private static boolean isInBoundary(int x, int y) {
        return x <= n && y <= n;
    }

    private static int calculate(int x, int y, int value) {
        int result = value;

        switch (operator) {
            case PLUS:
                result += toInt(board[x][y]);
                break;
            case MINUS:
                result -= toInt(board[x][y]);
                break;
            default:
                result *= toInt(board[x][y]);
        }

        return result;
    }

    private static int toInt(char value) {
        return value - '0';
    }

    private static boolean isDestination(int x, int y) {
        return x == n && y == n;
    }

    private static void initStatic() throws IOException {
        n = readInput();

        board = new char[n+1][];
        for (int i = 1 ; i <= n ; i++) {
            board[i] = readInputsAsArray();
        }
    }

    private static char[] readInputsAsArray() throws IOException {
        char[] result = new char[n + 1];
        char[] inputs = br.readLine().replaceAll(" ", "").toCharArray();

        for (int i = 1; i <= n; i++) {
            result[i] = inputs[i - 1];
        }

        return result;
    }

    private static int readInput() throws IOException {
        return Integer.parseInt(br.readLine());
    }

    private static BufferedReader newBufferedReader() {
        return new BufferedReader(new InputStreamReader(System.in));
    }
}