求教10个数字的排列算法--一个有趣的数学问题。

[jklq]

0－9共十个数字球，如果每次从其中拿出两个数组成不重复的组合（不管取出的球的顺序，比如01和10相同，算是一种组合），如01，02，03....89。共有45种组合。计算公式：10×9/2=45。
问题是：如何能把这45种组合，做出九个排列（45/5＝9)。使每一个排列都有0，1，2，3，4，5，6，7，8，9这10个数。问题好像很简单，哪位高手能排出来呢？我有个程序要用到。谢谢各位关注！

[mathe]

hehe,最后一个数据漏了最后一行，当然就是
9618275340了（根据对称性）

[mathe]

估计一下，解的总体数目大概在5×10^10种左右。

[寻开心]

问题：
10个数，每次取两个，有45种组合。
把这45种组合，做出九个排列（45/5＝9)
使每一个排列都有0，1，2，3，4，5，6，7，8，9这10个数。

想法：
只要是10个数的全排列当中的任何一个，都可以对应出满足楼主的一个解
既然是全排列，肯定包含的是0到9这个数而且不重复，每两个都对应45个组合当中的一个

全排列当中会有2^5个等价的排列，去除他们之后，在剩余的所有的可能当中任意取多少都可以的啊
为什么有 45/5=9 个排列的说法呢？

[mathe]

10个数中取两个数，总共只有45个组合，也就是下面45种组合：
12 39 48 57 60
13 20 49 58 67
14 23 59 68 70
15 24 30 69 78
16 25 34 79 80
17 26 35 40 89
18 27 36 45 90
19 28 37 46 50
10 29 38 47 56
现在要求将这15个组合分成9组，要求每组5个组合中0,1,...,9都正好出现一次

[寻开心]

那就是说每个组合在这个排列当中仅出现一次
那么下面这个就不可能是正解啊，因为01 10是相同的组合，他们多次出现了
01 23 45 67 89
10 32 54 98 76
23 05 98 74 61
32 50 76 49 18
45 97 01 86 32
54 86 10 23 97
69 74 82 01 53
78 49 63 10 25
87 61 39 52 04
96 18 27 35 40
mathe前面给出手工构造的那个才是
12 39 48 57 60
13 20 49 58 67
14 23 59 68 70
15 24 30 69 78
16 25 34 79 80
17 26 35 40 89
18 27 36 45 90
19 28 37 46 50
10 29 38 47 56
而能够满足这样条件的结果不会很多吧

[wangmin_yjitx]

对以上两位解决问题的执着和科学认真态度致敬!!!!!!!

[jklq]

谢谢各位高手的关注，我手工找到了解决办法：列出来给各位分享。结果如下：
10个数分成偶数和奇数两行，上下组合
02468
13579

得到01 23 45 67 89 （暂时不计算在内）
偶数向后移动一个数，由02468变成24680，上下组合。以后每次偶数都向后移动一位后和奇数组合得到以下四个结果。

1。 12 34 56 78 90
2。 14 36 58 70 92
3。 16 38 50 72 94
4。 18 30 52 74 96

另外，每次由01 23 45 67 89 中的一个和其他全单全偶组合成剩下的5种组合，（注意下面每组都是上下组合的）如下：
5。 0 2 3 4 5
1 8 9 6 7

6。 2 4 5 6 7
3 0 1 8 9

7。 4 6 7 8 9
5 2 3 0 1

8。 6 8 9 0 1
7 4 5 2 3

9。 8 0 1 2 3
9 6 7 4 5

大家发现以上5种排列组合的特点了吗。挺好玩的。

[寻开心]

写了一个小生成程序，计算出了一组
01 23 45 67 89
02 13 46 58 79
03 12 47 59 68
04 15 26 39 78
05 14 27 38 69
06 17 28 35 49
07 18 29 34 56
08 19 24 36 57
09 16 25 37 48
稍后再完善一下程序，看看可以生成多少组结果

[寻开心]

总共找到了6组
第1个
01 23 45 67 89
02 13 46 58 79
03 12 47 59 68
04 15 26 39 78
05 14 27 38 69
06 17 28 35 49
07 18 29 34 56
08 19 24 36 57
09 16 25 37 48



第2个
02 34 56 79 18
03 14 57 69 28
04 13 59 26 78
05 16 27 49 38
06 15 29 48 37
07 19 35 68 24
08 25 17 39 46
09 36 12 47 58
23 45 89 01 67



第3个
03 45 68 12 79
04 15 69 23 78
05 14 67 29 38
06 17 34 25 89
07 16 39 24 58
08 26 47 13 59
09 27 35 18 46
19 37 48 02 56
28 57 01 36 49



第4个
04 56 78 19 23
05 16 79 28 34
06 17 24 35 89
07 18 36 45 29
08 25 47 13 69
09 37 12 46 58
14 38 59 02 67
26 48 01 39 57
49 68 15 03 27



第5个
05 67 89 24 13
06 18 23 45 79
07 19 25 38 46
08 26 37 59 14
09 27 48 16 35
12 39 56 04 78
15 47 68 29 03
28 49 36 01 57
58 69 34 02 17



第6个
06 79 12 34 58
07 19 24 68 35
08 23 45 69 17
09 27 46 15 38
13 28 49 67 05
14 56 78 39 02
16 57 03 29 48
37 04 18 26 59
89 01 25 36 47

[寻开心]

但组计算的问题解决了
在计算下一组的算法上可能存在问题，现在忙，过两天再来调试。
应该不止这么几个的

[mathe]

To happy__888([顾问团]寻开心):
我上面给出的列表不是直接结果，而是中间结果，
就像我上面说的，这些给出的是一些10X10方阵。
比如方阵：
0 1 2 3 4 5 6 7 8 9
1 0 3 2 5 4 9 8 7 6
2 3 0 5 9 8 7 4 6 1
3 2 5 0 7 6 4 9 1 8
4 5 9 7 0 1 8 6 3 2
5 4 8 6 1 0 2 3 9 7
6 9 7 4 8 2 0 1 5 3
7 8 4 9 6 3 1 0 2 5
8 7 6 1 3 9 5 2 0 4
9 6 1 8 2 7 3 5 4 0
其中位置(0,1)对应的元素是1，也就是说，组合01在第一组。
同样，位置(0,2)对应的元素是2，所以组合02在第二组。

[mathe]

计算机还挺快，运行79分钟，总共
1,225,566,720个解。

[mathe]

贴出前面几个转化格式后的解：
01 23 46 59 78
02 13 48 56 79
03 12 49 57 68
04 15 28 37 69
05 14 29 38 67
06 17 24 39 58
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 46 59 78
02 13 49 57 68
03 12 48 56 79
04 15 28 37 69
05 14 29 38 67
06 17 24 39 58
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 48 56 79
02 13 46 59 78
03 12 49 57 68
04 15 28 37 69
05 14 29 38 67
06 17 24 39 58
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 49 57 68
02 13 46 59 78
03 12 48 56 79
04 15 28 37 69
05 14 29 38 67
06 17 24 39 58
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 48 56 79
02 13 49 57 68
03 12 46 59 78
04 15 28 37 69
05 14 29 38 67
06 17 24 39 58
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 49 57 68
02 13 48 56 79
03 12 46 59 78
04 15 28 37 69
05 14 29 38 67
06 17 24 39 58
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 46 58 79
02 13 48 57 69
03 12 49 56 78
04 15 28 39 67
05 14 29 37 68
06 17 24 38 59
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 46 58 79
02 13 49 56 78
03 12 48 57 69
04 15 28 39 67
05 14 29 37 68
06 17 24 38 59
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 48 57 69
02 13 46 58 79
03 12 49 56 78
04 15 28 39 67
05 14 29 37 68
06 17 24 38 59
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

01 23 49 56 78
02 13 46 58 79
03 12 48 57 69
04 15 28 39 67
05 14 29 37 68
06 17 24 38 59
07 16 25 34 89
08 19 26 35 47
09 18 27 36 45

[xdspower]

楼主新的想法不错，不过应该没有构造完，比如你的第5个就还可以用前面的方法构造新的组合可能。

[mathe]

通过定义宏DEBUG
比如
gcc -O3 -DDEBUG filename.c -o output
就可以让程序输出所有结果到113个148M的文件
（呵呵，当然你的磁盘空间要足够大，我的Linux在输出到103个文件时就把磁盘空间给用光了）

#include <stdio.h>
#define N 10
#define M (N*(N-1)/2)
int BUF[M];
int ROW[N][N-1];//if digit j is used in ROW i then ROW[i][j]=1
#define index(i,j) (j)*((j)-1)/2+(i)
#define elem(i,j) ((i)<(j))?(index(i,j)):(index(j,i))
#define SET(i,j,x) BUF[elem(i,j)]=(x)+1
#define GET(i,j) ((i==j)?INVALID:BUF[elem(i,j)]-1)
#define UNSET(i,j) BUF[elem(i,j)]=0
#define INVALID -1
FILE *out;
int tcount;
#ifdef DEBUG
void output()
{
int i,j,k;
if(tcount%1024000==0){
char f[10];
sprintf(f,"out%d",(int)(tcount/1024000));
if(out)fclose(out);
out=fopen(f,"w");
}
for(k=0;k<N-1;k++){
for(i=0;i<N;i++){
for(j=i+1;j<N;j++){
if(GET(i,j)==k)fprintf(out,"%d%d ",i,j);
}
}
fprintf(out,"\n");
}
fprintf(out,"\n");
}
#else
void output()
{
}
#endif
long long search(int i,int j)
{
int k;
long long count=0;
for(k=0;k<N-1;k++){
if(!ROW[i][k]&&!ROW[j][k]){
//Have a try to set element (i,j) to k
SET(i,j,k);
ROW[i][k]=1;
ROW[j][k]=1;
if(i==N-2&&j==N-1){
//Get a solution
output();
count++;
tcount++;
}else{
count+=(j==N-1)?search(i+1,i+2):search(i,j+1);
}
//Recover states
UNSET(i,j);
ROW[i][k]=0;
ROW[j][k]=0;
}
}
return count;
}
int main()
{
int i,j;
for(j=1;j<N;j++){
SET(0,j,j-1);
ROW[0][j-1]=1;
ROW[j][j-1]=1;
}
printf("Total %lld solutions\n",search(1,2));
}

[mathe]

呵呵,文件out99中最后两个解（同前面的区别就比较大了）
01 27 35 46 89
02 15 37 49 68
03 12 47 58 69
04 17 26 38 59
05 14 28 39 67
06 19 25 34 78
07 13 29 48 56
08 16 23 45 79
09 18 24 36 57

01 27 35 49 68
02 15 37 46 89
03 12 47 58 69
04 17 26 38 59
05 14 28 39 67
06 19 25 34 78
07 13 29 48 56
08 16 23 45 79
09 18 24 36 57

[mathe]

其实大部分结果都是本质上相同的，它们相互间可以通过交换不同的数的位置得到，比如对于
01 27 35 46 89
02 15 37 49 68
03 12 47 58 69
04 17 26 38 59
05 14 28 39 67
06 19 25 34 78
07 13 29 48 56
08 16 23 45 79
09 18 24 36 57
我们交换2和7,3和5，可以得到
01 27 35 46 89
02 15 79 48 36
03 14 78 59 26
04 12 67 58 39
05 17 24 38 69
06 19 37 45 28
07 13 25 49 68
08 16 57 34 29
09 18 47 56 23
所以我们可以认为上面二种本质上是相同的。
现在问：如果把所有本质上相同的解分成一类，那么总共又多少类？:)

[ywyw]

mark

[mathe]

完全不同的解有396个。
01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 17 26 38 59
05 16 28 37 49
06 12 39 47 58
07 13 29 48 56
08 19 24 36 57
09 18 27 35 46

01 23 45 67 89
02 14 35 68 79
03 15 24 69 78
04 16 27 38 59
05 17 28 36 49
06 12 39 47 58
07 13 29 48 56
08 19 26 34 57
09 18 25 37 46

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 16 27 38 59
05 18 26 37 49
06 12 39 47 58
07 13 29 48 56
08 19 24 36 57
09 17 28 35 46

01 23 45 67 89
02 14 35 68 79
03 15 24 69 78
04 17 26 38 59
05 18 27 36 49
06 12 39 47 58
07 13 29 48 56
08 19 25 37 46
09 16 28 34 57

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 17 26 38 59
05 18 27 36 49
06 12 39 47 58
07 16 29 35 48
08 19 24 37 56
09 13 28 46 57

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 16 28 37 59
05 17 26 38 49
06 12 39 47 58
07 13 29 48 56
08 19 24 36 57
09 18 27 35 46

01 23 45 67 89
02 14 35 68 79
03 15 24 69 78
04 17 28 36 59
05 16 27 38 49
06 12 39 47 58
07 13 29 48 56
08 19 26 34 57
09 18 25 37 46

01 23 45 67 89
02 14 35 68 79
03 15 24 69 78
04 18 27 36 59
05 17 26 38 49
06 12 39 47 58
07 13 29 48 56
08 19 25 37 46
09 16 28 34 57

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 18 27 36 59
05 17 26 38 49
06 12 39 47 58
07 16 29 35 48
08 19 24 37 56
09 13 28 46 57

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 17 26 38 59
05 16 28 37 49
06 12 39 47 58
07 18 29 35 46
08 19 24 36 57
09 13 27 48 56

01 23 45 67 89
02 14 35 68 79
03 15 24 69 78
04 16 27 38 59
05 17 28 36 49
06 12 39 47 58
07 18 29 34 56
08 19 25 37 46
09 13 26 48 57

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 16 27 38 59
05 17 28 36 49
06 12 39 47 58
07 18 29 35 46
08 19 24 37 56
09 13 26 48 57

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 16 28 37 59
05 17 26 38 49
06 12 39 47 58
07 18 29 35 46
08 19 24 36 57
09 13 27 48 56

01 23 45 67 89
02 14 35 68 79
03 15 24 69 78
04 17 28 36 59
05 16 27 38 49
06 12 39 47 58
07 18 29 34 56
08 19 25 37 46
09 13 26 48 57

01 23 45 67 89
02 15 34 68 79
03 14 25 69 78
04 17 28 36 59
05 16 27 38 49
06 12 39 47 58
07 18 29 35 46
08 19 24 37 56
09 13 26 48 57

01 23 45 67 89
02 16 34 58 79
03 14 25 69 78
04 13 27 59 68
05 17 26 38 49
06 12 39 48 57
07 18 29 35 46
08 19 24 37 56
09 15 28 36 47

01 23 45 67 89
02 14 36 58 79
03 15 24 69 78
04 12 37 59 68
05 16 27 38 49
06 17 25 39 48
07 18 29 35 46
08 19 26 34 57
09 13 28 47 56

01 23 45 67 89
02 13 46 58 79
03 14 25 69 78
04 12 37 59 68
05 17 26 38 49
06 15 27 39 48
07 18 29 34 56
08 19 24 36 57
09 16 28 35 47

01 23 45 67 89
02 16 34 58 79
03 14 25 69 78
04 12 37 59 68
05 17 26 38 49
06 15 27 39 48
07 18 29 35 46
08 19 24 36 57
09 13 28 47 56

01 23 45 67 89
02 13 46 58 79
03 15 24 69 78
04 12 37 59 68
05 16 27 38 49
06 17 25 39 48
07 18 29 34 56
08 19 26 35 47
09 14 28 36 57

01 23 45 67 89
02 14 36 58 79
03 15 24 69 78
04 12 37 59 68
05 16 27 38 49
06 17 25 39 48
07 18 29 34 56
08 19 26 35 47
09 13 28 46 57

01 23 45 67 89
02 16 34 58 79
03 15 24 69 78
04 13 27 59 68
05 17 28 36 49
06 12 39 48 57
07 14 29 38 56
08 19 26 35 47
09 18 25 37 46

...
总共文件54K

[寻开心]

这个问题的不重复的解可真多
加入了遍历算法后，一分钟能够生成350万个解
按照math的计算结果，要验证它，我需要7个小时
不玩啦。