HDU 1016（Java） 好大一个坑！！！

Prime Ring Problem

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 38463 Accepted Submission(s): 17008

Problem Description
A ring is compose of n circles as shown in diagram. Put
natural number 1, 2, …, n into each circle separately, and the sum of numbers in
two adjacent circles should be a prime.

Note: the number of first circle should always be 1.

Input
n (0 < n < 20).
Output
The output format is shown as sample below. Each row represents a series of circle
numbers in the ring beginning from 1 clockwisely and anticlockwisely.
The order of numbers must satisfy the above requirements. Print solutions in
lexicographical order.

You are to write a program that completes above process.

Print a blank line after each case.

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

深搜的一道水题，原先用C＋＋AC了，因为要学习Java，就用Java撸了一遍。然而悲剧就这么发生了，同样的逻辑代码，符号题目要求的输出，提交了一整天总是presentation error，万般无奈之下去网上搜AC代码，然而没有Java版的，所以只好对着C语言一个个看，后来一步一步调试，才发现要在Case %d:后面再加个空格（可是题目描述和C++版中都没有这个空格）。~~~~，虽然Java运行慢，用Java打比赛的人少，但也不能这么坑人吧！

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static int kase = 0,n;
    public static int[] circles = new int[50];
    public static boolean[] flag = new boolean[50],primes = new boolean[50];
    static boolean DEBUG = false;
    static void debug(){
        System.out.print("***");
    }
    public static void initPrimes(){
        Arrays.fill(primes, true);
        for(int i=2;i<=30;i++){
            for(int j=i+i;j<50;j+=i){
                if(j%i==0) primes[j] = false;
            }
        }
        primes[0]=primes[1] = false;
    }
    public static void DFS(int i){
        if(i==n){
            if(primes[1+circles[n-1]]){
                for(int j=0;j<n;j++){
                    if(j==n-1) System.out.print(circles[j]);
                    else System.out.print(circles[j]+" ");
                }
                System.out.println();
            }
            return ;
        }
        else{
            for(int j=2;j<=n;j++){
                if(flag[j]){
                    if(primes[j+circles[i-1]]&&((j+circles[i-1])&1)!=0){//相邻的数奇偶性不同，剪枝！
                        flag[j] = false;
                        circles[i] = j;
                        DFS(i+1);
                        flag[j] = true;
                    }
                }
            }
        }
        return ;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        initPrimes();
        while(in.hasNext()){
            n = in.nextInt();
            //就是这个坑！！
            System.out.printf("Case %d: \n", ++kase);
            if(n==1){
                System.out.println(1);
                System.out.println();
                continue;
            }
            else if((n&1)!=0){
                System.out.println();
                continue;
            }
            Arrays.fill(flag, true);
            circles[0] = 1;
            flag[1] = false;
            DFS(1);
            System.out.println();
        //  if(DEBUG) debug();
        }
    }

}

note：
1.数据规模小，所以把1~37的所有素数都找到了，打表空间换时间。
2.数据优化：再考虑输入的特点，如果输入N是奇数的话，由于起点从1开始，那么1-N之间一共有N / 2个偶数，N / 2 + 1个奇数，也就是奇数的个数比偶数多一个，那么把这N个数排成一个环，根据鸽巢原理，必然有两个奇数是相邻的，而两个奇数之和是偶数，偶数不是素数，所以我们得出结论，如果输入N是奇数的话，没有满足条件的排列。这样当N是奇数的时候，直接返回即可。如果1-N之间每个数输入的几率相同，这个判断可以减少一半的计算量。
3.剪枝：两个奇数之和或者两个偶数之和都是偶数，而偶数一定不是素数，所以在选取当前元素的时候，比较一下它和前一个元素的奇偶性。再做决定，可以减少一部分计算量。
4.位运算按位于判断整数N奇偶性：由于奇数的二进制表示中,最低位是1，N与1按位与运算（N&1)后结果是1，则说明N是一个奇数，否则是一个偶数。即输出结果环中相邻的数奇偶性一定不相同