获得大于给定数字的第 K 个最小数字所需的最小相邻交换

该问题可以用以下算法解决：

1. 字典序法

首先，将给定数字的每个数字排列成一个序列，然后按照字典序进行排序。例如，对于数字 34628，所得到的序列为 2 3 4 6 8。

接下来，我们可以使用以下算法获取大于给定数字的第 K 个最小数字：

1. 从序列的最右侧开始，找到第一个当前数字小于其右边的数字的位置 i。
2. 在从位置 i 开始到最右侧的子序列中，找到值大于位置 i 上的数字的最小数字， 记为 j。
3. 交换位置 i 和位置 j 上的数字。
4. 将从位置 i+1 开始到最右侧的子序列翻转。

在实现这个算法时，需要注意以下问题：

1. 如何确定第一个当前数字小于其右边的数字的位置 i？我们可以从右侧开始依次遍历数字，直到找到目标数字。
2. 如何找到位置 i 之后的序列中的最小数字，它的值大于位置 i 上的数字？我们可以从右侧开始依次遍历数字，直到找到目标数字。

代码示例：

def get_next_number(num, k):
    digits = list(map(int, str(num)))
    n = len(digits)
    i, j = n - 1, 0
    
    # Step 1: Find the right-most digit, which is smaller than the next digit to its right
    while i > 0 and digits[i-1] >= digits[i]:
        i -= 1
    
    # This is the largest number possible
    if i == 0:
        return -1
    
    # Step 2: Find the smallest digit to the right of i which is larger than i    
    j = i
    while j < n and digits[j] > digits[i-1]:
        j += 1
        
    # Step 3: Swap i-1 and j-1
    digits[i-1], digits[j-1] = digits[j-1], digits[i-1]
    
    # Step 4: Reverse the digits from i to the end of the list
    digits[i:] = digits[i:][::-1]
    
    # Convert the digits to a number
    next_num = int("".join(str(x) for x in digits))
    
    # Return the K-th smallest number
    return next_num if k == 1 else get_next_number(next_num, k-1)

该算法的时间复杂度为 O(n)，其中 n 是数字的位数。

2. 基于计数器的法则

第二种算法基于以下规则：

1. 数字的每个数字可以被视为计数器，其值是数字出现的频率。
2. 我们可以将所有数字的计数器分为两个集合，以下分别称为左集合和右集合，它们都是包含 0-9 的数字的数组。
3. 右集合代表的数字要比给定数字大，而左集合代表数字与给定数字相同。
4. 从右到左遍历数字，并将当前数字的计数器从右集合中移动到左集合，这会生成下一个大于给定数字的数字。

代码示例：

def get_next_number(num, k):
    digits = list(map(int, str(num)))
    n = len(digits)
    left = [0] * 10
    right = [0] * 10
    
    # Step 1: Count each digit's frequency
    for i in range(n):
        right[digits[i]] += 1
    
    # Step 2: Find the smallest number greater than the given number
    for i in range(n-1, -1, -1):
        j = digits[i]
        right[j] -= 1
        for k in range(j+1, 10):
            if right[k] > 0:
                left[j] += 1
                right[k] -= 1
                digits[i] = k
                for l in range(i+1, n):
                    for m in range(10):
                        if left[m] > 0:
                            digits[l] = m
                            left[m] -= 1
                            break
                        else:
                            digits[l] = -1
                return int("".join(str(d) for d in digits))
        left[j] += 1
        
    return -1

该算法的时间复杂度为 O(n^2)，其中 n 是数字的位数。因此，这种算法只适用于数字具有非常小的位数（例如，4位数以下）。