《leetCode》：Permutation Sequence

题目描述

The set [1,2,3,…,n] contains a total of n! unique permutations.

By listing and labeling all of the permutations in order,
We get the following sequence (ie, for n = 3):

"123"
"132"
"213"
"231"
"312"
"321"
Given n and k, return the kth permutation sequence.

Note: Given n will be between 1 and 9 inclusive.

题目大意：找到第k个排列。

思路

与找出n个数的全排列的思路一样，但是这里只需要我们找出第k个排列，因此，设置一个标志位flag，当其为flag为false时，表示已经找到第k个。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*
思路：递归法，要注意的是：结果是排序后的第k个结果 
*/
void swap(char *a,char *b){
    char temp=*a;
    *a=*b;
    *b=temp;
}
void bubbleSort(char *arr,int begin,int length){
    int i,j;
    for(i=begin;i<length;i++){
        for(j=i+1;j<length;j++){
            if(arr[i]>arr[j]){
                swap(&arr[i],&arr[j]);
            }
        }
    }
}
bool flag=true;
char *result;
void getPermutate(char *arr,int len,int* k,int start){
    if(arr==NULL||len<0){
        return ;
    }
    if(start==len-1){//得到一种结果
        if((*k)==1){//得到最终的结果 
            flag=false;
            for(int k=0;k<len;k++){
                result[k]=arr[k];
            }
            result[len]='\0';

        } 
        (*k)--;         
    }
    else{
        for(int i=start;i<len;i++){
            if(flag){
                swap(&arr[start],&arr[i]);
                bubbleSort(arr,start+1,len);
                getPermutate(arr,len,k,start+1);
                if(flag){
                    bubbleSort(arr,start+1,len);
                }

            }
        } 
    }

}
char* getPermutation(int n, int k) {
    if(n<1||k<1){
        return NULL; 
    }
    flag=true;
    //开辟一段空间来保存结果 
    result=(char *)malloc((n+1)*sizeof(char));
    if(result==NULL){
        exit(EXIT_FAILURE);
    } 
    char *s=(char *)malloc((n)*sizeof(char));
    if(s==NULL){
        exit(EXIT_FAILURE);
    } 
    for(int i=0;i<n;i++){
        s[i]=(char)(i+'1');
    //  printf("%c   ",s[i]);
    }
    getPermutate(s,n,&k,0) ;
    return result;
}

int main(void){

    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF&&n>0&&k>0){
        char *result=getPermutation(n,k);

        puts(result);
    }
    return 0;
}

AC结果如下：

小结

虽然AC了，但是效率不高。可以寻找更好的方法来做。

改进

此方法来源于：
思路如下：
http://blog.csdn.net/doc_sgl/article/details/12840715

方法二：数学解法
在n!个排列中，第一位的元素总是(n-1)!一组出现的，也就说如果p = k / (n-1)!，那么排列的最开始一个元素一定是nums[p]。

假设有n个元素，第K个permutation是
a1, a2, a3, .....   ..., an
那么a1是哪一个数字呢？
那么这里，我们把a1去掉，那么剩下的permutation为
a2, a3, .... .... an, 共计n-1个元素。 n-1个元素共有(n-1)!组排列，那么这里就可以知道
设变量K1 = K
a1 = K1 / (n-1)!
同理，a2的值可以推导为
a2 = K2 / (n-2)!
K2 = K1 % (n-1)!
 .......
a(n-1) = K(n-1) / 1!
K(n-1) = K(n-2) /2!
an = K(n-1)

实现代码如下：

char* getPermutation(int n, int k) {
    if(n<1||k<1){
        return NULL; 
    }
    //开辟一段空间来保存结果 
    char* result=(char *)malloc((n+1)*sizeof(char));
    if(result==NULL){
        exit(EXIT_FAILURE);
    }
    //开辟一段空间，来保存1~n的字符 
    char *s=(char *)malloc((n)*sizeof(char));
    if(s==NULL){
        exit(EXIT_FAILURE);
    } 
    int count=1; //用来表示n！ 
    for(int i=0;i<n;i++){
        s[i]=(char)(i+'1');
        count*=(i+1);
    }
    //求结果中每一位对应的字符 
    k--;//减一的原因在于：第（n-1）!个排列应该是以1开头的最后一个排列；如果不减一，将会是以2开头的第一个 
    for(int i=0;i<n;i++){
        count=count/(n-i);
        int index=k/count;
        result[i]=s[index];
        for(int j=index;j<n-i-1;j++){//将s后面的元素提前 
            s[j]=s[j+1];
        }
        //更新k
        k=k%count; 

    } 
    result[n]='\0';
    return result;
}

遇到的问题

1、当要求输出第k个排列时，原始代码实现的是：输出第k+1个排列，就报了如下错误。

解决方法：在开始之前，将k减1.//减一的原因在于：第（n-1）!个排列应该是以1开头的最后一个排列；如果不减一，将会是以2开头的第一个

最后AC的结果如下：