时间复杂度是O(kn)，空间是O(n)
public static void main(String[] args) {
//n = 4, r = 2, k = 3
int[] ret1 = getKthPermutation(4, 2, 3);
//ret1 is [1,0,0,1]
//n = 3, r = 2, k = 1
int[] ret2 = getKthPermutation(3, 2, 1);
//ret2 is [1,0,1]
}
static int[] getKthPermutation(int n, int r, int k) {
int[] array = new int[n];
setLastN(array, r, 1);
int lastIndex = n - 1;
for(int count = 0; count < k; count++) {
int indexOfLastOne = findIndexOfLast(array, lastIndex, 1);
int indexOfLastZero = findIndexOfLast(array, indexOfLastOne, 0);
array[indexOfLastOne] = 0;
array[indexOfLastZero] = 1;
//shortcut: swap the part after indexOfLastZero to keep them sorted
int h = indexOfLastZero + 1;
int e = lastIndex;
while(h < e) {
int temp = array[h];
array[h] = array[e];
array[e] = temp;
h++;
e--;
}
}
return array;
}
//starting from `from`, and traveling the array forward, find the first `value` and return its index.
static int findIndexOfLast(int[] array, int from, int value) {
for(int i = from; i > -1; i--)
if(array[i] == value) return i;
return -1;
}
//set the last n elements of an array to `value`
static void setLastN(int[] array, int n, int value){
for(int i = 0, l = array.length - 1; i < n; i++)
array[l - i] = value;
}
这是对非常典型的“查找第 k 个排列”算法的改编。
我将尝试解释一般概念（您的情况是一种特殊情况，因为只有两种类型的元素：0 和 1）。
假设我有[2,1,6,4,7,5]。比当前排列更大的下一个最小排列是什么？为什么我关心比当前更大的下一个最小排列？因为如果你从最小的排列[1,2,4,5,6,7] 开始，然后重复这个动作（找到比当前大的最小的）k 次，你会找到第 k+1 个最小的排列。
现在，由于我要查找的值需要大于当前值，因此我需要增加当前值。为了使增量尽可能小，我将尝试修改 5（最后一个）。现在，我不能只将 5 更改为随机值，我只能将其与之前的某个数字交换。
如果我将 5 换成更大的数字，比如 7，那么我将得到[2,1,6,4,5,7]，它比当前的要小。现在显然我需要在它之前用一些较小的数字交换 5，但是哪一个呢？如果我用 2 交换 5，我得到[5,1,6,4,7,2]，这个增量太大了。我需要用“低位”交换 5 以保持增量尽可能小。这导致我们找到小于 5 的第一个（最低）数字（从右到左）。在这种情况下，我需要将 5 与 4 交换并得到[2,1,6,5,7,4]。这样，我可以使“交换”的影响变小。现在前缀是[2,1,6,5。没有更小的前缀。我们需要处理后缀7,4]。显然，如果我们对后缀进行排序并使其成为4,7]，那么我们就完成了。
在我们的例子中，有两个区别：
1. 我们需要交换最后一个 1，因为你不能通过将一个零与它之前的任何数字交换来使排列变大。
2.我们总是可以使用代码所示的快捷方式对后缀进行排序。我会把它留给你:)