将1、2、．．．、20这20个数排成一排，使得相邻的两个数之和为一个素数，且首尾两数字之和也为一个素数。

将1、2、．．．、20这20个数排成一排，使得相邻的两个数之和为一个素数，且首尾两数字之和也为一个素数。

这里提供了三种方法：

（注意：为了让程序更快，根据排列的特点，每种方法都固定了最后一个元素，这样输出只是满足条件中的一部分，但是你可以修改每种方法中的输出，所有元素通过移动一个位置来输出, 如123,第一次输出123,第2次231,第3次312，这样就可以得到所有的解。）

下面只对其中的暴力方法做简单的说明。

暴力方法思想：对1-n做出所有的排列，然后依次检查每个排列看是否满足条件，满足的输出。

其中的递归只是做出排列。排列递归的思想就是，任选1到n中的一个放到最后位置，（递归）任选剩余的数中的一个放到次后位置，*** ，按照这样循环下去。

顺便提一下，这种方法很慢，做完所有排列要进行递归几十亿亿次，你要等很久（可能久到几个小时，哈哈）才能看到结果。 但是，你可以把我注释的for语句代替其下的for可以快一点看到结果。

具体看代码中的解释。

看懂暴力方法，就能看懂方法三了。一就不用看了，可能你也看不懂。虽然它的速度是这三个比较快的一个，但理解也更难。

如果这样你都看不懂，那么是你的问题了，可能你根本不知道什么是排列，也可能你根本不知道什么是递归，一切都是白说。（那样你应该找本书看，而不是光问。）

#include <stdio.h>

#include <malloc.h>

#include <memory.h>

#include <math.h>

#include <time.h>

bool IsPrimeNumber(int n)

{ /*判断素数*/

int i;

int sqrootN;

if ( n == 2 ) {

return true;

} else if ( n%2 == 0 || n==1 ) {

return false;

}

sqrootN = (int)( sqrt(n)+0.1 )+1;

i = 3;

while ( i < sqrootN ) {

if (n%i == 0) {

return false;

}

i += 2;

}

return true;

}

void Swap(int *a, int *b)

{ /*交换两数*/

int tmp;

tmp = *a;

*a = *b;

*b = tmp;

}

bool IsOk(int *arr, int arrsize)

{ /*判断是否满足条件*/

if ( !IsPrimeNumber(arr[arrsize-1]+arr[0]) ) {

return false;

}

while( --arrsize > 0 ) {

if ( !IsPrimeNumber(arr[arrsize]+arr[arrsize-1]) ) {

return false;

}

}

return true;

}

////////////////////////////////////////////////////////

// 方法一：

bool Adjust_Pair(int *arr, int arrsize, int depth)

{

static int total=0;

bool ret = false;

int i;

if ( depth==2 ) {

if ( IsPrimeNumber(arr[0]+arr[arrsize-1]) ) {

total++;

printf("\n%03d: ",total);

for( i=0; i<arrsize; i+=2 ) {

printf("%02d-%02d ", arr[i], arr[i+1]);

}

return true;

} else {

return false;

}

}

for (i=depth-2; i>1; i-=2) {

if ( IsPrimeNumber(arr[i-1]+arr[depth-2]) ) {

Swap(arr+depth-3, arr+i-1);

Swap(arr+depth-4, arr+i-2);

if ( Adjust_Pair(arr, arrsize, depth-2) ) {

ret = true;

}

Swap(arr+depth-3, arr+i-1);

Swap(arr+depth-4, arr+i-2);

}

}

return ret;

}

bool Make_Pair(int *arr, int arrsize, int depth)

{

bool ret = false;

int i;

static int total1=0;

static int total2=0;

if ( depth==0 ) {

return Adjust_Pair(arr, arrsize, arrsize);

}

for( i=0; i<depth-1; i+=2 ) {

if ( IsPrimeNumber(arr[depth-1]+arr[i]) ) {

Swap(arr+depth-2, arr+i);

if ( Make_Pair(arr, arrsize, depth-2) ) {

ret = true;

}

Swap(arr+depth-2, arr+i);

}

}

return ret;

}

void DoPermutation(int *arr, int arrsize)

{

if(arrsize%2==1) {

printf("\n结果：不存在(数组大小必须为偶数).");

return;

}

if ( !Make_Pair(arr, arrsize, arrsize) ) {

printf("\n结果：不存在.");

}

}

//////////////////////////////////////////////////////

//暴力方法：无条件进行所有排列，并逐一判断是否满足条件

bool _DoPermutation2(int *arr, int arrsize, int depth)

{

static int total=0;

bool ret = false;

int i;

if ( depth==0 ) { /*排列完成*/

if ( IsOk(arr, arrsize) ) { /*判断是否满足条件, 满足条件就输出*/

total++;

printf("\n%03d: ",total);

for( i=0; i<arrsize; i+=2 ) {

printf("%02d-%02d ", arr[i], arr[i+1]);

}

return true;

} else {

return false;

}

}

/* for ( i=(depth+1)%2; i<depth; i+=2 ) { 将下面for换成这个for可以优化一半的速度*/

for ( i=0; i<depth; i++ ) { /*depth-1相当于数组的最后一个位置*/

Swap(arr+depth-1, arr+i); /*选择arr[i]到放到数组的最后一个位置arr[depth-1]*/

if ( _DoPermutation2(arr, arrsize, depth-1) ) { /*递归排列前depth-1个元素*/

ret = true;

}

Swap(arr+depth-1, arr+i); /*交换回来，让原来的数组不变*/

}

return ret;

}

void DoPermutation2(int *arr, int arrsize)

{

if(arrsize%2==1) {

printf("\n结果：不存在(数组大小必须为偶数).");

return;

}

if ( !_DoPermutation2(arr, arrsize, arrsize-1) ) {

printf("\n结果：不存在.");

}

}

//////////////////////////////////////////////////////

// 方法三：当且仅当正在进行的排列满足部分条件时，进行递归

bool _DoPermutation3(int *arr, int arrsize, int depth)

{

static int total=0;

bool ret = false;

int i;

if ( depth==0 ) {

if ( IsPrimeNumber(arr[arrsize-1]+arr[0]) ) {

total++;

printf("\n%03d: ",total);

for( i=0; i<arrsize; i+=2 ) {

printf("%02d-%02d ", arr[i], arr[i+1]);

}

return true;

} else {

return false;

}

}

for ( i=(depth+1)%2; i<depth; i+=2 ) {

/* for ( i=0; i<depth; i++ ) { 将上面换成这句也可以，但上面更好*/

if ( !IsPrimeNumber(arr[depth]+arr[i]) ) {

continue;

}

Swap(arr+depth-1, arr+i);

if ( _DoPermutation3(arr, arrsize, depth-1) ) {

ret = true;

}

Swap(arr+depth-1, arr+i);

}

return ret;

}

void DoPermutation3(int *arr, int arrsize)

{

if(arrsize%2==1) {

printf("\n结果：不存在(数组大小必须为偶数).");

return;

}

if ( !_DoPermutation3(arr, arrsize, arrsize-1) ) {

printf("\n结果：不存在.");

}

}

int main(int argc, char* argv[])

{

clock_t start, finish;

int arr[100],i;

for( i=0; i<100; i++ ) {

arr[i]=i+1;

}

/*方法一*/

DoPermutation(arr, 18);

/*暴力方法*/

/*DoPermutation2(arr, 18);*/

/*方法三*/

/*DoPermutation3(arr, 18); */

return 0;

}