全排列生成算法

生成全排列的几种思路

(2011-10-08 13:39:14)

转载▼

标签： 杂谈

分类：IT

　　“如果在可能的地方找不到，就去不可能的地方找。”这是一句废话，也是一句挺有道理的话，甚至有时候，它还是一句有用的话。因为生活中有时真的会有神奇的事情发生。元宵节的前一天晚上，我和一位同事加班到10点半，正准备回家的时候，突然发现大事不妙——办公室唯一的一把钥匙找不到了——没有钥匙就没办法锁门，我们回不去家了。办公室是客户借给我们的，备份钥匙只有客户有，但是这么晚了实在不好意思打电话求救。钥匙是我几个小时前放在同事的桌子上的，却不知被同事随手扔到哪里去了。桌子上，抽屉里，所有的包包和衣服兜全找过了，就是不见钥匙的踪影。现在我们有3种选择：1）放弃。在办公室里睡到天亮或者不锁门就回家（但是那一屋子的电脑还有服务器实在让人放心不下）；2）再找一遍。不过已经找了2遍了，再原样重复一遍结果也不会有什么改变。3）去不可能的地方找。我决定碰碰运气。结果，5分钟之后，我居然在桌子上一个装着汤圆的袋子里找到了那把已经冻得冰凉的钥匙。
　　如果没办法直接取得沙子里的金子，就把沙子和金子一同捞起来，再用水慢慢淘去沙子，留下砂金。如果没有办法直接求解，可以先找到一个虽然大一些但是比较容易取得的包含所有解的搜索空间，再使用评估函数判断搜索空间里每一个潜在解的质量。
　　现在我们想求得["a","b","c"]的全排列，也就是想要得到解（为了看着舒服省略了引号）：
[[a,b,c],
 

[a,c,b],
  [b,a,c],
  [b,c,a],
  [c,a,b],
  [c,b,a]]
数组的下标的排列是：
0 1 2
0 2 1
1 0 2
1 2 0
2 0 1
2 1 0
有没有什么方法可以由“0 1 2”经过某种计算得到下一个下标的排列“0 2 1”呢？如果把 012 看作是一个3进制的数字，那么把012 加 1 就得到了 021。但是，把 021 加 1 得到的是 022 而 不是102。所以，用这种方法比较容易得到可重复的排列，从000开始，每次增加1可以得到：
0 0 0
0 0 1
0 0 2
0 1 0
0 1 1
0 1 2
0 2 0
0 2 1
0 2 2
1 0 0
1 0 1
1 0 2
1 1 0
1 1 1
1 1 2
1 2 0
1 2 1
1 2 2
2 0 0
2 0 1
2 0 2
2 1 0
2 1 1
2 1 2
2 2 0
2 2 1
2 2 2
其中绿颜色表示的是我们想要的结果，我们只要把它们挑出来就好。
如果把 currentIndexList 看作是一个 currentIndexList.Count进制的数字，GetNextIndexList() 函数的作用是把这个数字增加1：

viewsource print ?

// 获取currentIndexList 的下一个排列。例如 currentIndexList =[0,1,1]，调用此函数之后，

//currentIndexList 将变为 [0,1,2]；[0,2,2] 变为[1,0,0]

staticvoid GetNextIndexList(IList<int>currentIndexList)

{

intcount =currentIndexList.Count;

for(int i = count-1;i >= 0; i--)

{

if(currentIndexList[i] //不需要进位

{

currentIndexList[i]++;// 当前位加1

return;

}

else

{

currentIndexList[i]= 0; //进位前把当前位置0

}

}

}

接着，我们只要调用 GetNextIndexList() 函数  n ⁿ次(n=source.Count)，就可以遍历整个搜索空间，然后再判断是否所有下标都不重复就可以知道是不是想要的解了：

viewsource print ?

// 生成source 的全排列。

staticIEnumerablestring>>Permutation1(IList<string> source)

{

//初始化 indexList，使它具有 source.Count 个值为0的元素。

intcount = source.Count;

IList<int>indexList = newList<int>();

for(int i = 0; i< count; i++)

{

indexList.Add(0);

}

for(int i = 0; i< Math.Pow(count, count); i++)

{

GetNextIndexList(indexList);

if(indexList.Distinct().Count() ==count) //不重复

{

IList<string>result = newList<string>();

foreach(int jin indexList)

{

result.Add(source[j]);

}

yieldreturn result;

}

}

}

测试一下：

viewsource print ?

IList<string> s = new List<string> { "a","b", "c"};

foreach(IList<string>item in Permutation1(s))

{

Console.WriteLine(item.Montage(t=> t, ""));

}

注： Montage()是一个方便把列表拼接成字符串的扩展方法。

　　这种方法的缺点是效率比较差。要生成n个元素的全排列需要遍历  n ⁿ次才能得到 n! 个解（看上面那个绿色和黑色的下标的比例也可以有一个直观的感觉）。
　　由于这种方法可以根据当前下标计算出下一个下标，所以可以使用 yield return“按需生成”所需要的全排列，如果只需要得到前面几个而不是所有的全排列，会很划算。

思路2：一致，一致，一致！

　　第一种方法虽然简单，但是效率太差。能不能每次不是加1，而是加n，一下子就得到下一个排列呢？你可以亲自尝试一下，要想知道每次应该加多少真的很难。我们只好换个思路，能否通过交换数组元素得到下一个排列呢？譬如有数组s = ["A", "B", "C", "D"]，只要交换 s[2] 和 s[3] 就可得到下一个排列 A B DC。但是要得到下一个排列 A C B D 需要先交换 s[1] 和 s[3]，再交换 s[2] 和s[3]……有时只需交换一次，有时需要交换两次，有时甚至需要交换3次。 看图找规律神马的最讨厌了。但是如果不能找出一个 一致的处理方法，就没法编写程序。
　　从哪里着手呢？ 当问题难以直接求解时，如果可以先得到一个间接结果，一个可跟踪的线索，问题往往会变得简单很多。
　　所以我们可以先试试能否找出一个 一致的方法来确定第一次要交换的是哪两个元素。我们先使用常规办法：观察一个样本（例如ABCD的所有排列），看看是否能找到什么规律。但是这一次恐怕要失望了：第一次要交换的两个元素有可能是相邻的，也有可能不相邻；有可能是最大（或最小）的元素，也可能不是；有可能是第一个（或最后一个）元素，也有可能不是……除了前一个元素一定比后一个小之外，似乎难以发现其他规律。
　　好像要卡住了。我们换个思路—— 反着想：“什么情况下无法通过交换两个元素来得到下一个排列？”为什么这个问题有意义呢？让我们回想一下 目标：得到下一个（字典序的）排列。“下一个（字典序的）排列”的 定义是：只比前一个排列大一点点的那个排列。第一个排列（例如A B C D）是最小的那个排列，它一定是最小的元素在最高位、最大的元素在最低位。当我们想得到 A B C D的下一个排列时，一定是优先交换它的最低位的那个元素（也就是 C 和D），这样才能保证得到的是仅比当前排列大一点点的那个排列。只有无法交换最低2位来得到下一个排列时，才会考虑交换更高位的元素（例如想得到A B D C 的下一个排列时，就不能交换 D 和 C）。
　　那么，什么情况下无法通过交换两个元素来得到下一个排列呢？答案是，当子数组已经是最后一个排列时。例如，当前排列是 A B D C时，因为 “D C” 这个排列是子数组 [C,D] 的最后一个排列，所以交换 D C 的任意两个元素都只会得到比 D C这个排列更小的排列。同理，当前排列是 A D C B  时，由于 “D C B” 已经是子数组[B,C,D] 的最后一个排列，所以无法通过交换 D  CB  里的任意两个元素的方法得到下一个排列，只能交换 A 和B。这样我们终于可以确定第一次要交换的两个元素了：（从低位到高位找到的那个）已经是最后一个排列的子数组 subs 前面的那个元素 a和 subs里只比 a 大一点点的那个元素。举几个例子（下划线标出的是 subs，绿颜色标出的是第一次要交换的两个元素）：
A B C D
A B D C
A C B D
A C D B
A D B C
A D C B
...
B D C A

　　subs 的特征很明显，它一定是倒序排列的。
　　接下来想一想在做了第一次交换之后，还要做什么才能得到想要的下一个排列。例如想要得到 A D C B 的下一个排列 B A C D。首先，交换 A 和 B，得到B  D C A。这样保证了最高位只比当前排列大了一点点。然后再把 D C A变成最小的排列，也就是要把 D C  A 反转得到 A C D。这样得到的 B A C D一定是只比  A D C B 大一点点的那个排列。
下面是源代码：

viewsource print ?

///

///返回source的全排列

///

///

///

publicstatic IEnumerable<string[]> Permutation2(string[]source)

{

if(source.Length <=0)

yieldbreak;

string[]s = new string[source.Length];

Array.Copy(source,s, source.Length);

do

{

yieldreturn s;

}

while(NextPermutation(s) ==true);

}

// 将 s变换为下一个字典序排列。当前排列已经是最后一个排列时，返回false

privatestatic bool NextPermutation(string[]s)

{

inthighIndex = 0;

intlowIndex = s.Length - 1;

intsubsHighIndex =FindSubsHighIndex(s);

if(subsHighIndex == highIndex)// s已经是最后的排列

returnfalse;

Swap(s,subsHighIndex - 1, LastIndex(s, t => s[subsHighIndex- 1].CompareTo(t) <= 0));

Reverse(s,subsHighIndex, lowIndex);

returntrue;

}

//确定subs的高位index。subs是s最低n位的子数组，它已经是此子数组的最后一个排列

privatestatic int FindSubsHighIndex(string[]s)

{

inthighIndex = 0;

intlowIndex = s.Length - 1;

intresult = lowIndex;

for( ; result > highIndex;result--)

{

if(s[result].CompareTo(s[result - 1])> 0)

returnresult;

}

returnresult;

}

// 交换s[i] 和 s[j]

privatestatic void Swap(string[]s, int i, intj)

{

stringtemp = s[i];

s[i]= s[j];

s[j]= temp;

}

// 反转s[startIndex]..s[endIndex]

privatestatic void Reverse(string[]s, int startIndex, int endIndex)

{

while(startIndex

{

Swap(s,startIndex, endIndex);

startIndex++;

endIndex--;

}

}

//从后向前搜索s，返回第一个满足predicate()==true的元素下标；找不到时返回-1

privatestatic int LastIndex(string[] s,Func<string,bool> predicate)

{

for(int i = s.Length- 1; i >= 0; i--)

{

if(predicate(s[i]) == true)

returni;

}

return-1;

}

测试一下：

viewsource print ?

string[] s= new string[]{ "A", "B","C", "D"};

foreach(string[]p in Permutation2(s))

{

Console.WriteLine(p.Montage(t=> t, ""));

}

　在 上一篇的方法一里，我们使用把数组的下标每次增加1的方法得到重复的全排列，然后再挑出不重复的全排列。如下图所示，绿颜色表示想要得到的结果。
0 0 0
0 0 1
0 0 2
0 1 0
0 1 1
0 1 2
0 2 0
0 2 1
0 2 2
1 0 0
1 0 1
1 0 2
1 1 0
1 1 1
1 1 2
1 2 0
1 2 1
1 2 2
2 0 0
2 0 1
2 0 2
2 1 0
2 1 1
2 1 2
2 2 0
2 2 1
2 2 2
　　这种方法虽然简单，但是效率比较差。要生成n个元素的全排列需要遍历  n ⁿ次才能得到 n! 个解（看上面那个绿色和黑色的下标的比例也可以有一个直观的感觉）。能不能直接把当前排列增加 i得到下一个排列呢？例如，把 012 增加 2 得到 021 （按 3 进制计算），把 021 增加 4 得到 102……把 201增加 2 得到 210？可以看到，有时候是增加 2，有时候是增加 4，很难摸清其中的规律（如果想求 [1,2,3,4]的全排列，会发现有时候需要增加 3，有时候需要增加 6，有时候需要增加 9，甚至有时候需要增加 21）。这里的难点是，把数字增加 i之后，可能会发生一连串的进位，而你很难知道这一连串的进位之后，哪两个位上的数字会重复。 当问题的变量很多，而这些变量又相互影响时，问题就会变得复杂而难以解决。要想简化问题，就必须找到一个一致的方法表达这些相互影响的变量对结果的影响。 把多个维度叠加到一个维度之上，是简化问题的常用手段。譬如，能否找到一个一致的方法把全排列映射为一个每次增加1的序列呢？也就是：
[0,1,2] => 0
[0,2,1] => 1
[1,0,2] => 2
[1,2,0] => 3
[2,0,1] => 4
[2,1,0] => 5
这样给出[2,0,1]就可以知道它是第5个排列了；反过来，根据这种独特的映射方法，也有可能知道第5个排列是[2,0,1]。这个映射可以使用康托展开来实现。

康托展开

　　康托展开的公式是 X=an*(n-1)!+an-1*(n-2)!+...+ai*(i-1)!+...+a2*1!+a1*0!其中，ai为当前未出现的元素中是排在第几个（从0开始）。
　　这个公式可能看着让人头大，最好举个例子来说明一下。例如，有一个数组 s = ["A", "B", "C", "D"]，它的一个排列s1 = ["D", "B", "A", "C"]，现在要把 s1 映射成 X。n 指的是数组的长度，也就是4，所以
X(s1) = a4*3! + a3*2! + a2*1! + a1*0!
关键问题是 a4、a3、a2 和 a1  等于啥？
a4 = "D" 这个元素在子数组 ["D", "B", "A", "C"]中是第几大的元素。"A"是第0大的元素，"B"是第1大的元素，"C" 是第2大的元素，"D"是第3大的元素，所以 a4 =3。
a3 = "B" 这个元素在子数组 ["B", "A", "C"]中是第几大的元素。"A"是第0大的元素，"B"是第1大的元素，"C" 是第2大的元素，所以 a3 = 1。
a2 = "A" 这个元素在子数组 ["A", "C"] 中是第几大的元素。"A"是第0大的元素，"C"是第1大的元素，所以 a2 =0。
a1 = "C" 这个元素在子数组 ["C"] 中是第几大的元素。"C" 是第0大的元素，所以 a1 =0。（因为子数组只有1个元素，所以a1总是为0）
所以，X(s1) = 3*3! + 1*2! + 0*1! + 0*0! = 20
康托展开的C#代码如下：

viewsource print ?

// 返回s的康托展开值

static long X(string[] s)

{

longresult =0;

intlen =s.Length;

for(int i = 0; i < len;i++)

{

result+= An(s, i) * Factorial(len - i - 1);

}

returnresult;

}

// 返回 s[n] 是 s[n..length]中第几大的元素

static int An(string[] s, int n)

{

intresult =0;

for(int i = n + 1; i

{

if(s[n].CompareTo(s[i])>= 0)

result++;

}

returnresult;

}

// 返回 input 的阶乘

static int Factorial(int input)

{

intresult =1;

for(int i = 2; i <= input;i++)

{

result= result * i;

}

returnresult;

}

测试一下：

viewsource print ?

string[] s = new string[] { "A","B","C" };

foreach (string[] p in Permutation2(s))

{

Console.WriteLine(p.Montage(t=> t, " ") + " | " +X(p).ToString());

}

Permutation2() 和 Montage() 函数请参考上一篇。测试输出如下：
A B C | 0
A C B | 1
B A C | 2
B C A | 3
C A B | 4
C B A | 5

通过康托逆展开生成全排列

　　如果已知 s = ["A", "B", "C", "D"]，X(s1) = 20，能否推出 s1= ["D", "B", "A", "C"] 呢？
　　因为已知 X(s1) = a4*3! + a3*2! + a2*1! + a1*0! = 20，所以问题变成由 20能否唯一地映射出一组 a4、a3、a2、a1？如果不考虑 ai 的取值范围，有
3*3! + 1*2! + 0*1! + 0*0! = 20
2*3! + 4*2! + 0*1! + 0*0! = 20
1*3! + 7*2! + 0*1! + 0*0! = 20
0*3! + 10*2! + 0*1! + 0*0! = 20
0*3! + 0*2! + 20*1! + 0*0! = 20
等等。但是满足 0 <= ai <= n-1的只有第一组。可以使用辗转相除的方法得到 ai，如下图所示：

知道了a4、a3、a2、a1的值，就可以知道s1[0] 是子数组["A", "B", "C", "D"]中第3大的元素"D"，s1[1] 是子数组 ["A", "B", "C"] 中第1大的元素"B"，s1[2] 是子数组 ["A","C"] 中第0大的元素"A"，s[3] 是子数组 ["C"] 中第0大的元素"C"，所以s1 =["D", "B", "A", "C"]。
这样我们就能写出一个函数 Permutation3()，它可以返回  s 的第 m 个排列。

viewsource print ?

// 返回 s 的第 m 个排列（m 从 0 开始）。要求 s是升序排列的

static string[] Permutation3(string[] s, int m)

{

IList<string>sub = new List<string>(s);

IList<string>result = new List<string>();

for(int i = s.Length - 1; i >=0; i--)

{

intf =Factorial(i);

intai = m /f;

stringitem = sub[ai];//由于数组是升序排列的，所以第 ai 大的元素就是 sub[ai]

result.Add(item);

sub.RemoveAt(ai);

m= m % f;

}

returnresult.ToArray();

}

测试一下：

viewsource print ?

string[] s = new string[] { "A","B","C","D" };

for (int i = 0; i

{

string[]s1 = Permutation3(s, i);

Console.WriteLine(s1.Montage(t=> t, " "));

}

附录康托展开是怎么来的？

　　很显然，康托展开是本文的关键所在。你说康托他老人家当初是怎么想出来这种展开的方法的呢？我们还是以 s=["A", "B","C"] 为例：

A B C | 0
A C B | 1
B A C | 2
B C A | 3
C A B | 4
C B A | 5

　　他的思路可能是这样的：首先，确定一个目标：将每个排列映射为一个自然数，这个自然数是顺序增长的（或者至少要有一定的规律）。要说映射成自然数，第一个想到的方法自然是把数组的下标当作一个n进制的数字，但是正如本文开篇所讨论的，这个数字并没有什么规律；第二个方法是计数，也就是令X = 当前排列之前有多少个排列。例如 A B C 是第一个排列，它前面没有任何排列，所以 X(ABC) = 0；A C B前面有一个排列，所以 X(ACB) = 1……那么如何才能知道 X(BCA) = 3 也就是 B CA的前面有3个排列呢？这里的技巧仍然是分解——把问题分隔成相互独立的有限的小块。具体的方法是：先求出B 第一次出现在最高位（也就是 B A C 这个排列）时前面有几个排列，再求出 B C A 是 BA C 后面第几个排列，把这个两个数相加就是想要的结果了。
　　先看第一个问题：B 第一次出现在最高位（也就是 B A C 这个排列）时前面有几个排列？由于已知B A C 前面的排列一定是 A 开头的，所以只有 A 后面的两个元素可以变化，所以排列数是 P(2,2) = 2! 个。
　　第二个问题：B C A 是 B A C 后面第几个排列？因为都是 B 开头的，所以可以把开头的 B 忽略，问题变成 C A 是 AC 后面的第几个排列？同样，可以先考虑 C 第一次出现在最高位时前面有几个排列，因为 C A 前面的排列肯定是 A 开头的，所以只有A 后面的一个元素可以变化，所以排列数是 P(1,1) = 1! 个。
　　所以 X(BCA) = 2! + 1! = 3
　　再例如想求 X(CBA)，同样是先考虑 C 第一次出现在最高位时前面有多少个排列，因为比 C 小的元素有 A 和 B 两个，所以是2*2! 个。再求出 B  A 是 A B 后面的第 1! 个排列。就可以知道 X(CBA) =2*2! + 1! = 5 了。