个人作业数独

Github地址

https://github.com/Donemeb/SudukuProject
ps:名字好像起错了> <

PSP2.1 估计&实际


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

有很大一部分时间花在调bug上了（捂脸）。一开始没有仔细记录好各个参数的具体含义和范围，过一段时间修改时凭记忆去改那些参数，超容易产生各种小bug。

需求分析

命令行形式
9*9 数独生成，首位为特定数字
9-9 数独求解

设计思路

先说说等价数独。一个数独终局通过各类变换可以生成超大量的等价数独。但是，由于题目中提到了不重复原则，假使要求生成的数独数量大于一个等价数独组，那么查重部分就会消耗大量的时间，反而得不偿失。也没有找到一个能识别不同等价数独的特征。便放弃了这个想法。

不考虑等价数独，数独的生成和求解，在本质上都可归为求解数独的过程，只不过生成相对于全0的数独求解，且不会因得出一个解答停止。

第一个想到的方法，大约也是最简单粗暴的方法，就是无脑递归遍历，输出可行解。通过每次检查插入是否可行来决定往下一层or继续尝试，但同时想到，检查插入的可行性本身是一个极占运行比重的部分，即使可以一次计算出一个递归过程中的所有可填入值，单纯通过数独局来遍历仍会占去大量运行时间。于是开始考虑如何存储每次递归过程冲突信息，以快速检查插入的可行性。

由于也是一个回溯算法，加之判断冲突，便联想到了N皇后问题。在查找资料的过程中，这篇博客给了我很大启发。通过划分冲突种类，以0|1方式表示冲突与否，很大程度上减少了建立、回溯冲突表本身，以及冲突表使用所花费的时间。同时这个方法特别适合在一次填完一个数字的回溯方法中使用。这也就是我之后程序的基本思路。

最终的设计思路：一次填完一个数字，每个数字按第一行往第九行的顺序填入，冲突表有三个：列冲突表[每个数字]，九宫格冲突表[每个数字]，整体的数独冲突表

具体实现

建立一个suduku类，提供生成、解数独方法。

sudu_generation 生成的入口方法
- sudu_gene_init 初始化开局（决定回溯顺序、确定首位为5）
- sudu_gene_loop 递归函数
  - sudu_insert_0 冲突表插入
  - sudu_delete_0 冲突表回退
sudu_solve 解答的入口方法
- sudu_solve_new
- sudu_solve_init初始化开局
- sudu_solve_loop 递归函数
  - sudu_insert_0 冲突表插入
  - sudu_delete_0 冲突表回退
sudu_to_file 数独写入文件

单元测试
有很多是private方法，难以从外部调用。测试函数采用调用入口函数，检查数独终局的正确性的方式来进行测试。另有命令行输入的数字的合法性的检测。

代码优化

生成部分的代码写完后，迫不及待的试了一试——1s、10s、100s...当我终于忍不下去了强制结束程序时，不过输出了20w个数独。问题很快就发现了：文件IO。当时采用的是一个数字一个数字输出到文件的方式，极其拖慢性能。之后我为其申请了一个输出到文件的buf，每次调用sudu_to_file时先将输出暂存在buf中，等buf快满了，一次性输出到文件。在程序结束前再调一次sudu_to_file_flush来将还在buf中的数据输出到文件。

接下来做了一些小优化。删去了代码中的一些多余的计算等。

代码性能图
数独生成

数独求解

可以发现函数消耗的比例很相似，因为解答时基本使用的是同一个算法。

100w生成测试
在我的电脑上，release版本，生成100w数独的时间在6s上下。
消耗最大的函数
即回溯过程

	void sudu_gene_loop(int order, int & now_num, int target_num) {
		int canset = 0;
		int depth = order % 9;
		int order_num = order / 9;
		int num = rand_num_order[order_num];//ATTENTION 是否可以直接除
		int i;
		if (order == 0) {
			sudu[0] = num + 1;
			gene_row[num] = gene_row[num] | 0400;
			gene_hasput[depth] = gene_hasput[depth] | 0400;
			gene_33[0] = 0700;
			sudu_gene_loop(order + 1, now_num, target_num);
		}
		else {
			if (now_num == target_num) return;
			canset = gene_row[num] | gene_hasput[depth] | gene_33[order_num * 9 + depth / 3];
			for (int i1 = 1; i1 < 10; i1++) {
				i = rand_posi_order[order * 9 + i1 - 1];	//change the name of i
				if (!(canset & x1[i])) {
					//放入数据表
					if (order == 80) {
						sudu[depth * 9 + i] = num + 1;
						sudu_to_file();
						sudu[depth * 9 + i] = 0;
						now_num++;
						return;
						//	sudu_out << now_num;
						//输出到文件 //ATTENTION 考虑缓存、效率 
					}
					//更新冲突表 
					sudu_insert_0(i, num, depth, order_num);

					sudu_gene_loop(order + 1, now_num, target_num);

					if (now_num == target_num) return;

					sudu_delete_0(i, num, depth, order_num);
				}
			}
		}
	}

代码覆盖率

代码说明

回溯中判断可行操作的关键代码（即冲突表的使用）：

canset = gene_row[num] | gene_hasput[depth] | gene_33[order_num * 9 + depth / 3];
	for (int i1 = 1; i1 < 10; i1++) {
		i = rand_posi_order[order * 9 + i1 - 1];	//change the name of i
		if (!(canset & x1[i])) {
			//放入数据表
			…………

冲突表的插入：
num是当前插入的数字(0-8)，i是列数，depth是行数，order_num是总回溯中的顺序(0-80)
ps:由于在一开始随机了各种顺序参数（下面的其他会说到，所以记录了回溯顺序）

	void sudu_insert_0(int i, int num, int depth, int order_num) { 
		sudu[depth * 9 + i] = num + 1;
		gene_row[num] = gene_row[num] | x1[i];
		gene_hasput[depth] = gene_hasput[depth] | x1[i];
		if (depth < 3) {
			if (i <= 2) {
				gene_33[order_num * 9 + 0] |= 0700;
			}
			else if (i <= 5) {
				gene_33[order_num * 9 + 0] |= 0070;
			}
			else if (i <= 8) {
				gene_33[order_num * 9 + 0] |= 0007;
			}
		}
		else if (depth < 6) {
			if (i <= 2) {
				gene_33[order_num * 9 + 1] |= 0700;
			}
			else if (i <= 5) {
				gene_33[order_num * 9 + 1] |= 0070;
			}
			else if (i <= 8) {
				gene_33[order_num * 9 + 1] |= 0007;
			}
		}
		else if (depth < 8) {
			if (i <= 2) {
				gene_33[order_num * 9 + 2] |= 0700;
			}
			else if (i <= 5) {
				gene_33[order_num * 9 + 2] |= 0070;
			}
			else if (i <= 8) {
				gene_33[order_num * 9 + 2] |= 0007;
			}
		}
	}

冲突表的回退：
插入的逆过程

	void sudu_delete_0(int i, int num, int depth, int order_num) {
		//ATTENTION 是否考虑回退模式？栈存储？ 而不是再计算一遍 
		sudu[depth * 9 + i] = 0;//放入数据表
								//更新冲突表 
		gene_row[num] = gene_row[num] & (~x1[i]);
		gene_hasput[depth] = gene_hasput[depth] & (~x1[i]);
		if (depth < 3) {
			if (i <= 2) {
				gene_33[order_num * 9 + 0] &= 0077;
			}
			else if (i <= 5) {
				gene_33[order_num * 9 + 0] &= 0707;
			}
			else if (i <= 8) {
				gene_33[order_num * 9 + 0] &= 0770;
			}
		}
		else if (depth < 6) {
			if (i <= 2) {
				gene_33[order_num * 9 + 1] &= 0077;
			}
			else if (i <= 5) {
				gene_33[order_num * 9 + 1] &= 0707;
			}
			else if (i <= 8) {
				gene_33[order_num * 9 + 1] &= 0770;
			}
		}

		else if (depth < 9) {
			if (i <= 2) {
				gene_33[order_num * 9 + 2] &= 0077;
			}
			else if (i <= 5) {
				gene_33[order_num * 9 + 2] &= 0707;
			}
			else if (i <= 8) {
				gene_33[order_num * 9 + 2] &= 0770;
			}
		}

		sudu[depth * 9 + i] = 0; 
	}

数独、冲突表的初始化：

	void sudu_solve_init() {
		for (int i = 0; i < 9; i++) {
			for (int j = 0; j < 9; j++) {
				if (sudu[i * 9 + j] != 0) {
					sudu_insert_0(j, sudu[i * 9 + j] - 1, i, sudu[i * 9 + j] - 1);
				}
			}
		}
	}

其他

一个无聊的功能。因为之前以为要生成随机数独，所以给写了些rand函数随机了一下回溯顺序。后来发现没必要，它也只是在开始时运行一次，并不耗什么时间，也就一直留了下来。所以每次生成数独时得到的数独基本是不一样的（同次的数独仍是由一个回溯顺序生成）
一开始时求解数独时使用了最简单的回溯法，后来改成类似生成的算法后，在测试中却发现仍是最开始的方法性能较优。暂时未找到原因。

posted @ 2017-09-26 20:57 donemeb 阅读(558) 评论(1) 编辑收藏举报

刷新页面返回顶部

donemeb

个人作业 数独