Find the Grid of Region Average

Find the Grid of Region Average - Problem

Array Matrix Medium

You're given an m x n grayscale image represented as a 2D grid where each cell contains a pixel intensity value between 0 and 255. Your task is to identify smooth regions within the image and calculate regional averages.

A region is defined as any 3 x 3 subgrid where adjacent pixels (sharing an edge) have intensity differences ≤ threshold. Think of this as finding areas where the image transitions are smooth enough to be considered uniform.

Key Rules:

Each pixel can belong to multiple overlapping regions
For pixels in multiple regions: average the floor values of each region's average
For pixels in no regions: keep original intensity value
Always use floor division for final results

Return the processed image where each pixel shows its regional average intensity.

Input & Output

example_1.py — Basic Valid Region

$ Input: image = [[5,6,7,10],[8,9,10,10],[11,12,13,10]], threshold = 3

› Output: [[9,9,9,10],[9,9,9,10],[9,9,9,10]]

💡 Note: The 3x3 region in the top-left corner has all adjacent pixels differing by ≤ 3, so all pixels in this region get the average value floor(81/9) = 9. The rightmost column pixels don't belong to any valid region, so they keep their original values.

example_2.py — No Valid Regions

$ Input: image = [[10,20,30],[15,25,35],[20,30,40]], threshold = 3

› Output: [[10,20,30],[15,25,35],[20,30,40]]

💡 Note: Adjacent pixels differ by more than threshold=3 (e.g., |10-20|=10 > 3), so no valid 3x3 regions exist. All pixels retain their original values.

example_3.py — Multiple Overlapping Regions

$ Input: image = [[1,1,1,1],[1,1,1,1],[1,1,1,1],[1,1,1,1]], threshold = 0

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

💡 Note: All pixels have the same value, so every 3x3 region is valid with average 1. Each pixel belongs to multiple regions, but all regions have the same average, so the result is unchanged.

Constraints

3 ≤ m, n ≤ 300
0 ≤ image[i][j] ≤ 255
0 ≤ threshold ≤ 255
Adjacent pixels are those that share an edge (not diagonal)
All averages should be calculated using floor division

Visualization

Tap to expand

Asked in

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

The optimal solution uses a single-pass preprocessing approach to identify all valid 3×3 regions and their averages, then efficiently maps each pixel to its containing regions. This avoids redundant region validations and achieves O(mn) time complexity compared to the brute force O(mn × 9) approach. The key insight is that each region needs to be validated only once, not once per pixel it contains.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force (Check All Regions for Each Pixel)

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

The most straightforward approach: for every pixel in the result grid, iterate through all possible 3x3 regions that could contain this pixel, validate each region, and collect the averages to compute the final result.

Optimized Single Pass (Optimal)

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

The optimal approach processes all possible 3x3 regions once, validates them, calculates their averages, and builds a mapping from pixels to their containing regions. This eliminates redundant region validations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct ListNode {
    int val;
    struct ListNode* next;
};

int* solution(struct ListNode* head, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    if (!head || !head->next || !head->next->next) {
        result[0] = -1;
        result[1] = -1;
        return result;
    }
    
    struct ListNode* prev = head;
    struct ListNode* curr = head->next;
    int position = 1;
    
    int firstCritical = -1;
    int lastCritical = -1;
    int minDistance = INT_MAX;
    
    while (curr->next) {
        if ((curr->val > prev->val && curr->val > curr->next->val) || 
            (curr->val < prev->val && curr->val < curr->next->val)) {
            if (firstCritical == -1) {
                firstCritical = position;
            } else {
                int distance = position - lastCritical;
                if (distance < minDistance) minDistance = distance;
            }
            lastCritical = position;
        }
        
        prev = curr;
        curr = curr->next;
        position++;
    }
    
    if (firstCritical == -1 || lastCritical == firstCritical) {
        result[0] = -1;
        result[1] = -1;
    } else {
        int maxDistance = lastCritical - firstCritical;
        result[0] = minDistance;
        result[1] = maxDistance;
    }
    
    return result;
}

struct ListNode* buildList(int* arr, int size) {
    if (size == 0) return NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = arr[0];
    head->next = NULL;
    
    struct ListNode* curr = head;
    for (int i = 1; i < size; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr->next->val = arr[i];
        curr->next->next = NULL;
        curr = curr->next;
    }
    return head;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    int arr[100000];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        arr[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    struct ListNode* head = buildList(arr, size);
    int returnSize;
    int* result = solution(head, &returnSize);
    
    printf("[%d,%d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.8K Views

Medium Frequency

~25 min Avg. Time

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