数独C

问候，

欢迎回到数独文章的第三部分。 本部分描述实际

数独求解器。 求解器的工作非常简单：给定要填充的单元格，

尝试所有可能的值并解决电路板的其余部分。 如果所有单元格都已填充

数独难题解决了。

求解器对所有单元进行迭代，从左到右，从上到下。 它收到

两个参数i和j是要填充的单元格的索引。

单元格可以已经填写（这是给定的单元格值），在这种情况下

求解器必须找到下一个位置。 解决方法的第一部分尝试

查找一个空单元格：

private boolean solve(int i, int j) { 
    for(;;) {
        if (j >= columns.length) {
            j= 0;
            i++;
        } 
        if (i >= rows.length) return true; 
        if (board[i][j] > 0) j++;
        else break;
    }
    ...

如果您仔细检查这段代码，您会发现每一行都被选中，

逐列。 检查最后一列后，将检查下一行

再次检查所有单元格，在这种情况下数独难题就解决了

并且返回true。 否则，将找到一个空单元格，

执行此for循环之后的代码。 此方法的下一部分

递归尝试解决数独难题：

    ...
    for (int val= 0; val < squares.length; val++) {
        if (possible(i, j, val)) 
            if (!solve(i, j+1)) {
                reset(i, j);
            }
            else
                return true;
    } 
    return false;
}

对于当前单元格，尝试所有值0 ... 8。 如果值可行

它被填充，并试图解决数独难题的其余部分。

如果尝试失败，将重置单元格并尝试下一个值。 如果

尝试成功，该方法立即返回，因为整个

难题解决了。 否则循环结束（这些值均不可行

对于该特定单元格i，j），该方法返回false。

请注意，此方法是私有方法。 我是故意这样做的，因为我

不想其他对象提供两个索引值。 这是一个公众

为他们做的方法：

public boolean solve() {
    return solve(0, 0);
}

现在我们需要的是一个简单的驱动程序方法，该方法可以创建Sudoku求解器对象，

打开阅读器，初始化拼图并启动求解器。 我们将实施

为简单起见，main（）方法中的驱动程序功能：

public static void main(String[] args) throws Exception { 
    Sudoku s= new Sudoku();
    FileReader fr= new FileReader(args[0]); 
    if (s.read(new FileReader(args[0))) {
        if (s.solve()) {
            s.print(new OutputStreamWriter(System.out));
        }
        else
            System.err.println("problem cannot be solved");
    }
    else
        System.err.println("problem file cannot be read");
}

请注意，这是一个非常草率的实现，即当某些事情发生时

严重错误，例如未将文件名传递给main方法或

实际读取失败，则将异常简单地传递到JVM，它将

打印一个丑陋的堆栈跟踪。 我们甚至没有费心关闭FileStream

正确：当JVM退出时，FileReader仍将关闭。

我将取决于您的想象力和创造力，以实施适当的，

工业实力的驱动力。 上面的一个很好的示范

本文的目的。

我创建了一个文件“ /sudoku.txt”，其中包含以下内容：

旧报纸：

+-------+-------+-------+
| 7 . . | . . . | 4 . . | 
| . 2 . | . 7 . | . 8 . |
| . . 3 | . . 8 | . . 9 |
+-------+-------+-------+ 
| . . . | 5 . . | 3 . . |
| . 6 . | . 2 . | . 9 . |
| . . 1 | . . 7 | . . 6 |
+-------+-------+-------+ 
| . . . | 3 . . | 9 . . |
| . 3 . | . 4 . | . 6 . |
| . . 9 | . . 1 | . . 5 |
+-------+-------+-------+

然后我开始数独课：

java -classpath . Sudoku /sudoku.txt

这几乎是立即打印的：

+-------+-------+-------+
| 7 9 8 | 6 3 5 | 4 2 1 | 
| 1 2 6 | 9 7 4 | 5 8 3 | 
| 4 5 3 | 2 1 8 | 6 7 9 | 
+-------+-------+-------+
| 9 7 2 | 5 8 6 | 3 1 4 | 
| 5 6 4 | 1 2 3 | 8 9 7 | 
| 3 8 1 | 4 9 7 | 2 5 6 | 
+-------+-------+-------+
| 6 1 7 | 3 5 2 | 9 4 8 | 
| 8 3 5 | 7 4 9 | 1 6 2 | 
| 2 4 9 | 8 6 1 | 7 3 5 | 
+-------+-------+-------+

我查看了第二天的报纸，确实是：报纸和

求解器显示了相同的解决方案。 只是为了好玩，我改变了我的内容

/sudoku.txt文件：

+-------+-------+-------+
| . . . | . . . | . . . | 
| . . . | . . . | . . . |
| . . . | . . . | . . . |
+-------+-------+-------+ 
| . . . | . . . | . . . |
| . . . | . . . | . . . |
| . . . | . . . | . . . |
+-------+-------+-------+ 
| . . . | . . . | . . . |
| . . . | . . . | . . . |
| . . . | . . . | . . . |
+-------+-------+-------+

并再次触发求解器； 这是输出：

+-------+-------+-------+
| 1 2 3 | 4 5 6 | 7 8 9 | 
| 4 5 6 | 7 8 9 | 1 2 3 | 
| 7 8 9 | 1 2 3 | 4 5 6 | 
+-------+-------+-------+
| 2 1 4 | 3 6 5 | 8 9 7 | 
| 3 6 5 | 8 9 7 | 2 1 4 | 
| 8 9 7 | 2 1 4 | 3 6 5 | 
+-------+-------+-------+
| 5 3 1 | 6 4 2 | 9 7 8 | 
| 6 4 2 | 9 7 8 | 5 3 1 | 
| 9 7 8 | 5 3 1 | 6 4 2 | 
+-------+-------+-------+

输出清楚地表明，求解器可以解决以下问题：

严格从左到右，从上到下的方式：检查第一行和

第一个子正方形，看规律性。

这是一个幼稚的求解器，但是对于我尝试过的问题来说效果很好。 一些问题

被认为是极其困难的。 稍微玩这个解算器，喂它

一些困难的问题，看看它是如何运行的。

Sudoku类仅需要一个Reader和Writer，即它不在乎如何

这些流已创建。 您甚至可以创建一个免费的Sudoku求解器服务器

如果您愿意的话，请从其中取出：将Reader包裹在创建的InputStream周围

通过插座。 对Writer和套接字的OutputStream进行相同的操作。

该求解器可以找到给定问题的“第一个”解决方案。 您可以尝试

稍微改变“解决”方法，以便找到所有解决方案。 由你决定。

直到下周，我们将讨论一些更严重的问题。

亲切的问候，

乔斯

From: https://bytes.com/topic/java/insights/739703-sudoku-c