[Solved] Largest Local Values in a Matrix LeetCode Contest Problem

You are given an n x n integer matrix grid.

Generate an integer matrix maxLocal of size (n - 2) x (n - 2) such that:

• maxLocal[i][j] is equal to the largest value of the 3 x 3 matrix in grid centered around row i + 1 and column j + 1.

In other words, we want to find the largest value in every contiguous 3 x 3 matrix in grid.

Return the generated matrix.

Largest Local Values in a Matrix LeetCode Contest

Example 1:

Input: grid = [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]]
Output: [[9,9],[8,6]]
Explanation: The diagram above shows the original matrix and the generated matrix.
Notice that each value in the generated matrix corresponds to the largest value of a contiguous 3 x 3 matrix in grid.

Example 2:

Input: grid = [[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]]
Output: [[2,2,2],[2,2,2],[2,2,2]]
Explanation: Notice that the 2 is contained within every contiguous 3 x 3 matrix in grid.

Constraints:

• n == grid.length == grid[i].length
• 3 <= n <= 100
• 1 <= grid[i][j] <= 100

Solution

class Solution:
    def largestLocal(self, grid: List[List[int]]) -> List[List[int]]:
        n = len(grid)
        res = [[0] * (n - 2) for _ in range(n - 2)]
        for i in range(n - 2):
            for j in range(n - 2):
                max_val = max(grid[i+1][j+1], grid[i+1 - 1][j+1], grid[i+1 + 1][j+1], grid[i+1][j+1 -1], grid[i+1][j+1 + 1], grid[i+1 - 1][j+1 -1], grid[i+1 + 1][j+1 + 1], grid[i+1 -1][j+1 +1], grid[i+1 + 1][j+1 - 1])
                res[i][j] = max_val
        return res

class Solution 
{
public:
    vector<vector<int>> largestLocal(vector<vector<int>>& grid) 
    {
        int n=grid.size();
        vector<vector<int>> res(n-2, vector<int> (n-2));
        
        //find max of 3x3 grid centred around row i + 1 and column j + 1
        for(int i=1; i<=n-2; i++)
        {
            for(int j=1; j<=n-2; j++)
            {
                int maxi=0;
                maxi = max(maxi, max(grid[i-1][j-1], max(grid[i-1][j], grid[i-1][j+1])));
                maxi = max(maxi, max(grid[i][j-1], max(grid[i][j], grid[i][j+1])));
                maxi = max(maxi, max(grid[i+1][j-1], max(grid[i+1][j], grid[i+1][j+1])));
                
               res[i-1][j-1] = maxi;
            }
        }
        return res;
    }
};

class Solution {
    public int[][] largestLocal(int[][] grid) {
        
        
        int n= grid.length;
       int[][] maxLocal=new int[n-2][n-2];

       for(int i=0;i<n-2;i++){
           for(int j=0;j<n-2;j++){
               maxLocal[i][j]=solUtil(grid,i,j);
           }
       }
        
        return maxLocal;
    }
    
    public static int solUtil(int[][] grid,int row,int col){

        int mx=0;

        for(int i=row;i<row+3;i++){
            
            for(int j=col;j<col+3;j++){
                
                mx=Math.max(mx,grid[i][j]);
            }
        }
        return mx;
    }
}

Happy Learning – If you require any further information, feel free to contact me.