Minimum Path Sum in Grid in DSA Java - Time & Space Complexity

Time Complexity: Minimum Path Sum in Grid

O(m x n)

Understanding Time Complexity

We want to understand how the time needed to find the minimum path sum in a grid changes as the grid size grows.

How does the number of steps grow when the grid gets bigger?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public int minPathSum(int[][] grid) {
    int m = grid.length;
    int n = grid[0].length;
    int[][] dp = new int[m][n];
    dp[0][0] = grid[0][0];
    for (int i = 1; i < m; i++) dp[i][0] = dp[i-1][0] + grid[i][0];
    for (int j = 1; j < n; j++) dp[0][j] = dp[0][j-1] + grid[0][j];
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
        }
    }
    return dp[m-1][n-1];
}
    

This code calculates the minimum sum path from the top-left to the bottom-right of a grid, moving only down or right.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Nested loops traversing each cell of the grid once.
• How many times: Each cell is visited exactly once in the double loop, totaling m x n times.

How Execution Grows With Input

As the grid size grows, the number of operations grows with the total number of cells.

Input Size (m x n)	Approx. Operations
10 x 10	100
100 x 100	10,000
1000 x 1000	1,000,000

Pattern observation: The operations grow roughly by the product of rows and columns, so doubling both dimensions quadruples the work.

Final Time Complexity

Time Complexity: O(m x n)

This means the time needed grows proportionally to the total number of cells in the grid.

Common Mistake

[X] Wrong: "Since we only move right or down, the time complexity is O(m + n)."

[OK] Correct: Although the path length is about m + n, the algorithm must fill the entire grid to find the minimum sums, visiting all m x n cells.

Interview Connect

Understanding this time complexity helps you explain how dynamic programming efficiently solves grid path problems by avoiding repeated work.

Self-Check

"What if we allowed movement in all four directions? How would the time complexity change?"

Practice

1. What does the "Minimum Path Sum in Grid" problem ask you to find?
Given a grid of numbers, find the path from top-left to bottom-right with the smallest sum.

easy

A. The path with the smallest sum of numbers from top-left to bottom-right

B. The path with the largest sum of numbers from top-left to bottom-right

C. The number of paths from top-left to bottom-right

D. The maximum number in the grid

Solution

1. Step 1: Understand the problem goal

   The problem asks to find a path from the top-left cell to the bottom-right cell of a grid such that the sum of all numbers on the path is as small as possible.

2. Step 2: Clarify path movement

   Movement is only allowed down or right at each step, so the path is constrained.

3. Final Answer:

   The path with the smallest sum of numbers from top-left to bottom-right -> Option A

4. Quick Check:

   Minimum path sum means smallest total sum [OK]

Hint: Look for smallest sum path moving only right or down [OK]

Common Mistakes:

• Thinking the path can move diagonally or up
• Looking for maximum sum instead of minimum
• Counting number of paths instead of sum

2. Which of the following Java code snippets correctly initializes a 2D array named grid with 3 rows and 3 columns filled with zeros?

easy

A. int grid[][] = new int[3];

B. int[][] grid = new int[3][3];

C. int[] grid = new int[3][3];

D. int[][] grid = new int[3];

Solution

1. Step 1: Understand Java 2D array syntax

   In Java, a 2D array is declared as int[][] name = new int[rows][columns];. This creates a grid with specified rows and columns.

2. Step 2: Check each option

   int[][] grid = new int[3][3]; correctly declares a 3x3 int 2D array. Options A, C, and D have incorrect syntax or dimensions.

3. Final Answer:

   int[][] grid = new int[3][3]; -> Option B

4. Quick Check:

   Correct 2D array syntax = int[][] grid = new int[3][3]; [OK]

Hint: Use int[][] name = new int[rows][cols] for 2D arrays [OK]

Common Mistakes:

• Declaring 2D arrays with wrong brackets
• Initializing only one dimension
• Confusing 1D and 2D array syntax

3. What is the output of the following Java code that calculates the minimum path sum in a 2x2 grid?

int[][] grid = {{1, 3}, {1, 5}};
int m = grid.length;
int n = grid[0].length;
int[][] dp = new int[m][n];
dp[0][0] = grid[0][0];
for (int i = 1; i < m; i++) dp[i][0] = dp[i-1][0] + grid[i][0];
for (int j = 1; j < n; j++) dp[0][j] = dp[0][j-1] + grid[0][j];
for (int i = 1; i < m; i++) {
  for (int j = 1; j < n; j++) {
    dp[i][j] = Math.min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
  }
}
System.out.println(dp[m-1][n-1]);

medium

A. 7

B. 8

C. 9

D. 10

Solution

1. Step 1: Initialize dp array with first row and column sums

   dp[0][0] = 1
   dp[1][0] = dp[0][0] + grid[1][0] = 1 + 1 = 2
   dp[0][1] = dp[0][0] + grid[0][1] = 1 + 3 = 4

2. Step 2: Calculate dp[1][1]

   dp[1][1] = min(dp[0][1], dp[1][0]) + grid[1][1] = min(4, 2) + 5 = 2 + 5 = 7

3. Final Answer:

   7 -> Option A

4. Quick Check:

   Minimum path sum = 7 [OK]

Hint: Fill dp row and column first, then use min of top and left [OK]

Common Mistakes:

• Adding max instead of min
• Not initializing first row and column correctly
• Mixing indices in loops

4. Identify the error in the following Java code snippet that tries to compute the minimum path sum in a grid:

int[][] grid = {{1,2,3},{4,5,6}};
int m = grid.length;
int n = grid[0].length;
int[][] dp = new int[m][n];
dp[0][0] = grid[0][0];
for (int i = 1; i < m; i++) {
  dp[i][0] = dp[i-1][0] + grid[i][0];
}
for (int j = 1; j < n; j++) {
  dp[0][j] = dp[0][j-1] + grid[0][j];
}
for (int i = 1; i < m; i++) {
  for (int j = 1; j < n; j++) {
    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]) + grid[i][j];
  }
}

medium

A. Grid dimensions are wrong

B. Not initializing dp[0][0]

C. Loop ranges are incorrect

D. Using Math.max instead of Math.min in dp calculation

Solution

1. Step 1: Check dp initialization

   dp[0][0] is correctly initialized to grid[0][0]. Loops for first row and column are correct.

2. Step 2: Identify the error in dp update

   The inner loop uses Math.max instead of Math.min, which finds the maximum path sum, not minimum.

3. Final Answer:

   Using Math.max instead of Math.min in dp calculation -> Option D

4. Quick Check:

   Minimum path sum needs Math.min, not Math.max [OK]

Hint: Use Math.min to find minimum path sum, not Math.max [OK]

Common Mistakes:

• Using max instead of min in dp update
• Forgetting to initialize dp[0][0]
• Incorrect loop boundaries

5. Given a 3x3 grid:

int[][] grid = {
  {1, 2, 5},
  {3, 2, 1},
  {4, 1, 1}
};

What is the minimum path sum from top-left to bottom-right moving only right or down?

hard

A. 9

B. 8

C. 7

D. 10

Solution

1. Step 1: Initialize dp first row and column sums

   dp[0][0] = 1
   dp[0][1] = 1 + 2 = 3
   dp[0][2] = 3 + 5 = 8
   dp[1][0] = 1 + 3 = 4
   dp[2][0] = 4 + 4 = 8

2. Step 2: Calculate dp values for inner cells

   dp[1][1] = min(dp[0][1], dp[1][0]) + 2 = min(3,4) + 2 = 5
   dp[1][2] = min(dp[0][2], dp[1][1]) + 1 = min(8,5) + 1 = 6
   dp[2][1] = min(dp[1][1], dp[2][0]) + 1 = min(5,8) + 1 = 6
   dp[2][2] = min(dp[1][2], dp[2][1]) + 1 = min(6,6) + 1 = 7

3. Final Answer:

   7 -> Option C

4. Quick Check:

   Minimum path sum = 7 [OK]

Hint: Fill dp row and column first, then inner cells with min of top and left [OK]

Common Mistakes:

• Not updating dp correctly for inner cells
• Adding max instead of min
• Incorrect initialization of first row or column