Question

2711. 对角线上不同值的数量差

English Version

题目描述

给你一个下标从 0 开始、大小为 m x n 的二维矩阵 grid ，请你求解大小同样为 m x n 的答案矩阵 answer 。

矩阵 answer 中每个单元格 (r, c) 的值可以按下述方式进行计算：

• 令 topLeft[r][c] 为矩阵 grid 中单元格 (r, c) 左上角对角线上 不同值 的数量。
• 令 bottomRight[r][c] 为矩阵 grid 中单元格 (r, c) 右下角对角线上 不同值 的数量。

然后 answer[r][c] = |topLeft[r][c] - bottomRight[r][c]| 。

返回矩阵 answer 。

矩阵对角线 是从最顶行或最左列的某个单元格开始，向右下方向走到矩阵末尾的对角线。

如果单元格 (r1, c1) 和单元格 (r, c)属于同一条对角线且 r1 < r ，则单元格 (r1, c1) 属于单元格 (r, c) 的左上对角线。类似地，可以定义右下对角线。

 

示例 1：

输入：grid = [[1,2,3],[3,1,5],[3,2,1]]
输出：[[1,1,0],[1,0,1],[0,1,1]]
解释：第 1 个图表示最初的矩阵 grid 。 
第 2 个图表示对单元格 (0,0) 计算，其中蓝色单元格是位于右下对角线的单元格。
第 3 个图表示对单元格 (1,2) 计算，其中红色单元格是位于左上对角线的单元格。
第 4 个图表示对单元格 (1,1) 计算，其中蓝色单元格是位于右下对角线的单元格，红色单元格是位于左上对角线的单元格。
- 单元格 (0,0) 的右下对角线包含 [1,1] ，而左上对角线包含 [] 。对应答案是 |1 - 0| = 1 。
- 单元格 (1,2) 的右下对角线包含 [] ，而左上对角线包含 [2] 。对应答案是 |0 - 1| = 1 。
- 单元格 (1,1) 的右下对角线包含 [1] ，而左上对角线包含 [1] 。对应答案是 |1 - 1| = 0 。
其他单元格的对应答案也可以按照这样的流程进行计算。

示例 2：

输入：grid = [[1]]
输出：[[0]]
解释：- 单元格 (0,0) 的右下对角线包含 [] ，左上对角线包含 [] 。对应答案是 |0 - 0| = 0 。

 

提示：

• m == grid.length
• n == grid[i].length
• 1 <= m, n, grid[i][j] <= 50

解法

方法一

class Solution:
  def differenceOfDistinctValues(self, grid: List[List[int]]) -> List[List[int]]:
    m, n = len(grid), len(grid[0])
    ans = [[0] * n for _ in range(m)]
    for i in range(m):
      for j in range(n):
        x, y = i, j
        s = set()
        while x and y:
          x, y = x - 1, y - 1
          s.add(grid[x][y])
        tl = len(s)
        x, y = i, j
        s = set()
        while x + 1 < m and y + 1 < n:
          x, y = x + 1, y + 1
          s.add(grid[x][y])
        br = len(s)
        ans[i][j] = abs(tl - br)
    return ans

class Solution {
  public int[][] differenceOfDistinctValues(int[][] grid) {
    int m = grid.length, n = grid[0].length;
    int[][] ans = new int[m][n];
    for (int i = 0; i < m; ++i) {
      for (int j = 0; j < n; ++j) {
        int x = i, y = j;
        Set<Integer> s = new HashSet<>();
        while (x > 0 && y > 0) {
          s.add(grid[--x][--y]);
        }
        int tl = s.size();
        x = i;
        y = j;
        s.clear();
        while (x < m - 1 && y < n - 1) {
          s.add(grid[++x][++y]);
        }
        int br = s.size();
        ans[i][j] = Math.abs(tl - br);
      }
    }
    return ans;
  }
}

class Solution {
public:
  vector<vector<int>> differenceOfDistinctValues(vector<vector<int>>& grid) {
    int m = grid.size(), n = grid[0].size();
    vector<vector<int>> ans(m, vector<int>(n));
    for (int i = 0; i < m; ++i) {
      for (int j = 0; j < n; ++j) {
        int x = i, y = j;
        unordered_set<int> s;
        while (x > 0 && y > 0) {
          s.insert(grid[--x][--y]);
        }
        int tl = s.size();
        x = i;
        y = j;
        s.clear();
        while (x < m - 1 && y < n - 1) {
          s.insert(grid[++x][++y]);
        }
        int br = s.size();
        ans[i][j] = abs(tl - br);
      }
    }
    return ans;
  }
};

func differenceOfDistinctValues(grid [][]int) [][]int {
  m, n := len(grid), len(grid[0])
  ans := make([][]int, m)
  for i := range grid {
    ans[i] = make([]int, n)
    for j := range grid[i] {
      x, y := i, j
      s := map[int]bool{}
      for x > 0 && y > 0 {
        x, y = x-1, y-1
        s[grid[x][y]] = true
      }
      tl := len(s)
      x, y = i, j
      s = map[int]bool{}
      for x+1 < m && y+1 < n {
        x, y = x+1, y+1
        s[grid[x][y]] = true
      }
      br := len(s)
      ans[i][j] = abs(tl - br)
    }
  }
  return ans
}

func abs(x int) int {
  if x < 0 {
    return -x
  }
  return x
}

function differenceOfDistinctValues(grid: number[][]): number[][] {
  const m = grid.length;
  const n = grid[0].length;
  const ans: number[][] = Array(m)
    .fill(0)
    .map(() => Array(n).fill(0));
  for (let i = 0; i < m; ++i) {
    for (let j = 0; j < n; ++j) {
      let [x, y] = [i, j];
      const s = new Set<number>();
      while (x && y) {
        s.add(grid[--x][--y]);
      }
      const tl = s.size;
      [x, y] = [i, j];
      s.clear();
      while (x + 1 < m && y + 1 < n) {
        s.add(grid[++x][++y]);
      }
      const br = s.size;
      ans[i][j] = Math.abs(tl - br);
    }
  }
  return ans;
}