브루트포스(체스판 다시 칠하기)

[체스판 다시 칠하기 - 1018]

 

 

* 로직

• (0,0)부터 8*8 보드를 만들 수 있는 기준점으로 한 칸씩 이동한다
• 이동하면서 왼쪽 상단의 시작인 "W", "B"인 경우를 고려한다
• "W"인 경우
  • 행이 짝수이면서
    • 열도 짝수라면 -> 해당 좌표 값이 "W"가 아니면 cnt++
    • 열이 홀수라면 -> 해당 좌표 값이 "B"가 아니면 cnt++
  • 행이 홀수이면서
    • 열이 짝수라면 -> 해당 좌표 값이 "B"가 아니면 cnt++
    • 열이 홀수라면 -> 해당 좌표 값이 "W"가 아니면 cnt++
• "B"인 경우도 같은 방식으로 진행한다
• 최소 개수를 갱신하고 출력한다

 

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

public class Problem_1018 {
    static int N,M;
    static int Size = 8;
    static String[][] map;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        String input = br.readLine();
        st = new StringTokenizer(input, " ");
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());

        map = new String[N][M];
        for(int i=0; i<N; ++i){
            input = br.readLine();
            for(int j=0; j<M; ++j){
                map[i][j] = input.substring(j, j+1);
            }
        }

        //기준점 이동
        int answer = Integer.MAX_VALUE;
        for(int i=0; i<N-Size+1; ++i){
            for(int j=0; j<M-Size+1; ++j){

                //해당 기준점이 W로 시작하는 경우 고려
                answer = Math.min(answer, doProcess(i, j, "W"));

                //해당 기준점이 B로 시작하는 경우 고려
                answer = Math.min(answer, doProcess(i, j, "B"));
            }
        }

        System.out.println(answer);
    }

    private static int doProcess(int row, int col, String type) {
        int cnt = 0;

        switch (type){
            case "W":
                for(int a=0; a<8; ++a) {
                    for (int b=0; b<8; ++b) {
                        //행이 짝수 위치에서
                        if(a % 2 == 0){
                            //열이 짝수인 경우, W가 존재하지 않다면 카운트
                            if(b % 2 == 0){
                                if(!map[row+a][col+b].equals("W")) cnt++;
                            }

                            //열이 홀수인 경우, B가 존재하지 않다면 카운트
                            else {
                                if(!map[row+a][col+b].equals("B")) cnt++;
                            }
                        }

                        //행이 홀수 위치에서
                        else {
                            //열이 짝수인 경우, B가 존재하지 않다면 카운트
                            if(b % 2 == 0){
                                if(!map[row+a][col+b].equals("B")) cnt++;
                            }

                            //열이 홀수인 경우, W가 존재하지 않다면 카운트
                            else {
                                if(!map[row+a][col+b].equals("W")) cnt++;
                            }
                        }
                    }
                }
            break;

            case "B":
                for(int a=0; a<8; ++a) {
                    for (int b=0; b<8; ++b) {
                        //행이 짝수 위치에서
                        if(a % 2 == 0){
                            //열이 짝수인 경우, B가 존재하지 않다면 카운트
                            if(b % 2 == 0){
                                if(!map[row+a][col+b].equals("B")) cnt++;
                            }

                            //열이 홀수인 경우, W가 존재하지 않다면 카운트
                            else {
                                if(!map[row+a][col+b].equals("W")) cnt++;
                            }
                        }

                        //행이 홀수 위치에서
                        else {
                            //열이 짝수인 경우, W가 존재하지 않다면 카운트
                            if(b % 2 == 0){
                                if(!map[row+a][col+b].equals("W")) cnt++;
                            }

                            //열이 홀수인 경우, B가 존재하지 않다면 카운트
                            else {
                                if(!map[row+a][col+b].equals("B")) cnt++;
                            }
                        }
                    }
                }
            break;
        }

        return cnt;
    }
}