feat: add solutions to lc problem: No.0773

No.0773.Sliding Puzzle

Author: yanglbme

solution/0700-0799/0773.Sliding Puzzle/README.md

@@ -58,7 +58,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-BFS 最小步数模型。
+BFS 最小步数模型。可以使用朴素 BFS 直接搜索，也可以使用 A\* 算法优化搜索。
+
+A\* 算法主要思想如下：
+
+1. 将 BFS 队列转换为优先队列（小根堆）；
+1. 队列中的每个元素为 `(dist[state] + f(state), state)`，`dist[state]` 表示从起点到当前 state 的距离，`f(state)` 表示从当前 state 到终点的估计距离，这两个距离之和作为堆排序的依据；
+1. 当终点第一次出队时，说明找到了从起点到终点的最短路径，直接返回对应的 step；
+1. `f(state)` 是估价函数，并且估价函数要满足 `f(state) <= g(state)`，其中 `g(state)` 表示 state 到终点的真实距离；
+1. A\* 算法只能保证终点第一次出队时，即找到了一条从起点到终点的最小路径，不能保证其他点出队时也是从起点到当前点的最短路径。
 
 <!-- tabs:start -->
 
@@ -76,7 +84,7 @@ class Solution:
                 for j in range(3):
                     t[i * 3 + j] = str(board[i][j])
             return ''.join(t)
-        
+
         def setb(s):
             for i in range(2):
                 for j in range(3):
@@ -121,6 +129,58 @@ class Solution:
         return -1
 ```
 
+A* 算法：
+
+```python
+class Solution:
+    def slidingPuzzle(self, board: List[List[int]]) -> int:
+        m, n = 2, 3
+        seq = []
+        start, end = '', '123450'
+        for i in range(m):
+            for j in range(n):
+                if board[i][j] != 0:
+                    seq.append(board[i][j])
+                start += str(board[i][j])
+
+        def check(seq):
+            n = len(seq)
+            cnt = sum(seq[i] > seq[j] for i in range(n) for j in range(i, n))
+            return cnt % 2 == 0
+
+        def f(s):
+            ans = 0
+            for i in range(m * n):
+                if s[i] != '0':
+                    num = ord(s[i]) - ord('1')
+                    ans += abs(i // n - num // n) + abs(i % n - num % n)
+            return ans
+
+
+        if not check(seq):
+            return -1
+        q = [(f(start), start)]
+        dist = {start: 0}
+        while q:
+            _, state = heapq.heappop(q)
+            if state == end:
+                return dist[state]
+            p1 = state.index('0')
+            i, j = p1 // n, p1 % n
+            s = list(state)
+            for a, b in [[0, -1], [0, 1], [1, 0], [-1, 0]]:
+                x, y = i + a, j + b
+                if 0 <= x < m and 0 <= y < n:
+                    p2 = x * n + y
+                    s[p1], s[p2] = s[p2], s[p1]
+                    next = ''.join(s)
+                    s[p1], s[p2] = s[p2], s[p1]
+                    if next not in dist or dist[next] > dist[state] + 1:
+                        dist[next] = dist[state] + 1
+                        heapq.heappush(q, (dist[next] + f(next), next))
+        return -1
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -214,6 +274,91 @@ class Solution {
 }
 ```
 
+A* 算法：
+
+```java
+class Solution {
+    private int m = 2;
+    private int n = 3;
+
+    public int slidingPuzzle(int[][] board) {
+        String start = "";
+        String end = "123450";
+        String seq = "";
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                start += board[i][j];
+                if (board[i][j] != 0) {
+                    seq += board[i][j];
+                }
+            }
+        }
+        if (!check(seq)) {
+            return -1;
+        }
+        PriorityQueue<Pair<Integer, String>> q = new PriorityQueue<>(Comparator.comparingInt(Pair::getKey));
+        Map<String, Integer> dist = new HashMap<>();
+        dist.put(start, 0);
+        q.offer(new Pair<>(f(start), start));
+        int[] dirs = {-1, 0, 1, 0, -1};
+        while (!q.isEmpty()) {
+            String state = q.poll().getValue();
+            int step = dist.get(state);
+            if (end.equals(state)) {
+                return step;
+            }
+            int p1 = state.indexOf("0");
+            int i = p1 / n, j = p1 % n;
+            char[] s = state.toCharArray();
+            for (int k = 0; k < 4; ++k) {
+                int x = i + dirs[k], y = j + dirs[k + 1];
+                if (x >= 0 && x < m && y >= 0 && y < n) {
+                    int p2 = x * n + y;
+                    swap(s, p1, p2);
+                    String next = String.valueOf(s);
+                    if (!dist.containsKey(next) || dist.get(next) > step + 1) {
+                        dist.put(next, step + 1);
+                        q.offer(new Pair<>(step + 1 + f(next), next));
+                    }
+                    swap(s, p1, p2);
+                }
+            }
+        }
+        return -1;
+    }
+
+    private void swap(char[] arr, int i, int j) {
+        char t = arr[i];
+        arr[i] = arr[j];
+        arr[j] = t;
+    }
+
+    private int f(String s) {
+        int ans = 0;
+        for (int i = 0; i < m * n; ++i) {
+            if (s.charAt(i) != '0') {
+                int num = s.charAt(i) - '1';
+                ans += Math.abs(i / n - num / n) + Math.abs(i % n - num % n);
+            }
+        }
+        return ans;
+    }
+
+    private boolean check(String s) {
+        int n = s.length();
+        int cnt = 0;
+        for (int i = 0; i < n; ++i) {
+            for (int j = i + 1; j < n; ++j) {
+                if (s.charAt(i) > s.charAt(j)) {
+                    ++cnt;
+                }
+            }
+        }
+        return cnt % 2 == 0;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -297,6 +442,81 @@ public:
 };
 ```
 
+A* 算法：
+
+```cpp
+class Solution {
+public:
+    int m = 2;
+    int n = 3;
+
+    int slidingPuzzle(vector<vector<int>>& board) {
+        string start, seq;
+        string end = "123450";
+        for (int i = 0; i < m; ++i)
+        {
+            for (int j = 0; j < n; ++j)
+            {
+                start += char(board[i][j] + '0');
+                if (board[i][j] != 0) seq += char(board[i][j] + '0');
+            }
+        }
+        if (!check(seq)) return -1;
+        typedef pair<int , string> PIS;
+        priority_queue<PIS, vector<PIS>, greater<PIS>> q;
+        unordered_map<string, int> dist;
+        dist[start] = 0;
+        q.push({f(start), start});
+        vector<int> dirs = {-1, 0, 1, 0, -1};
+        while (!q.empty())
+        {
+            PIS t = q.top();
+            q.pop();
+            string state = t.second;
+            int step = dist[state];
+            if (state == end) return step;
+            int p1 = state.find('0');
+            int i = p1 / n, j = p1 % n;
+            for (int k = 0; k < 4; ++k)
+            {
+                int x = i + dirs[k], y = j + dirs[k + 1];
+                if (x < 0 || x >= m || y < 0 || y >= n) continue;
+                int p2 = x * n + y;
+                swap(state[p1], state[p2]);
+                if (!dist.count(state) || dist[state] > step + 1)
+                {
+                    dist[state] = step + 1;
+                    q.push({step + 1 + f(state), state});
+                }
+                swap(state[p1], state[p2]);
+            }
+        }
+        return -1;
+    }
+
+    bool check(string s) {
+        int n = s.size();
+        int cnt = 0;
+        for (int i = 0; i < n; ++i)
+            for (int j = i; j < n; ++j)
+                if (s[i] > s[j])
+                    ++cnt;
+        return cnt % 2 == 0;
+    }
+
+    int f(string s) {
+        int ans = 0;
+        for (int i = 0; i < m * n; ++i)
+        {
+            if (s[i] == '0') continue;
+            int num = s[i] - '1';
+            ans += abs(num / n - i / n) + abs(num % n - i % n);
+        }
+        return ans;
+    }
+};
+```
+
 ### **...**
 
 ```