求图的所有哈密顿环算法2

--------- node.h ------------------//定义节点类

#include<string>
#include<vector>
using namespace std;

class node
{
public:
node(int c,const string _name):cp(c),name(_name){}
string name; //结点名称
int cp; //结点标号
};

----------- sort.h ---------------------//寻找哈密尔顿回路的算法部分

#include<iostream>
#include<string>
#include<vector>
#include"node.h"
using namespace std;

vector<node> v_sort; //记录当前搜索时结点的连接状况
int N; //结点总数
vector<string> in_name; //结点名称
vector<vector<bool> > link_state; //结点的初始连接状况
vector<vector<bool> > clink; //结点当前连接状况（用于搜索）

//用于搜索的函数，由sort()调用，搜索结果保存在v_sort里
int node_sort()
{
int count=v_sort.back().cp; //v_sort栈顶结点的标号
if(v_sort.size()==N && link_state[count][0]==true)
return 1; //当成功找到一回路时返回 1

//通过查看clink进行搜索
for(int i=0;i<N;i++)
{
//发现另一结点M可与该结点相连
if(clink[count][i]==true)
{
bool in_stack=false; //标示M是否已在v_sort里
for(int j=0;j<v_sort.size();j++)
if(v_sort[j].name==in_name[i])
in_stack=true; //M已在v_sort里
if(in_stack==false)
{
//压入M结点
node tmp(i,in_name[i]);
v_sort.push_back(tmp);
//修改clink,堵住已走的路
clink[i][count]=false;
clink[count][i]=false;
return 0;
}
}
}
v_sort.pop_back(); //当找不到路时弹出该结点
clink[count]=link_state[count]; //恢复弹出结点的初始连接状态
return 0;
if(v_sort.size()==0)
return -1; //搜索失败，此时v_sort为空，返回-1
}

//sort函数由用户调用，依次传入结点数量，名称，初始连接状况；输出排好的结点名
bool sort(int n,const vector<string> _in_name,const vector<vector<bool> > _link_state,vector<string>& out_name)
{
//初始化全局变量
N=n;
in_name=_in_name;
link_state=_link_state;
clink=link_state;
v_sort.clear();

//先压入第一个结点
node first(0,in_name[0]);
v_sort.push_back(first);
while(1)
{
int r=node_sort();
if(r==1)
{
for(int i=0;i<n;i++)
out_name.push_back(v_sort[i].name);//找到回路就初始化out_name
return true;
}

if(r==-1)
return false; //未找到
}
}

------------- main.cpp ----------------//这个是调用部分，没有注释，有点乱，不过不是主要的

#include<iostream>
#include<string>
#include<vector>
#include"sort.h"
#include<cstdlib>
using namespace std;

void main()
{
cout<<endl<<"*************寻找哈密尔顿回路程序***************/n";

string is_continue="y";
while(is_continue=="y"||is_continue=="Y" )
{
int np;
string inN;
vector<string> in_name;
bool judge=true;

cout<<"/n 请依次输入各节点名称,以空格隔开:";
while(1)
{
do{
cin>>inN;
judge=true;

for(int i=0;i<in_name.size();i++)
{
if(inN==in_name[i])
{
cout<<"/n!节点名称不能重复,请重新输入各节点名称(先空一格):";
judge=false;
cin.ignore(1000,'/n');
in_name.assign(0,"");
break;
}
}
if(judge==true)
in_name.push_back(inN);

}while(cin.get()!='/n');
if(in_name.size()>=3)
break;
cout<<"/n!节点数必需大于或等于3,请重新输入:";
in_name.assign(0,"");
}

np=in_name.size();
vector<bool> _link_state(np);
vector<vector<bool> > link_state;
string in_link;

cout<<"/n请依次输入该节点与所有节点的连接情况,以空格隔开/n ";
for(int i=0;i<np;i++)
cout<<in_name[i]<<" ";
cout<<"/n";
bool input_again=false;
for(i=0;i<np;i++)
{
do{
input_again=false;
cout<<" "<<in_name[i]<<":";
for(int k=0;k<np;k++)
{
cin>>in_link;
if(in_link!="0" && in_link!="1")
{
cout<<"/n !!只能输入'0'/'1',请重新输入该节点连接情况:/n";
input_again=true;
cin.ignore(1000,'/n');
break;
}
else if(k==i && in_link=="1")
{
cout<<"/n !!这里节点不能与自身相连,请重新输入该节点连接情况:/n";
input_again=true;
cin.ignore(1000,'/n');
break;
}
in_link=="0"? _link_state[k]=false:_link_state[k]=true;
}
}while(input_again==true);

link_state.push_back(_link_state);
}

vector<string> out_name;

if(sort(np,in_name,link_state,out_name)==false)
cout<<"/n 无哈密尔顿回路 /n";
else
{
cout<<"/n 找到一条哈密尔顿回路: /n";
for(i=0;i<out_name.size();i++)
cout<<out_name[i]<<"---";

cout<<out_name[0];
}

cout<<"/n/n是否继续?(y/n):";
cin>>is_continue;
while(is_continue!="Y" && is_continue!="y" && is_continue!="N" && is_continue!="n")
{
cout<<"/n只能输入'y'/'n',请重新选择(y/n):";
cin>>is_continue;
}
}

cout<<"/n欢迎使用/n";
system("PAUSE");
}