枚举与回溯-八皇后与素数环问题

• 生成【0-N】的排列

public class MyPermution {

    static int[] a = new int[5];
    static boolean[] used = new boolean[5];

    public static void main(String[] args) {
        permution(0);
    }

    static void permution(int pos) {
        if(pos==5) {
            System.out.println(Arrays.toString(a));
            return ;
        }
        for(int i=0;i<5;i++) {
            if(!used[i]) {
                used[i] = true;
                a[pos] = i+1;
                permution(pos+1);
                used[i] = false;
            }
        }
    }
}

• 生成【0-N】的子集——位向量法
  构造一个位向量used[i]，其中used[i] = true，当且仅当i在子集A中

public class MySubSet {
    static int[] A = {0,1,2,3,4};
    static Boolean[] used = new Boolean[5];
    public static void main(String[] args) {
        subset(1);
    }

    static void subset(int cur) {
        if(cur==5) {
            //打印当前集合
            for(int i=0;i<5;i++)
                if(!used[i])
                    System.out.print(A[i]+" ");
            System.out.println();
            return ;
        }
        used[cur] = true;   
        subset(cur+1);   //选第cur个元素
        used[cur] = false;  
        subset(cur+1);  //不选第cur个元素
    }
}

• 素数环

输入一个正整数n，把整数1,2,3，……，n组成环，使得相邻两个整数之和均为素数。输出时从整数1开始逆时针排列。同一个环应该恰好输出一次。n<=16.

样例输入：
6
样例输出：
1 4 3 2 5 6
1 6 5 2 3 4

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

public class PrimeRing {
    static boolean[] isp = new boolean[64];

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int[] a = new int[N];
        boolean[] used = new boolean[N];
        a[0] = 1;
        //筛选法计算好64以内所有的素数，不是的话，标记为true
        for(int i=3;i<64;i++)
            for(int j=2;j*j<=i;j++)
                if(i%j==0)
                    isp[i] = true;
        prime_ring(a,used,1, N);
    }

    static void prime_ring(int[] a,boolean[] used,int pos, int n) {
        if(pos==n) {
            if(!isp[a[0]+a[n-1]]) 
                System.out.println(Arrays.toString(a).replaceAll("\\[|\\]|,", ""));
            return ;
        }
        for(int i=2;i<=n;i++) {
            //判断当前元素是否使用过，以及相邻元素之和是否为素数
            if(!used[i-1]&&!isp[a[pos-1]+i]) {
                used[i-1] = true;
                a[pos] = i;
                prime_ring(a,used,pos+1,n);
                used[i-1] = false;
            }
        }
    }
}

可以看出，素数环问题就是在【N的排列】的基础上加了一个判断。
如果在最坏的情况下枚举量很大，应该使用回溯法。

• 八皇后问题
  问题描述很简答。
  在棋盘上放置8个皇后，是的她们互不攻击。而每个皇后的攻击范围为同行同列。

package other;

import java.util.Arrays;

public class MyQueue {
    static int[] C = new int[4];
    static int cnt = 0;
    public static void main(String[] args) {
        queue2(0,4);
        System.out.println(cnt);
    }

    static void queue(int cur, int n) {
        if(cur==n) {
            cnt++;
            System.out.println(Arrays.toString(C));
            return ;
        }
        for(int i=0;i<n;i++) {
            boolean flag = true;
            //判断当前皇后与已知皇后是否冲突
            for(int j=0;j<cur;j++) 
                //y=-x+N==>>y+x=N  y=x+N==>>y-x=N
                if(C[j]==i||C[j]-j==i-cur||C[j]+j==i+cur) {
                    flag = false;
                    break;
                }
            if(flag) {
                C[cur] = i;
                queue2(cur+1, n);
            }
        }
    }
}

下面的解法虽没有上面的简洁，却是沿用【N的排列】思路。

import java.util.Arrays;

public class MyQueue {
    static int N = 4;
    static int cnt = 0;
    static int[][] a = new int[N][N];
    static boolean[][] used = new boolean[3][N*N];
    public static void main(String[] args) {
        queue(0);
        System.out.println(cnt);
    }

    static void queue(int row) {
        if(row==N) {
            cnt++;
            for(int[] t:a)
                System.out.println(Arrays.toString(t));
            System.out.println();
            return ;
        }
        for(int i=0;i<N;i++) {
            //这里的used[3][N*N]记录的是已填写的皇后占据的行列，以及对角
            //由于是按列插入的，所以就少了一个判断
            if(!used[0][i]&&!used[1][row+i]&&!used[2][row-i+N])
            {
                used[0][i] = used[1][row+i] = used[2][row-i+N] = true;
                a[row][i] = 1;
                queue(row+1);
                used[0][i] = used[1][row+i] = used[2][row-i+N] = false;
            }
        }
    }
}

代码基本上就是【N的排列】的变形，有么有。。。

8个的情况有92种输出，就测试了4的情况

[1, 1, 0, 0]
[0, 0, 1, 1]
[1, 1, 0, 0]
[0, 0, 1, 0]

[1, 1, 1, 0]
[1, 0, 1, 1]
[1, 1, 0, 1]
[0, 1, 1, 0]

2