1

数独パズルを解いて解くプログラムを書こうとしています。ただし、次の行で StackOverflow エラーが発生しています。

Move nMove = new Move(current.nextMove(current, sboard).i, current.nextMove(current, sboard).j);

移動が有効かどうかをチェックする isLegal メソッドがあります。手が有効で、次の手も有効な場合、それをスタックに追加します。それが有効であるが、次の動きが有効でない場合、有効な番号を検索し続ける必要があります。何が原因なのかわからない。

import java.util.Stack;

public class Board {
    Stack<Move> stack = new Stack<Move>(); 
    int boardSize = 9;
    public int[][] sboard = {{2,0,0,3,9,5,7,1,6},
            {5,7,1,0,2,8,3,0,9},
            {9,3,0,7,0,1,0,8,2},
            {6,8,2,0,3,9,1,0,4},
            {3,5,9,1,7,4,6,2,8},
            {7,1,0,8,6,0,9,0,3},
            {8,6,0,4,1,7,2,9,5},
            {1,9,5,2,8,6,4,3,7},
            {4,2,0,0,0,0,8,6,1}};

    public Board() {
        //for every cell in board:
        for (int i = 0; i < boardSize; i++) {
            for (int j = 0; j < boardSize; j++) {
                //get the value of each cell
                int temp = getCell(i,j);
                //if cell is empty:
                if (temp == 0) {
                    //print out location of cell
                    System.out.print ("("+i+", "+j+") ");

                    //guess values for that cell
                    solve(i, j);
                }
            }
        }
    }

    //places a value into specified cell
    public void setCell(int value, int row, int col) {
        sboard[row][col] = value;
    }

    //returns value contained at specified cell
    public int getCell(int row, int col) {
        return sboard[row][col];
    }

    //if value is legal, continue
    public boolean isLegal(int value, int row, int col) {
        int r = (row / boardSize) * boardSize;
        int c = (col / boardSize) * boardSize;

        for (int i = 0; i < boardSize; i++) {
            for (int j = 0; j < boardSize; j++) {
                if (value == getCell(i, col) || value == getCell(row, j)) {
                    return false;
                }
            }
        }

        return true;
    }

    //guesses values for empty cells
    public boolean solve(int i, int j) {
        //set location as current
        Move current = new Move(i, j);
        Move nMove = new Move(current.nextMove(current, sboard).i, current.nextMove(current, sboard).j);
        //guesses values 1 through 9 that are legal
        for (int k = 1; k <= 9; k++) {
            //if a legal value is found and the next move is possible:
            if(isLegal(k, i, j) && solve(nMove.i, nMove.j)) {
                //add current to stack
                stack.push(current);
                //enter the value k into the cell
                setCell(k, i, j);
                //print new value
                System.out.print(sboard[i][j]+"\n");
                //return as true
                return true;
            }

            else if (stack.empty()){

            }
            //if next move is not possible
            else if(!solve(nMove.i, nMove.j)){
                //remove last "solved" location from stack
                stack.pop();
                //solve last location again
                solve(stack.peek());
            }
        }
        return false;
    }

    public void solve(Move m) {
        solve(m.i, m.j);
    }

    public static void main(String[] args) {
        Board b = new Board();
    }  
};

class Move {
    int i, j; 

    public Move(int i, int j) {
        this.i = i; 
        this.j = j;
    }

    public int i() { return i;}

    public int j() { return j;}

    public Move nextMove(Move current, int[][] sboard){
        for (int i = current.i; i < 9; i++) {
            for (int j = current.j; j < 9; j++) {
                //get the value of each cell
                int temp = sboard[i][j];
                if (temp == 0) {
                    return new Move(i, j);
                }
            }   
        }
        return current;
    }
};
4

2 に答える 2

1

1 つには、この関数を の形式にするのは冗長に思えますcurrent.nextMove(current, board)。この関数を静的にするか、Move currentパラメーターを削除することができます。

しかし、solve(i, j)関数を見ると、基本的に次のようになります。

  1. 仮定sboard[i][j] = 0します(場合によっては、入力から明らかにそうします)。
  2. を呼び出すとしますsolve(i, j)
  3. currentとなりますnew Move(i, j)
  4. nMoveもなりますnew Move(i, j)(Move#nextMove では、基本的に と言うif sboard[i][j] == 0ので、ステップ 1 から実行されます)。
  5. あなたは電話をかけることになりますsolve(nMove.i, nMove.j)
  6. nMove.i == iと以来nMove.j == j、あなたは本質的solve(i, j)にもう一度電話をかけています。

同じパラメータで同じ関数を呼び出しており、基本ケースに到達していないため、スタック オーバーフローが発生します。

于 2011-11-02T03:01:03.040 に答える
0

(明示的な) スタックを定義したので、solve() を再帰的に呼び出すべきではありません。

ループし、ボードをポップし、すべての有効な次の動きを生成し、それらの 1 つが解決策であるかどうかを確認し、そうでない場合はそれらをスタックにプッシュします。

(ボードが完成したことを確認する場所が見つかりませんでしたが、おそらく疲れています。)

ところで、スタックはおそらくデキューである必要があります。コードが遅くなるスタックが同期されていると思います。

于 2011-11-02T04:31:54.003 に答える