我正在尝试创建一个用于监视的应用程序，其中我的内存资源非常有限，当我使用递归生成数独矩阵时，我得到堆栈溢出异常。有些人可以给我任何输入，如果我仍然想每次生成一个随机数独，但系统资源有限，没有递归。我正在使用当前正在给出堆栈溢出异常的代码。
package test;
import java.util.*;
import java.text.*;
/**
* The SudokuGenerator class creates a random standard (9x9) Sudoku board
* through the use of backtracking techniques.
*/
public class validS {
public static final int BOARD_WIDTH = 9;
public static final int BOARD_HEIGHT = 9;
/**
* Constructor. Resets board to zeros
*/
public validS() {
board = new int[BOARD_WIDTH][BOARD_HEIGHT];
}
/**
* Driver method for nextBoard.
*
* @param difficult
* the number of blank spaces to insert
* @return board, a partially completed 9x9 Sudoku board
*/
public int[][] nextBoard(int difficulty) {
board = new int[BOARD_WIDTH][BOARD_HEIGHT];
nextCell(0, 0);
makeHoles(difficulty);
return board;
}
/**
* Recursive method that attempts to place every number in a cell.
*
* @param x
* x value of the current cell
* @param y
* y value of the current cell
* @return true if the board completed legally, false if this cell has no
* legal solutions.
*/
public boolean nextCell(int x, int y) {
int nextX = x;
int nextY = y;
int[] toCheck = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Random r = new Random();
int tmp = 0;
int current = 0;
int top = toCheck.length;
for (int i = top - 1; i > 0; i--) {
current = r.nextInt(i);
tmp = toCheck[current];
toCheck[current] = toCheck[i];
toCheck[i] = tmp;
}
for (int i = 0; i < toCheck.length; i++) {
if (legalMove(x, y, toCheck[i])) {
board[x][y] = toCheck[i];
if (x == 8) {
if (y == 8)
return true;// We're done! Yay!
else {
nextX = 0;
nextY = y + 1;
}
} else {
nextX = x + 1;
}
if (nextCell(nextX, nextY))
return true;
}
}
board[x][y] = 0;
return false;
}
/**
* Given a cell's coordinates and a possible number for that cell, determine
* if that number can be inserted into said cell legally.
*
* @param x
* x value of cell
* @param y
* y value of cell
* @param current
* The value to check in said cell.
* @return True if current is legal, false otherwise.
*/
private boolean legalMove(int x, int y, int current) {
for (int i = 0; i < 9; i++) {
if (current == board[x][i])
return false;
}
for (int i = 0; i < 9; i++) {
if (current == board[i][y])
return false;
}
int cornerX = 0;
int cornerY = 0;
if (x > 2)
if (x > 5)
cornerX = 6;
else
cornerX = 3;
if (y > 2)
if (y > 5)
cornerY = 6;
else
cornerY = 3;
for (int i = cornerX; i < 10 && i < cornerX + 3; i++)
for (int j = cornerY; j < 10 && j < cornerY + 3; j++)
if (current == board[i][j])
return false;
return true;
}
/**
* Given a completed board, replace a given amount of cells with 0s (to
* represent blanks)
*
* @param holesToMake
* How many 0s to put in the board.
*/
public void makeHoles(int holesToMake) {
/*
* We define difficulty as follows: Easy: 32+ clues (49 or fewer holes)
* Medium: 27-31 clues (50-54 holes) Hard: 26 or fewer clues (54+ holes)
* This is human difficulty, not algorighmically (though there is some
* correlation)
*/
double remainingSquares = 81;
double remainingHoles = (double) holesToMake;
for (int i = 0; i < 9; i++)
for (int j = 0; j < 9; j++) {
double holeChance = remainingHoles / remainingSquares;
if (Math.random() <= holeChance) {
board[i][j] = 0;
remainingHoles--;
}
remainingSquares--;
}
}
/**
* Prints a representation of board on stdout
*/
public void print() {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++)
System.out.print(board[i][j] + " ");
System.out.println();
}
System.out.println();
}
public static void main(String[] args) {
validS sg = new validS();
sg.nextBoard(70);
sg.print();
}
int[][] board;
private int operations;
}
答案 0 :(得分：0)
你可能用完了堆栈空间，因为在“最糟糕”的情况下，即在完成构建板时，你有81次调用 nextCell + 1到 legalMove < / em>的。我不是Java人，但首先要尝试的是在 nextCall 的开头摆脱变量：
int nextX = x;
int nextY = y;
Random r = new Random();
int tmp = 0;
int current = 0;
int top = toCheck.length;
- 这个 Random 对象可能在调用之间共享; 如果您需要使用 nextX ， nextY （实际上并不是这样），请尝试在“if（块）中使用它们（legalMove（x，y， toCheck [i]））{“; 不要使用 top ，只需用 toCheck.length 初始化loop var; 在“shuffling loop”中声明 tmp 。 在geral中保持变量尽可能是本地的，这不仅仅是因为内存管理，还是很好的。
如果这没有用（这很可能），那么你可以尝试使用自己的控制结构 - 一个只包含 x s， y 的堆栈 toCheck S， 总是从堆栈中尝试第一个，直到你用完 toCheck 。这是一个示例js实现（我包括整个内容，以便您可以在浏览器中测试它，但您只对 buildBoard（）的代码感兴趣）：
var rand = function(uppBnd) { return(Math.floor(Math.random()*uppBnd)); };
var board = null; /// just for the scoping
function mkEmptyBoard(h,w) { /// can't think of other way to initialize hxw array in js
var b=[];
for(i=0;i<h;i++) {
var r=[];
for(j=0;j<w;j++) r.push(0);
b.push(r);
}
return b;
}
/// this one is taken from your code, btw you can make this corner things easier.
function legalMove(x,y,current) {
for (var i = 0; i < 9; i++) {
if (current == board[x][i])
return false;
}
for (var i = 0; i < 9; i++) {
if (current == board[i][y])
return false;
}
var cornerX = 0;
var cornerY = 0;
if (x > 2)
if (x > 5)
cornerX = 6;
else
cornerX = 3;
if (y > 2)
if (y > 5)
cornerY = 6;
else
cornerY = 3;
for (var i = cornerX; i < 10 && i < cornerX + 3; i++)
for (var j = cornerY; j < 10 && j < cornerY + 3; j++)
if (current == board[i][j])
return false;
return true;
}
function nextPos(x,y) { if(x<8) return [x+1,y]; else return [0,y+1]; }
function mkToCheck() { /// this one just builds your "suffled array"
var toCheck = [];
for(var i=0;i<9;i++) toCheck.push(i+1);
for(var i = toCheck.length - 1; i > 0; i--) {
var tmp;
current = rand(i);
tmp = toCheck[current];
toCheck[current] = toCheck[i];
toCheck[i] = tmp;
}
return toCheck;
}
/// THE THING IS HERE:
function buildBoard() {
board = mkEmptyBoard(9,9);
var stck = [{'x':0,'y':0,'check': mkToCheck()}];
while(stck.length>0) {
while(stck[0].check.length>0) {
var ch = stck[0].check.shift();
if(legalMove(stck[0].x, stck[0].y, ch)) {
board[stck[0].x][stck[0].y] = ch;
if(stck[0].y==8 && stck[0].x==8) return true; /// yay! board is ready
var nextpos = nextPos(stck[0].x, stck[0].y);
stck.unshift({'x':nextpos[0],'y':nextpos[1],'check':mkToCheck()});
break;
}
}
if(stck[0].check.length==0) { /// a bind alley -- revert!
board[stck[0].x][stck[0].y]=0;
stck.shift();
}
}
board=mkEmptyBoard(); // clear the board as this is
return false; /// a complete failure (hopefully notreached :))
}
如果仍然不适合你的记忆，你必须修改你的算法。也许你可以从每个行/列是一组正数的排列这一事实中获利？如果你的想法用完了，那么stackoverflow上的某个人（我已经在 sudoku 标签下看到它）建议通过置换[行]组来生成板的另一种（非回溯）方法已准备好的一列（一个这样的预先计算的板足以生成~46k新板） - 这可能是您设置的最佳选择。