从解决方案开始，确定排列的等级

Question

我正在阅读有关this的内容，并考虑形成一种算法来找到解决此问题的最小动作数。

我做出的限制：N X N矩阵有一个空插槽，比如说0，会绘制数字0 to n-1。

现在我们必须重新创建这个矩阵并从顶行开始从左到右依次递增数字，并且最后一个元素0即（N X Nth）元素。

例如，

Input :

8 4 0
7 2 5
1 3 6

Output:
1 2 3
4 5 6
7 8 0

现在问题是如何以尽可能少的步骤执行此操作。在游戏（提供的链接）中，您可以向左，向右，向上或向下移动，并将0（空槽）移动到相应位置以制作最终矩阵。

此算法打印的输出是步骤数M然后Tile（数字）移动方向说1，用于与上邻元素交换{{1} 1}}用于下相邻元素，2用于左相邻元素，3用于右相邻元素。

喜欢，对于

答案应为：2 <--- order of N X N matrix 3 1 0 2其中3 4 1 2为3，而M是平铺移动的步骤。

因此，我必须尽量减少此算法的复杂性，并希望找到最少的移动次数。请建议我解决此算法的最有效方法。

修改

我用c ++编写的内容，4 1 2。

Please see the algorithm rather than pointing out other issues in code

在上面的代码中，我正在检查每个具有最低成本（#include <bits/stdc++.h> using namespace std; int inDex=0,shift[100000],N,initial[500][500],final[500][500]; struct Node { Node* parent; int mat[500][500]; int x, y; int cost; int level; }; Node* newNode(int mat[500][500], int x, int y, int newX, int newY, int level, Node* parent) { Node* node = new Node; node->parent = parent; memcpy(node->mat, mat, sizeof node->mat); swap(node->mat[x][y], node->mat[newX][newY]); node->cost = INT_MAX; node->level = level; node->x = newX; node->y = newY; return node; } int row[] = { 1, 0, -1, 0 }; int col[] = { 0, -1, 0, 1 }; int calculateCost(int initial[500][500], int final[500][500]) { int count = 0; for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) if (initial[i][j] && initial[i][j] != final[i][j]) count++; return count; } int isSafe(int x, int y) { return (x >= 0 && x < N && y >= 0 && y < N); } struct comp { bool operator()(const Node* lhs, const Node* rhs) const { return (lhs->cost + lhs->level) > (rhs->cost + rhs->level); } }; void solve(int initial[500][500], int x, int y, int final[500][500]) { priority_queue<Node*, std::vector<Node*>, comp> pq; Node* root = newNode(initial, x, y, x, y, 0, NULL); Node* prev = newNode(initial,x,y,x,y,0,NULL); root->cost = calculateCost(initial, final); pq.push(root); while (!pq.empty()) { Node* min = pq.top(); if(min->x > prev->x) { shift[inDex] = 4; inDex++; } else if(min->x < prev->x) { shift[inDex] = 3; inDex++; } else if(min->y > prev->y) { shift[inDex] = 2; inDex++; } else if(min->y < prev->y) { shift[inDex] = 1; inDex++; } prev = pq.top(); pq.pop(); if (min->cost == 0) { cout << min->level << endl; return; } for (int i = 0; i < 4; i++) { if (isSafe(min->x + row[i], min->y + col[i])) { Node* child = newNode(min->mat, min->x, min->y, min->x + row[i], min->y + col[i], min->level + 1, min); child->cost = calculateCost(child->mat, final); pq.push(child); } } } } int main() { cin >> N; int i,j,k=1; for(i=0;i<N;i++) { for(j=0;j<N;j++) { cin >> initial[j][i]; } } for(i=0;i<N;i++) { for(j=0;j<N;j++) { final[j][i] = k; k++; } } final[N-1][N-1] = 0; int x = 0, y = 1,a[100][100]; solve(initial, x, y, final); for(i=0;i<inDex;i++) { cout << shift[i] << endl; } return 0; }）的子节点。

我想让这个算法更有效率并减少它的时间复杂度。任何建议都会很明显。

Answer 1

虽然这听起来很像家庭作业问题，但我会提供一些帮助。

对于非常小的问题，例如你的2x2或3x3，你可以蛮力强迫它。基本上，你可以对每一个可能的移动进行各种可能的组合，跟踪每次拍摄的转弯次数，然后打印出最小的转弯。

要改进这一点，请维护已解决的解决方案列表，然后在任何可能的移动时，如果已经完成移动，请停止尝试，因为它不可能是最小的。

示例，假设我处于这种状态（将矩阵展平为字符串以便于显示）：

5736291084
6753291084
5736291084

请注意，我们已经回到了以前见过的状态。这意味着它不可能是最小的移动，因为最小的移动不会返回到先前的状态。

你会想要创建一个这样做的树，所以你有类似的东西：

                            134
                            529
                            870
                           /   \
                          /     \
                         /       \
                        /         \
                     134           134
                     529           520
                     807           879
                    / | \         / | \
                   /  |  X       /  X  \
                134  134  134 134  134  130
                509  529  529 502  529  524
                827  087  870 879  870  879

等等。注意我用X标记了一些，因为它们是重复的，因此我们不想继续追求它们，因为我们知道它们不是最小的。

你只是不断重复这个，直到你尝试了所有可能的解决方案（即所有未停止的叶子到达解决方案），然后你只看到哪个是最短的。您也可以并行执行此操作，以便在任何人找到解决方案后停止，从而节省您的时间。

这种蛮力方法对大型矩阵无效。要解决这些问题，您需要考虑一些严肃的软件工程。您可以采用的一种方法是将其分解为更小的矩阵并以此方式解决，但这可能不是最佳路径。

这是一个难以解决的问题，需要在较大的值下解决，并且存在一些棘手的NP问题。

从解决方案开始，确定排列的等级

上面的反面是如何预先生成所有可能值的列表。

从解决方案开始。它的排列等级为0（如，零移动）：

012
345
678

然后，从那里做出所有可能的动作。所有这些举动的排列等级为1，如同一举一动。

                         012
0                        345
                         678
                        /   \
                       /     \
                      /       \
                   102         312
1                  345         045 
                   678         678

重复上述内容。每个新级别都具有相同的排列等级。生成所有可能的移动（在这种情况下，直到所有分支都作为重复移除）。

然后，您可以将所有这些内容存储到一个对象中。展平矩阵会使这变得容易（例如使用JavaScript语法）：

{
  '012345678': 0,
  '102345678': 1,
  '312045678': 1,
  '142305678': 2,
  // and so on
}

然后，要解决您的问题“最小移动次数”，只需找到与您的起点相同的条目。排列的等级就是答案。

如果您处于可以预生成整个解决方案的场景中，这将是一个很好的解决方案。生成会花费一些时间，但查找速度会很快（这类似于破解哈希的“彩虹表”）。

如果你必须动态解决（没有预生成），那么第一个解决方案，从答案开始，逐步移动，直到你发现解决方案会更好。

虽然最大复杂度为O（n！），但只有O（n ^ 2）个可能的解决方案。在你去的时候砍掉树上的副本，你的复杂性将介于这两者之间，可能在O（n ^ 3）~O（2 ^ n）附近

Answer 2

您可以使用BFS。

每个状态都是一个顶点，如果它们可以相互转移，则两个顶点之间有一条边。

例如

8 4 0
7 2 5
1 3 6

和

8 0 4
7 2 5
1 3 6

已连接。

通常，您可能希望使用一些数字来表示当前状态。对于小网格，您可以按照数字的顺序。例如，

8 4 0
7 2 5
1 3 6

只是840725136。

如果网格很大，您可以考虑使用数字排列的等级作为状态的表示。例如，

0 1 2
3 4 5
6 7 8

应该是0，因为它是排列中的第一个。

和

0 1 2
3 4 5
6 7 8

（由0表示）和

1 0 2
3 4 5
6 7 8

（由其他数字X表示）连接与0相同，X连接在图中。

算法的复杂性应为O(n!)，因为最多有n!个顶点/排列。

如何获得最小数量的动作来解决“十五岁的游戏”？

2 个答案:

从解决方案开始，确定排列的等级