通过用其左或右对角线和的最大值替换每个元素来修改矩阵

给定一个维度为M * N的矩阵mat[][] ，任务是用其左对角线或右对角线的最大和替换每个矩阵元素。

例子：

Input: mat[][] = {{5, 2, 1}, {7, 2, 6}, {3, 1, 9}}
Output: 
16  9   6 
9 16   8
6   8 16
Explanation:
Replace each element with max(sum of right diagonal, sum of left diagonal).
Follow the diagram below to understand more clearly.

Input: mat[][] = {{1, 2}, {3, 4}}
Output: 
5 5
5 5

方法：主要思想基于以下观察的事实：

• 右对角线元素的行索引和列索引之和相等。
• 左对角元素的行索引和列索引之间的差值相等。
• 使用上面的两个属性，使用一个Map来存储每个元素左右对角线的总和。
• 遍历矩阵并用左对角线和或右对角线和的最大值替换每个元素。
• 打印得到的最终矩阵。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
 
// Function to update given matrix with
// maximum of left and right diagonal sum
void updateMatrix(int mat[][3])
{
 
  // Stores the total sum
  // of right diagonal
  map right;
 
  // Stores the total sum
  // of left diagonal
  map left;
 
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
 
      // Update the map storing
      // right diagonal sums
      if (right.find(i + j) == right.end())
        right[i + j] = mat[i][j];
      else
        right[i + j] += mat[i][j];
 
      // Update the map storing
      // left diagonal sums
      if (left.find(i - j) == left.end())
        left[i - j] = mat[i][j];
      else
        left[i - j] += mat[i][j];
    }
  }
   
  // Traverse the matrix
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
 
      // Update the matrix
      mat[i][j] = max(right[i + j], left[i - j]);
    }
  }
 
  // Print the matrix
  for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
      cout << mat[i][j] << " ";
    }
    cout << endl;
  }
}
 
// Driver code
int main()
{
  int mat[][3]
    = { { 5, 2, 1 }, { 7, 2, 6 }, { 3, 1, 9 } };
  updateMatrix(mat);
  return 0;
}
 
// This code is contributed by ukasp.

Java

// Java program for the above approach
  
// Function to update given matrix with
// maximum of left and right diagonal sum
import java.io.*;
import java.util.*;
 
class GFG {
     
    static void updateMatrix(int mat[][])
    {
        Map right
            = new HashMap(); 
             
        Map left
            = new HashMap();     
             
        for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
              
            // Update the map storing
            // right diagonal sums
            if (!right.containsKey(i + j))
                right.put(i + j, mat[i][j]);
            else
                right.put(i + j,
                right.get(i + j) + mat[i][j]);
  
            // Update the map storing
            // left diagonal sums
            if (!left.containsKey(i - j))
                left.put(i - j, mat[i][j]);
  
            else
                left.put(i - j,
                left.get(i - j) + mat[i][j]);
        }
    }
  
    // Traverse the matrix
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
              
            // Update the matrix
            mat[i][j] = Math.max(right.get(i + j),
                                  left.get(i - j));
        }
    }
  
    // Print the matrix
    for(int i = 0; i < 3; i++)
    {
        for(int j = 0; j < 3; j++)
        {
            System.out.print(mat[i][j] + " ");
        }
        System.out.print("\n");
    }   
    }
     
    // Driver code
    public static void main (String[] args) {
        int[][] mat = {{ 5, 2, 1 },
            { 7, 2, 6 },
            { 3, 1, 9 }};
            updateMatrix(mat);
    }
}
 
// This code is contributed by avanitrachhadiya2155

Python3

# Python3 program for the above approach
 
# Function to update given matrix with
# maximum of left and right diagonal sum
def updateMatrix(mat):
 
    # Stores the total sum
    # of right diagonal
    right = {}
 
    # Stores the total sum
    # of left diagonal
    left = {}
 
    for i in range(len(mat)):
        for j in range(len(mat[0])):
 
            # Update the map storing
            # right diagonal sums
            if i + j not in right:
                right[i + j] = mat[i][j]
            else:
                right[i + j] += mat[i][j]
 
            # Update the map storing
            # left diagonal sums
            if i-j not in left:
                left[i-j] = mat[i][j]
            else:
                left[i-j] += mat[i][j]
 
    # Traverse the matrix
    for i in range(len(mat)):
        for j in range(len(mat[0])):
 
            # Update the matrix
            mat[i][j] = max(right[i + j], left[i-j])
 
    # Print the matrix
    for i in mat:
        print(*i)
 
# Given matrix
mat = [[5, 2, 1], [7, 2, 6], [3, 1, 9]]
updateMatrix(mat)

C#

// C# program for the above approach
using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{
    // Function to update given matrix with
    // maximum of left and right diagonal sum
    static void updateMatrix(int[,] mat)
    {
      
      // Stores the total sum
      // of right diagonal
      Dictionary right = new Dictionary();
      
      // Stores the total sum
      // of left diagonal
      Dictionary left = new Dictionary();
      
      for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
      
          // Update the map storing
          // right diagonal sums
          if (!right.ContainsKey(i + j))
            right[i + j] = mat[i,j];
          else
            right[i + j] += mat[i,j];
      
          // Update the map storing
          // left diagonal sums
          if (!left.ContainsKey(i - j))
            left[i - j] = mat[i,j];
          else
            left[i - j] += mat[i,j];
        }
      }
        
      // Traverse the matrix
      for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
      
          // Update the matrix
          mat[i,j] = Math.Max(right[i + j], left[i - j]);
        }
      }
      
      // Print the matrix
      for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
          Console.Write(mat[i,j] + " ");
        }
        Console.WriteLine();
      }
    }
     
  static void Main ()
  {
    int[,] mat = { { 5, 2, 1 }, { 7, 2, 6 }, { 3, 1, 9 } };
    updateMatrix(mat);
  }
}
 
// This code is contributed by suresh07.

Javascript

 
// Javascript program for the above approach
 
// Function to update given matrix with
// maximum of left and right diagonal sum
function updateMatrix(mat)
{
     
    // Stores the total sum
    // of right diagonal
    let right = new Map();
 
    // Stores the total sum
    // of left diagonal
    let left = new Map();
 
    for(let i = 0; i < 3; i++)
    {
        for(let j = 0; j < 3; j++)
        {
             
            // Update the map storing
            // right diagonal sums
            if (!right.has(i + j))
                right.set(i + j, mat[i][j]);
            else
                right.set(i + j,
                right.get(i + j) + mat[i][j]);
 
            // Update the map storing
            // left diagonal sums
            if (!left.has(i - j))
                left.set(i - j, mat[i][j]);
 
            else
                left.set(i - j,
                left.get(i - j) + mat[i][j]);
        }
    }
 
    // Traverse the matrix
    for(let i = 0; i < 3; i++)
    {
        for(let j = 0; j < 3; j++)
        {
             
            // Update the matrix
            mat[i][j] = Math.max(right.get(i + j),
                                  left.get(i - j));
        }
    }
 
    // Print the matrix
    for(let i = 0; i < 3; i++)
    {
        for(let j = 0; j < 3; j++)
        {
            document.write(mat[i][j] + " ");
        }
        document.write("<br>");
    }
}
 
// Driver code
let mat = [ [ 5, 2, 1 ],
            [ 7, 2, 6 ],
            [ 3, 1, 9 ] ];
updateMatrix(mat);
 
// This code is contributed by gfgking.
 

输出：

16 9 6
9 16 8
6 8 16

时间复杂度： O(N * M)
辅助空间： O(N * M)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。