2-yuyu0830

[yuyu0830]

🔗 문제 링크

백준 12851 숨바꼭질 2

✔️ 소요된 시간

3시간

✨ 수도 코드

이전 문제를 풀고 그대로 가져왔다 보니 조금 정리가 안된 부분이 있습니다.

블로그 해설 링크

수빈이와 동생은 수직선 위에 있다.
수빈이는 앞, 뒤로 1칸씩 움직이거나 현재 칸 * 2의 칸으로 순간이동 할 수 있다.
각 움직임은 1초의 시간이 소요된다.

동생은 움직이지 않을 때, 수빈이가 가장 빠르게 동생을 찾을 수 있는 시간과 경우의 수를 구하자

---

문제를 나눠보자.

1. 수빈이가 가장 빠르게 동생을 찾을 수 있는 시간
2. 1번의 시간에 도착할 수 있는 경우의 수

1번은 BFS로 해결하면 된다.
2개의 큐를 사용해 한 큐를 사용하는 동안 반대 큐에 다음 탐색 할 위치를 넣고 다음 탐색에는 반대로 사용한다.
큐에 들어있는 "수진이가 있을 수 있는 위치" 에서 + 1, - 1, * 2 한 위치를 탐색한다.
이 때, 최소 시간을 탐색해야하기 때문에 추후에 같은 위치를 방문하는 것은 의미가 없다.
visited 배열을 통해 중복 탐색을 방지하자

2번이 조금 헷갈렸는데
n번째 탐색에서 같은 위치에 갈 수 있는 경우의 수가 겹치는 경우가 있다.
예를 들어 1에서 2를 가는 경우, 1 + 1, 1 * 2 의 두가지 경우가 생긴다.
그래서 dist 라는 배열을 통해 해당 위치에 도달할 수 있는 경우의 수를 모았다.
여기서 주의할 점은 n번째 탐색에서 탐색하는 위치가 아니면 값을 바꾸면 안된다.
자꾸 값이 이상하게 나와 확인해봤더니 이전에 탐색했던 횟수를 자꾸 건드리고 있었다..

이 정도만 해결하면 되는데
100,000을 10,000 으로 잘못 적어서 자꾸 시간초과가 떴었는데
난 그것도 모르고 내 풀이가 문제인 줄 알고 최대한 시간을 줄이기 위해 노력했다.
결국 priority_queue를 통해 수진의 위치 정렬, 값이 cur보다 커지면 탐색 종료하는 로직으로 해결했다.
그냥 vector로 했어도 됐을듯?

📚 새롭게 알게된 내용

우선순위 큐는 따로 비우는 함수가 없다.
q = priority_queue<int> (); 이런 식으로 비울 수 있다!

[9kyo-hwang]

흠 항상 Visited 체크를 다음 칸(Nx) 검사할 때 했었어서 그렇게 했는데 계속 빠꾸당했네요.
이런 식으로 해버리면 1 + 1이랑 1 * 2를 검사할 때 앞에서 이미 Visited 체크가 돼버리니 카운팅이 제대로 되지 않네요...

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int main()
{
    cin.tie(nullptr)->sync_with_stdio(false);
    
    int N, K; cin >> N >> K;
    
    auto OutOfBound = [&](int X)
    {
        return X < 0 || X > 100000;
    };
    
    deque<pair<int, int>> Q;
    vector<bool> Visited(100001, false);
    
    Q.emplace_back(N, 0);
    Visited[N] = true;
    
    int AnswerTick = 100001, AnswerSize = 0;
    while(!Q.empty())
    {
        const auto [X, Tick] = Q.front();
        Q.pop_front();
        
        if(X == K)
        {
            if(Tick < AnswerTick)
            {
                AnswerTick = Tick;
                AnswerSize = 1;
            }
            else if(Tick == AnswerTick)
            {
                AnswerSize += 1;
            }
        }
        
        Visited[X] = true;  // 네 이놈!
        for(const int Nx : {X - 1, X + 1, X * 2})
        {
            if(OutOfBound(Nx) || Visited[Nx])
            {
                continue;
            }
            
            Q.emplace_back(Nx, Tick + 1);
        }
    }
    
    cout << AnswerTick << "\n" << AnswerSize;
    
    return 0;
}

현재 칸 X를 만날 때마다 Visited를 체크해줘야 똑바로 동작하는 걸 잡아내는 데 한참 걸렸군요...

[InSange]

여러 부가 조건을 추가하였지만 일전에 말씀주셨던 우선 순위큐로 해결하는 방법에 대해서 조금이나마 이해가 가는군요.
혹시 시간적 여유가 있으시다면 주석도 부탁드려도 될까요?
해석하는데 약간의 어려움에 도움이 될 수 있으면 좋을 것 같습니다!
전체적인 효율성에 대해서도 궁금하네요!

저는 다음과 같이 풀었습니다.

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

int N, K;
vector<int> times;	// 포인트마다 걸린 시간
vector<int> visited;	// 점마다 방문한 수
queue<int> q;

bool OutOfBounds(int num)
{
	return (num < 0 || 100000 < num);
}

void Solve()
{
	times.assign(100001, 100001);
	visited.assign(100001, 0);
	cin >> N >> K;
	times[N] = 0;

	if (N > K || N == K)
	{
		cout << N - K << "\n" << 1;
		return;
	}

	q.push(N);

	while (!q.empty())
	{
		int curPoint = q.front();
		q.pop();

		for (int nextPoint : {curPoint + 1, curPoint - 1, 2 * curPoint})
		{
			if (OutOfBounds(nextPoint) || times[curPoint]+1 > times[K]) continue;

			if (visited[nextPoint] == 0)
			{
				visited[nextPoint] = 1;
				times[nextPoint] = times[curPoint] + 1;
				q.push(nextPoint);
			}
			else if (times[nextPoint] >= times[curPoint] + 1)
			{
				visited[nextPoint]++;
				q.push(nextPoint);
			}
		}
	}

	cout << times[K] << "\n" << visited[K];
}

int main()
{
	cin.tie(nullptr);
	ios::sync_with_stdio(false);

	Solve();

	return 0;
}

K에 도달을 하였다면 현재 값의 시간을 비교해서 계산이 필요없는 부분을 생략해주었고, 조건이 아니면 모든 방문에 가능성을 열어주어 방문 해줬던 것 같습니다.
큐에 들어가는 값은 현재 시간 t에서 다음 시간 t+1에 들어가는 값들은 cur+1, cur-1, 2*cur 총 3개로 연속적인 부분을 지니기 때문에 이보다 큰 t값이 들어오게 되면 방문할 필요도 없이 넘어 가주는 방식으로 풀어줬습니다.

[InSange]

GOOOD

[seongwon030]

숨바꼭질 1에서 발전된 경로 수 찾기네요! 기존의 코드에 너무 의존해서 경로수 찾기가 오래 걸렸습니다. 저는 수빈이와 동생의 위치와 일치할 때 cnt라는 변수에 1을 더하는 식으로 했습니다. continue를 넣어 모든 경로수를 다 구하도록 했습니다.

from collections import deque

result, cnt = 0,0
MAX = 10**5 # 움직일 수 있는 최대좌표
dist = [0] * (MAX + 1) # 해당 위치에 도착했을 때 시간
n, k = map(int,input().split())

q = deque()
q.append(n)
while q:
    x = q.popleft()
    if x==k: # x변수인 수빈의 위치가 동생이 있는 k와 같을 때 멈춤
      result = dist[x]
      cnt += 1
      continue
    # nx = 4,6,10 (현재 위치 5일 때 이동할 수 있는 방향)
    for nx in (x-1, x+1, x*2):
      # 범위내에 있고 아직 방문안했거나 이전 방문 + 1이 현재
      if 0 <= nx <= MAX and (not dist[nx] or dist[nx] == dist[x]+1):
        dist[nx] = dist[x] + 1  # 이동한 위치에 현재 이동한 시간 표시
        q.append(nx)

print(result)
print(cnt)

[dhlee777]

큐를 비워주는 방식에 대해 새롭게 알고갑니다. 이번 PR도 고생하셨습니다 !

[dhlee777]

큐를 비우는 함수가 없기때문에 이렇게 비워주는군요.! 다음에 문제풀때 참고해봐야겠습니다 !!