Difference of Number of Distinct Values on Diagonals

Difference of Number of Distinct Values on Diagonals - Problem

You're given a 2D grid of size m × n, and your task is to create an answer matrix of the same size where each cell contains a special diagonal difference calculation.

For each cell grid[r][c], you need to:

Count distinct values on the diagonal going left and above (not including the current cell)
Count distinct values on the diagonal going right and below (not including the current cell)
Calculate the absolute difference between these two counts

A diagonal line starts from either the topmost row or leftmost column and extends in the bottom-right direction until it reaches the matrix boundary.

Visual Example:

For cell at position (2,3), the diagonal contains cells that share the same row - col value. The red cells are left and above, blue cells are right and below.

Return the matrix where answer[r][c] = |leftAbove[r][c] - rightBelow[r][c]|

Input & Output

example_1.py — Basic 3x3 Grid

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

› Output: [[1,1,0],[1,0,1],[0,1,1]]

💡 Note: For cell (1,1) with value 5: left-above diagonal has [1] (1 distinct), right-below has [9] (1 distinct), so |1-1| = 0

example_2.py — Repeated Values

$ Input: grid = [[1,2,2],[2,2,1],[1,1,2]]

› Output: [[0,1,1],[1,0,1],[1,1,0]]

💡 Note: When values repeat on diagonals, distinct count may be less than total count. Center cell has left-above [1] and right-below [2], giving |1-1| = 0

example_3.py — Single Row/Column

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

› Output: [[0,0,0,0]]

💡 Note: Each cell is on its own diagonal with no other elements, so both left-above and right-below counts are 0

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 50
1 ≤ grid[i][j] ≤ 50

Visualization

Tap to expand

Understanding the Visualization

Identify Diagonals

Group cells by their diagonal using (row - col) as the key

Process Each Diagonal

Traverse each diagonal once from top-left to bottom-right

Build Prefix Counts

Track distinct values accumulated from the beginning

Build Suffix Counts

Track distinct values accumulated from the end

Calculate Results

Use precomputed counts to find absolute differences

Key Takeaway

🎯 Key Insight: Grouping cells by diagonal (row-col) allows us to process each diagonal line exactly once, building prefix and suffix distinct counts efficiently rather than recalculating for every cell.

Asked in

G Google 12 f Meta 8 a Amazon 6 ⊞ Microsoft 4

The optimal solution uses a one-pass hash table approach that processes each diagonal exactly once. Key insight: cells sharing the same (row - col) value belong to the same diagonal. We group cells by diagonal, then traverse each diagonal once to build prefix and suffix distinct counts, eliminating redundant calculations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct Diagonal Traversal)	O(m * n * (m + n))	O(min(m, n))	For each cell, traverse its diagonal in both directions to count distinct values
One-Pass Hash Table (Optimal)	O(m * n)	O(m * n)	Process each diagonal once, building prefix and suffix distinct counts simultaneously

Brute Force (Direct Diagonal Traversal) — Algorithm Steps

For each cell (r,c) in the matrix
Traverse diagonal left and above: move (r-1,c-1) until out of bounds
Collect all values in a set to count distinct values
Traverse diagonal right and below: move (r+1,c+1) until out of bounds
Collect all values in another set to count distinct values
Calculate absolute difference and store in result matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Cell

Choose current cell (r,c) to calculate

Traverse Left-Above

Move diagonally up-left collecting values in a set

Traverse Right-Below

Move diagonally down-right collecting values in another set

Calculate Difference

Find absolute difference between set sizes

Code -

solution.c — C

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

int abs_diff(int a, int b) {
    return a > b ? a - b : b - a;
}

int countDistinct(int* arr, int size) {
    if (size == 0) return 0;
    
    // Simple O(n²) distinct counting
    int count = 0;
    for (int i = 0; i < size; i++) {
        bool found = false;
        for (int j = 0; j < i; j++) {
            if (arr[j] == arr[i]) {
                found = true;
                break;
            }
        }
        if (!found) count++;
    }
    return count;
}

int** differenceOfDistinctValuesOnDiagonals(int** grid, int m, int n) {
    int** result = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        result[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            // Collect left and above values
            int leftAbove[1000], leftCount = 0;
            int i = r - 1, j = c - 1;
            while (i >= 0 && j >= 0) {
                leftAbove[leftCount++] = grid[i][j];
                i--;
                j--;
            }
            
            // Collect right and below values
            int rightBelow[1000], rightCount = 0;
            i = r + 1; j = c + 1;
            while (i < m && j < n) {
                rightBelow[rightCount++] = grid[i][j];
                i++;
                j++;
            }
            
            int leftDistinct = countDistinct(leftAbove, leftCount);
            int rightDistinct = countDistinct(rightBelow, rightCount);
            result[r][c] = abs_diff(leftDistinct, rightDistinct);
        }
    }
    
    return result;
}

int main() {
    // Placeholder input parsing
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m * n * (m + n))

For each of m*n cells, we traverse up to m+n cells on the diagonal

✓ Linear Growth

Space Complexity

O(min(m, n))

Space for sets to store distinct values on each diagonal segment

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~25 min Avg. Time

847 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

Brute Force (Direct Diagonal Traversal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler