查询字符串给定范围的第 N 个最小字符

在字符串操作中，有时需要从一个给定的字符串范围中找到第 N 个最小的字符。这种问题可以使用一些常见的算法和数据结构来解决，如排序、二分查找和堆。

排序法

排序是一种常见的方法，可以将字符串范围内的所有字符排序后再取第 N 个最小的字符。例如，我们可以使用快速排序算法，将字符串范围内的字符从小到大排序，然后返回第 N 个最小字符。

def findNthSmallestChar(s: str, l: int, r: int, n: int) -> str:
    arr = sorted(s[l:r+1])
    return arr[n-1] if len(arr) >= n else None

上述实现中，我们通过调用 Python 内置的 sorted 函数进行排序，并返回第 N 个字符（从 1 开始数）。

二分查找法

除了排序之外，我们还可以使用二分查找法来查找第 N 个最小字符。该方法的基本思想是，对于给定范围内的所有字符，我们可以从其中选一个字符，统计在该字符左边和右边小于该字符的字符个数。如果左边字符个数小于 N-1，则该字符不可能是第 N 个最小字符；反之，如果左边字符个数大于 N-1，则该字符不可能是第 N 个最小字符；否则，该字符就是第 N 个最小字符。

def countSmallerChars(s: str, l: int, r: int, x: str) -> int:
    return sum(1 for c in s[l:r+1] if ord(c) < ord(x))

def findNthSmallestChar(s: str, l: int, r: int, n: int) -> str:
    if l > r or n <= 0 or n > r - l + 1:
        return None
    if l == r:
        return s[l]

    # 选取一个中间字符 x
    mid = (l + r) // 2
    x = s[mid]

    # 统计 x 左边和右边小于 x 的字符个数
    cnt_l = countSmallerChars(s, l, mid, x)
    cnt_r = countSmallerChars(s, mid+1, r, x)

    # 根据 cnt_l 与 n 的大小关系选择下一步查找区间
    if cnt_l >= n:
        return findNthSmallestChar(s, l, mid-1, n)
    elif cnt_l == n-1:
        return x
    else:
        return findNthSmallestChar(s, mid+1, r, n-cnt_l-1)

上述实现中，我们先选取一个中间字符 x，并统计在 x 左边和右边小于 x 的字符个数。然后根据这个个数与 n 的大小关系，选择下一步的查找区间，直到找到第 N 个最小字符。

堆法

堆是一种非常高效的数据结构，可以用于查找第 N 个最小字符。与二分查找法类似，我们先用堆来找到给定范围中最小的字符，并将其加入一个集合中。然后再用堆来找到第二小的字符，并判断是否在集合中；以此类推，直到找到第 N 个最小字符。

import heapq

def findNthSmallestChar(s: str, l: int, r: int, n: int) -> str:
    if l > r or n <= 0 or n > r - l + 1:
        return None
    if l == r:
        return s[l]

    seen = set()

    # 使用最小堆找到字符串范围内最小的字符
    h = [(c, i) for i, c in enumerate(s[l:r+1])]
    heapq.heapify(h)
    seen.add(h[0][0])

    # 依次找到第 2~N 个最小字符
    for i in range(n-1):
        while h:
            c, j = heapq.heappop(h)
            if c in seen:
                continue
            seen.add(c)
            if j > l:
                heapq.heappush(h, (s[j-1], j-1))
            if j < r:
                heapq.heappush(h, (s[j+1], j+1))
            break

    # 返回第 N 个最小字符
    return h[0][0] if h else None

上述实现中，我们先使用堆找到给定范围内最小的字符，并将其加入一个集合中。然后依次使用堆找到第 2~N 个最小字符，直到找到第 N 个最小字符。在这个过程中，我们需要记录已经找到的字符，以保证每个字符只会被统计一次。如果堆空了但仍未找到第 N 个最小字符，则表示该字符串范围内有 less than N 个不同的字符，此时返回 None。

总结

以上三种算法都可以解决查询字符串给定范围的第 N 个最小字符的问题。排序法最简单直接，但时间复杂度为 $O(n \log n)$；二分查找法时间复杂度为 $O(n \log n)$，但代码较长；堆法最为高效，时间复杂度为 $O(n \log k)$，其中 $k$ 为字符串范围内不同字符的个数。在实际应用中，可以根据具体问题的需求和输入规模选择适合的算法。