Sicily 1002. Anti-prime Sequences 解题报告

题目传送门：1002. Anti-prime Sequences

思路：

　　本题使用了dfs深度优先搜索（回溯法），用递归的形式实现。

　　一开始见到3s的时间竟然傻乎乎的跑去用回溯法按照字典序生成全排列，然后一个个的去判断是否是anti-prime，直接被TLE拍死。

　　后来才突然醒悟在搜索到某个数字时可以利用2到degree的相邻数字和不是素数这个性质进行大量剪枝才搞定。

　　这里选择了vector作为容器是为了能同时实现对元素的快速下标访问于在某一特定位置的增删元素。

　　用一个vector result存储生成的anti-prime sequence，然后将n~m这些数字一个一个的插进result中，插入时判断是否满足序列性质。如果迭代完整个numbers里面的元素都没找到能插入的元素，则删掉最后一个插入的元素，回溯到前面的情况。用全局变量bool unsolved判断是否已经找到序列，找到之后后面的搜索可以不用进行。

代码：

#include<iostream>
#include<vector>
#include<memory.h>
using namespace std;

const int MAX=10000;

int n,m,d;
vector<int>numbers,result;
bool prime[MAX];
bool unsolved=true;

void generate_prime_list();
void dfs_search_sequence();
bool can_be_insert(int new_entry);

int main(){
    generate_prime_list();
    while(cin>>n>>m>>d&&(n!=0||m!=0||d!=0)){
        numbers.clear();
        result.clear();
        unsolved=true;
        for(int i=n;i<=m;i++)
            numbers.push_back(i);
        dfs_search_sequence();
        if(unsolved)
            cout<<"No anti-prime sequence exists."<<endl;
    }
    return 0;
}
void generate_prime_list(){
    memset(prime,true,sizeof(prime));//assume all are prime first.
    for(int i=2;i<=100;++i){
        if(prime[i]){
            for(int j=2;j*i<MAX;++j){//times of a prime number can not be prime.
                prime[j*i]=false;
            }
        }
    }
}
void dfs_search_sequence(){
    //Post:If the anti-prime sequence exist,the lexicographically first will be printed.
    //Uses:the method of vector,the function dfs_search_sequence recursively,the function can_be_inserted.
    if(unsolved){
        int size_of_numbers=numbers.size(),size_of_result=result.size();
        if(size_of_result==m-n+1){//already find the full sequence
            unsolved=false;
            for(int i=0;i<size_of_result-1;i++)
                cout<<result[i]<<',';
            cout<<result[size_of_result-1]<<endl;
        }
        else{
            for(int i=0;i<size_of_numbers;i++){
                int entry=numbers[i];
                if(can_be_insert(entry)){
                    result.push_back(entry);
                    numbers.erase(numbers.begin()+i);
                    dfs_search_sequence();
                    //move back
                    numbers.insert(numbers.begin()+i,entry);
                    result.pop_back();
                }
            }
        }
    }
}
bool can_be_insert(int new_entry){
    //Post:If the new_entry can be inserted in the back of the result and remain the anti-prime
    //        property,return true.Otherwise return false.
    int size=result.size(),sum=new_entry;
    for(int i=size-1;i>size-d&&i>=0;i--){
        sum+=result[i];
        if(prime[sum])
            return false;
    }
    return true;
}