试图理解为什么使用 BFS 搜索网格的空间复杂度是 O(m * n)，其中 m 不是。 行数，n 为否。 列数

Question

I am trying to understand the space complexity of using BFS in a grid. When we start on a cell in a grid of m * n dimensions, we could go either up, right, down and left.

My understanding is the Space Complexity should be O(m + n) if we start somewhere in the middle. If we start in one of the 4 corners it should be O(min(m, n)). So overall it could be O(m + n) in the worst case given we don't know where to start.

I tried to test on my local by starting on all of the cells individually in a grid and calculate the max size of the queue and understand the Space Complexity.

My test code:

class Solution {

    int max = 0;

    public static void main(String[] args) {
        Solution solution = new Solution();

        int rows = 200, cols = 200;
        int[][] grid = new int[rows][cols];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                solution.initializeGrid(grid, rows, cols);
                solution.processGrid(grid, rows, cols, i, j);
            }
        }

        System.out.println("Highest queue size is " + solution.max);
    }

    private void initializeGrid(int[][] grid, int rows, int cols) {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                grid[i][j] = 1;
            }
        }
    }

    private void processGrid(int[][] grid, int rows, int cols, int row, int col) {
        Queue<int[]> queue = new LinkedList<>();
        int[] childrenRows = new int[]{-1, 0, 1, 0};
        int[] childrenCols = new int[]{0, 1, 0, -1};

        queue.add(new int[]{row, col});
        grid[row][col] = 0;

        while (!queue.isEmpty()) {
            max = Math.max(max, queue.size());

            int[] parent = queue.poll();
            int pr = parent[0], pc = parent[1];

            for (int i = 0; i < 4; i++) {
                int cr = pr + childrenRows[i], cc = pc + childrenCols[i];

                if (cr >= 0 && cr < rows && cc >= 0 && cc < cols && grid[cr][cc] == 1) {
                    queue.add(new int[]{cr, cc});
                    grid[cr][cc] = 0;
                }
            }
        }
    }
}

The output for the given input of m = 200, n = 200 is

The highest queue size is 399. This value proportional to O(m + n)

I know this is not the right way to calculate Space Complexity but I want to the know exact space used by the queue and if it's proportional to O(m * n) or not.

I tried with other larger inputs. Still, the Space Complexity is O(m + n).

Am I missing something here? Could someone please help me to understand the logic?

Answer 1

You are focusing on the max queue size, but you hit the O(m * n) space right at the beginning of your algorithm:

boolean[][] visited = new boolean[rows][cols]

You've just allocated O(m * n) space!

In generic BFS, you have to keep track of all visited states, so the space bound cannot be lower than the total number of states.

---

That being said O(m * n) is only valid when the grid can be complex. If it's just a full grid of size mxn, you can optimize the algorithm to make it O(m + n) space -- you don't need to keep the whole history of visited cells in memory.