class neighborSum {
public:
neighborSum(vector<vector<int>>& grid) {
}
int adjacentSum(int value) {
}
int diagonalSum(int value) {
}
};
/**
* Your neighborSum object will be instantiated and called as such:
* neighborSum* obj = new neighborSum(grid);
* int param_1 = obj->adjacentSum(value);
* int param_2 = obj->diagonalSum(value);
*/
use std::collections::HashMap;
const dirs: [ &[(i32, i32)]; 2] = [
&[(-1, 0), (1, 0), (0, -1), (0, 1)],
&[(-1, -1), (-1, 1), (1, -1), (1, 1)],
];
struct NeighborSum {
grid: Vec<Vec<i32>>,
pos: HashMap<i32, (usize, usize)>,
}
/**
* `&self` means the method takes an immutable reference.
* If you need a mutable reference, change it to `&mut self` instead.
*/
impl NeighborSum {
fn new(grid: Vec<Vec<i32>>) -> Self {
let mut pos = HashMap::new();
for (i, row) in grid.iter().enumerate() {
for (j, &val) in row.iter().enumerate() {
pos.insert(val, (i, j));
}
}
NeighborSum { grid, pos }
}
fn adjacent_sum(&self, value: i32) -> i32 {
self.get_sum(value, 0)
}
fn diagonal_sum(&self, value: i32) -> i32 {
self.get_sum(value, 1)
}
fn get_sum(&self, value: i32, idx: usize) -> i32 {
if let Some(&(x, y)) = self.pos.get(&value) {
let mut sum = 0;
for &(dx, dy) in dirs[idx] {
let nx = x as i32 + dx;
let ny = y as i32 + dy;
if nx >= 0 && (nx as usize) < self.grid.len() && ny >= 0 && (ny as usize) < self.grid[0].len() {
sum += self.grid[nx as usize][ny as usize];
}
}
sum
} else {
0
}
}
}
/**
* Your neighborSum object will be instantiated and called as such:
* let obj = neighborSum::new(grid);
* let ret_1: i32 = obj.adjacent_sum(value);
* let ret_2: i32 = obj.diagonal_sum(value);
*/
class neighborSum {
static constexpr int dirs[8][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {1, 1}, {-1, 1}, {-1, -1}, {1, -1}};
vector<array<int, 2>> s;
public:
neighborSum(vector<vector<int>>& grid) {
int n = grid.size();
s.resize(n * n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int v = grid[i][j];
for (int k = 0; k < 8; k++) {
int x = i + dirs[k][0], y = j + dirs[k][1];
if (0 <= x && x < n && 0 <= y && y < n) {
s[v][k / 4] += grid[x][y];
}
}
}
}
}
int adjacentSum(int value) {
return s[value][0];
}
int diagonalSum(int value) {
return s[value][1];
}
};
/**
* Your neighborSum object will be instantiated and called as such:
* neighborSum* obj = new neighborSum(grid);
* int param_1 = obj->adjacentSum(value);
* int param_2 = obj->diagonalSum(value);
*/
class neighborSum {
private static final int[][] DIRS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {1, 1}, {-1, 1}, {-1, -1}, {1, -1}};
private final int[][] s;
public neighborSum(int[][] grid) {
int n = grid.length;
s = new int[n * n][2];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int v = grid[i][j];
for (int k = 0; k < 8; k++) {
int x = i + DIRS[k][0];
int y = j + DIRS[k][1];
if (0 <= x && x < n && 0 <= y && y < n) {
s[v][k / 4] += grid[x][y];
}
}
}
}
}
public int adjacentSum(int value) {
return s[value][0];
}
public int diagonalSum(int value) {
return s[value][1];
}
}
/**
* Your neighborSum object will be instantiated and called as such:
* neighborSum obj = new neighborSum(grid);
* int param_1 = obj.adjacentSum(value);
* int param_2 = obj.diagonalSum(value);
*/
var dirs = []struct{ x, y int }{{-1, 0}, {1, 0}, {0, -1}, {0, 1}, {1, 1}, {-1, 1}, {-1, -1}, {1, -1}}
type neighborSum [][2]int
func Constructor(grid [][]int) neighborSum {
n := len(grid)
s := make(neighborSum, n*n)
for i, row := range grid {
for j, v := range row {
for k, d := range dirs {
x, y := i+d.x, j+d.y
if 0 <= x && x < n && 0 <= y && y < n {
s[v][k/4] += grid[x][y]
}
}
}
}
return s
}
func (s neighborSum) AdjacentSum(value int) int {
return s[value][0]
}
func (s neighborSum) DiagonalSum(value int) int {
return s[value][1]
}
/**
* Your neighborSum object will be instantiated and called as such:
* obj := Constructor(grid);
* param_1 := obj.AdjacentSum(value);
* param_2 := obj.DiagonalSum(value);
*/
# 偏移向量，前四：上下左右，后四：右上、左上、左下、右下
DIRS = ((-1, 0), (1, 0), (0, -1), (0, 1), (1, 1), (-1, 1), (-1, -1), (1, -1))
class neighborSum:
def __init__(self, grid: List[List[int]]):
n = len(grid)
s = [[0, 0] for _ in range(n * n)]
for i, row in enumerate(grid):
for j, v in enumerate(row):
for k, (dx, dy) in enumerate(DIRS):
x, y = i + dx, j + dy
if 0 <= x < n and 0 <= y < n:
s[v][k // 4] += grid[x][y]
self.s = s
def adjacentSum(self, value: int) -> int:
return self.s[value][0]
def diagonalSum(self, value: int) -> int:
return self.s[value][1]
# Your neighborSum object will be instantiated and called as such:
# obj = neighborSum(grid)
# param_1 = obj.adjacentSum(value)
# param_2 = obj.diagonalSum(value)
