Count Negative Numbers in a Sorted Matrix

Count Negative Numbers in a Sorted Matrix - Problem

You are given an m x n matrix grid that is sorted in non-increasing order both row-wise and column-wise. This means each row reads from largest to smallest (left to right), and each column also reads from largest to smallest (top to bottom).

Your task is to efficiently count how many negative numbers exist in this sorted matrix.

Example: In the matrix [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]], there are 8 negative numbers.

The key insight is leveraging the sorted property to avoid checking every single element - can you find a way to count negatives faster than O(m×n)?

Input & Output

example_1.py — Standard 4x4 Matrix

$ Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]

› Output: 8

💡 Note: There are 8 negative numbers in the matrix: the -1 in positions (0,3) and (1,3), the -1 and -2 in positions (2,2) and (2,3), and all four numbers in the last row are negative.

example_2.py — Single Row Matrix

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

› Output: 0

💡 Note: All numbers in the matrix are positive, so there are no negative numbers to count.

example_3.py — All Negative Matrix

$ Input: grid = [[-1,-2],[-3,-4]]

› Output: 4

💡 Note: All numbers in the 2x2 matrix are negative, so we count all 4 elements.

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 100
-100 ≤ grid[i][j] ≤ 100
grid is sorted in non-increasing order both row-wise and column-wise

Visualization

Tap to expand

Understanding the Visualization

Start at the boundary

Begin at top-right where temperature transitions happen

Make smart decisions

If current reading is below freezing, all readings below it are also below freezing

Follow the staircase

Move left when cold, move down when hot, tracing the freeze line

Key Takeaway

🎯 Key Insight: The sorted property creates a natural boundary between positive and negative regions. By walking this boundary instead of checking every cell, we can count negatives in optimal O(m+n) time!

Asked in

a Amazon 45 ⊞ Microsoft 38 G Google 32 f Meta 28

The optimal solution uses the two-pointers staircase search technique, starting from the top-right corner. When we encounter a negative number, we can count all elements below it in that column (since the matrix is sorted). This achieves O(m + n) time complexity by making at most m+n moves, significantly better than the O(m×n) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search Each Row	O(m × log n)	O(1)	Use binary search to find the first negative number in each row
Two Pointers (Staircase Search)	O(m + n)	O(1)	Start from top-right corner and move strategically using the sorted property
Brute Force (Check Every Element)	O(m × n)	O(1)	Iterate through every element in the matrix and count negatives

Binary Search Each Row — Algorithm Steps

Initialize total count to 0
For each row in the matrix
Use binary search to find the first negative number in that row
If found, add (total columns - first negative index) to count
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary search first row

Find first negative position in [4,3,2,-1]

Count negatives from position

From position 3 to end, count 1 negative

Repeat for all rows

Apply same logic to remaining rows

Code -

solution.c — C

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

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

int countNegatives(int** grid, int gridSize, int* gridColSize) {
    int count = 0;
    int n = gridSize > 0 ? gridColSize[0] : 0;
    
    for (int i = 0; i < gridSize; i++) {
        int firstNegIdx = findFirstNegative(grid[i], gridColSize[i]);
        count += n - firstNegIdx;
    }
    
    return count;
}

int main() {
    int grid[4][4] = {{4,3,2,-1},{3,2,1,-1},{1,1,-1,-2},{-1,-1,-2,-3}};
    int* gridRows[4];
    int gridColSize[4] = {4,4,4,4};
    for (int i = 0; i < 4; i++) {
        gridRows[i] = grid[i];
    }
    printf("%d\n", countNegatives(gridRows, 4, gridColSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × log n)

We perform binary search (log n) on each of the m rows

⚡ Linearithmic

Space Complexity

O(1)

Only using variables for binary search, no additional data structures

✓ Linear Space

68.4K Views

Medium Frequency

~15 min Avg. Time

2.2K 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 Each Row — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler