Code Review (Easy): Routing Around Spills

Story

Lena is polishing a helper function for the company’s automated document delivery system to help it navigate the office floor. Mark pointed out that the robot occasionally gets stuck because it doesn't account for temporary blockages like wet floor signs or moved furniture. She needs to calculate the total number of clear paths the robot can take from the entrance to the mailroom, assuming it only moves forward or downward across the floor grid. For example, if a small 3x3 office layout has a single blocked desk right in the middle, the robot should identify that there are exactly two unique ways to reach the destination by skirting around the obstacle.

Your Task

Read the story and code, then decide if the code is ready for production or needs improvement.

Hints

What would block an approval? Give me a hint.

Check out Next Topic: Mapping the Workflow

// Older approach using a full 2D DP matrix (kept for reference)
/*
function uniquePathsWithObstacles_old(obstacleGrid: number[][]): number {
  const m = obstacleGrid.length;
  if (m === 0) return 0;
  const n = obstacleGrid[0].length;
  const dp: number[][] = Array.from({ length: m }, () => new Array(n).fill(0));
  if (obstacleGrid[0][0] === 0) dp[0][0] = 1;
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < n; j++) {
      if (obstacleGrid[i][j] === 1) {
        dp[i][j] = 0;
      } else {
        if (i > 0) dp[i][j] += dp[i - 1][j];
        if (j > 0) dp[i][j] += dp[i][j - 1];
      }
    }
  }
  return dp[m - 1][n - 1];
}
*/

// ---------------------------------------------------------------------------
// Dead / unused code below: kept around "just in case" alternative analyzers
// ---------------------------------------------------------------------------

type Grid = number[][];

const DEFAULT_TEST_GRID: Grid = [
  [0, 0, 0],
  [0, 1, 0],
  [0, 0, 0],
];

class ObstacleGridAnalyzer {
  private grid: Grid;
  private rows: number;
  private cols: number;

constructor(grid: Grid) {
    this.grid = grid;
    this.rows = grid.length;
    this.cols = grid[0]?.length ?? 0;
  }

// Alternative DP method that builds a full matrix (never used)
  public countPathsFullMatrix(): number {
    if (this.rows === 0) return 0;
    const dp: number[][] = Array.from({ length: this.rows }, () => new Array(this.cols).fill(0));
    dp[0][0] = this.grid[0][0] === 0 ? 1 : 0;
    for (let i = 0; i < this.rows; i++) {
      for (let j = 0; j < this.cols; j++) {
        if (this.grid[i][j] === 1) {
          dp[i][j] = 0;
        } else {
          if (i > 0) dp[i][j] += dp[i - 1][j];
          if (j > 0) dp[i][j] += dp[i][j - 1];
        }
      }
    }
    return dp[this.rows - 1][this.cols - 1];
  }

// Recursive brute force (exponential) kept for debugging / validation (never called)
  public countPathsBruteForce(): number {
    const memo: Map<string, number> = new Map();
    const dfs = (r: number, c: number): number => {
      if (r >= this.rows || c >= this.cols) return 0;
      if (this.grid[r][c] === 1) return 0;
      if (r === this.rows - 1 && c === this.cols - 1) return 1;
      const key = `${r},${c}`;
      if (memo.has(key)) return memo.get(key)!;
      const res = dfs(r + 1, c) + dfs(r, c + 1);
      memo.set(key, res);
      return res;
    };
    return dfs(0, 0);
  }
}

// Unused helper function that prints a grid (kept for interactive debugging)
function prettyPrintGrid(grid: Grid): string {
  return grid.map(row => row.map(cell => (cell === 1 ? 'X' : '.')).join(' ')).join('\n');
}

// Another unused alternative implementation (kept as "backup")
function uniquePathsWithObstaclesBackup(obstacleGrid: number[][]): number {
  const m = obstacleGrid.length;
  if (m === 0) return 0;
  const n = obstacleGrid[0].length;
  let prevRow: number[] = new Array(n).fill(0);
  prevRow[0] = obstacleGrid[0][0] === 0 ? 1 : 0;
  for (let i = 0; i < m; i++) {
    const currentRow: number[] = new Array(n).fill(0);
    for (let j = 0; j < n; j++) {
      if (obstacleGrid[i][j] === 1) {
        currentRow[j] = 0;
      } else {
        if (i === 0 && j === 0) {
          currentRow[j] = prevRow[j];
        } else {
          const up = i > 0 ? prevRow[j] : 0;
          const left = j > 0 ? currentRow[j - 1] : 0;
          currentRow[j] = up + left;
        }
      }
    }
    prevRow = currentRow;
  }
  return prevRow[n - 1];
}

// Unused constants and caches
const PRECOMPUTED_ANSWERS: Map<string, number> = new Map();
const UNUSED_FLAG = true;

interface AnalyzerConfig {
  maxRows: number;
  maxCols: number;
}

// A utility class that might help test performance (never instantiated)
class PerformanceTester {
  config: AnalyzerConfig;
  constructor(config?: Partial<AnalyzerConfig>) {
    this.config = {
      maxRows: config?.maxRows ?? 100,
      maxCols: config?.maxCols ?? 100,
    };
  }

simulateLargeGrid(): Grid {
    const rows = Math.min(this.config.maxRows, 50);
    const cols = Math.min(this.config.maxCols, 50);
    const grid: Grid = Array.from({ length: rows }, () => new Array(cols).fill(0));
    // put a diagonal of obstacles
    for (let i = 0; i < Math.min(rows, cols); i++) {
      grid[i][i] = 0; // left as zero for simulation
    }
    return grid;
  }

// A method that measures time for the backup algorithm (not used)
  measureBackup(grid: Grid): { timeMs: number; result: number } {
    const start = Date.now();
    const result = uniquePathsWithObstaclesBackup(grid);
    const end = Date.now();
    return { timeMs: end - start, result };
  }
}

// End of file. The exported / intended API is the function above.