我做的骑士移动问题，不好意思，运行了一夜，结果也没出来！我不过我感觉自己做的是对的!

[earphone]

#include <iostream.h>
#include <iomanip.h>

int board[ 8 ][ 8 ] = { 0 };
int horizontal[ 8 ] = { 2, 1, -1, -2, -2, -1, 1, 2 };
int vertical[ 8 ] = { -1, -2, -2, -1, 1, 2, 2, 1 };
int TStop = 1;
int MoveStop = 64;

int MoveKnight( int, int );
void PrintFun( void );
void Initialization( void );

int main()
{
MoveKnight( 3, 4 );
PrintFun();
return 0;
}

int MoveKnight( int CurrentRow, int CurrentColumn )
{
if ( ::TStop == 64 ){
PrintFun();
Initialization();
PrintFun();
return 0;
}

for ( int Stop = 0; Stop < 8; Stop++ ){

if (( CurrentColumn + ::horizontal[ Stop ] ) < 0 || ( CurrentColumn + ::horizontal[ Stop ] ) > 7||
( CurrentRow + ::vertical[ Stop ] ) < 0 || ( CurrentRow + ::vertical[ Stop ] ) > 7 ||
( ::board[ CurrentRow + ::vertical[ Stop ] ][ CurrentColumn + ::horizontal[ Stop ] ] != 0))
continue;

::board[ CurrentRow + ::vertical[ Stop ] ][ CurrentColumn + ::horizontal[ Stop] ] = ::TStop++;
PrintFun();
if ( MoveKnight( ( CurrentRow + ::vertical[ Stop ] ), (CurrentColumn + ::horizontal[ Stop] )) == 0 ){
::board[ CurrentRow ][ CurrentColumn ] = MoveStop--;
PrintFun();
return 0;
}
}

::board[ CurrentRow ][ CurrentColumn ] = 0;
::TStop--;
return 1;
}


void PrintFun( )
{
for ( int Row = 0; Row < 8; Row++ ){
for ( int Culumn = 0; Culumn < 8; Culumn++ ){
cout << setw( 3 ) << board[ Row ][ Culumn ];
}
cout << endl;
}
cout << "_____________________________________________" << endl;
return;
}

void Initialization( )
{
for ( int Row = 0; Row < 8; Row++ ){
for ( int Culumn = 0; Culumn < 8; Culumn++ ){
::board[ Row ][ Culumn ] = 0;
}
}
return;
}

[allenwu]

就是我们一般所说的“马步遍历问题”
#include "stdafx.h"
#include "iostream.h"
const M=100;
int chess[M][M],count,m,n,gi,gj;
struct{
int i;
int j;
}d[8]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1}};
struct{
short i;
short j;
}trace[M*M];

void move(int i,int j,int step){
int s=0;
do{
if(i+d[s].i>=0&&i+d[s].i<m&&j+d[s].j>=0&&j+d[s].j<n)
if(chess[i+d[s].i][j+d[s].j]==0){
chess[i+d[s].i][j+d[s].j]=1;
trace[step].i=i+d[s].i;
trace[step].j=j+d[s].j;
if((step+1)==m*n){
count++;
cout<<"Solution"<<count<<endl;
for(gi=0;gi<step;gi++){
cout<<"["<<trace[gi].i<<","<<trace[gi].j<<"]";
if((gi+1)%8==0)
cout<<endl;
}
cout<<endl<<endl;
}
else move(i+d[s].i,j+d[s].j,step+1);
chess[i+d[s].i][j+d[s].j]=0;
}
s++;
}while(s<8);
}


main(){
int i,j,step;
do{
cout<<"Input m n i j(m<=0 to quit!)"<<endl;
cin>>m>>n>>i>>j;
if(m<=0)
break;
if(n<=0||i<0||j<0||i>=m||j>=n){
cout<<"Error input"<<endl;
continue;
}
count=0,step=1;
trace[0].i=i;
trace[0].j=j;
for(int ii=0;ii<m;ii++)
for(int jj=0;jj<n;jj++)
chess[ii][jj]=0;
chess[i][j]=1;
cout<<"The chessbroad:"<<m<<"*"<<n<<"\tand the start point is["<<i<<","<<j<<"]"<<endl;
move(i,j,step);
cout<<"The total is"<<count<<endl;
}while(1);
}
乱了
我也没办法

[winstarr]

那么乱，也没有把主要问题给我们说出来，
当然要是仔细去看才可以，
等我看清楚了！

[耙子]

8*8 的确很费时间。
你可以先试验一下，5*5, 6*6的这个有几秒就出来了

[weya]

不好意思，没看你程序。先问一下，你是求一个解还是所有解？

[earphone]

up

[我不懂电脑]

我做的，几秒种就出来了呀。

[耙子]

三十年古都
你用递归写的吗？

[我不懂电脑]

我用贪婪法写的。

[耙子]

哦！递归比较慢，但是算法简单。

[耙子]

三十年咕嘟

贪婪法的最优方向你怎么选择的？
能简要说明一下你的算法吗？
我不要源码。
谢谢

[earphone]

我要求的是第一个算。
噢，忘写函数功能了
int MoveKnight( int int )
它接收两个值。是当然骑士的位置。返回值是，当然骑士所在的位置是否还有下一步可走，如果没有下一步可走，则测试是否走够64步{
if ( ::TStop == 64 )这个地方我认为应该是65。因为第64步是可以走通的}

[我不懂电脑]

贪婪法的最优方向要根据计算得到，基本思想就是棋盘上不同格子的访问概率不同，先访问最难访问到的地方，使访问平均难度下降。

[耙子]

greedy search我也用过，但都是简单的应用。
我开个帖子，你仔细点说明一下好吗。

[ltt321]

"贪婪法的最优方向要根据计算得到，基本思想就是棋盘上不同格子的访问概率不同，先访问最难访问到的地方，使访问平均难度下降。"
上面的C++大学教程上也有，不只大家看了没有。

[fangrk]

不错，有做程序员的吃苦耐劳的基本要素：）

[earphone]

大家说我上面的递归对嘛！？

[liushmh]

你可能找个没有结果的位置开始的
我当年用赛扬333的机器 60个小时都没有出来（绝对没有夸张）
如果走63步要1分钟
62步要5秒的样子
你可以试试63步，和62步的情况来检查你的程序是否出错

[ltt321]

我刚写了一个，不知道是不是贪婪法

# include < iostream.h >
# include < iomanip.h >
# include < time.h >
# include < stdlib.h >
void mai ( );

void main ( ) {
while ( 1 ) {
mai ( );
cin.get ( );
}
}

/////////////////////////////////////////////////////////////////

void mai ( ) {

int Zao ( int [ ] );
void print ( int [ ] [ 8 ] , int , int , int );

srand ( time ( NULL ) );

int row = rand ( ) % 7;
int column = rand ( ) % 7;

int x = 1;

int board [ 8 ] [ 8 ] = { 0 } ; // 棋盘

int CurrentRow = row; // 骑士初始位置，行
int CurrentColumn = column; // 骑士初始位置，列
board [ CurrentRow ] [ CurrentColumn ] = 1; // 走过的标记

int horizontal [ 8 ]; // 列
int vertical [ 8 ]; // 行

horizontal [ 0 ] = 2; // 8种移动方式之列
horizontal [ 1 ] = 1;
horizontal [ 2 ] = -1;
horizontal [ 3 ] = -2;
horizontal [ 4 ] = -2;
horizontal [ 5 ] = -1;
horizontal [ 6 ] = 1;
horizontal [ 7 ] = 2;

vertical [ 0 ] = -1; // 8种移动方式之行
vertical [ 1 ] = -2;
vertical [ 2 ] = -2;
vertical [ 3 ] = -1;
vertical [ 4 ] = 1;
vertical [ 5 ] = 2;
vertical [ 6 ] = 2;
vertical [ 7 ] = 1;

int accessibility [ 8 ] [ 8 ] = { { 2,3,4,4,4,4,3,2 },
{ 3,4,6,6,6,6,4,3 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 3,4,6,6,6,6,4,3 } ,
{ 2,3,4,4,4,4,3,2 } }; // 棋盘相应点的难易值
int a = 1;

while ( x ) {

int nan [ 8 ] = { -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 }; // 保存难易值

for ( int moveNumber = 0; moveNumber < 8; moveNumber++ )

if ( CurrentRow + vertical [ moveNumber ] >= 0 && // 检查行，列，是否走过
CurrentRow + vertical [ moveNumber ] < 8 &&

CurrentColumn + horizontal [ moveNumber ] >= 0 &&
CurrentColumn + horizontal [ moveNumber ] < 8 &&

board [ CurrentRow + vertical [ moveNumber ] ]
[ CurrentColumn + horizontal [ moveNumber ] ] == 0 )

nan [ moveNumber ] = accessibility [ CurrentRow + vertical [ moveNumber ] ]
[ CurrentColumn + horizontal [ moveNumber ] ];// 难易值



int moveNumber1; // 最难走的移动方式
moveNumber1 = Zao ( nan );

if ( moveNumber1 == 9 ) {
if ( a == 64 ) {
cout << "走完了全部的格子!!!" << endl;
x = 0;
}
else {
cout << "走不动了!一共走了" << a << "步" << endl;
x = 0;
}
}
else {
a++;
CurrentRow += vertical [ moveNumber1 ]; // 相应移动方式移动后行的变化
CurrentColumn += horizontal [ moveNumber1 ]; // 相应移动方式移动后列的变化
board [ CurrentRow ] [ CurrentColumn ] = a; // 走过的标记
}
}
print ( board , a , row , column );

}

/////////////////////找出最难走的//////////////////////

int Zao ( int nan [ ] ) {
int temp = 9;
for ( int i = 0; i < 8; i++ )
if ( temp > nan [ i ] && nan [ i ] != -1 )
temp = nan [ i ];

for ( int j = 0; j < 8; j++ )
if ( temp == nan [ j ] ) {
temp = j;
break;
}
return temp;
}

////////////////////输出走过的格子//////////////

void print ( int b [ ] [ 8 ] , int a , int r , int c ) {

cout << "初始位置是: 行 " << r + 1 << " 列 " << c + 1 << endl;

for ( int x = 0; x < 8; x++ )
cout << " " << x + 1 << "列";
cout << endl;

for ( int i = 0; i < 8; i++ ) {
cout << i + 1 << "行";

for ( int j = 0; j < 8; j++ ) {
cout << setw ( 4 ) << b [ i ] [ j ] << " ";
}

cout << endl;
}
}

[ltt321]

在请earphone (窗子) 说一下你的程序里::是啥意思，为啥全局变量前都要用::

[ltt321]

又改进了一下，可以把1到64格全部走通一变，并把结果输出到文件，全部用时最快0.16秒，感觉挺高兴的。

# include < iostream.h >
# include < iomanip.h >
# include < time.h >
# include < stdlib.h >
# include < fstream.h >
bool mai ( int , int );

void main ( ) {

int a = 0;
while ( a != 8 ) {
int b = 0;

while ( b != 8 )
if ( mai ( a , b ) )
b++;
a++;
}
cout << "从第1格到第64格全部走完了！！！" << endl;
}

/////////////////////////////////////////////////////////////////

bool mai ( int row , int column ) {

clock_t tick;
tick = clock ( );
double t = ( double ) tick / CLK_TCK;

int Zao ( int [ ] );
void print ( int [ ] [ 8 ] , int , int , int , int , double );

// srand ( time ( NULL ) );

// int row = rand ( ) % 7;
// int column = rand ( ) % 7;

int x = 1;
static xx = 0;

int board [ 8 ] [ 8 ] = { 0 } ; // 棋盘

int CurrentRow = row; // 骑士初始位置，行
int CurrentColumn = column; // 骑士初始位置，列
board [ CurrentRow ] [ CurrentColumn ] = 1; // 走过的标记

int horizontal [ 8 ]; // 列
int vertical [ 8 ]; // 行

horizontal [ 0 ] = 2; // 8种移动方式之列
horizontal [ 1 ] = 1;
horizontal [ 2 ] = -1;
horizontal [ 3 ] = -2;
horizontal [ 4 ] = -2;
horizontal [ 5 ] = -1;
horizontal [ 6 ] = 1;
horizontal [ 7 ] = 2;

vertical [ 0 ] = -1; // 8种移动方式之行
vertical [ 1 ] = -2;
vertical [ 2 ] = -2;
vertical [ 3 ] = -1;
vertical [ 4 ] = 1;
vertical [ 5 ] = 2;
vertical [ 6 ] = 2;
vertical [ 7 ] = 1;

int accessibility [ 8 ] [ 8 ] = { { 2,3,4,4,4,4,3,2 },
{ 3,4,6,6,6,6,4,3 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 4,6,8,8,8,8,6,4 } ,
{ 3,4,6,6,6,6,4,3 } ,
{ 2,3,4,4,4,4,3,2 } }; // 棋盘相应点的难易值
int a = 1;

while ( x ) {

int nan [ 8 ] = { -1 , -1 , -1 , -1 , -1 , -1 , -1 , -1 }; // 保存难易值

for ( int moveNumber = 0; moveNumber < 8; moveNumber++ )

if ( CurrentRow + vertical [ moveNumber ] >= 0 && // 检查行，列，是否走过
CurrentRow + vertical [ moveNumber ] < 8 &&

CurrentColumn + horizontal [ moveNumber ] >= 0 &&
CurrentColumn + horizontal [ moveNumber ] < 8 &&

board [ CurrentRow + vertical [ moveNumber ] ]
[ CurrentColumn + horizontal [ moveNumber ] ] == 0 )

nan [ moveNumber ] = accessibility [ CurrentRow + vertical [ moveNumber ] ]
[ CurrentColumn + horizontal [ moveNumber ] ];// 难易值



int moveNumber1; // 最难走的移动方式
moveNumber1 = Zao ( nan );
// print ( board , a , row , column );
if ( moveNumber1 == 9 ) {
if ( a == 64 ) {
// cout << "走完了全部的格子!!!" << endl;
x = 0;
print ( board , a , row , column , xx , t );
// cin.get ( );
xx++;
return true;
}
else {
// cout << "走不动了!一共走了" << a << "步" << endl;
x = 0;
xx++;
return false;
}
}
else {
a++;
CurrentRow += vertical [ moveNumber1 ]; // 相应移动方式移动后行的变化
CurrentColumn += horizontal [ moveNumber1 ]; // 相应移动方式移动后列的变化
board [ CurrentRow ] [ CurrentColumn ] = a; // 走过的标记
}
}
}

/////////////////////找出最难走的//////////////////////

int Zao ( int nan [ ] ) {

int temp = 9;
for ( int i = 0; i < 8; i++ )
if ( temp > nan [ i ] && nan [ i ] != -1 )
temp = nan [ i ];

if ( temp != 9 ) {
int temp2 [ 8 ] = { 0 }; // 纪录满足条件的元素的下标
int t = 0; // 满足条件下标++
for ( int j = 0; j < 8; j++ )
if ( temp == nan [ j ] ) {
temp2 [ t ] = j + 1;
t++;
} // temp2中按顺序保存了nan中满足条件的元素的下标

int temp3 = 0; // 纪录满足条件的元素个数

for ( int jj = 0; jj < 8; jj++ )
if ( temp2 [ jj ] != 0 )
temp3++;

int temp4 = rand ( ) % temp3; // 随机选取满座条件的下标

temp = temp2 [ temp4 ] - 1;
}
return temp;
}

////////////////////输出走过的格子//////////////

void print ( int b [ ] [ 8 ] , int a , int r , int c , int xx , double t ) {

double tt = 0;
tt += t;


ofstream outfile ( "ltt.txt" , ios::app ); // 输出到文件
struct tm *ltt;
time_t ltt2;
time ( <t2 );
ltt = localtime ( <t2 ); // 输出日期

outfile << "初始位置是: 行 " << r + 1 << " 列 " << c + 1 << " 一共走了" << xx << "回" << endl;

for ( int x = 0; x < 8; x++ )
outfile << " " << x + 1 << "列";
outfile << endl;

for ( int i = 0; i < 8; i++ ) {
outfile << i + 1 << "行";

for ( int j = 0; j < 8; j++ ) {
outfile << setw ( 4 ) << b [ i ] [ j ] << " ";
}
outfile << endl;
}
outfile << "走了"<< tt << "秒" << endl;
outfile << asctime ( ltt );
outfile << endl;
}