Check if Grid Satisfies Conditions

Check if Grid Satisfies Conditions - Problem

Array Matrix Easy

You are given a 2D matrix grid of size m x n. You need to check if each cell grid[i][j] is:

Equal to the cell below it, i.e. grid[i][j] == grid[i + 1][j] (if it exists).
Different from the cell to its right, i.e. grid[i][j] != grid[i][j + 1] (if it exists).

Return true if all the cells satisfy these conditions, otherwise, return false.

Input & Output

Example 1 — Valid Grid

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

› Output: true

💡 Note: All cells in each column are equal (1,1), (0,0), (2,2). Adjacent columns differ: 1≠0, 0≠2. All conditions satisfied.

Example 2 — Invalid Vertical

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

› Output: false

💡 Note: Column values are not uniform: grid[0][0]=1 but grid[1][0]=0. Also adjacent columns are same: grid[0][0]==grid[0][1]. Fails both conditions.

Example 3 — Invalid Horizontal

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

› Output: false

💡 Note: Single column grid with two rows: grid[0][0]=1 and grid[1][0]=2. Since 1≠2, the vertical condition fails.

Constraints

1 ≤ m, n ≤ 10
1 ≤ grid[i][j] ≤ 9

Visualization

Tap to expand

Asked in

G Google 12 f Meta 8 M Microsoft 6

The key insight is that each column must be uniform (all same values) and adjacent columns must differ. Best approach is single-pass validation checking both conditions per cell. Time: O(m×n), Space: O(1)

Common Approaches

✓ Brute Force - Check Every Cell

⏱️ Time: O(m×n) Space: O(1)

Go through every cell in the grid and check if it equals the cell below (if exists) and differs from the cell to the right (if exists). Return false immediately if any condition fails.

Optimized - Column-wise Validation

⏱️ Time: O(m×n) Space: O(1)

Instead of checking each cell individually, first validate that each column is uniform (all elements same), then check that adjacent columns differ. This can potentially exit early if a column is not uniform.

Brute Force - Check Every Cell — Algorithm Steps

Step 1: Iterate through each row and column
Step 2: For each cell, check vertical equality condition
Step 3: For each cell, check horizontal difference condition
Step 4: Return false if any condition fails, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Vertical

Verify each cell equals the one below

Check Horizontal

Verify each cell differs from the one to its right

Result

Return true if all conditions pass

Code -

solution.c — C

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

bool solution(int** grid, int m, int n) {
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Check vertical condition: equal to cell below
            if (i + 1 < m && grid[i][j] != grid[i + 1][j]) {
                return false;
            }
            
            // Check horizontal condition: different from cell to right
            if (j + 1 < n && grid[i][j] == grid[i][j + 1]) {
                return false;
            }
        }
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for 2D array
    int** grid = malloc(100 * sizeof(int*));
    int m = 0, n = 0;
    
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            grid[m] = malloc(100 * sizeof(int));
            int j = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    grid[m][j++] = strtol(ptr, &ptr, 10);
                } else {
                    ptr++;
                }
            }
            if (m == 0) n = j;
            m++;
        }
        ptr++;
    }
    
    bool result = solution(grid, m, n);
    printf(result ? "true\n" : "false\n");
    
    for (int i = 0; i < m; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Visit each cell once and check its neighbors

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

234 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 - Check Every Cell — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler