31-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

2023 KAKAO BLIND RECRUITMENT 미로 탈출 명령어

✔️ 소요된 시간

거의 3시간?

✨ 수도 코드

1. 문제

n x m 격자 미로에서, (x, y)에서 출발해 (r, c)로 이동해야 한다. 단,

1. 격자의 바깥으로는 나갈 수 없다.
2. 인접한 상, 하, 좌, 우 격자로 한 칸씩 이동할 수 있다.
3. (x, y)에서 (r, c)까지 이동하는 거리가 총 k여야 한다. 이때, (x, y)와 (r, c)격자를 포함해 같은 격자를 두 번 이상 방문해도 된다.
4. 미로에서 탈출한 경로를 문자열로 나타냈을 때, 문자열이 사전 순으로 가장 빠른 경로로 탈출해야 한다.

예를 들어 다음과 같이 3 x 4 격자가 있다고 가정해보자.

....
..S.
E...

미로의 좌측 상단은 (1, 1)이고 우측 하단은 (3, 4)이다. .은 빈 공간, S는 출발 지점, E는 탈출 지점을 의미한다.
이동 경로를 다음과 같이 문자열로 바꿀 수 있다고 할 때,

• l: 왼쪽으로 한 칸 이동
• r: 오른쪽으로 한 칸 이동
• u: 위쪽으로 한 칸 이동
• d: 아래쪽으로 한 칸 이동

이동해야 하는 거리 k가 5라면 다음과 같은 경로로 탈출할 수 있다.

1. lldud
2. ulldd
3. rdlll
4. dllrl
5. dllud
6. ...

이때 dllrl보다 사전 순으로 빠른 경로로 탈출할 수는 없으므로, "dllrl"을 return 한다.
만약 위 조건대로 미로를 탈출할 수 없는 경우 "impossible"을 return 한다.

2. 풀이

대충 보면 그래프 문제 같은데, 풀고 보니 다양한 방식으로 풀 수 있는 문제였다. 나는 그리디 + DFS 방식으로 풀었다.

이 문제의 경우 방문 순서나 중복 처리를 신경써주지 않으면 악랄한 테스트케이스에 의해 터져버린다. 즉 그래프 순회처럼 풀었지만, 사실은 정답만을 향해 가도록 방문 케이스를 제한시켜야 하는 그리디의 성격에 가깝다. 크게 신경써야 할 부분은 2가지다.

1. 방문 처리
   동일한 칸을 두 번 이상 방문 가능하다고 해서 방문 처리를 안해주면 딱 봐도 메모리가 터지든 시간이 터질 것이다.
   즉 어떤 방식으로든 중복 처리를 해줘야 하는데, 1039 교환 PR 여기에서 썼던 테크닉이 생각났다.
   동일한 칸에 도달하더라도, 몇 번째 이동 인 지 구분해준다.
   즉 (x, y) 좌표인데 0번째 이동인 지, 1번째 이동인 지, ..., k번째 이동인 지를 모두 다르게 본다는 것이다.
2. 방문 순서
   탈출 경로가 사전 순으로 가장 빨라야 한다.
   인접한 네 칸이 동서남북인데, 이는 각각 rlud이다.
   하지만 재귀 DFS는 먼저 방문하는 순서로 가능한 끝까지 들어가는 특성이 있으므로, 방문 순서를 애초에 사전식 순서인 dlru 순서로 검사한다.

이 부분을 잡아내는 데 시간이 좀 걸렸다.

3. 코드

const vector<tuple<int, int, char>> Offset = {{1, 0, 'd'}, {0, -1, 'l'}, {0, 1, 'r'}, {-1, 0, 'u'}};
vector<vector<vector<bool>>> Visited;

위 단락에서 얘기했던 두 가지를 수행하는 코드이다 .
사전식 순서인 d - l - r - u 순으로 방문할 수 있도록 내부 원소를 배치했다.
그리고 (x, y) 좌표에 '몇 번째 이동'인 지를 나타내기 위해 3차원 방문 체크 배열을 선언한다.

string Answer = "";
string solution(int n, int m, int x, int y, int r, int c, int k)
{
    Visited.assign(k + 1, vector(n + 1, vector(m + 1, false)));
    DFS(n, m, r, c, x, y, k);
    return Answer.empty() ? "impossible" : Answer;
}

solution 함수에서 Visited를 초기화해주고, DFS 함수를 수행한다.
전역변수에 존재하는 Answer string 변수를 DFS 함수 내부에서 수정한다.
DFS 함수 수행이 완료됐을 때 Answer에 담긴 경로가 없을 경우, 이는 k번 이동으로 도달할 수 없음을 의미하므로 "impossible"을 반환한다. 아니라면 Answer에 담긴 경로를 반환한다.

void DFS(const int n, const int m, const int r, const int c, int InX, int InY, int Remain, string Path = "")
{
    if(Remain == 0)
    {
        if(InX == r && InY == c)
        {
            Answer = Path;
        }
        return;
    }
    
    Visited[Remain][InX][InY] = true;
    for(const auto& [Dx, Dy, Dp] : Offset)
    {
        int Nx = InX + Dx, Ny = InY + Dy;
        string NextPath = Path + Dp;
        int NextRemain = Remain - 1;
        
        if(!OutOfBound(n, m, Nx, Ny) && !Visited[NextRemain][Nx][Ny])
        {
            DFS(n, m, r, c, Nx, Ny, NextRemain, NextPath);
        }
        
        if(!Answer.empty())
        {
            break;
        }
    }
}

DFS 함수이다.
Remain이 남은 이동 횟수를 의미하는데, k부터 시작해서 1씩 줄어들며 0이 되면 Base case로 진입해 탈출한다.

• 이 때 만약 현재 좌표가 탈출구(r, c)라면 Answer를 지금까지 들어온 경로 Path로 갱신해준다.
• 탈출구 도달 유무와는 상관 없이 더 이상 재귀를 더 깊이 들어가지 않도록 return해준다.

남은 이동 횟수가 존재한다면 Recursive Case로 진입한다.

• 남은 이동 횟수에 현재 좌표를 Visit 체크해준다.
• 그리고 위에서 사전식 순서로 정의한 Offset을 이용해 인접한 4칸을 순회한다.
• DFS 순회 후 만약 Answer에 경로가 저장돼있다면 성공 Base Case에 진입한 것이므로 다음 인접 칸을 검사하지 않고 즉시 중단한다.

4. 전체 코드

#include <vector>
#include <string>
#include <tuple>

using namespace std;

const vector<tuple<int, int, char>> Offset = {{1, 0, 'd'}, {0, -1, 'l'}, {0, 1, 'r'}, {-1, 0, 'u'}};
vector<vector<vector<bool>>> Visited;

bool OutOfBound(const int n, const int m, int InX, int InY)
{
    return InX < 1 || InX > n || InY < 1 || InY > m;
}

string Answer = "";
void DFS(const int n, const int m, const int r, const int c, int InX, int InY, int Remain, string Path = "")
{
    if(Remain == 0)
    {
        if(InX == r && InY == c)
        {
            Answer = Path;
        }
        return;
    }
    
    Visited[Remain][InX][InY] = true;
    for(const auto& [Dx, Dy, Dp] : Offset)
    {
        int Nx = InX + Dx, Ny = InY + Dy;
        string NextPath = Path + Dp;
        int NextRemain = Remain - 1;
        
        if(!OutOfBound(n, m, Nx, Ny) && !Visited[NextRemain][Nx][Ny])
        {
            DFS(n, m, r, c, Nx, Ny, NextRemain, NextPath);
        }
        
        if(!Answer.empty())
        {
            break;
        }
    }
}

string solution(int n, int m, int x, int y, int r, int c, int k)
{
    Visited.assign(k + 1, vector(n + 1, vector(m + 1, false)));
    DFS(n, m, r, c, x, y, k);
    return Answer.empty() ? "impossible" : Answer;
}

📚 새롭게 알게된 내용

코드로 보면 쉬운데, 중간에 삽질 때문에 시간 꽤 날렸다 ㅂㄷㅂㄷ...
다른 사람들 보니까 되게 다양하게 풀었다. 단순 반복문에, DP에, 무슨 거리 계산에...
다들 대단해...

[Dolchae]

저번에 쓴 방법을 다시 적용하는 게 정말 좋은 것같아요!! 저도 다양한 문제를 풀어보고 배우면서 적절하게 잘 쓰는 걸 연습해야 할 것 같아요😶😊

[xxubin04]

한 문제도 다양한 알고리즘으로 풀 수 있군요.
저는 문제를 봤을 때, 어떤 알고리즘으로 풀어야 하는지 확실하게 알지 못하네요...😭
아마도 더 많은 문제를 풀어봐야 할 것 같습니다!
복잡한 문제를 보다 간단하게 코드로 짜시는 것도 진짜 대단하신 것 같아요!👍👍

[gjsk132]

저도 이상하게? 푼 경우 중 하나인 것 같아요.

처음엔 BFS나 DFS로 접근하려다가 안 써도 될 것 같아서 냅다 시도했는데 됐네요

기나긴 저의 문제 풀이...

( 남은 횟수가 홀수이거나 가야하는 거리보다 멀 때 impossible을 반환하고 가능한 경우 아래 설명 진행 )

일단 최소 이동으로 한 지점에서 지점까지 가는 방법은 좌표의 차를 이용하여 쉽게 알 수 있습니다.

이제 남은 횟수동안 반복하는 것에 많은 고민을 했었는데

문자열 순서까지 생각하면 4가지 반복할 수 있는 경우가 나옵니다.

du, lr, rl, ud

rl, ud는 더 빠른 문자가 뒤에 있기 때문에 반복해야 합니다.
rlrlrlrl 이나 ududud처럼 말이죠.

그에 비해, du나 lr의 경우에는 분리 시켜야 의미가 있습니다.
dddduuuu또는 llllrrrr 처럼요.

d와 l의 최대 연속으로 나올 수 있는 횟수가 중요합니다.

more_d와 more_l이 주어진 미로의 크기와 시작 위치, 이전에 구한 최소 이동 횟수를 가져와 더 연속으로 쓸 수 있는 횟수를 구한 것 입니다.

more_d 만큼 d와 u를 각각 올려주고, 다음은 more_l, 마지막으로 남은 횟수는 'rl'에 추가해주면 됩니다.

미로의 크기가 2 이상으로 주어지기 때문에 ud를 하지 않아도 rl에서 충분히 끝낼 수 있습니다.

그렇게 마지막으로 결과를 join을 이용하여 붙여서 출력해줬습니다.

조건문만 사용한 풀이

def solution(n, m, x, y, r, c, k):
    offset = ['d', 'l', 'rl', 'r', 'u']
    cnt = [0 for _ in range(5)]
    
    x_gap = x-r
    y_gap = y-c
    
    dist = abs(x_gap) + abs(y_gap)
    
    left = k-dist
    
    if left%2 or left<0:
        return("impossible")
    
    if x_gap > 0:
        cnt[4] += x_gap
    else:
        cnt[0] -= x_gap
    
    if y_gap > 0:
        cnt[1] += y_gap
    else:
        cnt[3] -= y_gap
        
    left //= 2
    more_d = n-x-cnt[0]
    more_l = y-1-cnt[1]
    
    if left > more_d:
        cnt[0] += more_d
        cnt[4] += more_d
        left -= more_d
    else:
        cnt[0] += left
        cnt[4] += left
        return("".join(s*c for s,c in zip(offset, cnt)))
    
    if left > more_l:
        cnt[1] += more_l
        cnt[3] += more_l
        left -= more_l
    else:
        cnt[1] += left
        cnt[3] += left
        return("".join(s*c for s,c in zip(offset, cnt)))
    
    cnt[2] += left
    
    return("".join(s*c for s,c in zip(offset, cnt)))
        

아마 이런 방법은 문자가 정해져있기도 하고, 주어진 문자로 생각해야하는 경우의 수가 적어서 가능했던 것 같습니당...