HDU1016 Prime Ring Problem

大致题意：有这样的几个排列，使得从1到n的排列中，相邻的两个数的和都是素数且首位两个也符合这个要求。
使用深度优先搜索加上剪枝美其名曰“回溯法”：

DFS(int cur)
    if (递归终点达到):
        输出一个解
    else 从cur + 1到n :
        if (不满足剪枝条件) :
            构造状态
            DFS(cur + 1)
            恢复状态

于是就有了下面的代码，主要参考了刘汝佳书：

/*
 Sample Input:
    6
    8
 Sample Output:
    Case 1:
    1 4 3 2 5 6
    1 6 5 2 3 4

    Case 2:
    1 2 3 8 5 6 7 4
    1 2 5 8 3 4 7 6
    1 4 7 6 5 8 3 2
    1 6 7 4 3 8 5 2
*/

//#define LOCAL

#include <iostream>
#include <string>

using namespace std;

const int MAXN = 42;

int A[MAXN / 2], visited[MAXN / 2], n;

/* ---------------------- Prime SCL ---------------------- */
int prime[MAXN];
void getPrime() 
{
    memset(prime, true, sizeof(prime));
    prime[0] = prime[1] = false;
    for (int i = 2; i < MAXN; ++i)  if (prime[i]) {
        if (i > MAXN / i)   continue;
        for (int j = i * i; j < MAXN; j += i)
            prime[j] = false;
    }
}
/* ---------------------- Prime SCL ---------------------- */

void dfs(int cur)
{
    // 头尾的两个数和都是素数，并且到达递归边界
    if (cur == n && prime[A[0] + A[n - 1]]) {
        for (int i = 0; i < n; ++i) cout << A[i] << ' ';
        cout << endl;
    } else for (int i = 2; i <= n; ++i)
        if (!visited[i] && prime[i + A[cur - 1]]) {
            visited[i] = 1;
            A[cur] = i;
            dfs(cur + 1);
            visited[i] = 0;
        }
}
int main()
{
    std::ios::sync_with_stdio(false);
    getPrime();
    int num = 1;
    while (cin >> n) {
        memset(visited, 0, sizeof(visited));
        A[0] = 1;
        visited[1] = 1;
        cout << "Case " << num++ << ":\n"; 
        dfs(1);
        cout << "\n";
    }
    return 0;
}

这个getPrime已经加入我的SCL中了，用它来筛选素数判断，之前也看到过素数筛选的模板，不过因为没有真正的使用过所以印象不深刻。
这道题最终没能AC，我并不清楚原因，总是PE到我醉了，索性就不做了，不过这题的大致思想就是如此。其实很多的搜索大致框架都差不多，唯独需要确定的是如何进行下一次状态搜索以及怎样进行剪枝和它的条件的确定。