贪婪算法优化计算-马踏棋盘问题

#include<iostream>
#include<iomanip>
#include<fstream>
#include<vector>
#include<algorithm>
#include<cstdlib>
#include<ctime>
usingnamespacestd;

constintN=8;//棋盘规模
intoffsetX
={-1,1,-1,1,-2,-2,2,2};//相对于当前点马的下一落脚点x的偏移量
intoffsetY
={-2,-2,2,2,-1,1,-1,1};//相对于当前点马的下一落脚点y的偏移量
intchessboard

;//棋盘,此时每个chessboard[i][j]=0
//程序运行后要对chessboard[i][j]进行编号,从1,2,...,N*N

ofstreamlog;//输出文件流,记录贪婪寻优结果

classChessNode//马下一跳的位置--棋盘结点类
{
private:
intx;//此结点在棋盘的位置(x,y)
inty;
intwayout;//每个结点有8个出口,出口表示此结点的在棋盘下一跳的位置
//wayout表示此位置的出口数,如果在某一个方向没有出口,那么wayout=0

public:
ChessNode(int_x=0,int_y=0):x(_x),y(_y)
{
wayout=0;
}
intgetX()const
{
returnx;
}
intgetY()const
{
returny;
}
intgetwayout()const
{
returnwayout;
}
voidsetX(intX)
{
x=X;
}
voidsetY(intY)
{
y=Y;
}
boolIsCorrect()const
{
//此时要保证(x,y)不能越界并且此时chessboard[x][y]=0
//马才能跳到这一位置
if(x<N&&x>=0&&y<N&&y>=0&&chessboard[x][y]==0)
{
returntrue;
}
elsereturnfalse;
}
voidSetWayout()//设置结点的出口
{
intdirection;
for(direction=0;direction<N;direction++)//依次检测8个方向
{
intnx=x+offsetX[direction];//每一个方向的位置(nx,ny)
intny=y+offsetY[direction];
ChessNodenode(nx,ny);//构造一个结点位置
wayout+=node.IsCorrect();//求出出口数
}
}
voidshow()const
{
cout<<"("<<x<<","<<y<<")"<<endl;
cout<<wayout<<endl;
}
};

classLessThan//函数对象
{
public:
booloperator()(constChessNode&one,constChessNode&other)
{
returnone.getwayout()<other.getwayout();
}
};

constintmax=100000;//最大递归深度
classHourseJumpChessboard
{
private:
intRDepth;//递归的深度
intcount;//棋盘的编号
boolfind;

voidSuccess()//成功求解
{
inti,j;
log<<"程序运行后棋盘编号:"<<endl;
for(i=0;i<N;i++)
{
for(j=0;j<N;j++)log<<setw(4)<<chessboard[i][j]<<"";
log<<endl;
}
log<<"递归深度:"<<RDepth<<endl;
}

voidDFS(ChessNodenode,intcount)//普通的寻径算法,类似于图的深度遍历
{
//此时的算法很难得到正确的解,原因是程序在遍历时解空间太大
if(find==true||RDepth>max)
{
if(RDepth>max)
{
log<<"用普通寻径方式已经达到最大递归深度,无法得到正确的解!"<<endl;
}
return;//截断递归
}
if(count>N*N)
{
find=true;
Success();
}
intdirection;
for(direction=0;direction<N;direction++)//依次搜寻8个方向
{
ChessNodenode(node.getX()+offsetX[direction],node.getY()+offsetY[direction]);
if(node.IsCorrect())
{
RDepth++;
chessboard[node.getX()][node.getY()]=count;
DFS(node,count+1);
}
}
chessboard[node.getX()][node.getY()]=0;//此时node为死结点,即没有出口的结点
}

voidGreedyDFS(ChessNodenode,intcount)//用贪婪算法优化
{
if(find==true)return;//截断递归
if(count>N*N)
{
find=true;
Success();
}
intdirection;
vector<ChessNode>v;//保存下一跳位置结点
for(direction=0;direction<N;direction++)//依次搜寻8个方向
{
ChessNodenode(node.getX()+offsetX[direction],node.getY()+offsetY[direction]);
if(node.IsCorrect())
{
node.SetWayout();
v.push_back(node);
}
}
sort(v.begin(),v.end(),LessThan());//对向量v进行升序排序
vector<ChessNode>::iteratorit;
for(it=v.begin();it!=v.end();it++)
{
chessboard[it->getX()][it->getY()]=count;
RDepth++;
GreedyDFS(*it,count+1);
}
chessboard[node.getX()][node.getY()]=0;
}
public:
intgetRecursiveDepth()const
{
returnRDepth;
}
HourseJumpChessboard()
{
inti,j;
for(i=0;i<N;i++)//初始化棋盘
{
for(j=0;j<N;j++)chessboard[i][j]=0;
}
}

Walk(intx,inty)//初始位置(x,y)
{
ChessNodenode(x,y);
if(node.IsCorrect()==false)
{
cerr<<"初始位置不合法,程序退出!"<<endl;
exit(1);
}
find=true;
count=2;
RDepth=1;
chessboard[x][y]=1;
DFS(node,count);
}

GreedyWalk(intx,inty)//初始位置(x,y)
{
ChessNodenode(x,y);
if(node.IsCorrect()==false)
{
cerr<<"初始位置不合法,程序退出!"<<endl;
exit(1);
}
find=false;
count=2;
RDepth=1;
chessboard[x][y]=1;
GreedyDFS(node,count);
}
};

voidmain()
{
log.open("e:\\log.txt");
if(!log)
{
cerr<<"不能写日志文件,程序退出!"<<endl;
exit(1);
}
srand(unsigned(time(0)));
intn=28;//随机产生28个位置进行测试
inti;
intx,y;
for(i=0;i<n;i++)
{
HourseJumpChessboardhorse;
x=rand()%N;
y=rand()%N;
horse.Walk(x,y);//普通寻径方式

HourseJumpChessboardGreedyhorse;
Greedyhorse.GreedyWalk(x,y);//贪婪寻径方式
}
log.close();
}