本文深入剖析了一个用于解决数独问题的代码，包括其核心算法、难点处理、全局变量的高效利用以及代码的优缺点分析。作者详细介绍了如何在VC2010环境下实现这一代码，以及它在处理复杂数独问题时的表现。通过阅读本文，读者将了解如何解决数独问题并提升自己的编程技能。
这是我闭关七天写的最早的数独代码，现在看来真是牛逼的不得了啊，要吐槽就吐哈。现在想写篇文章发期刊才想到把这篇牛逼的文章晒晒，能找到这篇文章真是高兴啊，还好当年发给了某老师看看。
/*问题描述： 数独即九宫格：根据九宫格中已经填写的数字把剩余的数字补充完，要求：每行每列有1-9这九个数字，整个大正方形（九行九列）分成九个小正方形（每小块三行三列）
一种分发。填完后要求每小块亦有1-9这九个数字。本人自认为本代码能解决所有的数独问题，但没法证明。本代码能自动检测错误设计的题目还有用户的输入错误，
并在默认输入输出窗口输出提示，对错误的种类区别对待，错误提示明晰。最后的结果即补充完后每个格子所填数据会写到一个文件里且会标明运行时间。
简单的数独和复杂的数独都解决，问题规模小，所以系统，基本上所有情况的出口都清晰，并最终反馈给用户。
接口描述： 本代码在vc2010旗舰版编译通过取得预期效果，解决了芬兰数学家设计的11级数独（另附图片）程序运行时需要用户输入数据，提示清楚简便易操作。
代码难点： 递归：表现为addv2（）即恢复函数的强大功能，这个函数是我调试过程中写出来的，是摸着石头过河摸出来的，在以后的分析过程中感觉自己写出的这
个不起眼的小代码竟有鬼斧神工之效。subtraction（）和addv2（）前一个是探索过程中把不能填的数字减去，后一个函数是探索失败后的恢复把
原来减去的又加上。subtraction（）要求不能减的不减，能减的不多减，返回值的设定是个难点，里面设计对全局变量的修改与返回是个难点
addv2（）要求能恢复的不能重复恢复，不能恢复的就不动，这里有个谁先恢复谁后恢复的问题，这是本代码的最难的地方。这两个函数就是既要发挥
计算机超前的探索能力（即运算能力不知对否）又要保护好现场恢复好现场。
全局变量的处理：
代码涉及的知识点：结构体中放数组的好处、全局变量的设定、函数重载、多维向量、break、continue、多重循环、goto语句、写文件最好用txt文件
调试中的很多细节、vc2010环境的熟悉、模块化即函数化（函数通过变量传递信息特别是全局变量，还有函数和主函数之间的交流，变量的作用域）、传值调用与传址调用
变量的声明，定义，初始化（貌似很简单，当与全局变量结合你就知道全局变量声明的信号作用真棒）
代码优缺点： 规范层次分明，注释简明易懂，保留有重要的历史遗迹（有些代码是最开始写的或过程中写的，最后没用但有价值保留了下来），细节近乎完美，可读性强
一开始就是冲着芬兰数学家设计的11级难题做的，调试时发现了大量的问题，代码自认为无法再精简。subtraction（）函数的探索方向可以任意调，在选取最初探索节点时可以人机动态结合改变搜索方向。可以电脑搜一轮输出中间结果，然后视情况改变代码搜索方向，代码还有广阔的人工技巧没有体现，还可以把牛人的方法翻译成代码可迅速提升速度
无法证明本代码对任何数独有效，数学功底弱，算法和数据结构就不好，时间复杂度也差，没经过大量测验。
数据： 以芬兰数学家设计的那道11级题为例，最快59秒解决，稳定在60秒(探索方向的选择会影响问题求解速度），如果输出中间探索过程的话要5分多钟，输出数据136M多（光输矩阵），7月4号到7月11号几乎全部精力都花在这代码上，代码前后写了10000多行最后定格2064行 */
#include<iostream>
#include<fstream>
#include<vector>
#include<time.h>
using namespace std;
struct{
int semaphore[11];//semaphore[10]表示存储值，semaphore[11]表示能否调用subtraction或subtraction
int probable;
int semaphore_explore_recover[10];
int probable_explore_recover;
int explore[10];//每个节点node都可能被用来作为探索节点，探索时从该节点可能取值的数字（1--9）从小到大依次探索，当一个节点所有取值探索过后都出现错误（即该节点不能去任何值）这表明这个探索节点不能取任何值是上一步的错误造成的，应该回溯进一步往前恢复。而要判断该探索节点任何值都不能取就必须设一个长度为9的数组，如果数组的每个元素都为0表示每个取值探索过后都不成功，即需要进一步往前回溯。
} node[10][10];
int finished=0;
ofstream out_stream;
vector<int> v1;
vector<vector<int>> v2,success;
vector<vector<vector<int>>> v3;
typedef struct {
int row;
int col;
int probable;
} sign;
sign min_probable_node={{0},{0},{10}};
void fills_up()
{
for(int i=1;i<=9;i++)
for(int j=1;j<=9;j++)
{
for(int k=1;k<=9;k++)
{
node[i][j].semaphore[k]=1;
node[i][j].semaphore_explore_recover[k]=0;
node[i][j].explore[k]=0;
}
node[i][j].semaphore[10]=0;
node[i][j].probable=9;
node[i][j].probable_explore_recover=0;
}
}
int fun(int row,int col)
{
if(1<=row && row<=3 )
{
if( 1<=col && col<=3)
return 1;
else if( 4<=col && col<=6)
return 2;
else
return 3;
}
else if( 4<=row && row<=6)
{
if( 1<=col && col<=3)
return 4;
else if( 4<=col && col<=6)
return 5;
else
return 6;
}
else
{
if( 1<=col && col<=3)
return 7;
else if( 4<=col && col<=6)
return 8;
else
return 9;
}
}
void add(int row1,int col1,int row2,int col2,int storage,int semaphore)//semaphore的值为100,200,300，400 表示从四个方向上恢复
{
finished--;
node[row1][col1].semaphore[storage]=1;
node[row1][col1].probable+=1; //node[row][col].storage的值最后变回0，下面恢复三个区域要用到这个值。
node[row1][col1].semaphore[10]=0;
switch(semaphore)
{
case 100: for(int j=col2;j>=1;j--)
if(node[row1][j].semaphore[storage]==0 && node[row1][j].probable!=0)
{
node[row1][j].semaphore[storage]=1;
node[row1][j].probable+=1;
} break;
case 200: for(int i=row2;i>=1;i--)
if(node[i][col2].semaphore[storage]==0 && node[i][col2].probable!=0)
{
node[i][col2].semaphore[storage]=1;
node[i][col2].probable+=1;
}
for(int j=9;j>=1;j--)
if(node[row1][j].semaphore[storage]==0 && node[row1][j].probable!=0)
{
node[row1][j].semaphore[storage]=1;
node[row1][j].probable+=1;
} break;
case 300: switch(fun(row1,col1))
{
case 1: for(int j=col2;j>=1;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=1;i--)
for(int j=3;j>=1;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 2: for(int j=col2;j>=4;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=1;i--)
for(int j=6;j>=4;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 3: for(int j=col2;j>=7;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=1;i--)
for(int j=9;j>=7;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 4: for(int j=col2;j>=1;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=4;i--)
for(int j=3;j>=1;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 5: for(int j=col2;j>=4;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=4;i--)
for(int j=6;j>=4;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 6: for(int j=col2;j>=7;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=4;i--)
for(int j=9;j>=7;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 7: for(int j=col2;j>=1;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=7;i--)
for(int j=3;j>=1;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 8: for(int j=col2;j>=4;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=7;i--)
for(int j=6;j>=4;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 9: for(int j=col2;j>=7;j--)
if(node[row2][j].semaphore[storage]==0 && node[row2][j].probable!=0)
{
node[row2][j].semaphore[storage]=1;
node[row2][j].probable+=1;
}
for(int i=row2-1;i>=7;i--)
for(int j=9;j>=7;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
}
for(int i=9;i>=1;i--)
if(node[i][col1].semaphore[storage]==0 && node[i][col1].probable!=0)
{
node[i][col1].semaphore[storage]=1;
node[i][col1].probable+=1;
}
for(int j=9;j>=1;j--)
if(node[row1][j].semaphore[storage]==0 && node[row1][j].probable!=0)
{
node[row1][j].semaphore[storage]=1;
node[row1][j].probable+=1;
}
break;
case 400: switch(fun(row1,col1))
{
case 1:
for(int i=3;i>=1;i--)
for(int j=3;j>=1;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 2:
for(int i=3;i>=1;i--)
for(int j=6;j>=4;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 3:
for(int i=3;i>=1;i--)
for(int j=9;j>=7;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 4:
for(int i=6;i>=4;i--)
for(int j=3;j>=1;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 5:
for(int i=6;i>=4;i--)
for(int j=6;j>=4;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 6:
for(int i=6;i>=4;i--)
for(int j=9;j>=7;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 7:
for(int i=9;i>=7;i--)
for(int j=3;j>=1;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 8:
for(int i=9;i>=7;i--)
for(int j=6;j>=4;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
case 9:
for(int i=9;i>=7;i--)
for(int j=9;j>=7;j--)
if(node[i][j].semaphore[storage]==0 && node[i][j].probable!=0)
{
node[i][j].semaphore[storage]=1;
node[i][j].probable+=1;
} break;
}
for(int i=9;i>=1;i--)
if(node[i][col1].semaphore[storage]==0 && node[i][col1].probable!=0)
{
node[i][col1].semaphore[storage]=1;
node[i][col1].probable+=1;
}
for(int j=9;j>=1;j--)
if(node[row1][j].semaphore[storage]==0 && node[row1][j].probable!=0)
{
node[row1][j].semaphore[storage]=1;
node[row1][j].probable+=1;
}
break;
}
if(node[row1][col1].probable_explore_recover!=0)
{
for(int i=1;i<=9;i++)
node[row1][col1].semaphore[i]=node[row1][col1].semaphore_explore_recover[i];
/*node[row1][col1].semaphore[storage]=0;*/
node[row1][col1].probable=node[row1][col1].probable_explore_recover;
min_probable_node.row=row1;
min_probable_node.col=col1;
min_probable_node.probable=node[row1][col1].probable;
}
}
/*void explore_min_node()
{ cout<<"i love you"<<endl;
bool outv2=true;
int t=10-min_probable_node.probable;
for(int i=1;i<=9;i++)
for(int j=1;j<=9;j++)
if(node[i][j].probable-min_probable_node.probable>=0 && node[i][j].probable-min_probable_node.probable<=t && !(i==min_probable_node.row && j==min_probable_node.col) )
{
t= node[i][j].probable-min_probable_node.probable;
min_probable_node.row=i;
min_probable_node.col=j;
}
for(int i=0;i<v3.size();i++)
for( int j=0;j<v3[i].size();j++)
outv2=outv2 && !(min_probable_node.row==v3[i][j][0] && min_probable_node.col==v3[i][j][1]) ;
if(!outv2) explore_min_node();
} */
vector<vector<int>> subtraction(int row,int col)
{
finished++;
if(finished==81) return success;
vector<vector<int>> temp;
for(int j=1;j<=9;j++)
if(node[row][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[row][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[row][j].probable-=1; //probable即可能填的数目减1
if(node[row][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[row][j].semaphore[k]==1)
{
for(int m=1;m<=9;m++)
if(k==node[row][m].semaphore[10] && m!=j)
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
}
for(int m=1;m<=9;m++)
if(k==node[m][j].semaphore[10] && m!=row)
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
}
switch(fun(row,j))
{
case 1: for(int m=1;m<=3;m++)
for(int n=1;n<=3;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 2: for(int m=1;m<=3;m++)
for(int n=4;n<=6;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 3: for(int m=1;m<=3;m++)
for(int n=7;n<=9;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 4: for(int m=4;m<=6;m++)
for(int n=1;n<=3;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 5: for(int m=4;m<=6;m++)
for(int n=4;n<=6;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 6: for(int m=4;m<=6;m++)
for(int n=7;n<=9;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear(); return v2;
} break;
case 7: for(int m=7;m<=9;m++)
for(int n=1;n<=3;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 8: for(int m=7;m<=9;m++)
for(int n=4;n<=6;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 9: for(int m=7;m<=9;m++)
for(int n=7;n<=9;n++)
if(k==node[m][n].semaphore[10] && !(m==row && n==j))
{
v1.push_back(row);
v1.push_back(j);
v1.push_back(0);
v1.push_back(100);
v2.push_back(v1);
v1.clear();
return v2;
} break;
}
node[row][j].semaphore[10]=k;
node[row][j].semaphore[k]=0;
node[row][j].probable=0;
v1.push_back(row);
v1.push_back(j);
v1.push_back(node[row][j].semaphore[10]);
v1.push_back(10);
v2.push_back(v1);
v1.clear();
temp=subtraction(row,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
}
for(int i=1;i<=9;i++)
if(node[i][col].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][col].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][col].probable-=1; //probable即可能填的数目减1
if(node[i][col].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][col].semaphore[k]==1)
{
for(int m=1;m<=9;m++)
if(k==node[i][m].semaphore[10] && m!=col)
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
}
for(int m=1;m<=9;m++)
if(k==node[m][col].semaphore[10] && m!=i)
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
}
switch(fun(i,col))
{
case 1: for(int m=1;m<=3;m++)
for(int n=1;n<=3;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 2: for(int m=1;m<=3;m++)
for(int n=4;n<=6;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 3: for(int m=1;m<=3;m++)
for(int n=7;n<=9;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 4: for(int m=4;m<=6;m++)
for(int n=1;n<=3;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 5: for(int m=4;m<=6;m++)
for(int n=4;n<=6;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 6: for(int m=4;m<=6;m++)
for(int n=7;n<=9;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 7: for(int m=7;m<=9;m++)
for(int n=1;n<=3;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 8: for(int m=7;m<=9;m++)
for(int n=4;n<=6;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
case 9: for(int m=7;m<=9;m++)
for(int n=7;n<=9;n++)
if(k==node[m][n].semaphore[10] && !(m==i && n==col))
{
v1.push_back(i);
v1.push_back(col);
v1.push_back(0);
v1.push_back(200);
v2.push_back(v1);
v1.clear();
return v2;
} break;
}
node[i][col].semaphore[10]=k;
node[i][col].semaphore[k]=0;
node[i][col].probable=0;
v1.push_back(i);
v1.push_back(col);
v1.push_back(k);
v1.push_back(20);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,col);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
}
switch(fun(row,col))
{
case 1: for(int i=1;i<=3;i++)
for(int j=1 ;j<=3;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=3;m++)
for( int n=1;n<=3;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 2: for(int i=1;i<=3;i++)
for(int j=4 ;j<=6;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=3;m++)
for( int n=4;n<=6;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 3: for(int i=1;i<=3;i++)
for(int j=7 ;j<=9;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=3;m++)
for( int n=7;n<=9;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 4: for(int i=4;i<=6;i++)
for(int j=1 ;j<=3;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=4;m<=6;m++)
for( int n=1;n<=3;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 5: for(int i=4;i<=6;i++)
for(int j=4 ;j<=6;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=4;m<=6;m++)
for( int n=4;n<=6;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 6: for(int i=4;i<=6;i++)
for(int j=7 ;j<=9;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=4;m<=6;m++)
for( int n=7;n<=9;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 7: for(int i=7;i<=9;i++)
for(int j=1 ;j<=3;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=7;m<=9;m++)
for( int n=1;n<=3;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 8: for(int i=7;i<=9;i++)
for(int j=4 ;j<=6;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=7;m<=9;m++)
for( int n=4;n<=6;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
case 9: for(int i=7;i<=9;i++)
for(int j=7;j<=9;j++)
if(node[i][j].semaphore[node[row][col].semaphore[10]]==1)
{
node[i][j].semaphore[node[row][col].semaphore[10]]=0; //把节点中不能填的点排除
node[i][j].probable-=1; //probable即可能填的数目减1
if(node[i][j].probable==1)
{
for(int k=1;k<=9;k++)
if(node[i][j].semaphore[k]==1)
{
node[i][j].semaphore[10]=k;
for(int m=1;m<=9;m++)
{
if(node[i][m].semaphore[10]==k && m!=j)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=1;m<=9;m++)
{
if(node[m][j].semaphore[10]==k && m!=i)
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
for(int m=7;m<=9;m++)
for( int n=7;n<=9;n++)
{
if(k==node[m][n].semaphore[10] && !(m==i && n==j))
{
v1.push_back(i);
v1.push_back(j);
v1.push_back(0);
v1.push_back(300);
v2.push_back(v1);
v1.clear();
return v2;
}
}
node[i][j].semaphore[10]=k;
node[i][j].semaphore[k]=0;
node[i][j].probable=0;
v1.push_back(i);
v1.push_back(j);
v1.push_back(k);
v1.push_back(30);
v2.push_back(v1);
v1.clear();
temp=subtraction(i,j);
if(temp==success) return success;
if(temp[v2.size()-1][3]>30 && temp[v2.size()-1][3]!=400 )
goto loop;
}
}
} break;
}
v1.push_back(row);
v1.push_back(col);
v1.push_back(1);
v1.push_back(400);
v2.push_back(v1);
v1.clear();
loop: return v2;
}
void addv2(vector<vector<int>> & v2)
{
vector<vector<int>> v2_transcript;
switch(v2[v2.size()-1][3])
{
case 100:
case 200:
case 300: node[v2[v2.size()-1][0]][v2[v2.size()-1][1]].semaphore[10]=0;
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back(); break;
case 400:
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
for( int i=v2.size()-1;i>=0;i--)
{
if(v2[i][3]==400)
{
v2_transcript.push_back(v2[i]);
v2.pop_back();
continue;
}
if(v2_transcript[v2_transcript.size()-1][3]==400 && v2_transcript[v2_transcript.size()-1][0]==v2[i][0] && v2_transcript[v2_transcript.size()-1][1]==v2[i][1] )
{
add(v2[i][0],v2[i][1],v2[i][0],v2[i][1],v2[i][2],400);
if(v2_transcript.size()==1)
{
v2_transcript.pop_back();
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
else
{
v2.pop_back();
v2_transcript.pop_back();
}
continue;
}
if(v2_transcript[v2_transcript.size()-1][3]==100 && v2_transcript[v2_transcript.size()-1][0]==v2[i][0])
{
add(v2[i][0],v2[i][1],v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1],v2[i][2],100);
if(v2_transcript.size()==1)
{
v2_transcript.pop_back();
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
else
{
v2.pop_back();
v2_transcript.pop_back();
}
continue;
}
if(v2_transcript[v2_transcript.size()-1][3]==200 && v2_transcript[v2_transcript.size()-1][1]==v2[i][1])
{
add(v2[i][0],v2[i][1],v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1],v2[i][2],200);
if(v2_transcript.size()==1)
{
v2_transcript.pop_back();
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
else
{
v2.pop_back();
v2_transcript.pop_back();
}
continue;
}
if(v2_transcript[v2_transcript.size()-1][3]==300 && fun(v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1])==fun(v2[i][0],v2[i][1]))
{
add(v2[i][0],v2[i][1],v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1],v2[i][2],300);
if(v2_transcript.size()==1)
{
v2_transcript.pop_back();
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
else
{
v2.pop_back();
v2_transcript.pop_back();
}
continue;
}
/* if(v2[i][3]==10 || v2[i][3]==20 || v2[i][3]==30)
{
v2_transcript.push_back(v2[i]);
v2.pop_back();
continue;
} */
if(v2_transcript[v2_transcript.size()-1][3]==10 && v2_transcript[v2_transcript.size()-1][0]==v2[i][0])
{
add(v2[i][0],v2[i][1],v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1],v2[i][2],100);
if(v2_transcript.size()==1)
{
v2_transcript.pop_back();
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
else
{
v2.pop_back();
v2_transcript.pop_back();
}
continue;
}
if(v2_transcript[v2_transcript.size()-1][3]==20 && v2_transcript[v2_transcript.size()-1][1]==v2[i][1])
{
add(v2[i][0],v2[i][1],v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1],v2[i][2],200);
if(v2_transcript.size()==1)
{
v2_transcript.pop_back();
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
else
{
v2.pop_back();
v2_transcript.pop_back();
}
continue;
}
if(v2_transcript[v2_transcript.size()-1][3]==30 && fun(v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1])==fun(v2[i][0],v2[i][1]))
{
add(v2[i][0],v2[i][1],v2_transcript[v2_transcript.size()-1][0],v2_transcript[v2_transcript.size()-1][1],v2[i][2],300);
if(v2_transcript.size()==1)
{
v2_transcript.pop_back();
v2_transcript.push_back(v2[v2.size()-1]);
v2.pop_back();
}
else
{
v2.pop_back();
v2_transcript.pop_back();
}
}
}//for
}
void explore( )
{
int row,col,probable;
probable=10;
/*for(int i=1;i<=9;i++)
{
for(int j=1 ;j<=9;j++)
{
if(probable>=node[i][j].probable && node[i][j].probable!=0 )
{ probable=node[i][j].probable;
row=i;
col=j;
}
// out_stream<<node[i][j].semaphore[10]<<" ";
}
// out_stream<<endl;
}*/
for(int i=9;i>=1;i--)
{
for(int j=9 ;j>=1;j--)
{
if(probable>=node[i][j].probable && node[i][j].probable!=0 )
{ probable=node[i][j].probable;
row=i;
col=j;
}
// out_stream<<node[i][j].semaphore[10]<<" ";
}
// out_stream<<endl;
}
min_probable_node.row=row; min_probable_node.col=col; min_probable_node.probable=probable;
// out_stream<<endl;
/* for(int i=1;i<=9;i++)
{
for(int j=1 ;j<=9;j++)
{
//if(min>num[i][j].probable && num[i][j].probable!=0,) { min=num[i][j].probable; row=i; col=j;}
out_stream<<node[i][j].probable<<" ";
}
out_stream<<endl;
}
out_stream<<endl;*/
/* for(int i=0;i<v3.size();i++)
for( int j=0;j<v3[i].size();j++)
if(min_probable_node.row==v3[i][j][0] && min_probable_node.col==v3[i][j][1])
explore_min_node(); */
// out_stream<<"row="<<min_probable_node.row<<" "<<"col="<<min_probable_node.col<<endl;
for(int k=1;k<=9;k++)
{
if(node[min_probable_node.row][min_probable_node.col].semaphore[k]==1)
{
for(int r=1;r<=9;r++)
if(node[min_probable_node.row][r].semaphore[10]==k )
goto loop;
for(int r=1;r<=9;r++)
if(node[r][min_probable_node.col].semaphore[10]==k )
goto loop;
switch(fun(min_probable_node.row,min_probable_node.col))
{
case 1: for( int i=1;i<=3;i++)
for(int j=1;j<=3;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 2: for( int i=1;i<=3;i++)
for(int j=4;j<=6;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 3: for( int i=1;i<=3;i++)
for(int j=7;j<=9;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 4: for( int i=4;i<=6;i++)
for(int j=1;j<=3;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 5: for( int i=4;i<=6;i++)
for(int j=4;j<=6;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 6: for( int i=4;i<=6;i++)
for(int j=7;j<=9;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 7: for( int i=7;i<=9;i++)
for(int j=1;j<=3;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 8: for( int i=7;i<=9;i++)
for(int j=4;j<=6;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
case 9: for( int i=7;i<=9;i++)
for(int j=7;j<=9;j++)
{
if(node[i][j].semaphore[10]==k)
goto loop;
} break;
}
for(int r=1;r<=9;r++)
node[min_probable_node.row][min_probable_node.col].semaphore_explore_recover[r]=node[min_probable_node.row][min_probable_node.col].semaphore[r];
node[min_probable_node.row][min_probable_node.col].probable_explore_recover=node[min_probable_node.row][min_probable_node.col].probable;
for(int r=1;r<=9;r++)
node[min_probable_node.row][min_probable_node.col].semaphore[r]=0;
node[min_probable_node.row][min_probable_node.col].probable=0;
node[min_probable_node.row][min_probable_node.col].semaphore[10]=k;
v1.push_back(min_probable_node.row);
v1.push_back(min_probable_node.col);
v1.push_back(node[min_probable_node.row][min_probable_node.col].semaphore[10]);
v1.push_back(0);
v2.push_back(v1);
v1.clear();
node[min_probable_node.row][min_probable_node.col].explore[k]=1;
if(subtraction(min_probable_node.row,min_probable_node.col)==success)
;
else if(v2[v2.size()-1][3]>30 && v2[v2.size()-1][3]!=400)
{
addv2(v2);
node[min_probable_node.row][min_probable_node.col].explore[k]=0;
/*if(k==9)
{
addv2(v3[v3.size()-1]);
node[min_probable_node.row][min_probable_node.col].exploe[k]=0;
v3.pop_back();
}*/
}
else
{
v3.push_back(v2);
v2.clear();
explore();
}
}
loop: ;
}
int sum=0;
for(int k=1;k<=9;k++)
sum+=node[min_probable_node.row][min_probable_node.col].explore[k];
if(sum==0)
{
node[v3[v3.size()-1][0][0]][v3[v3.size()-1][0][1]].explore[v3[v3.size()-1][0][2]]=0;
addv2(v3[v3.size()-1]);
v3.pop_back();
}
}
int test()
{
int sum=0,i,j;
for(int i=1;i<=9;i++)
{
sum=0;
for(int j=1;j<=9;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
}
for( j=1;j<=9;j++)
{
sum=0;
for(i=1;i<=9;i++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
}
sum=0;
for(i=1;i<=3;i++)
for(j=1;j<=3;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=1;i<=3;i++)
for(j=4;j<=6;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=1;i<=3;i++)
for(j=7;j<=9;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=4;i<=6;i++)
for(j=1;j<=3;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=4;i<=6;i++)
for(j=4;j<=6;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=4;i<=6;i++)
for(j=7;j<=9;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=7;i<=9;i++)
for(j=1;j<=3;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=7;i<=9;i++)
for(j=4;j<=6;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
sum=0;
for(i=7;i<=9;i++)
for(j=7;j<=9;j++)
sum+=node[i][j].semaphore[10];
if(sum!=45) {cout<<"wrong"<<endl; return 0;}
return 1;
}
int fun( int array[10])
{
int i,j;
for(i=1;i<=8;i++)
{
if(*(array+i)==0) continue;
for(j=i+1;j<=9;j++)
if(*(array+i)==*(array+j)) return 0;
}
return 1;
}
int test(vector<vector<int>> v2) //数据输入后，检查数据有没有同一行（列，方块）输入同一个数字
{
int matrix[10][10]={0};
int i,j,array[10],index=0;
for(i=0;i<=v2.size()-1;i++)
matrix[v2[i][0]][v2[i][1]]=v2[i][2];
for(i=1;i<=9;i++)
if(!fun(matrix[i])) { cout<<"您的输入有误或题目错误，第"<<i<<"行输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
for(j=1;j<=9;j++)
{
for(i=1;i<=9;i++)
array[i]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误，第"<<j<<"列输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
}
for(i=1;i<=3;i++)
for(j=1;j<=3;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=1;i<=3;i++)
for(j=4;j<=6;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=1;i<=3;i++)
for(j=7;j<=9;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=4;i<=6;i++)
for(j=1;j<=3;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=4;i<=6;i++)
for(j=4;j<=6;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=4;i<=6;i++)
for(j=7;j<=9;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=7;i<=9;i++)
for(j=1;j<=3;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=7;i<=9;i++)
for(j=4;j<=6;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
index=0;
for(i=7;i<=9;i++)
for(j=7;j<=9;j++)
array[++index]=matrix[i][j];
if(!fun(array)) { cout<<"您的输入有误或题目错误,九个块其中一块输入了两个相等的数 要不就是设计数独的人太愚蠢"<<endl; return 0;}
}
int main()
{
int row,col,number,information_number=0;
time_t nowtime1,nowtime2;
out_stream.open("d:\\c++\\数独12\\out.txt");
do{;
cout<<"请输入row（行），col（列），number（已填的数字即已经填进九宫格的数字1-9） 三个一组（每组3个数之间要留至少一个空格)按回车键，当所有已知填进九宫格的数字都输完后请输入三个0按回车键"<<endl;
cin>>row>>col>>number;
v1.push_back(row);
v1.push_back(col);
v1.push_back(number);
v2.push_back(v1);
v1.clear();
}while(row!=0 && col!=0);
v2.pop_back();
information_number=v2.size();
/* v1.push_back(1); //这是芬兰数学家在2012年 6月30号发布的据说是难度为11级的数独，牛逼老道还说最难的地方填上一数要往前推10个数。
v1.push_back(1);
v1.push_back(8);
v2.push_back(v1);
v1.clear();
v1.push_back(2);
v1.push_back(3);
v1.push_back(3);
v2.push_back(v1);
v1.clear();
v1.push_back(2);
v1.push_back(4);
v1.push_back(6);
v2.push_back(v1);
v1.clear();
v1.push_back(3);
v1.push_back(2);
v1.push_back(7);
v2.push_back(v1);
v1.clear();
v1.push_back(3);
v1.push_back(5);
v1.push_back(9);
v2.push_back(v1);
v1.clear();
v1.push_back(3);
v1.push_back(7);
v1.push_back(2);
v2.push_back(v1);
v1.clear();
v1.push_back(4);
v1.push_back(2);
v1.push_back(5);
v2.push_back(v1);
v1.clear();
v1.push_back(4);
v1.push_back(6);
v1.push_back(7);
v2.push_back(v1);
v1.clear();
v1.push_back(5);
v1.push_back(5);
v1.push_back(4);
v2.push_back(v1);
v1.clear();
v1.push_back(5);
v1.push_back(6);
v1.push_back(5);
v2.push_back(v1);
v1.clear();
v1.push_back(5);
v1.push_back(7);
v1.push_back(7);
v2.push_back(v1);
v1.clear();
v1.push_back(6);
v1.push_back(4);
v1.push_back(1);
v2.push_back(v1);
v1.clear();
v1.push_back(6);
v1.push_back(8);
v1.push_back(3);
v2.push_back(v1);
v1.clear();
v1.push_back(7);
v1.push_back(3);
v1.push_back(1);
v2.push_back(v1);
v1.clear();
v1.push_back(7);
v1.push_back(8);
v1.push_back(6);
v2.push_back(v1);
v1.clear();
v1.push_back(7);
v1.push_back(9);
v1.push_back(8);
v2.push_back(v1);
v1.clear();
v1.push_back(8);
v1.push_back(3);
v1.push_back(8);
v2.push_back(v1);
v1.clear();
v1.push_back(8);
v1.push_back(4);
v1.push_back(5);
v2.push_back(v1);
v1.clear();
v1.push_back(8);
v1.push_back(8);
v1.push_back(1);
v2.push_back(v1);
v1.clear();
v1.push_back(9);
v1.push_back(2);
v1.push_back(9);
v2.push_back(v1);
v1.clear();
v1.push_back(9);
v1.push_back(7);
v1.push_back(4);
v2.push_back(v1);
v1.clear();
information_number=21; */
for(int i=0;i<information_number;i++)
if(v2[i][2]<1 || v2[i][2]>9)
{
cout<<"输入错误，要填入九宫格中的数字不在1--9内 或行号和列号不在9内，您没有按格式输入，请重新运行并输入 要不就是设计数独的人太愚蠢"<<endl;
cin>>row;
return 0;
}
if(!test(v2))
{
cin>>row;
return 0;
}
nowtime1=time(NULL);
fills_up();
for(int i=0;i<information_number;i++)
{
for(int k=1;k<=9;k++)
node[v2[i][0]][v2[i][1]].semaphore[k]=0;
node[v2[i][0]][v2[i][1]].probable=0;
node[v2[i][0]][v2[i][1]].semaphore[10]=v2[i][2];
}
vector<vector<int>> v2_temporary;
for(int i=0;i<information_number;i++)
{
v2_temporary=subtraction(v2[i][0],v2[i][1]);
if(v2_temporary[v2.size()-1][3]==400) continue;
if(v2_temporary[v2.size()-1][3]==100 || v2_temporary[v2.size()-1][3]==200 ||v2_temporary[v2.size()-1][3]==300)
{
cout<<"数组题目设计错误"<<endl;
}
}
v2.clear();
if(finished==81)
{
for( int i=1;i<=9;i++)
{
for(int j=1;j<=9;j++)
out_stream<<node[i][j].semaphore[10]<<" ";
out_stream<<endl;
}
out_stream<<endl;
if(test()) { nowtime2=time(NULL); out_stream<<"用时(不含输入数据时间)"<<nowtime2-nowtime1<<"秒"<<endl; cout<<"right"<<endl;}
cin>>row;
return 0;
}
explore();
if(test())
{
for( int i=1;i<=9;i++)
{
for(int j=1;j<=9;j++)
out_stream<<node[i][j].semaphore[10]<<" ";
out_stream<<endl;
}
out_stream<<endl;
nowtime2=time(NULL);
out_stream<<"用时(不含输入数据时间)"<<nowtime2-nowtime1<<"秒"<<endl;
cout<<"right"<<endl;
}
cin>>row;
}
扫一扫
1961
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
