Minimum Swaps to Arrange a Binary Grid

Minimum Swaps to Arrange a Binary Grid - Problem

Given an n x n binary grid, in one step you can choose two adjacent rows of the grid and swap them.

A grid is said to be valid if all the cells above the main diagonal are zeros.

Return the minimum number of steps needed to make the grid valid, or -1 if the grid cannot be valid.

The main diagonal of a grid is the diagonal that starts at cell (1, 1) and ends at cell (n, n).

Input & Output

Example 1 — Basic Grid Arrangement

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

› Output: 2

💡 Note: Row 2 [1,0,0,0] has 3 trailing zeros, perfect for position 0. We swap row 2 with row 1 (1 swap), then row 1 with row 0 (1 swap), giving us 2 total swaps.

Example 2 — Already Valid Grid

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

› Output: 0

💡 Note: The grid is already valid - all cells above the main diagonal are zeros. No swaps needed.

Example 3 — Impossible Case

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

› Output: -1

💡 Note: Row 0 needs ≥2 trailing zeros but [1,1,1] has 0. Row 2 [1,1,1] also has 0. No valid arrangement possible.

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 200
grid[i][j] is 0 or 1

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is counting trailing zeros in each row to determine valid positions. For a grid to be valid, row i must have at least n-1-i trailing zeros. The greedy approach works well: for each position, find the nearest suitable row and bubble it up using adjacent swaps. Best approach achieves Time: O(n²), Space: O(n).

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n²) Space: O(n²)

Try every possible permutation of rows, check if each arrangement is valid, and count the minimum adjacent swaps needed to reach that arrangement.

Greedy - Count Trailing Zeros

⏱️ Time: O(n²) Space: O(n)

For each row position i, we need at least n-1-i trailing zeros. Count trailing zeros in each row, then greedily find suitable rows and bubble them to correct positions using adjacent swaps.

Brute Force - Try All Permutations — Algorithm Steps

Generate all n! permutations of rows
For each permutation, check if it's valid
Calculate minimum adjacent swaps to reach valid permutation

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all n! possible row arrangements

Check Validity

Test if upper triangle has only zeros

Count Swaps

Calculate adjacent swaps needed for valid arrangements

Code -

solution.c — C

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

int is_valid(int** arrangement, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            if (arrangement[i][j] == 1) {
                return 0;
            }
        }
    }
    return 1;
}

int find_index(int* arr, int n, int target) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == target) {
            return i;
        }
    }
    return -1;
}

int count_swaps(int* original_indices, int* target_indices, int n) {
    int* arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = original_indices[i];
    }
    
    int swaps = 0;
    for (int i = 0; i < n; i++) {
        while (arr[i] != target_indices[i]) {
            int pos = find_index(arr, n, target_indices[i]);
            while (pos > i) {
                int temp = arr[pos];
                arr[pos] = arr[pos-1];
                arr[pos-1] = temp;
                pos--;
                swaps++;
            }
        }
    }
    
    free(arr);
    return swaps;
}

void swap_ints(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int next_permutation(int* arr, int n) {
    int i = n - 2;
    while (i >= 0 && arr[i] >= arr[i + 1]) {
        i--;
    }
    
    if (i < 0) {
        return 0;
    }
    
    int j = n - 1;
    while (arr[j] <= arr[i]) {
        j--;
    }
    
    swap_ints(&arr[i], &arr[j]);
    
    int left = i + 1, right = n - 1;
    while (left < right) {
        swap_ints(&arr[left], &arr[right]);
        left++;
        right--;
    }
    
    return 1;
}

int solution(int** grid, int n) {
    int* original_indices = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        original_indices[i] = i;
    }
    
    int min_swaps = INT_MAX;
    
    int* indices = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        indices[i] = i;
    }
    
    do {
        int** arrangement = malloc(n * sizeof(int*));
        for (int i = 0; i < n; i++) {
            arrangement[i] = grid[indices[i]];
        }
        
        if (is_valid(arrangement, n)) {
            int swaps = count_swaps(original_indices, indices, n);
            if (swaps < min_swaps) {
                min_swaps = swaps;
            }
        }
        
        free(arrangement);
    } while (next_permutation(indices, n));
    
    free(original_indices);
    free(indices);
    
    return min_swaps == INT_MAX ? -1 : min_swaps;
}

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[10000];
    fgets(line, sizeof(line), stdin);
    
    int n = 0;
    char* p = line;
    while (*p) {
        if (*p == '[' && *(p+1) != '[') n++;
        p++;
    }
    
    int** grid = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = malloc(n * sizeof(int));
    }
    
    p = line;
    int row = 0;
    while (*p && row < n) {
        if (*p == '[' && *(p+1) != '[') {
            char rowStr[1000];
            int len = 0;
            rowStr[len++] = '[';
            p++;
            while (*p && *p != ']') {
                rowStr[len++] = *p;
                p++;
            }
            if (*p == ']') {
                rowStr[len++] = *p;
                p++;
            }
            rowStr[len] = '\0';
            
            int size;
            parseArray(rowStr, grid[row], &size);
            row++;
        } else {
            p++;
        }
    }
    
    printf("%d\n", solution(grid, n));
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

Generate n! permutations, each requiring O(n²) validation and swap counting

⚠ Quadratic Growth

Space Complexity

O(n²)

Store grid copy and permutation arrays

⚠ Quadratic Space

23.5K Views

Medium Frequency

~25 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler