598_范围求和(II)_2021.11.7

给定一个初始元素全部为 0，大小为 m*n 的矩阵 M 以及在 M 上的一系列更新操作。

操作用二维数组表示，其中的每个操作用一个含有两个正整数 a 和 b 的数组表示，含义是将所有符合 0 <= i < a 以及 0 <= j < b 的元素 M[i][j] 的值都增加 1。

在执行给定的一系列操作后，你需要返回矩阵中含有最大整数的元素个数。

 

一开始不想进行过多思考，直接依照题目思路，3重FOR循环拉满，结果可想而知的运行超时了：

int maxCount(int m, int n, vector<vector<int>>& ops) {
        
        // 二维数组初始化学习
        vector<vector<int> > matrix(m, vector<int>(n, 0));

        int max = 0; //记录矩阵中的最大值
        int total = 0;

        for (auto i = ops.begin(); i != ops.end(); i++) {
            int rows = i->at(0);
            int cols = i->at(1);

            for (int k = 0; k < rows; k++)
            {
                for (int s = 0; s < cols; s++) {
                    matrix[k][s] += 1;

                    max = max > matrix[k][s] ? max : matrix[k][s];
                }
            }
        }

        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (matrix[i][j] == max)
                {
                    total++;
                }
            }
        }
        

        return total;
    }

 

思考之后发现每一个元素的 +1 操作其实都是从(0,0)开始操作的，那我只需要记录每一次进行过该操作的元素就行了，有点像层次叠加的模型过程，所以便有了如下代码，

（值得注意的是这里调整BUG我调整了很久，为了方便自己以后查看，特别红色注明：

　　我在取值过程中leetcode总是提示我代码问题，但是vs2017没有类似问题，即leetcode中无法取到ops[0][0]这样的数值，而vs2017则可以，后续可能值得注意。）

int maxCount2(int m, int n, vector<vector<int>>& ops) {
        int total = 0;

        int rowsOpeEle = m;
        int colsOpeEle = n;

        if(ops.empty())
            return m * n;
        
        for (auto e : ops) {
            int tmpRow = e[0];
            int tmpCol = e[1];

            if(tmpRow < rowsOpeEle) {
                rowsOpeEle = tmpRow;
            }

            if(tmpCol < colsOpeEle) {
                colsOpeEle = tmpCol;
            }

            total = rowsOpeEle * colsOpeEle;
        }

        return total;
    }    

 

再参考了一下题解答案，代码优雅度和简洁度方面还是存在差距，但是思考的方式还是没有问题：

int maxCount3(int m, int n, vector<vector<int>>& ops) {
        int mina = m,minb = n;

        for (const auto& op : ops)
        {
            mina = min(mina, op[0]);
            minb = min(minb, op[1]);
        }

        return mina * minb;
    }