个人项目作业

1.github项目地址

https://github.com/easylliu/gitlearning/tree/master/Sudoku

2.开发时间

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	30	50
Estimate	估计这个任务需要多少时间	10	15
Development	开发
Analysis	需求分析 (包括学习新技术)	120	180
Design Spec	生成设计文档	无	无
Design Review	设计复审 (和同事审核设计文档)	无	无
Coding Standard	代码规范 (为目前的开发制定合适的规范)	无	30
Design	具体设计	30	60
Coding	具体编码	120	240
Code Review	代码复审	60	120
Test	测试（自我测试，修改代码，提交修改）	120	180
Reporting	报告
Test Report	测试报告	30	50
Size Measurement	计算工作量	10	20
Postmortem & Process Improvement Plan	事后总结, 并提出过程改进计划	30	30
	合计	560	975

3.解题思路描述

（1）.数独终局生成

开始在看到题目时想到的是通过初始点一直往后延伸推导，后来想了一会感觉有点复杂；在思考无果后通过上网查找资料了解到生成终局的两种方法
随机法,矩阵转换法;但相比之下感觉矩阵转换法更加直接，随机法不确定性加大了难度；而由于第一个数已经确定为9，因此第一行第一列不能参与变换，这样通过一个数独变换能产生共计5184种；但我们的要求最多有1000000种，因此想产生200个种子数独，从8个数中取出四位，共有70种取法，而每种取法又对应三种数字交换方式共计210种符合要求，这样产生的数独数就已经超过1000000种符合要求了。

（2）.求解数独

在求解数独上，开始自己思考是想通过那些已确定的那些数字出发，沿着他们所在行列块进行推导，但随后感觉有点困难；通过网上查找感觉方法差不多，相对较为直接的就是回溯法求解了，从最开始点一直递归遍历找到所有存在的可能性，在通过行列和3*3块的验证来确定是否符合条件，简单粗暴，在实现上较为简单，初始计划打算就使用了这种方法。

4.设计实现过程

(1).数独终局生成

根据思路想到，首先产生的一个种子出发，首先通过其行列变换最多产生5184个数独，如果还不足的话从那70种取法中随机选出先交换数字产生新的种子数独，然后再行列变换，如此种种，在一定程度上还可以保证随机性，直到产生够所要的数独数即可结束。通过这种思路构建函数也就清晰起来，在数独产生的函数中通过种子数独不断调用矩阵变换函数，然后可将矩阵变换函数拆解成行变换函数和列变换函数，如此这样，函数之间的联系清晰明朗，实现起来目标也很明确。总得来说在这一部分产生4个函数，其直接的关系也是层层调用。通过这样的分析对函数的作用了解也清晰许多，通过他们直接的联系和他们的用途设计单元测试就比较轻松了。

(2).求解数独

通过暴力解法，对从0到81的所有空白进行1到9的选择，然后判断适合符合行列和块的要求，然后递归往下延伸，当后面推不出来递归返回继续延伸推导，直到求解出正确的结果结束。
相对来说这种接法也相对较为直接，从0到81，先填入数字，在判断是否符合行列和块的要求，然后递归向后延伸。如此这样分析，相对复杂点的就是递归的使用，想都来说3个函数足以。主函数调用填空递归函数，递归函数在填入数字后调用检查函数判断是否符合行列块的要求，如此实现。然后相对来说，对递归的单元测试也相对有些麻烦，通过从对函数功能的理解出发，结合和其他函数的联系设计单元测试会更加全面。

5.性能改进

改进：由于产生数独和求解数独的最大值已到达1000000，在输出到文件和读取时的效率问题就显得尤为重要了，因此在这方面花费时间能减就减，因此我就从每次写入到文件的数量上做出了改进，再往文件里写入数独时，我改进到每次写入两百个数独，这样减少写入的次数，提高效率。
由图片中可以看到，调用次数最多的为检查行列块的合理性函数，这也是暴力求解产生的负面效果，其次在面对文件操作时话费的时间较多，仍待改善。

6.代码说明

主要分做两个部分，一个是产生终局数独，一个是求解数独。
这四个为生成终局数独的四个关键函数：
主要就是sudo_create产生种数独通过调用矩阵变换得到扩展的数独，矩阵变换由行变换和列变换组成；

    void sudo_create(int sudo_count, char sudo[9][10], char changenum_array[70][5]);		//生成数独
    int matrix_change(int count, int sudo_count, char sudo[9][10], char output[1000000]);	//矩阵变换
    void line_range(int init, int n, char mid_sudo[9][10], char sudo[9][10]);				//行交换
    void column_range(int init, int n, char mid_sudo[9][10], char sudo[9][10]);				//列变换

其中最为关键一个:产生种子，调用扩展

void sudo_create(int sudo_count, char sudo[9][10], char changenum_array[70][5]) {
	int index_changenum[70] = { 0 };	//是否随机到标识符	
	char sudo_middle[9][10];				//中间种子数独
	int randnum = 0, i, j;
	int count = 0;							//已生成的数独数
	char a, b, c, d;
	for (i = 0; i<9; i++) {									//初始化
		strcpy_s(sudo_middle[i], sudo[i]);
	}
	count = matrix_change(count, sudo_count, sudo_middle, output);	//根据一个种子转换输出
	while (count < sudo_count) {
		if (count == -1) break;
		randnum = rand() % 70 + 0;
		if (index_changenum[randnum] == 0) {				//未随机到
			a = changenum_array[randnum][0];
			b = changenum_array[randnum][1];
			c = changenum_array[randnum][2];
			d = changenum_array[randnum][3];
			for (i = 0; i < 9; i++) {
				for (j = 0; j < 9; j++) {
					if (sudo[i][j] == a) {
						sudo_middle[i][j] = b;
					}
					else if (sudo[i][j] == b) {
						sudo_middle[i][j] = a;
					}
					else if (sudo[i][j] == c) {
						sudo_middle[i][j] = d;
					}
					else if (sudo[i][j] == d) {
						sudo_middle[i][j] = c;
					}
					else
						sudo_middle[i][j] = sudo[i][j];
				}
			}
			count = matrix_change(count, sudo_count, sudo_middle, output);
			if (count == -1) break;

			for (i = 0; i < 9; i++) {
				for (j = 0; j < 9; j++) {
					if (sudo[i][j] == a) {
						sudo_middle[i][j] = c;
					}
					else if (sudo[i][j] == b) {
						sudo_middle[i][j] = d;
					}
					else if (sudo[i][j] == c) {
						sudo_middle[i][j] = a;
					}
					else if (sudo[i][j] == d) {
						sudo_middle[i][j] = b;
					}
					else
						sudo_middle[i][j] = sudo[i][j];
				}
			}
			count = matrix_change(count, sudo_count, sudo_middle, output);
			if (count == -1) break;
			for (i = 0; i < 9; i++) {
				for (j = 0; j < 9; j++) {
					if (sudo[i][j] == a) {
						sudo_middle[i][j] = d;
					}
					else if (sudo[i][j] == b) {
						sudo_middle[i][j] = c;
					}
					else if (sudo[i][j] == c) {
						sudo_middle[i][j] = b;
					}
					else if (sudo[i][j] == d) {
						sudo_middle[i][j] = a;
					}
					else
						sudo_middle[i][j] = sudo[i][j];
				}
			}
			count = matrix_change(count, sudo_count, sudo_middle, output);
			if (count == -1) break;
		}
	}
	//cout << output;
}

这三个为求解数独的主要函数：
主要就是solve_sudo函数调用填空进行递归，填入一个数后就判断其合理性

int solve_sudo(char output[], int count);//求解数独
bool solve_blank(int sudo_num);//填空
bool matrix_judge(int line, int column, int choose);//判断合理性

关键一个函数：递归调用，逐步展开

//填数
bool solve_blank(int sudo_num) {
	int line, column, i;
	line = sudo_num / 9;
	column = sudo_num % 9;
	if (sudo_num >= 81)
		return true;
	if (sudo1[line][column] == 0) {
		for (i = 1; i <= 9; i++) {
			sudo1[line][column] = i;
			if (matrix_judge(line, column, i)) {
				if (solve_blank(sudo_num + 1)) return true;
			}
			sudo1[line][column] = 0;
		}
	}
	else {
		return solve_blank(sudo_num + 1);
	}
	return false;
}