给定尺寸为N * M的矩阵arr [] [] ,任务是生成一个矩阵,以使任何像元(r,c)存储在给定矩阵中水平,垂直和对角线方向上存在的相邻元素的总和。
例子:
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}}
方法:想法是遍历给定矩阵的每个像元,对于每个像元(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 [] []的每个单元格中的值。
下面是上述方法的实现:
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(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 prsum 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
10 13 13
13 19 12
7 16 10
时间复杂度: O(N * M)其中N * M是矩阵的维数。
辅助空间: O(N * M)