# Construct a Matrix such that each cell consists of sum of adjacent elements of respective cells in given Matrix

• Last Updated : 08 Jun, 2021

Given a matrix arr[][] of dimensions N * M, the task is to generate a matrix such that any cell (r, c) stores the sum of adjacent elements present horizontally, vertically, and diagonally in the given matrix.

Examples:

Input: arr[][] = {{1, 3}, {2, 4}}
Output: {{9, 7}, {8, 6}}
Explanation: Matrix is constructed by the following operations:
For cell (0, 0), arr[1][0] + arr[0][1] + arr[1][1] = 2 + 3 + 4 = 9.
For cell (0, 1), arr[1][0] + arr[0][0] + arr[1][1] = 2 + 1 + 4 = 7.
For cell (1, 0), arr[0][0] + arr[0][1] + arr[1][1] = 1 + 3 + 4 = 8.
For cell (1, 1), arr[1][0] + arr[0][1] + arr[0][0] = 2 + 3 + 1 = 6.

Input: arr[][] = {{1}}
Output: {{0}}

Approach: The idea is to traverse each cell of the given matrix and for each cell (r, c), store the sum of adjacent cells {{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}} if possible.

1. Initialize a matrix v[][] of dimension N * M to store the results of each cell.
2. Now, traverse each cell of the matrix. For each cell, check for valid adjacent cells and keep updating their sum.
3. After traversing, print the value stored in each cell of the matrix v[][].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Initialize rows and columns` `int` `r, c;`   `// Store all 8 directions` `vector > 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 >& 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 >& M)` `{` `    ``// Stores the resultant matrix` `    ``vector > 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 > M` `        ``= { { 1, 4, 1 }, { 2, 4, 5 }, { 3, 1, 2 } };`   `    ``// Size of matrix` `    ``r = M.size(), c = M[0].size();`   `    ``// Function call` `    ``findsumofneighbors(M);` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `import` `java.lang.*;`   `public` `class` `GFG {`   `    ``// Initialize rows and columns` `    ``private` `static` `int` `r, c;`   `    ``// Store all 8 directions` `    ``static` `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` `    ``public` `static` `boolean` `valid(``int` `i, ``int` `j)` `    ``{` `        ``if` `(i >= ``0` `&& j >= ``0` `&& i < r && j < c)` `            ``return` `true``;`   `        ``return` `false``;` `    ``}`   `    ``// Function to find sum of adjacent cells` `    ``// for cell (i, j)` `    ``static` `int` `find(``int` `i, ``int` `j, ``int``[][] v)` `    ``{` `        ``// Initialize sum` `        ``int` `s = ``0``;`   `        ``// Visit all 8 directions` `        ``for` `(``int` `k = ``0``; k < ``8``; k++) {`   `            ``int` `ni = i + dir[k][``0``], nj = j + dir[k][``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` `    ``static` `void` `findsumofneighbors(``int``[][] M)` `    ``{` `        ``// Stores the resultant matrix` `        ``int``[][] v = ``new` `int``[r];`   `        ``// 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);` `                ``System.out.print(v[i][j] + ``" "``);` `            ``}` `            ``System.out.println(``""``);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Given matrix` `        ``int``[][] M` `            ``= { { ``1``, ``4``, ``1` `},` `               ``{ ``2``, ``4``, ``5` `}, ` `               ``{ ``3``, ``1``, ``2` `} };`   `        ``// Size of matrix` `        ``r = M.length;` `        ``c = M[``0``].length;`   `        ``// Function call` `        ``findsumofneighbors(M);` `    ``}` `}`   `// This code is contributed by ajaykr00kj`

## Python3

 `# Python program for the above approach`   `# Initialize rows and columns` `r, c ``=` `0``, ``0``;`   `# Store all 8 directions` `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` `def` `valid(i, j):` `    ``if` `(i >``=` `0` `and` `j >``=` `0` `and` `i < r ``and` `j < c):` `        ``return` `True``;`   `    ``return` `False``;`   `# Function to find sum of adjacent cells` `# for cell (i, j)` `def` `find(i, j, v):` `  `  `    ``# Initialize sum` `    ``s ``=` `0``;`   `    ``# Visit all 8 directions` `    ``for` `k ``in` `range``(``8``):`   `        ``ni ``=` `i ``+` `dir``[k][``0``];` `        ``nj ``=` `j ``+` `dir``[k][``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` `def` `findsumofneighbors(M):` `  `  `    ``# Stores the resultant matrix` `    ``v ``=` `[[``0` `for` `i ``in` `range``(c)] ``for` `j ``in` `range``(r)];`   `    ``# Iterate each elements of matrix` `    ``for` `i ``in` `range``(r):` `        ``for` `j ``in` `range``(c):` `          `  `            ``# Find adjacent sum` `            ``v[i][j] ``=` `find(i, j, M);` `            ``print``(v[i][j], end``=``" "``);`   `        ``print``("");`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``# Given matrix` `    ``M ``=` `[[``1``, ``4``, ``1``], [``2``, ``4``, ``5``], [``3``, ``1``, ``2``]];`   `    ``# Size of matrix` `    ``r ``=` `len``(M[``0``]);` `    ``c ``=` `len``(M[``1``]);`   `    ``# Function call` `    ``findsumofneighbors(M);`   `# This code is contributed by 29AjayKumar`

## C#

 `// C# program for the above approach` `using` `System;` `public` `class` `GFG {`   `    ``// Initialize rows and columns` `    ``private` `static` `int` `r, c;`   `    ``// Store all 8 directions` `    ``static` `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` `    ``public` `static` `bool` `valid(``int` `i, ``int` `j)` `    ``{` `        ``if` `(i >= 0 && j >= 0 && i < r && j < c)` `            ``return` `true``;`   `        ``return` `false``;` `    ``}`   `    ``// Function to find sum of adjacent cells` `    ``// for cell (i, j)` `    ``static` `int` `find(``int` `i, ``int` `j, ``int``[,] v)` `    ``{` `        ``// Initialize sum` `        ``int` `s = 0;`   `        ``// Visit all 8 directions` `        ``for` `(``int` `k = 0; k < 8; k++) {`   `            ``int` `ni = i + dir[k, 0], nj = j + dir[k, 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` `    ``static` `void` `findsumofneighbors(``int``[,] M)` `    ``{` `        ``// Stores the resultant matrix` `        ``int``[,] v = ``new` `int``[r, c];`   `        ``// 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);` `                ``Console.Write(v[i, j] + ``" "``);` `            ``}` `            ``Console.WriteLine(``""``);` `        ``}` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``// Given matrix` `        ``int``[,] M` `            ``= { { 1, 4, 1 },` `               ``{ 2, 4, 5 }, ` `               ``{ 3, 1, 2 } };`   `        ``// Size of matrix` `        ``r = M.GetLength(0);` `        ``c = M.GetLength(1);`   `        ``// Function call` `        ``findsumofneighbors(M);` `    ``}` `}`   `// This code is contributed by Rajput-Ji `

## Javascript

 ``

Output

```10 13 13
13 19 12
7 16 10```

Time Complexity: O(N*M) where N * M are the dimensions of the matrix.
Auxiliary Space: O(N*M)

My Personal Notes arrow_drop_up
Recommended Articles
Page :