Related Articles

# Kth Smallest Element of a Matrix of given dimensions filled with product of indices

• Difficulty Level : Medium
• Last Updated : 23 Apr, 2021

Given an integer K and a matrix of size N x M, where each matrix element is equal to the product of its indices(i * j), the task is to find the Kth Smallest element in the given Matrix.
Examples:

Input: N = 2, M = 3, K = 5
Output:
Explanation:
The matrix possible for given dimensions is {{1, 2, 3}, {2, 4, 6}}
Sorted order of the matrix elements: {1, 2, 2, 3, 4, 6}
Therefore, the 5th smallest element is 4.
Input: N = 1, M = 10, K = 8
Output:
Explanation:
The matrix possible for given dimensions is {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}
Therefore, the 8th smallest element is 8

Naive Approach: The simplest approach is to store all the elements of the matrix in an array and then find the Kth smallest element by sorting the array.
Time Complexity: O(N×M×log(N×M))
Auxiliary Space: O(N×M)
Efficient Approach:
To optimize the naive approach the idea is to use the Binary Search algorithm. Follow the steps below to solve the problem:

1. Initialize low as 1 and high as N×M, as the Kth smallest element lies between 1 and N×M.
2. Find the mid element between the low and high elements.
3. If the number of elements less than mid is greater than or equal to K, then update high to mid-1 as the Kth smallest element lies between low and mid.
4. If the number of elements less than mid is less than K, then update low to mid+1 as the Kth smallest element lies between mid and high.
5. As the elements in the ith row are the multiple of i, the number of elements less than mid in the ith row can be calculated easily by min(mid/i, M). So, the time complexity to find the number of elements less than mid can be done in only O(N).
6. Perform binary search till low is less than or equal to high and return high + 1 as the Kth smallest element of the matrix N×M.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `#define LL long long` `// Function that returns true if the``// count of elements is less than mid``bool` `countLessThanMid(LL mid, LL N,``                    ``LL M, LL K)``{``    ``// To store count of elements``    ``// less than mid``    ``LL count = 0;` `    ``// Loop through each row``    ``for` `(``int` `i = 1;``        ``i <= min((LL)N, mid); ++i) {` `        ``// Count elements less than``        ``// mid in the ith row``        ``count = count + min(mid / i, M);``    ``}` `    ``if` `(count >= K)``        ``return` `false``;``    ``else``        ``return` `true``;``}` `// Function that returns the Kth``// smallest element in the NxM``// Matrix after sorting in an array``LL findKthElement(LL N, LL M, LL K)``{``    ``// Initialize low and high``    ``LL low = 1, high = N * M;` `    ``// Perform binary search``    ``while` `(low <= high) {` `        ``// Find the mid``        ``LL mid = low + (high - low) / 2;` `        ``// Check if the count of``        ``// elements is less than mid``        ``if` `(countLessThanMid(mid, N, M, K))``            ``low = mid + 1;``        ``else``            ``high = mid - 1;``    ``}` `    ``// Return Kth smallest element``    ``// of the matrix``    ``return` `high + 1;``}` `// Driver Code``int` `main()``{``    ``LL N = 2, M = 3;` `    ``LL ``int` `K = 5;` `    ``cout << findKthElement(N, M, K) << endl;` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``class` `GFG{``    ` `// Function that returns true if the``// count of elements is less than mid``public` `static` `boolean` `countLessThanMid(``int` `mid, ``int` `N,``                                       ``int` `M, ``int` `K)``{``    ` `    ``// To store count of elements``    ``// less than mid``    ``int` `count = ``0``;` `    ``// Loop through each row``    ``for``(``int` `i = ``1``;``            ``i <= Math.min(N, mid); ++i)``    ``{``        ` `        ``// Count elements less than``        ``// mid in the ith row``        ``count = count + Math.min(mid / i, M);``    ``}` `    ``if` `(count >= K)``        ``return` `false``;``    ``else``        ``return` `true``;``}` `// Function that returns the Kth``// smallest element in the NxM``// Matrix after sorting in an array``public` `static` `int` `findKthElement(``int` `N, ``int` `M, ``int` `K)``{``    ` `    ``// Initialize low and high``    ``int` `low = ``1``, high = N * M;` `    ``// Perform binary search``    ``while` `(low <= high)``    ``{``        ` `        ``// Find the mid``        ``int` `mid = low + (high - low) / ``2``;` `        ``// Check if the count of``        ``// elements is less than mid``        ``if` `(countLessThanMid(mid, N, M, K))``            ``low = mid + ``1``;``        ``else``            ``high = mid - ``1``;``    ``}` `    ``// Return Kth smallest element``    ``// of the matrix``    ``return` `high + ``1``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``2``, M = ``3``;``    ``int` `K = ``5``;` `    ``System.out.println(findKthElement(N, M, K));``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program for the above approach``# Function that returns true if the``# count of elements is less than mid``def` `countLessThanMid(mid, N, M, K):``    ` `    ``# To store count of elements``    ``# less than mid``    ``count ``=` `0` `    ``# Loop through each row``    ``for` `i ``in` `range` `(``1``, ``min``(N, mid) ``+` `1``):` `        ``# Count elements less than``        ``# mid in the ith row``        ``count ``=` `count ``+` `min``(mid ``/``/` `i, M)``    ` `    ``if` `(count >``=` `K):``        ``return` `False``    ``else``:``        ``return` `True` `# Function that returns the Kth``# smallest element in the NxM``# Matrix after sorting in an array``def` `findKthElement(N, M, K):` `    ``# Initialize low and high``    ``low ``=` `1``    ``high ``=` `N ``*` `M` `    ``# Perform binary search``    ``while` `(low <``=` `high):` `        ``# Find the mid``        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2` `        ``# Check if the count of``        ``# elements is less than mid``        ``if` `(countLessThanMid(mid, N, M, K)):``            ``low ``=` `mid ``+` `1``        ``else``:``            ``high ``=` `mid ``-` `1` `    ``# Return Kth smallest element``    ``# of the matrix``    ``return` `high ``+` `1` `# Driver Code``if` `__name__ ``=``=` `"__main__"``: ``    ``N ``=` `2``    ``M ``=` `3``    ``K ``=` `5``    ``print``(findKthElement(N, M, K))``    ` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG{``    ` `// Function that returns true if the``// count of elements is less than mid``public` `static` `bool` `countLessThanMid(``int` `mid, ``int` `N,``                                    ``int` `M, ``int` `K)``{``    ` `    ``// To store count of elements``    ``// less than mid``    ``int` `count = 0;` `    ``// Loop through each row``    ``for``(``int` `i = 1;``            ``i <= Math.Min(N, mid); ++i)``    ``{``        ` `        ``// Count elements less than``        ``// mid in the ith row``        ``count = count + Math.Min(mid / i, M);``    ``}` `    ``if` `(count >= K)``        ``return` `false``;``    ``else``        ``return` `true``;``}` `// Function that returns the Kth``// smallest element in the NxM``// Matrix after sorting in an array``public` `static` `int` `findKthElement(``int` `N, ``int` `M,``                                        ``int` `K)``{``    ` `    ``// Initialize low and high``    ``int` `low = 1, high = N * M;` `    ``// Perform binary search``    ``while` `(low <= high)``    ``{``        ` `        ``// Find the mid``        ``int` `mid = low + (high - low) / 2;` `        ``// Check if the count of``        ``// elements is less than mid``        ``if` `(countLessThanMid(mid, N, M, K))``            ``low = mid + 1;``        ``else``            ``high = mid - 1;``    ``}` `    ``// Return Kth smallest element``    ``// of the matrix``    ``return` `high + 1;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `N = 2, M = 3;``    ``int` `K = 5;` `    ``Console.WriteLine(findKthElement(N, M, K));``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`4`

Time Complexity: O(N×log(N×M))
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up