迷宫问题

#include <bits/stdc++.h>
using namespace std;

bool dfs(int dx, int dy, int n, int m, vector<vector<int>>& maze, vector<pair<int, int>>& ans) {
    /* 遇到墙或者出界 */
    if (dx < 0 || dy < 0 || dx == n && dy < m || dy == m && dx < n || maze[dx][dy] == 1)
        return false;
    /* 到达出口 */
    if (dx == n - 1 && dy == m - 1)
        return true;
    /* 标记当前位置 */
    maze[dx][dy] = 1;
    /* 向南走 */
    ans.push_back(make_pair(dx + 1, dy));
    if (dfs(dx + 1, dy, n, m, maze, ans))
        return true;
    ans.pop_back();
    /* 向东走 */
    ans.push_back(make_pair(dx, dy + 1));
    if (dfs(dx, dy + 1, n, m, maze, ans))
        return true;
    ans.pop_back();
    /* 向西走 */
    ans.push_back(make_pair(dx - 1, dy));
    if (dfs(dx - 1, dy, n, m, maze, ans))
        return true;
    ans.pop_back();
    /* 向北走 */
    ans.push_back(make_pair(dx, dy - 1));
    if (dfs(dx, dy - 1, n, m, maze, ans))
        return true;
    ans.pop_back();
    /* 都走不通则失败 */
    maze[dx][dy] = 0;
    return false;
}

int main() {
    int n, m;
    cin >> n >> m;
    vector<vector<int>> maze(n, vector<int>(m));
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> maze[i][j];
    vector<pair<int, int>> ans;
    /* 从起点(0，0)开始 */
    dfs(0, 0, n, m, maze, ans);
    cout << "(0,0)" << endl;
    for (int i = 0; i < ans.size(); i++)
        cout << "(" << ans[i].first << "," << ans[i].second << ")" << endl;
    return 0;
}

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
var flag=true,m,n,arr=[],res
function findWay(i,j,direction,path){
    if(i==m-1 && j==n-1){
        for(let i in path){
            console.log('('+path[i][0]+','+path[i][1]+')')
        }
    }
    if(i+1<m && arr[i+1][j]==0 && direction[1]!=0){
        findWay(i+1,j,[0,1,1,1],path.concat([[i+1,j]]))
    }
    if(i-1>=0 && arr[i-1][j]==0 && direction[0]!=0){
        findWay(i-1,j,[1,0,1,1],path.concat([[i-1,j]]))
    }
    if(j+1<n && arr[i][j+1]==0 && direction[3]!=0){
        findWay(i,j+1,[1,1,0,1],path.concat([[i,j+1]]))
    }
    if(j-1>=0 && arr[i][j-1]==0 && direction[2]!=0){
        findWay(i,j-1,[1,1,1,0],path.concat([[i,j-1]]))
    }
}
rl.on('line', function (line) {
    const tokens = line.split(' ');
    if (tokens[tokens.length-1]=='') tokens.pop()
    if(flag){
        m=parseInt(tokens[0]),n=parseInt(tokens[1])
        flag=false
    }
    else{
        arr.push(tokens.map((value,index,arr)=>{
            return parseInt(value)
        }))
        if(arr.length==m){
            //console.log(arr)
            findWay(0,0,[0,1,0,1],[[0,0]])
            arr=[]
            flag=true
        }
    }
});

//回溯
import java.util.*;

public class Main{
    private static List<int[]> ans = new ArrayList<>();
    private static List<int[]> path = new ArrayList<>();
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            int m = sc.nextInt();
            int[][] maze = new int[n][m];
            for(int i=0; i<n; i++){
                for(int j=0; j<m; j++){
                    maze[i][j] = sc.nextInt();
                }
            }
            //深度优先搜索
            dfs(maze, 0, 0);
            for(int[] arr : ans){
                System.out.println("("+arr[0]+","+arr[1]+")");
            }
            //清空路径path，结果集ans，实际ans指向新建对象，无需清空
            path.clear();ans.clear();
        }
    }
    
    private static void dfs(int[][] maze, int i, int j){
        //结束条件，一定要用路径新建集合，path最后会remove为空
        if(i==maze.length-1 && j==maze[0].length-1){
            path.add(new int[]{i, j});
            ans = new ArrayList<>(path);
            return;
        }
        //边界条件，剪枝
        if(i<0 || i>=maze.length || j<0 || j>=maze[0].length || maze[i][j]==1) return;
        
        //i,j加入集合,并且当前位置设置为障碍
        path.add(new int[]{i, j});
        maze[i][j]=1;
        //向四个方向递归
        dfs(maze, i+1, j);
        dfs(maze, i, j+1);
        dfs(maze, i-1, j);
        dfs(maze, i, j-1);
        //找到死胡同，回溯，撤销i,j选择，当前位置设置为可走
        path.remove(path.size()-1);
        maze[i][j]=0;
    }
}

import java.io.*;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
/**
bfs搜索，然后打印路径即可--- 不想递归打印的，可以从从右下往左上搜索
/*
public class Main{

    static int n, N = 12, m;
    static int[][] g = new int[N][N];
    static boolean[][] st = new boolean[N][N];
    static int[][] dis = new int[][]{ {1, 0}, {-1, 0}, {0, -1}, {0, 1} };
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        while(in.hasNext()){
            n = in.nextInt(); m = in.nextInt();
            for(int i = 0; i < n; i ++)
                for(int j = 0; j < m; j ++){
                    g[i][j] = in.nextInt();
                }

            for(int i = 0; i < n; i ++)
                Arrays.fill(st[i], false);
            bfs();
        }


    }

    static void bfs(){
        st[0][0] = true;
        Queue<Node> queue = new LinkedList<>();
        Node start = new Node(0, 0);
        queue.add(start);

        while(!queue.isEmpty()){
            Node t = queue.poll();
            int a = t.x, b = t.y;
            for(int[] d : dis){
                int x = a + d[0], y = d[1] + b;
                if(x < 0 || x >= n || y < 0 || y >= m || g[x][y] == 1 || st[x][y]) continue;
                st[x][y] = true;
                Node tmp = new Node(x, y);
                tmp.next = t;
                if(x == n - 1 && y == m - 1){
                    //找到
                    print(tmp);
                    return;
                }
                queue.add(tmp);
            }

        }
    }

    static void print(Node root){
        if(root == null) return;
        print(root.next);
        System.out.println("(" + root.x + ","  + root.y + ")");
    }

    static class Node{
        int x, y;
        Node next;
        public Node(int x, int y){
            this.x = x;
            this.y = y;
        }
    }
}

import sys

def print_result(path):
    for item in path:
        print('({},{})'.format(item[0], item[1]))

def min_path(maze, visited, path, m, n, i, j):
    if i >= m&nbs***bsp;j >= n&nbs***bsp;i < 0&nbs***bsp;j < 0:
        return
    if visited[i][j]:
        return 
    if maze[i][j] == 1:
        return
    if i == m-1 and j == n-1 and maze[i][j] == 0:
        path.append((i, j))
        print_result(path)
        return

    path.append((i, j))
    visited[i][j] = True
    min_path(maze, visited, path, m, n, i+1, j)
    min_path(maze, visited, path, m, n, i-1, j) 
    min_path(maze, visited, path, m, n, i, j+1)
    min_path(maze, visited, path, m, n, i, j-1)
    path.pop()
    visited[i][j] = False

def get_input():
    m, n = list(map(int, input().strip().split()))

    maze = []
    for i in range(m):
        row = list(map(int, input().strip().split()))
        maze.append(row)

    return maze, m, n

if __name__ == '__main__':
    try:
        while True:
            maze, m, n = get_input()
            row = [False for _ in range(n)]
            visited = [row.copy() for _ in range(m)]    
            path = []
            min_path(maze, visited, path, m, n, 0, 0)
    except Exception:
        pass

#include<iostream>
#include<stdio.h>
#include<string>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
int main()
{
    int row,col;
    while(cin>>row>>col) {
        vector<vector<int>> dst(row,vector<int>(col,-1)); //dst[i][j]记录是从哪个格子到达的(i,j)
        vector<vector<int>> arr(row,vector<int>(col,0));
        for(int i=0;i<row;++i) {
            for(int j=0;j<col;++j)
                cin>>arr[i][j];
        }
        queue<pair<int,int>> q;
        dst[0][0]=0;
        q.push(pair<int,int>(0,0));
        int dx[4]={0,0,-1,1};
        int dy[4]={-1,1,0,0};
        bool flag=false;
        while(!q.empty()) {
            auto [x,y]=q.front(); q.pop();
            for(int i=0;i<4;++i) {
                int newx=x+dx[i];
                int newy=y+dy[i];
                if(newx>=0 && newx<row && newy>=0 && newy<col && arr[newx][newy]==0 && dst[newx][newy]==-1) {
                    dst[newx][newy]=x*100+y;
                    if(newx==row-1 && newy==col-1) {
                        flag=true;
                        break;
                    }
                    q.push(pair<int,int>(newx,newy));
                }
            }
            if(flag)
                break;
        }
        int from=dst[row-1][col-1];
        vector<string> res;
        while(from!=0) {
            int x=from/100;
            int y=from%100;
            res.push_back("("+to_string(x)+","+to_string(y)+")");
            from=dst[x][y];
        }
        cout<<"(0,0)"<<endl;
        for(int i=res.size()-1;i>=0;i--) {
            cout<<res[i]<<endl;
        }
        cout<<"("<<(row-1)<<","<<(col-1)<<")"<<endl;
    }
    return 0;
}

鄙人认为本题出的一般，只有一条路径走得通为什么还要说求最短路径，而且只有一条路径走得通也让大家可以投机取巧，不用广度、深度优先搜索就能出结果（看已通过的代码）；

附上本人的广度优先搜索代码：

def bfs(maze,x1,y1,x2,y2):
    directions = [(1,0),(-1,0),(0,1),(0,-1)]
    queue = [(x1,y1,-1)]
    path = []
    while queue:
        path.append(queue.pop(0))
        cur = (path[-1][0],path[-1][1])
        if cur == (x2,y2):
            res = [(path[-1][0],path[-1][1])]
            loc = path[-1][2]
            while loc != -1:
                res.append((path[loc][0],path[loc][1]))
                loc = path[loc][2]
            return res

        for d in directions:
            next_node = (cur[0]+d[0],cur[1]+d[1])
            if 0 <= next_node[0] < len(maze) and \
               0 <= next_node[1] < len(maze[0]) and \
               maze[next_node[0]][next_node[1]] == 0:
                maze[next_node[0]][next_node[1]] == 2
                queue.append((next_node[0],next_node[1],len(path)-1))
while True:
    try:
        m,n = list(map(int, input().split()))
        maze = []
        for i in range(m):
            maze.append(list(map(int, input().split())))
        res = bfs(maze, 0, 0, m-1, n-1)[::-1]
        for i in res:
            print('(%d,%d)'%(i[0],i[1]))
    except:
        break

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Arrays;
import java.util.Comparator;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
 
public class Main {
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNext()) {
            int row = in.nextInt();
            int col = in.nextInt();
            int[][] maze = new int[row][col];
            for (int i=0; i<row; i++) 
                for (int j=0; j<col; j++)
                    maze[i][j] = in.nextInt();
            recursion(maze, 0, 0, -1);
            ArrayList<Point> list = new ArrayList();
            int x = row - 1, y = col - 1;
            int n = maze[x][y];
            // 从右下角根据步数，开始搜索最优路径（唯一），循环放入list
            while (true) {
                // 因为从后面开始循环，所以每次放入第一位
                list.add(0,new Point(x, y));
                // 步数时负数，所以++
                n ++;
                // 为0，则表示到达左上角
                if (n == 0)
                    break;
                // 目的： 找出与n相同的步数
                if (x - 1 >= 0 && maze[x - 1][y] == n){
                    x -= 1;
                    continue;
                }
                if (x + 1 < row && maze[x + 1][y] == n){
                    x += 1;
                    continue;
                }
                if (y - 1 >= 0 && maze[x][y - 1] == n){
                    y -= 1;
                    continue;
                }
                if (y + 1 < col && maze[x][y + 1] == n){
                    y += 1;
                    continue;
                }
            }
            for (Point p : list)
                System.out.println("(" + p.r + "," + p.c + ")");
        }
    }
    
    // 深度优先搜索 （递归）
    // 思路 : 0 位可以走， 1 为墙， 递归时，传入走的步数 （这里从-1 开始递减）
    public static void recursion(int[][] maze, int r, int y, int i) {
        // 如果为墙， 或者当前位已经走过，且走的步数（负数） <= 当前位的步数 ，直接返回
        if (maze[r][y] == 1 || (maze[r][y] < 0 && maze[r][y] >= i)) 
            return;
        // 这里可以直接更新步数
        maze[r][y] = i;
        // 判断是否到达右下角
        if (r == maze.length - 1 && y == maze[0].length - 1)
            return;
        // 往上走
        if (r - 1 >= 0)
            recursion(maze, r - 1, y, i - 1);
        // 往下走
        if (r + 1 < maze.length)
            recursion(maze, r + 1, y, i - 1);
        // 往左走
        if (y - 1 >= 0)
            recursion(maze, r, y - 1, i - 1);
        // 往右走
        if (y + 1 < maze[0].length)
            recursion(maze, r, y + 1, i - 1);
    }
    
}
// 定义一个用来保存坐标的类
class Point {
    int r;
    int c;
    Point(int r, int c) {
        this.r = r;
        this.c = c;
    }
}

import java.util.*;

// HJ43
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt();
            int m = in.nextInt();

            int[][] map = new int[n][m];

            for (int i = 0; i < n * m; i++) {
                int num = in.nextInt();
                map[i / m][i % m] = num;
            }
            Point start = new Point(0, 0, m), end = new Point(m - 1, n - 1, m);
            LinkedList<Point> result = compute(n, m, map, start, end);
            if (Objects.isNull(result)) {
                System.out.println("ERROR");
                continue;
            }
            result.forEach(System.out::println);

        }
    }


    private static LinkedList<Point> compute(int rowNum, int colNum, int[][] map, Point start, Point end) {
        // 构造邻接矩阵
        int pointNum = rowNum * colNum;
        int[][] lin = new int[pointNum][pointNum];
        Map<Integer, Point> repo = new HashMap<>(pointNum);
        repo.put(start.toIndex(), start);
        repo.put(end.toIndex(), end);
        for (int i = 0; i < pointNum; i++) {
            int x = i % colNum;
            int y = i / colNum;
            int pointType = map[y][x];

            repo.putIfAbsent(i, new Point(x, y, colNum));

            for (int j = 0; j < 9; j++) {

                int tx = x - 1 + (j % 3);
                int ty = y - 1 + (j / 3);
                if (tx < 0 || ty < 0 || tx >= colNum || ty >= rowNum) {
                    continue;
                }
                int targetIndex = toIndex(tx, ty, colNum);
                if (i == targetIndex || lin[i][targetIndex] > 0) {
                    continue;
                }
                if (j == 0 || j == 2 || j == 4 || j == 6 || j == 8) {
                    continue;
                }
                switch (pointType) {
                    case 1:
                        lin[i][targetIndex] = 1;
                        lin[targetIndex][i] = 1;
                        break;
                    case 0:
                        if (map[ty][tx] == 1) {
                            lin[i][targetIndex] = 1;
                            lin[targetIndex][i] = 1;
                        } else {
                            lin[i][targetIndex] = 2;
                            lin[targetIndex][i] = 2;
                        }
                        break;
                }
            }
        }

        // 查询数量

        return computeAvailable(lin, repo, start, end, rowNum, colNum);


    }

    private static LinkedList<Point> computeAvailable(int[][] lin, Map<Integer, Point> repo, Point p1, Point p2, int rowNum, int colNum) {
        p1.passed = true;
        if (lin[p1.toIndex()][p2.toIndex()] == 2) {
            p1.passed = false;
            return new LinkedList<>(Arrays.asList(p1, p2));
        }

        boolean available = false;
        LinkedList<Point> minSubList = new LinkedList<>();
        for (int i = 0; i < 9; i++) {

            int tx = p1.x - 1 + (i % 3);
            int ty = p1.y - 1 + (i / 3);
            if (tx < 0 || ty < 0 || tx >= colNum || ty >= rowNum) {
                continue;
            }
            int targetIndex = toIndex(tx, ty, colNum);
            Point targetPoint = repo.get(targetIndex);
            if (!targetPoint.passed && lin[p1.toIndex()][targetPoint.toIndex()] == 2) {
                LinkedList<Point> subList = computeAvailable(lin, repo, targetPoint, p2, rowNum, colNum);
                if (Objects.nonNull(subList) && subList.size() < (minSubList.isEmpty() ? repo.size() : minSubList.size())) {
                    minSubList = subList;
                    available = true;
                }
            }
        }
        p1.passed = false;
        if (available) {
            minSubList.addFirst(p1);
            return minSubList;
        }
        return null;
    }

    private static int toIndex(int x, int y, int colNum) {
        return y * colNum + x;
    }

    private static class Point {
        final int x;
        final int y;
        final int colNum;
        boolean passed = false;

        public Point(int x, int y, int colNum) {
            this.x = x;
            this.y = y;
            this.colNum = colNum;
        }


        public int toIndex() {
            return y * colNum + x;
        }

        @Override
        public String toString() {
            return "(" + y +
                    "," + x +
                    ')'
                    ;
        }
    }
}

def trace(start, end, maps):
    # 获取坐标
    m, n = len(maps), len(maps[0])
    x, y = start[0], start[1]
    # 判断能否走
    if x < 0&nbs***bsp;y < 0&nbs***bsp;x > m - 1&nbs***bsp;y > n - 1: return
    if maps[x][y] == 1: return
    # 走过的路改为 1，添加到路径
    maps[x][y] = 1
    stack.append(start)
    # 判断是否到达终点
    if start == end:
        if best_path == []&nbs***bsp;len(stack) < len(best_path):
            best_path.clear()
            for p in stack:
                best_path.append(p)
    # 这里防止到达终点后继续走下一步，不加也行，只是迭代步数更多
            stack.pop()
            maps[x][y] = 0
            return
    # 向四个方向走
    trace([x - 1, y], end, maps)
    trace([x + 1, y], end, maps)
    trace([x, y - 1], end, maps)
    trace([x, y + 1], end, maps)
    # 还原，删除路径
    stack.pop()
    maps[x][y] = 0


while True:
    try:
        MAP = []
        stack = []
        best_path = []
        M, N = map(int, input().split())
        for point in range(M):
            MAP.append(list(map(int, input().split())))
        trace([0, 0], [M - 1, N - 1], MAP)
        for point in best_path:
            print('(%d,%d)' % (point[0], point[1]))
    except:
        break

import java.util.*;
public class Main{
    //存储所有的路径和路径长度
    static Map<LinkedList<String>, Integer> res = new HashMap<>();
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int m = sc.nextInt();
            int n = sc.nextInt();
            int[][] arr = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    arr[i][j] = sc.nextInt();
                }
            }
            res.clear();
            LinkedList<String> trace = new LinkedList<>();
            int x = 0;
            int y = 0;
            dfs(arr, 0, 0, 1, trace);
            int min = Integer.MAX_VALUE;
            LinkedList<String> minTrace = new LinkedList<>();
            for(Map.Entry<LinkedList<String>, Integer> t : res.entrySet()){
                if(t.getValue() < min){
                    min = t.getValue();
                    minTrace = t.getKey();
                }
            }
            for(int i=0; i<minTrace.size(); i++){
                System.out.println(minTrace.get(i));
            }

        }
    }
    public static void dfs(int[][] arr, int x, int y, int cnt, LinkedList<String> trace){
        int m = arr.length;
        int n = arr[0].length;
        if(x == m-1 && y == n-1){
            trace.add("(" + x + "," + y +")");
            res.put(new LinkedList<>(trace), cnt);
            return;
        }
        if(x >= m || y >= n || arr[x][y] == 1 ){
            return;
        }
        //添加当前节点为trace
        trace.add("(" + x + "," + y +")");
        dfs(arr, x+1, y,cnt+1, trace);
        dfs(arr, x, y+1, cnt+1, trace);
        trace.removeLast();
    }
}

深度优先遍历搜索。
从（0,0）开始整个矩阵矩阵，只能向上向下，向左向右走，且前方没有障碍物并且没有走过。遍历过程需要记录下来当前点是从哪个点（如果为点（i，j）存储对于id: i*m+j）走过来的。当遍历到（n,m）时，可以得到一条最短路径。然后从（n,m）倒序恢复整条路径。

import java.util.*;
public class Main {
    static int[] dx, dy;
    static int[][] bfs(int[][] grid, int n, int m) {
        //id : x*m + y
        int[][] ans = new int[n][m];
        Queue<Integer> q = new LinkedList<>();
        q.offer(0);
        while(!q.isEmpty()) {
                int cur = q.poll();
                int x = cur / m, y = cur % m;
                //System.out.println(x+","+y);
                for(int j=0; j < 4; j++) {
                    int xx = dx[j] + x, yy = dy[j] + y;
                    if(xx>= 0 && xx<n && yy >=0 && yy < m && grid[xx][yy] == 0) {
                        grid[xx][yy] = 2;
                        q.offer(xx*m+yy);
                        ans[xx][yy] = cur;
                    }
                }
        }
        //System.out.println(Arrays.deepToString(ans));
        return ans;
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        dx = new int[] {0, 1, 0, -1};
        dy = new int[] {1, 0, -1, 0};
        while(sc.hasNext()){
            int n =sc.nextInt(), m = sc.nextInt();
            int[][] grid = new int[n][m];
            for(int i=0; i < n; i++)
                for(int j=0; j < m; j++)
                    grid[i][j] = sc.nextInt();
            int[][] path = bfs(grid, n, m);
            List<int[]> res = new ArrayList<>();
            res.add(new int[] {n-1, m-1});
            int x = n-1, y = m-1;
            while(!(x == 0 && y == 0)) {
                int t = path[x][y];
                x = t / m; y = t % m;
                res.add(new int[] {x, y});
            }
            for(int i=res.size()-1; i >= 0; i--) {
                System.out.println("(" + res.get(i)[0] +"," + res.get(i)[1]+")");
            }
        }
    }
}

import java.util.Scanner;
import java.util.ArrayList;

public class Main{
    public static ArrayList<String>list=new ArrayList<>();
    public static ArrayList<String>best=new ArrayList<>();

    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            list.clear();
            best.clear();
            int h=sc.nextInt();
            int l=sc.nextInt();
            int arr[][]=new int[h][l];
            for(int i=0;i<h;i++){
                for(int j=0;j<l;j++){
                    arr[i][j]=sc.nextInt();
                }
            }
            MazeTrack(arr,0,0);
           // System.out.println(best.toString());
            for(int i=0;i<best.size();i++){
                System.out.println(best.get(i));
            }

        }
    }

    public static void MazeTrack(int[][]arr, int x, int y){
        list.add("("+x+","+y+")");
        //System.out.println(list.toString());
        arr[x][y]=1;
        int h=arr.length;
        //System.out.println(h);
        int l=arr[0].length;
       // System.out.println(l);
        if(x==h-1&&y==l-1){
            if(best.size()==0||list.size()<best.size()) {
                best.clear();
                for(int i=0;i<list.size();i++)
                best.add(list.get(i));
            }
            //System.out.println(best);
        }
        if(x-1>=0&&arr[x-1][y]==0){
            MazeTrack(arr,x-1,y);
        }
        if(y-1>=0&&arr[x][y-1]==0){
            MazeTrack(arr,x,y-1);
        }
        if(x+1<h&&arr[x+1][y]==0){
            MazeTrack(arr,x+1,y);
        }
        if(y+1<l&&arr[x][y+1]==0){
            MazeTrack(arr,x,y+1);
        }
        arr[x][y]=0;
        list.remove("("+x+","+y+")");
        //System.out.println(best);

    }
}