The K Weakest Rows in a Matrix

The K Weakest Rows in a Matrix - Problem

Imagine you're a military strategist analyzing the defensive strength of different battle formations. You have an m x n binary matrix representing a battlefield where 1's represent soldiers and 0's represent civilians.

The key insight is that soldiers always position themselves in front of civilians - meaning all 1's appear to the left of all 0's in each row.

Your mission: Identify the k weakest rows based on these rules:

A row is weaker if it has fewer soldiers
If two rows have the same number of soldiers, the one with the smaller index is weaker

Return the indices of the k weakest rows, ordered from weakest to strongest.

Example: If row 0 has 2 soldiers, row 1 has 1 soldier, and row 2 has 3 soldiers, and k=2, you'd return [1, 0] because row 1 is weakest (1 soldier), followed by row 0 (2 soldiers).

Input & Output

example_1.py — Basic Case

$ Input: mat = [[1,1,0,0,0],[1,1,1,1,0],[1,0,0,0,0],[1,1,0,0,0],[1,1,1,1,1]], k = 3

› Output: [2,0,3]

💡 Note: Row 2 has 1 soldier (weakest), row 0 has 2 soldiers, row 3 has 2 soldiers (but comes after row 0), so the 3 weakest are [2,0,3]

example_2.py — Tie Breaking

$ Input: mat = [[1,0,0,0],[1,1,1,1],[1,0,0,0],[1,0,0,0]], k = 2

› Output: [0,2]

💡 Note: Rows 0, 2, 3 all have 1 soldier each. Since we need k=2 weakest and there's a tie, we pick the ones with smaller indices: [0,2]

example_3.py — All Different

$ Input: mat = [[1,1,1],[1,1,0],[1,0,0]], k = 2

› Output: [2,1]

💡 Note: Row 2 has 1 soldier (weakest), row 1 has 2 soldiers (second weakest), row 0 has 3 soldiers (strongest)

Constraints

m == mat.length
n == mat[i].length
2 ≤ n, m ≤ 100
1 ≤ k ≤ m
matrix[i][j] is either 0 or 1
All 1's appear before all 0's in each row (soldiers before civilians)

Visualization

Tap to expand

Asked in

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

The optimal approach uses binary search to efficiently count soldiers in O(log n) per row, leveraging the fact that soldiers always appear before civilians. Combined with sorting, this gives us O(m log n + m log m) time complexity, which is better than the brute force O(m*n + m log m) for wide matrices.

Common Approaches

✓ Binary Search Optimization

⏱️ Time: O(m log n + m log m) Space: O(m)

Since soldiers (1's) always appear before civilians (0's) in each row, we can use binary search to find the first occurrence of 0, which gives us the soldier count. This optimizes the counting phase from O(n) to O(log n) per row.

Brute Force (Count and Sort)

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

The most straightforward approach: iterate through each row to count soldiers, pair each count with its row index, sort by strength, and return the first k indices.

Binary Search Optimization — Algorithm Steps

For each row, use binary search to find the first position of 0
The position gives us the count of soldiers (1's before it)
Store soldier count with row index
Sort pairs by soldier count and index
Return first k row indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Find first 0 position using binary search

Count Soldiers

Position gives soldier count

Sort Results

Sort by strength and index

Code -

solution.c — C

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

int countSoldiers(int* row, int rowSize) {
    int left = 0, right = rowSize;
    while (left < right) {
        int mid = (left + right) / 2;
        if (row[mid] == 1) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

typedef struct {
    int soldier_count;
    int index;
} RowStrength;

int compare(const void *a, const void *b) {
    RowStrength *rowA = (RowStrength*)a;
    RowStrength *rowB = (RowStrength*)b;
    if (rowA->soldier_count != rowB->soldier_count) {
        return rowA->soldier_count - rowB->soldier_count;
    }
    return rowA->index - rowB->index;
}

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* kWeakestRows(int** mat, int matSize, int* matColSize, int k, int* returnSize) {
    *returnSize = k;
    RowStrength* rows_strength = (RowStrength*)malloc(matSize * sizeof(RowStrength));
    for (int i = 0; i < matSize; i++) {
        rows_strength[i].soldier_count = countSoldiers(mat[i], matColSize[i]);
        rows_strength[i].index = i;
    }
    qsort(rows_strength, matSize, sizeof(RowStrength), compare);
    int* result = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < k; i++) {
        result[i] = rows_strength[i].index;
    }
    free(rows_strength);
    return result;
}

int main() {
    char matLine[100000];
    char kLine[100];
    
    fgets(matLine, sizeof(matLine), stdin);
    fgets(kLine, sizeof(kLine), stdin);
    int k = atoi(kLine);
    
    // Count rows
    int matSize = 0;
    char* p = matLine;
    int depth = 0;
    while (*p) {
        if (*p == '[') {
            depth++;
            if (depth == 2) matSize++;
        } else if (*p == ']') {
            depth--;
        }
        p++;
    }
    
    int** mat = (int**)malloc(matSize * sizeof(int*));
    int* matColSize = (int*)malloc(matSize * sizeof(int));
    
    p = matLine;
    while (*p && *p != '[') p++;
    p++;
    
    int rowIdx = 0;
    while (*p && rowIdx < matSize) {
        if (*p == '[') {
            char* rowEnd = strchr(p, ']');
            char rowStr[1000];
            int len = rowEnd - p + 1;
            strncpy(rowStr, p, len);
            rowStr[len] = '\0';
            mat[rowIdx] = (int*)malloc(100 * sizeof(int));
            parseArray(rowStr, mat[rowIdx], &matColSize[rowIdx]);
            rowIdx++;
            p = rowEnd + 1;
        } else {
            p++;
        }
    }
    
    int returnSize;
    int* result = kWeakestRows(mat, matSize, matColSize, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]");
    
    for (int i = 0; i < matSize; i++) free(mat[i]);
    free(mat);
    free(matColSize);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log n + m log m)

O(m log n) for binary search in m rows of length n, O(m log m) for sorting

⚡ Linearithmic

Space Complexity

O(m)

O(m) space to store soldier counts and indices

✓ Linear Space

58.0K Views

Medium Frequency

~15 min Avg. Time

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

Binary Search Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler