以前玩过汉罗塔,现在第一次编写,也没见过算法,所以不知道是不是对的,我这编写的是一个汉罗塔演示程序,即给出层数,演示如何得到结果的过程!帮忙看下,我没编译调试,大家一起帮帮忙,看看,谢谢了

#include <iostream>
#include <windows.h>
using namespace std;

//-----------函数声明--------------
void Instruct();
void display(int row);
void OtoTw(int n,int row);
void ThtoO(int n,int row);
void ThtoTw(n,int row);
void TwtoTh(int n,int row);
void TwtoO(int n,int row);
void ThtoTw(n,int row);
void TwtoTh(int n,int row);
void TwtoO(int n,int row);
int main()
{
//定义一个字符串类型的容器
vector<string>s(10);
s[0]=" _ ";
s[1]=" ___ ";
s[2]=" _____ ";
s[3]=" _______ ";
s[4]=" _________ ";
s[5]=" ___________ ";
s[6]=" _____________ ";
s[7]=" _______________ ";
s[8]=" _________________ ";
s[9]=" ___________________ ";
string space=" ";
vector<vector<string>>sArr;
//-------------用户界面开始-----------
Instruct();
int row; //用户选择排数
char choice; //用户选择是否继续
do
{
do
{
cout<<"Input the number of HanLuoTa's row:";
cin>>row;
sArr.resize(row);
//-------------初始化汉罗塔----------
//将第3个柱子设置为全部满，第1和2为空（space定义的那样）
for(;row;row--)
{
sArr[row].resize(3);
sArr[row][0]=s[row];
sArr[row][1]=space;
sArr[row][2]=space;
}
if(row<0||row>10){cout<<"***Error***! Out of range! Input again!\n";}
}while(row<0||row>10);
/*因为是递归函数，所以首先返回的肯定是最深层的内容。这样结实够清楚了吧？*/
display(row);
OtoTh(row,row);
cout<<endl<<endl;
cout<<"Go again or exit?\n";
"Press any key without y to come again:";
cin>>choice;if(choice=='y'||choice=='Y')b=0;
}while (b);
system("pause");
return 0;
}
//游戏说明
void Instruct()
{
cout<<"This is an old game being palyed by many years \n"
"which named HanLuoTa ! \n"
"You should just inputed a number to determine how many row \n"
"the HanLuoTa have!\n";
}
void display(int row)
//-----输出汉偌塔目前情景-----
{
for(int i=0;i<row;i++)
for(int j=0;j<3;j++)
cout<<sArr[i][j];
Sleep(1000);
system("cls");
}

row->总层数 n->转移几层
void OtoTh(int n,int row)
//1->3：将第1个柱子上的盘移动n个到第3个上
{
//--------如果移动的排数递归到不是1个盘，执行下面操作---------
if(n!=1)
{
//-----先将n-1个盘从第1个柱子移到第2个柱子上（怎么实现呢？继续下面的递归）
OtoTw(n-1);
//-----再将第n个盘（最下面的盘）移动到第3个柱子上
sArr[row-1][0].swap(sArr[n][2]);//这就是一个字符串交换的过程。
//再将第2个柱子上的n-1个盘移动到第3个柱子上（怎么实现呢？继续下面的递归）
TwtoTh(n-1);
//显示现在情景
}
//--------如果移动的排数递归到只剩1个盘，执行下面操作（直接移动到目标盘上）---------
else sArr[row-1][0].swap(sArr[n][2]);
display(row);
}
void OtoTw(int n,int row)
//1->2：将第1个柱子上的盘移动n个到第2个上
{
//-----先将n-1个盘从第1个柱子移到第3个柱子上（怎么实现呢？继续下面的递归）
OtoTh(n-1);
//-----再将第n个盘（最下面的盘）移动到第2个柱子上
sArr[row-1][0].swap(sArr[n][1]);
//再将第2个柱子上的n-1个盘移动到第3个柱子上（怎么实现呢？继续下面的递归）
ThtoTw(n-1);
//显示现在情景
display(row);
}
//---------下面的跟上面的解释差不多，整体上是一个递归函数--------
void ThtoO(int n,int row)
//3->1
{
ThtoTw(n-1);
sArr[row-1][2].swap(sArr[n][0]);
TwtoO(n-1);
display(row);
}
void ThtoTw(n,int row)
//3->2
{
ThtoO(n-1);
sArr[row-1][2].swap(sArr[n][1]);
OtoTw(n-1);
display(row);
}

void TwtoTh(int n,int row)
//2->3
{
//---------解释同上-------------
if(n!=1)
{
TwtoO(n-1);
sArr[row-1][1].swap(sArr[n][2]);
OtoTh(n-1);
}
else sArr[row-1][1].swap(sArr[n][2]);
display(row);
}
void TwtoO(int n,int row) //2->1
{
TwtoTh(n-1);
sArr[row-1][1].swap(sArr[n][0]);
ThtoO(N-1);
display(row);
}

[此贴子已经被作者于2006-5-22 23:00:02编辑过]

我现在是在学windows编程.但是我上面的思想就是你说的那样的啊

我首先假设游戏中有n个盘,那么从第一个柱子移动n-1个盘到第2个柱子,怎么样去完成这呢?那就必须先把n-2个盘移动到第3个柱子,当第n-1个盘被从第一个柱子移动到第2个柱子时,再把第3个柱子上的n-2个盘移动到第2个盘上去,怎么实现呢?就又象刚才这样,递归上去,直到第1和第2个柱子上累计只有一个盘时,只需要将这个盘移动到第3个柱子上就可以了,但是这样深层递归最先输出的将是最后移动到第3个柱子以后的情形,所以我就反过来写,从第三个柱子往第一个柱子上运,这样应该就可以得到答案了,但是你说的算法其实很简单?那我写的思路是复杂咯?

兄弟们有的进来说句话啊，不要嫌太长啊！一句话，我马上就写注释，只要你们需要

你可以用八皇后的方法,什么前掷法?..
我没看过算法，不知道八皇后的方法

以后来看帖的，不要直接一句：编译有问题
可以看完思路，提意见，或则哪里明显错误指出

上午弄了下，编译通过了
#include <iostream>
#include <vector>
#include <windows.h>
using namespace std;

//-----------函数声明--------------
void Instruct();
void display(int row);
void OtoTw(int n,int row);
void OtoTh(int n,int row);
void ThtoO(int n,int row);
void ThtoTw(int n,int row);
void TwtoTh(int n,int row);
void TwtoO(int n,int row);

vector < vector<string> > sArr;
static int one,two,three;//分别记录3个柱子上的盘子数量
int main()
{
//定义一个字符串类型的容器
vector<string>s(10);
s[0]=" _ ";
s[1]=" ___ ";
s[2]=" _____ ";
s[3]=" _______ ";
s[4]=" _________ ";
s[5]=" ___________ ";
s[6]=" _____________ ";
s[7]=" _______________ ";
s[8]=" _________________ ";
s[9]=" ___________________ ";
string space=" ";
//-------------用户界面开始-----------
Instruct();bool b=1;
int row; //用户选择排数
char choice; //用户选择是否继续
do
{
do
{
cout<<"Input the number of HanLuoTa's row:";
cin>>row;
if(row<0||row>10){cout<<"***Error***!\n Out of range! Input again!\n";continue;}
sArr.resize(row);
//-------------初始化汉罗塔----------
//将第3个柱子设置为全部满，第1和2为空（space定义的那样）
for(int i=0;i<row;i++)
{
sArr[i].resize(3);
sArr[i][0]=s[i];
sArr[i][1]=space;
sArr[i][2]=space;

}
one=row;two=0;three=0;
}while(row<0||row>10);

/*因为是递归函数，所以首先返回的肯定是最深层的内容。这样结实够清楚了吧？*/
display(row);
//cout<<sArr[0][1];
OtoTh(row,row);
cout<<"Go again or exit?\n"
"Press any key to come again(y to quit):";
cin>>choice;if(choice=='y'||choice=='Y')b=0;
}while (b);
system("pause");
return 0;
}
//游戏说明
void Instruct()
{
cout<<"*_*_*_*_*_Instruction_*_*_*_*_*_*\n"
"This is an old game being palyed by many years "
"which named HanLuoTa ! \n"
"You should just inputed a number to determine how "
"many rows the HanLuoTa have!\n\n"
"***GAME BEGIN***\n";
}
void display(int row)
//-----输出汉偌塔目前情景-----
{
Sleep(1000);
system("cls");
for(int i=0;i<row;i++)
{
for(int j=0;j<3;j++)
{cout<<sArr[i][j];}
cout<<endl;
}
}

//row->总层数 n->转移几层
void OtoTh(int n,int row)
//1->3：将第1个柱子上的盘移动n个到第3个上
{
//--------如果移动的排数递归到不是1个盘，执行下面操作---------
if(n!=1)
{
//-----先将n-1个盘从第1个柱子移到第2个柱子上（怎么实现呢？继续下面的递归）
OtoTw(n-1,row);
//-----再将第n个盘（最下面的盘）移动到第3个柱子上
sArr[row-one][0].swap(sArr[row-three-1][2]);//这就是一个字符串交换的过程。
one--;three++;
display(row);
//再将第2个柱子上的n-1个盘移动到第3个柱子上（怎么实现呢？继续下面的递归）
TwtoTh(n-1,row);
//显示现在情景
}
//--------如果移动的排数递归到只剩1个盘，执行下面操作（直接移动到目标盘上）---------
else
{
sArr[row-one][0].swap(sArr[row-three-1][2]);
one--;three++;
display(row);
}
}
void OtoTw(int n,int row)
//1->2：将第1个柱子上的盘移动n个到第2个上
{
if(n!=1)
{
//-----先将n-1个盘从第1个柱子移到第3个柱子上（怎么实现呢？继续下面的递归）
OtoTh(n-1,row);
//-----再将第n个盘（最下面的盘）移动到第2个柱子上
sArr[row-one][0].swap(sArr[row-two-1][1]);
one--;two++;
display(row);
//再将第2个柱子上的n-1个盘移动到第3个柱子上（怎么实现呢？继续下面的递归）
ThtoTw(n-1,row);
}
else
{
sArr[row-one][0].swap(sArr[row-two-1][1]);
one--;two++;
//显示现在情景
display(row);
}

}
//---------下面的跟上面的解释差不多，整体上是一个递归函数--------
void ThtoO(int n,int row)
//3->1
{
if(n!=1)
{
ThtoTw(n-1,row);
sArr[row-three][2].swap(sArr[row-one-1][0]);
one++;three--;
display(row);
TwtoO(n-1,row);
}
else
{
sArr[row-three][2].swap(sArr[row-one-1][0]);
three--;one++;
display(row);
}
}
void ThtoTw(int n,int row)
//3->2
{
if(n!=1)
{
ThtoO(n-1,row);
sArr[row-three][2].swap(sArr[row-two-1][1]);
three--;two++;
display(row);
OtoTw(n-1,row);
}
else
{
sArr[row-three][2].swap(sArr[row-two-1][1]);
three--;two++;
display(row);
}
}

void TwtoTh(int n,int row)
//2->3
{
//---------解释同上-------------
if(n!=1)
{
TwtoO(n-1,row);
sArr[row-two][1].swap(sArr[row-three-1][2]);
three++;two--;
display(row);
OtoTh(n-1,row);
}
else
{
sArr[row-two][1].swap(sArr[row-three-1][2]);
three++;two--;
display(row);
}
}
void TwtoO(int n,int row) //2->1
{
if(n!=1)
{
TwtoTh(n-1,row);
sArr[row-two][1].swap(sArr[row-one-1][0]);
one++;two--;
display(row);
ThtoO(n-1,row);
}
else
{
sArr[row-two][1].swap(sArr[row-one-1][0]);
two--;one++;
display(row);
}

}

还不错，就是汉诺塔的直观描述