题目：输入一个数N，计算1、2、3、...、N这N个数进行排列组合，使得这个数列任意两个相邻数之和为素数，求结果T，T为这样的数列的个数；
private static final Map<Integer, Boolean> SUSHU = new HashMap<Integer, Boolean>();
public static void main(String[] args) throws IOException {
method();
}
//获取标准输入
private static String[] getInput(int linesCounts) {
BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
String line[] = new String[linesCounts];
try {
for (int i = 0; i < linesCounts; i++) {
line[i] = stdin.readLine();
}
} catch (IOException e) {
e.printStackTrace();
}
return line;
}
private static void method() {
int N = Integer.parseInt(getInput(1)[0]);
System.out.println(N);
for (int i = 1; i <= N; i++) {
Num num = new Num(i);
for (int j = N; j > 0; j--) {
if (isSuShu(i + j)) {
num.add(j);
}
}
}
int leastNears = Integer.MAX_VALUE;
int startNum = 0;
for (Num num : Num.map.values()) {//找出能与之相邻的数字最少的数，以尽量减少方法调用次数
if (leastNears > num.near.size()) {
leastNears = num.near.size();
startNum = num.num;
}
}
Num item = Num.map.get(startNum);
Num.startNum = startNum;
System.out.println(Num.linkCounts(item, new HashSet<Integer>()));
}
private static class Num {
static int startNum = 0;//起始数，用以判断首尾数之和能否为素数
static Map<Integer, Num> map = new HashMap<Integer, Num>();//
int num;
Set<Integer> near = new HashSet<Integer>();//找出所有能与num相邻的数
Num(int num) {
this.num = num;
map.put(num, this);
}
void add(int num) {
if (num != this.num) {
near.add(num);
}
}
static int linkCounts(Num thisNum, Set<Integer> removeList) {
int counts = 0;
Set<Integer> newNear = new HashSet<Integer>(thisNum.near);
newNear.removeAll(removeList);
removeList.add(thisNum.num);
if (newNear.size() == 0) {
if (removeList.size() < map.size() || !isSuShu(startNum + thisNum.num)) {
counts = 0;
} else {
counts = 1;
}
} else {
for (int near : newNear) {
Set<Integer> newRemoveList = new HashSet<Integer>(removeList);
newRemoveList.add(thisNum.num);
counts += linkCounts(map.get(near), newRemoveList);
}
}
return counts;
}
}
//判断一个数是否是素数，放在一个map里面，以减少计算量
private static boolean isSuShu(int num) {
Boolean suShu = SUSHU.get(num);
if (suShu != null) {
return suShu;
}
suShu = true;
int sqrt = (int) Math.sqrt(num);
for (int i = 2; i < sqrt + 1; i++) {
if (num % i == 0) {
suShu = false;
}
}
SUSHU.put(num, suShu);
return suShu;
}
其实有一个规律，就是当N为奇数的时候，T肯定为0，因为两个相邻的数不可能都是奇数，于是就可以不用计算了。
程序还有很多需要小修补的，比如map.size这样的最好设置一个常量，但是这些不影响算法的实现
这种方法计算结果倒没问题，但是当N大于等于18的时候就会出现效率问题，因为递归量太大，最后结果超过百万，也就是linkCounts这个方法至少要计算百万次，所以在N很大的时候，还需要寻找其它更好的办法
当N为20的时候，T好像为6309600
转载于:https://blog.51cto.com/hanlang/1144459
