关于相邻两数之和为素数的解答

 题目：巧排数字。将１、２、．．．、２０这２０个数排成一排，使得相邻的两个数之 和为一个素数，且首尾两数字之和也为一个素数。编程打印出所有的排法。

    先说下这道题的思路，肯定是应该用回溯的方法。穷举则运算的量太大不适合，而递归空间复杂度也太大。

先放入第一个数 1，然后依次放入2、3、4···，每次放入时判断与前一个数之和是否为素数，若是则继续放入，若不是则回退一步，选后一个数。这样直到放完。

 伪算法：

0. 初始化 标记所有数在每个位置都能放置。

1. 从剩下的数选最小的一个且能在此位置放置的，放入数组，若没有数满足到3，若已放完到4.

2. 判断放入的数与前一个数之和是否为素数（第一个不判断，最后一个要与它前一个和第一个数判断）
    是素数回到1，不是素数，标记此数不能在这个位置放置到1.

3. 回退一步，即将前面一个数取出，并且标记此位置之后的位置，所有数都能放置。到1.

4. 打印出结果。到5.

5. 判断是否退空，若没退空到3.。退空结束。

这里我将放数，退数模仿成进栈、出栈。然后输出结果到文件时声明了

一个友元函数，方便一些。

下面是源代码 ( 编译器 VC++ 8.0 )

//Stack.h
#ifndef STACK_H
#define STACK_H


class Stack
{
    public:
        Stack();
        bool Push();    
        bool Pop();        
        void Display();
        bool IsFull();
        int GetTop();
        long TheCount();

        friend void FileDisplay(const Stack&);        //输出到文件
    
    private:
        bool IsPrime(int);

    private:
        long count;                //解数
        int top;
        int value[21];            //结果
        bool state[21][21];     //状态    [位置][数]
};
#endif  //STACK_H
///:~

 

//Stack.cpp
#include "Stack.h"
#include <iostream>
#include <fstream>
#include <cstring>    //memset()
#include <math.h>
using namespace std;



Stack::Stack()
{
    memset(value,0,21*sizeof(int));
    memset(state,true,21*21*sizeof(bool));
    top=0;
    count=0;
}
void Stack::Display()
{
    for(int i=1;i<=20;i++)
        cout<<value[i]<<" ";
    cout<<endl;
}

bool Stack::IsFull()
{
    return (top==20);
}

bool Stack::Push()
{
      if(top==20)    //已填完
         return false;
    
    top++;
    for(int i=1;i<=20;i++)
    {
        //测试i是否满足
        if(state[top][i])
        {
            bool flag=true;
            for(int j=1;j<top;j++)
            {
               //判断前面是否用过此数
                if(value[j]==i)
                {
                    flag=false;
                    break;
                }
            }
            if(flag)
            {
    if(top==20)                
    {
          if(!IsPrime(i+value[1]))    //最后一个数要判断与第一个数之和是否为素数
          {
                 state[20][i]=false;
                 continue;
           }
    }                                
                     if(IsPrime(i+value[top-1]))    //判断与其前一个数之和是否为素数
                    {                    
                            state[top][i]=false;
                            value[top]=i;
           if(top==20)
                count++;           //填完
                            return true;
                     }
                     else
                     {
                           state[top][i]=false;
                     }
            }
        }
    }
    top--;
    return false;    //没有满足条件的数 返回false
}

bool Stack::Pop()
{
       if(top==0)          //栈空返回false
           return false;
       state[top][value[top]]=false;
       memset(state[top+1],true,21*sizeof(int));    //其后位置所有数可再用        
       value[top]=0;
       top--;
      return true;
}

bool Stack::IsPrime(int e)
{
    if(e%2==0)
        return false;
    for(int i=3;i<=sqrt((float)e);i+=2)
    {
        if(e%i==0)
            return false;
    }
    return true;
}

int Stack::GetTop()
{
    return top;
}

long Stack::TheCount()
{
    return count;
}

void FileDisplay(const Stack& a)
{
       ofstream out("Answer.txt",std::ios_base::app);
       out<<"No."<<a.count<<endl;
       for(int i=1;i<=20;i++)
            out<<a.value[i]<<" ";
       out<<endl;
}

 

memset(char* ,value,long)这个函数初始化比较快一点，它把起始于某一特定地址的内存(该内存作为第一个参数)从起始地址直至气候的n(n作为第三个参数)个字节的所有内存都设置成同一个特定的值(该值作为第二个参数)

 

//main.cpp
#include <iostream>
#include "Stack.h"
using namespace std;

int main()
{
    Stack a;
    bool s=true;

    while(s)    //循环直到栈空，即不能再回退，则所有已测试完
    {
         if(a.Push())
         {/*继续往内填数*/}
         else
         {
              s=a.Pop();    //不能再填则回退一步        
         }
         if(a.IsFull())
         {            
             FileDisplay(a);
         }
     }    
     return 0;
}

这个结果共有1千多万组，这是不考虑相对位置即不把它看成一个圆。

若有高手有更好算法，还请指点。