2017BUAA软工个人项目之数独

1.项目GitHub地址：https://github.com/ZiJiaW/Soduko

（由于一开始把sudoku看成了soduko，于是名字建错了，读起来可能有点奇怪…）

2.项目PSP表格如下：

3.解题思路

3.1 任务需求

编写命令行程序(sudoku.exe)，支持下列指令：1. sudoku.exe –c N  2. sudoku.exe  -s absolute_path_of_puzzlefile；

指令1实现程序生成不重复的N个数独终局至同目录下文件sudoku.txt，数独矩阵的左上角数字为确定的(9+6)%9+1=7；指令2将绝对路径下的数独题目解出并生成答案于同目录下的sudoku.txt。

3.2 思路分析

直觉告诉我解数独比较简单，所以我先想的是怎么解数独。查了下资料发现主要就两种方法，最简单的就是递归回溯，另外一种就是Dancing Links算法，将数独转化成精确覆盖问题求解，其实也是需要回溯的，但是使用的数据结构比较方便。因为我先想的也是递归填数，而且比较简单，所以就选择第一种方法了。思路很简单，将读取到的数独题目保存在9*9的二维数组中：

1. 从第一个格子开始填数，如果该格子已经填过，那么处理下一个格子；
2. 如果当前格子是空的，尝试从1-9中选择数字填入，并判断是否符合数独规则，符合则填入；
3. 若最终没有找到合适的数填入，说明在之前填的某一个数字不对，进行回溯。
4. 若填的是最后一个格子且满足规则，说明找到了数独的一个解，程序结束。

解决了解数独的问题，再来看怎么生成数独，其实从上面的角度很容易就想到，把初始的数独矩阵全部置零，按照解数独的方法即可生成数独了，只不过需要生成的数独数量较多，相当于求全零数独的前N个解，那么只要将解数独的算法步骤稍作修改，当生成的解是第N个，输出该解让程序结束，当生成的解不足N个时，输出该解并回溯，这样就能够保证已经生成的解不会二次生成，因为回溯后必然改变之前的某个值。至于左上角规则，只需要在预先放置好需要的数字，然后从第二个格子开始处理即可。

4.实现过程

分析需求，我设计了以下函数和类：

4.1输入

vector<int(*)[9]> SodukoInput(char * filename);

读取文件中的数独题目，每一个题目为一个2维矩阵，返回各题目矩阵指针的vector；

4.2输出

void SudokuOutput(char *ret, int maxnum, char *ret2);

将得到的保存所有数独解的数组设置格式（空格和回车），然后返回之，使用fputs输出。

4.3数独求解模块

class SudokuSolve {
public:
    bool Solve(int r, int l);//递归填数
    bool check(int r, int l, int num);//测试同行同宫同列是否已有num
    void ProblemInit(int p[9][9]);//初始化
    int(*getSolution())[9];//返回解
private:
    int problem[9][9];
};

每一个需要求解的数独初始化一个类，Solve函数即为对problem[r][l]的处理试填，check函数判断在problem[r][l]处填入num是否符合规则，getSolution用于在解决数独后返回填完的problem的指针，用于输出。

4.3数独生成模块

class SudokuMaker {
public:
    bool fill(int r, int l, char *ret);//递归填数
    bool check(int r, int l, int num);//判断在[r,l]处放入num是否符合数独规则
    void RequestInit(int n);//初始化需求
private:
    int maxnum;//需要生成的数独终局数
    int count;//当前已生成的数独终局数
    int M[9][9];//维护的数独棋盘
};

5.关键代码说明

下面给出数独求解的Solve函数进行说明：

bool SudokuSolve::Solve(int r, int l)
{
    int nr = l == 8 ? r + 1 : r;
    int nl = l == 8 ? 0 : l + 1;
    if (problem[r][l] != 0 && nr < 9)//(r, l) already has a number
    {
        if (SudokuSolve::Solve(nr, nl))
            return true;
        else
            return false;
    }
    else if (problem[r][l] != 0 && nr >= 9)//problem solved
        return true;
    // now problem[i][j] == 0, try to fill it.
    for (int k = 1; k < 10; ++k)
    {
        if (!SudokuSolve::check(r, l, k))
            continue;
        problem[r][l] = k;
        if (r == 8 && l == 8)//problem solved
            return true;
        if (SudokuSolve::Solve(nr, nl))
            return true;
        else
            problem[r][l] = 0;//k is bad, try k+1.
    }
    return false;//can‘t find a k.
}

实际调用的时候，首先初始化数独题目，即函数中的problem，而后调用Solve(0,0)即可将problem解出；上面的函数首先计算当前处理位置的下一位置，若当前位置已经有值，则直接处理下一个，若恰好在最后一个位置有值，则说明此时数独已经解好了，可以结束递归；在当前位置为空时，我们就要尝试填数，对每一个判断是否符合规则，找到一个合适的值后，若填的是最后一个位置，同样说明数独解决；否则填值后处理下一个位置，若下一个位置的处理失败，说明当前位置的填值不合适，尝试下一个数；在尝试所有数后，若没有合适的，说明之前位置填值有误，需要恢复当前位置的空状态并回溯。注意恢复problem[r][l]=0是必要的，否则回溯到上一个位置时会对check函数（判断同行同列同宫是否存在k）的结果有影响，导致少解。

对这个函数的单元测试函数如下：

TEST_METHOD(TestMethod1)
        {
            int p[9][9] = { {8,0,0,0,0,0,0,0,0},{0,0,3,6,0,0,0,0,0},{0,7,0,0,9,0,2,0,0},
            {0,5,0,0,0,7,0,0,0},{0,0,0,0,4,5,7,0,0},{0,0,0,1,0,0,0,3,0},
            {0,0,1,0,0,0,0,6,8},{0,0,8,5,0,0,0,1,0},{0,9,0,0,0,0,4,0,0} };
            SudokuSolve s;
            s.ProblemInit(p);
            s.Solve(0, 0);
            int(*q)[9] = s.getSolution();
            bool r = true;
            for (int i = 0; i < 9; ++i)
            {
                for (int j = 0; j < 9; ++j)
                    r &= s.check(i, j, q[i][j]);
            }
            Assert::AreEqual(r, true);
        }

使用的数独题目为号称最难的芬兰题，在实际运行中使用clock计时得到求解时间为245ms，测试中给出数独的解并测试其是否合法，测试结果如下：

相似的思路处理生成数独的问题，给出SudokuMaker::fill函数如下：

bool SudokuMaker::fill(int r, int l, char *ret)
{
    int nr = l == 8 ? r + 1 : r;
    int nl = l == 8 ? 0 : l + 1;
    for (int k = 1; k < 10; ++k)
    {
        if (!SudokuMaker::check(r, l, k))
            continue;
        M[r][l] = k;
        if (r == 8 && l == 8)//到达最后一个位置
        {
            count++;
            if (count == maxnum)//若已生成要求数目的数独终局，则输出终局并结束递归
            {
                for (int i = 0; i < 9; ++i)
                {
                    for (int j = 0; j < 9; ++j)
                    {
                        ret[9 * i + j + 81 * (count-1)] = char(M[i][j] + ‘0‘);
                    }
                }
                return true;
            }
            else
            {
                //生成数目不够，则输出并恢复[r,l]处的值，并试填下一个
                for (int i = 0; i < 9; ++i)
                {
                    for (int j = 0; j < 9; ++j)
                    {
                        ret[9 * i + j + 81 * (count-1)] = char(M[i][j] + ‘0‘);
                    }
                }
                M[r][l] = 0;
                continue;
            }
        }
        else
        {
            if (SudokuMaker::fill(nr, nl, ret))//递归求解下一个位置
                return true;
            else
            {
                M[r][l] = 0;
                continue;
            }
        }
    }
    return false;
}

可以看到两个函数布局差不多，实际上和之前分析的一样，初始化数组M的左上角，从位置(0,1)开始求解，两者的区别在于前者只要得到一个可行解就可以输出结束递归，而后者需要生成maxnum个数独终局，因此在生成足够数目的数独前，函数一律在输出后继续尝试，尝试所有的值后回溯。下面给出代码覆盖率测试结果，分两块，一块是生成数独，一块是解数独：

因为一次只能设置一个命令行参数，所以都不是100%，但是可以看到两个模块分别都是覆盖率很高的。

6.性能分析和改进

由于选择的是暴力回溯，瓶颈在那里，所以数独生成的速度肯定不会很快…但是按照以上的思路编译通过后第一次性能分析，我选择的是生成1000个数独终局，运行时间达到了惊人的38秒，我瞬间有了跳崖的冲动。仔细查看性能分析结果，我发现程序98%以上的时间在做文件IO（最初版本性能测试没有截图），于是我仔细查看了我的IO函数，实际上我的IO是在每生成一个数组的时候进行输出，由于写的比较快，就直接在函数内进行文件的打开和关闭了，所以输出1000个数独需要开闭文件1000次，我将文件流传入函数，在外面开闭文件，速度就上去了。此时100000个数独需要1分钟左右，仍然很慢，下面是这时的输出函数。

void SudokuOutput(int p[9][9], bool flag, fstream &file)
{
    if (!file.is_open())
        cerr << "fail to open file!" << endl;
    else
    {
        for (int i = 0; i < 9; ++i)
        {
            for (int j = 0; j < 9; ++j)
            {
                if (j == 8)
                    file << p[i][j] << endl;
                else
                    file << p[i][j] << ‘ ‘;
            }
        }
        if (flag)
            file << endl;
    }
}

再次进行性能分析，发现程序运行时间依然是文件IO占了大头，这是突然想到这里是直接将数字以整型输出到文件，如果我把它改成字符输出呢？当即把p[i][j]改成char(p[i][j]+’0’),发现输出快了十几秒。继续分析发现操作符<<和endl的耗时很长，查阅资料，这里endl的flush作用是不需要的，所以将endl改成file.put(‘\n’),前者同理，到这里再运行，100000级的时间是14秒。但是还是很慢。由于我选择的算法十分的暴力，所以我预期百万级的测试在1分钟内完成，十万级就耗时14秒是不行的。机缘巧合之下又看到了这篇文章，于是试用了freopen重定向和putchar的组合，运行时间优化到9秒，确实有效果。这时又看到微信群里罗老师建议保存答案到最后一起输出，于是我尝试建了一个全局字符数组，将所有终局都存进去，在最后的时候直接用fputs全部输出，这时运行100000级输出运行时间为：5.121s，百万级为：49.553s（用clock计时）。满足预期了……到这里Output函数已经面目全非，被我改成给输出的数组添加空格和回车的函数了，就不贴了，但是之前贴的关键函数都是最终版。下面是性能分析结果（-c 100000）：

可以看到在优化IO后，IO占的时间很少了，现在最耗时的在于每次试填都要使用的check函数，用于判断同行同宫同列是否符合需求，我尝试过维护专门的数组来记录每行每列每宫已填数的信息，这样check函数就只需要查询这些数组了，但是实际测试下来和最简单的直接遍历行列宫相差无几，因为维护这些数组同样需要时间成本，所以最终按照原方案。

7.PSP各模块实际花费时间（略，见1）

8.感想

俗话说得好，不作死就不会死，暴力回溯生成数独终局确实是挺慢的，比不上各种取巧的方法，但是用来解数独我倒觉得是最实用也是最简单的方法，因为解数独是无法避免回溯和试填的。在写这个程序之前，说实话我没怎么用C++写过程序，计院的面向对象也还没上过，撑死了用C++解过几十道LeetCode，只能说略懂C++的语法而已，可以说是相当的菜了。前面写的优化其实只是对IO作了优化，对大佬们来说可以说是相当trivial了，但是对我来说，之前确实没有过处理这么多数据的情况，所以其实收获还是蛮大的，因为很多东西都是第一次用，包括VS和GitHub。最后，图简单暴力解题我觉得我大概要倒数了吧……