荫试图解决一个数独板用蛮力算法，我真的不能得到正确的算法的工作。

有创建的属于实际柱，方形和行的每一行，列和盒包含所有正方形（细胞）一个对象，这是用在legalValue（），以检查是否值可放置在细胞

我找不到，使算法的工作结构。

 布尔setNumberMeAndTheRest（董事会板）{


    如果（GETNEXT（）== NULL）{
        的for（int i = 1; I＆LT; = board.getDimension（）;我++）{
            如果（legalValue（i））的{
                的setValue（ⅰ）;
            }
        }
        board.saveSolution（）;
    } 其他 {
        如果（这的instanceof DefinedSquare）{
            GETNEXT（）setNumberMeAndTheRest（板）。

        } 其他 {
            的for（int i = 1; I＆LT; = board.getDimension（）;我++）{
                如果（legalValue（i））的{
                    的setValue（ⅰ）;

                    如果（GETNEXT（）。setNumberMeAndTheRest（板））{
                        返回true;
                    } 其他 {
                        的setValue（ⅰ）;
                    }
                }
            }
            返回false;
        }
    }

    返回false;
}
 

下面是legalValue（int i）以;

  / **
 *如果值是合法的​​箱子，行和列的检查。
 *参数值来检查。
 * @返回true，如果值是合法的​​，否则为假。
 * /
布尔legalValue（int值）{
    如果（box.legalValue（值）及和放大器; row.legalValue（值）及和放大器; columne.legalValue（值））{
        返回true;
    }
    返回false;
}
 

  ** 4x4的数独板输入**

0 2 | 1 3
0 0 | 0 4
---------
0 0 | 0 1
0 4 | 3 2

**预期的输出**

4 2 | 1 3
3 1 | 2 4
---------
2 3 | 4 1
1 4 | 3 2

**实际输出**

4 2 | 1 3
2 4 | 3 4
---------
3 0 | 0 1
0 4 | 3 2
 

补充板复位

 布尔setNumberMeAndTheRest（董事会板）{

    主板原=板;

    如果（GETNEXT（）== NULL）{
        的for（int i = 1; I＆LT; = board.getDimension（）;我++）{
            如果（legalValue（i））的{
                的setValue（ⅰ）;
            }
        }
        board.saveSolution（）;

    } 其他 {
        如果（这的instanceof DefinedSquare）{
            GETNEXT（）setNumberMeAndTheRest（板）。

        } 其他 {
            的for（int i = 1; I＆LT; = board.getDimension（）;我++）{
                如果（legalValue（i））的{
                    的setValue（ⅰ）;

                    如果（GETNEXT（）。setNumberMeAndTheRest（板））{
                        返回true;
                    } 其他 {
                        的setValue（ⅰ）;
                    }
                }
            }
            板=原件;
            返回false;
        }
    }
    板=原件;
    返回false;
}
 

她是一个解决方案，经过很长一段时间：D

 布尔setNumberMeAndTheRest（董事会板）{

    如果（下一个== NULL）{
        board.saveSolution（）;
        返回true;
    }

    如果（这的instanceof DefinedSquare）{
        返回next.setNumberMeAndTheRest（板）;
    }

    的for（int i = 1; I＆LT; = board.getDimension（）; ++ I）{
        如果（legalValue（i））的{
            的setValue（ⅰ）;

            如果（next.setNumberMeAndTheRest（板））{
                返回true;
            }
        }
    }
    的setValue（0）;
    返回false;
}
 

解决方案

 布尔setNumberMeAndTheRest（董事会板）{

  //使原板的副本
  主板原=板;
 

然后每次返回false时，您还需要董事会恢复到初始状态

 板=原件;
返回false;
 

Iam trying to solve a sudoku board with a brute force algorithm, I cant really get this algorithm work correctly.

There is created a object for each row, column and box that contains all squares(cells) that belongs to the actually column, square and row, this is used in legalValue() to check if value can be placed in the cell.

I cant find the structure that make the algorithm to work.

    boolean setNumberMeAndTheRest(Board board) {


    if(getNext() == null) {
        for(int i = 1; i <= board.getDimension(); i++) {
            if(legalValue(i)) {
                setValue(i);
            }
        }
        board.saveSolution();
    } else {
        if(this instanceof DefinedSquare) {
            getNext().setNumberMeAndTheRest(board);

        } else {
            for(int i = 1; i <= board.getDimension(); i++) {
                if(legalValue(i)) {
                    setValue(i);

                    if(getNext().setNumberMeAndTheRest(board)) {
                        return true;
                    } else {
                        setValue(i);
                    }
                }
            }
            return false;
        }
    }

    return false;
}

Here is legalValue(int i);

/**
 * Checks if value is legal in box, row and column.
 * @param value to check.
 * @return true if value is legal, else false.
 */
boolean legalValue(int value) {
    if(box.legalValue(value) && row.legalValue(value) && columne.legalValue(value)) {
        return true;
    }
    return false;
}

**4x4 Sudoku board INPUT**

0 2 | 1 3
0 0 | 0 4
---------
0 0 | 0 1
0 4 | 3 2

**Expected OUTPUT**

4 2 | 1 3
3 1 | 2 4
---------
2 3 | 4 1
1 4 | 3 2

**Actually OUTPUT**

4 2 | 1 3
2 4 | 3 4
---------
3 0 | 0 1
0 4 | 3 2

Added resetting of board

boolean setNumberMeAndTheRest(Board board) {

    Board original = board;

    if(getNext() == null) { 
        for(int i = 1; i <= board.getDimension(); i++) {
            if(legalValue(i)) {
                setValue(i);
            }
        }
        board.saveSolution();

    } else {
        if(this instanceof DefinedSquare) {
            getNext().setNumberMeAndTheRest(board);

        } else {
            for(int i = 1; i <= board.getDimension(); i++) {
                if(legalValue(i)) {
                    setValue(i);

                    if(getNext().setNumberMeAndTheRest(board)) {
                        return true;
                    } else {
                        setValue(i);
                    }
                }
            }
            board = original;
            return false;
        }
    }
    board = original;
    return false;
}

Her is a solution, after a long time :D

boolean setNumberMeAndTheRest(Board board) {

    if(next == null) {
        board.saveSolution();
        return true;
    }

    if(this instanceof DefinedSquare) {
        return next.setNumberMeAndTheRest(board);
    }

    for(int i = 1; i <= board.getDimension(); ++i) {
        if(legalValue(i)) {
            setValue(i);

            if(next.setNumberMeAndTheRest(board)) {
                return true;
            }
        }
    }
    setValue(0);
    return false;
}

boolean setNumberMeAndTheRest(Board board) {

  // make a copy of the original board
  Board original = board;

then every time you return false, you also need to reset the board to its original state

board = original;
return false;