Kth Smallest Element of a Matrix of given dimensions filled with product of indices
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.
Below is the implementation of the above approach:
C++
// 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 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
<script> // Javascript program for the above approach // Function that returns true if the // count of elements is less than mid function 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 array function 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)
Please Login to comment...