Number of Increasing Paths in a Grid - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Initialize Grid

Each cell represents an elevation point. We need to find all strictly increasing paths.

DFS with Memoization

From each cell, explore all 4 directions and count paths to higher elevation cells.

Cache Results

Store the number of paths from each cell to avoid recalculation.

Sum All Paths

Add up all possible increasing paths from every starting cell.

Key Takeaway

🎯 Key Insight: Use memoization to transform an exponential brute force solution into an efficient O(m×n) algorithm by caching path counts for each cell.

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

Each cell is processed exactly once due to memoization, and we visit m*n cells

✓ Linear Growth

Space Complexity

O(m*n)

Memoization table stores results for all m*n cells, plus recursion stack

⚡ Linearithmic Space

Constraints

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

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

Approach	Time	Space	Notes
✓ Brute Force DFS (Exponential)	O(4^(m*n))	O(m*n)	Recursively explore all possible increasing paths from every cell
DFS with Memoization (Optimal)	O(m*n)	O(m*n)	Use DFS with memoization to avoid recalculating paths from the same cell

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>

#define MOD 1000000007

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

int dfs(int row, int col) {
    long long count = 1; // Current cell 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;
        }
    }
    
    return count;
}

int countPaths(int** inputGrid, int rows, int cols) {
    grid = inputGrid;
    m = rows;
    n = cols;
    
    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() {
    int rows, cols;
    scanf("%d %d", &rows, &cols);
    
    int** grid = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        grid[i] = (int*)malloc(cols * sizeof(int));
        for (int j = 0; j < cols; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    
    printf("%d\n", countPaths(grid, rows, cols));
    
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    
    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

Constraints

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

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force DFS (Exponential) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler