hdu1027 Ignatius and the Princess II(排列问题)

本文介绍了一个经典的算法问题:给定两个整数N和M,如何找到由1到N组成的第M小的排列。文章通过具体示例解释了算法思路,并提供了完整的Java代码实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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

import java.io.IOException;
import java.io.FileReader;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.StreamTokenizer;
import java.io.PrintWriter;
import java.io.OutputStreamWriter;

class Main
{
	public static final boolean DEBUG = false;
	public StreamTokenizer tokenizer;
	public PrintWriter cout;
	public BufferedReader cin;
	public int n, m;
	int[] f = new int[10];
	int[] ans;
	
	public void init() throws IOException
	{
		if (DEBUG) {
			cin = new BufferedReader(new FileReader("d:\\OJ\\uva_in.txt"));
		} else {
			cin = new BufferedReader(new InputStreamReader(System.in));
		}
		
		cout = new PrintWriter(new OutputStreamWriter(System.out));
		tokenizer = new StreamTokenizer(cin);
		f[0] = 0;
		f[1] = 1;
		
		for (int i = 2; i < 10; i++) f[i] = i * f[i - 1];
	}
	
	public int next() throws IOException
	{
		tokenizer.nextToken();
		if (tokenizer.ttype == StreamTokenizer.TT_EOF) return -1;
		else if (tokenizer.ttype == StreamTokenizer.TT_NUMBER) {
			return (int)tokenizer.nval;
		}
		
		return -1;
	}
	
	public boolean input() throws IOException
	{
		n = next();
		if (n == -1) return false;
		
		m = next();
		
		return true;
	}
	
	public void solve()
	{
		boolean[] vis = new boolean[10];
		ans = new int[n];
		int t;
		
		if (n >= 8) {
			t = 8;
		} else {
			t = n;
		}
		
		for (int i = 0; i < t; i++) {
			for (int j = 0; j < t; j++) {
				while (vis[j]) {
					j++;
				}
				
				if (i == t - 1) {
					ans[i] = j + 1;
					vis[j] = true;
					break;
				}
				
				if (m - f[t - i - 1] <= 0) {
					while (vis[j]) {
						j++;
					}
					ans[i] = j + 1;
					vis[j] = true;
					break;
				} else {
					m -= f[t - i - 1];
				}
			}
		}
		
		if (n >= 8) {
			for (int i = 1; i <= n - 8; i++) {
				cout.print(i + " ");
			}
			
			for (int i = 0; i < t; i++) {
				ans[i] += n - 8;
			}
		}
		
		for (int i = 0; i < t - 1; i++) cout.print(ans[i] + " ");
		cout.println(ans[t - 1]);
		
		cout.flush();
	}
	
	public static void main(String[] args) throws IOException
	{
		Main solver = new Main();
		solver.init();
		
		while (solver.input()) {
			solver.solve();
		}
	}
}


Java代码HDU4109-重新排列指令问题是一个经典的算法问题,要求我们重新排列一系列指令,使得最终结果符合特定条件。以下是一个详细的解决方案: ```java import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int T = scanner.nextInt(); while (T-- > 0) { int n = scanner.nextInt(); int[] a = new int[n]; for (int i = 0; i < n; i++) { a[i] = scanner.nextInt(); } System.out.println(canRearrange(a, n) ? "Yes" : "No"); } scanner.close(); } private static boolean canRearrange(int[] a, int n) { // 创建一个布尔数组来记录每个数字是否被使用过 boolean[] used = new boolean[n]; // 创建一个数组来存储每个数字的目标位置 int[] target = new int[n]; for (int i = 0; i < n; i++) { target[a[i] - 1] = i; } // 尝试重新排列指令 for (int i = 0; i < n; i++) { if (!used[i]) { int j = i; int cycleLength = 0; while (!used[j]) { used[j] = true; j = target[j]; cycleLength++; } if (cycleLength % 2 != 0) { return false; } } } return true; } } ``` ### 解释 1. **输入处理**:首先读取测试用例的数量T,然后对于每个测试用例,读取指令的数量n和指令的初始排列a。 2. **目标位置计算**:通过创建一个`target`数组来存储每个数字的目标位置。 3. **重新排列检查**:使用一个布尔数组`used`来记录每个数字是否被使用过。遍历每个数字,如果它还没有被使用过,则开始一个新的循环,并计算循环的长度。如果循环的长度是奇数,则返回`false`,否则继续。 4. **输出结果**:如果所有循环的长度都是偶数,则返回`true`,否则返回`false`。 ### 关键点 - **循环检测**:通过记录每个数字是否被使用过,避免重复计算。 - **奇偶性检查**:只有当所有循环的长度都是偶数时,才能成功重新排列指令。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kgduu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值