查找第N个最小的整数，该整数可被100次K整除

在数学和计算机科学中，查找第N个最小的整数，该整数可被100次K整除，是一个常见的问题。这个问题可以用多种算法来解决，具体的选择取决于N的大小，K的大小，以及系统的可用资源。以下是一些解决这个问题的常见算法：

算法一：暴力枚举

暴力枚举是一种朴素的解法，它的思想是从第一个整数开始，依次判断每一个整数是否符合条件，直到找到第N个符合条件的整数为止。这种方法的时间复杂度是O(N*K)，空间复杂度是O(1)，其中N和K分别表示需要找到的第N个整数和100次K的值。

def get_nth_multiple_of_k(N, K):
    count = 0
    x = 0
    while count < N:
        x += 1
        if x % (100*K) == 0:
            count += 1
    return x

算法二：二分查找

二分查找是一种高效的算法，在已知范围的情况下，可以快速定位符合条件的整数。具体的实现思路是，首先将要查找的整数范围缩小到一个较小的区间，然后不断缩小区间，直到找到符合条件的整数为止。这种方法的时间复杂度是O(log(N)*K)，空间复杂度是O(1)，其中N和K分别表示需要找到的第N个整数和100次K的值。

def get_nth_multiple_of_k(N, K):
    low = 0
    high = 100*N*K
    while low <= high:
        mid = (low + high) // 2
        if mid % (100*K) == 0:
            count = mid // (100*K)
            if count == N:
                return mid
            elif count < N:
                low = mid + 1
            else:
                high = mid - 1
        else:
            if mid < 100*K:
                low = 100*K
            else:
                high = (mid // (100*K) + 1) * (100*K) - 1

算法三：Heap算法

Heap算法是一种优化的算法，在处理较大的整数范围时，可以更快地定位符合条件的整数。具体的实现思路是，首先建立一个小顶堆，将第一个100K的倍数加入堆中，然后不断弹出堆顶，每弹出一个堆顶，就插入该堆顶的下一个100K的倍数。这样，每次弹出的都是当前最小的符合条件的整数，直到找到第N个符合条件的整数为止。这种方法的时间复杂度是O(N*log(K))，空间复杂度是O(K)，其中N和K分别表示需要找到的第N个整数和100次K的值。

import heapq

def get_nth_multiple_of_k(N, K):
    heap = [100*K]
    for i in range(N):
        x = heapq.heappop(heap)
        if i == N-1:
            return x
        heapq.heappush(heap, x + 100*K)
        while heap[0] % (100*K) != 0:
            heapq.heappush(heap, heapq.heappop(heap) + 100*K)