백준 14890번: 경사로

백준 14890번: 경사로

14890번: 경사로

단순 노가다로 풀었다. 다른 쉬운 방법이 있을 것 같지만 난 무식하게 행에 대한 연산과 열에 대한 연산을 진행했고, 조건 검사해야 하는 부분이 많아 코드가 엄청나게 길어졌다.

난 이렇게 문제를 풀었다.

 

1. 전과 같은 층일 때 같은 층 개수 카운터를 해준다.

2. 만약 다른 층일 경우 두가지를 본다

2-1. 두 층의 차가 1이 넘으면 이동할 수 없는 길이다.

2-2. 두 층의 차가 1이면 다음 3-1과 3-2를 확인한다.

3-1. 다음 층이 지금 층보다 높은가?

3-1-1. 같은 층 카운터가 사다리 길이보다 길고, 사다리 길이 만큼의 같은층에서 사다리가 이미 놓여져있는 곳이 있는가?

3-2. 다음 층이 지금 층보다 낮은가?

3-2-1. 높아야할 사다리 길이를 놓는 횟수에 초기화한다.

3-2-2. 1번으로 돌아가 다시 진행하되 사다리를 놓는 횟수가 0이 아닌가?

3-2-3. 놓는 횟수가 0이 아니면 다음 진행하는 길이 전과 같은 층인가?

 

신경써야할 부분이 엄청나게 많다.

이것을 이용해 각 행의 길과 열의 길을 카운터해준다.

코드가 길어져 조금만 실수하면 틀린거 찾느라 바쁠것 같았다.

다행히 틀린거 없이 코드가 잘 이루어져 테스트케이스를 통과했다.

 

#include<iostream>
#include<cstring>
using namespace std;

int mapSize;
int arrMap[100][100];
int leader[100][100];
int answer = 0;
int leaderLength;

int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    cin >> mapSize >> leaderLength;
    for(int row = 0; row < mapSize; row++){
        for(int col = 0; col < mapSize; col++){
            cin >> arrMap[row][col];
        }
    }
    for(int row = 0; row < mapSize; row++){
        int first = arrMap[row][0];
        int samefloor = 1;
        int lowerfloor = 0;
        bool enableMove = true;
        for(int col = 1; col < mapSize; col++){
            // 한번 내려온 경우
            if(lowerfloor > 0){
                if(first == arrMap[row][col]){
                    lowerfloor-=1;
                    leader[row][col] = true;
                }
                else{
                    enableMove = false;
                    break;
                }
            }
            // 같은 층일 때
            if(arrMap[row][col] == first){
                samefloor += 1;
                continue;
            }
            // 다른 층일 때
            else if(arrMap[row][col] != first){
                // 차가 1이 이상이면 길이 아님
                if(abs(arrMap[row][col] - first) > 1){
                    enableMove = false;
                    break;
                }
                // 차가 1일 경우
                else{
                    // 높은 길일 경우
                    if(arrMap[row][col] - first > 0){
                        // 같은 층의 바닥 수와 놓을 수 있는 사다리 길이를 비교
                        if(samefloor >= leaderLength){
                            for(int backField = 1; backField <= leaderLength; backField++){
                                // 이미 사다리가 놓아져 있다면 길이 아니다.
                                if(leader[row][col - backField]){
                                    enableMove = false;
                                    break;
                                }
                                // 사다리를 놓는다.
                                leader[row][col - backField] = true;
                            }
                            first = arrMap[row][col];
                            //samefloor = 0;
                        } else {
                            enableMove = false;
                            break;
                        }
                    }
                    // 낮은 길일 경우
                    else{
                        lowerfloor = leaderLength - 1;
                        first = arrMap[row][col];
                        leader[row][col] = true;
                    }
                    samefloor = 1;
                    // 길이 아니라고 판단하여 해당 행을 종료
                    if(!enableMove) 
                        break;
                }
            }
        }
        if(lowerfloor != 0)
            enableMove = false;
        if(enableMove){
            answer += 1;
        }
    }
    memset(leader, false, sizeof(leader));

    for(int col = 0; col < mapSize; col++){
        int first = arrMap[0][col];
        int samefloor = 1;
        int lowerfloor = 0;
        bool enableMove = true;
        for(int row = 1; row < mapSize; row++){
            // 한번 내려온 경우
            if(lowerfloor > 0){
                if(first == arrMap[row][col]){
                    lowerfloor-=1;
                    leader[row][col] = true;
                }
                else{
                    enableMove = false;
                    break;
                }
            }
            // 같은 층일 때
            if(arrMap[row][col] == first){
                samefloor += 1;
                continue;
            }
            // 다른 층일 때
            else if(arrMap[row][col] != first){
                // 차가 1이 이상이면 길이 아님
                if(abs(arrMap[row][col] - first) > 1){
                    enableMove = false;
                    break;
                }
                // 차가 1일 경우
                else{
                    // 높은 길일 경우
                    if(arrMap[row][col] - first > 0){
                        // 같은 층의 바닥 수와 놓을 수 있는 사다리 길이를 비교
                        if(samefloor >= leaderLength){
                            for(int backField = 1; backField <= leaderLength; backField++){
                                // 이미 사다리가 놓아져 있다면 길이 아니다.
                                if(leader[row - backField][col]){
                                    enableMove = false;
                                    break;
                                }
                                // 사다리를 놓는다.
                                leader[row - backField][col] = true;
                            }
                            first = arrMap[row][col];
                            //samefloor = 0;
                        } else {
                            enableMove = false;
                            break;
                        }
                    }
                    // 낮은 길일 경우
                    else{
                        lowerfloor = leaderLength - 1;
                        first = arrMap[row][col];
                        leader[row][col] = true;
                    }
                    samefloor = 1;
                    // 길이 아니라고 판단하여 해당 행을 종료
                    if(!enableMove) 
                        break;
                }
            }
        }
        if(lowerfloor != 0)
            enableMove = false;
        if(enableMove){
            answer += 1;
        }
    }

    cout << answer;

    return 0;
}