使用java程序帮你解数独

相信数独大家都多少有玩过吧？就是一个3x3 的9个块、每块里面又是3x3的小块

使每行每列都填充1-9的数字且只能使用一次、一般期刊后面都会有数独小游戏的、

以前也玩过数独、但是太难的就不知道该怎么解了、

今天逛了外国网站、发现一解数独的小程序、偷拿来分享、

只使用了两个类 SudokuSolver 和 Grid 、

先贴源码：

SudokuSolver

/**
* This program is executed in the following way:
*    java SudokuSolver <input-file>
* For details of the input-file format, see the Grid.java class.
*
* @author  Patrick Chan
* @version 1, 12/31/05
* @see Grid
*/
import java.io.*;
import java.util.*;

public class SudokuSolver {
public static void main(String[] args) throws Exception {
// Open the file containing the givens
String arg = "C:/ad.txt";

//File file = new File(arg);
FileReader rd = new FileReader(arg);

// Process each grid in the file
while (true) {
Grid grid = Grid.create(rd);
if (grid == null) {
// No more grids
break;
}

// Find a solution
List<Grid> solutions = new ArrayList<Grid>();
solve(grid, solutions);

printSolutions(grid, solutions);
}
}

// Recursive routine that implements the bifurcation algorithm
private static void solve(Grid grid, List<Grid> solutions) {
// Return if there is already a solution
if (solutions.size() >= 2) {
return;
}

// Find first empty cell
int loc = grid.findEmptyCell();

// If no empty cells are found, a solution is found
if (loc < 0) {
solutions.add(grid.clone());
return;
}

// Try each of the 9 digits in this empty cell
for (int n=1; n<10; n++) {
if (grid.set(loc, n)) {
// With this cell set, work on the next cell
solve(grid, solutions);

// Clear the cell so that it can be filled with another digit
grid.clear(loc);
}
}
}

private static void printSolutions(Grid grid, List<Grid> solutions) {
// Print the grid with the givens
System.out.println("Original");
System.out.println(grid);

// Print the solution
if (solutions.size() == 0) {
System.out.println("Unsolveable");
} else if (solutions.size() == 1) {
System.out.println("Solved");
} else {
System.out.println("At least two solutions");
}

// Print the solution(s)
for (int i=0; i<solutions.size(); i++) {
System.out.println(solutions.get(i));
}
System.out.println();
System.out.println();
}
}

和 Grid

/**
* @author  Patrick Chan
* @version 1, 12/31/05
* @see SudokuSolver
*/
import java.io.Reader;

/**
* A Grid object holds the currently known values of the Sudoku puzzle.
* The grid consists of 9x9 cells that hold integer values from 0 to 9.
* A value of 0 indicates that the cell is empty.
*
* Each of the 81 cells has a location which is used to identify a
* specific cell. There are 81 locations, labelled location 0 to location 80.
* Cell locations are ordered from left-to-right and top-down.
* For example, location 0 refers to the top-leftmost cell.
* Location 8 refers to the top-righttmost cell.
* Location 71 refers to the bottom-leftmost cell.
* Location 80 refers to the bottom-rightmost cell.
*
* The grid consists of 9 columns, labelled column 0 to column 8.
* The grid consists of 9 rows, labelled row 0 to row 8.
*
* The grid consists of 9 subgrids, labelled subgrid 0 to subgrid 8.
* Each subgrid contains a subgrid of 3x3 cells.
* Subgrid 0 contains cells - 0, 1, 2, 9, 10, 11, 18, 19, 20.
* Subgrid 8 contains cells - 60, 61, 62, 69, 70, 71, 78, 79, 80
*/
public class Grid implements Cloneable {
// Array that contains values of all 81 cells in the grid.
int[] cells = new int[81];

// A set of bit-vectors that represent the known values for each column.
// Specifically, if column c contains the digits d1 and d2,
//   colsSet[c] = 2^(d1-1)|2^(d2-1)
// For example, if column 0 contains the values 1 and 4, colsSet[0] = 9.
// The information in this variable is redundant with the information
// in the cells variable. The purpose of this variable is to reduce
// the cost of determining whether a particular digit can be set in
// a particular cell.
int[] colsSet = new int[9];

// This purpose and behavior of this variable is similar to colsSet.
int[] rowsSet = new int[9];

// This purpose and behavior of this variable is similar to colsSet.
int[] subgridSet = new int[9];

/**
* This method returns a grid of givens and empty cells ready to be solved.
* The cells containing givens have values between 1 and 9.
* Empty cells have the value 0.
*
* Characters are read one at a time from the input stream and placed
* into the grid in left-to-right and top-down order.
* - The characters 0 or . indicates an empty cell.
* - The characters 1 to 9 indicates a given.
* - The character # is used for comments; subsequent characters are
*   ignored until a newline is encountered.
* - All other characters are simply ignored.
*
* @param     rd  Reader containing the givens
* @return    null if there are not enough characters in 'rd' to form a grid.
*/
public static Grid create(Reader rd) throws Exception {
Grid grid = new Grid();

// Read until all 81 cells are filled
for (int loc=0; loc<grid.cells.length; ) {
// Read a character
int ch = rd.read();

// -1 is returned if the input stream has no more characters
if (ch < 0) {
// No more characters so return null
return null;
}
if (ch == '#') {
// Skip to end-of-line
while (ch >= 0 && ch != '\n' && ch != '\r') {
ch = rd.read();
}
} else if (ch >= '1' && ch <= '9') {
// A given
grid.set(loc, ch-'0');
loc++;
} else if (ch == '.' || ch == '0') {
// Empty cell
loc++;
}
}
return grid;
}

/*
* Finds an empty cell.
* @return the location of an empty cell or -1 if there are no empty cells.
*         Values must be in the range [-1, 80].
*/
public int findEmptyCell() {
for (int i=0; i<cells.length; i++) {
if (cells[i] == 0) {
return i;
}
}
return -1;
}

/*
* Sets a number in a cell. This method checks to see if
*   1. the cell is empty
*   2. the cell is allowed to contain the specified number. E.g. if
*      the number is 5 but the row already has a 5, the cell will
*      not be set and false is returned.
* @param loc  the location of the target cell.
*             Values must be in the range [0, 80].
* @param num  the number to set in the cell.
*             Values must be in the range [1, 9].
* @return     true if the set was successful.
*/
public boolean set(int loc, int num) {
// Compute row and column
int r = loc/9;
int c = loc%9;
int blockLoc = (r/3)*3+c/3;

boolean canSet = cells[loc] == 0
&& (colsSet[c] & (1<<num)) == 0
&& (rowsSet[r] & (1<<num)) == 0
&& (subgridSet[blockLoc] & (1<<num)) == 0;
if (!canSet) {
return false;
}

cells[loc] = num;
colsSet[c] |= (1<<num);
rowsSet[r] |= (1<<num);
subgridSet[blockLoc] |= (1<<num);
return true;
}

/*
* Removes the number in a cell.
* @param loc  the location of the target cell.
*             Values must be in the range [0, 80].
*/
public void clear(int loc) {
// Compute row and column
int r = loc/9;
int c = loc%9;
int blockLoc = (r/3)*3+c/3;

int num = cells[loc];
cells[loc] = 0;
colsSet[c] ^= (1<<num);
rowsSet[r] ^= (1<<num);
subgridSet[blockLoc] ^= (1<<num);
}

/**
* Returns a copy of this grid. Any modifications to the returned
* grid will not affect this grid.
*
* @return a non-null deep copy of this grid.
*/
public Grid clone() {
Grid grid = new Grid();
grid.cells = cells.clone();
grid.colsSet = colsSet.clone();
grid.rowsSet = rowsSet.clone();
grid.subgridSet = subgridSet.clone();
return grid;
}

/**
* Returns a string representing the current contents of the grid.
* Used for debugging purposes.
*
* @return a non-null string representing the current contents of the grid.
*/
public String toString() {
StringBuffer buf = new StringBuffer();
for (int r=0; r<9; r++) {
if (r%3 == 0) {
buf.append("-------------------------\n");
}
for (int c=0; c<9; c++) {
if (c%3 == 0) {
buf.append("| ");
}
int num = cells[r*9+c];
if (num == 0) {
buf.append(". ");
} else {
buf.append(num+" ");
}
}
buf.append("|\n");
}
buf.append("-------------------------");
return buf.toString();
}
}

自己建立个文件自己定义好路径

贴上你要解的数独格式、（格式应该有很多种、我只知道2种）

先贴出来几个

1、

-------------------------

| . . 8 | . . . | 2 . . |

| . 3 . | 8 . 2 | . 6 . |

| 7 . . | . . 9 | . . 5 |

-------------------------

| . 5 . | . . . | . 1 . |

| . . 4 | . . . | 6 . . |

| . 2 . | . . . | . 7 . |

-------------------------

| 4 . . | . 8 . | . . 6 |

| . 7 . | 1 . 3 | . 9 . |

| . . 1 | . . . | 8 . . |

-------------------------

2、

0 0 8 0 0 0 2 0 0

0 3 0 8 0 2 0 3 0

7 0 0 0 0 9 0 0 5

0 5 0 0 0 0 0 1 0

0 0 4 0 0 0 6 0 0

0 2 0 0 0 0 0 7 0

4 0 0 0 8 0 0 0 6

0 7 0 1 0 3 0 9 0

0 0 1 0 0 0 8 0 0

使用方法很简单、首先要建立好一个txt文件 里面放入上面的格式、

然后就是执行SudokuSolver 的java application 的main方法、