You are given an m x n matrix M initialized with all 0's and an array of operations ops, where ops[i] = [ai, bi] means M[x][y] should be incremented by one for all 0 &lt;= x &lt; ai and 0 &lt;= y &lt; bi.

Count and return the number of maximum integers in the matrix after performing all the operations.

&nbsp;
Example 1:

Input: m = 3, n = 3, ops = [[2,2],[3,3]]
Output: 4
Explanation: The maximum integer in M is 2, and there are four of it in M. So return 4.


Example 2:

Input: m = 3, n = 3, ops = [[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3],[2,2],[3,3],[3,3],[3,3]]
Output: 4


Example 3:

Input: m = 3, n = 3, ops = []
Output: 9


&nbsp;
Constraints:


	1 &lt;= m, n &lt;= 4 * 104
	0 &lt;= ops.length &lt;= 104
	ops[i].length == 2
	1 &lt;= ai &lt;= m
	1 &lt;= bi &lt;= n


class Solution:
    def maxCount(self, m: int, n: int, ops: List[List[int]]) -> int:
        if not ops:
            return m*n
        else:
            x,y = zip(*ops)
            return min(x) * min(y)
class Solution {
    public int maxCount(int m, int n, int[][] ops) {
        int minRow=m,minCol=n;
        for(int[] op:ops){
            minRow=Math.min(minRow,op[0]);
            minCol=Math.min(minCol,op[1]);
        }
        return minRow*minCol;
    }
}
class Solution {
public:
    int maxCount(int m, int n, vector<vector<int>>& ops) {

        int mn_i = m, mn_j = n;
        for(auto &i : ops)
            mn_i = min(mn_i, i[0]), mn_j = min(mn_j, i[1]);

        return mn_i * mn_j;
    }
};
var maxCount = function(m, n, ops) {
    if( ops.length === 0 )
        return m*n
    let min_a = m , min_b = n
    for( let [x,y] of ops ){
        if( x < min_a )
            min_a = x
        if( y < min_b )
            min_b = y
    }
    return min_a * min_b
};
Range Addition II