Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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: 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. 
 

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.

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 <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) 



My Personal Notes
arrow_drop_up
Next

Kth smallest element in a row-wise and column-wise sorted 2D array | Set 1
Recommended Articles
Page :
Count of indices pairs such that product of elements at these indices is equal to absolute difference of indices
07, Jul 21
Count 1s in binary matrix having remaining indices of its row and column filled with 0s
23, Sep 20
Count pairs with product of indices equal to the product of elements present at those indices
18, Mar 21
Convert a Matrix into another Matrix of given dimensions
13, Jan 21
Count pairs of indices having sum of indices same as the sum of elements at those indices
21, Jul 21
Count of unordered pair of indices such that ratio of elements at these indices is same as ratio of indices
24, Aug 21
Smallest pair of indices with product of subarray co-prime with product of the subarray on the left or right
23, Nov 20
Count occurrences of an element in a matrix of size N * N generated such that each element is equal to product of its indices
25, Feb 21
Count occurrences of an element in a matrix of size N * N generated such that each element is equal to product of its indices | Set-2
02, Mar 21
Find the element at the specified index of a Spirally Filled Matrix
22, Jul 20
Size of smallest square that contains N non-overlapping rectangles of given dimensions
13, Apr 21
Minimum number of 1s present in a submatrix of given dimensions in a Binary Matrix
09, Mar 21
Nth term where K+1th term is product of Kth term with difference of max and min digit of Kth term
22, May 20
Minimize cost of placing tiles of dimensions 2 * 1 over a Matrix
22, Feb 21
Fill an empty 2D Matrix with integers from 1 to N*N filled diagonally
21, Jun 21
Number of ways of cutting a Matrix such that atleast one cell is filled in each part
28, May 20
Rearrange sorted array such that all odd indices elements comes before all even indices element
09, Sep 21
Count of triplets whose indices and element at that indices are in increasing order
15, Sep 21
Kth smallest number in array formed by product of any two elements from two arrays
21, Oct 21
Count of elements that are Kth powers of their indices in given Array
09, Nov 21
Count squares of unique dimensions possible from given Straight Lines parallel to the axes
29, Oct 20
Count tiles of dimensions 2 * 1 that can be placed in an M * N rectangular board that satisfies the given conditions
15, Feb 21
Absolute difference between sum of even elements at even indices & odd elements at odd indices in given Array
04, Dec 21
Program to check if tank will overflow, underflow or filled in given time
12, Dec 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
dreamer07
@dreamer07
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!