Java 数独解算器错误

我不知道我做错了什么，我整天都在盯着这个代码。这是一个Java中的“标准”数独解算器，它在空格所在的位置使用

int[][]

和0。考虑到我只通过了一个有35个洞的板，这应该可以解决绝大多数问题，但只能解决66%。在另一些情况下，会留下一些（通常是2或4个）无法解决的空白（即，

电路板

中写入了不正确的数字）。几乎总是缺少9

我明白这样一个简单的解决方案并不能解决所有数独问题。我故意给它一些简单的

import java.util.ArrayList;
import java.util.List;

public class SudokuSolver
{
    public SudokuSolver()
    {
        init();
    }

    public boolean solve()
    {
        /* Each method checks (in different ways) to see if it can find a new number
            If said method does find a number, it sets off a chain reaction, starting back at the beginning.
        */
        int countdown = 20;
        while(!solved() && --countdown > 0)
        {
            if(given())
                continue;
            if(findSingletons())
                continue;
            if(zerosLeft() <= 4)
                justGuess();
        }
        return solved();
    }

    public boolean given()
    {
        boolean repeat = false;
        //Iterate through every given number
        for(int i=0;i<9;i++)
        {
            for(int j=0;j<9;j++)
            {
                if(board[i][j] != 0 && !found[i][j])
                {
                    repeat = true;
                    foundNum(i, j, board[i][j]);
                }
            }
        }
        //Call given every time a new number is found
        return repeat;
    }

    public boolean findSingletons()
    {
        boolean repeat = false;
        //LOTS of iteration, but I'm out of ideas.
        int[] values;
        ArrayList<Integer> singletons = new ArrayList<Integer>();
        for(int i=0;i<9;i++)
        {
            values = new int[10];
            singletons.clear();
            for(int j=0;j<9;j++)
                for(int k=0;k<possible[i][j].size();k++)
                    values[possible[i][j].get(k)]++;
            for(int j=1;j<10;j++)
                if(values[j] == 1)
                    singletons.add(j);
            for(int j=0;j<9;j++)
                for(int k=0;k<singletons.size();k++)
                    if(possible[i][j].contains(singletons.get(k)))
                    {
                        foundNum(i, j, singletons.get(k));
                        repeat = true;
                    }
        }

        for(int i=0;i<9;i++)
        {
            values = new int[10];
            singletons.clear();
            for(int j=0;j<9;j++)
                for(int k=0;k<possible[j][i].size();k++)
                    values[possible[j][i].get(k)]++;
            for(int j=1;j<10;j++)
                if(values[j] == 1)
                    singletons.add(j);
            for(int j=0;j<9;j++)
                for(int k=0;k<singletons.size();k++)
                    if(possible[j][i].contains(singletons.get(k)))
                    {
                        foundNum(j, i, singletons.get(k));
                        repeat = true;
                    }
        }

        int[] corners = {0,3,6};
        for(int a=0;a<3;a++)
            for(int l=0;l<3;l++)
                for(int i=corners[a];i<corners[a]+3;i++)
                {
                    values = new int[10];
                    singletons.clear();
                    for(int j=corners[l];j<corners[l]+3;j++)
                        for(int k=0;k<possible[i][j].size();k++)
                            values[possible[i][j].get(k)]++;
                    for(int j=1;j<10;j++)
                        if(values[j] == 1)
                            singletons.add(j);
                    for(int j=0;j<9;j++)
                        for(int k=0;k<singletons.size();k++)
                            if(possible[i][j].contains(singletons.get(k)))
                            {
                                foundNum(i, j, singletons.get(k));
                                repeat = true;
                            }
                }
        return repeat;
    }

    public void justGuess()
    {
        outer:
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
                if(board[i][j] == 0)
                {
                    foundNum(i, j, possible[i][j].get(0));
                    break outer;
                }
    }

    public void foundNum(int x, int y, int numFound)
    {

        if(board[x][y] != 0 && board[x][y] != numFound)
        {
            throw new RuntimeException("Attempting to place a number where one was already found");
        }

        board[x][y] = numFound;
        possible[x][y].clear();
        possible[x][y].add(numFound);
        found[x][y] = true;

        for(int i=0;i<9;i++) {
            if(i != x)
                if(possible[i][y].indexOf(numFound) != -1)
                    possible[i][y].remove(possible[i][y].indexOf(numFound));
        }
        for(int i=0;i<9;i++) {
            if(i != y)
                if(possible[x][i].indexOf(numFound) != -1)
                    possible[x][i].remove(possible[x][i].indexOf(numFound));
        }
        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(i != x && j != y)
                    if(possible[i][j].indexOf(numFound) != -1)
                        possible[i][j].remove(possible[i][j].indexOf(numFound));
    }

    public boolean solved() {
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
                if(!found[i][j])
                    return false;
        return true;
    }

    public void reset(int[][] board)
    {
        this.board = board;
        init();
    }

    public void init()
    {
        possible = new ArrayList[9][9];
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
            {
                possible[i][j] = new ArrayList<Integer>();
                for(int k=1;k<10;k++)
                    possible[i][j].add(k);
            }
        found = new boolean[9][9];
    }

    public void print()
    {
        for(int i=0;i<9;i++)
        {
            if(i%3==0 && i != 0)
                System.out.println("-  -  -  | -  -  -  |  -  -  -");
            for(int j=0;j<9;j++)
            {
                if(j%3==0 & j != 0)
                    System.out.print("| ");
                System.out.print(board[i][j] + "  ");
            }
            System.out.println();
        }
        System.out.println();
    }

    private int zerosLeft()
    {
        int empty = 0;
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
                if(board[i][j] == 0)
                    empty++;
        return empty;
    }

    private void data(int difficulty)
    {
        int empty = 0;
        for(int i=0;i<9;i++)
            for(int j=0;j<9;j++)
                if(board[i][j] == 0)
                    empty++;
        System.out.println(empty);
    }

    public static void main(String[] args)
    {
        SudokuGenerator sg = new SudokuGenerator();
        SudokuSolver ss = new SudokuSolver();
        int[][] tempBoard = {{4, 0, 1, 0, 9, 7, 0, 5, 8 },
                        {2, 0, 0, 5, 3, 1, 4, 0, 6 },
                        {5, 0, 6, 4, 0, 2, 0, 3, 9 },
                        {0, 9, 0, 0, 0, 4, 3, 0, 2 },
                        {0, 0, 0, 9, 0, 0, 6, 4, 7 },
                        {7, 0, 4, 0, 0, 0, 9, 0, 5 },
                        {0, 0, 7, 0, 0, 3, 8, 9, 4 },
                        {8, 5, 0, 1, 4, 9, 7, 0, 0 },
                        {9, 0, 3, 8, 7, 6, 0, 0, 0 }};
        ss.reset(tempBoard);
        System.out.println(ss.solve());
        ss.print();
        ss.data(35);
    }

    int[][] board;
    ArrayList<Integer>[][] possible;
    boolean[][] found;
}

import java.util.ArrayList；
导入java.util.List；
公共级数独行者
{
公共数独
{
init（）；
}
公共布尔解（）
{
/*每个方法都会检查（以不同的方式）是否可以找到新的编号
如果这个方法真的找到了一个数字，它会引发一个连锁反应，从头开始。
*/
整数倒计时=20；
而（！solved（）&&--countdown>0）
{
if（给定（））
继续；
if（findSingletons（））
继续；
如果（zerosLeft（）我开始阅读你的代码，但感觉它比应该的要长，而且那些循环变得非常混乱。没有什么东西会立即向我跳出来。你说过你不只是想要解决方案，而是需要建议

你必须弄清楚问题是出在你的设计上（它不适用于解决数独问题），还是在实现过程中的某个地方有一个简单的错误。也许可以浏览并写下关于每个循环所完成的“橡皮鸭测试”的评论，被迫解释一切，你会停下来，意识到有些东西是不必要的，或者不是它所需要的。这有助于解决设计问题

如果问题是实现，您知道如何正式调试应用程序吗？设置断点并逐条指令检查应用程序？如果您有一个小错误，但看不到在哪里，那就是解决方法。找到一个失败的非常简单的示例，然后运行该测试，并在开始时将其中断。逐步执行，然后按照在逻辑上。希望你能看到哪里出了问题。编写JUnit测试或日志语句很好，但是当你遇到棘手的错误时，你必须进行一些真正的断点调试

你的通用框架很好，你有一些对象来保存数据，还有一个很好的干净的solve方法，它调用了一些不同的方法和循环。但是这些方法中的每一个，哇，它们都很凌乱。那种代码，很多紧循环使用相同的变量名，很多数组操作，很容易搞乱一些东西我发现了一个bug，这使得阅读和查找bug变得非常困难

Eclipse使调试java变得非常容易，如果您以前没有这样做过的话。google上有很多很好的教程，所以我不想麻烦您^ ~
您似乎没有实现回溯机制。有时，如果没有实现正确的启发式，您必须猜测数字

启发式是“交易技巧”，下面是一个例子

如果你只对其中的几个进行编程，你将陷入死胡同，不得不猜测。这使得猜测更加困难，因为你必须考虑到这些猜测可能是错误的。回溯是一种允许你“回滚”的策略做一些猜测，然后做出不同的猜测。把它想象成一棵可能的树，用某种暴力来解决数独问题

因此，您的两种可能性是实施更多的启发式或找到一种方法来进行更广泛的猜测
“这是我迄今为止编写的最亵渎的代码。”Eric Lippert在C#中编写了一个相当漂亮的数独解算器。它使用了Java没有的一些功能，但我建议大家看看。通过编写jUnit测试来测试特定方法来驱动开发。阅读测试驱动开发（TDD）在面向对象的设计中阅读。这里有两个明显的代码重构，这里没有时间做全面的回顾。但是这里有一些亮点：findSingletons很长。考虑将它重构成更小的方法。重写ToStin，而不是使用打印方法；检查我的代码。在这里写了一个类似但更简单的问题@Rob：你可以删除你自己的评论（你需要更多的声誉吗？）-例如，如果你过早地点击“回车”，可能是为了创建一个新行。我熟悉回溯，我在算法中使用它生成数独板。我对解决每个板都不感兴趣，只对我从生成器传入的非常简单的板感兴趣。感谢您帮助我确定我需要查找的位置。我将尝试清理循环语句。如果解决了问题，我将接受