力扣每日一题3242：设计相邻元素求和服务

题目描述：

给你一个 n x n 的二维数组 grid，它包含范围 [0, n2 - 1] 内的不重复元素。

实现 neighborSum 类：

• neighborSum(int [][]grid) 初始化对象。
• int adjacentSum(int value) 返回在 grid 中与 value 相邻的元素之和，相邻指的是与 value 在上、左、右或下的元素。
• int diagonalSum(int value) 返回在 grid 中与 value 对角线相邻的元素之和，对角线相邻指的是与 value 在左上、右上、左下或右下的元素。

示例 1：

输入：

["neighborSum", "adjacentSum", "adjacentSum", "diagonalSum", "diagonalSum"]

[[[[0, 1, 2], [3, 4, 5], [6, 7, 8]]], [1], [4], [4], [8]]

输出： [null, 6, 16, 16, 4]

解释：

• 1 的相邻元素是 0、2 和 4。
• 4 的相邻元素是 1、3、5 和 7。
• 4 的对角线相邻元素是 0、2、6 和 8。
• 8 的对角线相邻元素是 4。

示例 2：

输入：

["neighborSum", "adjacentSum", "diagonalSum"]

[[[[1, 2, 0, 3], [4, 7, 15, 6], [8, 9, 10, 11], [12, 13, 14, 5]]], [15], [9]]

输出： [null, 23, 45]

解释：

• 15 的相邻元素是 0、10、7 和 6。
• 9 的对角线相邻元素是 4、12、14 和 15。

提示：

• 3 <= n == grid.length == grid[0].length <= 10
• 0 <= grid[i][j] <= n2 - 1
• 所有 grid[i][j] 值均不重复。
• adjacentSum 和 diagonalSum 中的 value 均在范围 [0, n2 - 1] 内。
• 最多会调用 adjacentSum 和 diagonalSum 总共 2 * n2 次。

解题思路  

• 类定义：NeighborSum类包含一个构造函数，用于初始化网格及其行列数。
• 搜索值：search_value函数遍历网格，寻找指定值的位置，并返回其坐标。如果未找到，则返回(-1, -1)。
• 相邻和计算：adjacentSum函数调用search_value获取指定值的位置，然后计算其相邻元素的和。
• 对角线和计算：diagonalSum函数类似地调用search_value获取位置，然后计算其对角线元素的和。
• 测试代码：在main函数中创建一个示例网格，并测试adjacentSum和diagonalSum函数。

代码实现

class NeighborSum {
public:
    NeighborSum(const vector<vector<int>>& grid) : grid(grid), rawlen(grid.size()), collen(grid[0].size()) {}

    pair<int, int> search_value(int value) const {
        for (int i = 0; i < rawlen; ++i) {
            for (int j = 0; j < collen; ++j) {
                if (grid[i][j] == value) {
                    return {i, j}; // 返回行和列的索引
                }
            }
        }
        return {-1, -1}; // 如果未找到值，返回 (-1, -1)
    }

    int adjacentSum(int value) const {
        auto [x, y] = search_value(value);
        if (x == -1 && y == -1) {
            return 0; // 如果未找到值，返回 0
        }

        vector<pair<int, int>> adj = {{x-1, y}, {x, y-1}, {x, y+1}, {x+1, y}};
        int total = 0;
        for (auto& [a, b] : adj) {
            if (a >= 0 && a < rawlen && b >= 0 && b < collen) {
                total += grid[a][b];
            }
        }
        return total;
    }

    int diagonalSum(int value) const {
        auto [x, y] = search_value(value);
        if (x == -1 && y == -1) {
            return 0; // 如果未找到值，返回 0
        }

        vector<pair<int, int>> dia = {{x-1, y-1}, {x-1, y+1}, {x+1, y-1}, {x+1, y+1}};
        int total = 0;
        for (auto& [a, b] : dia) {
            if (a >= 0 && a < rawlen && b >= 0 && b < collen) {
                total += grid[a][b];
            }
        }
        return total;
    }

private:
    vector<vector<int>> grid;
    int rawlen; // 行数
    int collen; // 列数
};