題目

LCP 13. 尋寶

我的思路

第一次接觸此類“狀態壓縮”的動態規劃問題。下面整理一下網上題解的思路。

首先需要把題目簡化，我們只需要關注3種距離：

• 從S走到O
• 從O走到M，和從M走到O
• 從M走到T

通過預處理（深搜），預先儲存得到從S到各個O的最短距離，每一個O與每一個M之間的最短距離，每一個M到T的最短距離。可以通過進一步計算得到任意兩個M之間通過某個O的前提下的最短距離d[i][j]（從Mi到Mj經過某個O的最短距離）。

這時有一種很直觀的思路是繼續深搜解決問題，根節點S有n棵子樹（路線從S出發第一次到達某個M），接著每一棵子樹有n-1個孩子節點（未抵達過的M），如此下去直到走完所有的M。這樣一來複雜度達到了n！級別。這其中很顯然會有不少重複計算，比如多條路線中出線M2、M3、M4這樣的序列，如何記憶化儲存呢？似乎不方便，但一定和狀態變化有關！

另一種思路是在於處理的前提下進行動態規劃，我的想法是對2^n個狀態（每個M被觸發與否），從無到有進行遍歷。因為有t個機關被觸發的狀態一定是由有t-1個機關被觸發的狀態轉移過來的。這時的複雜度是(2^n)*n*n。相比階乘的複雜度有所降低。

我的實現

官方題解實現，它用了一個掩碼錶示狀態的技巧。

class Solution {
public:
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    int n, m;

    bool inBound(int x, int y) {
        return x >= 0
 
 && x < n && y >= 0 && y < m;
    }

    vector<vector<int>> bfs(int x, int y, vector<string>& maze) {
        vector<vector<int>> ret(n, vector<int>(m, -1));
        ret[x][y] = 0;
        queue<pair<int, int>> Q;
        Q.push({x, y});
        
 
while (!Q.empty()) {
            auto p = Q.front();
            Q.pop();
            int x = p.first, y = p.second;
            for (int k = 0; k < 4; k++) {
                int nx = x + dx[k], ny = y + dy[k];
                if (inBound(nx, ny) && maze[nx][ny] != '#' && ret[nx][ny] == -1) {
                    ret[nx][ny] = ret[x][y] + 1;
                    Q.push({nx, ny});
                }
            }
        }
        return ret;
    }

    int minimalSteps(vector<string>& maze) {
        n = maze.size(), m = maze[0].size();
        // 機關 & 石頭
        vector<pair<int, int>> buttons, stones;
        // 起點 & 終點
        int sx, sy, tx, ty;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (maze[i][j] == 'M') {
                    buttons.push_back({i, j});
                }
                if (maze[i][j] == 'O') {
                    stones.push_back({i, j});
                }
                if (maze[i][j] == 'S') {
                    sx = i, sy = j;
                }
                if (maze[i][j] == 'T') {
                    tx = i, ty = j;
                }
            }
        }
        int nb = buttons.size();
        int ns = stones.size();
        vector<vector<int>> start_dist = bfs(sx, sy, maze);

        // 邊界情況：沒有機關
        if (nb == 0) {
            return start_dist[tx][ty];
        }
        // 從某個機關到其他機關 / 起點與終點的最短距離。
        vector<vector<int>> dist(nb, vector<int>(nb + 2, -1));
        // 中間結果
        vector<vector<vector<int>>> dd(nb);
        for (int i = 0; i < nb; i++) {
            vector<vector<int>> d = bfs(buttons[i].first, buttons[i].second, maze);
            dd[i] = d;
            // 從某個點到終點不需要拿石頭
            dist[i][nb + 1] = d[tx][ty];
        }

        for (int i = 0; i < nb; i++) {
            int tmp = -1;
            for (int k = 0; k < ns; k++) {
                int mid_x = stones[k].first, mid_y = stones[k].second;
                if (dd[i][mid_x][mid_y] != -1 && start_dist[mid_x][mid_y] != -1) {
                    if (tmp == -1 || tmp > dd[i][mid_x][mid_y] + start_dist[mid_x][mid_y]) {
                        tmp = dd[i][mid_x][mid_y] + start_dist[mid_x][mid_y];
                    }
                }
            }
            dist[i][nb] = tmp;
            for (int j = i + 1; j < nb; j++) {
                int mn = -1;
                for (int k = 0; k < ns; k++) {
                    int mid_x = stones[k].first, mid_y = stones[k].second;
                    if (dd[i][mid_x][mid_y] != -1 && dd[j][mid_x][mid_y] != -1) {
                        if (mn == -1 || mn > dd[i][mid_x][mid_y] + dd[j][mid_x][mid_y]) {
                            mn = dd[i][mid_x][mid_y] + dd[j][mid_x][mid_y];
                        }
                    }
                }
                dist[i][j] = mn;
                dist[j][i] = mn;
            }
        }

        // 無法達成的情形
        for (int i = 0; i < nb; i++) {
            if (dist[i][nb] == -1 || dist[i][nb + 1] == -1) return -1;
        }
        
        // dp 陣列， -1 代表沒有遍歷到
        vector<vector<int>> dp(1 << nb, vector<int>(nb, -1));
        for (int i = 0; i < nb; i++) {
            dp[1 << i][i] = dist[i][nb];
        }
        
        // 由於更新的狀態都比未更新的大，所以直接從小到大遍歷即可
        for (int mask = 1; mask < (1 << nb); mask++) {
            for (int i = 0; i < nb; i++) {
                // 當前 dp 是合法的
                if (mask & (1 << i)) {
                    for (int j = 0; j < nb; j++) {
                        // j 不在 mask 裡
                        if (!(mask & (1 << j))) {
                            int next = mask | (1 << j);
                            if (dp[next][j] == -1 || dp[next][j] > dp[mask][i] + dist[i][j]) {
                                dp[next][j] = dp[mask][i] + dist[i][j];
                            }
                        }
                    }
                }
            }
        }

        int ret = -1;
        int final_mask = (1 << nb) - 1;
        for (int i = 0; i < nb; i++) {
            if (ret == -1 || ret > dp[final_mask][i] + dist[i][nb + 1]) {
                ret = dp[final_mask][i] + dist[i][nb + 1];
            }
        }

        return ret;
    }
};

作者：LeetCode-Solution
連結：https://leetcode-cn.com/problems/xun-bao/solution/xun-bao-bfs-dp-by-leetcode-solution/
來源：力扣（LeetCode）
著作權歸作者所有。商業轉載請聯絡作者獲得授權，非商業轉載請註明出處。

拓展學習

狀態壓縮的動態規劃

下面這個題解也不錯

https://leetcode-cn.com/problems/xun-bao/solution/bfs-zhuang-tai-ya-suo-dp-by-haozheyan97/