bfs路径打印

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <string>
#include <map>
#include <algorithm>
#include <utility>

using namespace std;

const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {1, -1, 0, 0};
const int MAXN = 300000;
int tot = 0;

struct pii
{
int x, y, pre, ord;
pii(){}
pii(int x, int y, int pre, int ord):x(x), y(y), pre(pre), ord(ord){}
};

struct Node
{
int x, y, step, index;
int A[3][3];
Node(){}
Node(Node &rhs, int step, int index){
for(int i=0; i<3; ++i){
for(int j=0; j<3; ++j){
A[i][j] = rhs.A[i][j];
if(A[i][j] == 9){
x = i;
y = j;
}
}
}
this->step = step;
this->index = index;
}
string toString(){
string ret = "";
for(int i=0; i<3; ++i){
for(int j=0; j<3; ++j){
ret += (char)(A[i][j] + '0');
}
}
return ret;
}
void change(int x1, int y1){
int temp = A[x1][y1];
A[x1][y1] = A[x][y];
A[x][y] = temp;
x = x1; y = y1;
step += 1;
index = ++tot;
}
bool judge(){
for(int i=0; i<3; ++i){
for(int j=0; j<3; ++j){
if(A[i][j] != i*3 + j + 1) return false;
}
}
return true;
}
};

Node rhs;
pii B[MAXN];

inline bool check(int x, int y){
return (0<=x && x<3 && 0<=y && y<3);
}

void dfs(int index){
if(B[index].pre != -1) dfs(B[index].pre);
cout<<"("<<B[index].x<<", "<<B[index].y<<") "<<B[index].ord<<endl;
}

void bfs(){
map<string, bool> mp;
queue<Node> q;
q.push(rhs);
mp[rhs.toString()] = true;

B[tot].x = rhs.x;
B[tot].y = rhs.y;
B[tot].pre = -1;
B[tot].ord = 9;
++tot;
rhs.index = 0;

while(!q.empty()){
Node now = q.front(); q.pop();
if(now.judge()){
cout<<"total steps are: "<<now.step<<endl;
dfs(now.index);
return;
}
for(int i=0; i<4; ++i){
Node tmp = now;
int tx = tmp.x + dx[i];
int ty = tmp.y + dy[i];
if(check(tx, ty)){
tmp.change(tx, ty);
if(mp[tmp.toString()]) continue;
q.push(tmp);
mp[tmp.toString()] = true;
B[tot].x = tx;
B[tot].y = ty;
B[tot].pre = now.index;
B[tot].ord = now.A[tx][ty];
++tot;
}
}
}
}

int main(){
rhs.A[0][0] = 5; rhs.A[0][1] = 1; rhs.A[0][2] = 2;
rhs.A[1][0] = 7; rhs.A[1][1] = 8; rhs.A[1][2] = 4;
rhs.A[2][0] = 6; rhs.A[2][1] = 3; rhs.A[2][2] = 9;
rhs.x = 2;
rhs.y = 2;
rhs.step = 0;

rhs.judge();
bfs();
return 0;
}