全排列的题目

本文介绍了一个Java程序案例,该程序用于生成特定数字序列的所有不同排列,并遵循特定的约束条件,例如数字4不能位于第三位及数字3和5不能相邻等。通过递归算法实现,详细解释了核心函数的工作原理。

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

[url]
原文地址:
http://www.blogjava.net/nokiaguy/archive/2008/05/10/199647.html
[/url]
[url]
另外一篇文章:
http://topic.youkuaiyun.com/u/20070114/14/1170e023-e8f0-4331-8bd8-516c6f1e40da.html
[/url]
[b]原题如下:[/b]
用1、2、2、3、4、5这六个数字,用java写一个程序,打印出所有不同的排列,如:512234、412345等,要求:"4"不能在第三位,"3"与"5"不能相连。
[b]解题思路:[/b]
很明显,这是一个递归算法。我们可以排列将这6个数按从小到大的顺序排一下,如果是1,2,3,4,5,6,那么会有1*2*3*4*5*6= 6!=720个递增的数。但如果是1,2,2,3,4,5,那么在这720个数中一定会有相同的数对出现(由于在这6个数中只有两个数两同,也就是说,如果有重复的数,那么一定是一对数,如122345会出现两次)。

排列的基本规则是分步进行。也就是说,要排列上面6个数,首先应该选择第一个数,这第一个数可以选择这6个数中的任意一个,如选择1.第二步是选择第二个数,这第二个数不能再选择已经选过的数,如1.因此,它只能从后面5个数中选择。如选择2。以此类推。

我们也可以在程序中模拟这一过程。源程序如下:

public class test1
{
private int[] numbers = new int[]
{ 1, 2, 3, 3, 4, 5 };
public int n;
private String lastResult = "";

private boolean validate(String s)
{
if (s.compareTo(lastResult) <= 0)
return false;
if (s.charAt(2) == '4')
return false;
if (s.indexOf("35") >= 0 || s.indexOf("53") >= 0)
return false;
return true;
}

public void list(String index, String result)
{
for (int i = 0; i < numbers.length; i++)
{
if (index.indexOf(i + 48) < 0)
{
String s = result + String.valueOf(numbers[i]);
if (s.length() == numbers.length)
{
if (validate(s))
{
System.out.println(s);
lastResult = s;
n++;
}
break;
}
list(index + String.valueOf(i), s);
}
}
}

public static void main(String[] args)
{
test1 t = new test1();
t.list("", "");
System.out.println("总数:" + t.n);

}
}


其中list函数是这个算法的核心函数。index参数表示已经选择过的数,用numbers数组的索引表示。如index="012",表示numbers的前三个数已经被选择,也表示应该选择第四个数了,而这第四个数应该从后三个数中选择。result参数表示临时的数字组合(这个数字组合最多是5个数字,因为,如果到了6个数字,就表示已经有一个结果产生了)。在默认情况下index和result的值都是""。

在validate中使用了 if (s.compareTo(lastResult) <= 0)进行判断,由于按这种方法进行排列,如果这6个数是递增给出的,那么排列的结果一定是递增的,但上述的6个数其中第2和第3个位置上都是2,因此,如果出现了上一个结果不小于当前结果的情况,一定是有重复了,因此,要将这部分数过滤出去。
==============================================================
以下是评论:
问题1:
请问index.indexOf(i + 48) < 0判断条件的作用是什么?

回答1:
ndex保存了当前数字串的索引,index.indexOf(i + 48) < 0就是判断当前的数字的索引是否在index中(由于给定的数字串有重复的数字,因此,只能使用索引来判断了),如果不在,就会认为这个数字还没有加到index中,如果存在了,说明这个数已经在数字串中了。
注: i+48 ,当i=0时,正好是数字0的ASCII,因为index中存的毕竟是索引,是位置嘛,所以是从0开始的
<think>好的,我现在要解决全排列的问题。全排列是指给定一组不同的元素,返回所有可能的排列方式。比如输入[1,2,3],应该输出六个排列。首先,我需要想清楚怎么用算法来实现这个功能。首先想到的是回溯法。回溯法通常用于解决这种需要遍历所有可能情况的问题。全排列的生成可以通过递归和交换元素来实现。例如,对于每个位置,依次将后面的元素交换到当前位置,然后递归处理剩下的位置。当处理到最后一个元素时,就得到一个排列,记录下来。 那具体怎么操作呢?假设有一个函数,参数是当前需要处理的起始位置,当起始位置到达数组末尾时,将当前数组加入结果列表。否则,从起始位置开始,每个元素都交换到起始位置,然后递归处理下一个位置,处理完后再交换回来,恢复原状,避免影响后续的交换。这就是回溯的基本思路。 接下来要考虑的是重复元素的情况。但题目中假设元素是不同的,所以暂时不需要处理重复的情况。但如果元素有重复,可能需要去重,比如在交换前判断是否已经交换过相同的元素,避免重复排列。 然后,编写代码。以Python为例,定义一个递归函数,参数包括数组nums,当前的位置start,以及结果列表res。当start等于数组长度时,将当前数组的副本加入结果(因为后续操作会修改数组,所以需要复制)。否则,循环从start到数组末尾,依次交换start和i位置的元素,递归调用start+1,之后再交换回来,恢复状态。测试一下这个算法,比如输入[1,2,3],应该生成6种排列。每次递归时,第一个位置依次是1、2、3,然后处理剩下的部分。这样确实能覆盖所有可能的情况。 那代码的大致结构应该是怎样的?举个例子: def permute(nums): res= [] defbacktrack(start):if start == len(nums): res.append(nums.copy())returnfor i in range(start, len(nums)): nums[start], nums[i]= nums[i],nums[start]backtrack(start +1) nums[start], nums[i] = nums[i], nums[start]backtrack(0) return res这样应该可以生成所有排列。这里需要注意的是,在添加到结果列表时,必须使用nums.copy(),因为直接添加nums的话,后续的交换操作会改变已经添加到结果中的列表,导致结果错误。 现在,考虑另一种方法,使用深度优先搜索(DFS),维护一个路径path和一个记录已使用元素的列表used。每次递归时,选择一个未被使用的元素,加入path,标记为已使用,递归直到path长度等于原数组长度,然后回溯,恢复used状态,并移除path的最后一个元素。这种方法可能更容易理解,但需要额外的空间存储used数组。 例如: def permute(nums): res= [] used= [False]* len(nums)def dfs(path): if len(path) == len(nums): res.append(path.copy())returnfor i in range(len(nums)):if not used[i]: used[i] = Truepath.append(nums[i]) dfs(path) path.pop() used[i] = Falsedfs([]) return res这种方法同样有效,而且适用于元素可能重复的情况,虽然当前题目假设元素不同。但这种方法的空间复杂度稍高,因为需要维护used数组和path的递归栈。 比较两种方法,回溯法的交换方法更节省空间,因为它直接在原数组上进行操作,不需要额外的used数组,但可能更难理解。而DFS方法更直观,但需要额外的空间。 现在,需要验证这两种方法的正确性。例如,对于输入[1,2,3],两种方法都应该返回6个排列。测试一下交换法:当start=0时,i从0到2循环。第一次交换0和0位置,数组不变,递归处理start=1。在start=1的位置,i从1到2循环,交换1和1,然后递归到start=2,此时添加数组。接着回溯到start=1,交换回来,然后i=2,交换1和2的位置,得到[1,3,2],递归到start=2,添加。这样依次下去,确实能得到所有排列。 那么,这两种方法的时间复杂度都是O(n!),因为全排列的数量是n!,每个排列生成的时间是O(n),所以总的时间复杂度是O(n* n!)。空间复杂度,交换法主要是递归栈的深度O(n),而结果存储是O(n!*n),所以总的空间复杂度是O(n! *n)。DFS方法同样如此。 现在,回到问题,用户可能需要一个具体的实现。这里给出交换法的代码,并解释其过程。然后,可能还会给出DFS方法的代码作为补充。所以,最终的解决方案可以是两种方法的代码,并解释它们的原理。然后相关问题可能涉及时间复杂度、如何处理重复元素、其他算法实现等。</think>排列可以通过回溯算法实现,以下是使用Python的实现代码: ```python def permute(nums): def backtrack(start): if start == len(nums): result.append(nums.copy()) return for i in range(start, len(nums)): nums[start], nums[i] = nums[i], nums[start] backtrack(start + 1) nums[start], nums[i] = nums[i], nums[start] result = [] backtrack(0) return result # 示例用法 print(permute([1, 2, 3])) # 输出所有6种排列 ``` 上述代码通过交换元素的位置生成排列,具体过程如下: 1. `backtrack`函数通过`start`参数标记当前处理位置 2. 当`start`到达数组末尾时记录当前排列 3. 通过循环将后续元素依次交换到`start`位置 4. 递归处理下一个位置后恢复交换状态(回溯) 另一种基于DFS和标记数组的实现: ```python def permute_dfs(nums): def dfs(path, used): if len(path) == len(nums): result.append(path.copy()) return for i in range(len(nums)): if not used[i]: used[i] = True path.append(nums[i]) dfs(path, used) path.pop() used[i] = False result = [] dfs([], [False]*len(nums)) return result ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值