백준 14890번 - 경사로 [Python, Java]

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

14890번: 경사로

문제

크기가 N×N인 지도가 있다. 지도의 각 칸에는 그 곳의 높이가 적혀져 있다. 

오늘은 이 지도에서 지나갈 수 있는 길이 몇 개 있는지 알아보려고 한다. 길이란 한 행 또는 한 열 전부를 나타내며, 한쪽 끝에서 다른쪽 끝까지 지나가는 것이다. 

다음과 같은 N=6인 경우 지도를 살펴보자.

이때, 길은 총 2N개가 있으며, 아래와 같다.

길을 지나갈 수 있으려면 길에 속한 모든 칸의 높이가 모두 같아야 한다. 또는, 경사로를 놓아서 지나갈 수 있는 길을 만들 수 있다. 경사로는 높이가 항상 1이며, 길이는 L이다. 또, 개수는 매우 많아 부족할 일이 없다. 경사로는 낮은 칸과 높은 칸을 연결하며, 아래와 같은 조건을 만족해야한다.

• 경사로는 낮은 칸에 놓으며, L개의 연속된 칸에 경사로의 바닥이 모두 접해야 한다.
• 낮은 칸과 높은 칸의 높이 차이는 1이어야 한다.
• 경사로를 놓을 낮은 칸의 높이는 모두 같아야 하고, L개의 칸이 연속되어 있어야 한다.

아래와 같은 경우에는 경사로를 놓을 수 없다.

• 경사로를 놓은 곳에 또 경사로를 놓는 경우
• 낮은 칸과 높은 칸의 높이 차이가 1이 아닌 경우
• 낮은 지점의 칸의 높이가 모두 같지 않거나, L개가 연속되지 않은 경우
• 경사로를 놓다가 범위를 벗어나는 경우

L = 2인 경우에 경사로를 놓을 수 있는 경우를 그림으로 나타내면 아래와 같다.

경사로를 놓을 수 없는 경우는 아래와 같다.

위의 그림의 가장 왼쪽부터 1번, 2번, 3번, 4번 예제라고 했을 때, 1번은 높이 차이가 1이 아니라서, 2번은 경사로를 바닥과 접하게 놓지 않아서, 3번은 겹쳐서 놓아서, 4번은 기울이게 놓아서 불가능한 경우이다.

가장 위에 주어진 그림 예의 경우에 지나갈 수 있는 길은 파란색으로, 지나갈 수 없는 길은 빨간색으로 표시되어 있으며, 아래와 같다. 경사로의 길이 L = 2이다.

지도가 주어졌을 때, 지나갈 수 있는 길의 개수를 구하는 프로그램을 작성하시오.

문제 유형 / 난이도

구현 / 골드 3

문제 풀이

한 행 씩 진행한다고 할 때 나올 수 있는 경우의 수는 4가지가 있다.

1. 앞의 값과 뒤의 값이 같은 경우

2. 앞의 값이 뒤의 값보다 1 큰 경우

3. 앞의 값이 뒤의 값보다 1 작은 경우

4. 앞의 값과 뒤의 값의 차가 2 이상인 경우

 

앞의 값과 뒤의 값이 같은 경우

경사로를 놓을 수 있는지 확인해야하기 때문에 ++cnt한다.

 

앞의 값이 뒤의 값보다 1 큰 경우

뒤의 칸에 경사로를 놓을 수 있는지 확인해야한다. 현재 칸(뒷칸)의 위치 + L 의 값이 현재 칸의 값과 같다면 놓을 수 있다는 말이므로 지금까지 세었던 칸의 수를 초기화하고 현재의 위치를 경사로의 끝 위치로 바꿔줘야한다. 초기화 할 때 경사로 끝 위치에서 마무리 되므로 cnt는0으로 초기화 해야한다.

 

앞의 값이 뒤의 값보다 1 작은 경우

지금 까지 세었던 칸에 경사로를 놓을 수 있는지 확인해야한다. 놓을 수 있다면 지금까지 세었던 칸을 초기화 시킨다.

 

앞의 값과 뒤의 값의 차가 2이상인 경우

이 경우에는 도로를 완성할 수 없으므로 다음 행으로 넘어간다.

 

위의 과정은 행에 관해 시행한 것이고 열에 관해서도 시행해야한다. 이 때 2차원 배열의 행과 열을 바꾸면 위의 과정을 다시 반복할 수 있다.

Python

import sys
import copy
input = sys.stdin.readline


def swapRowCol(graph):
    temp = [[0]*n for _ in range(n)]
    for i in range(n):
        for j in range(n):
            temp[j][i] = graph[i][j]
    
    return temp
            
def canRoad(graph, x, y):
    height = graph[x][y+1]
    for j in range(y+1, y+1+l):
        if j > n-1 or graph[x][j] != height:
            return False
    
    return True

def findRoad(graph):
    global path
    for i in range(n):
        flag = True
        cnt = 1
        j = 0
        while j < n-1:
            if graph[i][j] == graph[i][j+1]:
                cnt += 1
            elif graph[i][j] == graph[i][j+1] + 1:
                if canRoad(graph, i, j):
                    cnt = 0
                    j = j + l - 1
                else:
                    flag = False
                    break
                
            elif graph[i][j] == graph[i][j+1] - 1:
                if cnt >= l:
                    cnt = 1
                else:
                    flag = False
                    break

            elif abs(graph[i][j] - graph[i][j+1]) >= 2:
                flag = False
                break
            
            j += 1
        
        if flag == True:
            path += 1
                    

n, l = map(int, input().split())
graph1 = [list(map(int, input().split())) for _ in range(n)]
path = 0

graph2 = swapRowCol(graph1)
findRoad(graph1)
findRoad(graph2)

print(path)

Java

import java.io.*;
import java.util.*;

public class Main_14890 {
        static int[][] graph1;
        static int[][] graph2;
        static int n, l;
        static int path;

    public static void main(String[] args) throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        n = Integer.parseInt(st.nextToken());
        l = Integer.parseInt(st.nextToken());

        graph1 = new int[n][n];
        graph2 = new int[n][n];

        for (int i = 0; i < n; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < n; j++) {
                graph1[i][j] = Integer.parseInt(st.nextToken());
            }
        }
        graph2 = swapRowCol(graph1);
        findRoad(graph1);
        findRoad(graph2);

        System.out.println(path);
    }

    private static void findRoad(int[][] graph) {
        for (int i = 0; i < n; i++) {
            boolean flag = true;
            int cnt = 1;

            for (int j = 0; j < n-1; j++) {
                if (graph[i][j] == graph[i][j + 1]) {
                    ++cnt;
                } else if (graph[i][j] == graph[i][j + 1] + 1) {
                    if (canRoad(graph, i, j)) {
                        cnt = 0;
                        j = j + l - 1;
                    } else {
                        flag = false;
                        break;
                    }
                } else if (graph[i][j] == graph[i][j + 1] - 1) {
                    if (cnt >= l) {
                        cnt = 1;
                    } else {
                        flag = false;
                        break;
                    }
                } else if (Math.abs(graph[i][j] - graph[i][j + 1]) > 1) {
                    flag = false;
                    break;
                }
            }

            if (flag == true) {
                ++path;
            }
        }
    }

    static int[][] swapRowCol(int[][] graph) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                graph2[j][i] = graph[i][j];
            }
        }
        return graph2;
    }

    static boolean canRoad(int[][] graph, int x, int y) {

        int height = graph[x][y+1];
        for(int j=y+1; j<y+1+l; j++) {
            if (j > n-1 || graph[x][j] != height) {
                return false;
            }
        }
        return true;
    }
}

feedback

문제를 잘 못 읽어 헤맸던 문제이다.

 

📝 메모: 2차원 배열의 행과 열 swap 구현, 해당 칸들에 경사로를 놓을 수 있는지 확인하는 부분 구현(다음 칸의 위치 + 경사로 길이의 높이가 같다면 놓을 수 있다.)