为什么我必须在这个迷宫中使用 do-while 循环？

Question

I found this question [here]: https://leetcode.com/problems/the-maze/ If you can't open the question, Here is the image of the problem:

Here is my code:

class Solution {
    public boolean hasPath(int[][] maze, int[] start, int[] destination) {
        ArrayDeque<int[]> queue = new ArrayDeque<>();
        int[][] directions = {{1,0},{-1,0},{0,1},{0,-1}};
        queue.offer(start);
        while(!queue.isEmpty()) {
            int [] loc = queue.poll();
            int x = loc[0];
            int y = loc[1];
            if(x == destination[0] && y == destination[1]) 
                return true;
            for(int[] dir : directions) {
                do{
                    x += dir[0];
                    y += dir[1];     
                }while(x >= 0 && y >= 0 && x < maze.length && y < maze[0].length && maze[x][y] == 0);     
                x -= dir[0];
                y -= dir[1];
                if(maze[x][y] != 2) {
                    queue.offer(new int[] {x,y});
                    maze[x][y] = 2;
                }
            }
        }
        return false;
    }
}

I referenced the solution while I was writing this code. Why do I need do-while in the code? I tried to use only while loop and it got wrong answer.

Answer 1

As explained in the link posted by Ole VV while loop checked the condition prior to executing the block. do-while checks the condition after executing the block.
This means that changing from one form to another, requires changing the condition. However, before you attempt to compare two solutions, one implemented using while and another using do-while , make sure that you start with a valid solution.
The posted solution returns false if maze is changed to:

   int[][] maze = {
            {0, 0, 1, 0, 0},
            {0, 1, 0, 0, 0},
            {0, 0, 0, 1, 0},
            {1, 1, 0, 1, 1},
            {0, 0, 0, 0, 0},
    };

(using the same start and end points).
To my understanding it should return true.

This solution seems to do better (may need some more testing though):

public boolean hasPath(int[][] maze, int[] start, int[] destination) {
    ArrayDeque<int[]> queue = new ArrayDeque<>();
    int[][] directions = {{1,0},{-1,0},{0,1},{0,-1}};
    queue.offer(start);
    while(!queue.isEmpty()) {
        int [] loc = queue.poll();
        int x = loc[0];
        int y = loc[1];
        if(x == destination[0] && y == destination[1]){
             return true;
        }

        for(int[] dir : directions) {
            while(x+dir[0]>= 0 &&  y+dir[1] >= 0 && x+dir[0] < maze.length && y+dir[1] <
                    maze[0].length && maze[x+dir[0]][y+dir[1]] == 0){
                x += dir[0];
                y += dir[1];
                if(!queue.contains(new int[] {x,y})) {
                    queue.offer(new int[] {x,y});
                  maze[x][y] = 2;
                }
            }
        }
    }
    return false;
}

Answer 2

Why do I have to use do-while loop for this maze?

You don't have to. Ever.

As @brandonx states:

do ... while loops are typically used when you want to ensure that the loop always executes at least once.

(Emphasis added!)

And if this is what you want to happen, using a do ... while loop will often give you more readable code.

However, you don't have to do it this way. Any do ... while loop can be rewritten as a while loop and vice-versa . For example,

do { statement; } while (condition)

can be rewritten as:

boolean firstTime = true;
while (firstTime || condition) {
    firstTime = false;
    statement;
}

And we can transform in the other direction:

while (condition) { statement; }

can be rewritten as:

if (condition) {
    do { statement; } while (condition)
}

---

This doesn't directly answer your question about what was wrong with your code. But it you understand the relationship between while and do ... while , it will help you understand why it makes a difference which one you use.