##### Welcome to Subscribe On Youtube

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

# 1351. Count Negative Numbers in a Sorted Matrix (Easy)

Given a m * n matrix grid which is sorted in non-increasing order both row-wise and column-wise.

Return the number of negative numbers in grid.

Example 1:

Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
Output: 8
Explanation: There are 8 negatives number in the matrix.


Example 2:

Input: grid = [[3,2],[1,0]]
Output: 0


Example 3:

Input: grid = [[1,-1],[-1,-1]]
Output: 3


Example 4:

Input: grid = [[-1]]
Output: 1


Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 100
• -100 <= grid[i][j] <= 100

Related Topics:
Array, Binary Search

## Solution 1. Brute Force

// OJ: https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/
// Time: O(MN)
// Space: O(1)
class Solution {
public:
int countNegatives(vector<vector<int>>& grid) {
int ans = 0;
for (auto &row : grid) {
for (int c : row) {
if (c < 0) ++ans;
}
}
return ans;
}
};

// OJ: https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/
// Time: O(MlogN)
// Space: O(1)
class Solution {
public:
int countNegatives(vector<vector<int>>& grid) {
int ans = 0;
for (auto &row : grid) {
ans += upper_bound(row.rbegin(), row.rend(), -1) - row.rbegin();
}
return ans;
}
};


## Solution 3. Search Break Points

Traverse from upper right to lower left.

// OJ: https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/
// Time: O(M+N)
// Space: O(1)
class Solution {
public:
int countNegatives(vector<vector<int>>& grid) {
int M = grid.size(), N = grid[0].size(), x = 0, y = N - 1, ans = 0;
while (x < M) {
while (y >= 0 && grid[x][y] < 0) --y;
ans += N - 1 - y;
++x;
}
return ans;
}
};

• class Solution {
public int countNegatives(int[][] grid) {
int count = 0;
int rows = grid.length, columns = grid[0].length;
for (int i = rows - 1; i >= 0; i--) {
if (grid[i][columns - 1] >= 0)
break;
for (int j = columns - 1; j >= 0; j--) {
if (grid[i][j] < 0)
count++;
else
break;
}
}
return count;
}
}

############

class Solution {
public int countNegatives(int[][] grid) {
int m = grid.length, n = grid[0].length;
int ans = 0;
for (int i = m - 1, j = 0; i >= 0 && j < n;) {
if (grid[i][j] < 0) {
ans += n - j;
--i;
} else {
++j;
}
}
return ans;
}
}

• // OJ: https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix/
// Time: O(MN)
// Space: O(1)
class Solution {
public:
int countNegatives(vector<vector<int>>& grid) {
int ans = 0;
for (auto &row : grid) {
for (int c : row) {
if (c < 0) ++ans;
}
}
return ans;
}
};

• class Solution:
def countNegatives(self, grid: List[List[int]]) -> int:
m, n = len(grid), len(grid[0])
i, j = m - 1, 0
ans = 0
while i >= 0 and j < n:
if grid[i][j] < 0:
ans += n - j
i -= 1
else:
j += 1
return ans


• func countNegatives(grid [][]int) int {
m, n := len(grid), len(grid[0])
ans := 0
for i, j := m-1, 0; i >= 0 && j < n; {
if grid[i][j] < 0 {
ans += n - j
i--
} else {
j++
}
}
return ans
}

• function countNegatives(grid: number[][]): number {
const m = grid.length,
n = grid[0].length;
let ans = 0;
for (let i = m - 1, j = 0; i >= 0 && j < n; ) {
if (grid[i][j] < 0) {
ans += n - j;
--i;
} else {
++j;
}
}
return ans;
}


• /**
* @param {number[][]} grid
* @return {number}
*/
var countNegatives = function (grid) {
const m = grid.length,
n = grid[0].length;
let ans = 0;
for (let i = m - 1, j = 0; i >= 0 && j < n; ) {
if (grid[i][j] < 0) {
ans += n - j;
--i;
} else {
++j;
}
}
return ans;
};


• impl Solution {
pub fn count_negatives(grid: Vec<Vec<i32>>) -> i32 {
let m = grid.len();
let n = grid[0].len();
let mut i = m;
let mut j = 0;
let mut res = 0;
while i > 0 && j < n {
if grid[i - 1][j] >= 0 {
j += 1;
} else {
res += n - j;
i -= 1;
}
}
res as i32
}
}