Number of Paths with Max Score

Number of Paths with Max Score - Problem

Number of Paths with Max Score

Imagine you're navigating a treasure-filled dungeon represented as a square grid! You start at the bottom-right corner marked with 'S' and need to reach the top-left corner marked with 'E'.

Each cell contains either:
• A treasure value (digits 1-9) that you can collect
• An obstacle marked with 'X' that blocks your path

You can move in three directions: up, left, or diagonally up-left. Your goal is to find the path that maximizes your treasure collection!

Return: A list with two integers:
1. The maximum sum of treasure you can collect
2. The number of different paths that achieve this maximum sum (modulo 10⁹ + 7)

If no path exists, return [0, 0].

Input & Output

example_1.py — Basic Path Finding

$ Input: board = ["E23", "2X2", "12S"]

› Output: [6, 1]

💡 Note: There is one path: S(0) → 1(1) → 2(3) → 3(6) → E. The maximum score is 6 and there's exactly 1 path achieving this score.

example_2.py — Multiple Optimal Paths

$ Input: board = ["E12", "1X1", "21S"]

› Output: [4, 2]

💡 Note: There are two optimal paths: S(0) → 1(1) → 2(3) → 1(4) → E and S(0) → 2(2) → 1(3) → 1(4) → E. Both achieve maximum score of 4.

example_3.py — No Valid Path

$ Input: board = ["E11", "XXX", "11S"]

› Output: [0, 0]

💡 Note: All paths from S to E are blocked by obstacles 'X', so there's no valid path. Return [0, 0].

Constraints

2 ≤ board.length == board[i].length ≤ 100
board[i][j] is one of 'E', 'S', '1', '2', ..., '9', or 'X'
It is guaranteed that board[0][0] == 'E' and board[n-1][n-1] == 'S'
Answer fits in 32-bit signed integer

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal solution uses Dynamic Programming with O(n²) time complexity. We build a DP table where each cell stores the maximum treasure score and count of optimal paths. The key insight is to work from the destination 'E' to the source 'S', considering three possible previous positions for each cell. This avoids redundant calculations while correctly handling multiple optimal paths and obstacles.

Common Approaches

✓ Dynamic Programming (Optimal)

⏱️ Time: O(n²) Space: O(n²)

Use dynamic programming to solve the problem efficiently. Create a 2D DP table where dp[i][j] stores the maximum score and count of paths to reach cell (i,j). Work backwards from destination to source, ensuring each cell is calculated only once.

Recursive Exploration (Brute Force)

⏱️ Time: O(3^(n²)) Space: O(n²)

Use recursive backtracking to explore every possible path from start to end. For each cell, try all three possible moves (up, left, diagonal) and keep track of the maximum sum and count of optimal paths.

Dynamic Programming (Optimal) — Algorithm Steps

Initialize DP table with dimensions n×n
Set base case: dp[0][0] = (0, 1) for destination 'E'
For each cell, calculate maximum score from three possible previous positions
Track count of paths that achieve the maximum score
Handle obstacles by marking them as unreachable
Return result from starting position dp[n-1][n-1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP table

Set up base case at destination 'E'

Fill row by row

Calculate max score and path count for each cell

Check three directions

Consider paths from up, left, and diagonal

Get final result

Return answer from starting position 'S'

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#define MOD 1000000007
#define MAXN 105

typedef struct {
    int score;
    int paths;
} State;

int* pathsWithMaxScore(char board[][MAXN], int boardSize, int* returnSize) {
    int n = boardSize;
    *returnSize = 2;
    
    // Dynamic allocation instead of static
    State** dp = (State**)malloc(n * sizeof(State*));
    for (int i = 0; i < n; i++) {
        dp[i] = (State*)malloc(n * sizeof(State));
        for (int j = 0; j < n; j++) {
            dp[i][j].score = -1;
            dp[i][j].paths = 0;
        }
    }
    
    dp[n-1][n-1].score = 0;
    dp[n-1][n-1].paths = 1;
    
    if (n == 1) {
        int* result = (int*)malloc(2 * sizeof(int));
        result[0] = 0;
        result[1] = 1;
        for (int i = 0; i < n; i++) free(dp[i]);
        free(dp);
        return result;
    }
    
    for (int i = n-1; i >= 0; i--) {
        for (int j = n-1; j >= 0; j--) {
            if (board[i][j] == 'X' || (i == n-1 && j == n-1)) continue;
            
            int maxScore = -1;
            int pathCount = 0;
            int directions[3][2] = {{i+1, j}, {i, j+1}, {i+1, j+1}};
            
            for (int k = 0; k < 3; k++) {
                int ni = directions[k][0];
                int nj = directions[k][1];
                
                if (ni < n && nj < n && dp[ni][nj].score != -1) {
                    int currentValue = isdigit(board[i][j]) ? board[i][j] - '0' : 0;
                    int newScore = dp[ni][nj].score + currentValue;
                    
                    if (newScore > maxScore) {
                        maxScore = newScore;
                        pathCount = dp[ni][nj].paths;
                    } else if (newScore == maxScore) {
                        pathCount = (pathCount + dp[ni][nj].paths) % MOD;
                    }
                }
            }
            
            if (maxScore != -1) {
                dp[i][j].score = maxScore;
                dp[i][j].paths = pathCount;
            }
        }
    }
    
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = (dp[0][0].score == -1) ? 0 : dp[0][0].score;
    result[1] = (dp[0][0].score == -1) ? 0 : dp[0][0].paths;
    
    for (int i = 0; i < n; i++) free(dp[i]);
    free(dp);
    
    return result;
}

int main() {
    char input_line[1000];
    if (!fgets(input_line, sizeof(input_line), stdin)) return 1;
    
    input_line[strcspn(input_line, "\n")] = 0;
    
    char board[MAXN][MAXN];
    int n = 0;
    char* p = input_line;
    
    while (*p && (*p == ' ' || *p == '[')) p++;
    
    while (*p && *p != ']' && n < MAXN) {
        while (*p && (*p == ' ' || *p == ',')) p++;
        if (!*p || *p == ']') break;
        if (*p == '"') p++;
        
        int j = 0;
        while (*p && *p != '"' && *p != ']' && j < MAXN) {
            board[n][j++] = *p++;
        }
        board[n][j] = '\0';
        if (*p == '"') p++;
        if (j > 0) n++;
    }
    
    int returnSize;
    int* result = pathsWithMaxScore(board, n, &returnSize);
    printf("[%d, %d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Visit each cell exactly once in the n×n grid

⚠ Quadratic Growth

Space Complexity

O(n²)

DP table to store maximum score and path count for each cell

⚠ Quadratic Space

48.2K Views

Medium-High Frequency

~25 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler