1351. 统计有序矩阵中的负数

最新推荐文章于 2025-08-02 21:22:58 发布

原创最新推荐文章于 2025-08-02 21:22:58 发布 · 357 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#二分查找

每日刷题专栏收录该内容

302 篇文章

订阅专栏

该博客探讨了一种解决统计有序矩阵中负数数量的方法，包括暴力遍历和二分查找两种策略。时间复杂度分别分析为O(n*m)和O(nlogm)，并提出了O(n+m)的进阶解决方案。通过倒序搜索，可以在更短的时间内完成任务。

1351. 统计有序矩阵中的负数https://leetcode.cn/problems/count-negative-numbers-in-a-sorted-matrix/

难度简单96

给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。请你统计并返回 grid 中负数的数目。

示例 1：

输入：grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
输出：8
解释：矩阵中共有 8 个负数。

示例 2：

输入：grid = [[3,2],[1,0]]
输出：0

提示：

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

方法一：【暴力遍历】

时间复杂度：O(n*m) 遍历整个矩阵的总个数。空间复杂度：O(1)。

方法二：【二分查找】循环遍历每一行，在每一行中使用二分查找来找到正数与负数的边界。

时间复杂度：遍历每一行：O(n) 在每一行中二分查找：O(logm) 总时间复杂度：O(nlogm)

空间复杂度：O(1)。

class Solution {
    public int countNegatives(int[][] grid) {

        int ans = 0;

        for(int i=0;i<grid.length;i++)
        {
                if(grid[i][0]<0) continue;
                if(grid[i][grid[0].length-1]>=0)
                {
                    ans+=grid[0].length;
                    continue;
                }
                //二分查找
                int start = 0;
                int end = grid[0].length-1;
                int mid;
                while(start<=end)
                {
                    mid = (end-start)/2+start;
                    if(grid[i][mid]>=0 && grid[i][mid+1]<0)
                    {
                        
                        System.out.println(mid);
                        ans+=(mid+1);
                        break;
                    } 
                    else if(grid[i][mid]>=0) start = mid+1;
                    else end = mid-1;
                }
        }

        return grid.length*grid[0].length -ans;

    }
}

进阶：你可以设计一个时间复杂度为 O(n + m) 的解决方案吗？

倒序搜索：

时间复杂度：遍历n行的时间复杂度为O(n)，负数倒序只遍历一遍，总的时间复杂度为O(n+m)

空间复杂度：O(1)

class Solution {
    public int countNegatives(int[][] grid) {

        //倒序搜索
        int ans = 0;
        int j=grid[0].length-1;
        for(int i=0;i<grid.length;i++)
        {    
            while(j>=0)
            {
                if(grid[i][j]<0 && j==0)
                {
                    ans+=grid[0].length;
                    break;
                }
                if(grid[i][j]<0) j--;
                else
                {
                    System.out.println(j);
                    ans+= grid[0].length-(j+1);
                    break;
                }
            }
        }
        
        return ans;

    }
}