Matrix Problems

// Declaration
int[][] grid = new int[m][n];   // m rows, n columns, all 0
char[][] board = new char[m][n]; // for island problems (often '0' or '1')

// Dimensions
int m = grid.length;          // number of ROWS
int n = grid[0].length;       // number of COLUMNS

// Access: O(1)
grid[r][c];                   // row r, column c

// Traversal (row-major order): O(m*n)
for (int r = 0; r < m; r++)
    for (int c = 0; c < n; c++)
        process(grid[r][c]);

// Reusable inBounds helper (write this at the top of every grid solution)
boolean inBounds(int r, int c) {
    return r >= 0 && r < m && c >= 0 && c < n;
}

// 4-direction expansion (use this template ALWAYS)
int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
for (int[] d : dirs) {
    int nr = r + d[0], nc = c + d[1];
    if (inBounds(nr, nc)) { /* process neighbour */ }
}

List<Integer> spiralOrder(int[][] matrix) {
    List<Integer> res = new ArrayList<>();
    int top = 0, bot = matrix.length - 1;
    int lft = 0, rgt = matrix[0].length - 1;

    while (top <= bot && lft <= rgt) {
        // → traverse top row left-to-right
        for (int c = lft; c <= rgt; c++) res.add(matrix[top][c]);
        top++;

        // ↓ traverse right column top-to-bottom
        for (int r = top; r <= bot; r++) res.add(matrix[r][rgt]);
        rgt--;

        // ← traverse bottom row right-to-left (guard: rows remain)
        if (top <= bot) {
            for (int c = rgt; c >= lft; c--) res.add(matrix[bot][c]);
            bot--;
        }

        // ↑ traverse left column bottom-to-top (guard: cols remain)
        if (lft <= rgt) {
            for (int r = bot; r >= top; r--) res.add(matrix[r][lft]);
            lft++;
        }
    }
    return res;
}
// Time: O(m*n) — every cell visited exactly once
// Space: O(1) extra (result array not counted)

void rotate(int[][] m) {
    int n = m.length;

    // Step 1: Transpose — swap across main diagonal (i,j) ↔ (j,i)
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++) {
            int tmp = m[i][j]; m[i][j] = m[j][i]; m[j][i] = tmp;
        }

    // Step 2: Reverse each row
    for (int i = 0; i < n; i++) {
        int lo = 0, hi = n - 1;
        while (lo < hi) {
            int tmp = m[i][lo]; m[i][lo] = m[i][hi]; m[i][hi] = tmp;
            lo++; hi--;
        }
    }
}
// Time: O(n²)  |  Space: O(1)
// Counter-clockwise 90° = Transpose + Reverse each COLUMN
// 180° = Reverse all rows + Reverse each row

void setZeroes(int[][] m) {
    int rows = m.length, cols = m[0].length;
    boolean row0 = false, col0 = false;

    // Pass 1: does row 0 / col 0 itself contain a zero?
    for (int c = 0; c < cols; c++) if (m[0][c] == 0) row0 = true;
    for (int r = 0; r < rows; r++) if (m[r][0] == 0) col0 = true;

    // Pass 2: mark row 0 and col 0 as sentinels for inner cells
    for (int r = 1; r < rows; r++)
        for (int c = 1; c < cols; c++)
            if (m[r][c] == 0) { m[r][0] = 0; m[0][c] = 0; }

    // Pass 3: use sentinels to zero out inner cells
    for (int r = 1; r < rows; r++)
        for (int c = 1; c < cols; c++)
            if (m[r][0] == 0 || m[0][c] == 0) m[r][c] = 0;

    // Pass 4: zero out row 0 and col 0 based on original flags
    if (row0) for (int c = 0; c < cols; c++) m[0][c] = 0;
    if (col0) for (int r = 0; r < rows; r++) m[r][0] = 0;
}
// Time: O(m*n)  |  Space: O(1)
// KEY: Why handle row0/col0 with separate flags?
// Because we reuse them as sentinel storage — if we zeroed them first,
// we'd corrupt our own sentinel data.

int m, n;

int numIslands(char[][] grid) {
    m = grid.length; n = grid[0].length;
    int count = 0;
    for (int r = 0; r < m; r++)
        for (int c = 0; c < n; c++)
            if (grid[r][c] == '1') { count++; dfs(grid, r, c); }
    return count;
}

void dfs(char[][] grid, int r, int c) {
    // Base cases — ALWAYS bounds check first
    if (r < 0 || r >= m || c < 0 || c >= n) return;
    if (grid[r][c] != '1') return;     // water or already visited

    grid[r][c] = '2';                   // mark visited in-place (sink it)

    dfs(grid, r-1, c); // up
    dfs(grid, r+1, c); // down
    dfs(grid, r, c-1); // left
    dfs(grid, r, c+1); // right
}
// Time: O(m*n)  |  Space: O(m*n) call stack worst case
// Interview follow-up: "What if the grid is huge and DFS stack overflows?"
// Answer: Use BFS (iterative queue) — same O(m*n), no stack overflow risk.

int[][] updateMatrix(int[][] mat) {
    int m = mat.length, n = mat[0].length;
    int[][] dist = new int[m][n];
    Queue<int[]> q = new LinkedList<>();

    // Seed: enqueue ALL 0-cells; mark 1-cells as unvisited (dist=-1)
    for (int r = 0; r < m; r++)
        for (int c = 0; c < n; c++) {
            if (mat[r][c] == 0) { dist[r][c] = 0; q.offer(new int[]{r,c}); }
            else dist[r][c] = -1;
        }

    int[][] dirs = {{-1,0},{1,0},{0,-1},{0,1}};
    while (!q.isEmpty()) {
        int[] curr = q.poll();
        for (int[] d : dirs) {
            int nr = curr[0]+d[0], nc = curr[1]+d[1];
            if (nr>=0 && nr<m && nc>=0 && nc<n && dist[nr][nc]==-1) {
                dist[nr][nc] = dist[curr[0]][curr[1]] + 1;
                q.offer(new int[]{nr, nc});
            }
        }
    }
    return dist;
}
// Time: O(m*n)  |  Space: O(m*n)
// Why dist=-1 and not Integer.MAX_VALUE? Avoids overflow on +1 and
// serves as the "unvisited" sentinel naturally.

boolean searchMatrix(int[][] matrix, int target) {
    int r = 0, c = matrix[0].length - 1;   // top-right corner
    while (r < matrix.length && c >= 0) {
        if      (matrix[r][c] == target) return true;
        else if (matrix[r][c] >  target) c--;  // too large → go left
        else                             r++;  // too small → go down
    }
    return false;
}
// Time: O(m+n)  |  Space: O(1)

// LC 74 vs LC 240:
// LC 74: Fully sorted (row-major), last of row < first of next row
//   → treat as 1D, use classic binary search: O(log(m*n))
// LC 240: Only row-sorted AND col-sorted independently
//   → need corner walk: O(m+n)   ← this solution