java回溯算法解决数独_js回溯算法解决数独问题

直接上代码

代码里面注释很清晰

传说中的最难数组大概是在20ms左右解决

/**

* 数独算法

*/

class Sudoku {

constructor({

display = false,

sudokuMap = []

}) {

// 是否展示算法过程

this.display = display;

// 原始数独数组

this.sudokuMap = sudokuMap;

// 回溯数组

this.stacks = [];

// 是否已经解答完成

this.resolved = false;

this.allTimes = 0; // 所有的循环次数统计

this.dataMap = new Map();

console.time('init:time');

this.init();

console.timeEnd('init:time');

this.testRuleTimes = {

ok: 0,

fail: 0,

};

this.currentOrder = 0 ;

}

/**

* 初始化确定每个可填写的格子可以的填入的数值，做成一个MAP

*/

init() {

let exsitTimes = {};

for(let i = 0 ; i < 9 ; i++ ) {

for(let j = 0 ; j < 9; j ++) {

this.allTimes++;

let node = this.sudokuMap[i][j];

if(node === 0) {

this.testMayFill(i, j);

}else{

// 记录每个数字出现的次数

exsitTimes[node] ? exsitTimes[node]++ : exsitTimes[node]=1;

}

}

}

// 进行一次可填入数字的排序

// 回溯的时候找下一个节点的时候从小到大进行搜索

let data = [];

for(let [key, value] of this.dataMap) {

this.allTimes++;

data.push({

x: parseInt(key.split('-')[0]),

y: parseInt(key.split('-')[1]),

value: value,

// value: value.sort((a, b) => {

// exsitTimes[a] - exsitTimes[b] > 0 ? 1:-1;

// })

})

}

//

// data.sort(function(a , b) {

// return a.value.length > b.value.length ? 1 : -1;

// })

//

// data.reverse();

this.orders = data;

}

/**

* 设置当前格子可能填入的值

*/

testMayFill(x, y) {

let mayFillNumber = new Set([1,2,3,4,5,6,7,8,9]);

// 横向查找

for (let i = 0; i < 9; i++) {

this.allTimes++;

let node = this.sudokuMap[i][y];

if (mayFillNumber.has(node)) {

mayFillNumber.delete(node);

}

}

// 纵向查找

for (let i = 0; i < 9; i++) {

this.allTimes++;

let node = this.sudokuMap[x][i];

if (mayFillNumber.has(node)) {

mayFillNumber.delete(node);

}

}

/* x为n所在的小九宫格左顶点竖坐标 */

let startX = Math.floor(x / 3) * 3;

/* y为n所在的小九宫格左顶点横坐标 */

let startY = Math.floor(y / 3) * 3;

/* 判断n所在的小九宫格是否合法 */

for (let i = startX; i < startX + 3; i++)

{

for (let j = startY; j < startY + 3; j++)

{

this.allTimes++;

let node = this.sudokuMap[i][j];

if (mayFillNumber.has(node)) {

mayFillNumber.delete(node);

}

}

}

this.dataMap.set(`${x}-${y}`, [...mayFillNumber]);

}

/**

* 如果某一个方格填写的测试数据能够经过校验

* 就寻找到一下个需要填写数的方格

* 这个方格的不能已经填写过数字

* 找到这个方格的坐标返回

*/

getNextPoint() {

let currentStack = this.stacks[this.stacks.length - 1];

let ret = {

x: -1,

y: -1,

value: 1,

}

this.currentOrder++;

let nextValue = this.orders[this.currentOrder];

if(!nextValue) {

this.resolved = true;

return ret;

// break;

}

ret.x = nextValue.x;

ret.y = nextValue.y;

ret.value = nextValue.value[0];

return ret;

}

/**

* 获取初始节点

* 初始节点为第一个不为0的方格

* 0 0 坐标节点上面可能已经填写了数字

*/

getFirstPoint() {

let ret = {

x: this.orders[0].x,

y: this.orders[0].y,

value: this.orders[0].value[0],

}

return ret;

}

/**

* 程序入口

* 开始执行

*/

start() {

let s = new Date();

// 清空命令行

let {

resolved: resolved,

stacks: stacks

} = this;

if(this.display) {

process.stdout.cursorTo(0, 0);

process.stdout.clearScreenDown();

}

// 如果记录填写数字的历史表为空，直接找第一个可以填写的方格填入

//

stacks.push(this.getFirstPoint());

while (resolved === false) {

let cStack = stacks[stacks.length - 1];

if (this.display) {

process.stdout.cursorTo(0,0);

console.log(this.sudokuMap);

console.log('已经填入数量',stacks.length);

console.log(`当前耗时${new Date()-s}ms`);

}

/**

* 结束判断

* 如果获取不到需要填写的方格

* 说明已经全部填写完成

*/

if (cStack.x === -1 && cStack.y === -1) {

resolved = true;

console.log(this.sudokuMap);

console.log('已经填入数量',stacks.length);

console.log(`当前耗时${new Date()-s}ms`);

console.log(this.testRuleTimes);

console.log('所有For循环次数',this.allTimes);

return this;

}

let valid = this.testRules(cStack);

if (valid) {

/**

* 填写的数字满足校验

* 先设置数独数组的值为当前测试的值

* 然后寻找下一个方格

*/

this.sudokuMap[cStack.x][cStack.y] = cStack.value;

stacks.push(this.getNextPoint());

} else {

/**

* 如果校验不通过

* 将当前方格的测试数据清空

*

* 在当前格子进行测试别的值

* 从1到9依次测试

* 如果全部失败

* 回溯到上一级

*

*/

//this.sudokuMap[cStack.x][cStack.y] = 0;

// console.log(stacks);

this.rollback();

}

};

}

/**

* 回退

* 取出数组最后一次填入的数据

* 1、如果当前位置是起始位置

* 并且值小于9

* 直接给这个值+1，并且推进堆栈数组中

* 2、如果不是起始位置

* 2.1 判定数值是否小于9，如果小于9直接进行+1并且推入堆栈进行计算

* 2.2 如果已经是9了，等于说这个格子填写任何数都不合适，所以需要继续回溯到上一个步骤

*/

rollback() {

let {

stacks, dataMap

} = this;

let currentStack = stacks.pop();

this.sudokuMap[currentStack.x][currentStack.y] = 0;

let cOrder = this.orders[this.currentOrder];

if(currentStack.value === cOrder.value[cOrder.value.length-1]) {

this.currentOrder--;

this.rollback()

}else{

let orderIndex = cOrder.value.indexOf(currentStack.value);

currentStack.value = cOrder.value[orderIndex+1];

stacks.push(currentStack);

}

}

/**

* 判断填入的数值是否满足数独规则

* 1、横向扫描，当前填入的数字是否有重复

* 2、纵向扫描，当前填入的数字是否有重复

* 3、扫描当前格子所在的3X3的小格子中是否有重复数字

*/

testRules(stack) {

let {

x: x,

y: y,

value: val

} = stack;

let ret = true;

let found = false;

for(let i = 0 ; i < 9 ; i++) {

this.allTimes++;

let node = this.sudokuMap[i][y];

if (node === val) {

this.testRuleTimes.fail++;

return false;

}

}

for(let j = 0 ; j < 9 ; j++) {

this.allTimes++;

let node = this.sudokuMap[x][j];

if (node === val) {

this.testRuleTimes.fail++;

return false;

}

}

/* x为n所在的小九宫格左顶点竖坐标 */

let startX = Math.floor(x / 3) * 3;

/* y为n所在的小九宫格左顶点横坐标 */

let startY = Math.floor(y / 3) * 3;

/* 判断n所在的小九宫格是否合法 */

for (let i = startX; i < startX + 3; i++)

{

for (let j = startY; j < startY + 3; j++)

{

this.allTimes++;

let node = this.sudokuMap[i][j];

if (node === val) {

this.testRuleTimes.fail++;

return false;

}

}

}

if(ret) {

this.testRuleTimes.ok++;

}else{

this.testRuleTimes.fail++;

}

return ret;

}

}

module.exports = Sudoku;

调用方法

let maps = {

easy: [

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

[ 5 ,0 ,0 , 0 , 7, 3 , 0 , 0 , 0 ],

[0 ,0 ,0 , 9 , 2, 8 , 0 , 0 , 5 ],

[0 ,0 , 3 , 0 , 4, 0 , 0 , 8 , 6 ],

[0 , 9 ,0 , 0 ,0, 0 , 0 , 0 , 4 ],

[0 , 2 ,0 , 0 ,0, 0 , 9 , 0 , 7 ],

[0 , 8 ,0 , 0 ,0, 2 , 0 , 0 , 1 ],

[ 9 ,0 , 6 , 0 ,0, 0 , 0 , 0 , 3 ],

[0 ,0 ,0 , 0 ,0, 0 , 0 , 6 , 0 ]

],

normal: [

[0 , 0 ,0 , 0 ,0, 0 , 2 , 0 , 0 ,],

[0 , 9 , 8 , 0 ,0, 0 , 4 , 0 , 0 ,],

[ 4 , 0 ,0 , 0 , 2, 0 , 3 , 0 , 0 ,],

[0 , 4 ,0 , 9 ,0, 0 , 0 , 0 , 6 ,],

[ 5 , 0 ,0 , 1 ,0, 0 , 7 , 3 , 0 ,],

[0 , 0 ,0 , 0 ,0, 6 , 0 , 5 , 0 ,],

[ 9 , 8 , 4 , 0 ,0, 1 , 6 , 0 , 0 ,],

[0 , 0 ,0 , 0 ,0, 4 , 0 , 0 , 3 ,],

[0 , 2 ,0 , 0 , 9, 0 , 1 , 0 , 0 ,],

],

hard: [

[ 0 , 0 ,5 , 3 ,0, 0 , 0 , 0 , 0 ],

[ 8 , 0 ,0 , 0 ,0, 0 , 0 , 2 , 0 ],

[ 0 , 7 ,0 , 0 ,1, 0 , 5 , 0 , 0 ],

[ 4 , 0 ,0 , 0 ,0, 5 , 3 , 0 , 0 ],

[ 0 , 1 ,0 , 0 ,7, 0 , 0 , 0 , 6 ],

[ 0 , 0 ,3 , 2 ,0, 0 , 0 , 8 , 0 ],

[ 0 , 6 ,0 , 5 ,0, 0 , 0 , 0 , 9 ],

[ 0 , 0 ,4 , 0 ,0, 0 , 0 , 3 , 0 ],

[ 0 , 0 ,0 , 0 ,0, 9 , 7 , 0 , 0 ],

],

hard1: [

[8,0,0,0,0,0,0,0,0],

[0,0,3,6,0,0,0,0,0],

[0,7,0,0,9,0,2,0,0],

[0,5,0,0,0,7,0,0,0],

[0,0,0,0,4,5,7,0,0],

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

[0,0,1,0,0,0,0,6,8],

[0,0,8,5,0,0,0,1,0],

[0,9,0,0,0,0,4,0,0]

]

}

for(let map in maps) {

let sdk = new Sudoku({

display: false, // 是否打印过程，打印的速度慢很多

sudokuMap: maps[map],

}).start();

}