[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):

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

Given n and k, return the kth permutation sequence.

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

分析：首先想到的是回溯法的排列树+计数，但是排列树并不符合next_permutation 的关系，所以只能使用时间复杂度O(n^n)的排序树。。每个位置都有n中可能，记录下已经使用的数字，然后从未使用的数据中选择，然后递归调用，其实使用的还是回溯法的框架，有所更改。

上Code，但是大数时会超时。。

class Solution {
        vector<bool> m_avaliable;
        int m_k;
        int m_cnt;
        vector<int> m_array;
    public:
        string m_str;

        void dfs_permutation(int size, int dep)
        {
            if(dep == size)
            {
                m_cnt ++;
                if(m_cnt == m_k)
                {
                    for(int i = 0; i < size; i++)
                    {
                        m_str += m_array[i] + '1';
                    }
                    return;
                }
            }

            //dfs to the next level
            // every level has size choices, its time complexity is O(n^n)
            for(int i = 0; i < size; i++)
            {
                if( m_avaliable[i] == true)
                {
                    //cout <<"dep = " <<dep <<endl;
                    //cout <<"i   = " <<i <<endl;
                    m_array[dep] = i;
                    m_avaliable[i] = false;
                    dfs_permutation( size, dep+1);
                    m_avaliable[i] = true;
                }

            }



        }
        string getPermutation(int n, int k)
        {
            //initinalize the member variable
            m_avaliable.resize(n, true);
            m_array.resize(n);
            m_k = k;
            m_cnt = 0;
            m_str.clear();

            //call dfs
            dfs_permutation(n, 0);

            // return 
            return m_str;
        }

};

 方法二：基于 next permutation的方法的计算，复杂度O(n),不会超时，空间复杂度O（1）

class Solution {
    public:
        string getPermutation(int n, int k)  
        {   
            k--;

            string s;
            vector<int> container;
            vector<int> res;

            for(int i = 1; i <=n; i++)
            {   
                container.push_back(i);
            }   
            //printVector(container);

            for(int i = n-1; i >=0; i--)
            {   
                int index = k/calcFactorial(i);
                int value =  container[index];
                res.push_back(value);


                vector<int>::iterator findit = find(container.begin(),container.end(),value);
                container.erase(findit);
                k = k%calcFactorial(i);
#if 0
                cout << "===================================" <<endl;
                cout << "i =	" << i <<endl;
                cout << "index =	" << index <<endl;
                printVector(container);
                printVector(res);
                cout << "===================================" <<endl;
#endif
            }
            //printVector(res);

            for(int i = 0; i <res.size(); i++)
            {
                s += res[i] + '0';
            }
            return s;
        }

        int calcFactorial(int n)
        {
            if(n == 0 || n == 1)
                return 1;
            int sum = 1;
            for(int i = 2; i <= n; i++)
                sum *= i;
            return sum;
        }

};