17-froglike6

[froglike6]

🔗 문제 링크

아맞다우산

✔️ 소요된 시간

1시간

✨ 수도 코드

수도코드(약간 어려울 것 같아 주석도 달았어요)

입력 n, m
입력 m 줄의 문자열로 집 구조 grid 를 저장한다

start, exit ← None  
item ← 빈 리스트

모든 좌표 (y, x)에 대해:
    만약 grid[y][x] == "S" 라면:
        start ← (y, x)
    아니라면 grid[y][x] == "E" 라면:
        exit ← (y, x)
    아니라면 grid[y][x] == "X" 라면:
        item 목록에 (y, x) 추가

node ← [start] + item + [exit]  
k ← item 의 개수  
l ← k + 2          # 전체 노드 수(S, X들, E)

dist ← l × l 배열을 -1 로 초기화  
dirs ← {(1, 0), (-1, 0), (0, 1), (0, -1)}

각 노드 (sy, sx) 와 그 인덱스 idx 에 대해:
    d ← m × n 배열을 -1 로 초기화
    큐 q ← (sy, sx) 를 넣어 생성
    d[sy][sx] ← 0

    while q 가 비어있지 않다면:
        (y, x) ← q 에서 꺼낸다
        dirs 의 네 방향 (dy, dx) 에 대해:
            ny ← y + dy, nx ← x + dx
            만약 0 ≤ ny < m, 0 ≤ nx < n,
                 그리고 grid[ny][nx] != '#',
                 그리고 d[ny][nx] == -1 이라면:
                d[ny][nx] ← d[y][x] + 1
                q 에 (ny, nx) 추가

    모든 노드 (ty, tx) 와 인덱스 j 에 대해:
        dist[idx][j] ← d[ty][tx]          # idx ↔ j 최단 거리 기록

만약 k == 0 (챙길 물건이 없다면):
    dist[0][1] 을 출력한다           # S→E 최단 거리

그 외의 경우:                      # 물건을 하나 이상 챙겨야 할 때
    INF ← 10^9
    dp ← (1 << k) × (k + 1) 배열을 INF 로 초기화
    dp[0][0] ← 0                    # (아무것도 안 챙김, S 위치)

    모든 비트마스크 mask (0 ~ 2^k - 1)에 대해:
        i = 0 ~ k 까지:
            cur ← dp[mask][i]
            만약 cur == INF 라면: 다음 i 로
            j = 0 ~ k - 1 까지:
                만약 mask 에 j 번째 비트가 켜져 있다면: continue
                cost ← dist[i][j + 1]        # 현 위치 i → 새 아이템 j
                만약 cost == -1 이라면: continue
                nxt ← mask | (1 << j)
                dp[nxt][j + 1] ← min(dp[nxt][j + 1], cur + cost)

    all_mask ← (1 << k) - 1          # 모든 아이템을 챙긴 상태
    ans ← INF
    i = 0 ~ k 까지:
        만약 dp[all_mask][i] == INF 이거나 dist[i][k + 1] == -1 라면: continue
        ans ← min(ans, dp[all_mask][i] + dist[i][k + 1])   # 마지막으로 E 까지 이동

    ans 를 출력한다

이 문제는 단순한 BFS 문제와 비슷하지만, 약간 다른 문제입니다. BFS로 모든 경로의 길이를 구하고, 비트마스크 DP를 통해 가장 적게 움직이는 경로를 찾습니다. 비트마스크는 #24 에 설명되어 있습니다 ㅎㅎ. 이를 활용한 DP라고 생각하시면 되겠습니다.

격자 안의 출발점에서 시작하여 모든 아이템을 얻고, 출구로 이동해야 합니다. 먼저 입력에서 격자를 받고, 탐색할 노드를 node에 저장합니다(S, 모든 E, X).
그런 다음 node의 모든 노드에 대해 BFS를 돌려 모든 노드 간 최단 거리 행렬 dist를 만듭니다.

이제 비트마스크 DP로 넘어가겠습니다.
mask는 k비트 집합으로, 각 비트가 1이면 해당 아이템을 획득했다고 설정했습니다. 그런 다음 dp[mask][i]에다가, mask된 상태에서 node[i]에 도착한 최소 거리를 저장했습니다. 모든 아이템을 순회하고 출구로 나가, 답을 도출할 수 있었습니다.

📚 새롭게 알게된 내용

비트마스크 DP를 알게 되었습니다. 이 문제에서는 아이템의 수가 작아서 다익스트라를 사용하지 않았는데, 새로 알게 된 비트마스크 DP를 사용하면서 비교적 더 빠르게 계산할 수 있었습니다.

[dohyeondol1]

비트마스킹은 아직 익숙하지가 않아서 그런가 풀이를 알아내도 코드를 바로 짜기가 어렵네요...
그마저도 비트마스크 dp가 아니라 비트마스크만 사용하였습니다.
찾아보니 외판원 순회(TSP)도 비트마스크 DP를 사용한다고 하던데...
BFS 연습 뿐만 아니라 응용할 수 있는 내용도 있어서 배워갈게 많은 문제네요 ㅎㅎ

저는 visited[y][x][mask] 상태로 탐색을 수행했습니다.
비트마스크는 상태관리 용도로만 사용했어욥
아이템 개수가 많아진다면 좀 비효율적일순 있겠네요..

#include <iostream>
#include <queue>
#include <vector>
#include <tuple>
#include <algorithm>
using namespace std;

int N, M;
vector<string> house;
vector<pair<int, int>> items;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};

int bfs(int sy, int sx, int ey, int ex, const vector<pair<int, int>>& items) {
    int item_cnt = items.size();
    vector<vector<int>> item_idx(M, vector<int>(N, -1));
    for (int i = 0; i < item_cnt; ++i)
        item_idx[items[i].first][items[i].second] = i;

    vector<vector<vector<int>>> visited(M, vector<vector<int>>(N, vector<int>(1 << item_cnt, 0)));
    queue<tuple<int, int, int, int>> q;
    q.push({sy, sx, 0, 0});
    visited[sy][sx][0] = 1;

    while(!q.empty()) {
        auto [y, x, mask, dist] = q.front();
        q.pop();

        if(y == ey && x == ex && mask == (1<<item_cnt)-1)
            return dist;

        for(int dir = 0; dir < 4; ++dir) {
            int ny = y + dy[dir];
            int nx = x + dx[dir];
            if(ny < 0 || ny >= M || nx < 0 || nx >= N) continue;
            if(house[ny][nx] == '#') continue;

            int nmask = mask;
            if(item_idx[ny][nx] != -1)
                nmask |= (1 << item_idx[ny][nx]);
            if(!visited[ny][nx][nmask]) {
                visited[ny][nx][nmask] = 1;
                q.push({ny, nx, nmask, dist + 1});
            }
        }
    }
    return -1;
}

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    cin >> N >> M;
    house.resize(M);
    for(int i = 0; i < M; ++i)
        cin >> house[i];

    int sy, sx, ey, ex;
    items.clear();
    for(int i = 0; i < M; ++i) {
        for(int j = 0; j < N; ++j) {
            if(house[i][j] == 'S') sy = i, sx = j;
            if(house[i][j] == 'E') ey = i, ex = j;
            if(house[i][j] == 'X') items.push_back({i, j});
        }
    }

    int answer = bfs(sy, sx, ey, ex, items);
    cout << answer << '\n';
    return 0;
}

[Fnhid]

저도 비트마스킹을 처음 접해보아서 수도 코드 보면서 짜보았습니다..!

bfs는 하던 대로 했고,
dp[a][b]에서
a를 가장 최근에 방문한 물건, b를 방문한 물건의 집합으로 작성했어요

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

using namespace std;
#define X first
#define Y second
#define INF 999999999

int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

vector<vector<int> > bfs(pair<int, int> sp, int m, int n, const vector<string> &map) {
    vector<vector<int> > visited(m, vector<int>(n, -1));
    queue<pair<int, int> > q;

    q.push(sp);
    visited[sp.X][sp.Y] = 0;

    while (!q.empty()) {
        pair<int, int> cur = q.front();
        q.pop();

        for (int i = 0; i < 4; i++) {
            int nx = cur.X + dx[i];
            int ny = cur.Y + dy[i];
            if (nx < 0 || nx >= m || ny < 0 || ny >= n ||
                map[nx][ny] == '#' || visited[nx][ny] != -1)
                continue;
            visited[nx][ny] = visited[cur.X][cur.Y] + 1;
            q.push({nx, ny});
        }
    }
    return visited;
}

int main() {
    vector<pair<int, int> > x;
    pair<int, int> s, e;

    vector<pair<int, int> > p;

    int n, m;
    cin >> n >> m;

    vector<string> map;
    map.resize(m);


    for (int i = 0; i < m; i++) {
        cin >> map[i];
    }

    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (map[i][j] == 'S') {
                s.X = i;
                s.Y = j;
            } else if (map[i][j] == 'E') {
                e.X = i;
                e.Y = j;
            } else if (map[i][j] == 'X')
                x.push_back(pair<int, int>(i, j));
        }
    }

    p.push_back(s);
    for (const auto &i: x)
        p.push_back(i);
    p.push_back(e);
    int p_size = p.size();
    vector<vector<int> > dist_matrix(p_size, vector<int>(p_size));

    //bfs
    for (int i = 0; i < p_size; i++) {
        vector<vector<int> > dist = bfs(p[i], m, n, map);
        for (int j = 0; j < p_size; j++) {
            dist_matrix[i][j] = dist[p[j].X][p[j].Y];
        }
    }

    int x_size = x.size();

    if (x_size == 0) {
        cout << dist_matrix[0][1] << endl;
        return 0;
    }
    // dp
    vector<vector<int> > dp(x_size, vector<int>(1 << x_size, INF));

    for (int i = 0; i < x_size; i++) {
        dp[i][1 << i] = dist_matrix[0][i + 1];
    }

    for (int mask = 1; mask < (1 << x_size); mask++) {
        for (int i = 0; i < x_size; i++) {
            if (mask & (1 << i)) {
                for (int j = 0; j < x_size; j++) {
                    if (!(mask & (1 << j))) {
                        int cost = dist_matrix[i + 1][j + 1];
                        int next_mask = mask | (1 << j);
                        dp[j][next_mask] = min(dp[j][next_mask], dp[i][mask] + cost);
                    }
                }
            }
        }
    }
    int min_total_dist = INF;
    int all_mask = (1 << x_size) - 1;

    for (int i = 0; i < x_size; i++) {
        int cost_to_end = dist_matrix[i + 1][x_size + 1];
        min_total_dist = min(min_total_dist, cost_to_end + dp[i][all_mask]);
    }
    cout << min_total_dist << endl;
    return 0;
}

[9kyo-hwang]

비트 마스킹으로 현재 챙긴 물건들을 표현하면, visited 방문 처리를 쉽게 해낼 수 있죠. 약간 어려운 그래프 문제는 비트 마스킹을 섞는 쪽으로 꾸준히 나오는 것 같아요 :)

그런데 주어지는 입력을 보면 집 크기나 아이템 개수의 최대값이 작기 때문에 조금 비효율적인 풀이도 될 것 같더라구요. 저는 아래와 같이 풀어봤습니다.

1. 시작 지점 S와 도착 지점 E는 고정
2. S, E 사이에 방문해야 할 아이템 순서를 "순열"을 이용해 모든 경우의 수를 확인
3. S -> $X_1$에 대해 BFS / $X_1$ -> $X_2$에 대해 BFS / ... / $X_k$ -> E에 대해 BFS를 수행, 각각의 BFS로부터 반환된 최단 경로의 합을 계산
4. 이 최단 경로 합 중 가장 작은 값을 출력

소스 코드

#include <bits/stdc++.h>

using namespace std;
using Vector2 = pair<int32_t, int32_t>;

enum : uint8_t {
    START = 'S',
    END = 'E',
    ITEM = 'X',
    EMPTY = '.',
    WALL = '#',
};

const vector<Vector2> OFFSET {
    {-1, 0},
    {0, 1},
    {1, 0},
    {0, -1}
};

int32_t N, M;
vector<vector<int32_t>> gVisited;
Vector2 s, e;
vector<Vector2> items;

inline bool isOutOfBound(int i, int j) {
    return i < 0 || i >= N || j < 0 || j >= M;
}

int32_t BFS(Vector2 src, Vector2 dst) {
    queue<Vector2> q;
    q.emplace(src);
    
    vector<vector<int32_t>> visited = gVisited;
    visited[src.first][src.second] = 0;
    
    int32_t move = 0;
    while(!q.empty()) {
        const auto cur = q.front();
        q.pop();
        
        if(cur == dst) {
            move = visited[dst.first][dst.second];
            break;
        }
        
        const auto& [i, j] = cur;
        for(const auto& [di, dj] : OFFSET) {
            int32_t ni = i + di, nj = j + dj;
            if(isOutOfBound(ni, nj) || visited[ni][nj] > -1) {
                continue;
            }
            
            visited[ni][nj] = visited[i][j] + 1;
            q.emplace(ni, nj);
        }
    }
    
    return move;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    cin >> M >> N;
    gVisited.assign(N, vector<int32_t>(M, -1));

    for(int32_t i = 0; i < N; ++i) {
        for(int32_t j = 0; j < M; ++j) {
            uint8_t val; cin >> val;
            if(val == WALL) {
                gVisited[i][j] = 0;
                continue;
            }
            
            if(val == START) {
                s = {i, j};
            } else if(val == END) {
                e = {i, j};
            } else if(val == ITEM) {
                items.emplace_back(i, j);
            }
        }
    }
    
    if(items.empty()) {
        cout << BFS(s, e);
        return 0;
    }
    
    sort(items.begin(), items.end());
    
    int32_t ans = 1e9;
    do
    {
        int32_t move = BFS(s, items.front());
        for(int32_t i = 0; i < items.size() - 1; ++i) {
            move += BFS(items[i], items[i + 1]);
        }
        move += BFS(items.back(), e);
        
        ans = min(ans, move);
    } while(next_permutation(items.begin(), items.end()));
    
    cout << ans;

    return 0;
}

그런데 다시 생각해보니 시작 지점, 도착 지점, 물건 지점 별 거리는 고정되어 있더라구요. 모든 경우의 수 마다 BFS를 호출해서 거리를 다시 계산할 필요는 없이, 최초 1회에 한해 모든 위치에 대한 최단 경로 값을 미리 계산해놓으면 순열을 이용해 경우의 수를 따질 때 캐싱된 거리값을 이용하면 더 빠르게 계산할 수 있겠더라구요.

C++

#include <bits/stdc++.h>
using namespace std;
using Vector2 = pair<int, int>;

enum : uint8_t {
    START = 'S',
    END   = 'E',
    ITEM  = 'X',
    EMPTY = '.',
    WALL  = '#',
};

const vector<Vector2> OFFSET = {
    {-1, 0}, {0, 1}, {1, 0}, {0, -1}
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int M, N;
    cin >> M >> N;
    
    vector<vector<char>> house(N, vector<char>(M));
    Vector2 s, e;
    deque<Vector2> points;

    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < M; ++j) {
            char c;
            cin >> c;
            house[i][j] = c;
            
            if(c == START) {
                s = {i, j};
            } else if(c == END) {
                e = {i, j};
            } else if(c == ITEM) {
                points.emplace_back(i, j);
            }
        }
    }
    
    points.emplace_front(s);
    points.emplace_back(e);
    
    auto isOutOfBound = [N, M](int i, int j) {
        return i < 0 || i >= N || j < 0 || j >= M;
    };

    auto BFS = [&house, N, M, &isOutOfBound](const Vector2 &src) {
        queue<Vector2> q;
        vector<vector<int>> d(N, vector<int>(M, -1));
        
        q.push(src);
        d[src.first][src.second] = 0;

        while (!q.empty()) {
            auto [i, j] = q.front();
            q.pop();
            for (const auto& [di, dj] : OFFSET) {
                int ni = i + di, nj = j + dj;
                if(isOutOfBound(ni, nj) || house[ni][nj] == WALL || d[ni][nj] > -1) {
                    continue;
                }
                
                d[ni][nj] = d[i][j] + 1;
                q.emplace(ni, nj);
            }
        }
        
        return d;
    };
    
    const int numPoints = points.size();
    const int INF = 1e9;
    vector<vector<int>> dist(numPoints, vector<int>(numPoints, INF));
    
    for(int u = 0; u < numPoints; ++u) {
        auto distFromSrc = BFS(points[u]);  // u번 지점(출발/도착/물건들 중 1개)으로부터 나머지 모든 지점까지의 거리가 저장된 2차원 배열
        for(int v = 0; v < numPoints; ++v) {
            const auto& [vi, vj] = points[v];
            if(u != v && distFromSrc[vi][vj] > -1) {
                dist[u][v] = distFromSrc[vi][vj];  // u-> v 최단 거리 저장
            }
        }
    }
    
    int ans = INF;
    if (points.size() == 2) {  // 가져가야 할 물건이 없다면
        ans = dist[0][1];  // points는 [S, E]만 존재
    } else {  // 물건이 있다면
        vector<int> perm;
        for(int i = 1; i <= numPoints - 2; ++i) {  // S, [X1, X2, ..., Xi], K 중 물건들에 대한 인덱스 추출
            perm.emplace_back(i);
        }
        
        sort(perm.begin(), perm.end());
        
        do {
            int sum = dist[0][perm[0]];  // S -> 물건 1번
            for (int i = 0; i + 1 < perm.size(); ++i) {  // 물건 1번 -> 2번, 2번 -> 3번, ...
                sum += dist[perm[i]][perm[i + 1]];
            }
            
            sum += dist[perm.back()][numPoints - 1];  // 마지막 물건 -> E
            
            ans = min(ans, sum);  // 거리 합 중 최소값 캐싱
        } while (next_permutation(perm.begin(), perm.end()));  // 물건 인덱스들을 순열로 모든 경우의 수 확인
    }

    cout << ans;
    return 0;
}

python

def solution(N, M, house):
    s, e = None, None
    p = []
    for i in range(N):
        for j, c in enumerate(house[i]):
            if c == 'S': 
                s = (i, j)
            elif c == 'E': 
                e = (i, j)
            elif c == 'X': 
                p.append((i, j))
            
            
    p = [s] + p + [e]
    pn = len(p)
    
    OFFSET = ((-1, 0), (0, 1), (1, 0), (0, -1))
    
    def bfs(src):
        q = deque([src])
        d = [[-1] * M for _ in range(N)]
        d[src[0]][src[1]] = 0
        
        while q:
            i, j = q.popleft()
            for di, dj in OFFSET:
                ni, nj = i + di, j + dj
                if (0 <= ni < N and 0 <= nj < M) and house[ni][nj] != '#' and d[ni][nj] == -1:
                    d[ni][nj] = d[i][j] + 1
                    q.append((ni, nj))

                
        return d
        
        
    INF = 10**9
    pn = len(p)
    dist = [[INF] * pn for _ in range(pn)]
    for u, src in enumerate(p):
        d = bfs(p[u])
        for v, dst in enumerate(p):
            vi, vj = dst
            if u != v and d[vi][vj] > -1:
                dist[u][v] = d[vi][vj]
                
                
    ans = INF
    items = list(range(1, pn - 1))
    if not items:
        ans = dist[0][1]
    else:
        for perm in permutations(items):
            total = dist[0][perm[0]]
            for a, b in zip(perm, perm[1:]):
                total += dist[a][b]
            total += dist[perm[-1]][pn - 1]
            ans = min(ans, total)

    return ans
    
    
def main(input):
    M, N = map(int, input().split())
    house = tuple(tuple(input().rstrip()) for _ in range(N))
    print(solution(N, M, house))


if __name__ == "__main__":
    from collections import deque
    from itertools import permutations
    main(open(0).readline)

[hadongun]

비트마스킹이 익숙치 않아 그냥 visited 리스트를 이용해 도전해보았습니다

이전에 봤던 문제들은 거리 테이블이 주어졌던 것 같은데
거리 테이블을 직접 구해야 하는 경우는 처음 보는 것 같아요!

그래프 탐색을 조금 알게 됐다고 생각했지만 더 열심히 해야겠슴둥..

Details

from collections import deque
import sys
input = sys.stdin.readline

def bfs(sx, sy, board, N, M):
    visited = [[-1]*N for _ in range(M)]
    q = deque()
    q.append((sx, sy))
    visited[sy][sx] = 0

    while q:
        x, y = q.popleft()
        for dx, dy in [(0,1), (1,0), (0,-1), (-1,0)]:
            nx, ny = x + dx, y + dy
            if 0 <= nx < N and 0 <= ny < M and board[ny][nx] != '#' and visited[ny][nx] == -1:
                visited[ny][nx] = visited[y][x] + 1
                q.append((nx, ny))
    return visited

N, M = map(int, input().split())
board = [list(input().strip()) for _ in range(M)]

points = []
for i in range(M):
    for j in range(N):
        if board[i][j] == 'S':
            points.insert(0, (j, i))  
        elif board[i][j] == 'E':
            points.append((j, i))     
        elif board[i][j] == 'X':
            points.append((j, i))     

k = len(points) 

dist_table = [[-1]*k for _ in range(k)]
for i in range(k):
    visited = bfs(points[i][0], points[i][1], board, N, M)
    for j in range(k):
        x, y = points[j]
        dist_table[i][j] = visited[y][x]

min_total = sys.maxsize
visited = [False] * k

def dfs(now, depth, total):
    global min_total
    if depth == k - 2:  
        d = dist_table[now][k-1]  
        if d != -1:
            min_total = min(min_total, total + d)
        return

    for nxt in range(1, k - 1):  
        if not visited[nxt]:
            d = dist_table[now][nxt]
            if d == -1:
                continue
            visited[nxt] = True
            dfs(nxt, depth + 1, total + d)
            visited[nxt] = False

dfs(0, 0, 0)
print(min_total)