LeetCode: NQueens

n皇后问题。用的是back tracking以及递归的方法。这个算法的时间复杂度为O(n^2).

首先确定第一行的皇后放在什么位置。(需要遍历这个皇后所有可以放的位置)。就是说第一个皇后可以在第一行的任一位置。

然后遍历第二行的皇后放在哪个位置，如果满足条件就接着放第三个，否则移到下一位置。。。以此类推

当放置完最后一个时，返回结果。

注意的问题是ArrayList是引用传递，所以可以把所有值都加在里面。

 1 public ArrayList<String[]> solveNQueens(int n) {
 2         int[] result = new int[n];
 3         ArrayList<String[]> a = new ArrayList<String[]>();
 4         generate(result, 0, a);
 5         return a;
 6         
 7     }
 8     public void generate(int[] result, int N, ArrayList<String[]> a) {
 9         if (result.length == N) {
10             a.add(print(result));
11         }
12         else {
13             for (int i=0; i<result.length; i++) {
14                 result[N] = i;
15                 if (isConsistent(result, N)) 
16                     generate(result, N+1, a);
17             }
18         }
19     }
20     
21     public String[] print(int[] result) {
22         String[] w = new String[result.length];
23         for (int i=0; i<w.length; i++) w[i] = "";
24         for (int i=0; i<result.length; i++) {
25             for (int j=0; j<result.length; j++) {
26                 if(j == result[i]) {
27                     w[i] = w[i] + "Q";
28                 }
29                 else {
30                     w[i] = w[i] + ".";
31                 }
32             }
33         }
34         return w;
35     }
36     
37     public boolean isConsistent(int[] result, int N) {
38         for (int i=0; i<N; i++) {
39             if(result[N] == result[i]) return false;
40             if(result[N] - result[i] == N - i) return false;
41             if(result[N] - result[i] == i - N) return false;
42         }
43         return true;
44     }

 

NQueens II

返回所有解法的数量。

还是上面的方法。

注意问题是，上面可以用ArrayList引用传递记录每个值，这里不能用int或Integer进行引用传递，所以只能用函数返回值的形式。

 1 public int totalNQueens(int n) {
 2         int[] result = new int[n];
 3         int a = 0;
 4         a = generate(result, 0);
 5         return a;
 6         
 7     }
 8     public int generate(int[] result, int N) {
 9         int res = 0;
10         if (result.length == N) {
11             return 1;
12         }
13         else {
14             for (int i=0; i<result.length; i++) {
15                 result[N] = i;
16                 if (isConsistent(result, N)) 
17                     res += generate(result, N+1);
18             }
19         }
20         return res;
21     }
22     
23     public boolean isConsistent(int[] result, int N) {
24         for (int i=0; i<N; i++) {
25             if(result[N] == result[i]) return false;
26             if(result[N] - result[i] == N - i) return false;
27             if(result[N] - result[i] == i - N) return false;
28         }
29         return true;
30     }

 

 

posted on 2014-01-14 13:40  longhorn  阅读(283)  评论(0)    收藏  举报

导航