leetcode_060 Permutation Sequence

题意分析：1~n组成的序列从小到大排序，按顺序找出k个序列，并输出。

解题思路：

                     对于数值n，排列组合共有n!种排列。

                     第一位每个数组开头的序列有(n-1)！个序列，

                     依此类推，第二位每一个数开头有(n-2)!个序列。

                     因数字不重复，故用sign标记数字是否使用过，data存阶层的数，每次循环找到没有使用的数中第

                     k/data[i]个数就是当前位的数字。

                     其详细过程见程序中注释。

class Solution 
{
	public:
		// 利用库函数实现（超时） 
	    string getPermutation(int n, int k) 
		{
	        string str = string("123456789").substr(0, n);
	        for(int i = 1; i <= k-1; i++)
	            next_permutation(str.begin(), str.end());
	        return str;
	    }
	    // 递归实现（超时） 
	    string getPermutation(int n, int k) 
		{
			string result;
			vector<int> nums;
	        for (int i = 1; i <= n; i++)
				nums.push_back(i);
	        for(int i = 1; i <= k-1; i++)
	            nextPermutation(nums);
	        for (int i = 0; i < nums.size(); i++)
	        {
	        	result += nums[i] + '0';
			}
			return result;
	    }
	    
	    void myswap(int &x, int &y)
		{
			int t;
			t = x;
			x = y;
			y = x;
		}
		void nextPermutation(vector<int> &nums)
		{
			int n = nums.size();
			if (n == 1)
				return;
			for (int i = n - 2, j = n - 1; i >= 0; i--, j--)
			{
				//执行第一步，从后向前，找第一个不满足递增的数nums[i] 
				if (nums[i] < nums[j])
				{
					int k = n - 1;
					//执行第二步，从后向前，找第一个比nums[i]大的数nums[k] 
					while (nums[k] <= nums[i])
						k--;
					//执行第三步，交换两个数nums[i]和num[k] 
					swap(nums[i], nums[k]);
					//执行第四步，对nums[i] 后面的数进行翻转
					reverse(nums.begin() + j, nums.end());
					return ;
				}
			}
			//当没第一步未找到合适的数，则对整个进行翻转 
			reverse(nums.begin(), nums.end());
		}

		// 上面超时的原因是算法都是逐个求排列，下面利用非逐个求，而是直接构造第k个排列。以n=4，k=17为例，数组src=[1,2,3,...]。
		// 计算第17个排列的第一个数。首先直到(n-1)!=3!=6，即以1和2开头的排列总共有6*2=12个<17,故第17个排列的第一个数不可能为
		// 1或者2,6*3>17，故第17个排列第一个数为3。即第17个排列的第一数是原数组（原数组有序）的第m=upper(17/6)=3个数。第一个
		// 数固定后，从src数组中删除概述，相当于在当前src的基础上求k-(m-1)*(n-1)！=17-2*6=5个排列，在递归求解。
		string getPermutation(int n, int k)
		{
			string str = string("123456789").substr(0, n);
			string result(n, ' ');
			for (int i = 0; i < n; i++)
			{
				result[i] = helper(str, k);
			}
			return result;
		}
		// 以s中字符构造全排列中，返回第k个排列的第一个字符，并删除s中该字符，s中字符递增有序
		char helper(string &s, int &k)
		{
			int tmp = factorial(s.size() - 1);
			int i = (k - 1) / tmp;
			char res = s[i];
			s.erase(i, 1);
			k -= i * tmp;    // 更新k
			return res; 
		}
		int factorial(int n)
		{
			int res = 1;
			for (int i = 2; i <= n; i++)
				res *= i;
			return res;
		 }
		// 上面算法的非递归实现（未超时） 
		string getPermutation(int n, int k)
		{
			int total = factorial(n);
			string candidate = string("123456789").substr(0, n);
			string res(n, ' ');
			for (int i = 0; i < n; i++)   // 依次计算排列的每个位
			{
				total /= (n - i);
				int index = (k - 1) / total;
				res[i] = candidate[index];
				candidate.erase(index, 1);
				k -= index * total;
			}
			return res; 
		}
		int factorial(int n)
		{
			int res = 1;
			for (int i = 2; i <= n; i++)
			{
				res *= i;
			}
			return res;
		} 
		// 整体思路：先初始化字符串"1,2,...,n"，然后从0位开始逐步确定每一位的数字，第i位后面的数字有(n-1-i)!种排法，若假设k<(n-1-i)!，则
		// 可确定第i位的数字。 
		string getPermutation(int n, int k)
		{
			// 初始化字符串"1...n" 
			int Kn = 1;
			string res(n, '1');
			for (int i = 2; i <= n; i++)
			{
				Kn *= i;
				res[i - 1] = i + '0';
			}
			int temp = n;
			for (int i = 0; i < res.size(); i++)
			{
				Kn /= temp;
				for (int j = i + 1; j < n && k > Kn; j++)
				{
					swap(res[i], res[j]);
					k -= Kn;
					if (k == 1)
						break; 
				}
				temp--;
			}
			return res; 
		}		
	    // 非递归实现（未超时） 
		string getPermutation(int n, int k)
		{
			int i;
			int j;
			int data[10];
			int sign[10];
			data[1] = 1;
			for (i = 2; i <= n; i++)
			{
				data[i] = data[i - 1] * i;
			}
			for (int i = 0; i < 10; i++)
			{
				sign[i] = 0;
			}
			string s = "";
			i = i - 2;
			k--;
			while (i >= 0)
			{
				int temp = k / data[i];
				for (j = 1; j < 10; j++)
				{
					if (sign[j] == 0)
						temp--;
					if (temp < 0)
						break;
				}
				sign[j] = 1;
				s += j + '0';
				k %= data[i];
				i--;
			}
			return s;
		}  
};