게임 맵 최단거리

문제 설명

ROR 게임은 두 팀으로 나누어서 진행하며, 상대 팀 진영을 먼저 파괴하면 이기는 게임입니다. 따라서, 각 팀은 상대 팀 진영에 최대한 빨리 도착하는 것이 유리합니다.

 

지금부터 당신은 한 팀의 팀원이 되어 게임을 진행하려고 합니다. 다음은 5 x 5 크기의 맵에, 당신의 캐릭터가 (행: 1, 열: 1) 위치에 있고, 상대 팀 진영은 (행: 5, 열: 5) 위치에 있는 경우의 예시입니다.

 

 

위 그림에서 검은색 부분은 벽으로 막혀있어 갈 수 없는 길이며, 흰색 부분은 갈 수 있는 길입니다. 캐릭터가 움직일 때는 동, 서, 남, 북 방향으로 한 칸씩 이동하며, 게임 맵을 벗어난 길은 갈 수 없습니다.

아래 예시는 캐릭터가 상대 팀 진영으로 가는 두 가지 방법을 나타내고 있습니다.

 

첫 번째 방법은 11개의 칸을 지나서 상대 팀 진영에 도착했습니다.

 

두 번째 방법은 15개의 칸을 지나서 상대팀 진영에 도착했습니다.

 

위 예시에서는 첫 번째 방법보다 더 빠르게 상대팀 진영에 도착하는 방법은 없으므로, 이 방법이 상대 팀 진영으로 가는 가장 빠른 방법입니다.

 

만약, 상대 팀이 자신의 팀 진영 주위에 벽을 세워두었다면 상대 팀 진영에 도착하지 못할 수도 있습니다. 예를 들어, 다음과 같은 경우에 당신의 캐릭터는 상대 팀 진영에 도착할 수 없습니다.

 

 

게임 맵의 상태 maps가 매개변수로 주어질 때, 캐릭터가 상대 팀 진영에 도착하기 위해서 지나가야 하는 칸의 개수의 최솟값을 return 하도록 solution 함수를 완성해주세요. 단, 상대 팀 진영에 도착할 수 없을 때는 -1을 return 해주세요. 

제한사항

• maps는 n x m 크기의 게임 맵의 상태가 들어있는 2차원 배열로, n과 m은 각각 1 이상 100 이하의 자연수입니다.
• n과 m은 서로 같을 수도, 다를 수도 있지만, n과 m이 모두 1인 경우는 입력으로 주어지지 않습니다.
• maps는 0과 1로만 이루어져 있으며, 0은 벽이 있는 자리, 1은 벽이 없는 자리를 나타냅니다.
• 처음에 캐릭터는 게임 맵의 좌측 상단인 (1, 1) 위치에 있으며, 상대방 진영은 게임 맵의 우측 하단인 (n, m) 위치에 있습니다.

입출력 예

maps	answer
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,1],[0,0,0,0,1]]	11
[[1,0,1,1,1],[1,0,1,0,1],[1,0,1,1,1],[1,1,1,0,0],[0,0,0,0,1]]	-1

---

문제 해설

전형적인 BFS문제이다. 깊이우선탐색으로 진행하면, 무조건 시간초과가 날 수밖에 없는 유형.

너비우선탐색으로 탐색을 해야한다.

 

전체 탐색여부를 기록해서 활용하면 됨.

---

첫 번째 시도

#include<vector>
#include<set>

using namespace std;

set<int> mapr;

void DFS(vector<vector<int>> maps, vector<int> n, int answer = 1)
{
    maps[n[0]][n[1]] = 0;
    // UP
    if (n[0] - 1 >= 0 && maps[n[0] - 1][n[1]] == 1)
        DFS(maps, { n[0] - 1, n[1] }, answer + 1);

    // Down
    if (n[0] + 1 < maps.size() && maps[n[0] + 1][n[1]] == 1)
        DFS(maps, { n[0] + 1, n[1] }, answer + 1);
    
    // Left
    if (n[1] - 1 >= 0 && maps[n[0]][n[1] - 1] == 1)
        DFS(maps, { n[0], n[1] - 1 }, answer + 1);
    
    // Right
    if (n[1] + 1 < maps[0].size() && maps[n[0]][n[1] + 1] == 1)
        DFS(maps, { n[0], n[1] + 1 }, answer + 1);

    if (n[0] == maps.size()-1 && n[1] == maps[0].size()-1)
        mapr.insert(answer);
}

int solution(vector<vector<int>> maps)
{
    vector<int> n;
    n.resize(2);
    DFS(maps, n);
    return mapr.size() > 0 ? *mapr.begin() : -1;
}

실패

 

귀찮아서 DFS로 진행했다가. 시간초과로 터졌다.

---

두 번째 시도

#include<vector>
#include<set>
#include <map>

using namespace std;

int solution(vector<vector<int>> maps)
{
    map<int, vector<vector<int>>> searchmap;
    searchmap[0].push_back({ 0,0 });
    int nowsearch = 0;
    while (searchmap[nowsearch].size() > 0)
    {
        for (auto& visit : searchmap[nowsearch]) {
            maps[visit[0]][visit[1]] = 0;
            if (visit[0] == maps.size() - 1 && visit[1] == maps[0].size() - 1)
                return nowsearch+1;
            // UP
            if (visit[0] - 1 >= 0 && maps[visit[0] - 1][visit[1]] == 1)
                searchmap[nowsearch + 1].push_back({ visit[0] - 1, visit[1] });
            // Down
            if (visit[0] + 1 < maps.size() && maps[visit[0] + 1][visit[1]] == 1)
                searchmap[nowsearch + 1].push_back({ visit[0] + 1, visit[1] });
            // Left
            if (visit[1] - 1 >= 0 && maps[visit[0]][visit[1] - 1] == 1)
                searchmap[nowsearch + 1].push_back({ visit[0] , visit[1] - 1 });
            // Right
            if (visit[1] + 1 < maps[0].size() && maps[visit[0]][visit[1] + 1] == 1)
                searchmap[nowsearch + 1].push_back({ visit[0], visit[1] + 1 });
        }
        nowsearch++;
    }
    return -1;
}

실패

 

이번에는 너비우선 탐색으로 진행했는데 터졌다..?

그래서 왜 터졌는지 확인해봐야한다.

---

세 번째 시도

#include <vector>
#include <queue>

using namespace std;

int solution(vector<vector<int>> maps) {
    int rows = maps.size();
    int cols = maps[0].size();

    vector<vector<bool>> visited(rows, vector<bool>(cols, false));
    queue<pair<int, int>> q;
    q.push({0, 0});
    visited[0][0] = true;
    int distance = 1;

    while (!q.empty()) {
        int levelSize = q.size();
        for (int i = 0; i < levelSize; ++i) {
            auto [x, y] = q.front();
            q.pop();
            if (x == rows - 1 && y == cols - 1) {
                return distance;
            }
            // UP
            if (x - 1 >= 0 && maps[x - 1][y] == 1 && !visited[x - 1][y]) {
                q.push({x - 1, y});
                visited[x - 1][y] = true;
            }
            // Down
            if (x + 1 < rows && maps[x + 1][y] == 1 && !visited[x + 1][y]) {
                q.push({x + 1, y});
                visited[x + 1][y] = true;
            }
            // Left
            if (y - 1 >= 0 && maps[x][y - 1] == 1 && !visited[x][y - 1]) {
                q.push({x, y - 1});
                visited[x][y - 1] = true;
            }
            // Right
            if (y + 1 < cols && maps[x][y + 1] == 1 && !visited[x][y + 1]) {
                q.push({x, y + 1});
                visited[x][y + 1] = true;
            }
        }
        distance++;
    }
    return -1; // 목적지에 도달할 수 없는 경우
}

성공

 

데이터저장 타입을 큐와 지정된 vector형태로 구현했다.

탐색시간을 더 효율적으로 관리하기 위해서 넣었더니 성공함.

 

생각보다 Map형태로 저장하는게 크게 효율적이지 않은것같다. vector가 탐색시, 위치를 알 고 있다면 한번에 탐색해서 차이가 있나부다.