从前有一条河，河的左岸有m个传教士(Missionary)和m个野人(Cannibal)，和一艘最多可乘n人的小船。约定左岸，右岸和船上或者没有传教士，或者野人数量少于传教士，否则野人会把传教士吃掉。
编程，接收m和n，搜索一条可让所有的野人和传教士安全渡到右岸的方案。
我们先假设左岸有3个传教士和3个野人，小船最多可乘2人。把当前左岸的状态抽象为：
(3,3,1)
前两个"3"代表左岸有3个传教士和3个野人，1代表船在左岸。把每一次可行的渡船方案作为算符。比如，在初始状态，让1个传教士和1个野人上船并渡到右岸，这一算符可表示为：
(1,1)
算符的两位数分别代表要移动的传教士，野人的数量；把人移到没有船的岸边并且改变状态向量中船的值。
对于固定大小的小船，算符的数量是一定的：
class Move {
public :
int missionary; // 要移动的传教士数量
int cannibal; // 野人
};
class MoveGroup {
public :
Move move[500]; // 算符集
int numMove; // 可用算符的总数
MoveGroup(int MAX_ON_BOAT) { // 利用构造器求算符集
int m, c, i = 0;
for (m = 0; m <= MAX_ON_BOAT; m++)
for (c = 0; c <= MAX_ON_BOAT; c++)
if (c==0 && m!=0) {
move[i].missionary=m;
move[i].cannibal=0;
i++;
}
else if (m==0 && c!=0) {
move[i].missionary=0;
move[i].cannibal=c;
i++;
}
else if (m+c<=MAX_ON_BOAT && m+c!=0 && m>=c) {
move[i].missionary = m;
move[i].cannibal = c;
i++;
}
numMove = i;
}
};
创建一个MoveGroup 对象
MoveGroup mg(2);
即可得到当小船最多可乘2人时的算符集。
这个程序所要做的，就是通过这个已知的算符集，将初始状态(3,3,1)转变为最终状态(0,0,0)。我们应将状态作为搜索的元素。
构建类时应注意，并不是每个算符对于任意的状态都是可以应用的，这需要对应用算符后的安全性进行检查，以判断这一算符对当前状态是否可用；同时，类中也要包含一个判断当前状态是否是最终节点(0,0,0)的方法；当然”==”，”=”这两个运算符以及null值，这是调用dso.h时所不可或缺的。（详见源文件）
class ElemType : Move { // 继承 Move 类，获得传教士，野人数据成员。
private :
bool boat; // 船是否在左岸？
public :
ElemType* flag; // 这个后边再说，暂时用不到
ElemType(int MAX_PEOPLE) { // 创建初始状态
missionary = cannibal = MAX_PEOPLE;
boat = true;
flag = NULL;
}
ElemType() {}
bool operator ==(ElemType e) {
return this->missionary==e.missionary &&
this ->cannibal==e.cannibal &&
this ->boat==e.boat;
}
void operator =(ElemType e) {
this->missionary = e.missionary;
this->cannibal = e.cannibal;
this->boat = e.boat;
this->flag = e.flag;
}
ElemType friend operator >>(ElemType source, Move &mv) {
// 移动操作，通过重载运算符 “>>” ，你将在 isSafe(ElemType) 中见到用法。
ElemType result;
if(source.boat == 1) {
result.missionary = (source.missionary -= mv.missionary);
result.cannibal = (source.cannibal -= mv.cannibal);
result.boat = 0;
} else {
result.missionary = (source.missionary += mv.missionary);
result.cannibal = (source.cannibal += mv.cannibal);
result.boat = 1;
}
return result;
}
bool isSafe(Move &mv, int MAX_PEOPLE) {
// 判断当前状态在进行 mv 操作后还是不是安全状态
if( (boat==1&&(missionary-mv.missionary < 0 ||
cannibal-mv.cannibal < 0)) ||
(boat==0&&(missionary+mv.missionary > MAX_PEOPLE ||
cannibal+mv.cannibal > MAX_PEOPLE)) )
return false;
else {
ElemType temp = *this >> mv;
if( temp.missionary==0 || temp.missionary==MAX_PEOPLE ||
(temp.missionary>=temp.cannibal &&
MAX_PEOPLE-temp.missionary >= MAX_PEOPLE-temp.cannibal))
return true;
else return false;
}
}
bool isSuccess() { return missionary==0 && cannibal==0 && boat==0; }
//isSuccess() 判断当前状态是否为最终节点
int getM() { return missionary; }
int getC() { return cannibal; }
int getB() { return boat; }
void print() {
cout <<'('<< missionary <<','<< cannibal
<<','<< boat <<')' << endl;
}
};
const ElemType null(0); //(0,0,1) 这是不会出现的
void print(ElemType &e) { e.print(); } // 打印函数
至此，我们已经完成了对问题的描述。
搜索过程采用较简单的“宽度优先盲目搜索”，算法框图如下：
#include "dso.h"
typedef ElemType Status;
当得到了一个最终节点(0,0,0)时，如果我们前边的操作没有保存路径的话，那么我们就只知道这个问题有解，而不知道解的具体路径。还记得在定义ElemType时那个旗子指针吗，用它保留它的父节点的地址，问题就解决了。
open，closed表均通过队列实现。由于对扩展节点要保存指针，所以closed表需要一个获得尾指针的方法。
class Queuex : public Queue {
public :
ElemType* getTailPtr() {
if(Queue::isEmpty()) return NULL;
QNode* temp = front->next;
while(temp != rear) {
if(temp->next == rear) return &temp->next->node;
temp = temp->next;
}
return &temp->node;
}
};
搜索得到的答案也保存在一个队列里，但我们知道：当得到一个最终节点时，根据它的指向父节点的指针向上搜索得到的是一个反的解序列，这里使用一个临时的栈，可以将解的顺序调换过来。
class Answer : public Queue {
private :
int max_people;
public :
Answer(int MAX_PEOPLE, int MAX_ON_BOAT) {
Queue open;
Queuex closed;
Stack temp; // 这是所使用的临时栈
Status s0(MAX_PEOPLE); // 这是初始节点
MoveGroup mg(MAX_ON_BOAT); // 这是算符集
// 以下是搜索算法：
open.enqueue(s0);
max_people = MAX_PEOPLE;
while(!open.isEmpty()) {
Status s1 = open.dequeue(), s2;
closed.enqueue(s1);
ElemType* ptr = closed.getTailPtr();
// 得到被扩展的父节点的指针 ptr
for(int i = 0; i < mg.numMove; i++)
if( s1.isSafe(mg.move[i], MAX_PEOPLE) ) {
s2 = s1 >> mg.move[i];
if(closed.locate(s2) == INFEASIBLE) {
s2.flag = ptr; open.enqueue(s2);
}
if(s2.isSuccess()) {
// 搜索到最终节点后的操作
closed.enqueue(s2);
while(s2.flag != NULL) {
temp.push(s2); s2 = *(s2.flag);
}
this->enqueue(s0);
while(!s2.isSuccess()) {
s2 = temp.pop(); this->enqueue(s2);
}
return;
}
}
}
}
void show() { this->traverse(print); }
};
就要成功了，通过下面这个声明就可以得到MAX_PEOPLE个传教士，MAX_PEOPLE个野人，每艘船上最多乘坐MAX_ON_BOAT人的解：
Answer answer(MAX_PEOPLE, MAX_ON_BOAT);
通过下面的调用可以列出整个解的过程：
answer.show();
源程序 >>> （在控制台输入MAX_PEOPLE和MAX_ON_BOAT，然后输出mco.log演示移动过程）
以前编过一个C语言版的，不过似乎有内存泄漏的八哥，这个版本应该是没问题了。
完成于2006年6月18日
