编程题1

#include <bits/stdc++.h>
using namespace std;
const int N = 51;
int dir[4][2]={{0,-1}, {0,1}, {-1,0}, {1,0}};
bool vis[N][N][N][N];
char G[N][N];

struct P{
    int sx, sy, bx, by, t;
};

int main(){
    int n, m, s=-1;
    scanf("%d%d", &n, &m);
    P p;
    p.t = 0;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++){
            cin>>G[i][j];
            if(G[i][j] == 'S'){
                p.sx = i;
                p.sy = j;
            }else if(G[i][j]=='0'){
                p.bx = i;
                p.by = j;
            }
        }
    vis[p.sx][p.sy][p.bx][p.by] = true;
    queue<P> q;
    q.push(p);
    while(!q.empty() && s==-1){
        p = q.front();
        q.pop();
        if(p.t > 1000)
            break;
        for(int i=0;i<4 && s==-1;i++){
            int sx = p.sx + dir[i][0];
            int sy = p.sy + dir[i][1];
            int bx, by;
            if(sx<0 || sx>=n || sy<0 || sy>=m || G[sx][sy]=='#')
                continue;
            if(sx==p.bx && sy==p.by){
                bx = p.bx + dir[i][0];
                by = p.by + dir[i][1];
                if(G[bx][by]=='E')
                    s = p.t + 1;
            }else{
                bx = p.bx;
                by = p.by;
            }
            if(!vis[sx][sy][bx][by]){
                vis[sx][sy][bx][by] = true;
                q.push(P{sx, sy, bx, by, p.t+1});
            }
        }
    }
    printf("%d\n", s);
    return 0;
}

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        new Main().solute();
    }

    public void solute() {
        Scanner sc = new Scanner(System.in);
        // m n
        int m = sc.nextInt();
        int n = sc.nextInt();
        sc.nextLine();
        // maze
        String[] input = new String[m];
        for (int i = 0; i < m; i++) {
            input[i] = sc.nextLine();
        }
        char[][] maze = new char[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                maze[i][j] = input[i].charAt(j);
            }
        }

        bfs(m, n, maze);
    }

    public void bfs(int m, int n, char[][] maze) {
        int[][][][] arr = new int[m][n][m][n];
        Queue<int[]> queue = new LinkedList<>();
        // find S, box, E
        int sX = 0, sY = 0, bX = 0, bY = 0, eX = 0, eY = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (maze[i][j] == 'S') {
                    sX = i;
                    sY = j;
                }
                if (maze[i][j] == '0') {
                    bX = i;
                    bY = j;
                }
                if (maze[i][j] == 'E') {
                    eX = i;
                    eY = j;
                }
            }
        }
        queue.offer(new int[]{sX, sY, bX, bY});
        while (queue.peek() != null) {
            int[] poll = queue.poll();
            int sNowX = poll[0];
            int sNowY = poll[1];
            int bNowX = poll[2];
            int bNowY = poll[3];

            for (int i = 0; i < 4; i++) {
                int snx = sNowX + theX[i];
                int sny = sNowY + theY[i];
                int bnx = snx + theX[i];
                int bny = sny + theY[i];

                if (snx >= 0 && sny >= 0 && snx < m && sny < n && maze[snx][sny] != '#' &&
                        (snx != bNowX || sny != bNowY) &&
                        arr[snx][sny][bNowX][bNowY] == 0) {

                    arr[snx][sny][bNowX][bNowY] = arr[sNowX][sNowY][bNowX][bNowY] + 1;

                    queue.offer(new int[]{snx, sny, bNowX, bNowY});

                } else if (snx == bNowX && sny == bNowY &&
                        bnx >= 0 && bny >= 0 && bnx < m && bny < n && maze[bnx][bny] != '#' &&
                        arr[snx][sny][bnx][bny] == 0
                        ) {

                    arr[snx][sny][bnx][bny] = arr[sNowX][sNowY][snx][sny] + 1;

                    if (bnx == eX && bny == eY) {
                        System.out.println(arr[snx][sny][bnx][bny]);
                        return;
                    }

                    queue.offer(new int[]{snx, sny, bnx, bny});
                }
            }
        }
        System.out.println(-1);
    }

    // up right down left
    int[] theX = new int[]{-1, 0, 1, 0};
    int[] theY = new int[]{0, 1, 0, -1};
}

参考：https://blog.csdn.net/yuanxu716/article/details/78286266

from collections import deque
n,m=map(int,input().split())
board=[]
s=[]
b=[]
for i in range(n):
    tmp=input()
    board.append(tmp)
    if not s:
        sidx=tmp.find('S')
        if sidx!=-1: s=[i,sidx]
    if not b:
        bidx=tmp.find('0')
        if bidx!=-1: b=[i,bidx]
step=-1
q=deque([(s[0],s[1],b[0],b[1],0)])
visit=[[[[False]*m for _ in range(n)]for _ in range(m)]for _ in range(n)]
visit[s[0]][s[1]][b[0]][b[1]]=True
while q:
    p0,p1,b0,b1,cnt=q.popleft()
    if board[b0][b1]=='E': 
        step=cnt
        break 
    for dx,dy in zip((-1,0,1,0),(0,-1,0,1)):
        nx,ny=p0+dx,p1+dy
        if 0<=nx<n and 0<=ny<m and board[nx][ny]!='#':
            if nx==b0 and ny==b1:
                nb0,nb1=b0+dx,b1+dy
                if 0<=nb0<n and 0<=nb1<m and board[nb0][nb1]!='#':
                    if not visit[nx][ny][nb0][nb1]:
                        visit[nx][ny][nb0][nb1]=True
                        q.append((nx,ny,nb0,nb1,cnt+1))
            else:
                if not visit[nx][ny][b0][b1]:
                    visit[nx][ny][b0][b1]=True
                    q.append((nx,ny,b0,b1,cnt+1))
print(step)

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;

int n, m, x[4] = {1, -1, 0, 0}, y[4] = {0, 0, -1, 1};//四个方向移动，上下左右
char mp[55][55];
bool vis[5050][5050];//记录当前人位置和箱子位置状态是否待访问
//二维坐标结构体
struct node{
    int x, y;
    
    int toint(){//将二维坐标转化为整型，便于判断是否访问过
        return x * 100 + y;
    }
    friend bool operator == (node a, node b){
        return b.x == a.x && a.y == b.y;
    }
}now, box, target;
//记录当前人位置和箱子位置的结构体
struct status{
    node now, box;
    int ans;
    
    status(){}
    status(node _now, node _box, int _ans){
        now = _now, box = _box, ans = _ans;
    }
}temp;
// 队列存储bfs的状态
queue<status> nxt;

int bfs(){
    nxt.push(status(now, box, 0));//初始状态
    while(!nxt.empty()){
        temp = nxt.front();
        nxt.pop();
        if(temp.box == target){//判断当前箱子位置是否到达终点
            return temp.ans;
        }
        for(int i = 0; i < 4; ++i){
            now = temp.now, box = temp.box;
            now.x += x[i], now.y += y[i];//移动人的位置
            if(now == box){//若人的位置移动后与箱子位置重合则推箱子
                box.x += x[i], box.y += y[i];
            }//判断人和箱子位置是否同时访问过并合法，确保不越界而且可以到达
            if(mp[now.x][now.y] == '.' && mp[box.x][box.y] == '.' && !vis[now.toint()][box.toint()]){
                nxt.push(status(now, box, temp.ans + 1));
                vis[now.toint()][box.toint()] = true;
            }
        }
    }
    return -1;
}

int main(){
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= n; ++i){
        scanf("%s", mp[i] + 1);
    }
    for(int i = 1; i <= n; ++i){
        for(int j = 1; j <= m; ++j){//将人和箱子起始位置和预期位置记录下来，并改成可到达的位置以便搜索
            if(mp[i][j] == 'S'){
                now.x = i, now.y = j;
                mp[i][j] = '.';
            }
            else if(mp[i][j] == '0'){
                box.x = i, box.y = j;
                mp[i][j] = '.';
            }
            else if(mp[i][j] == 'E'){
                target.x = i, target.y = j;
                mp[i][j] = '.';
            }
        }
    }
    printf("%d", bfs());
}

#include<bits/stdc++.h>
using namespace std;
int main() {
	int n, m;
	cin >> n >> m;
	vector<vector<int>> v1(n, vector<int>(51, 0));
	vector<vector<vector<vector<int>>>> vi(n, vector<vector<vector<int>>>(51, v1));
	//int vi[6][51][6][51] = { 0 };
	int x, x2, x3, y, y2, y3;
	vector<vector<char>> v(n, vector<char>(m, '0'));
	for (int i = 0; i < n; i++) {
		for (int ii = 0; ii < m; ii++) {
			cin >> v[i][ii];
			if (v[i][ii]== 'S') {
				x = i;
				y = ii;
			}
			if (v[i][ii]== 'E') {
				x3 = i;
				y3 = ii;
			}
			if (v[i][ii] == '0') {
				x2 = i;
				y2 = ii;
			}
		}
	}

	queue<vector<int>> q;
	q.push({ x,y,x2,y2,0 });
	while (!q.empty()) {
		auto qq = q.front();
		q.pop();
		int x = qq[0], y = qq[1], x2 = qq[2], y2 = qq[3], i = qq[4];
		if (x3 == x2 && y3 == y2) {
			cout << i;
			return 0;
		}
		if (x<0||x2<0||y<0||y2<0||x>=n||y>=m||x2>=n||y2>=m || v[x][y] == '#'|| vi[x2][y2][x][y]==1) continue;
		vi[x2][y2][x][y] = 1;
		if ((abs(x - x2) == 1&& y==y2) || (abs(y - y2) == 1 &&x==x2)) {
			if (x - x2 == 1) {
				q.push({ x + 1,y,x2,y2,i + 1 });
				q.push({ x,y + 1,x2,y2,i + 1 });
				q.push({ x - 1,y,x2-1,y2,i + 1 });
				q.push({ x ,y - 1,x2,y2,i + 1 });
			}
			else if (x2 - x == 1) {
				q.push({ x + 1,y,x2+1,y2,i + 1 });
				q.push({ x,y + 1,x2,y2,i + 1 });
				q.push({ x - 1,y,x2,y2,i + 1 });
				q.push({ x ,y - 1,x2,y2,i + 1 });
			}
			else if (y - y2 == 1) {
				q.push({ x + 1,y,x2,y2,i + 1 });
				q.push({ x,y + 1,x2,y2,i + 1 });
				q.push({ x - 1,y,x2,y2,i + 1 });
				q.push({ x ,y - 1,x2,y2-1,i + 1 });
			}
			else if (y2 - y == 1) {
				q.push({ x + 1,y,x2,y2,i + 1 });
				q.push({ x,y + 1,x2,y2+1,i + 1 });
				q.push({ x - 1,y,x2,y2,i + 1 });
				q.push({ x ,y - 1,x2,y2,i + 1 });
			}
		}
		else {
			q.push({ x + 1,y,x2,y2,i + 1 });
			q.push({ x,y+1,x2,y2,i + 1 });
			q.push({ x -1,y,x2,y2,i + 1 });
			q.push({ x ,y-1,x2,y2,i + 1 });
		}
	}
	cout << -1;
}

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
const int maxn = 1e3+5;
char arr[maxn][maxn];
int n,m;
int sx,sy;          //人物起始位置
int bx,by;          //箱子起始位置
int ex,ey;
struct node{
    int x,y;        //当前点坐标
    int h,d;        //当前箱子坐标
    int step;
};
const int maxn_ = 55;
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};
int vis[maxn_][maxn_][maxn_][maxn_];            //1 表示已经走过了
int bfs(int sx,int sy)
{
    queue<node> q;
    node f;                 //f表示队首
    f.x=sx;
    f.y=sy;
    f.h=bx;
    f.d=by;
    f.step=0;
    vis[sx][sy][bx][by]=1;  //一开始的状态标记为1
    q.push(f);              //将初始状态入队
    int t=1e6+5;
    while(!q.empty())       //当队不空时
    {
        t--;
        if(t==0)
        {
            return -1;
        }
        f=q.front();        //f接收队首
        //cout<<f.x<<" "<<f.y<<endl;
        if(f.h==ex && f.d==ey)      //如果队首坐标为E点坐标，则返回答案
        {
            return f.step;
        }
        q.pop();            //出队操作
        int nstep=f.step+1;     //下一步的步数为0
        int nbx=f.h;            //表示盒子的横坐标下一步的盒子假设还没移动
        int nby=f.d;           
        for(int i=0;i<4;++i)
        {
            int nx=f.x+dir[i][0];       //四个方向的某一个方向坐标
            int ny=f.y+dir[i][1];
            if(nx<0 || nx>=n || ny<0 || ny>=m || arr[nx][ny]=='#')  //坐标不合法
            {
                continue;               //如果出界或者遇到墙，则坐标不合法
            }
            if(f.h==ex && f.d==ey)
            {
                node temp ;
                temp.x=nx;
                temp.y=ny;
                temp.step=f.step+1;
                q.push(temp);
            }
            /*
            if(vis[nx][ny][f.h][f.d])   //状态已经存在了
            {
                continue;
            }
            */
            //if(arr[nx][ny]=='0')
            if(nx==f.h && ny==f.d)     
            {
                int ox,oy;
                ox=nx+dir[i][0];   
                oy=ny+dir[i][1];
                if(ox<0 || ox>=n || oy<0 || oy>=m || arr[ox][oy]=='#' || arr[ox][oy]=='X')  //坐标不合法
                {
                    continue;
                }
                node temp;
                temp.x=nx;
                temp.y=ny;
                temp.h=ox;
                temp.d=oy;
                temp.step=nstep;
                if(!vis[temp.x][temp.y][temp.h][temp.d])
                {
                    q.push(temp);
                }
                vis[temp.x][temp.y][temp.h][temp.d]=1;
            }
            else if(arr[nx][ny]=='.' || arr[nx][ny]=='X' || arr[nx][ny]=='E')   //如过遇到的是.和X
            {
                node temp;
                temp.x=nx;
                temp.y=ny;
                temp.h=nbx;
                temp.d=nby;
                temp.step=nstep;
                if(!vis[nx][ny][nbx][nby])          //如果状态没遇到过，则入队
                {
                    q.push(temp);
                }
                vis[temp.x][temp.y][temp.h][temp.d]=1; //这个状态标记为1
            }

        }
    }
    return -1;
}
void judge(int i,int j)
{
    int flag1=0,flag2=0,flag3=0,flag4=0;
    if(i-1<0)
    {
        flag1=1;
    }else if(arr[i-1][j]=='#')
    {
        flag1=1;
    }
    if(j-1<0)
    {
        flag2=1;
    }else if(arr[i][j-1]=='#')
    {
        flag2=1;
    }
    if(i+1==n)
    {
        flag3=1;
    }else if(arr[i+1][j]=='#')
    {
        flag3=1;
    }
    if(j+1==m)
    {
        flag4=1;
    }else if(arr[i][j+1]=='#')
    {
        flag4=1;
    }
    if((flag1 && flag2) || (flag2 && flag3) || (flag3 && flag4) || (flag4 && flag1))
    {
        arr[i][j]='X';
    }
}
int main()
{
    memset(vis,0,sizeof(vis));
    while(cin>>n>>m)
    {
        for(int i=0;i<n;++i)
        {
            scanf("%s",arr+i);
        }
        for(int i=0;i<n;++i)
        {
            for(int j=0;j<m;++j)
            {
                if(arr[i][j]=='S')
                {
                    sx=i;
                    sy=j;  
                }
                if(arr[i][j]=='0')
                {
                    bx=i;
                    by=j;
                    arr[i][j]='.'; 
                }
                if(arr[i][j]=='E')
                {
                    ex=i;
                    ey=j;  
                }      
            }
        }
        for(int i=0;i<n;++i)
        {
            for(int j=0;j<m;++j)
            {
                if(arr[i][j]=='#' || arr[i][j]=='E') continue;
                judge(i,j);
            }
        }
        //test map
        /*
        cout<<endl;
        for(int i=0;i<n;++i)
        {
            cout<<arr[i]<<endl;
        }
        */
        cout<<bfs(sx,sy)<<endl;
    }
    return 0;
}

import java.util.Scanner;
import java.util.ArrayDeque;

public class Main {
    public static void main( String[] args ) {
        Scanner sc = new Scanner( System.in );
        while( sc.hasNext() ) {
            int m = sc.nextInt();
            int n = sc.nextInt();
            char[][] map = new char[m][n];
            for ( int i = 0; i < m; i++ )
                map[i] = sc.next().toCharArray();
            Sokoban game = new Sokoban( map );
            System.out.println( game.play() );
        }
    }
}
class Sokoban {
    private char[][] map;
    private boolean[][][][] flag;
    private int tm,tn;
    private int m, n;
    private Layout cur;
    private class Layout {
        int pm,pn,bm,bn;
        Layout( int p1, int p2, int p3, int p4 ) {
            pm = p1; pn = p2; bm = p3; bn = p4;
            flag[p1][p2][p3][p4] = true;
        }
        Layout moveUp() {
            if( pm - 1 == bm && pn == bn ) {
                if( bm >= 1 && map[bm-1][bn] != '#' &&
                    flag[pm-1][pn][bm-1][bn] == false ) {
                    return new Layout( pm-1, pn, bm-1, bn );
                }
            }
            else {
                if( pm >= 1 && map[pm-1][pn] != '#' &&
                    flag[pm-1][pn][bm][bn] == false ) {
                    return new Layout( pm-1, pn, bm, bn );
                }
            }
            return null;
        }
        Layout moveDown() {
            if( pm + 1 == bm && pn == bn ) {
                if( bm+1 < m && map[bm+1][bn] != '#' &&
                    flag[pm+1][pn][bm+1][bn] == false ) {
                    return new Layout( pm+1, pn, bm+1, bn );
                }
            }
            else {
                if ( pm+1 < m && map[pm+1][pn] != '#' &&
                    flag[pm+1][pn][bm][bn] == false ) {
                    return new Layout( pm+1, pn, bm, bn );
                }
            }
            return null;
        }
        Layout moveLeft() {
            if( pm == bm && pn - 1 == bn ) {
                if( bn >= 1 && map[bm][bn-1] != '#' &&
                    flag[pm][pn-1][bm][bn-1] == false ) {
                    return new Layout( pm, pn-1, bm, bn-1 );
                }
            }
            else {
                if ( pn >= 1 && map[pm][pn-1] != '#' &&
                    flag[pm][pn-1][bm][bn] == false ) {
                    return new Layout( pm, pn-1, bm, bn );
                }
            }
            return null;
        }
        Layout moveRight() {
            if( pm == bm && pn + 1 == bn ) {
                if( bn+1 < n && map[bm][bn+1] != '#' &&
                    flag[pm][pn+1][bm][bn+1] == false ) {
                    return new Layout( pm, pn+1, bm, bn+1 );
                }
            }
            else {
                if( pn+1 < n && map[pm][pn+1] != '#' &&
                    flag[pm][pn+1][bm][bn] == false ) {
                    return new Layout( pm, pn+1, bm, bn );
                }
            }
            return null;
        }
    }
    public Sokoban( char[][] map ) {
        this.map = map;
        m = map.length;
        n = map[0].length;
        flag = new boolean[m][n][m][n];
        int p1 = 0, p2 = 0, p3 = 0, p4 = 0;
        for( int i = 0; i < m; i ++ ) {
            for( int j = 0; j < n; j ++ ) {
                if( map[i][j] == 'S' ) {
                    p1 = i; p2 = j;
                }
                else if( map[i][j] == '0' ) {
                    p3 = i; p4 = j;
                }
                else if( map[i][j] == 'E' ) {
                    tm = i; tn = j;
                }
            }
        }
        cur = new Layout( p1, p2, p3, p4 );
    }
    public int play() {
        ArrayDeque<Layout> stack = new ArrayDeque<>();
        stack.offer( cur );
        Layout tmp;
        for( int i = 0; !stack.isEmpty(); i ++ ) {
            int len = stack.size();
            for( int j = 0; j < len; j ++ ) {
                cur = stack.poll();
                if( cur.bm == tm && cur.bn == tn ) return i;
                if( ( tmp = cur.moveUp() ) != null ) stack.offer( tmp );
                if( ( tmp = cur.moveDown() ) != null ) stack.offer( tmp );
                if( ( tmp = cur.moveLeft() ) != null ) stack.offer( tmp );
                if( ( tmp = cur.moveRight() ) != null ) stack.offer( tmp );
            }
        }
        return -1;
    }
}

/**
 * 推箱子游戏。
 * 思路：直接用BFS从玩家起点开始遍历。注意的是利用buf四维数组存储到当前位置所需的步数。由于利用的是BFS，所以第一次赋给buf的数值一定是最小的步数。
 * <br>
 * <a href=https://interview.nowcoder.com/question/next?pid=8537140&qid=141017&tid=19866373>具体描述</a>
 * @author LBW
 */
import java.util.*;


public class Main {
    char[][] space = new char[51][51];   //棋盘二维数组
    int[][][][] buf = new int[51][51][51][51];   //buf四维数组，既可以用来存储走过的路径以防重复，又可以直接得到当前局面所需的最小步数。
    int n, m;
    int px, py, bx, by;  // px,py: 玩家位置  bx,by:箱子位置
    int targetX, targetY;  //目标位置
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Main sokoban = new Main();
        sokoban.n = scanner.nextInt();
        sokoban.m = scanner.nextInt();
        for (int i1 = 0; i1 < 51; i1++) {
            for (int i2 = 0; i2 < 51; i2++) {
                for (int i3 = 0; i3 < 51; i3++) {
                    for (int i4 = 0; i4 < 51; i4++) {
                        sokoban.buf[i1][i2][i3][i4] = -1;
                    }
                }
            }
        }
        //Find px,py,bx,by,targetX, targetY
        for (int i = 0; i < sokoban.n; i++) {
            String line = scanner.next();
            for (int j = 0; j < sokoban.m; j++) {
                sokoban.space[i][j] = line.charAt(j);
                if (sokoban.space[i][j] == 'S') {
                    sokoban.px = i;
                    sokoban.py = j;
                }
                else if (sokoban.space[i][j] == '0') {
                    sokoban.bx = i;
                    sokoban.by = j;
                }
                else if (sokoban.space[i][j] == 'E') {
                    sokoban.targetX = i;
                    sokoban.targetY = j;
                }
            }
        }
        int result = sokoban.getResult();
        System.out.println(result);
    }
    // start
    private int getResult() {
        if (bx == targetX && by == targetY) {
            return 0;
        }
        // Use BFS to solve the problem.
        LinkedList<PlayerBox> queue = new LinkedList<>();
        queue.add(new PlayerBox(px, py, bx, by, 0));
        buf[px][py][bx][by] = 0;

        while (!queue.isEmpty()) {
            PlayerBox cur = queue.poll();
            //search four directions from current position.
            PlayerBox next = cur.moveUp();
            if (next != null && notInPaths(next)) {
                if (next.bx == targetX && next.by == targetY) {
                    return next.num;
                }
                queue.add(next);
                buf[next.px][next.py][next.bx][next.by] = next.num;
            }
            next = cur.moveDown();
            if (next != null && notInPaths(next)) {
                if (next.bx == targetX && next.by == targetY) {
                    return next.num;
                }
                queue.add(next);
                buf[next.px][next.py][next.bx][next.by] = next.num;
            }
            next = cur.moveLeft();
            if (next != null && notInPaths(next)) {
                if (next.bx == targetX && next.by == targetY) {
                    return next.num;
                }
                queue.add(next);
                buf[next.px][next.py][next.bx][next.by] = next.num;
            }
            next = cur.moveRight();
            if (next != null && notInPaths(next)) {
                if (next.bx == targetX && next.by == targetY) {
                    return next.num;
                }
                queue.add(next);
                buf[next.px][next.py][next.bx][next.by] = next.num;
            }
        }
        return -1;
    }
    // whether the position has been visited
    private boolean notInPaths(PlayerBox playerBox) {
        if (buf[playerBox.px][playerBox.py][playerBox.bx][playerBox.by] == -1)
            return true;
        else
            return false;
    }
    class PlayerBox {
        int px, py, bx, by;
        int num;
        public PlayerBox(int px, int py, int bx, int by, int num) {
            this.px = px;
            this.py = py;
            this.bx = bx;
            this.by = by;
            this.num = num;
        }
        public PlayerBox moveUp() {
            if (bx == px - 1 && by == py) {
                if (bx - 1 >= 0 && space[bx-1][by] != '#') {
                    return new PlayerBox(px-1, py, bx-1, by, num+1);
                }
            }
            else {
                if (px - 1 >= 0 && space[px-1][py] != '#') {
                    return new PlayerBox(px-1, py, bx, by, num+1);
                }
            }
            return null;
        }
        public PlayerBox moveDown() {
            if (bx == px + 1 && by == py) {
                if (bx + 1 < n && space[bx+1][by] != '#') {
                    return new PlayerBox(px+1, py, bx+1, by, num+1);
                }
            }
            else {
                if (px + 1 < n && space[px+1][py] != '#') {
                    return new PlayerBox(px+1, py, bx, by, num+1);
                }
            }
            return null;
        }
        public PlayerBox moveLeft() {
            if (bx == px && by == py - 1) {
                if (by - 1 >= 0 && space[bx][by-1] != '#') {
                    return new PlayerBox(px, py-1, bx, by-1, num+1);
                }
            }
            else {
                if (py - 1 >= 0 && space[px][py-1] != '#') {
                    return new PlayerBox(px, py-1, bx, by, num+1);
                }
            }
            return null;
        }
        public PlayerBox moveRight() {
            if (bx == px && by == py + 1) {
                if (by + 1 < m && space[bx][by+1] != '#') {
                    return new PlayerBox(px, py+1, bx, by+1, num+1);
                }
            }
            else {
                if (py + 1 < m && space[px][py+1] != '#') {
                    return new PlayerBox(px, py+1, bx, by, num+1);
                }
            }
            return null;
        }
    }
}