Ignatius and the Princess II

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 9892    Accepted Submission(s): 5777

Problem Description

Now our hero finds the door to the BEelzebub feng5166. He opens the door and finds feng5166 is about to kill our pretty Princess. But now the BEelzebub has to beat our hero first. feng5166 says, "I have three question for you, if you can work them out, I will release the Princess, or you will be my dinner, too." Ignatius says confidently, "OK, at last, I will save the Princess."

"Now I will show you the first problem." feng5166 says, "Given a sequence of number 1 to N, we define that 1,2,3...N-1,N is the smallest sequence among all the sequence which can be composed with number 1 to N(each number can be and should be use only once in this problem). So it's easy to see the second smallest sequence is 1,2,3...N,N-1. Now I will give you two numbers, N and M. You should tell me the Mth smallest sequence which is composed with number 1 to N. It's easy, isn't is? Hahahahaha......"
Can you help Ignatius to solve this problem?

Input

The input contains several test cases. Each test case consists of two numbers, N and M(1<=N<=1000, 1<=M<=10000). You may assume that there is always a sequence satisfied the BEelzebub's demand. The input is terminated by the end of file.

Output

For each test case, you only have to output the sequence satisfied the BEelzebub's demand. When output a sequence, you should print a space between two numbers, but do not output any spaces after the last number.

Sample Input

6 4 11 8

Sample Output

1 2 3 5 6 4 1 2 3 4 5 6 7 9 8 11 10

題目大意：輸入一個n，求n的全排列，在輸入一個m，求按照字典序第m個排列順序，輸出出來。

法一：遞迴順序輸出：

因為這個題目m只有1e+5範圍，所以完全可以遍歷，然後輸出，按順序遍歷，找到第m個後儲存然後輸出：

ac：

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h> 

#include<map>
#include<set>
#include<deque>
#include<queue>
#include<stack>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;

#define ll long long
#define da    0x3f3f3f3f
#define xiao -0x3f3f3f3f
#define clean(a,b) memset(a,b,sizeof(a))// 雷打不動的標頭檔案

bool biaoji[1005];//標記 
int shuzu[1005];//儲存變數 
int n,m,sum,f;
//數字個數，第幾個排列，當前第幾個排列，是否找到 

void dfs(int i,int j)
{
	if(j==n)// 排列完成 
	{
		sum++;//個數++ 
		if(sum==m)//確定是該排列 
			f=1;//f=1 
		return ;
	}
	for(i=1;i<=n;++i)
	{
		if(biaoji[i]==0)//沒被標記過 
		{
			biaoji[i]=1;//標記 
			dfs(i,j+1);//排列數的個數+1 
			biaoji[i]=0;//取消標記 
			if(f)//是該數 
			{
				shuzu[j]=i;//入陣列 
				break;//接下來就不用 找了 
			}
		}
	}
}

int main()
{
	while(cin>>n>>m)
	{
		sum=0;
		f=0;
		clean(shuzu,0);
		clean(biaoji,0);
		int i,j;
		for(i=1;i<=n;++i)//每個數都找一遍 ，因為是初始的第一個數，所以必定都沒被標記
		{
			biaoji[i]=1;// 標記該數 
			dfs(i,1);// 第一個數字，排列了幾個數字了 
			biaoji[i]=0;//讓這個標記取消 
			if(f)	//若找到目標排列 
			{
				shuzu[0]=i;//第一個元素插入 
				break;//結束迴圈 
			}
		}
		for(i=0;i<n-1;++i)//按順序輸出 
			cout<<shuzu[i]<<" ";
		cout<<shuzu[n-1]<<endl;
	}
}
 

法二：運用全排列函式排列，輸出第m個排列：

這個函式我。。一開始不知道，傻傻的手寫dfs。。

　這裡先說兩個概念：“下一個排列組合”和“上一個排列組合”，對序列 {a, b, c}，每一個元素都比後面的小，按照字典序列，固定a之後，a比bc都小，c比b大，它的下一個序列即為{a, c, b}，而{a, c, b}的上一個序列即為{a, b, c}，同理可以推出所有的六個序列為：{a, b, c}、{a, c, b}、{b, a, c}、{b, c, a}、{c, a, b}、{c, b, a}，其中{a, b, c}沒有上一個元素，{c, b, a}沒有下一個元素。

　　　　1）next_permutation：求下一個排列組合　

a.函式模板：next_permutation(arr, arr+size);
b.引數說明：
　　arr： 陣列名
　　size：陣列元素個數
c.函式功能： 返回值為bool型別，噹噹前序列不存在下一個排列時，函式返回false，否則返回true，排列好的數在陣列中儲存

d.注意：在使用前需要對欲排列陣列按升序排序，否則只能找出該序列之後的全排列數。
　　　　比如，如果陣列num初始化為2,3,1，那麼輸出就變為了：{2 3 1} {3 1 2} {3 2 1}

2）prev_permutation：求上一個排列組合

a.函式模板：prev_permutation(arr, arr+size);
b.引數說明：
　　arr： 陣列名
　　size：陣列元素個數
c.函式功能： 返回值為bool型別，噹噹前序列不存在上一個排列時，函式返回false，否則返回true
d.注意：在使用前需要對欲排列陣列按降序排序，否則只能找出該序列之後的全排列數。

#include <iostream>
#include <algorithm>
using namespace std;
int main ()
{
    int arr[] = {3,2,1};
    cout<<"用prev_permutation對3 2 1的全排列"<<endl;
    do
    {
        cout << arr[0] << ' ' << arr[1] << ' ' << arr[2]<<'\n';
    }
    while ( prev_permutation(arr,arr+3) );      ///獲取上一個較大字典序排列，如果3改為2，只對前兩個數全排列

    int arr1[] = {1,2,3};
    cout<<"用next_permutation對1 2 3的全排列"<<endl;
    do
    {
        cout << arr1[0] << ' ' << arr1[1] << ' ' << arr1[2] <<'\n';
    }
    while ( next_permutation(arr1,arr1+3) );      ///獲取下一個較大字典序排列，如果3改為2，只對前兩個數全排列
    ///注意陣列順序，必要時要對陣列先進行排序

    return 0;
}

這是兩者的區別，下面是ac程式碼：

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h> 

#include<map>
#include<set>
#include<deque>
#include<queue>
#include<stack>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;

#define ll long long
#define da    0x3f3f3f3f
#define xiao -0x3f3f3f3f
#define clean(a,b) memset(a,b,sizeof(a))// 雷打不動的標頭檔案

int shuzu[1010];
int n,m;

int main()
{
	while(cin>>n>>m)
	{
		clean(shuzu,0);
		int i,j;
		for(i=1;i<=n;++i)
			shuzu[i]=i;
		int sum=0;
		do{
			sum++;
			if(sum==m)
			{
				for(i=1;i<n;++i)
					cout<<shuzu[i]<<" ";
				cout<<shuzu[n]<<endl;
				break;
			}
			
		}while(next_permutation(shuzu+1,shuzu+n+1));
	}
}