求C++“修道士与野人”问题的程序

人工智能 野人与传教士c++程序，能运行~

这个是以前写的野人与传教士的c程序，在win-tc下运行通过，由于其中有中文字符，显示可以会有乱码：
#include
#include

#define maxloop 100 /* 最大层数，对于不同的扩展方法自动调整取值 */
#define pristnum 3
#define slavenum 3

struct SPQ{ int sr,pr; /* 船运行一个来回后河右岸的野人、传教士的人数 */
int sl,pl; /* 船运行一个来回后河左岸的野人、传教士的人数 */
int ssr,spr; /* 回来（由左向右时）船上的人数 */
int sst,spt; /* 去时（由右向左时）船上的人数 */
int loop; /* 本结点所在的层数 */
struct SPQ *upnode ,*nextnode;/* 本结点的父结点和同层的下一个结点的地址 */
}spq;
int loopnum;/* 记录总的扩展次数 */
int openednum;/* 记录已扩展节点个数 */
int unopenednum;/* 记录待扩展节点个数 */
int resultnum;
struct SPQ *opened;
struct SPQ *oend;
struct SPQ *unopened;
struct SPQ *uend;
struct SPQ *result;
void initiate();
void releasemem();
void showresult();
void addtoopened(struct SPQ *ntx);
int search();
void goon();
int stretch(struct SPQ* ntx);
void recorder();
void main()
{
int flag; /* 标记扩展是否成功 */
for( ; ; )
{
initiate();
flag = search ();
if(flag == 1)
{
recorder();
releasemem();
showresult();
goon();
}
else
{
printf("无法找到符合条件的解");
releasemem();
goon();
}
}
}
void initiate()
{
int x;
char choice;
uend = unopened = (struct SPQ*)malloc(sizeof(spq));
if(uend==NULL)
{
printf("
内存不够！
");
exit(0);
}
unopenednum=1;
openednum=0;
unopened -> upnode = unopened; /* 保存父结点的地址以成链表 */
unopened -> nextnode = unopened;
unopened -> sr = slavenum;
unopened -> pr = pristnum;
unopened -> sl = 0;
unopened -> pl = 0;
unopened -> sst = 0;
unopened -> spt = 0;
unopened -> ssr = 0;
unopened -> spr = 0;
unopened -> loop = 0;
printf("题目：设有n个传教士和m个野人来到河边，打算乘一只船从右岸到左岸去。
");
printf("该船的负载能力为两人。在任何时候，如果野人人数超过传教士人数，野人
");
printf("就会把传教士吃掉。他们怎样才能用这条船安全的把所有人都渡过河去?
");
printf("
默认的n、m值皆为3
");
for(;;)
{
printf("
是否修改？(Y/N)");
scanf("%s",&choice);
choice=toupper(choice);
if(choice=='Y')
{
printf("
请输入传教士人数");
for(;;)
{
scanf("%d",&x);
if(x>0)
{
unopened -> pr = x;
break;
}
else printf("
输入值应大于0！
请重新输入");
}
printf("
请输入野人人数");
for(;;)
{
scanf("%d",&x);
if(x>0)
{
unopened -> sr = x;
break;
}
else printf("
输入值应大于0！
请重新输入");
}
break;
}
if(choice=='N')break;
}
}

int search()
{
int flag;
struct SPQ *ntx; /* 提供将要扩展的结点的指针 */
for( ; ; )
{
ntx = unopened; /* 从待扩展链表中提取最前面的一个 */
if(ntx->loop == maxloop)
return 0;
addtoopened(ntx); /* 将ntx加入已扩展链表，并将这个节点从待扩展链表中去掉 */
flag = stretch(ntx); /* 对ntx进行扩展,返回-1,0,1 */
if(flag == 1)
return 1;
}
}

int stretch(struct SPQ *ntx)
{
int fsr , fpr ; /* 在右岸上的人数 */
int fsl , fpl ; /* 在左岸上的人数 */
int sst , spt ; /* 出发时在船上的人数 */
int ssr , spr ; /* 返回时船上的人数 */
struct SPQ *newnode;
for (sst = 0 ; sst <= 2 ; sst++) /* 讨论不同的可能性并判断是否符合条件 */
{ fsr = ntx -> sr;
fpr = ntx -> pr;
fsl = ntx -> sl;
fpl = ntx -> pl;
if ((sst <= fsr) && (( 2 - sst) <= fpr))/* 满足人数限制 */
{ spt = 2 - sst;
fsr = fsr - sst;
fpr = fpr - spt;
if((fpr == 0) && (fsr == 0))/* 搜索成功 */
{
newnode = (struct SPQ*) malloc (sizeof(spq));
if(newnode==NULL)
{
printf("
内存不够！
");
exit(0);
}
newnode -> upnode = ntx; /* 保存父结点的地址以成链表 */
newnode -> nextnode = NULL;
newnode -> sr = 0;
newnode -> pr = 0;
newnode -> sl = opened -> sr;
newnode -> pl = opened -> pr;
newnode -> sst = sst;
newnode -> spt = spt;
newnode -> ssr = 0;
newnode -> spr = 0;
newnode -> loop = ntx -> loop + 1;
oend -> nextnode = newnode;
oend = newnode;
openednum++;
return 1;
}
else if ((fpr - fsr) * fpr >= 0) /* 判断是否满足传教士人数必须大于或等于野人人数 */
{
fsl = fsl + sst;
fpl = fpl + spt;
for (ssr = 0 ; ssr <= 1 ; ssr++) /* 返回 */
{
int ffsl , ffpl;
if ((ssr <= fsl) && ((1 - ssr) <= fpl))
{
spr = 1 - ssr;
ffsl = fsl - ssr;
ffpl = fpl - spr;
if ((ffpl - ffsl) * ffpl >= 0)
{ /* 若符合条件则分配内存并付值 */
int ffsr , ffpr;
ffsr = fsr + ssr;
ffpr = fpr + spr;
newnode = (struct SPQ*) malloc (sizeof(spq));
if(newnode==NULL)
{
printf("
内存不够！
");
exit(0);
}
newnode -> upnode = ntx; /* 保存父结点的地址以成链表 */
newnode -> sr = ffsr;
newnode -> pr = ffpr;
newnode -> sl = ffsl;
newnode -> pl = ffpl;
newnode -> sst = sst;
newnode -> spt = spt;
newnode -> ssr = ssr;
newnode -> spr = spr;
newnode -> loop = ntx -> loop + 1;
uend -> nextnode = newnode;
uend = newnode;
unopenednum++;
}
}
}
}
}
}
return 0;
}

void addtoopened(struct SPQ *ntx)
{
unopened = unopened -> nextnode;
unopenednum--;
if (openednum == 0 )
oend = opened = ntx;
oend -> nextnode = ntx;
oend = ntx;
openednum++;
}

void recorder()
{
int i , loop;
struct SPQ *newnode;
struct SPQ *ntx;
loop = oend -> loop;
ntx = oend;
resultnum = 0;
for( i = 0 ; i <= loop ; i++ )
{
newnode = (struct SPQ*) malloc (sizeof(spq));
if(newnode==NULL)
{
printf("
内存不够！
");
exit(0);
}
newnode -> sr = ntx -> sr;
newnode -> pr = ntx -> pr;
newnode -> sl = ntx -> sl;
newnode -> pl = ntx -> pl;
newnode -> sst = ntx -> sst;
newnode -> spt = ntx -> spt;
newnode -> ssr = ntx -> ssr;
newnode -> spr = ntx -> spr;
newnode -> nextnode = NULL;
ntx = ntx -> upnode;
if(i == 0)
result = newnode;
newnode -> nextnode = result;
result = newnode;
resultnum++;
}
}

void releasemem()
{
int i;
struct SPQ* nodefree;
for ( i = 1 ; i < openednum ; i++ )
{
nodefree = opened;
opened = opened -> nextnode;
free(nodefree);
}
for ( i = 0 ; i < unopenednum ; i++ )
{
nodefree = unopened;
unopened = unopened -> nextnode;
free(nodefree);
}
}

void showresult()
{
int i;
int fsr , fpr ; /* 在右岸上的人数 */
int fsl , fpl ; /* 在左岸上的人数 */
struct SPQ* nodefree;
printf("%d个传教士",result -> pr);
printf("%d个野人",result -> sr);
printf("%d个传教士",result -> pl);
printf("%d个野人",result -> sl);
for ( i = 1 ; i < resultnum ; i++ )
{
nodefree = result;
result = result -> nextnode;
free(nodefree);
printf("

左岸人数 船上人数及方向 右岸人数
");
printf("第%d轮
",i);
fpl = result -> pl - result -> spt + result -> spr;
fpr = result -> pr - result -> spr;
fsl = result -> sl - result -> sst + result -> ssr;
fsr = result -> sr - result -> ssr;
printf("传教士%8d%8d spt,fpr);
printf("野 人%8d%8d sst,fsr);
printf("传教士%8d%8d->%8d
",result -> pl,result -> spr,result -> pr - result -> spr);
printf("野 人%8d%8d->%8d
",result -> sl,result -> ssr,result -> sr - result -> ssr);
}
printf("
全体传教士和野人全部到达对岸");
free(result);
}

void goon()
{
char choice;
for(;;)
{
printf("是否继续？(Y/N)
");
scanf ("%s" , &choice);
choice=toupper(choice);
if(choice=='Y')break;
if(choice=='N')exit(0);
}
}

你把问题看简单了。你的程序有几个问题：
int boatf(int im,int ic,int ii)在这个函数中改变的im和ic的值只是改变的两个临时变量的值，并没有改变全局变量im和ic的值。你可以把前两个参数去掉。
还有，你的for循环并不是可以正确遍历所有情况的。
我写了一个程序，tc2.0通过了。在执行到第145种方案时成功。
程序中case的几个顺序请不要任意改动，因为ltor和rtol函数中他们有对应关系。
本题目一共有5的13次方种方案，我的算法能排除很多非法方案。当然，我的算法不是最好的，希望高手能提供更高效的算法。
做这个程序累坏了我几万个脑细胞，楼主给多加点分吧！谢谢了！
#include/*定义N为所用步数，先定为6步*/#define N 6/*分别为左岸和右岸的im，ic数*/int iml, imr, icl, icr;/*定义sn为左右岸的移动的每一步*/int sn[N+N-1] = {0};void ltor(int i)/* left to right */{ switch (i) { case 0: iml--; icl--; printf("%dim %dic | im + ic --> | %dim %dic
", iml, icl, imr, icr); imr++; icr++; break; case 1: iml -= 2; printf("%dim %dic | im + im --> | %dim %dic
", iml, icl, imr, icr); imr += 2; break; case 2: icl -= 2; printf("%dim %dic | ic + ic --> | %dim %dic
", iml, icl, imr, icr); icr += 2; break; case 3: iml--; printf("%dim %dic | im --> | %dim %dic
", iml, icl, imr, icr); imr++; break; case 4: icl--; printf("%dim %dic | ic --> | %dim %dic
", iml, icl, imr, icr); icr++; break; default: printf("error
"); }}void rtol(int i)/* right to left */{ switch (i) { case 0: imr--; icr--; printf("%dim %dic | 0; i--) /* 每位元素超过4则置零，并向前一位进一*/ { if (sn[i] > 4) { sn[i] = 0; sn[i - 1]++; } else break; } if (sn[0] > 5) /*sn遍历一遍则返回0，否则返回1*/ return 0; else return 1;}void restart(void)/* restart the work */{ imr = icr = 0; iml = icl = 3;}void main() { int i, step, found = 0; unsigned long n = 0; /* The NUM of the plans */ do { i = 0; step = N - 1; n++; restart(); ltor(sn[i]); while ((step--) || !(iml == 0 && icl == 0)) { i++; rtol(sn[i]); if (sn[i] == sn[i - 1]) { printf("The %ldth plan to R is not perfect!
", n); break; } if ((imr > 0 && imr 0 && iml 0 && imr 0 && iml < icl) || iml < 0 || icl < 0) { printf("The %ldth plan to R is fail!
", n); break; } } if (iml == 0 && icl == 0) { printf("The plan to Pass the river is success!
"); getchar(); break; } } while ( set ( i ));}

struct INFO
{
int nSavage; // 岸边野人的数量 开始为3 全部到对岸为0
int nBoanerges; // 岸边传教士的数量 开始为3 全部到对岸为0
int nSide; // 船的位置 在此岸为-1 彼岸为1
int nMoveSavage; // 渡河的野人的数量，用于递归时记录操作状态
int nMoveBoanerges; // 渡河的传教士的数量，用于递归时记录操作状态
INFO* pPrevious;
INFO* pNext;
};

// 判断是否有下一个满足条件的渡河方案
bool GetNextMove(INFO* pInfo)
{
// 渡船的优先顺序
// 此岸数量多优先，野人优先，彼岸数量少优先，传教士优先。
const int nStoreCount = 5;
struct STORE
{
int nSavage;
int nBoanerges;
};

STORE listStore[nStoreCount];
if (pInfo-> nSide == -1)
{
listStore[0].nSavage = 2;
listStore[0].nBoanerges = 0;
listStore[1].nSavage = 1;
listStore[1].nBoanerges = 1;
listStore[2].nSavage = 0;
listStore[2].nBoanerges = 2;
listStore[3].nSavage = 1;
listStore[3].nBoanerges = 0;
listStore[4].nSavage = 0;
listStore[4].nBoanerges = 1;
}
else
{
listStore[0].nSavage = 0;
listStore[0].nBoanerges = 1;
listStore[1].nSavage = 1;
listStore[1].nBoanerges = 0;
listStore[2].nSavage = 0;
listStore[2].nBoanerges = 2;
listStore[3].nSavage = 1;
listStore[3].nBoanerges = 1;
listStore[4].nSavage = 2;
listStore[4].nBoanerges = 0;
}

int iStart;
if (pInfo-> nMoveSavage == 0 && pInfo-> nMoveBoanerges == 0)
{
iStart = 0;
}
else
{
for (iStart=0; iStart <nStoreCount; iStart++)
{
if (pInfo-> nMoveSavage == listStore[iStart].nSavage && pInfo-> nMoveBoanerges == listStore[iStart].nBoanerges)
break;
}
iStart++;
}

if (iStart < nStoreCount)
{
int i;
for (i=iStart; i <nStoreCount; i++)
{
int nSideSavage = pInfo-> nSavage + listStore[i].nSavage * pInfo-> nSide;
int nSideBoanerges = pInfo-> nBoanerges + listStore[i].nBoanerges * pInfo-> nSide;
int nBesideSavage = 3 - nSideSavage;
int nBesideBoanerges = 3 - nSideBoanerges;

// 传教士数量大于等于野人或为零
if ((nSideSavage <=nSideBoanerges || nSideBoanerges == 0) &&
(nBesideSavage <=nBesideBoanerges || nBesideBoanerges == 0) &&
nSideSavage> =0 && nSideBoanerges> =0 && nBesideSavage> =0 && nBesideBoanerges> =0)
{
// 如果本此解等于上次，放弃
if (pInfo-> pPrevious != NULL)
{
if (pInfo-> pPrevious-> nMoveBoanerges == listStore[i].nBoanerges &&
pInfo-> pPrevious-> nMoveSavage == listStore[i].nSavage)
continue;
}
break;
}
}
if (i < nStoreCount)
{
pInfo-> nMoveSavage = listStore[i].nSavage;
pInfo-> nMoveBoanerges = listStore[i].nBoanerges;
return true;
}
}

return false;
}

// 递归函数
bool Ship(INFO* pInfo)
{
if (GetNextMove(pInfo))
{
INFO* pNew = new INFO;
pNew-> nSavage = pInfo-> nSavage + pInfo-> nMoveSavage * (pInfo-> nSide);
pNew-> nBoanerges = pInfo-> nBoanerges + pInfo-> nMoveBoanerges * (pInfo-> nSide);
pNew-> nSide = (pInfo-> nSide) * (-1);
pNew-> pPrevious = pInfo;
pNew-> pNext = NULL;
pNew-> nMoveSavage = 0;
pNew-> nMoveBoanerges = 0;
pInfo-> pNext = pNew;
if (pNew-> nSavage == 0 && pNew-> nBoanerges == 0) return true; // 完成
return Ship(pNew);
}
else
{
INFO* pPre = pInfo-> pPrevious;
if (pPre == NULL) return false; // 无解
delete pInfo;
pPre-> pNext = NULL;
return Ship(pPre);
}
return true;
}

int main(int argc, char* argv[])
{
INFO* pHead = new INFO;
pHead-> nSavage = 3;
pHead-> nBoanerges = 3;
pHead-> nSide = -1;
pHead-> pPrevious = NULL;
pHead-> pNext = NULL;
pHead-> nMoveSavage = 0;
pHead-> nMoveBoanerges = 0;

if (Ship(pHead))
{
printf( "渡河过程如下：\n ");
INFO* pInfo = pHead;
while (pInfo-> pNext)
{
printf( "渡河方向：%s 人数：野人%d - 传教士%d 此岸野人数：%d, 传教士数：%d\n ",
(pInfo-> nSide == -1) ? "--> " : " <-- ", pInfo-> nMoveSavage,
pInfo-> nMoveBoanerges, pInfo-> nSavage, pInfo-> nBoanerges);
pInfo = pInfo-> pNext;
}
printf( "渡河完成。 ");
}
else
{
printf( "此题无解！ ");
}

// 删除链表
while (pHead)
{
INFO* pTemp = pHead-> pNext;
delete pHead;
pHead=pTemp;
}
pHead = NULL;

printf( "请结束程序。 ");
return 0;
}

不知道怎么编,

是不是那个,河的两边,野人的数量不能多于修道士,否则,修道士会被野人吃掉,任务失败

rtwe bn

---

凤凰县18666917347： 求C++“修道士与野人”问题的程序 - ？
潘趴复方： struct INFO { int nSavage; // 岸边野人的数量 开始为3 全部到对岸为0 int nBoanerges; // 岸边传教士的数量 开始为3 全部到对岸为0 int nSide; // 船的位置 在此岸为-1 彼岸为1 int nMoveSavage; // 渡河的野人的数量,用于递归时记录操作状态...

凤凰县18666917347： 一个简单的人工智能题:用问题归约法求解野人与修道士的问题野人与修道士的问题:河的左岸有3个野人和3个修道士以及一条小船,修道士们想用这条小船... - ？
潘趴复方：[答案] 问题归约法从目标(要解决的问题)出发,逆向推理,通过一系列变换把初始问题变换为子问题集合和子子问题集合,直至最后归约为一个平凡的本原问题集合.已知条件1:最后一次乘船的一定是两人.已知条件2:往与返的组合不能...

凤凰县18666917347： 在河的左岸有三个修道士,三个野人和一条船,修道士想用这条船把所有的人都运到河对岸,但要受到以下条件限 - ？
潘趴复方： 1.修道士A划船,运野人甲过河修道 2.修道士A划船,运修道士B过河修道士A划船回.同时将野人甲带回. 3.修道士A划船,运修道士C过河修道士A划船回. 4.修道士A划船,运野人甲过河修道士A划船回. 5.修道士A划船,运野人乙过河修道士A划船回. 6.修道士A划船,运野人丙过河

凤凰县18666917347： 一个简单的人工智能题:用问题归约法求解野人与修道士的问题 - ？
潘趴复方： 问题归约法从目标(要解决的问题)出发,逆向推理,通过一系列变换把初始问题变换为子问题集合和子子问题集合,直至最后归约为一个平凡的本原问题集合.已知条件1:最后一次乘船的一定是两人.已知条件2:往与返的组合不能重复,否...

凤凰县18666917347： 急求传教士与野人过河算法设计要设计方法和程序追加分 - ？
潘趴复方： 野人过河问题算法分析 野人过河问题属于人工智能学科中的一个经典问题,问题描述如下: 有三个牧师(也有的翻译为传教士)和三个野人过河,只有一条能装下两个人的船,在河的任何一方或者船上,如果野人的人数大于牧师的人数,那么...

凤凰县18666917347： 急!求野人过河问题用c语言实现!! - ？
潘趴复方： 本来没打算发出来.送你算了.下面的程序称得上perfect,程序在dev-c++下编译通过.#include <stdio.h>#include <stdlib.h>#include <ctype.h>#define maxloop 100 /* 最大层数,对于不同的扩展方法自动调整取值 */#define pristnum 3 /*初始化时设...

凤凰县18666917347： 求C语言高手解答,这是传教士野人过河问题.程序运行总是出现无解死循环,看不出问题,求大神解答! - ？
潘趴复方： 陷入死循环,说明 在退出循环的语句中出现了问题.不知道你如何定义的栈结构,所以你自己分析下,while((s->top...

凤凰县18666917347： 传教士和野人渡河问题 - ？
潘趴复方： 第一步:先过去两个食人兽,再回来一个;(或先过去一个传教士和一个兽,传教士回来) 第二步:再过去两个食人兽,再回来一个; (再过去两个兽,再回来一个兽,下面的一样) 第三步:过去两个传教士,再回来一个传教士和一个食人兽; 第四步:再过去两个传教士,回来一个食人兽; 第五步:过去两个食人兽,再回来一个食人兽; 第六步:最后两个食人兽过去.希望能解决你的疑问O∩_∩O~

凤凰县18666917347： 人工智能 野人与传教士c++程序,能运行？
潘趴复方： http://so.csdn.net/bbsSearchResult.aspx?q=%e9%87%8e%e4%ba%ba%e4%b8%8e%e4%bc%a0%e6%95%99%e5%a3%ab%e8%bf%87%e6%b2%b3&amp;p=0csdn的论坛,自己找,有答案.

凤凰县18666917347： 用状态空间表示表示问题的一般步骤 - ？
潘趴复方： . 搜索搜索(Search),设法在庞大状态空间图中找到目标.主要分为两类性质的搜索:基本搜索,是一种没有任何经验和知识起作用的、由某种规则所确定的非智能性的搜索; 启发式搜索(Heuristic Search):其特点在于是一种有准备的...