数独游戏破解

游戏规则：

1、每行都是 1~9

2、没列都是 1~9

3、每块都是 1~9

解答思路：

从坐标 [0][0] 开始，算出其允许填入的数字集合（每行允许数字集合、每列允许数字集合和每块允许数字集合的交集）。

从左到右，从上到下依次尝试（即，递归），当无法向 [下一步] 进行时候，则回溯（恢复状态，再尝试另一个值）。

这样直到最后解答完成。

源代码：

package com.gq.algorithm;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class NumberOnly {
public static Set<Integer> NUMBER = new HashSet<Integer>();
static
{
for( int i=1 ; i<=9 ; i++ )
{
NUMBER.add(i);
}
}
/**
* 记录每行还未输入的数字
*/
private List<Set<Integer>> rowMissNumber = new ArrayList<Set<Integer>>();
/**
* 记录每列还未输入的数字
*/
private List<Set<Integer>> colMissNumber = new ArrayList<Set<Integer>>();
/**
* 记录每方块还未输入的数字
*/
private List<Set<Integer>> squareMissNumber = new ArrayList<Set<Integer>>();
{
for( int i=0 ; i<9 ; i++ )
{
rowMissNumber.add( null );
colMissNumber.add( null );
squareMissNumber.add( null );
}
}
/**
* 解答是否完成
*/
private boolean gameOver = false;
public static void main(String[] args) 
{
int[][] numbers = {
{0, 9, 3,  0, 0, 1,  5, 0, 6},
{0, 8, 0,  4, 3, 5,  1, 0, 0},
{0, 0, 7,  9, 0, 2,  0, 8, 4},
{0, 2, 0,  0, 7, 4,  8, 6, 0},
{3, 7, 0,  5, 9, 0,  2, 0, 0},
{9, 0, 4,  1, 0, 8,  7, 5, 0},
{0, 0, 0,  0, 5, 3,  6, 0, 2},
{8, 1, 0,  0, 0, 0,  0, 3, 5},
{6, 0, 0,  0, 1, 9,  0, 0, 8},
};
NumberOnly obj = new NumberOnly();
obj.init(numbers);
obj.solution(0, 0, numbers);
}
/**
* 递归破解
* @param x
* @param y
* @param numbers
*/
void solution( int x, int y, int[][] numbers)
{
if( numbers[x][y] == 0 )
{
Set<Integer> allowNums = possiableNumber(x, y);
for( Integer num : allowNums )
{
numbers[x][y] = num;
// 移除设定的值
rowMissNumber.get(x).remove( num );
colMissNumber.get(y).remove( num );
squareRemove( x,y,num );
// 结束
if( x == 8 && y == 8 )
{
gameOver = true;
print( numbers );
return;
}
// 下一步
int x1=x, y1=0;
if( y == 8 )
{
x1 = (x+1)%9;
}
y1 = (y+1)%9;
solution( x1, y1, numbers);
//如果已经计算完成就不需要再回溯，直接返回
if( gameOver )
{
return;
}
// 恢复
numbers[x][y] = 0;
rowMissNumber.get(x).add( num );
colMissNumber.get(y).add( num );
squareAdd( x, y, num );
}
}
else
{
// 结束
if( x == 8 && y == 8 )
{
gameOver = true;
print( numbers );
return;
}
// 下一步
int x1=x, y1=0;
if( y == 8 )
{
x1 = (x+1)%9;
}
y1 = (y+1)%9;
solution( x1, y1, numbers);
}
}
/**
* 打印结果
* @param numbers
*/
void print( int[][] numbers )
{
if( check(numbers) )
{
System.out.println( "计算数独成功。" );
}
else 
{
System.out.println( "计算数独失败。" );
}
for( int i=0 ; i<9 ; i++ )
{
for( int j=0 ; j<9 ; j++ )
{
System.out.print( numbers[i][j] + ", ");
}
System.out.println( );
}
}
/**
* 检查结果是否正确
* @param numbers
* @return
*/
boolean check( int[][] numbers )
{
// 验证每行
for( int i=0 ; i<9 ; i++ )
{
int sum = 0;
for( int j=0 ; j<9 ; j++ )
{
sum += numbers[i][j];
if( j==8 && sum != 45 )
{
return false;
}
}
}
// 验证每列
for( int i=0 ; i<9 ; i++ )
{
int sum = 0;
for( int j=0 ; j<9 ; j++ )
{
sum += numbers[j][i];
if( j==8 && sum != 45 )
{
return false;
}
}
}
// 验证每块
if( !checkSquare(0, 3, 0, 3, numbers))
{
return false;
}
if( !checkSquare(0, 3, 3, 6, numbers))
{
return false;
}
if( !checkSquare(0, 3, 6, 9, numbers))
{
return false;
}
if( !checkSquare(3, 6, 0, 3, numbers))
{
return false;
}
if( !checkSquare(3, 6, 3, 6, numbers))
{
return false;
}
if( !checkSquare(3, 6, 6, 9, numbers))
{
return false;
}
if( !checkSquare(6, 9, 0, 3, numbers))
{
return false;
}
if( !checkSquare(6, 9, 3, 6, numbers))
{
return false;
}
if( !checkSquare(6, 9, 6, 9, numbers))
{
return false;
}
return true;
}
/**
* 验证块
* @param x1
* @param x2
* @param y1
* @param y2
* @param numbers
* @return
*/
boolean checkSquare( int x1, int x2, int y1, int y2, int[][] numbers )
{
int sum =0;
for( int i=x1 ; i<x2 ; i++ )
{
for( int j=y1 ; j<y2 ; j++ )
{
sum += numbers[i][j];
}
}
if( sum != 45 )
{
return false;
}
return true;
}
void squareRemove( int x, int y, int num )
{
if( 0<=x && x <=2 )
{
if( 0<=y && y<=2 )
{
squareMissNumber.get(0).remove( num );
}
if( 3<=y && y<=5 )
{
squareMissNumber.get(1).remove( num );
}
if( 6<=y && y<=8 )
{
squareMissNumber.get(2).remove( num );
}
}
if( 3<=x && x <=5 )
{
if( 0<=y && y<=2 )
{
squareMissNumber.get(3).remove( num );
}
if( 3<=y && y<=5 )
{
squareMissNumber.get(4).remove( num );
}
if( 6<=y && y<=8 )
{
squareMissNumber.get(5).remove( num );
}
}
if( 6<=x && x <=8 )
{
if( 0<=y && y<=2 )
{
squareMissNumber.get(6).remove( num );
}
if( 3<=y && y<=5 )
{
squareMissNumber.get(7).remove( num );
}
if( 6<=y && y<=8 )
{
squareMissNumber.get(8).remove( num );
}
}
}
void squareAdd( int x, int y, int num )
{
if( 0<=x && x <=2 )
{
if( 0<=y && y<=2 )
{
squareMissNumber.get(0).add( num );
}
if( 3<=y && y<=5 )
{
squareMissNumber.get(1).add( num );
}
if( 6<=y && y<=8 )
{
squareMissNumber.get(2).add( num );
}
}
if( 3<=x && x <=5 )
{
if( 0<=y && y<=2 )
{
squareMissNumber.get(3).add( num );
}
if( 3<=y && y<=5 )
{
squareMissNumber.get(4).add( num );
}
if( 6<=y && y<=8 )
{
squareMissNumber.get(5).add( num );
}
}
if( 6<=x && x <=8 )
{
if( 0<=y && y<=2 )
{
squareMissNumber.get(6).add( num );
}
if( 3<=y && y<=5 )
{
squareMissNumber.get(7).add( num );
}
if( 6<=y && y<=8 )
{
squareMissNumber.get(8).add( num );
}
}
}
/**
* 计算出指定坐标可能输入的数字
* @return
*/
Set<Integer> possiableNumber( int x, int y )
{
Set<Integer> result = buildAllNumber();
result.retainAll( rowMissNumber.get(x) );
result.retainAll( colMissNumber.get(y) );
if( 0<=x && x <=2 )
{
if( 0<=y && y<=2 )
{
result.retainAll( squareMissNumber.get(0) );
}
if( 3<=y && y<=5 )
{
result.retainAll( squareMissNumber.get(1) );
}
if( 6<=y && y<=8 )
{
result.retainAll( squareMissNumber.get(2) );
}
}
if( 3<=x && x <=5 )
{
if( 0<=y && y<=2 )
{
result.retainAll( squareMissNumber.get(3) );
}
if( 3<=y && y<=5 )
{
result.retainAll( squareMissNumber.get(4) );
}
if( 6<=y && y<=8 )
{
result.retainAll( squareMissNumber.get(5) );
}
}
if( 6<=x && x <=8 )
{
if( 0<=y && y<=2 )
{
result.retainAll( squareMissNumber.get(6) );
}
if( 3<=y && y<=5 )
{
result.retainAll( squareMissNumber.get(7) );
}
if( 6<=y && y<=8 )
{
result.retainAll( squareMissNumber.get(8) );
}
}
return result;
}
/**
* 初始化
* @param numbers
*/
void init( int[][] numbers )
{
for( int i=0 ; i<9 ; i++ )
{
for( int j=0 ; j<9 ; j++ )
{
// 初始化行
if( rowMissNumber.get(i) == null )
{
rowMissNumber.set(i, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
rowMissNumber.get(i).remove( numbers[i][j] );
}
// 初始化列
if( colMissNumber.get(j) == null )
{
colMissNumber.set(j, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
colMissNumber.get(j).remove( numbers[i][j] );
}
// 初始化方块
//[0][0] ~ [2][2]
if( 0<=i && i <=2 )
{
if( 0<=j && j<=2 )
{
if( squareMissNumber.get(0) == null )
{
squareMissNumber.set(0, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(0).remove( numbers[i][j] );
}
}
if( 3<=j && j<=5 )
{
if( squareMissNumber.get(1) == null )
{
squareMissNumber.set(1, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(1).remove( numbers[i][j] );
}
}
if( 6<=j && j<=8 )
{
if( squareMissNumber.get(2) == null )
{
squareMissNumber.set(2, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(2).remove( numbers[i][j] );
}
}
}
if( 3<=i && i <=5 )
{
if( 0<=j && j<=2 )
{
if( squareMissNumber.get(3) == null )
{
squareMissNumber.set(3, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(3).remove( numbers[i][j] );
}
}
if( 3<=j && j<=5 )
{
if( squareMissNumber.get(4) == null )
{
squareMissNumber.set(4, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(4).remove( numbers[i][j] );
}
}
if( 6<=j && j<=8 )
{
if( squareMissNumber.get(5) == null )
{
squareMissNumber.set(5, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(5).remove( numbers[i][j] );
}
}
}
if( 6<=i && i <=8 )
{
if( 0<=j && j<=2 )
{
if( squareMissNumber.get(6) == null )
{
squareMissNumber.set(6, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(6).remove( numbers[i][j] );
}
}
if( 3<=j && j<=5 )
{
if( squareMissNumber.get(7) == null )
{
squareMissNumber.set(7, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(7).remove( numbers[i][j] );
}
}
if( 6<=j && j<=8 )
{
if( squareMissNumber.get(8) == null )
{
squareMissNumber.set(8, buildAllNumber());
}
if( numbers[i][j] != 0 )
{
squareMissNumber.get(8).remove( numbers[i][j] );
}
}
}
}
}
}
/**
* 构造一个集合，包含1~9
* @return
*/
Set<Integer> buildAllNumber()
{
Set<Integer> set = new HashSet<Integer>();
for( int i=1 ; i<=9 ; i++ )
{
set.add(i);
}
return set;
}
}

  int[][] numbers = {
{5, 0, 6,  0, 0, 0,  0, 8, 0},
{0, 4, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 5,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  6, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 1,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  3, 0, 0},
{0, 0, 0,  0, 0, 0,  9, 0, 8}
};
  int[][] numbers = {
{4, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 1,  0, 0, 0,  0, 0, 0},
{0, 5, 0,  0, 0, 0,  0, 7, 0},
{0, 8, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 1, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 6,  0, 1, 0},
{0, 6, 0,  0, 0, 0,  0, 5, 0}
};
  int[][] numbers = {
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
{0, 0, 0,  0, 0, 0,  0, 0, 0},
};