Leetcode-Permuation 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):

1. "123"
2. "132"
3. "213"
4. "231"
5. "312"
6. "321"

Given n and k, return the k^th permutation sequence.

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

Newest Solution, a much shorter one:

public class Solution {
    public String getPermutation(int n, int k) {
        boolean[] used = new boolean[n];
        
        int index = n;
        int total = 1;
        for (int i=1;i<=n;i++){
            total *= i;
        }
        StringBuilder builder = new StringBuilder();
        while (index!=0){
            total = total / index;
            int count = (k-1) / total + 1;
            k = (k-1) % total + 1;
            int ind = 0;
            for (int i=0;i<n;i++)
                if (!used[i]){
                    ind++;
                    if (ind==count){
                        used[i] = true;
                        builder.append(i+1);
                        break;
                    }
                }
            index--;
        }
        return builder.toString();
    }
}

 

Solution 1:

We use recursive method to get the sequence one by one. However, this method is slow.

public class Solution {
    public String getPermutation(int n, int k) {
        int[] seq = new int[n+1];
        int level = 1;
        boolean[] used = new boolean[n+1];
        Arrays.fill(used,false);
        Arrays.fill(seq,0);
        used[0] = true;
        int count = 0;
        String res = "";
        while (true){
            if (level==n){
                count++;
                if (count==k){
                    for (int i=1;i<=n;i++)
                        if (!used[i]){
                            seq[level] = i;
                            break;
                        }
                    for (int i=1;i<=n;i++)
                        res += Integer.toString(seq[i]);
                    break;
                } else {
                    level--;
                    continue;
                }       
            }

            int val = seq[level];
            //NOTE: we need the first condition, because used array does not have n+1.
            while (val<n+1 && used[val])
                val++;
            if (val==n+1){
                if (seq[level]!=0) used[seq[level]] = false;
                seq[level]=0;
                level--;
                continue;
            } else {
                if (seq[level]!=0) used[seq[level]] = false;
                seq[level] = val;
                used[val]=true;
                level++;
            }
        }

        return res;
        
    }
}

Solution 2:

We actually can calculate the sequence. For sequences with n numbers, it is composed by n segments of sequences with n-1 numbers. The number of (n-1) sequences in each segment is (n-1)!. So if we are looking for kth n sequence, it is in (k/(n-1)!)th or (k/(n-1)!+1)th segment (boundary case considerred) which is means the number in the first place should be the (k/(n-1)!)th available number between 1 and n. The number of sequences we should count in this segment to find the target is (k%(n-1)!)th sequence in this segement. With this recurrence formula, we can directly calculate the string one place by one place.

NOTE: We need to consider the boundary cases where k%(n-1)!==0, in this case, it is the (n-1)!th sequence in the k/(n-1)! segment.

public class Solution {
    public String getPermutation(int n, int k) {
        int[] seq = new int[n+1];        
        boolean[] used = new boolean[n+1];
        Arrays.fill(used,false);
        Arrays.fill(seq,0);        
        String res = "";
        int[] val = new int[n+1];
        val[0] = 0;
        val[1] = 1;
        for (int i=2;i<=n;i++)
            val[i] = val[i-1]*i;
        
        int left = k;
        int num = n;
        for (int i=1;i<n;i++){
            int interval = val[num-1];
            int step = left/interval;
            int nextLeft = left%interval;
            if (nextLeft==0)
                nextLeft = interval;
            else step++;
            int index=0;
            for (int j=1;j<=n;j++)
                if (!used[j]){
                    index++;
                    if (index==step){
                        seq[i]=j;
                        used[j] = true;
                        break;
                    }
                }
             left = nextLeft;
             num--;
         }
         for (int i=1;i<=n;i++)
             if (!used[i]){
                 seq[n]=i;
                 break;
             }

         for (int i=1;i<=n;i++)
             res += Integer.toString(seq[i]);
         return res;
        
    }
}