Paths in Matrix Whose Sum Is Divisible by K

Paths in Matrix Whose Sum Is Divisible by K - Problem

You are given a 0-indexed m x n integer matrix grid and an integer k. You are currently at position (0, 0) and you want to reach position (m - 1, n - 1) moving only down or right.

Return the number of paths where the sum of the elements on the path is divisible by k. Since the answer may be very large, return it modulo 10^9 + 7.

Input & Output

Example 1 — Basic Case

$ Input: grid = [[5,2,4],[3,0,5],[0,7,2]], k = 3

› Output: 2

💡 Note: There are two paths with sum divisible by 3: Path 1: 5→2→4→5→2 = 18 (18%3=0), Path 2: 5→3→0→7→2 = 17... Actually checking: 5→2→0→7→2=16, 5→3→0→7→2=17. Need to verify paths carefully.

Example 2 — Small Grid

$ Input: grid = [[5,2],[4,3]], k = 2

› Output: 2

💡 Note: Two paths: 5→2→3=10 (10%2=0) and 5→4→3=12 (12%2=0). Both sums are divisible by 2.

Example 3 — No Valid Paths

$ Input: grid = [[1,2],[3,4]], k = 10

› Output: 0

💡 Note: Path 1: 1→2→4=7, Path 2: 1→3→4=8. Neither 7 nor 8 is divisible by 10.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 5 × 10¹
0 ≤ grid[i][j] ≤ 100
1 ≤ k ≤ 50

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to use dynamic programming tracking remainder states instead of full sums. Best approach uses 3D DP with state dp[i][j][remainder] representing paths to position (i,j) with sum remainder r. Time: O(m×n×k), Space: O(m×n×k)

Common Approaches

✓ 3D Dynamic Programming

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

Use a 3D DP table dp[i][j][r] representing the number of paths to reach position (i,j) with sum remainder r. Fill the table bottom-up from (0,0) to (m-1,n-1).

Memoized Recursion

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

Optimize the recursive solution by memoizing results based on current position (i,j) and current sum modulo k to avoid recomputing the same subproblems.

Recursive Brute Force

⏱️ Time: O(2^(m+n)) Space: O(m+n)

Use recursion to explore every possible path from top-left to bottom-right, calculating the sum along each path and counting those divisible by k.

3D Dynamic Programming — Algorithm Steps

Initialize 3D DP table dp[m][n][k]
Set base case: dp[0][0][grid[0][0]%k] = 1
Fill table: dp[i][j][r] = sum of paths from top and left

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create 3D table dp[i][j][remainder]

Fill

Process each cell, updating remainder counts

Result

Answer is dp[m-1][n-1][0]

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_SIZE 100

static int grid[MAX_SIZE][MAX_SIZE];
static int dp[MAX_SIZE][MAX_SIZE][51];

int solution(int m, int n, int k) {
    // Initialize DP array
    memset(dp, 0, sizeof(dp));
    
    // Base case
    dp[0][0][grid[0][0] % k] = 1;
    
    // Fill first row
    for (int j = 1; j < n; j++) {
        for (int r = 0; r < k; r++) {
            if (dp[0][j-1][r] > 0) {
                int newR = (r + grid[0][j]) % k;
                dp[0][j][newR] = (dp[0][j][newR] + dp[0][j-1][r]) % MOD;
            }
        }
    }
    
    // Fill first column
    for (int i = 1; i < m; i++) {
        for (int r = 0; r < k; r++) {
            if (dp[i-1][0][r] > 0) {
                int newR = (r + grid[i][0]) % k;
                dp[i][0][newR] = (dp[i][0][newR] + dp[i-1][0][r]) % MOD;
            }
        }
    }
    
    // Fill the rest
    for (int i = 1; i < m; i++) {
        for (int j = 1; j < n; j++) {
            for (int r = 0; r < k; r++) {
                // From top
                if (dp[i-1][j][r] > 0) {
                    int newR = (r + grid[i][j]) % k;
                    dp[i][j][newR] = (dp[i][j][newR] + dp[i-1][j][r]) % MOD;
                }
                
                // From left
                if (dp[i][j-1][r] > 0) {
                    int newR = (r + grid[i][j]) % k;
                    dp[i][j][newR] = (dp[i][j][newR] + dp[i][j-1][r]) % MOD;
                }
            }
        }
    }
    
    return dp[m-1][n-1][0];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int k;
    scanf("%d", &k);
    
    // Parse the grid from JSON-like format
    int m = 0, n = 0;
    char* ptr = line;
    
    // Skip initial '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    // Parse each row
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            // Parse numbers in this row
            while (*ptr && *ptr != ']') {
                if (isdigit(*ptr)) {
                    grid[m][n] = strtol(ptr, &ptr, 10);
                    n++;
                } else {
                    ptr++;
                }
            }
            if (*ptr == ']') ptr++;
            m++;
        } else {
            ptr++;
        }
    }
    
    printf("%d\n", solution(m, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n*k)

Three nested loops: m rows × n columns × k remainders

✓ Linear Growth

Space Complexity

O(m*n*k)

3D DP table stores m×n×k states

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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

3D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler