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

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: 4 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: 8 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:
Initialize low as 1 and high as N×M, as the Kth smallest element lies between 1 and N×M. Find the mid element between the low and high elements.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.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.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).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.
Initialize low as 1 and high as N×M, as the Kth smallest element lies between 1 and N×M. 
Find the mid element between the low and high elements.
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.
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.
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).
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++
Java
Python3
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>using namespace std; #define LL long long // Function that returns true if the// count of elements is less than midbool 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 arrayLL 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 Codeint main(){    LL N = 2, M = 3;     LL int K = 5;     cout << findKthElement(N, M, K) << endl;     return 0;}
// Java program to implement// the above approachclass GFG{     // Function that returns true if the// count of elements is less than midpublic 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 arraypublic 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 codepublic 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 program for the above approach# Function that returns true if the# count of elements is less than middef 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 arraydef 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 Codeif __name__ == "__main__":     N = 2    M = 3    K = 5    print(findKthElement(N, M, K))     # This code is contributed by Chitranayal
// C# program to implement// the above approachusing System; class GFG{     // Function that returns true if the// count of elements is less than midpublic 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 arraypublic 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 codepublic 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
<script>// Javascript program for the above approach // Function that returns true if the// count of elements is less than midfunction countLessThanMid(mid, N, M, K){    // To store count of elements    // less than mid    let count = 0;     // Loop through each row    for (let i = 1;        i <= Math.min(N, mid); ++i) {         // Count elements less than        // mid in the ith row        count = count + Math.min(parseInt(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 arrayfunction findKthElement(N, M, K){    // Initialize low and high    let low = 1, high = N * M;     // Perform binary search    while (low <= high) {         // Find the mid        let mid = low + parseInt((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    let N = 2, M = 3;     let K = 5;     document.write(findKthElement(N, M, K)); </script>
Output: 
4
Time Complexity: O(N×log(N×M)) Auxiliary Space: O(1) 
divyeshrabadiya07
Rajput-Ji
ukasp
subham348
Binary Search
Mathematical
Matrix
Searching
Sorting
Searching
Mathematical
Sorting
Matrix
Binary Search
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples
Prime Numbers
Program to find GCD or HCF of two numbers
Print all possible combinations of r elements in a given array of size n
Matrix Chain Multiplication | DP-8
Print a given matrix in spiral form
Rat in a Maze | Backtracking-2
Maximum size square sub-matrix with all 1s
Sudoku | Backtracking-7