Fill a Special Grid

Fill a Special Grid - Problem

You are given a non-negative integer n representing a 2ⁿ x 2ⁿ grid. You must fill the grid with integers from 0 to 2²ⁿ - 1 to make it special.

A grid is special if it satisfies all the following conditions:

All numbers in the top-right quadrant are smaller than those in the bottom-right quadrant.
All numbers in the bottom-right quadrant are smaller than those in the bottom-left quadrant.
All numbers in the bottom-left quadrant are smaller than those in the top-left quadrant.
Each of its quadrants is also a special grid.

Return the special 2ⁿ x 2ⁿ grid.

Note: Any 1x1 grid is special.

Input & Output

Example 1 — Base Case

$ Input: n = 0

› Output: [[0]]

💡 Note: A 2^0 x 2^0 = 1x1 grid with single element 0. Any 1x1 grid is special by definition.

Example 2 — Small Grid

$ Input: n = 1

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

💡 Note: A 2^1 x 2^1 = 2x2 grid. Quadrants: TR=0, BR=1, BL=2, TL=3. Satisfies 0 < 1 < 2 < 3.

Example 3 — Larger Grid

$ Input: n = 2

› Output: [[15,14,3,2],[13,12,1,0],[11,10,7,6],[9,8,5,4]]

💡 Note: A 4x4 grid where each 2x2 quadrant is special and follows the ordering: TR < BR < BL < TL

Constraints

0 ≤ n ≤ 6
Grid size will be 2ⁿ x 2ⁿ
Numbers range from 0 to 2²ⁿ - 1

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 20 a Amazon 18 f Facebook 15

The key insight is to use divide and conquer with proper value range assignment. Each quadrant gets a specific range: top-right (smallest) < bottom-right < bottom-left < top-left (largest), then recursively fill each quadrant. Best approach is divide and conquer with Time: O(2^(2n)), Space: O(2^(2n)).

Common Approaches

✓ Optimized

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

Brute Force - Try All Permutations

⏱️ Time: O((2^(2n))!) Space: O(2^(2n))

Try every possible way to fill the grid with numbers 0 to 2^(2n)-1 and check if each arrangement satisfies all special grid conditions including quadrant ordering and recursive structure.

Divide and Conquer - Recursive Quadrants

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

Use divide and conquer to recursively build special grids. For each level, divide into 4 quadrants and assign value ranges such that top-right < bottom-right < bottom-left < top-left, then recursively fill each quadrant.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int* solveRecursive(int* sumsList, int size, int* resultSize) {
    if (size == 1) {
        *resultSize = 0;
        return NULL;
    }
    if (size == 2) {
        qsort(sumsList, size, sizeof(int), compare);
        int* result = (int*)malloc(sizeof(int));
        result[0] = sumsList[1] - sumsList[0];
        *resultSize = 1;
        return result;
    }
    
    qsort(sumsList, size, sizeof(int), compare);
    
    for (int i = 1; i < size; i++) {
        int candidate = sumsList[i] - sumsList[0];
        if (candidate == 0) continue;
        
        // Simple approach: try to split into two equal halves
        int* withoutCandidate = (int*)malloc(size / 2 * sizeof(int));
        int* tempSums = (int*)malloc(size * sizeof(int));
        memcpy(tempSums, sumsList, size * sizeof(int));
        
        int withoutSize = 0;
        int used[1000] = {0}; // assuming max 1000 elements
        
        for (int j = 0; j < size && withoutSize < size / 2; j++) {
            if (used[j]) continue;
            
            int target = tempSums[j] + candidate;
            for (int k = j + 1; k < size; k++) {
                if (!used[k] && tempSums[k] == target) {
                    withoutCandidate[withoutSize++] = tempSums[j];
                    used[j] = used[k] = 1;
                    break;
                }
            }
        }
        
        if (withoutSize == size / 2) {
            int subResultSize;
            int* subResult = solveRecursive(withoutCandidate, withoutSize, &subResultSize);
            
            int* result = (int*)malloc((subResultSize + 1) * sizeof(int));
            for (int j = 0; j < subResultSize; j++) {
                result[j] = subResult[j];
            }
            result[subResultSize] = candidate;
            *resultSize = subResultSize + 1;
            
            free(withoutCandidate);
            free(tempSums);
            if (subResult) free(subResult);
            return result;
        }
        
        free(withoutCandidate);
        free(tempSums);
    }
    
    *resultSize = 0;
    return NULL;
}

int* solution(int n, int* sums, int sumsSize) {
    int resultSize;
    int* result = solveRecursive(sums, sumsSize, &resultSize);
    
    int* finalResult = (int*)calloc(n, sizeof(int));
    
    if (result) {
        for (int i = 0; i < resultSize && i < n; i++) {
            finalResult[i] = result[i];
        }
        free(result);
    }
    
    return finalResult;
}

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() {
    int n;
    scanf("%d", &n);
    
    char line[10000];
    scanf(" %[^\n]", line);
    
    int sums[1000];
    int sumsSize = 0;
    
    if (strcmp(line, "[]") != 0) {
        char* token = strtok(line + 1, ",]");
        while (token != NULL) {
            sums[sumsSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int* result = solution(n, sums, sumsSize);
    
    printf("[");
    for (int i = 0; i < n; i++) {
        printf("%d", result[i]);
        if (i < n - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

35.6K Views

Medium Frequency

~30 min Avg. Time

890 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