Formatted question description: https://leetcode.ca/all/1337.html

# 1337. The K Weakest Rows in a Matrix

## Level

Easy

## Description

Given a `m * n`

matrix `mat`

of *ones* (representing soldiers) and *zeros* (representing civilians), return the indexes of the `k`

weakest rows in the matrix ordered from the weakest to the strongest.

A row ** i** is weaker than row

**, if the number of soldiers in row**

*j***is less than the number of soldiers in row**

*i***, or they have the same number of soldiers but**

*j***is less than**

*i***. Soldiers are**

*j***always**stand in the frontier of a row, that is, always

*ones*may appear first and then

*zeros*.

**Example 1:**

```
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]
Explanation:
The number of soldiers for each row is:
row 0 -> 2
row 1 -> 4
row 2 -> 1
row 3 -> 2
row 4 -> 5
Rows ordered from the weakest to the strongest are [2,0,3,1,4]
```

**Example 2:**

```
Input: mat =
[[1,0,0,0],
[1,1,1,1],
[1,0,0,0],
[1,0,0,0]],
k = 2
Output: [0,2]
Explanation:
The number of soldiers for each row is:
row 0 -> 1
row 1 -> 4
row 2 -> 1
row 3 -> 1
Rows ordered from the weakest to the strongest are [0,2,3,1]
```

**Constraints:**

`m == mat.length`

`n == mat[i].length`

`2 <= n, m <= 100`

`1 <= k <= m`

`matrix[i][j]`

is either 0**or**1.

## Solution

For each row in `mat`

, obtain the number of soldiers. Use a 2D array to store each row’s index and the number of soldiers. Sort the 2D array according to the number of soldiers in ascending order then according to the indices in ascending order. After sorting, use an array to store the indices of the first `k`

rows, and return.

```
class Solution {
public int[] kWeakestRows(int[][] mat, int k) {
if (mat == null || mat.length == 0 || mat[0].length == 0)
return new int[0];
int rows = mat.length, columns = mat[0].length;
int[][] indexCount = new int[rows][2];
for (int i = 0; i < rows; i++) {
int rowCount = 0;
for (int j = 0; j < columns; j++) {
if (mat[i][j] == 1)
rowCount++;
else
break;
}
indexCount[i][0] = i;
indexCount[i][1] = rowCount;
}
Arrays.sort(indexCount, new Comparator<int[]>() {
public int compare(int[] array1, int[] array2) {
if (array1[1] != array2[1])
return array1[1] - array2[1];
else
return array1[0] - array2[0];
}
});
int[] kWeakest = new int[k];
for (int i = 0; i < k; i++)
kWeakest[i] = indexCount[i][0];
return kWeakest;
}
}
```