Minimum Path Sum in Grid in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the first cell of the dp array with the grid's first cell value.

DSA Java

dp[0][0] = grid[1]0][0];

Drag options to blanks, or click blank then click option'

A*

B+

C.

D[

Attempts:

3 left

💡 Hint

Common Mistakes

Using dot notation instead of square brackets to access array elements.

Using multiplication or addition symbols instead of brackets.

We use square brackets to access elements in a 2D array in Java, so dp[0][0] = grid[0][0]; is correct.

2fill in blank

medium

Complete the code to fill the first row of the dp array by accumulating sums from the left.

DSA Java

for (int j = 1; j < n; j++) {
    dp[0][j] = dp[0][j - 1] [1] grid[0][j];
}

Drag options to blanks, or click blank then click option'

A-

B+

C*

D/

Attempts:

3 left

💡 Hint

Common Mistakes

Using subtraction or multiplication instead of addition.

Forgetting to accumulate sums and just assigning the current grid value.

We add the current grid value to the sum from the left cell to accumulate the path sum.

3fill in blank

hard

Fix the error in the nested loop condition to correctly iterate over rows starting from 1.

DSA Java

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];
    }
}

Drag options to blanks, or click blank then click option'

A1

B0

Cm

Dn

Attempts:

3 left

💡 Hint

Common Mistakes

Starting the loop from 0 which overwrites the first row.

Using the wrong variable or limit in the loop.

We start from 1 because the first row and first column are already initialized.

4fill in blank

hard

Fill both blanks to complete the code that initializes the first column of the dp array by accumulating sums from above.

DSA Java

for (int i = 1; i [1] m; i++) {
    dp[i][0] = dp[i - 1][0] [2] grid[i][0];
}

Drag options to blanks, or click blank then click option'

A<

B<=

C+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= instead of < in the loop condition causing index errors.

Using subtraction instead of addition when accumulating sums.

The loop runs while i is less than m, and we add the current grid value to the sum from above.

5fill in blank

hard

Fill both blanks to complete the method that returns the minimum path sum from top-left to bottom-right in the grid.

DSA Java

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] [1] grid[i][0];
    }
    for (int j = 1; j < n; j++) {
        dp[0][j] = dp[0][j - 1] [2] 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];
}

Drag options to blanks, or click blank then click option'

A[

B+

D-

Attempts:

3 left

💡 Hint

Common Mistakes

Using dot notation instead of brackets for array access.

Using subtraction instead of addition when accumulating sums.

We use brackets to access grid elements and add values to accumulate sums in dp.

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