用STL实现先深搜索及先宽搜索——数独(sudoku)例子(1)
用STL实现先深搜索及先宽搜索
——数独
(sudoku)
例子
(1)
前面我们用STL容器实现了简单的DFS和BFS算法，为了检查它们的有效性，我们选择一个游戏——数独sudoku，先来实作出一个简单（但效率较差）的解法，测试了一下这两个DFS和BFS算法。
考虑到可能有些朋友还不太了解这个数独sudoku，所以我先来简单地介绍一下这个游戏的规则。如下图所示：
左边是一条典型的3x3数独问题，而右边则是该题的答案。数独的规则很简单，3x3的数独题就是一个9x9的方阵，方阵中的每一个格子可以填入1-9的数字，要求是：每行不能有重复的数字，每列也不能有重复的数字，而且9x9的方阵再划分为9个3x3的小方阵，要求每个小方阵中也不能有重复的数字。按照正常的数独规则，每个问题必须只能有一个答案，不过这个规则与我们的搜索算法无关，我们可以不理睬问题是否无解或有多个解，只管搜索就是了（前面的文章也介绍过，我们的DFS和BFS算法中有一个模板参数，可以由使用者来决定只找出一个解或是找出所有解）。
现在开始来实作这个数独程序。前面给出的DFS和BFS算法是一个泛型算法，它需要我们针对不同的具体问题，提供两个东西，然后搜索算法才可以得以执行。
首先是一个表示问题状态的类，在这个例子中，就是要设计一个表示数独问题状态的类。最简单的想法就是用一个二维数组来表示数独问题的一个状态，对于3x3数独问题，我们用一个9x9的二维数组来表示问题状态，数组中的每个元素取值为0-9，其中0表示空格，1-9表示相应已固定的数字。根据我们的DFS和BFS算法要求，这个类需要提供两个成员函数：void nextStep(vector&)和bool isTarget()；前者以自身状态为起点，返回所有可能的下一步状态，由于可能的下一步状态数量不定，所以需要用vector&来返回；后一个成员函数则比较简单，返回一个bool值来判断自身状态是否满足解答条件。除此之外，我还准备为这个类增加流输入和流输出函数，用以读入问题和输出答案。所以，这个类的定义如下：
class SudokuState
{
public:
SudokuState() {}
void nextStep(vector&) const;
bool isTarget() const;
friend ostream& operator<< (ostream& os, const SudokuState& s);
friend istream& operator>> (istream& is, SudokuState& s);
private:
int data_[SUDOKU_DIMS][SUDOKU_DIMS];
...
};
我们先从简单的bool isTarget()着手。这个很简单，只要对二维数组中的所有元素进行逐个检查，如果全部不为0，则表示方阵中的所有格子已经填满，即已经完成了解答。当然，我们本应在isTarget()中检查这些数字是否满足数独的规则要求，不过，我们可以通过在nextStep()中确保填入的每个数字满足规则来确保这一点，因而在isTarget()中我们就可以省略这一检查了。isTarget()如下：
bool SudokuState::isTarget() const
{
for (int row = 0; row < SUDOKU_DIMS; ++row)
{
for (int col = 0; col < SUDOKU_DIMS; ++col)
{
if (data_[row][col] == 0)
{
return false;
}
}
}
return true;
}
nextStep()是算法的核心，所以相对复杂一些，不过我们也可以有所选择。我首先选择的是实作一个简单的算法，当然它的效率会相对低一些，我决定把对算法的优化延后处理。这个简单的算法就是：扫描表示问题状态的二维数组，当发现第一个空格时，就针对这个空格找出全部可供选择的数字（即与空格所在行、列、小方阵中已有的数字均不重复），每一个可选的数字代当前问题状态的一个下一步可选状态。按照DFS和BFS算法的要求，我们把所有可选的下一步状态插入作为参数传入的vector对象中返回给DFS和BFS。
void SudokuState::nextStep(vector& vs) const
{
SudokuState newState;
bool pos[SUDOKU_DIMS];
for (int row = 0; row < SUDOKU_DIMS; ++row)
{
for (int col = 0; col < SUDOKU_DIMS; ++col)
{
if (data_[row][col] == 0) //
有一个空格，找出其可能填入的值
{
fill_n(pos, SUDOKU_DIMS, true);
for (int i = 0; i < SUDOKU_DIMS; ++i) //
排除同行、同列的值
{
checkValue(pos, data_[i][col]);
checkValue(pos, data_[row][i]);
}
int rs = row - (row % SUDOKU_ROWS); //
排除同一小方阵的值
int cs = col - (col % SUDOKU_COLS);
for (int i = 0; i < SUDOKU_ROWS; ++i)
{
for (int j = 0; j < SUDOKU_COLS; ++j)
{
checkValue(pos, data_[rs+i][cs+j]);
}
}
for (int i = 0; i < SUDOKU_DIMS; ++i)
{
if (pos[i]) //
找到一个可能的候选值
{
newState = *this;
newState.data_[row][col] = i+1; //
把候选值填入空格
vs.push_back(newState); //
作为下一步的可选状态
}
}
return; //
每步只处理一个空格
}
}
}
}
在nextStep()中，我们定义了一个bool数组pos[]，它用于记录空格所在的行、列、小方阵中已经有哪些数字，只有那些不重复的数字才可以填入空格。函数中调用了另一个成员函数checkValue()，它用于将pos数组中对应已有数字的bool值置为false，由于它很简短，我把它放在类的定义中。
class SudokuState
{
public:
...
private:
static void checkValue(bool* pos, int i)
{
if (i != 0)
{
pos[i-1] = false;
}
}
};
流输入和流输出函数也很简单，只需如常从流中读入或向流输出二维数组中的元素即可，如下：
ostream& operator<< (ostream& os, const SudokuState& s)
{
for (int i = 0; i < SUDOKU_DIMS; ++i)
{
for (int j = 0; j < SUDOKU_DIMS; ++j)
{
os << s.data_[i][j] << " ";
}
os << endl;
}
return os;
}
istream& operator>> (istream& is, SudokuState& s)
{
int v;
for (int i = 0; i < SUDOKU_DIMS; ++i)
{
for (int j = 0; j < SUDOKU_DIMS; ++j)
{
is >> v;
s.data_[i][j] = (v < 1 || v > SUDOKU_DIMS) ? 0 : v;
}
}
return is;
}
至此，问题状态类SudokuState的各组成部分已经全部列出。我们在其中看到有三个常量，它们的定义如下：
const int SUDOKU_ROWS = 3;
const int SUDOKU_COLS = 3;
const int SUDOKU_DIMS = SUDOKU_ROWS * SUDOKU_COLS;
数独游戏可以多种不同的大小，有2x2、3x3、4x4、5x5的，也有2x3、3x4、4x5的，所以我们用两个常量来表示数独游戏的大小，这样就可以很容易地把这个程序用于解决其它大小的数独游戏。
DFS和BFS算法需要的第二个东西是一个函数指针或函数对象，它接受一个const T1&参数，并返回一个bool值，传入的参数为搜索算法找到的一个答案状态，函数可以按自己的方法处理它（我们将打印它），然后返回一个bool值来表示是否继续搜索其它答案（我们只想找出一个答案就好了，所以返回了true）。由于我们的处理方法比较简单，我就直接使用传统的函数指针好了，如果你有兴趣用函数对象，我想也不是什么问题。
bool PrintResult(const SudokuState& r)
{
cout << "Solution : /n" << r << endl;
return true;
}
你看，由于我们的SudokuState类已经提供了流输出函数，所以打印它非常简单。如果你想找到所有答案，那么你把函数的返回值改为false好了。
DFS和BFS算法所需要的二样东西我们都准备好了，现在是时候写主函数了。如你所想，主函数也没有几行，它首先从cin读入一个数独问题，然后调用DFS或BFS来搜索答案，如果找到则给出所有答案以及答案的总数，就是这么多了：
int main()
{
SudokuState start;
cin >> start;
cout << "Problem :/n" << start << endl;
int n = DepthFirstSearch(start, &PrintResult);
//int n = BreadthFirstSearch(start, &PrintResult);
if (n == 0)
{
cout << "Solution not found!/n";
} else {
cout << n << " solution(s) found!/n";
}
return 0;
}
你可以看到，我们可以选择使用DFS还是BFS，它们都可以找到正确的答案。同时，由于我们的结果处理函数PrintResult返回了true，它表示找到一个答案就停止搜索，你会发现对于多数数独问题，通常DFS会比BFS快一些。这只能说明对于数独这个具体问题，DFS的平均效率比BFS更好些。
如果你把PrintResult改为返回false，它表示要求找出所有答案，即需要完成整棵问题状态树的搜索，这样的话无论是DFS还是BFS，它们的搜索量是一样，所以它们的速度就会不相上下。
前面也说过，这是我第一次尝试这个DFS/BFS算法，为简单起见，我采用了最简单的解法而暂不考虑效率。下一次，我将尝试改进一下数独问题解法的效率。注意，不是DFS/BFS搜索算法的效率，由于它们是针对通用问题的，我认为可以改进的地方已不多。我要改进的是SudokuState::nextStep()成员函数中的效率，如果可以让它更智能地返回最佳的下一步状态，也即让状态树中的下一层结点分支最少，就应该可以有效地改善算法的效率。