곽로그

[백준14500, Java] 테트로미노 본문

알고리즘/백준

[백준14500, Java] 테트로미노

일도이동 2020. 11. 26. 18:51
반응형

문제

www.acmicpc.net/problem/14500

 

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

 

 

풀이

  각 폴리오미노를 대칭, 회전시켜 나올 수 있는 모든 경우에 대해 구했다. 

 

check

 폴리오미노를  for문으로 ****를 체크하는 게 아니라  좀 더 쉽게 체크할 수 있는 방법이 있을 것 같다. 

 

코드

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.StringTokenizer;

public class Main {
    public static int N;
    public static int M;
    public static int[][] MAP;
    public static int MAX;

    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine()," ");
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        MAP = new int[N][M];
        MAX = -1;

        for(int r= 0 ; r<N; r++){
            st = new StringTokenizer(br.readLine()," ");
            for(int c=0; c<M; c++){
                MAP[r][c] = Integer.parseInt(st.nextToken());
            }
        }

        findMax();
        bw.write(String.valueOf(MAX));
        bw.flush();
    }
    public static void findMax(){
        int sum = 0;
        /*
            * * * *
         */
        for(int r = 0; r<N; r++){
            for(int c = 0; c<M-3; c++){
                sum = MAP[r][c] + MAP[r][c+1] + MAP[r][c+2] +MAP[r][c+3];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            *
            *
            *
            *
         */

        for(int r=0; r<N-3; r++){
            for(int c=0; c<M; c++){
                sum = MAP[r][c] + MAP[r+1][c] +MAP[r+2][c] +MAP[r+3][c];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            * *
            * *
         */

        for(int r= 0 ;r<N-1; r++){
            for(int c=0; c<M-1; c++){
                sum = MAP[r][c] + MAP[r][c+1] +MAP[r+1][c] +MAP[r+1][c+1];
                MAX = Math.max(MAX,sum);
            }
        }
        /*
            *
            *
            * *
         */
        for(int r=0; r<N-2; r++){
            for(int c=0; c<M-1; c++){
                sum = MAP[r][c] + MAP[r+1][c] + MAP[r+2][c] + MAP[r+2][c+1];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            * * *
            *
         */
        for(int r= 0 ;r<N-1; r++){
            for(int c=0; c<M-2; c++){
                sum = MAP[r][c] + MAP[r][c+1] +MAP[r][c+2] + MAP[r+1][c];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            * *
              *
              *
         */
        for(int r=0 ; r<N-2; r++){
            for(int c=0; c<M-1; c++){
                sum = MAP[r][c] + MAP[r][c+1] +MAP[r+1][c+1] + MAP[r+2][c+1];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
                  *
              * * *
         */
        for(int r=0; r<N-1; r++){
            for(int c=2; c<M; c++){
                sum = MAP[r][c] + MAP[r+1][c] +MAP[r+1][c-1] +MAP[r+1][c-2];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
             *
             *
           * *
         */
        for(int r=0; r<N-2; r++){
            for(int c=1 ; c<M; c++){
                sum = MAP[r][c] + MAP[r+1][c] +MAP[r+2][c] + MAP[r+2][c-1];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            * * *
                *
         */

        for(int r=0; r<N-1; r++){
            for(int c=0; c<M-2; c++){
                sum = MAP[r][c] + MAP[r][c+1] + MAP[r][c+2] + MAP[r+1][c+2];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            * *
            *
            *
         */
        for(int r= 0 ;r<N-2; r++){
            for(int c=0 ;c<M-1; c++){
                sum =MAP[r][c] + MAP[r][c+1] +MAP[r+1][c] +MAP[r+2][c];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            *
            * * *
         */
        for(int r= 0; r<N-1; r++){
            for(int c=0; c<M-2; c++){
                sum = MAP[r][c] + MAP[r+1][c] + MAP[r+1][c+1] + MAP[r+1][c+2];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            *
            *  *
               *
         */
        for(int r = 0; r<N-2; r++){
            for(int c=0; c<M-1; c++){
                sum = MAP[r][c] + MAP[r+1][c] + MAP[r+1][c+1] + MAP[r+2][c+1];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
               * *
           *  *
         */

        for(int r=0; r<N-1; r++){
            for(int c=2; c<M; c++){
                sum = MAP[r][c] +MAP[r][c-1] + MAP[r+1][c-1]+ MAP[r+1][c-2];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
                 *
              *  *
              *
         */
        for(int r= 0; r<N-2; r++){
            for(int c=1; c<M; c++){
                sum = MAP[r][c] + MAP[r+1][c] + MAP[r+1][c-1] +MAP[r+2][c-1];
                MAX = Math.max(MAX,sum);
            }
        }
        /*
            * *
              * *
         */
        for(int r=0; r<N-1; r++){
            for(int c=0; c<M-2; c++){
                sum = MAP[r][c] + MAP[r][c+1] + MAP[r+1][c+1] + MAP[r+1][c+2];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            * * *
              *
         */

        for(int r=0; r<N-1; r++){
            for(int c=0; c<M-2; c++){
                sum = MAP[r][c] + MAP[r][c+1] + MAP[r][c+2] +MAP[r+1][c+1];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
            *
            * *
            *
         */
        for(int r =0 ;r<N-2; r++){
            for(int c=0; c<M-1; c++){
                sum = MAP[r][c] + MAP[r+1][c] + MAP[r+1][c+1] + MAP[r+2][c];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
                *
             *  *  *
         */
        for(int r= 0; r<N-1; r++){
            for(int c= 1; c<M-1; c++){
                sum = MAP[r][c] + MAP[r+1][c] + MAP[r+1][c-1] + MAP[r+1][c+1];
                MAX = Math.max(MAX,sum);
            }
        }

        /*
                *
             *  *
                *
         */
        for(int r= 0; r<N-2; r++){
            for(int c=1; c<M; c++){
                sum = MAP[r][c] + MAP[r+1][c-1] + MAP[r+1][c] + MAP[r+2][c];
                MAX = Math.max(MAX,sum);
            }
        }
    }
}

 

반응형

'알고리즘 > 백준' 카테고리의 다른 글

[백준 1107, Java] 리모컨  (0) 2020.11.27
[백준 9461, Java] 파도반 수열  (0) 2020.11.27
[백준 2800, Java] 괄호제거  (1) 2020.11.26
[백준 2309, Java] 일곱 난쟁이  (0) 2020.11.24
[백준 1662, Java] 압축  (0) 2020.11.22
Comments