773. Sliding Puzzle

On a 2x3 board, there are 5 tiles represented by the integers 1 through 5, and an empty square represented by 0.

A move consists of choosing 0 and a 4-directionally adjacent number and swapping it.

The state of the board is solved if and only if the board is [[1,2,3],[4,5,0]].

Given a puzzle board, return the least number of moves required so that the state of the board is solved. If it is impossible for the state of the board to be solved, return -1.

Examples:

Input: board = [[1,2,3],[4,0,5]]
Output: 1
Explanation: Swap the 0 and the 5 in one move.
Input: board = [[1,2,3],[5,4,0]]
Output: -1
Explanation: No number of moves will make the board solved.
Input: board = [[4,1,2],[5,0,3]]
Output: 5
Explanation: 5 is the smallest number of moves that solves the board.
An example path:
After move 0: [[4,1,2],[5,0,3]]
After move 1: [[4,1,2],[0,5,3]]
After move 2: [[0,1,2],[4,5,3]]
After move 3: [[1,0,2],[4,5,3]]
After move 4: [[1,2,0],[4,5,3]]
After move 5: [[1,2,3],[4,5,0]]
Input: board = [[3,2,4],[1,5,0]]
Output: 14
Note:

board will be a 2 x 3 array as described above.
board[i][j] will be a permutation of [0, 1, 2, 3, 4, 5].

方法1: bfs

思路：

每一次我们尝试找到0的位置，然后将其上下左右做一次交换，检查是否能得到目标。为了方便查找，我们用string来代替棋盘，我们的目标就变成了查找“123450”。这就要求在输出和每次提取的时候做一下棋盘和string之间的转换。“最少”这个关键词应该第一时间map到bfs的方法。

Complexity

Time complexity: O(n!)
Space complexity: O(n!)

class Solution {
public:
    int slidingPuzzle(vector<vector<int>>& board) {
        int kRows = 2;
        int kCols = 3;
        string goal, start;
        for (int i = 0; i < board.size(); i++) {
            for (int j = 0; j < board[0].size(); j++) {
                start += board[i][j] + '0';
                goal += (i * kCols + j + 1) % (kRows * kCols) + '0';
            }
        }
        if (start == goal) return 0;
        
        vector<vector<int>> dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
        set<string> visited;
        queue<string> q;
        visited.insert(start);
        q.push(start);
        int steps = 0;
        while (!q.empty()) {
            steps++;
            int sz = q.size();
            while (sz-- > 0) {
                string top = q.front();
                q.pop();
                
                size_t pos = top.find('0');
                int i = pos / kCols;
                int j = pos % kCols;
                for (auto dir: dirs) {
                    int x = i + dir[0];
                    int y = j + dir[1];
                    if (x < 0 || x >= kRows || y < 0 || y >= kCols) continue;
                    size_t pos_swap = x * kCols + y;
                    string tmp(top);
                    swap(tmp[pos], tmp[pos_swap]);
                    if (visited.find(tmp) == visited.end()) {
                        if (tmp == goal) return steps;
                        visited.insert(tmp);
                        q.push(tmp);
                    }
                }
            }
        }
        return -1;
    }
};