java数据结构 深搜+栈

     深度优先搜索遍历类似于树的先序遍历。假定给定图G的初态是所有顶点均未被访问过，在G中任选一个顶点i作为遍历的初始点，则深度优先搜索递归调用包含以下操作：

（1）访问搜索到的未被访问的邻接点；

（2）将此顶点的visited数组元素值置1；

（3）搜索该顶点的未被访问的邻接点，若该邻接点存在，则从此邻接点开始进行同样的访问和搜索。

深度优先搜索DFS可描述为：

（1）访问v0顶点；

（2）置visited[v0]=1；

（3）搜索v0未被访问的邻接点w，若存在邻接点w，则DFS(w)。

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

68

 

Sample Output

Case 1:1 4 3 2 5 61 6 5 2 3 4Case 2:1 2 3 8 5 6 7 41 2 5 8 3 4 7 61 4 7 6 5 8 3 21 6 7 4 3 8 5 2

package cn.hncu.serch;

import java.util.Scanner;


public class SearchMethodDFS {//hdu 1016


public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int num=1;
while (sc.hasNext()) {
int n = sc.nextInt();
int[] a = new int[n];//待搜索数
int[] color = new int[a.length];//是否被搜索的标志
int[] parent = new int[a.length];//父节点
for (int i = 0; i < a.length; i++) {
a[i] = i + 1;
color[i] = -1;//表示没搜索
parent[i] = -1;//记录的是父节点的下标
}
int startNode = 0;//开始节点
int count = 0;//表示搜索了几个数
System.out.println("Case "+num+":");
dfs(a, color, parent, startNode, count);
num++;
System.out.println();
}
}


private static void dfs(int[] a, int[] color, int[] parent, int u,
int count) {
color[u]=1;
count++;
if(count==a.length&&isPrime(a[u]+a[0])){
parent[0]=u;
print(a,parent);
}
for(int v=1;v<a.length;v++){
if(color[v]==-1&&isPrime(a[v]+a[u])){
parent[v]=u;//记录的是a的下标
dfs(a, color, parent, v, count);
parent[v]=-1;//因为下次要搜索，所有必须还原
color[v]=-1;
}
}
}


private static void print(int[] a, int[] parent) {
int index[]=new int[a.length];//因为parent记录的是逆序，所有要改过来.
int p=0;//第一个节点
for(int i=0;i<parent.length;i++){
index[parent.length-i-1]=parent[p];
p=parent[p];//自低向上
}
for(int i=0;i<index.length;i++){
if(i==index.length-1){
System.out.println(a[index[i]]);
}else{
System.out.print(a[index[i]]+" ");
}
}
}


private static boolean isPrime(int n) {
if(n==2){
return true;
}else{
for(int i=2;i*i<=n;i++){
if(n%i==0){
return false;
}
}
}
return true;
}


}