poj2488

今天不不知道中了什么邪了，这道曾经写过的马步图问题竟然，用树的深度优先遍历去做（用栈结构+回溯），花了半天也没写对。在纸上写，感觉想明白了就在电脑上敲，敲完总也运行不出想要的结果。整地头晕脑胀地，决定先放着，换一种方法。

用递归实现。（也很周折，有个字母敲错了，提交了好几次，后来才发现）。

啊啊啊啊，哥要疯了！

好郁闷啊。等哥那天状态好了，一定写个启发式搜索的马步图出来。

啊啊啊啊，哥要疯了。

递归代码：

#include<iostream>
#include<fstream>
#include<string.h>
using namespace std;
int direct[8][2]={{-1,-2},{+1,-2},{-2,-1},{+2,-1},{-2,+1},{+2,+1}
	,	{-1,+2},{+1,+2}};
int n,p,q;
bool visited[100][100];
int output[100][2];
int flag;
void  dfs(int row,int col,int depth)
{
	output[depth][0]=row;
	output[depth][1]=col;
	if(depth==p*q)
	{
		flag=true;
		return ;
	}

	for(int i=0;i<8;i++)
	{
		int next_row=row+direct[i][0];
		int next_col=col+direct[i][1];
		if(flag==false&&next_row>=0&&next_row<p&&next_col>=0&&next_col<q&&visited[next_row][next_col]==false)
		{
			visited[next_row][next_col]=true;
			dfs(next_row,next_col,depth+1);
			visited[next_row][next_col]=false;

		}
	}
}
int main()
{
	freopen("input.txt","r",stdin);
	cin>>n;
	for(int i=0;i<n;i++)
	{
		cin>>p>>q;
		flag=false;
		for(int j=0;j<100;j++)
		{
			memset(visited[j],false,100);
		}
		visited[0][0]=true;
		dfs(0,0,1);
		printf("Scenario #%d:\n",i+1);
		if(flag)
		{
			for(int j = 1;j <= p*q;j++)
			{
				printf("%c",output[j][1]+'A');
				printf("%d",output[j][0]+1);
			}
		}
		else
			printf("impossible");
		printf("\n\n");
	}
              


	return 0;

}

栈+回溯   未完成代码：

#include<iostream>
#include<fstream>
#include<stack>
using namespace std;
int direct[8][2]={{-1,-2},{+1,-2},{-2,-1},{+2,-1},{-2,+1},{+2,+1}
,	{-1,+2},{+1,+2}};
struct Node
{
	int row;
	int col;
	int id;
	int depth;
	Node(int r,int c,int i,int d)
	{
		row=r;
		col=c;
		id=i;
		depth=d;
	}
        bool	isLogical(int p,int q)
	{
	      if(row>=0&&row<p&&col>=0&&col<q)
	      return true;
              return false;	      
	}
};
int main()
{
	freopen("input.txt","r",stdin);
	int n;
	cin>>n;
	for(int i=0;i<n;i++)
	{
		int p,q;
		cin>>p>>q;
		bool **visited;
		visited=new bool *[p];
		for(int i=0;i<p;i++)
		{
			visited[i]=new bool[q];
			for(int j=0;j<q;j++)
			{
				visited[i][j]=false;
			}
		}
		stack<Node> mystack;
		Node start(0,0,0,0);
		mystack.push(start);
		visited[start.row][start.col]=true;
		const int final=p*q;
		int *output=new int[final*2];
		output[0*0+1]=0;
		output[0*0]=0;
		int last=-1;
		while(mystack.empty()==false&&mystack.size()<final)
		{
			Node temp=mystack.top();
			cout<<temp.row+1<<" "<<temp.col+1<<endl;
			bool flag=false;
			for(int j=last+1;j<8;j++)
			{
				Node next(temp.row+direct[j][0],temp.col+direct[j][1],j,temp.depth+1);

				if(next.isLogical(p,q)&&visited[next.row][next.col]==false)
				{
                                     mystack.push(next);
				     visited[next.row][next.col]=true;
				     flag=true;
				     output[2*next.depth+1]=next.row;
				     output[2*next.depth]=next.col;
				     break;
				}
			}
			if(flag)
			{
                             last=-1;
			}
			else
			{
				mystack.pop();
				if(mystack.empty())
					break;
				visited[temp.row][temp.col]=false;
				last=temp.id;
			}
		}
		if(mystack.empty())
			cout<<"impossible"<<endl;
		else if(mystack.size()==final)
		{
			for(int j=0;j<final;j++)
			{
				cout<<output[2*j+1]+'A'<<output[2*j];
			}
		}
	}
}