[백준 14890 : 경사로] Java, 시뮬레이션

오랜만에 알고리즘 문제를 풀어냈다...

요즘 스터디에서 삼성 코테 준비하는데 너무 어려워서

건드는 것마다 못 풀어내는 중이댜 엉엉ㅠㅠ

하다 보면 늘겠지 싶지만서두 답답하다!

어쨌든 오늘은 경사로 문제를 풀어냈다!! 경사다~~~(덩실)

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

*저는 메소드를 가로 경로로만 움직이면서 경사로 조건을 체크하도록 만들었습니다.

대신 세로 경로는 입력 받을 때 가로 경로로 변환해서 입력받았어요.

map[i][j] = arr[j][i] 이렇게 입력 받았어요. 아래 사진은 map[i][j]와 arr[i][j]입니다.

(사실 메소드를 좀 활용성 있게(?) 짜보고 싶었는데 머리는 머리카락 기르는 화분인 지 잘 안 돼서

그냥 입력을 바꿔서 했어요^^ㅎㅎ)

1. 지도를 배열로 입력받는다. 

2. 탐색하면서 옆 칸과 높이차가 1이라면 

ㄱ) 오른쪽에 작은 게 있으면 ->check 메소드 호출

ㄴ) 왼쪽에 작은 게 있으면 ->check_counter 메소드 호출

3. 메소드에서 범위 체크, 경사로가 이미 존재하는 지, L개 칸이 존재하는 지 등 경사로를

만들 수 있는 지 체크한다.

4. main에서 flag값이 true인채로 한 행의 반복문이 끝나면 cnt++해준다.

이걸 map이랑 arr 배열에 대해서 각 한 번씩 해주면 됩니다.

 
package week2;
import java.util.Scanner;
 
public class bj14890 {
    static int[][]map,check,arr;
    static int cnt, L, N;
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner scan = new Scanner(System.in);
        N = scan.nextInt();
        L = scan.nextInt();
        
        map = new int[N][N];
        check = new int[N][N];
        arr = new int[N][N];
        
        for(int i=0;i<N;i++)
            for(int j=0;j<N;j++)
                map[i][j] = arr[j][i] = scan.nextInt();
        
        boolean flag = true;
        
        for(int i=0;i<N;i++) {
            for(int j=0;j<N-1;j++) {
                flag = true;
                if(Math.abs(map[i][j]-map[i][j+1])>1) {        //높이 차이가 1이상 나는 경우 
                    flag = false;
                    break;
                }
                if(map[i][j]-map[i][j+1]==1) {     
                    if(check(map,i,j+1)==false){
                        flag = false;
                        break;
                        }
                }else if(map[i][j+1]-map[i][j]==1) {
                    if(check_counter(map,i,j)==false) { 
                        flag = false;
                        break;
                    }
                }
            }
            if(flag == true) {
                cnt++;                    //가로로 경사로 놓을 수 있는 부분 카운트
            }
        }
        for(int i=0;i<N;i++) 
            for(int j=0;j<N;j++)
                check[i][j] = 0;
                                        //세로로 경사로 놓을 수 있는 부분 카운트
        for(int i=0;i<N;i++) {
            for(int j=0;j<N-1;j++) {
                flag = true;
                if(Math.abs(arr[i][j]-arr[i][j+1])>1) {        
                    flag = false;
                    break;
                }
                if(arr[i][j]-arr[i][j+1]==1) {     
                    if(check(arr,i,j+1)==false){
                        flag = false;
                        break;
                        }
                }else if(arr[i][j+1]-arr[i][j]==1) {
                    if(check_counter(arr,i,j)==false) { 
                        flag = false;
                        break;
                    }
                }
            }
            if(flag == true) {
                cnt++;            
            }
        }
        System.out.println(cnt);
    }
 
    private static boolean check_counter(int map[][],int i, int j) {
        // TODO Auto-generated method stub
        boolean flag = true;
        
        if(j-L+1<0) return false;
        if(check[i][j] == 1) return false;
        for(int k=j;k>j-L+1;k--) {
            if(map[i][k] != map[i][k-1])
                flag = false;
            if(check[i][k] == 1 || check[i][k-1] == 1)
                flag = false;
        }
        if(flag == true) {
            for(int k=j;k>j-L;k--)
                check[i][k] = 1;
        }
        return flag;
    }
 
    private static boolean check(int[][]map, int i, int j) {
        // TODO Auto-generated method stub
        
        if(j+L-1>=N) return false;
        
        boolean flag = true;
        for(int k=j;k<j+L-1;k++) {    
            if(check[i][k] == 1 || check[i][k+1] == 1)
                flag = false;
            if(map[i][k] != map[i][k+1])
                flag = false;
        }
        if(flag == true) {
            for(int k=j;k<j+L;k++)
                check[i][k] = 1;
        }
        return flag;
    }
 
}