一笔画游戏路径搜索代码<未优化>

#include <iostream>

#include <vector>

#include <string>

#include <algorithm>

#include <stack>

using namespace std;

//*******************************************************************************************

/*

* 穷取法寻找一条路径，若等于输入的边数则成功退出;

*

*/

class GraphicData

{

public:

int signal; //边索引号。

char nodea; //节点a。

char nodeb; //节点b。

int oriFir; //是否有方向(0:无,1:有,2:可变)。

int oriSec; //节点指向(0:a->b,1:b->a)。

int byCount; //边可通过次数 :1，2。

public:

GraphicData(){}

GraphicData(int s,int na,int nb,int or,int oc,int bt)

{

signal=s;

nodea=na;

nodeb=nb;

oriFir=or;

oriSec=oc;

byCount=bt;

}

};

typedef struct Table

{

vector<GraphicData> v; //存储容器表

int seq; //存储遍历深度

int dir; //存储方向0:a,1:b

}Ta;

typedef struct CharData

{

char element; //存储字符

int seq; //与Table 中索引一致

}CDa;

//********************************************************************************************

/*在容器中查找字符，将结果返回到迭代器中

* a: 查找字符 ;

* nextValue: 查找下一字符 ;

* hse: 判断是否还有未扫描的边

*/

//容器中查找字符，返回bool值

bool findElem(vector<char>&vec,char seq)

{

for(vector<char>::iterator it=vec.begin();it!=vec.end();it++)

{

if((*it)==seq)

return true;

}

return false;

}

//查找字符，返回查找到的迭代器和指向

bool findChar(vector<GraphicData>&vec,vector<GraphicData>::iterator &it,char &Value,int &nextSig,int &hse,vector<char>& veceng)

{

hse=0;

while(it<vec.end())

{

//判断边是否可以通过

if((*it).byCount>0)

{

hse=1;

//判断方向:有(0);无(1);其中可变被包含

if((*it).oriFir==0)

{

if((*it).nodea==Value &&!findElem(veceng,(*it).nodeb))

{

nextSig=1;

return true;

}

else if((*it).nodeb==Value&&!findElem(veceng,(*it).nodea))

{

nextSig=0;

return true;

}

}

else if((*it).oriFir==1)

{

if((*it).oriSec==0)

{

if((*it).nodea==Value &&!findElem(veceng,(*it).nodeb))

{

nextSig=1;

return true;

}

}

else

{

if((*it).nodeb==Value &&!findElem(veceng,(*it).nodea))

{

nextSig=0;

return true;

}

}

}

else if((*it).oriFir==2)

{

if((*it).oriSec==0)

{

if((*it).nodea==Value &&!findElem(veceng,(*it).nodeb))

{

nextSig=1;

return true;

}

}

else

{

if((*it).nodeb==Value &&!findElem(veceng,(*it).nodea))

{

nextSig=0;

return true;

}

}

}

}

it++;

}

return false;

}

//交换两元素的位置

template<typename T> void swap2(T &a,T &b)

{

T temp=a; a=b; b=temp;

}

//计算总路径(包括重复的边)

int sumEdge(vector<GraphicData>&vec)

{

int sum=0;

for(vector<GraphicData>::iterator it=vec.begin();it!=vec.end();it++)

{

sum+=(*it).byCount;

}

return sum;

}

//查找字符，返回迭代器

void findIterator(vector<GraphicData>&vec,vector<GraphicData>::iterator &st,int seq)

{

for(vector<GraphicData>::iterator it=vec.begin();it!=vec.end();it++)

{

if((*it).signal==seq)

{

st=it;

break;

}

}

}

//查找可变的边

void findVariable(vector<GraphicData>&vec,vector<char> &v)

{

for(vector<GraphicData>::iterator it=vec.begin();it!=vec.end();it++)

{

if((*it).oriFir==2)

{

if((*it).oriSec==0)

v.push_back((*it).nodea);

else

v.push_back((*it).nodeb);

}

}

}

//修改Table里面的值

void AlterVariable(vector<GraphicData>&vec,char &c)

{

for(vector<GraphicData>::iterator it=vec.begin();it!=vec.end();it++)

{

if((*it).oriFir==2)

{

if((*it).oriSec==0 &&(*it).nodea==c)

{

(*it).oriFir=1;

(*it).oriSec=1;

break;

}

else if((*it).oriSec==1 &&(*it).nodeb==c)

{

(*it).oriFir=1;

(*it).oriSec=0;

break;

}

}

}

}

//根据指定元素查找其他元素

/*

*tempvec:存储结果

*sig :指示方向 0:a 1:b

*/

bool runFinder(vector<GraphicData>&vec,

vector<GraphicData>::iterator st,

vector<CharData> &tempvec,

const int sig)

{

stack<Table> sktable; //存储元素表

stack<vector<GraphicData>::iterator> sktg;//存储元素索引

Table vt;

CharData ca;

char tempc='0';

int nextSig=0; //下一个索引的方向

tempvec.clear(); //清空缓存

vector<char> veceng; //保存同一层

vector<char> v2; //存储可变的边

findVariable(vec,v2);

// cout<<"输出2的节点"<<endl;

// for(int i=0;i<v2.size();i++)

// cout<<v2[i]<<" ";

// cout<<endl;

//若开始就有方向可变边的节点，则后面的表要改变方向

(*st).byCount--;

if(v2.size()>0)

{

if(sig==1)

{

if(findElem(v2,(*st).nodeb))

{

AlterVariable(vec,(*st).nodeb);

}

}

else

{

if(findElem(v2,(*st).nodea))

{

AlterVariable(vec,(*st).nodea);

}

}

}

//存储起始节点(0:a,1:b)

if(sig==0)

{

ca.element=(*st).nodeb;

ca.seq=1;

tempvec.push_back(ca);

vt.dir=0;

vt.seq=1;

vt.v=vec;

sktable.push(vt);

//cout<<"进栈: "<<(*st).nodea<<endl;

}

else

{

ca.element=(*st).nodea;

ca.seq=1;

tempvec.push_back(ca);

vt.dir=1;

vt.seq=1;

vt.v=vec;

sktable.push(vt);

// cout<<"进栈: "<<(*st).nodeb<<endl;

}

sktg.push(st);

//循环遍历以该节点为首的序列

long depth=1; //记录深度

bool isSuccess=true;

vector<GraphicData>::iterator tt;

vector<GraphicData> veccopy=vec;

while(!sktg.empty())

{

veceng.clear();

vt=sktable.top();

tt=sktg.top();

// if(vt.dir==0)

// cout<<"出栈: "<<(*tt).nodea<<endl;

// else

// cout<<"出栈: "<<(*tt).nodeb<<endl;

sktable.pop();

sktg.pop();

++depth;

//若路径失败,刷新容器

if(!isSuccess)

{

for(vector<CharData>::iterator it=tempvec.end()-1;it>=tempvec.begin();it--)

{

if((*it).seq==vt.seq)

{

for(vector<CharData>::iterator st=it+1;st!=tempvec.end();)

{

st=tempvec.erase(st++);

}

break;

}

}

}

//存储出栈的字符

if(vt.dir==0)

{

tempc=(*tt).nodea; //存储下一字符

ca.element=(*tt).nodea;

ca.seq=depth;

tempvec.push_back(ca);

}

else

{

tempc=(*tt).nodeb;//存储下一字符

ca.element=(*tt).nodeb;

ca.seq=depth;

tempvec.push_back(ca);

}

int isFind=0; //判断循环是否执行

int nes=0; //判断是否还有未扫描的边

vector<GraphicData> tempv=vt.v;

tt=tempv.begin();

char temchild='0';

while(findChar(tempv,tt,tempc,nextSig,nes,veceng))

{

isFind=1;

if((*tt).oriFir==2)

{

if((*tt).oriSec==1)

(*tt).oriSec=0;

else

(*tt).oriSec=1;

}

(*tt).byCount--;

if(nextSig==0)

temchild=(*tt).nodea;

else

temchild=(*tt).nodeb;

//cout<<"进栈: "<<temchild<<endl;

veceng.push_back(temchild);

if(v2.size()>0)

{

if(nextSig==0)

{

if(findElem(v2,(*tt).nodea))

{

AlterVariable(tempv,(*tt).nodea);

}

}

else

{

if(findElem(v2,(*tt).nodeb))

{

AlterVariable(tempv,(*tt).nodeb);

}

}

}

Table vtt;

vtt.dir=nextSig;

vtt.seq=depth;

vtt.v=tempv;

sktable.push(vtt);

vector<GraphicData>::iterator ttmp;

findIterator(veccopy,ttmp,(*tt).signal);

sktg.push(ttmp);

tempv=vt.v;

tt=tempv.begin();

}

if(nes==0)

{

cout<<"--Result: find success!"<<endl;

return true; //路径成功，返回

}

else if(isFind==0 && nes==1)

{

isSuccess=false; //路径失败！

}

}

return false;

}

void main()

{

int noScanCount=0; //定义是否有未扫描的边数，若为0，则成功;

cout<<"*****************************************"<<endl;

vector<GraphicData> vec1;

vec1.clear();

int i=0;

//cout<<"--Please enter bilateral relations! "<<endl;

cout<<"--Format: <int signal,char nodea, char nodeb,int oriFir,int oriSec,int byCount> "<<endl;

cout<<" --signal : bilateral index number."<<endl;

cout<<" --nodea : node a."<<endl;

cout<<" --nodeb : node b."<<endl;

cout<<" --oriFir : direction(0:no; 1:yes; 2:variable."<<endl;

cout<<" --oriSec : node direction(0:a->b,1:b->a)."<<endl;

cout<<" --byCount: the number of side which can be able to go"<<endl;

/*while(i++<num)

{

cin>>data.signal>>data.nodea>>data.nodeb>>data.oriFir>>data.oriSec>>data.byCount;

vec1.push_back(data);

}

*/

//**************************测试**********************************

/*

GraphicData data4(4,'c','d',2,0,2);

GraphicData data5(5,'a','b',0,0,1);

GraphicData data3(3,'a','c',2,0,2);

GraphicData data2(2,'a','d',0,0,2);

GraphicData data1(1,'c','b',1,0,1);

vec1.push_back(data1);

vec1.push_back(data2);

vec1.push_back(data3);

vec1.push_back(data4);

vec1.push_back(data5);

*/

GraphicData data1(1,'a','c',0,0,1);

GraphicData data2(2,'d','b',0,0,1);

GraphicData data6(3,'a','b',0,0,2);

GraphicData data7(4,'c','d',0,0,2);

GraphicData data3(5,'a','j',0,0,1);

GraphicData data4(6,'c','k',0,0,1);

GraphicData data5(7,'b','m',0,0,1);

GraphicData data8(8,'d','l',0,0,1);

GraphicData data9(9,'f','n',0,0,2);

GraphicData data10(10,'i','n',0,0,2);

GraphicData data11(11,'e','n',0,0,1);

GraphicData data12(12,'n','h',1,0,2);

GraphicData data13(13,'k','f',1,0,2);

GraphicData data14(14,'k','h',0,0,1);

GraphicData data15(15,'h','l',0,0,1);

GraphicData data16(16,'l','i',1,0,2);

GraphicData data17(17,'i','m',0,0,2);

GraphicData data18(18,'m','e',0,0,1);

GraphicData data19(19,'e','j',0,0,1);

GraphicData data20(20,'j','f',0,0,2);

vec1.push_back(data1);

vec1.push_back(data2);

vec1.push_back(data3);

vec1.push_back(data4);

vec1.push_back(data5);

vec1.push_back(data6);

vec1.push_back(data7);

vec1.push_back(data8);

vec1.push_back(data9);

vec1.push_back(data10);

vec1.push_back(data11);

vec1.push_back(data12);

vec1.push_back(data13);

vec1.push_back(data14);

vec1.push_back(data15);

vec1.push_back(data16);

vec1.push_back(data17);

vec1.push_back(data18);

vec1.push_back(data19);

vec1.push_back(data20);

//***************************************************************

vector<GraphicData> vec2=vec1;

cout<<"--show bilateral inputed!"<<endl;

for(vector<GraphicData>::iterator it=vec2.begin();it!=vec2.end();it++)

cout<<" ("<<(*it).signal<<","<<(*it).nodea<<","<<(*it).nodeb<<","<<(*it).oriFir<<","<<(*it).oriSec<<","<<(*it).byCount<<")"<<endl;

//<1>每遍历一个data,则其可通过次数-1,若容器中每个元素可通过次数都为0,则路径正确。

//<2>若是方向可变边,扫描一次时,将其oriSec改变即可。

int c2=sumEdge(vec2); //总路径

cout<<"--TotalPath: "<<c2<<endl;

vector<CharData> tempvec; //存储正确的连接顺序

vector<GraphicData>::iterator st=vec2.begin(); //遍历迭代器

vector<GraphicData>::iterator stb=vec2.begin();

while(stb!=vec2.end())

{

noScanCount=0;

if((*stb).oriFir==0)

{

if(runFinder(vec2,st,tempvec,0)) //0:a,1:b

{

noScanCount=1;

break;

}

else

{

vec2=vec1;

st=stb;

if(runFinder(vec2,st,tempvec,1))

{

noScanCount=1;

break;

}

}

}

else

{

if((*stb).oriSec==0)

{

if(runFinder(vec2,st,tempvec,1))

{

noScanCount=1;

break;

}

}

else

{

if(runFinder(vec2,st,tempvec,0))

{

noScanCount=1;

break;

}

}

}

stb++;

st=stb;

vec2=vec1;

}

if(noScanCount==1)

{

cout<<" ";

for(vector<CharData>::iterator it=tempvec.begin();it!=tempvec.end();it++)

cout<<" "<<(*it).element<<" ->";

}

cout<<endl;

}