给定尺寸为N * M的矩阵 arr [] []，任务是生成一个矩阵，以使任何元素（r，c）存储在给定矩阵中水平，垂直和对角线方向上存在的相邻元素的总和。

例子：

    输入： arr [] [] = {{1，3}，{2，4}}
    输出： {{9，7}，{8，6}}
    说明：矩阵是通过以下操作构造的：
    对于单元格（0 ，0），arr [1] [0] + arr [0] [1] + arr [1] [1] = 2 + 3 + 4 =9。
    对于单元格（0，1），arr [1] [0 ] + arr [0] [0] + arr [1] [1] = 2 +1 + 4 =7。
    对于单元格（1，0），arr [0] [0] + arr [0] [1] + arr [1] [1] = 1 + 3 + 4 =8。
    对于单元格（1，1），arr [1] [0] + arr [0] [1] + arr [0] [0] = 2 + 3 +1 = 6。

    输入： arr [] [] = {{1}}
    输出： {{0}}

方法：想法是遍历给定矩阵的每个元素，对于每个像元（r，c），存储相邻像元{{r-1，c-1}，{r + 1，c + 1}， {r-1，c + 1}，{r + 1，c-1}，{r，c-1}，{r-1，c}，{r + 1，c}，{r，c + 1 }}。

• 初始化尺寸为N * M的矩阵v [] []以存储每个单元格的结果。
• 现在，遍历矩阵的每个单元格。对于每个单元格，检查有效的相邻单元格，并继续更新其总和。
• 遍历后，打印存储在矩阵v [] []的每个单元格中的值。

#include <bits/stdc++.h> 
using namespace std; 

// Initialize rows and columns 
int r, c; 

// Store all 8 directions 
vector<vector<int> > dir 
    = { { 1, 0 }, { -1, 0 }, 
        { 0, 1 }, { 0, -1 }, 
        { -1, -1 }, { -1, 1 }, 
        { 1, 1 }, { 1, -1 } }; 

// Function to check if a cell 
// (i, j) is valid or not 
bool valid(int i, int j) 
{ 
    if (i >= 0 && j >= 0 
        && i < r && j < c) 
        return 1; 

    return 0; 
} 

// Function to find sum of adjacent cells 
// for cell (i, j) 
int find(int i, int j, vector<vector<int> >& v) 
{ 
    // Initialize sum 
    int s = 0; 

    // Visit all 8 directions 
    for (auto x : dir) { 
        int ni = i + x[0], nj = j + x[1]; 

        // Check if cell is valid 
        if (valid(ni, nj)) 
            s += v[ni][nj]; 
    } 

    // Return sum 
    return s; 
} 

// Function to print sum of adjacent elements 
void findsumofneighbors(vector<vector<int> >& M) 
{ 
    // Stores the resultant matrix 
    vector<vector<int> > v( 
        r, vector<int>(c, 0)); 

    // Iterate each elements of matrix 
    for (int i = 0; i < r; i++) { 
        for (int j = 0; j < c; j++) { 

            // Find adjacent sum 
            v[i][j] = find(i, j, M); 
            cout << v[i][j] << " "; 
        } 
        cout << "\n"; 
    } 
} 

// Driver Code 
int main() 
{ 

    // Given matrix 
    vector<vector<int> > M 
        = { { 1, 4, 1 }, 
            { 2, 4, 5 }, 
            { 3, 1, 2 } }; 

    // Size of matrix 
    r = M.size(), c = M[0].size(); 

    // Function call 
    findsumofneighbors(M); 
} 

输出：
10 13 13
13 19 12
7 16 10

时间复杂度： O（N * M），其中N * M是矩阵的维数。
辅助空间： O（N * M）