Number of Increasing Paths in a Grid - Problem

Array Dynamic Programming Depth-First Search Breadth-First Search Graph Topological Sort Memoization Matrix Hard

Imagine you're exploring a mountainous terrain represented by a grid where each cell contains an elevation value. You can move to any of the 4 adjacent cells (up, down, left, right), but there's a catch - you can only move to cells with strictly higher elevation!

Given an m x n integer matrix grid, your task is to find the total number of strictly increasing paths possible in this terrain. You can start from any cell and end at any cell, as long as each step takes you to a higher elevation.

Key Points:

Two paths are different if they visit different sequences of cells
A single cell counts as a valid path of length 1
Return the answer modulo 10⁹ + 7 since it can be very large

Example: In a 2x2 grid [[1,1],[3,4]], you have paths like: [1]→[3]→[4], [1]→[3], [3]→[4], and all single cells, totaling 8 different increasing paths.

Input & Output

example_1.py — Basic Grid

$ Input: grid = [[1,1],[3,4]]

› Output: 8

💡 Note: The 8 increasing paths are: [1], [1], [3], [4], [1,3], [1,4], [1,3,4], [3,4]. Note that paths [1,3,4] and [1,4] start from different cells with value 1.

example_2.py — Single Row

$ Input: grid = [[1]]

› Output: 1

💡 Note: There's only one cell, so there's exactly one path consisting of just that single cell [1].

example_3.py — Larger Grid

$ Input: grid = [[1,2,3],[4,5,6],[7,8,9]]

› Output: 109

💡 Note: This 3x3 grid has many possible increasing paths. Each cell can potentially reach multiple higher-valued cells, creating numerous path combinations.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 1000
1 ≤ grid[i][j] ≤ 10⁵
All values in the grid are unique

Visualization

Tap to expand

Asked in

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

The optimal approach uses DFS with memoization to count increasing paths efficiently. By caching results for each cell, we avoid recalculating the same subproblems multiple times, reducing complexity from exponential to O(m×n). Each cell stores the number of increasing paths starting from that position, building up the solution bottom-up.

Common Approaches

✓ Brute Force DFS (Exponential)

⏱️ Time: O(4^(m*n)) Space: O(m*n)

Start DFS from every cell in the grid and recursively count all possible strictly increasing paths. For each cell, explore all 4 directions and continue only if the next cell has a higher value.

DFS with Memoization (Optimal)

⏱️ Time: O(m*n) Space: O(m*n)

Optimize the brute force approach by storing the results of DFS from each cell in a memoization table. This way, when we need to calculate paths from a cell we've visited before, we can directly return the cached result.

Brute Force DFS (Exponential) — Algorithm Steps

Iterate through every cell in the grid as a starting point
For each starting cell, perform DFS to explore all increasing paths
From current cell, check all 4 adjacent cells
Recursively continue DFS only if adjacent cell has higher value
Count all possible paths and sum them up

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from cell (0,0)

Begin DFS from first cell, exploring all increasing directions

Recursive exploration

From each cell, recursively explore all 4 directions with higher values

Count all paths

Sum up all possible increasing paths found from this starting cell

Repeat for all cells

Repeat the entire process for every cell as a starting point

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MOD 1000000007
#define MAX_SIZE 1000

int** grid;
int m, n;
int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
static int memo[MAX_SIZE][MAX_SIZE];
static int memo_set[MAX_SIZE][MAX_SIZE];

int dfs(int row, int col) {
    if (memo_set[row][col]) {
        return memo[row][col];
    }
    
    long long count = 1; // Current cell itself is a valid path
    
    for (int i = 0; i < 4; i++) {
        int newRow = row + directions[i][0];
        int newCol = col + directions[i][1];
        
        if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && 
            grid[newRow][newCol] > grid[row][col]) {
            count = (count + dfs(newRow, newCol)) % MOD;
        }
    }
    
    memo[row][col] = count;
    memo_set[row][col] = 1;
    return count;
}

int countPaths(int** inputGrid, int rows, int cols) {
    grid = inputGrid;
    m = rows;
    n = cols;
    
    // Clear memoization
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            memo_set[i][j] = 0;
        }
    }
    
    long long totalPaths = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            totalPaths = (totalPaths + dfs(i, j)) % MOD;
        }
    }
    
    return totalPaths;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Find start of array
    char* start = strstr(input, "[[");
    if (!start) return 1;
    
    // Parse grid dimensions and data
    char* p = start + 2; // Skip first '[['  
    int rows = 0;
    int cols = 0;
    int gridData[MAX_SIZE][MAX_SIZE];
    
    // Count and parse first row to get cols
    int firstRowCols = 0;
    char* rowStart = p;
    while (*p && *p != ']') {
        if (*p >= '0' && *p <= '9') {
            gridData[0][firstRowCols] = (int)strtol(p, &p, 10);
            firstRowCols++;
        } else {
            p++;
        }
    }
    cols = firstRowCols;
    rows = 1;
    
    // Skip ']' and look for more rows
    if (*p == ']') p++;
    
    while (*p) {
        // Look for next '['
        while (*p && *p != '[') p++;
        if (!*p) break;
        
        p++; // Skip '['
        int colCount = 0;
        while (*p && *p != ']') {
            if (*p >= '0' && *p <= '9') {
                gridData[rows][colCount] = (int)strtol(p, &p, 10);
                colCount++;
            } else {
                p++;
            }
        }
        
        if (colCount > 0) {
            rows++;
        }
        
        if (*p == ']') p++;
    }
    
    // Allocate dynamic grid
    int** dynamicGrid = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        dynamicGrid[i] = (int*)malloc(cols * sizeof(int));
        for (int j = 0; j < cols; j++) {
            dynamicGrid[i][j] = gridData[i][j];
        }
    }
    
    printf("%d\n", countPaths(dynamicGrid, rows, cols));
    
    // Clean up
    for (int i = 0; i < rows; i++) {
        free(dynamicGrid[i]);
    }
    free(dynamicGrid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(4^(m*n))

In worst case, from each cell we might explore 4 directions recursively, leading to exponential branching

✓ Linear Growth

Space Complexity

O(m*n)

Recursion stack depth can go up to m*n in worst case

⚡ Linearithmic Space

67.3K Views

High Frequency

~25 min Avg. Time

1.8K 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

Number of Increasing Paths in a Grid - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force DFS (Exponential) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler