# Smallest element from all square submatrices of size K from a given Matrix

• Difficulty Level : Expert
• Last Updated : 16 Sep, 2021

Given a matrix arr[][] and an integer K, the task is to find the smallest element from all possible square submatrices of size K from the given matrix.

Examples:

Input: K = 2, arr[][] ={ {1, 2, 3}, {4, 5, 6},  {7, 8, 9} }
Output:
1 2
4 5
Explanation:
Smallest elements from all possible square submatrices of size 2 are as follows:
{ {1, 2}, {4, 5} } -> 1
{ {2, 3}, {5, 6} } -> 2
{ {4, 5}, {7, 8} } -> 4
{ {5, 6}, {8, 9} } -> 5

Input: K = 3,
arr[][] = { {-1, 5, 4, 1, -3},
{4, 3, 1, 1, 6},
{2, -2, 5, 3, 1},
{8, 5, 1, 9, -4},
{12, 3, 5, 8, 1} }
Output:
-2 -2 -3
-2 -2 -4
-2 -2 -4

Naive Approach: The simplest approach to solve the problem is to generate all possible square submatrices of size K from the given matrix and print the smallest element from each such submatrices.

Time Complexity: O(N * M * K2)
Auxiliary Space: O(1)

Efficient Approach: Follow the steps below to optimize the above approach:

• Traverse over each row of the matrix and for every arr[i][j], update in-place the smallest element present between indices arr[i][j] to arr[i][j + K – 1] (0 <= j < M – K + 1).
• Similarly, traverse over each column of the matrix and for every arr[i][j], update in-place the smallest element present between indices arr[i][j] to arr[i+K-1][j] (0 <= i < N – K + 1).
• After performing the above operations, the top-left submatrix of size (N – K + 1)*(M – K + 1) of the matrix arr[][] consists of all the smallest elements of all the K x K sub-matrices of the given matrix.
• Therefore, print the submatrix of size (N – K + 1)*(M – K + 1) as the required output.

Below is the implementation of the above approach:

## C++

 `// C++ Program for``// the above approach``#include ``using` `namespace` `std;` `// Function to returns a smallest``// elements of all KxK submatrices``// of a given NxM matrix``vector > matrixMinimum(``       ``vector > nums, ``int` `K)``{``  ``// Stores the dimensions``  ``// of the given matrix``  ``int` `N = nums.size();``  ``int` `M = nums[0].size();` `  ``// Stores the required``  ``// smallest elements``  ``vector > res(N - K + 1,``                           ``vector<``int``>(M - K + 1));` `  ``// Update the smallest elements row-wise``  ``for` `(``int` `i = 0; i < N; i++)``  ``{``    ``for` `(``int` `j = 0; j < M - K + 1; j++)``    ``{``      ``int` `mini = INT_MAX;``      ``for` `(``int` `k = j; k < j + K; k++)``      ``{``        ``mini = min(mini, nums[i][k]);``      ``}``      ``nums[i][j] = mini;``    ``}``  ``}` `  ``// Update the minimum column-wise``  ``for` `(``int` `j = 0; j < M; j++)``  ``{``    ``for` `(``int` `i = 0; i < N - K + 1; i++)``    ``{``      ``int` `mini = INT_MAX;``      ``for` `(``int` `k = i; k < i + K; k++)``      ``{``        ``mini = min(mini, nums[k][j]);``      ``}``      ``nums[i][j] = mini;``    ``}``  ``}` `  ``// Store the final submatrix with``  ``// required minimum values``  ``for` `(``int` `i = 0; i < N - K + 1; i++)``    ``for` `(``int` `j = 0; j < M - K + 1; j++)``      ``res[i][j] = nums[i][j];` `  ``// Return the resultant matrix``  ``return` `res;``}` `void` `smallestinKsubmatrices(vector > arr,``                            ``int` `K)``{``  ``// Function Call``  ``vector > res = matrixMinimum(arr, K);` `  ``// Print resultant matrix with the``  ``// minimum values of KxK sub-matrix``  ``for` `(``int` `i = 0; i < res.size(); i++)``  ``{``    ``for` `(``int` `j = 0; j < res[0].size(); j++)``    ``{``      ``cout << res[i][j] << ``" "``;``    ``}``    ``cout << endl;``  ``}``}` `// Driver Code``int` `main()``{` `  ``// Given matrix``  ``vector > arr = {{-1, 5, 4, 1, -3},``                              ``{4, 3, 1, 1, 6},``                              ``{2, -2, 5, 3, 1},``                              ``{8, 5, 1, 9, -4},``                              ``{12, 3, 5, 8, 1}};` `  ``// Given K``  ``int` `K = 3;` `  ``smallestinKsubmatrices(arr, K);``}` `// This code is contributed by Chitranayal`

## Java

 `// Java Program for the above approach` `import` `java.util.*;``import` `java.lang.*;` `class` `GFG {` `    ``// Function to returns a smallest``    ``// elements of all KxK submatrices``    ``// of a given NxM matrix``    ``public` `static` `int``[][] matrixMinimum(``        ``int``[][] nums, ``int` `K)``    ``{``        ``// Stores the dimensions``        ``// of the given matrix``        ``int` `N = nums.length;``        ``int` `M = nums[``0``].length;` `        ``// Stores the required``        ``// smallest elements``        ``int``[][] res``            ``= ``new` `int``[N - K + ``1``][M - K + ``1``];` `        ``// Update the smallest elements row-wise``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``for` `(``int` `j = ``0``; j < M - K + ``1``; j++) {` `                ``int` `min = Integer.MAX_VALUE;``                ``for` `(``int` `k = j; k < j + K; k++) {``                    ``min = Math.min(min, nums[i][k]);``                ``}``                ``nums[i][j] = min;``            ``}``        ``}` `        ``// Update the minimum column-wise``        ``for` `(``int` `j = ``0``; j < M; j++) {``            ``for` `(``int` `i = ``0``; i < N - K + ``1``; i++) {``                ``int` `min = Integer.MAX_VALUE;``                ``for` `(``int` `k = i; k < i + K; k++) {``                    ``min = Math.min(min, nums[k][j]);``                ``}``                ``nums[i][j] = min;``            ``}``        ``}` `        ``// Store the final submatrix with``        ``// required minimum values``        ``for` `(``int` `i = ``0``; i < N - K + ``1``; i++)``            ``for` `(``int` `j = ``0``; j < M - K + ``1``; j++)``                ``res[i][j] = nums[i][j];` `        ``// Return the resultant matrix``        ``return` `res;``    ``}` `    ``public` `static` `void` `smallestinKsubmatrices(``        ``int` `arr[][], ``int` `K)``    ``{``        ``// Function Call``        ``int``[][] res = matrixMinimum(arr, K);` `        ``// Print resultant matrix with the``        ``// minimum values of KxK sub-matrix``        ``for` `(``int` `i = ``0``; i < res.length; i++) {``            ``for` `(``int` `j = ``0``; j < res[``0``].length; j++) {``                ``System.out.print(res[i][j] + ``" "``);``            ``}``            ``System.out.println();``        ``}``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Given matrix``        ``int``[][] arr = { { -``1``, ``5``, ``4``, ``1``, -``3` `},``                        ``{ ``4``, ``3``, ``1``, ``1``, ``6` `},``                        ``{ ``2``, -``2``, ``5``, ``3``, ``1` `},``                        ``{ ``8``, ``5``, ``1``, ``9``, -``4` `},``                        ``{ ``12``, ``3``, ``5``, ``8``, ``1` `} };` `        ``// Given K``        ``int` `K = ``3``;` `        ``smallestinKsubmatrices(arr, K);``    ``}``}`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to returns a smallest``# elements of all KxK submatrices``# of a given NxM matrix``def` `matrixMinimum(nums, K):` `    ``# Stores the dimensions``    ``# of the given matrix``    ``N ``=` `len``(nums)``    ``M ``=` `len``(nums[``0``])` `    ``# Stores the required``    ``# smallest elements``    ``res ``=` `[[``0` `for` `x ``in` `range``(M ``-` `K ``+` `1``)]``              ``for` `y ``in` `range``(N ``-` `K ``+` `1``)]` `    ``# Update the smallest elements row-wise``    ``for` `i ``in` `range``(N):``        ``for` `j ``in` `range``(M ``-` `K ``+` `1``):``            ``mn ``=` `sys.maxsize``            ` `            ``for` `k ``in` `range``(j, j ``+` `K):``                ``mn ``=` `min``(mn, nums[i][k])` `            ``nums[i][j] ``=` `mn` `    ``# Update the minimum column-wise``    ``for` `j ``in` `range``(M):``        ``for` `i ``in` `range``(N ``-` `K ``+` `1``):``            ``mn ``=` `sys.maxsize``            ` `            ``for` `k ``in` `range``(i, i ``+` `K):``                ``mn ``=` `min``(mn, nums[k][j])` `            ``nums[i][j] ``=` `mn` `    ``# Store the final submatrix with``    ``# required minimum values``    ``for` `i ``in` `range``(N ``-` `K ``+` `1``):``        ``for` `j ``in` `range``(M ``-` `K ``+` `1``):``            ``res[i][j] ``=` `nums[i][j]` `    ``# Return the resultant matrix``    ``return` `res` `def` `smallestinKsubmatrices(arr, K):` `    ``# Function call``    ``res ``=` `matrixMinimum(arr, K)` `    ``# Print resultant matrix with the``    ``# minimum values of KxK sub-matrix``    ``for` `i ``in` `range``(``len``(res)):``        ``for` `j ``in` `range``(``len``(res[``0``])):``            ``print``(res[i][j], end ``=` `" "``)``            ` `        ``print``()` `# Driver Code` `# Given matrix``arr ``=` `[ [ ``-``1``, ``5``, ``4``, ``1``, ``-``3` `],``        ``[ ``4``, ``3``, ``1``, ``1``, ``6` `],``        ``[ ``2``, ``-``2``, ``5``, ``3``, ``1` `],``        ``[ ``8``, ``5``, ``1``, ``9``, ``-``4` `],``        ``[ ``12``, ``3``, ``5``, ``8``, ``1` `] ]` `# Given K``K ``=` `3` `# Function call``smallestinKsubmatrices(arr, K)` `# This code is contributed by Shivam Singh`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to returns a smallest``// elements of all KxK submatrices``// of a given NxM matrix``public` `static` `int``[,] matrixMinimum(``int``[,] nums,``                                   ``int` `K)``{``    ` `    ``// Stores the dimensions``    ``// of the given matrix``    ``int` `N = nums.GetLength(0);``    ``int` `M = nums.GetLength(1);` `    ``// Stores the required``    ``// smallest elements``    ``int``[,] res = ``new` `int``[N - K + 1,``                         ``M - K + 1];` `    ``// Update the smallest elements row-wise``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``for``(``int` `j = 0; j < M - K + 1; j++)``        ``{``            ``int` `min = ``int``.MaxValue;``            ``for``(``int` `k = j; k < j + K; k++)``            ``{``                ``min = Math.Min(min, nums[i, k]);``            ``}``            ``nums[i, j] = min;``        ``}``    ``}` `    ``// Update the minimum column-wise``    ``for``(``int` `j = 0; j < M; j++)``    ``{``        ``for``(``int` `i = 0; i < N - K + 1; i++)``        ``{``            ``int` `min = ``int``.MaxValue;``            ``for``(``int` `k = i; k < i + K; k++)``            ``{``                ``min = Math.Min(min, nums[k, j]);``            ``}``            ``nums[i, j] = min;``        ``}``    ``}` `    ``// Store the readonly submatrix with``    ``// required minimum values``    ``for``(``int` `i = 0; i < N - K + 1; i++)``        ``for``(``int` `j = 0; j < M - K + 1; j++)``            ``res[i, j] = nums[i, j];` `    ``// Return the resultant matrix``    ``return` `res;``}` `public` `static` `void` `smallestinKsubmatrices(``int` `[,]arr,``                                          ``int` `K)``{``    ` `    ``// Function call``    ``int``[,] res = matrixMinimum(arr, K);` `    ``// Print resultant matrix with the``    ``// minimum values of KxK sub-matrix``    ``for``(``int` `i = 0; i < res.GetLength(0); i++)``    ``{``        ``for``(``int` `j = 0; j < res.GetLength(1); j++)``        ``{``            ``Console.Write(res[i, j] + ``" "``);``        ``}``        ``Console.WriteLine();``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{` `    ``// Given matrix``    ``int``[,] arr = { { -1, 5, 4, 1, -3 },``                   ``{ 4, 3, 1, 1, 6 },``                   ``{ 2, -2, 5, 3, 1 },``                   ``{ 8, 5, 1, 9, -4 },``                   ``{ 12, 3, 5, 8, 1 } };` `    ``// Given K``    ``int` `K = 3;` `    ``smallestinKsubmatrices(arr, K);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

```-2 -2 -3
-2 -2 -4
-2 -2 -4```

Time Complexity: O( max(N, M)3 )
Auxiliary Space: O( (N-K+1)*(M-K+1) )

My Personal Notes arrow_drop_up