在上一篇博文介紹了用矩陣轉換法來產生數獨終盤。關于矩陣轉換法產生終盤矩陣請參考如下的文章。

[b]Swing數獨游戲(一)：終盤生成之矩陣轉換法 [/b]==> [url]http://mouselearnjava.iteye.com/blog/1941483[/url]

本篇博文將對數獨游戲隨機產生數獨終盤展開說明。

[size=medium][color=blue][b]用什么樣的隨機方法？[/b][/color][/size]

讀過一些文章，關于隨機產生數據終盤比較流行的是將拉斯維加斯算法與回溯法相結合。比如下面的文章都有提及：

[url]http://zhangroup.aporc.org/images/files/Paper_3485.pdf[/url]
[url]http://wenku.baidu.com/view/f9e3f17101f69e31433294e1.html[/url]

[img]http://dl2.iteye.com/upload/attachment/0089/2557/e887ce09-1027-319f-b4d1-cf4a7947f2f8.jpg[/img]

看了如下PPT: Java算法[url]http://wenku.baidu.com/view/0a67634de518964bcf847c80.html[/url]

[img]http://dl2.iteye.com/upload/attachment/0089/2564/4105d102-57b2-3228-8aa9-dd18e581007e.jpg[/img]

[img]http://dl2.iteye.com/upload/attachment/0089/2566/3e2b4b61-33d4-3787-8b86-da572118371d.jpg[/img]

從上面的兩個PPT截圖中可以看出，拉斯維加斯算法思想去解決N皇后時所花費的時間不少。
數獨中的判斷不比N皇后少，如果想要在1秒內或者更短的時間產生1000個數獨終盤，個人覺得并不是很容易（當然了，這個希望以后去證明一下是正確的 :)）。

所以，我想選擇另外的途徑去完成。

[size=medium][color=blue][b]我的隨機方法思想[/b][/color][/size]

在給出我的隨機方法思想之前，我們先來看看數獨終盤的數量。

[b]終盤數量[/b]

終盤數量數獨中的數字排列千變萬化，那么究竟有多少種終盤的數字組合呢？
6,670,903,752,021,072,936,960（約有[b]6.67×10的21次方[/b]）種組合，2005年由Bertram Felgenhauer和Frazer Jarvis計算出該數字，并將計算方法發布在他們網站上，[b]如果將等價終盤（如旋轉、翻轉、行行對換，數字對換等變形）不計算，則有5,472,730,538個組合[/b]。數獨終盤的組合數量都如此驚人，那么數獨題目數量就更加不計其數了，因為每個數獨終盤又可以制作出無數道合格的數獨題目。
-- 參考自[url]http://baike.baidu.com/link?url=ePXUCvpBaRKBkEA3pVfOkg3m-NBozO6a4GDS0N3E5_gK1nnJCDzd5O-YL1w7c5S3[/url]


[color=blue][b]按照這個數量，如果我們將一個[1,2,3,4,5,6,7,8,9]的數組隨機化，然后將其作為一行數據添加到一個二維數組中去，該行能滿足數獨終盤規則的概率是很大的。[/b][/color]

[b]基于這個假設(假設的有效性會在文章后面驗證)，我的隨機算法思想如下：[/b]

[list]
[*][b]1. 寫一個方法用于獲取一個由1到9九個數隨機排列的一維數組。
[*]2. 循環行(下標從0到8)，將這個隨機產生的一維數組作為當前行的內容，如果是第一行（行標為0），那么直接作為該行的內容。如果是其它行，則驗證數據是否都符合條件。
[*] 如果符合條件，則再產生一個由1到9九個數隨機排列的一維數組作為下一行的內容并驗證數據是否可用。
[*] 如果不符合條件，則將該行數據設置為0，調整row和col，產生一個由1到9九個數隨機排列的一維數組，重新對該行驗證。
[*]3. 程序中為了防止產生一維隨機數組的方法調用很多次而沒有產生結果，設置一個最多調用該方法次數的閾值，當達到這個閾值還沒有產生結果，重新從 row =0 col =0 開始。[/b]
[/list]

實現的程序如下：

package my.utils.algorithm.sudoku;

import java.util.Random;

public class SudokuPuzzleGenerator {

private Random random = new Random();

/**運行此程序300次，最大值是217，最小值11，平均約等于50
* 閾值設置為220， 能滿足大部分程序，二維矩陣不會置為0，重新再產生值。
*/
private static final int MAX_CALL_RANDOM_ARRAY_TIMES = 220;

/**記錄當前buildRandomArray()方法調用的次數*/
private int currentTimes = 0;

public int[][] generatePuzzleMatrix() {

int[][] randomMatrix = new int[9][9];

for (int row = 0; row < 9; row++) {
if (row == 0) {
currentTimes = 0;
randomMatrix[row] = buildRandomArray();

} else {
int[] tempRandomArray = buildRandomArray();

for (int col = 0; col < 9; col++) {
if (currentTimes < MAX_CALL_RANDOM_ARRAY_TIMES) {
if (!isCandidateNmbFound(randomMatrix, tempRandomArray,
row, col)) {

/*
* 將該行的數據置為0，并重新為其準備一維隨機數數組
*/
resetValuesInRowToZero(randomMatrix,row);
row -= 1;
col = 8;
tempRandomArray = buildRandomArray();
}
} else {
/*
* 將二維矩陣中的數值置為0，
* row賦值為-1 col賦值為8， 下一個執行的就是row =0 col=0，
*
* 重頭開始
*/
row = -1;
col = 8;
resetValuesToZeros(randomMatrix);
currentTimes = 0;
}
}
}
}
return randomMatrix;
}

private void resetValuesInRowToZero(int[][] matrix, int row)
{
for (int j = 0; j < 9; j++) {
matrix[row][j] = 0;
}

}

private void resetValuesToZeros(int[][] matrix) {
for (int row = 0; row < 9; row++) {
for (int col = 0; col < 9; col++) {
matrix[row][col] = 0;
}
}
}

private boolean isCandidateNmbFound(int[][] randomMatrix,
int[] randomArray, int row, int col) {
for (int i = 0; i < randomArray.length; i++) {
/**
* 試著給randomMatrix[row][col] 賦值,并判斷是否合理
*/

randomMatrix[row][col] = randomArray[i];
if (noConflict(randomMatrix, row, col)) {
return true;
}
}
return false;
}

private boolean noConflict(int[][] candidateMatrix, int row, int col) {
return noConflictInRow(candidateMatrix, row, col)
&& noConflictInColumn(candidateMatrix, row, col)
&& noConflictInBlock(candidateMatrix, row, col);
}

private boolean noConflictInRow(int[][] candidateMatrix, int row, int col) {
/**
* 因為產生隨機數矩陣是按照先行后列，從左到右產生的 ，該行當前列后面的所有列的值都還是0， 所以在行比較的時候，
* 只要判斷該行當前列與之前的列有無相同的數字即可。
*
*/
int currentValue = candidateMatrix[row][col];

for (int colNum = 0; colNum < col; colNum++) {
if (currentValue == candidateMatrix[row][colNum]) {
return false;
}
}

return true;
}

private boolean noConflictInColumn(int[][] candidateMatrix, int row, int col) {

/**
* 與noConflictInRow(...)方法類似：
*
*
* 因為產生隨機數矩陣是按照先行后列，從左到右產生的，該列當前行后面的所有行的值都還是0，
*
* 所以在列比較的時候， 只要判斷該列當前行與之前的行有無相同的數字即可。
*
*/

int currentValue = candidateMatrix[row][col];

for (int rowNum = 0; rowNum < row; rowNum++) {
if (currentValue == candidateMatrix[rowNum][col]) {
return false;
}
}

return true;
}

private boolean noConflictInBlock(int[][] candidateMatrix, int row, int col) {

/**
* 為了比較3 x 3 塊里面的數是否合理， 需要確定是哪一個Block，我們先要求出3 x 3的起始點。 比如： Block 1
* 的起始點是[0][0] Block 2 的起始點是[3]][0]
*
* ... Block 9 的起始點是[6][6]
*/

int baseRow = row / 3 * 3;
int baseCol = col / 3 * 3;

for (int rowNum = 0; rowNum < 8; rowNum++) {
if (candidateMatrix[baseRow + rowNum / 3][baseCol + rowNum % 3] == 0) {
continue;
}
for (int colNum = rowNum + 1; colNum < 9; colNum++) {
if (candidateMatrix[baseRow + rowNum / 3][baseCol + rowNum % 3] == candidateMatrix[baseRow
+ colNum / 3][baseCol + colNum % 3]) {
return false;
}
}
}
return true;

}

/**
* 返回一個有1到9九個數隨機排列的一維數組,
*/
private int[] buildRandomArray() {
currentTimes++;
int[] array = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int randomInt = 0;
/*
* 隨機產生一個1到8的隨機數，使得該下標的數值與下標為0的數值交換，
*
* 處理20次，能夠獲取一個有1到9九個數隨機排列的一維數組,
*/
for (int i = 0; i < 20; i++) {
randomInt = random.nextInt(8) + 1;
int temp = array[0];
array[0] = array[randomInt];
array[randomInt] = temp;
}

return array;
}

/**
* @return the currentTimes
*/
public int getCurrentTimes() {
return currentTimes;
}

/**
* @param currentTimes the currentTimes to set
*/
public void setCurrentTimes(int currentTimes) {
this.currentTimes = currentTimes;
}

}
[b]

[size=medium][color=blue][b]假設有效性驗證及閾值設定[/b][/color][/size]

針對上述的代碼，我跑10組，每組30個實例，看看這300個例子中，產生數獨終盤所需要調用隨機產生由1到9的一維數組的次數各是多少， 結果如下：

[img]http://dl2.iteye.com/upload/attachment/0089/2535/0c1df9c0-bad5-3fa5-8393-d4298f635528.jpg[/img]

從上面的結果圖中可以看出：[[color=blue]b]300個實例中，調用次數最小的為11，接近理想最小調用次數9.

最大值為217次，平均約50次。而且大部分實例調用的次數在100以內。

從這些數據[/color]分析中，上述假設基本上是合適的，閾值最后選擇了接近實驗最大值217的220.[/b]

[size=medium][color=blue][b]效果和結論[/b][/color][/size]

選擇產生不同的數目的數獨終盤，看看執行的時間。
[img]http://dl2.iteye.com/upload/attachment/0089/2553/1e7bb208-1dd9-3469-97e3-f370f9296e14.jpg[/img]

[img]http://dl2.iteye.com/upload/attachment/0089/2555/772bbfe7-f06e-3f93-91cb-ecb4616f65d6.jpg[/img]


[b]結論：[/b]

[b]1. 在打印二維數組到控制臺顯示的情況下，產生10萬個隨機數獨終盤的時間差不多1分鐘左右。
2. 在打印二維數組到控制臺顯示的情況下，產生1000個隨機數獨終盤的時間差不到1秒，這個正是我們之前所期望的。
3. 產生大數目的隨機終盤，將二維數組打印到控制臺顯示的時間占據總時間的60%左右。
如果不在控制臺輸出二維數組，花費的時間將少很多。 看上面的折線就可以知道。[/b]

[b]總的來說，效果還是比較不錯的，比較適合一下需要產生很多的數獨終盤的情況，比如：初始化1000個或者更多個數獨終盤并寫入文件，然后作為數獨游戲的每關內容。[/b]

在下一篇博文中將介紹使用“挖洞”的思想去生成數獨難題。

使用在Console打印出隨機產生二維矩陣的的測試代碼，及其產生50000個和100000個二維矩陣的結果截圖如下：[/b]


public class Main {
public static void main(String[] args) {
SudokuPuzzleGenerator sudokuPuzzleGenerator = new SudokuPuzzleGenerator();
long start = System.currentTimeMillis();
int numOfSudokuMatrix = 10000;
for (int count = 1; count <= numOfSudokuMatrix; count++) {
System.out.println("第" + count + "個");
int[][] randomMatrix = sudokuPuzzleGenerator.generatePuzzleMatrix();
printMatrix(randomMatrix);
}

long end = System.currentTimeMillis();

System.out.println("產生"+numOfSudokuMatrix+"個數獨矩陣花費時間: " + ((end - start) / 1000.0)
+ " 秒");


}

public static void printMatrix(int[][] randomMatrix) {
for (int rowNum = 0; rowNum < 9; rowNum++) {
for (int colNum = 0; colNum < 9; colNum++) {
System.out.print(randomMatrix[rowNum][colNum] + " ");
}
System.out.println();
}
}
}


[img]http://dl2.iteye.com/upload/attachment/0089/2537/6ab07468-e52e-305e-959b-5facb63f356d.jpg[/img]

[img]http://dl2.iteye.com/upload/attachment/0089/2539/83da46e8-2e96-3a04-b66c-0e4208ce3d24.jpg[/img]


在下一篇博文中將介紹使用“挖洞”的思想去生成數獨難題。

轉載請注明出處：[url]http://mouselearnjava.iteye.com/blog/1941693[/url]

總結

以上是生活随笔為你收集整理的Swing数独游戏(二)：终盘生成之随机法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。