10-H0ngJu

[H0ngJu]

🔗 문제 링크

숨바꼭질 4

✔️ 소요된 시간

(숨바꼭질 포함) 2시간

✨ 수도 코드

이번 문제도 숨바꼭질를 먼저 풀고 풀었습니다. 숨바꼭질 4가 꽤 오래걸렸습니다.

먼저 위치 N에서 수빈이가 갈 수 있는 next_location은
[location+1, location-1, location*2] 중 하나입니다.

따라서 다음의 위치들을 큐에 넣고 방문노드임을 표시해주면 됩니다.

그렇게 location을 pop하고 next_location을 append하면서 동생위치(K)에 도달할 때까지 반복문을 돌면 됩니다.

N, K = map(int, input().split())

visited = [0] * 100001
time = 0

q = deque([N])
visited[N] = 1

while q:
    size = len(q)
    for _ in range(size):
        location = q.popleft()
        if location == K:
            print(time)
            break
        for next_location in (location + 1, location - 1, location * 2):
            if 0 <= next_location <= 100000 and not visited[next_location]:
                q.append(next_location)
                visited[next_location] = 1
    time += 1

숨바꼭질 4는 기존 숨바꼭질에서 추가되는 조건은 따로 없고, 출력으로 수빈이가 동생까지 가는 경로를 출력하면 됩니다.

숨바꼭질 코드에서 q를 출력해보면,

와 같이 나오기 때문에, 각각의 원소가 어떤 부모노드에서 나왔는지 판단이 불가합니다.

만약, 부모노드(이전 위치)가 어딘지만 알면 거슬러가면 되기 때문에,
현재위치 location - 다음위치 next_location을 쌍으로 저장하면 해결될 것이라고 생각하였습니다.

문제는 어떤 자료구조로 저장할 것인가? 였는데

처음에는 '덱에 튜플 형식으로 (location, next_location)저장할까?' 하고 생각하였습니다.
그런데 어차피 반복문 안에서 pop하고 새로 append할 거라면 (location, nex_location)이 계속 남아있는게 아니기 때문에, 거슬러 가는 것이 불가능하다고 생각하였습니다.

각각의 현재위치에 대하여 next_location을 저장하려고 했던 까닭은,
next_location = 6이라면, location이 5,7,3일 때처럼,
_한 위치에 대해 갈 수 있는 경로가 여러 개라고 판단_했기 때문입니다.
(지금 생각해보면 쌍으로 저장한다고 하더라도 경로가 여러 개인 경우에 대해서 해결을 할 수 없네요)

그런데 BFS 특성상, 가장 먼저 도달하는 경로가 최단경로이므로, 한 위치에 대해서 경로가 여러 개라는 점을 생각하지 않아도 됩니다.

즉, 목표값을 찾는 순간 반환하기 때문에 앞서 생각했던 점들을 무시하고, '부모노드-자식노드'만의 연결로만으로도 충분히 최단 경로를 저장할 수 있다는 의미입니다.

배열에 그냥 다음 위치를 index값으로 현재 위치를 저장하면 거슬러 갈 수 있겠다 싶어서 아래와 같이 구현하였습니다.

import sys
from collections import deque

def input(): return sys.stdin.readline().rstrip()

N, K = map(int, input().split())

visited = [0] * 100001
time = 0
parent = [-1] * 100001

q = deque([N])
visited[N] = 1

while q:
    size = len(q)
    for _ in range(size):
        location = q.popleft()
        if location == K: 
            print(time)
            answer = []
            while location != -1:
                answer.append(location)
                location = parent[location]
            answer.reverse()
            print(" ".join(map(str, answer)))
            break
        for next_location in (location + 1, location - 1, location * 2):
            if 0 <= next_location <= 100000 and not visited[next_location]:
                q.append(next_location)
                visited[next_location] = 1
                parent[next_location] = location
    time += 1

📚 새롭게 알게된 내용

[tgyuuAn]

아이고... 홍주님 코드를 보고 제 코드를 보니 부끄럽네요 ^^;;

처음에 백트래킹으로 접근을 했다가 시간초과에 된통 당하고,

BFS로 틀었는데 아래 사진 처럼 46퍼에서 걸려서..

홍주님 PR 참고하고 parent를 저장하면 된다는 인사이트를 얻고 뚝딱했습니다.

쉬운 듯 하면서도 역추적 하는 과정이 바로 떠오르지 않았네요..

좋은 문제 감사합니다 !!

from collections import deque
import sys

def input(): return sys.stdin.readline().rstrip()
N, K = map(int, input().split())

parent = [-1 for _ in range(100001)]
visited = set()

deq = deque([[N, 0]])
while deq:
    now, now_count = deq.popleft()

    if now == K:
        print(now_count)

        if N == K:
            print(N)
            break
        
        answer = deque([now])
        prev = parent[now]
        while prev != N:
            answer.appendleft(prev)
            prev = parent[prev]

        answer.appendleft(N)
        
        print(*answer)
        break

    if now != 0 and now*2 <= 100000 and now*2 not in visited:
        visited.add(now*2)
        parent[now*2] = now
        deq.append([now*2, now_count+1])
        
    if now-1 >= 0 and now-1 not in visited:
        visited.add(now-1)
        parent[now-1] = now
        deq.append([now-1, now_count+1])
        
    if now < K and now+1 not in visited:
        visited.add(now+1)
        parent[now+1] = now
        deq.append([now+1, now_count+1])

`

[tgyuuAn]

오... 저는 time을 뜻하는 count를 큐 내부에 넣어서 연산했는데,

이런 식으로 하면 메모리를 절약할 수도 있겠네요... 신박해요

[tgyuuAn]

헉 이렇게 좋은 방법이.... 배우고 갑니다..

[9kyo-hwang]

저는 부모 출력하는 역추적 로직을 재귀로 짜곤 합니다. 왠지 이게 더 익숙하더라구요 ㅋㅋ
distances 배열의 초기값을 100001(조건 상 나올 수 없는 최대 거리값)으로 설정해놓고, next 거리값이 current 거리값 + 1보다 작은 경우에만 queue에 들어가도록 코드를 작성하면 별도의 변수를 안써도 된답니다 :)

from collections import deque
from sys import stdin, setrecursionlimit
setrecursionlimit(10**6)
input = stdin.readline

n, k = map(int, input().split())
distances = [100001] * 100001
parents = [-1] * 100001

q = deque([n])
distances[n] = 0

def out_of_bound(x: int) -> bool:
    return not (0 <= x <= 100000)


while q:
    x = q.popleft()
    if x == k:
        print(distances[x])
        break
    
    for nx in (x * 2, x - 1, x + 1):
        if out_of_bound(nx) or distances[nx] < distances[x] + 1:
            continue
        
        distances[nx] = distances[x] + 1
        parents[nx] = x
        q.append(nx)
        

def dfs(x: int = k):
    if(x == -1):
        return
    
    dfs(parents[x])
    print(x, end=' ')
    
    
dfs()

---

아니면 부모 경로를 저장할 때, deque을 써서 front에 계속 밀어넣는 식으로 하면 굳이 reverse 할 필요 없겠죠?

paths = deque([k])
while parents[k] != -1:
    k = parents[k]
    paths.appendleft(k)
    
print(' '.join(map(str, paths)))