6148. 矩阵中的局部最大值：

给你一个大小为 n x n 的整数矩阵 grid 。

生成一个大小为 (n - 2) x (n - 2) 的整数矩阵 maxLocal ，并满足：

maxLocal[i][j] 等于 grid 中以 i + 1 行和 j + 1 列为中心的 3 x 3 矩阵中的 最大值 。

换句话说，我们希望找出 grid 中每个 3 x 3 矩阵中的最大值。

返回生成的矩阵。

样例 1：

输入：
	grid = [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]]
	
输出：
	[[9,9],[8,6]]
	
解释：
	原矩阵和生成的矩阵如上图所示。
	注意，生成的矩阵中，每个值都对应 grid 中一个相接的 3 x 3 矩阵的最大值。

样例 2：

输入：
	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]]
	
输出：
	[[2,2,2],[2,2,2],[2,2,2]]
	
解释：
	注意，2 包含在 grid 中每个 3 x 3 的矩阵中。

提示：

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

原题传送门：

https://leetcode.cn/problems/largest-local-values-in-a-matrix/

分析

面对这道算法题目，二当家的陷入了沉思。
谁也无法阻止暴力破解，除了慢，没毛病。

在这里插入图片描述

题解

rust

impl Solution {
    pub fn largest_local(grid: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
        let n = grid.len() - 2;
        let mut ans = vec![vec![0; n]; n];

        (0..n).for_each(|i| {
            (0..n).for_each(|j| {
                (0..3).for_each(|r| {
                    (0..3).for_each(|c| {
                        ans[i][j] = ans[i][j].max(grid[i + r][j + c]);
                    });
                });
            });
        });

        ans
    }
}

go

func largestLocal(grid [][]int) [][]int {
    n := len(grid) - 2
	var ans [][]int

	for i := 0; i < n; i++ {
		row := make([]int, n)
		for j := 0; j < n; j++ {
			for r := 0; r < 3; r++ {
				for c := 0; c < 3; c++ {
					if grid[i+r][j+c] > row[j] {
						row[j] = grid[i+r][j+c]
					}
				}
			}
		}
		ans = append(ans, row)
	}

	return ans
}

c++

class Solution {
public:
    vector<vector<int>> largestLocal(vector<vector<int>>& grid) {
        const int n = grid.size() - 2;
        vector<vector<int>> ans(n, vector<int>(n));

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                int m = 0;
                for (int r = 0; r < 3; ++r) {
                    for (int c = 0; c < 3; ++c) {
                        ans[i][j] = max(ans[i][j], grid[i + r][j + c]);
                    }
                }
            }
        }

        return ans;
    }
};

java

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

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                for (int r = 0; r < 3; ++r) {
                    for (int c = 0; c < 3; ++c) {
                        ans[i][j] = Math.max(ans[i][j], grid[i + r][j + c]);
                    }
                }
            }
        }

        return ans;
    }
}

python

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