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;

     }
 }