Github项目地址：https://github.com/MokouTyan/suduku_131700101
【2019.09.20】更新：代码经过Code Quality Analysis工具的分析并消除所有的警告。
【2019.09.21】更新：使用性能分析工具Studio Profiling Tools来找出代码中的性能瓶颈。
尚未完成内容：
PSP表格
| Personal Software Process Stages | 预估耗时 | 实际耗时 | |
|---|---|---|---|
| Planning | 计划 | 1小时 | 5分钟 |
| Estimate | 这个任务需要多少时间 | 26小时 | |
| Development | 开发 | 5小时 | 4小时 |
| Analysis | 需求分析 (包括学习新技术) | 2小时 | 1小时 |
| Design Spec | 生成设计文档 | 2小时 | 1小时 |
| Design Review | 设计复审 | 2小时 | 1小时 |
| Coding Standard | 代码规范 | 30分钟 | 1小时 |
| Design | 具体设计 | 30分钟 | 30分钟 |
| Coding | 具体编码 | 5小时 | 2小时 |
| Code Review | 代码复审 | 2小时 | 4小时 |
| Test | 测试（自我测试，修改代码，提交修改） | 1小时 | 3小时 |
| Reporting | 报告 | 1小时 | |
| Test Repor | 测试报告 | 1小时 | |
| Size Measurement | 计算工作量 | 1小时 | |
| Postmortem | 事后总结, 并提出过程改进计划 | 1小时 | |
| Improvement Plan | 过程改进计划 | 1小时 | |
| 合计 | 26小时 |
视频介绍所用思路
最近因为有自己的视频在做，所以有点忙不过来，这次的视频也是花了两小时赶出来的，以后如果太忙了可能不会做视频啦见谅（咕咕咕）
因为这个方法是自己想的，我没有依据可以证明“唯一的解必须由唯一的可能性推导而出”，所以我也不知道对不对
（我的舍友是认为，即使所有的格子有一个以上的可能性数量，也可以推出唯一的解来）
视频里是我的思路，如果看不清表盘填的数字可以在视频右下角切换清晰度
不论是inside函数还是outside函数，他们的执行顺序都是横纵宫
（其实这三个顺序无所谓的，但是三个都要去执行）
黄色是传入函数的位置，而绿色是所要检测的格子
源代码解释
全局变量介绍：
//记录棋盘上的标记点
//前两个[10][10]是棋盘上的具体位置
//第三个[10]是记录当前位置数字的可能性
bool sign[10][10][10];
//记录标记点的可能性剩余个数
int sign_count[10][10];
//记录棋盘上的具体数字
int checkerboard[10][10];
//记录类型，区分三...九宫格
int type; 初始化表盘：
在CMD中输入type和棋盘个数后进入循环
在开始处理数据前先进行表盘重置化
每个位置的可能性初期都为9个（根据输入type大小而定）
表盘上所有数字为0（代表空）
sign第三个[]内的0号位都为False，其意义是还未填入数字
每个位置上的第一格到第九格可能性都存在（标为True）
void reset()
{
for ( int i=1 ; i<type+1 ; i++ )
{
for ( int j=1 ; j<type+1 ; j++ )
{
//假设每个位置都有type种可能
sign_count[i][j]=type;
//每个位置都是空
checkerboard[i][j]=0;
//每个位置未曾填写
sign[i][j][0]=false;
//假设每个位置的type种可能都是可实现的
for ( int k=1 ; k<type+1 ; k++ )
{
sign[i][j][k]=true;
}
}
}
return;
}inside函数解释：
我用的第一个函数，我称为inside函数
从头到尾遍历，向函数传递格子的位置
它会检测当前位置横、纵、九宫格有没有数字的格子
如果有数字存在并且该数字可能性还未去掉
便把该格子上的相同数字的可能性去掉，同时可能性数量－1
如果当可能性等于1时，立即写入数字
//查出所有空缺的可能性（位置上还没有数字）
//此时是扣除所在位置的可能性
int inside(int x, int y)
{
//排除横向可能性
int remove;
for( int i=1 ; i<type+1 ; i++ )
{
//如果检测位置存在数
if ( sign[x][i][0] )
{
remove=checkerboard[x][i];
//则这个空位不能出现相同数字
//防止sign_count被误减去，前面先判断是不是已经变否了，未变否才变否
if ( sign[x][y][remove] )
{
sign[x][y][remove]= false;
//可能性-1
sign_count[x][y]--;
}
if ( sign_count[x][y] == 1 && !sign[x][y][0] )
{
//如果该位置只剩下一种可能性，那么立即执行write()
write(x,y);
return 0;
}
}
}
//排除纵向可能性
for ( int i=1 ; i<type+1 ; i++ )
{
if ( sign[i][y][0] )
{
remove=checkerboard[i][y];
if (sign[x][y][remove] )
{
sign[x][y][remove]= false;
sign_count[x][y]--;
}
if ( sign_count[x][y] == 1 && !sign[x][y][0])
{
//如果该位置只剩下一种可能性，那么立即执行write()
write(x,y);
return 0;
}
}
}
//宫格判断
if ( type==4 || type==6 || type==8 || type==9 )
{
int beginx, beginy;
int xplus,yplus;
switch ( type )
{
case 4:
xplus=2;
yplus=2;
break;
case 6:
xplus=2;
yplus=3;
break;
case 8:
xplus=4;
yplus=2;
break;
case 9:
xplus=3;
yplus=3;
break;
}
beginx=((x-1)/xplus)*xplus+1;
beginy=((y-1)/yplus)*yplus+1;
for ( int i=beginx ; i<beginx+xplus ; i++ )
{
for ( int j=beginy ; j<beginy+yplus ; j++ )
{
if ( sign[i][j][0] )
{
if ( sign[x][y][ (checkerboard[i][j]) ])
{
sign[x][y][ (checkerboard[i][j]) ] = false;
sign_count[x][y]--;
}
if ( sign_count[x][y] == 1 && !sign[x][y][0])
{
//如果该位置只剩下一种可能性，那么立即执行write()
write(x,y);
return 0;
}
}
}
}
}
return 0;
}write函数：
写入数字的时候会把位置上的标记改为存在数字（该位置sign第三个的[0]＝True）
可能性数量变为0（该位置的sign_count=0;）
防止被二次修改
//填入确定值
int write(int x,int y)
{
//这个位置标记为存在数字
sign[x][y][0]=true;
sign_count[x][y]=0;
//填入数字
for ( int i=1 ; i<type+1 ; i++ )
{
if ( sign[x][y][i] )
{
checkerboard[x][y]=i;
break;
}
}
/*//输出改变的位置和新棋盘
cout<<x<<' '<<y<<'\n';
for ( int i=1 ; i<type+1 ; i++ )
{
for ( int j=1 ; j<type+1 ; j++ )
{
cout<<checkerboard[i][j]<<' ';
}
cout<<'\n';
}
//输出每个位置剩余的可能性数量
cout<<'\n'<<"可能性：\n";
for ( int i=1 ; i<type+1 ; i++ )
{
for ( int j=1 ; j<type+1 ; j++ )
{
cout<<sign_count[i][j]<<' ';
}
cout<<'\n';
}
cout<<'\n';*/
outside(x,y);
return 0;
} 在写入数字的函数结束前
此时调用第二个函数，我称为outside函数
进行横纵宫的外部检查，将这个数字影响扩出去，当这个格子的“横纵宫”检查完成后等于说就成为一张新的表盘了
outside函数：
传入所写数字的位置
将它的横纵九宫格上所有格子上的相同数字的可能性去掉
当其他位置可能性数量为1的时候
再次立即调动write函数
//去除所填位置的横纵九宫格所有同数可能性（位置上刚填入数字）
//此时是扣除所填位置的横纵九宫格的其他位置可能性
int outside(int x,int y)
{
//remove是当前位置填入的数字
int remove=checkerboard[x][y];
for( int i=1 ; i<type+1 ; i++ )
{
if ( !sign[x][i][0] && sign[x][i][remove] )
{
sign[x][i][remove] = false;
sign_count[x][i]--;
if ( sign_count[x][i]==1 && !sign[x][i][0])
{
write(x,i);
}
}
}
for ( int i=1 ; i<type+1 ; i++ )
{
if ( !sign[i][y][0] && sign[i][y][remove] )
{
sign[i][y][remove] = false;
sign_count[i][y]--;
if ( sign_count[i][y]==1 && !sign[i][y][0])
{
write(i,y);
}
}
}
//宫格判断
if ( type==4 || type==6 || type==8 || type==9 )
{
int beginx, beginy;
int xplus,yplus;
switch ( type )
{
case 4:
xplus=2;
yplus=2;
break;
case 6:
xplus=2;
yplus=3;
break;
case 8:
xplus=4;
yplus=2;
break;
case 9:
xplus=3;
yplus=3;
break;
}
beginx=((x-1)/xplus)*xplus+1;
beginy=((y-1)/yplus)*yplus+1;
for ( int i=beginx ; i<beginx+xplus ; i++ )
{
for ( int j=beginy ; j<beginy+yplus ; j++ )
{
if ( !sign[i][j][0] && sign[i][j][remove] )
{
sign[i][j][remove] = false;
sign_count[i][j]--;
if ( sign_count[i][j]==1 && !sign[i][j][0])
{
write(i,j);
}
}
}
}
}
return 0;
}经常会出现这样的情况，(write)填入第一个数字→(第一个outside)检查第一个数字的横向，刚好找到可能性数量为1的存在→(write)填入第二个数字→(第二个outside)检查第二个数字的横纵宫，减去外部的可能性，没有出现可能性数量刚好为1的点（此时return回调用自己write，再return回上一个outside）→(第一个outside)重新返回第一个数字的函数内，继续检查完第一个数字的横纵宫
（也正是因为这样所以write里面要对填入的格子进行锁死，防止第一个outside会遍历 第二个及其以后的outside 会再次填入）
write和outside就这样子互相嵌套调用，每当outside函数彻底完成后（即直到当前的outside是由 inside调用的write所调用的）是相当于生成一个新的表盘
主函数：
int main(int argc, char *argv[])
{
int n;
FILE* fp1;
FILE* fp2;
type = atoi(argv[2]);
n = atoi(argv[4]);
//cin >> type >> n;
//cout << type << n;
//以只读方式打开文件
fp1 = fopen("input.txt", "r");
if (fp1 == NULL) //
return -1;
//打开output.txt，并立即关闭，意义为清空文本内容
fp2 = fopen("output.txt", "w");
if (fp2 == NULL) //
return -1;
fclose(fp2);
while (n > 0)
{
//重置棋盘
reset();
//输入棋盘
for (int i = 1; i < type + 1; i++)
{
for (int j = 1; j < type + 1; j++)
{
fscanf(fp1, "%d", &checkerboard[i][j]);
if (checkerboard[i][j] != 0)
{
sign[i][j][0] = true;
sign_count[i][j] = 0;
}
}
}
//关闭input文件
//以只写方式打开文件
fp2 = fopen("output.txt", "a");
if (fp2 == NULL)
return -1;
//找出空缺位置
for (int k = 0; k < 2; k++)
{
for (int i = 1; i < type + 1; i++)
{
for (int j = 1; j < type + 1; j++)
{
if (!sign[i][j][0])
{
inside(i, j);
}
}
}
}
bool sign_complete = true;
for (int i = 1; i < type + 1; i++)
{
for (int j = 1; j < type + 1; j++)
{
fprintf(fp2, "%d", checkerboard[i][j]);
if (checkerboard[i][j] == 0)
{
sign_complete = false;
}
if (j != type)
{
fprintf(fp2, " ");
}
//cout << checkerboard[i][j] << ' ';//
}
if( n != 1 && i==type && sign_complete){ fprintf(fp2, "\n\n"); }
else if (n != 1 && i == type && !sign_complete) { fprintf(fp2, "\n这道题有多个解存在，无法再填入任何一格，因此棋盘中有空位\n\n"); }
else if ( n == 1 && i == type && sign_complete){}
else if (n == 1 && i == type && !sign_complete) { fprintf(fp2, "\n这道题有多个解存在，无法再填入任何一格，因此棋盘中有空位"); }
else { fprintf(fp2, "\n"); }
//cout << '\n';//
}
//cout << '\n';//
//fprintf(fp2, "\n");
n--;
fclose(fp2);
}
fclose(fp1);
}总结：
这个解决方案只能解决唯一解的数独问题
面对多个解的数独棋盘，这个方法可能解不完整，会有空缺位置
代码调试阶段
Code Quality Analysis检查结果：
测试样例结果：
得到的答案是能百分百确定的格子里的数字，有空的话再去写得出多个解的程序吧~
上面那第一道无法解出来的六宫格题目是有3个解的（手算）
五宫格、七宫格、八宫格找不到题目可以试一下ovo
性能分析工具Studio Profiling Tools分析结果
都很平均，不知道要怎么改进了，有点尴尬
