解题过程

:::info 题目链接
给你一个 m x n 的矩阵 M ，初始化时所有的 0 和一个操作数组 op ，其中 ops[i] = [ai, bi] 意味着当所有的 0 <= x < ai 和 0 <= y < bi 时， M[x][y] 应该加 1。

在 执行完所有操作后 ，计算并返回 矩阵中最大整数的个数 :::

  1. /**
  2.  * @link https://leetcode.cn/problems/range-addition-ii/
  3.  * @title 598. 范围求和 II
  4.  * @description 给你一个 m x n 的矩阵 M ，初始化时所有的 0 和一个操作数组 op ，其中 ops[i] = [ai, bi] 意味着当所有的 0 <= x < ai 和 0 <= y < bi 时， M[x][y] 应该加 1。
  5.  * 在 执行完所有操作后 ，计算并返回 矩阵中最大整数的个数
  6.  * @param {number} m
  7.  * @param {number} n
  8.  * @param {number[][]} ops
  9.  * @return {number}
  10.  */
  11. // 💡解法一：
  12. // 思路：遍历ops数组，然后在遍历ai，bi可执行范围的矩阵M加1，再遍历操作后的数组统计各个数组出现的值次数，获取数组中最大值及个数
  13. // ❌官方测试用例maxCount(39999, 39999, [19999,19999])报错（大概意思是堆内存溢出）：FATAL ERROR: Committing semi space failed. Allocation failed - JavaScript heap out of memory
  14. // 本地运行时可以的，可能官方有限制内存吧，这也说明，这种代码实现方式不友好，需要改进，所以需要优化其他代码方式实现才行
  15. // var maxCount = function (m, n, ops) {
  16. //   const res = []
  18. //   for (let i = 0; i < ops.length; i++) {
  19. //     const ai = ops[i][0]
  20. //     const bi = ops[i][1]
  22. //     for (let j = 0; j < ai; j++) {
  23. //       for (let e = 0; e < bi; e++) {
  24. //         if (!res[j]) {
  25. //           res[j] = new Array(n).fill(0)
  26. //           res[j][e]++
  27. //         } else {
  28. //           res[j][e]++
  29. //         }
  30. //       }
  31. //     }
  32. //   }
  34. //   // 寻找最大整数值及个数
  35. //   const flatArr = res.flat().sort((a, b) => b - a) // 获取最大值
  36. //   const numMap = new Map()
  37. //   for (let i = 0; i < res.length; i++) {
  38. //     for (let j = 0; j < res[i].length; j++) {
  39. //       if (numMap.has(res[i][j])) {
  40. //         numMap.set(res[i][j], numMap.get(res[i][j]) + 1)
  41. //       } else {
  42. //         numMap.set(res[i][j], 1)
  43. //       }
  44. //     }
  45. //   }
  47. //   // 注意操作数组为空的时候的默认最大整数最大值就是矩阵M个数
  48. //   return numMap.get(flatArr[0]) || m * n
  49. // }
  51. // 💡解法二：
  52. // 思路：求重叠的最小交集区域：只需找到最小的重叠区域即可，因为都是从(0, 0)点出发覆盖区域到(ai, bi)，那么只需找到最小值的(aiMin, biMin)即可
  53. var maxCount = function (m, n, ops) {
  54.   let aiMin = m
  55.   let biMin = n
  57.   for (let i = 0; i < ops.length; i++) {
  58.     // if (ops[i][0] < aiMin) {
  59.     //   aiMin = ops[i][0]
  60.     // }
  62.     // if (ops[i][1] < biMin) {
  63.     //   biMin = ops[i][1]
  65.     // }
  67.     aiMin = Math.min(ops[i][0], aiMin)
  68.     biMin = Math.min(ops[i][1], biMin)
  69.   }
  71.   return aiMin * biMin
  72. }
  75. const result = maxCount(3, 3, [[2,2],[3,3]]) // 4
  76. // const result = maxCount(3, 3, [[2, 2], [3, 3], [3, 3], [3, 3], [2, 2], [3, 3], [3, 3], [3, 3], [2, 2], [3, 3], [3, 3], [3, 3]]) // 4
  77. // const result = maxCount(3, 3, []) // 9
  78. // const result = maxCount(39999, 39999, [19999,19999]) // 1599920001
  79. console.log(result)

解题感受

想到了两种方法，第一种是本办法，以为只需要遍历所有情况计算即可，但是超出官方测试用例内存限制，不知道为啥，感觉思维还没有转变，因为最近做题没头绪的时候都会用本办法来做（穷举所有情况然后计算），没有挖掘题目更深层的含义和总结技巧规律，不过也有点难，需要多遇到类似的题型和尝试做多种解法的转换才能更好的灵活多变应用解决问题
对于类似的题型，跟昨晚做的图片平滑器也很相似，这样的二维数组，坐标(0,0)开始、重叠区域计算等关键信息是解题关键，下次需要多多注意了

参考答案