给定一个整数K和一个大小为N x M的矩阵，其中每个矩阵元素等于其索引( i * j )的乘积，任务是在给定矩阵中找到第K个最小元素。
例子：
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.
天真的方法：最简单的方法是将矩阵的所有元素存储在一个数组中，然后通过对数组进行排序来找到第K个最小的元素。
时间复杂度： O(N×M×log(N×M))
辅助空间： O(N×M)
高效方法：
为了优化幼稚的方法，该思想是使用二进制搜索算法。请按照以下步骤解决问题：
- 由于第K个最小元素位于1和N×M之间，因此将低初始化为1 ，高初始化为N×M。
- 找到中间 低位之间的元素 和高元素。
- 如果少于mid的元素数大于或等于 K，然后将高更新为-1，因为第K个最小元素位于低和中之间。
- 如果少于mid的元素数少于 K，然后更新低到中+1，因为第K个最小元素位于中和高之间。
- 如在第i行中的元素i的倍数，元素小于第i行中间可由分钟(中/ I，M)容易地计算出的数量。因此，仅在O(N)中即可完成查找元素数量少于mid的时间复杂度。
- 执行二进制搜索，直到low小于或等于high并返回high +1作为矩阵N×M的第K个最小元素。
下面是上述方法的实现：
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 divyeshrabadiya07Python3
# 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 ChitranayalC#
// 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输出：
4
时间复杂度： O(N×log(N×M))
辅助空间： O(1)