矩阵稀疏扫描 - 矩阵

系列文章目录

---

前言

本人最近再练习算法，所以会发布一些解题思路，希望大家多指教

一、题目描述

如果矩阵中的许多系数都为零，那么该矩阵就是稀疏的。对稀疏现象有兴趣是因为它的开发可以带来巨大的计算节省，并且在许多大的实践中都会出现矩阵稀疏的问题。

给定一个矩阵，现在需要逐行和逐列地扫描矩阵，如果某一行或者某一列内，存在连续出现的0的个数超过了行宽或者列宽的一半，则认为该行或者该列是稀疏的。

二、输入描述

第一行输入两个数，分别为M和N

接下来M行输入为矩阵的成员，每行N个成员，矩阵成员都是整数，范围-32768~32767

三、输出描述

输出两行，第一行表示稀疏行的个数，第二行表示稀疏列的个数。

四、Java代码

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 行的数量
        int M = sc.nextInt();
        // 列的数量
        int N = sc.nextInt();
        // 正矩阵（行是行，列是列）
        int[][] rowArr = new int[M][N];
        //通过二维数组接受矩阵信息
        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                rowArr[i][j] = sc.nextInt();
            }
        }

        //初始化满足稀疏列的行数
        int rowTimes = 0;
        //初始化满足稀疏行的行数
        int colTime = 0;
        //初始化每行最大连续0的个数
        int maxRowCount = 0;
        //初始化每行连续0的个数
        int rowCount = 1;

        for (int i = 0; i < M; i++) {
            for (int j = 0; j < N; j++) {
                if(rowArr[i][j] == 0){
                    if(j+1 < N && rowArr[i][j+1] == 0){
                        rowCount++;
                    }
                    maxRowCount = Math.max(rowCount, maxRowCount);
                }else {
                    //连续0区间被断开，将rowCount重置为1
                    rowCount = 1;
                }
                //列的处理，只需要在遍历第一行数据时，通过深度搜索进行判断
                if (i==0){
                    dfs(rowArr, i, j, M, 0);
                    if(maxColCount > M/2){
                        colTime++;
                    }
                    //每列遍历结束后，将maxColcount重置为0
                    maxColCount = 0;
                }
            }
            if(maxRowCount > N/2){
                rowTimes++;
            }
            //每行遍历结束后，将maxCount，rowCount进行重置
            maxRowCount = 0;
            rowCount = 1;
        }
        System.out.println("稀疏行的个数："+rowTimes);
        System.out.println("稀疏列的个数："+colTime);
    }

    static int maxColCount = 0;
    private static void dfs(int[][] rowArr, int i, int j, int m, int count) {
        if(rowArr[i][j] == 0) count++;
        maxColCount = Math.max(maxColCount, count);
        if(i+1 < m){
            if(rowArr[i+1][j] == 1){
                //连续0区间被断开，将count重置为1
                count = 0;
            }
            dfs(rowArr, i+1, j, m, count);
        }
    }

五、测试用例

输入：
7 6
1 1 0 1 1 0
0 1 0 0 0 1
1 0 0 0 1 0
1 0 0 0 0 0
0 1 1 0 0 0
1 0 0 0 0 1
1 0 0 0 0 1
输出：

提示

也可以通过，矩阵反转来处理列的数据，本人有点偷懒，所以就直接在处理第一行元素的时候，顺便处理了列的数据。