GeeksforGeeks App
Open App
Browser
Continue

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

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.

## C++

 `#include ``#include ``#include // for INT_MAX``using` `namespace` `std;` `// Function to return the smallest elements of all KxK submatrices of a given NxM matrix``void` `print_smallest_elements(``const` `vector> &arr, ``int` `K) {``    ``// Get the number of rows and columns in the matrix``    ``int` `rows = arr.size();``    ``int` `cols = arr[0].size();``    ` `    ``// Loop through the matrix, creating submatrices of size KxK``    ``for` `(``int` `row = 0; row <= rows - K; row++) {``        ``for` `(``int` `col = 0; col <= cols - K; col++) {``            ``// Create a submatrix by extracting elements from the original matrix``            ``vector> subarr;``            ``for` `(``int` `i = row; i < row + K; i++) {``                ``vector<``int``> subcol;``                ``for` `(``int` `j = col; j < col + K; j++) {``                    ``subcol.push_back(arr[i][j]);``                ``}``                ``subarr.push_back(subcol);``            ``}``            ` `            ``// Find the minimum value in the submatrix``            ``int` `minimum = INT_MAX;``            ``for` `(``const` `auto` `&x : subarr) {``                ``for` `(``const` `auto` `&y : x) {``                    ``minimum = min(minimum, y);``                ``}``            ``}``            ` `            ``// Print the minimum value of the submatrix``            ``cout << minimum << ``" "``;``        ``}``        ``cout << endl;``    ``}``}` `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}};``    ``int` `K = 3;``    ` `    ``// Call the function to print the smallest elements of all KxK submatrices``    ``print_smallest_elements(arr, K);``    ` `    ``return` `0;``}`

## Java

 `import` `java.util.ArrayList;` `public` `class` `Main { ``// Function to return the smallest``                    ``// elements of all KxK submatrices of a``                    ``// given NxM matrix``    ``static` `void` `printSmallestElements(``        ``ArrayList > arr, ``int` `K)``    ``{``        ``// Get the number of rows and columns in the matrix``        ``int` `rows = arr.size();``        ``int` `cols = arr.get(``0``).size();` `        ``// Loop through the matrix, creating submatrices of``        ``// size KxK``        ``for` `(``int` `row = ``0``; row <= rows - K; row++) {``            ``for` `(``int` `col = ``0``; col <= cols - K; col++) {``                ``// Create a submatrix by extracting elements``                ``// from the original matrix``                ``ArrayList > subarr``                    ``= ``new` `ArrayList >();``                ``for` `(``int` `i = row; i < row + K; i++) {``                    ``ArrayList subcol``                        ``= ``new` `ArrayList();``                    ``for` `(``int` `j = col; j < col + K; j++) {``                        ``subcol.add(arr.get(i).get(j));``                    ``}``                    ``subarr.add(subcol);``                ``}` `                ``// Find the minimum value in the submatrix``                ``int` `minimum = Integer.MAX_VALUE;``                ``for` `(ArrayList x : subarr) {``                    ``for` `(``int` `y : x) {``                        ``minimum = Math.min(minimum, y);``                    ``}``                ``}` `                ``// Print the minimum value of the submatrix``                ``System.out.print(minimum + ``" "``);``            ``}``            ``System.out.println();``        ``}``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given matrix``        ``ArrayList > arr``            ``= ``new` `ArrayList >();``        ``arr.add(``new` `ArrayList() {``            ``{``                ``add(-``1``);``                ``add(``5``);``                ``add(``4``);``                ``add(``1``);``                ``add(-``3``);``            ``}``        ``});``        ``arr.add(``new` `ArrayList() {``            ``{``                ``add(``4``);``                ``add(``3``);``                ``add(``1``);``                ``add(``1``);``                ``add(``6``);``            ``}``        ``});``        ``arr.add(``new` `ArrayList() {``            ``{``                ``add(``2``);``                ``add(-``2``);``                ``add(``5``);``                ``add(``3``);``                ``add(``1``);``            ``}``        ``});``        ``arr.add(``new` `ArrayList() {``            ``{``                ``add(``8``);``                ``add(``5``);``                ``add(``1``);``                ``add(``9``);``                ``add(-``4``);``            ``}``        ``});``        ``arr.add(``new` `ArrayList() {``            ``{``                ``add(``12``);``                ``add(``3``);``                ``add(``5``);``                ``add(``8``);``                ``add(``1``);``            ``}``        ``});``        ``int` `K = ``3``;` `        ``// Call the function to print the smallest elements``        ``// of all KxK submatrices``        ``printSmallestElements(arr, K);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Function to returns a smallest``# elements of all KxK submatrices``# of a given NxM matrix`  `def` `print_smallest_elements(arr, K):``    ``rows ``=` `len``(arr)``    ``cols ``=` `len``(arr[``0``])``    ``for` `row ``in` `range``(rows``-``K``+``1``):``        ``for` `col ``in` `range``(cols``-``K``+``1``):``            ``subarr ``=` `[row[col:col``+``K] ``for` `row ``in` `arr[row:row``+``K]]``            ``print``(``min``([``min``(x) ``for` `x ``in` `subarr]), 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``print_smallest_elements(arr, K)` `# This code is contributed by Aman Kumar`

## C#

 `using` `System;``using` `System.Collections.Generic;` `public` `class` `Mainn``{``    ``// Function to return the smallest elements of all KxK submatrices of a``    ``// given NxM matrix``    ``static` `void` `PrintSmallestElements(List> arr, ``int` `K)``    ``{``        ``// Get the number of rows and columns in the matrix``        ``int` `rows = arr.Count;``        ``int` `cols = arr[0].Count;` `        ``// Loop through the matrix, creating submatrices of size KxK``        ``for` `(``int` `row = 0; row <= rows - K; row++)``        ``{``            ``for` `(``int` `col = 0; col <= cols - K; col++)``            ``{``                ``// Create a submatrix by extracting elements from the original matrix``                ``List> subarr = ``new` `List>();``                ``for` `(``int` `i = row; i < row + K; i++)``                ``{``                    ``List<``int``> subcol = ``new` `List<``int``>();``                    ``for` `(``int` `j = col; j < col + K; j++)``                    ``{``                        ``subcol.Add(arr[i][j]);``                    ``}``                    ``subarr.Add(subcol);``                ``}` `                ``// Find the minimum value in the submatrix``                ``int` `minimum = ``int``.MaxValue;``                ``foreach` `(List<``int``> x ``in` `subarr)``                ``{``                    ``foreach` `(``int` `y ``in` `x)``                    ``{``                        ``minimum = Math.Min(minimum, y);``                    ``}``                ``}` `                ``// Print the minimum value of the submatrix``                ``Console.Write(minimum + ``" "``);``            ``}``            ``Console.WriteLine();``        ``}``    ``}` `    ``public` `static` `void` `Main()``    ``{``        ``// Given matrix``        ``List> arr = ``new` `List>()``        ``{``            ``new` `List<``int``>() {-1, 5, 4, 1, -3},``            ``new` `List<``int``>() {4, 3, 1, 1, 6},``            ``new` `List<``int``>() {2, -2, 5, 3, 1},``            ``new` `List<``int``>() {8, 5, 1, 9, -4},``            ``new` `List<``int``>() {12, 3, 5, 8, 1}``        ``};``        ``int` `K = 3;` `        ``// Call the function to print the smallest elements of all KxK submatrices``        ``PrintSmallestElements(arr, K);``    ``}``}`

## Javascript

 `// Function to return the smallest elements of all KxK submatrices of a given NxM matrix``function` `print_smallest_elements(arr, K) {``    ``// Get the number of rows and columns in the matrix``    ``let rows = arr.length;``    ``let cols = arr[0].length;` `    ``// Loop through the matrix, creating submatrices of size KxK``    ``for` `(let row = 0; row <= rows - K; row++) {``        ``for` `(let col = 0; col <= cols - K; col++) {``            ``// Create a submatrix by extracting elements from the original matrix``            ``let subarr = [];``            ``for` `(let i = row; i < row + K; i++) {``                ``let subcol = [];``                ``for` `(let j = col; j < col + K; j++) {``                    ``subcol.push(arr[i][j]);``                ``}``                ``subarr.push(subcol);``            ``}` `            ``// Find the minimum value in the submatrix``            ``let minimum = Number.MAX_SAFE_INTEGER;``            ``subarr.forEach(x => {``                ``x.forEach(y => {``                    ``minimum = Math.min(minimum, y);``                ``})``            ``})` `            ``// Print the minimum value of the submatrix``            ``process.stdout.write(minimum + ``" "``);``        ``}``        ``console.log();``    ``}``}` `// Given matrix``let 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]];``let K = 3;` `// Call the function to print the smallest elements of all KxK submatrices``print_smallest_elements(arr, K);`

Output

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

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

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