有没有做过三个传教士和三个野人过河【人工智能吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：67,457贴子：
有没有做过三个传教士和三个野人过河收藏
有没有做过三个传教士和三个野人过河的人工智能解决方法的兄弟啊，如果写过报告就更好了
人工智能_总监级一线名师全程面授,保证教学质量,21周超长课程,项目实战案例式教学.人工智能,千锋名师带你O基础入门,一站式掌握必知必会全部技能,点击申请2周免费试听.
求参考和指导
这也算是经典问题了
这个问题的答案网上很多，你直接从网上搜一个出来就行。经典的解法是穷举，把野人传教士所有的组合列出来，从中搜索出能过河的组合。穷举法的核心是列出所有的组合，也就是状态空间，这里给出一个简单列出组合办法。把组合分成三个部分：此岸，船上，彼岸。所有的组合就是此岸X船上X彼岸，按照船往返的次序从这个组合集合中选出合理的组合，问题就求解。此岸的组合数：4X4=16船上的组合数：4对岸的组数：16状态空间总数：16X4X16我们可以做个表来解这个题，第一行是表头，分别是此岸，船上，彼岸，每个表头对应的列填可能的野人教士组合。事实上这个表最多列出的组合是16X3。把这个表用程序表达，就可以上机计算。
上面说的不对。此岸和船上约束了彼岸，状态空间是16X4,表也不对，应当列是此岸，行是船上，表与状态空间对应。
这可是老故事啦
传教士坐船 野人游泳扶着船！或者反过来！ 绝对不会淹死！
登录百度帐号启发式搜索 野人与传教士_中华文本库
方法二:启发式搜索 构造启发式函数为: ?6.01 ? ML ? CL 满足规则时 f =?...四、实验结果 方法一的实验结果: 传教士野人过河问题 第 1 种方法: 第 1 ...
(3) 寻找一个启发式函数引导规则的选用 右岸总人数 6 – ML – CL 两岸中传教士数目&=野人数目 f= –∞ 其它 f=2 P11 (2,2,0) f=1 Q11 (3,3,1...
(3) 寻找一个启发式函数引导规则的选用 右岸总人数 6 – ML – CL 两岸中传教士数目&=野人数目 f= –∞ 其它 f=2 P11 (2,2,0) f=1 Q11 (3,3,1...
传教士与野人过河问题_数学_自然科学_专业资料。传教士...(3) 寻找一个启发式函数引导规则的选用 右岸总人数...我们应该划去不合法的状态,这样可以加快搜索 求解的...
( ML , CL +2, BL +1 ) 两岸中传教士数目&=野人数目 增加一个启发式...值得注意的是按照题目规定的条件,我们应该划去不合 法的状态,这样可以加快搜索...
人工智能 野人和传教士问题_理学_高等教育_教育专区...(3) 寻找一个启发式函数引导规则的选用 右岸总人数...我们应该划去不合法的状态,这样可以加快搜索 求解的...
启发式搜索,利用“启发性信息”引导的搜索。 3、什么是问题的解?什么是最优解...14、传教士和野人问题。有三个传教士和三个野人一起来到河边准备渡河,河边有一...
传教士过去 1 人,野人过去 1 人第 2 次:右岸到左岸,传教士过去 1 人,...4.观察运行过程和搜索顺序,理解启发式搜索的原理。在下拉框中选择演示 “15 ...
7 (3 3 1) → (传教士 野人 左右) (2 2 0) (3 2 0) (3 1 0)...? ? ? ? 什么是搜索 回溯策略 图搜索策略 无信息图搜索过程 启发式搜索过程...
第二章2 启发式搜索_计算机软件及应用_IT/计算机_专业资料。问题求解的基本方法...(n) ≡0 实例№ 19 传教士和野人问题 N=5,K&=3 左岸传教士人数M,野人C...传教士与野人过河问题_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
传教士与野人过河问题
阅读已结束，下载本文需要
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
还剩9页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢传教士和野人过河问题-CSDN论坛
数据结构与算法
传教士和野人过河问题
M个传教士，C个野人，M&=C，船上能载2人，要求过河时，传教士不能少于野人个数，否则被吃掉。怎么过河？
我看网上说这好像是一个经典问题，请问哪儿有详细的解法和源代码啊
今天360的笔试题~~~~~考这个了，感觉小本好像吃亏不少
好贴自己顶
1、首先由1传教士+1野蛮人过河，船在目的地；
2、此时始发地传教士&野蛮人，目的地传教士=野蛮人；
3、无论后续如何装卸，都必须是1个人回，两个人去，那么可以经过一定的等效转换，也就是一回一去的周期内，只过一个人；
4、由于目的地两种人数相等，因此需要考虑先运传教士；
5、循环运送传教士、野蛮人、传教士、野蛮人，知道始发地只剩下传教士；
6、由一个野蛮人不断将所有传教士运往目的地。
题目本身很简单，非要用代码来表达，似乎没有什么逻辑是需要程序计算的；
如果是强调编程的题目，那就应该是教程序如何来解答这个题目，而不能像人思考那样把所有的特例都利用起来，程序解逻辑应该包含一个变量：船的容量N为各种值时，程序依然工作，否则真不知道程序在这个题目还能写些什么！
你这个是M&C的情况，这个很好做，如果是M==C呢？我想知道怎么做，（m=1,2,3的网上好多)引用&2&楼&&的回复:1、首先由1传教士+1野蛮人过河，船在目的地；
2、此时始发地传教士&野蛮人，目的地传教士=野蛮人；
3、无论后续如何装卸，都必须是1个人回，两个人去，那么可以经过一定的等效转换，也就是一回一去的周期内，只过一个人；
4、由于目的地两种人数相等，因此需要考虑先运传教士；
5、循环运送传教士、野蛮人、传教士、野蛮人，知道始发地只剩下传教士；
6、由一个野蛮人不断将所有传教士运往目的地。
http://hi.baidu.com/urzalknsyzchrur/item/538f25f19417adb630c199e1
我也考到这道题，题目我都理解错了，我以为靠岸船上的人不参与吃人or被吃，，
好像是a*算法
很基础的人工智能例题，定义出状态与转换规则，就可以等价变换为一道搜索题
比如可以用2维坐标(传教士，狼)来表示数量，那刚开始的时候，出发地就是S=(M,C)，目的地是T=(0,0)，船上的人是B=(b1,b2)。所以这道题就变成了:遍历所有T=T+B,&T-B的情况，最终让T变为(M,C)，相应的S=(0,0)
还有些限制条件，“船上能载2人”：b1+b2&=2
“过河时，传教士不能少于野人个数，否则被吃掉”:在整个搜索过程中，对于当时的S,T,B，有
出发地:s1=0&或&s1&=s2
目的地:t1=0&或&t1&=t2
船上:b1=0&或&b1&=b2（题目没说清楚b1能不能为0)
很显然这个用广度优先搜索最合适。类似还有什么农夫狐狸鸡白菜的问题，把坐标扩展到四维就行了。
我的答案，详细见我博客：
#include&&iostream&
#include&&vector&
#include&&string&
#include&&stdio.h&
using&namespace&
bool&flag&=&&//true:表示在右岸
vector&string&&&//记录已经访问过的状态
bool&dfs(&int&M,&int&C,&int&m,&int&c){
if(&M&0||C&0||m&0||c&0)&&&//非法
if(&(M&&C&M)&||(m&&c&m))&&&//野人会吃牧师
if(&flag&&M==0&&C==0&||(!flag&&m==0&&c==0))&&//全部运输过去
//检查该节点是否出现过
char&s[30];
if(&!flag&)
sprintf(&s,&"M=%d,C=%d,m=%d,c=%d,boat=left",&M,C,m,c);
sprintf(&s,&"M=%d,C=%d,m=%d,c=%d,boat=right",&m,c,M,C);
string&str(s);
for(&int&i=0;&i&visit.size();&i++)
if(&visit[i]==str)&&&&&&&&&&&&&&&&&&&&&//该状态已经搜索过了
visit.push_back(str);
if(&dfs(&m+2,&c,&M-2,C)&){
printf("2,0\n");
printf("%s\n",s);
else&if(&dfs(&m,&c+2,&M,&C-2)&){
printf("0,2\n");
printf("%s\n",s);
else&if(&dfs(&m+1,&c+1,&M-1,&C-1)&){
printf("1,1\n");
printf("%s\n",s);
else&if(&dfs(&m+1,&c,&M-1,&C)){
printf("1,0\n");
printf("%s\n",s);
else&if(&dfs(&m,&c+1,&M,&C-1)){
printf("0,1\n");
printf("%s\n",s);
visit.pop_back();
int&main(){
char&s[30];
int&M=6,C=6,m=0,c=0;
sprintf(&s,&"M=%d,C=%d,m=%d,c=%d,boat=left",&M,C,m,c);
printf("%s\n",s);
if(!dfs(M,C,0,0))
cout&&&&"Can&not&find&the&solution."&&
我估计也死在这道题上了，所以360没给我打电话..&这个还是有点深度的.
这题出的太坑爹了，实际上有些情况是无解的，比如44以上MC相同这个就没解，其他基本2楼正解了
是啊。m=c=4压根就不可能了。
所以c=4的，m必须大于4
引用&2&楼&&的回复:1、首先由1传教士+1野蛮人过河，船在目的地；
2、此时始发地传教士&野蛮人，目的地传教士=野蛮人；
3、无论后续如何装卸，都必须是1个人回，两个人去，那么可以经过一定的等效转换，也就是一回一去的周期内，只过一个人；
4、由于目的地两种人数相等，因此需要考虑先运传教士；
5、循环运送传教士、野蛮人、传教士、野蛮人，知道始发地只剩下传教士；
6、由一个野蛮人不断将所有传教士运往目的地。
你的解答不对。
野人过去，对岸的野人数就大于传教士的数目了
2楼的确错了，m&c简单的方法是
每次都是1传教士一野蛮人过河，奇数轮传教士留下野蛮人回，偶数轮野蛮人留下传教士回，最后如果有剩余传教士在用1野蛮人接即可
这个问题应该是，每次船上都是一个传教士和一个野人，过河后根据奇偶分别留传教士和野人，反复循环。。。等最后一个野人过河后，不在留下，让他过河接完所有剩下的传教士即可。
某侧只剩下野人，没有传教士的话，会不会跑啊？:)
该回复于 08:41:17被版主删除
引用&14&楼&&的回复:这个问题应该是，每次船上都是一个传教士和一个野人，过河后根据奇偶分别留传教士和野人，反复循环。。。等最后一个野人过河后，不在留下，让他过河接完所有剩下的传教士即可。+
引用&7&楼&&的回复:我的答案，详细见我博客：
http://blog.csdn.net/huangxy10/article/details/8066408
C/C++&code
#include&&iostream&
#include&&vector&
#include&&string&
#include&&stdio.h&
using&namespace&
bool&flag&=&……
牛B啊每次船上都是一个传教士和一个野人
用穷举大法吧，哈哈
好像很厉害
好贴自己顶
这个太简单了吧，需要M次，返程需要将m－c个传教士送回。
经典算法题
该回复于 08:44:07被版主删除
该回复于 08:44:11被版主删除
该回复于 08:44:16被版主删除
该回复于 08:44:22被版主删除
该回复于 08:44:27被版主删除
该回复于 08:44:43被版主删除
该回复于 08:44:48被版主删除
该回复于 08:44:54被版主删除
人工智能没学过啊，是不是研究生的课程啊？
rengongzhineng?
引用&15&楼&&的回复:某侧只剩下野人，没有传教士的话，会不会跑啊？:)
兄弟我认真学习了
我在人工智能课本里看到过这个题，是说用状态图表示过河
该回复于 08:45:04被版主删除
引用&9&楼&&的回复:这题出的太坑爹了，实际上有些情况是无解的，比如44以上MC相同这个就没解，其他基本2楼正解了
该回复于 08:45:11被版主删除
该回复于 08:45:19被版主删除
人工智能没学过啊，是不是研究生的课程啊？
没学过人工智能
七楼好算法
每次船上都是一个传教士和一个野人
第一次传教士到目的
第二次传野人到目的
第三次传教士到目的
第四次传野人到目的
依次循环下去即可。
我喜欢小马过河
引用&7&楼&&的回复:我的答案，详细见我博客：
http://blog.csdn.net/huangxy10/article/details/8066408
C/C++&code
#include&&iostream&
#include&&vector&
#include&&string&
#include&&stdio.h&
using&namespace&
bool&flag&=&……
这个很强大！
为啥m&c都为4的时候无解？
第一次不运牧师(m)，只运两个野蛮人(Y)过河，左岸2*Y+4*m，右岸2*Y
第二次只运两个牧师过河，左岸2*Y+2*m，右岸2*Y+2*m
然后就简单了，第三次&第四次分别运送1*Y+1*m过河，然后空船返回，左岸和右岸人数变化分别是
1*Y+1*m&&&3*Y+3*m
0&&&&&&&&&4*Y+4*m
这题和“狼、羊与萝卜过河”显然不一样的，因为前者可以空载的，但是后者决不可以空载！！&
空船不能自己返回的。。。至少得有人吧
引用&48&楼&&的回复:为啥m&c都为4的时候无解？
第一次不运牧师(m)，只运两个野蛮人(Y)过河，左岸2*Y+4*m，右岸2*Y
第二次只运两个牧师过河，左岸2*Y+2*m，右岸2*Y+2*m
然后就简单了，第三次&第四次分别运送1*Y+1*m过河，然后空船返回，左岸和右岸人数变化分别是
1*Y+1*m&&&3*Y+3*m
0&&&&&&&&&4*Y+4*m
这题和“狼、羊与萝卜过河……
引用&48&楼&&的回复:为啥m&c都为4的时候无解？
第一次不运牧师(m)，只运两个野蛮人(Y)过河，左岸2*Y+4*m，右岸2*Y
第二次只运两个牧师过河，左岸2*Y+2*m，右岸2*Y+2*m
然后就简单了，第三次&第四次分别运送1*Y+1*m过河，然后空船返回，左岸和右岸人数变化分别是
1*Y+1*m&&&3*Y+3*m
0&&&&&&&&&4*Y+4*m
这题和“狼、羊与萝卜过河……
空船返回。。。。你好厉害
状态图----》直接解法（广度搜索）----》switch/case结构
状态图----》状态矩阵----》遍历算法----》搜索函数
我喜欢小马过河~
坚持每天一贴。。。
新手，为了获得积分下软件
空船过河。。这还是问题不。。。
该回复于 10:05:25被版主删除
该回复于 10:05:26被版主删除
有点意思,不过用程序做的话貌似挺麻烦吧,至少现在的我弄不出来
引用&4&楼&&的回复:看看这个
http://hi.baidu.com/urzalknsyzchrur/item/538f25f19417adb630c199e1
算法可以看看，但是他的答案有点问题
1，1商1从过河，商回，
2，2从过河，1回，
3，2商过河，1商1从回，
4，2商过河，从回，
5，2从过河，
6，再回，接最后一个随从过河。&
野人过河问题属于人工智能学科中的一个经典问题，问题描述如下：&有三个牧师（也有的翻译为传教士）和三个野人过河，只有一条能装下两个人的船，在河的任何一方或者船上，如果野人的人数大于牧师的人数，那么牧师就会有危险.&你能不能找出一种安全的渡河方法呢？&
一、算法分析&
先来看看问题的初始状态和目标状态，假设和分为甲岸和乙岸：&
初始状态：甲岸，3野人，3牧师；&
乙岸，0野人，0牧师；&
船停在甲岸，船上有0个人；&
目标状态：甲岸，0野人，0牧师；&
乙岸，3野人，3牧师；&
船停在乙岸，船上有0个人；&
整个问题就抽象成了怎样从初始状态经中间的一系列状态达到目标状态。问题状态的改变是通过划船渡河来引发的，所以合理的渡河操作就成了通常所说的算符，根据题目要求，可以得出以下5个算符（按照渡船方向的不同，也可以理解为10个算符）：&
渡1野人、渡1牧师、渡1野人1牧师、渡2野人、渡2牧师&
算符知道以后，剩下的核心问题就是搜索方法了，本文采用深度优先搜索，通过一个FindNext(…)函数找出下一步可以进行的渡河操作中的最优操作，如果没有找到则返回其父节点，看看是否有其它兄弟节点可以扩展，然后用Process(…)函数递规调用FindNext(…)，一级一级的向后扩展。&
搜索中采用的一些规则如下：&
1、渡船优先规则：甲岸一次运走的人越多越好（即甲岸运多人优先），同时野人优先运走；&
乙岸一次运走的人越少越好（即乙岸运少人优先），同时牧师优先运走；&
2、不能重复上次渡船操作（通过链表中前一操作比较），避免进入死循环;&
3、任何时候河两边的野人和牧师数均分别大于等于0且小于等于3；&
4、由于只是找出最优解，所以当找到某一算符（当前最优先的）满足操作条件后，不再搜索其兄弟节点，而是直接载入链表。&
5、若扩展某节点a的时候，没有找到合适的子节点，则从链表中返回节点a的父节点b，从上次已经选择了的算符之后的算符中找最优先的算符继续扩展b。&
上面是转的
原文&http://blog.csdn.net/wodejiaoao/article/details/5998448
该回复于 13:00:29被版主删除
正在学习当中……
先占个位置！
M==C时好像无解
该回复于 14:27:23被版主删除
引用&69&楼&&的回复:M==C时好像无解
2、3时有解。
实际上，每一次船上必定是一个传教士和一个野人或两个传教士。
要解决的是，
1&此岸谁上船；
2&船到彼岸时谁下船。
条件是两岸任何一边，传教士的人数大于等于野人。M&C&是必要条件。
&&&&if((Ca==0)||(Ma==2))&//如果最后两个都是传教士，一起过去，不再返回
&&&&&&&&Mb++;
&&&&&&&&Mb++;
&&&&&&&&Ma--;
&&&&&&&&Ma--;
&&&&else&if((Ca==0)||((Ca&0)&&&&((Mb==0)||(Mb==Cb)))
&&&&&&&&Mb++;
&&&&&&&&Ma--;
&&&&&&&&Cb++;
&&&&&&&&Ca--;
&&&&sprintf("time=%d,Mb=%d,Cb=%d",&n,Mb,Cb);
实际上，就是此岸还有野人时，每船渡一个传教士和一个野人。
第一船留在彼岸的一定是传教士。也就是说，要保证彼岸的传教士在此后多于或等于野人。因为有先决条件&M&C，所以，任何时间两岸和船上，传教士都不少于野人。
如果传教士比野人多一人以上，最后会在此岸全留下传教士。此时，每船渡两个传教士，返回一人，直至全渡过去。
该回复于 14:33:22被版主删除
真傻，旁边有桥不走，非要坐船
支持，继续加油哈
如果&&野人也会开船的话那44是可以&的
1.两个野人过河&一个野人返回
2.一个野人一个传教士&一个野人返回
7.野人与传教士&不要返回了
1.两个野人过河&一个野人返回
2.一个野人一个传教士&一个野人返回&&//过去就被吃了
这个问题要弄懂，船上的人和岸上的人不能同时计算。否则无解、。。。
引用&78&楼&&的回复:这个问题要弄懂，船上的人和岸上的人不能同时计算。否则无解、。。。
这是你自己的理解，实际上，比如岸上一个野人，船上一个野人一个传教士，船一靠岸，传教士就玩完了，合理的解释就是如此。
该回复于 15:10:34被版主删除
空船当然可以返回，因为船上是有摆渡船夫的。不然“狼&羊和萝卜过河”狼或者是萝卜怎么返回
我也觉得好像很厉害的样子
经典试题，人工智能或者编译原理的有向图都能解
我比较想知道，是两边在任何情况下传道士都必须大于野人的个数还是说只有船在和中央的时候才有这个要求？
这个楼都是牛人，我不会
太复杂太复杂太复杂
太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了太复杂了
不会用绳子将野人捆住？
该回复于 08:33:24被版主删除
支持了，继续阀业
引用&79&楼&&的回复:引用&78&楼&&的回复:
这个问题要弄懂，船上的人和岸上的人不能同时计算。否则无解、。。。
这是你自己的理解，实际上，比如岸上一个野人，船上一个野人一个传教士，船一靠岸，传教士就玩完了，合理的解释就是如此。
对的，本来我也没考虑这个问题然后觉得很简单，后然突然想到这个问题仔细一琢磨觉得难度提高了不少
该回复于 08:33:25被版主删除
我是这样的一种思路，
首先：过河的必须是2人，返回的必须是一个人。否则过河的方法有无数种就没必须来说了（过去一个传教士，回来一个传教士，这样永远都不会结束）。
过程中必须满足两个条件，就是过河的时候两岸的人数传教士必须大于等于野蛮人。（这里仅指的是过河过程中，上下船的时候不算，否则如果M=C，这道题就无解了）
每次来回也就是一个人过河，
在这一次来回过程中，只有一个人过河。
我是用java写的，按照这个思路，我先声明一个PersonList类，保存的是每次渡河后的两岸的人数。
public&class&PersonList&{
private&int&m1=8;//登船口传教士的人数
private&int&m2=8;//目标处传教士的人数
private&int&c1=0;//登船的野蛮人人数
private&int&c2=0;//目标处传教士的人数
public&int&getM1()&{
return&m1;
public&void&setM1(int&m1)&{
this.m1&=&m1;
public&int&getM2()&{
return&m2;
public&void&setM2(int&m2)&{
this.m2&=&m2;
public&int&getC1()&{
return&c1;
public&void&setC1(int&c1)&{
this.c1&=&c1;
public&int&getC2()&{
return&c2;
public&void&setC2(int&c2)&{
this.c2&=&c2;
public&PersonList(int&m1,&int&m2,&int&c1,&int&c2)&{
this.m1&=&m1;
this.m2&=&m2;
this.c1&=&c1;
this.c2&=&c2;
继续楼上的代码，下面是实现类。
package&com.briup.test09;
import&java.util.ArrayL
import&java.util.L
public&class&Test7&{
private&int&m1;//登船口传教士的人数
private&int&m2;//目标处传教士的人数
private&int&c1;//登船的野蛮人人数
private&int&c2;//目标处传教士的人数
private&ArrayList&PersonList&&
public&Test7(){
list=new&ArrayList&PersonList&();
public&void&guohe(PersonList&p){
int&x=(int)&(Math.random()*2);//产生0到2之间的随机数，表示过河的时候传教士的人数,那么2-x就表示过河时野蛮人的人数
int&y=(int)&(Math.random()*2);//产生0到1之间的随机数，表示回来的时候传教士的人数，那么1-y就表示回来的时野蛮人的人数
m1=p.getM1();
c1=p.getC1();
m2=p.getM2();
c2=p.getC2();
//设置循环的结束条件(传教士和野蛮人都过河)
while(m1!=0&&c1!=0){
//&&之前的判断是过河时登船口所剩下的人数比较，&&之后的判断是返回时目标处所剩下的人数比较，这两处的人数传教士都必须不少于野蛮人
if(((m1-x)&=(c1-(2-x)))&&((m2+x-y)&=(c2+(2-x)-(1-y)))){
//如果这两个判断都成功的话，则表示可以，随机的数产生满足条件，则对数据进行修改
m1=m1-x+y;
c1=c1-(2-x)+(1-y);
m2=m2+x-y;
c2=c2+(2-x)-(1-y);
PersonList&person=new&PersonList(m1,&m2,&c1,&c2);
list.add(person);//保存本次的结果到list集合里面
guohe(person);//本次成功，继续进行下一次的过河过程
//如果不满条件的话，则加载最后一个personlist锁存储的数据，也就是上一次的成功后的结果，重新运行本函数，直到成功为止
if(list.size()==0){//先判断是不是第一次运行失败，如果是的话list为空，则输入的p
guohe(list.get(list.size()-1));
public&void&setList(){
for(PersonList&p:list){
System.out.println("第"+i+"次渡河后");
System.out.println("登船口传教士人数m1："+p.getM1());
System.out.println("登船口野蛮人人数c1："+p.getC1());
System.out.println("目标口传教士人数m2："+p.getM2());
System.out.println("目标口野蛮人人数c2："+p.getC2());
public&ArrayList&PersonList&&getArrayList(){
public&static&void&main(String[]&args)&{
Test7&test=new&Test7();
PersonList&p=new&PersonList(8,&0,&8,&0);//初始化未过河的时候人数
test.guohe(p);//方法调用开始
test.setList();
最后的结果我测试了，下面是结果
我的输入是：PersonList&p=new&PersonList(8,&0,&8,&0);//分别指的是过河前的人数，
分别指的是（登船口的传教士，目标口的传教士，登船口的野蛮人，目标口的野蛮人）;
结果我测试了，应该是正确的，当然，我这里的渡河方法只是随机生成的一种，要全列举出来有点麻烦，那个就不写出来了。
下面是测试结果：
第1次渡河后
登船口传教士人数m1：7
登船口野蛮人人数c1：8
目标口传教士人数m2：1
目标口野蛮人人数c2：0
第2次渡河后
登船口传教士人数m1：7
登船口野蛮人人数c1：7
目标口传教士人数m2：1
目标口野蛮人人数c2：1
第3次渡河后
登船口传教士人数m1：6
登船口野蛮人人数c1：7
目标口传教士人数m2：2
目标口野蛮人人数c2：1
第4次渡河后
登船口传教士人数m1：6
登船口野蛮人人数c1：6
目标口传教士人数m2：2
目标口野蛮人人数c2：2
第5次渡河后
登船口传教士人数m1：5
登船口野蛮人人数c1：6
目标口传教士人数m2：3
目标口野蛮人人数c2：2
第6次渡河后
登船口传教士人数m1：5
登船口野蛮人人数c1：5
目标口传教士人数m2：3
目标口野蛮人人数c2：3
第7次渡河后
登船口传教士人数m1：4
登船口野蛮人人数c1：5
目标口传教士人数m2：4
目标口野蛮人人数c2：3
第8次渡河后
登船口传教士人数m1：4
登船口野蛮人人数c1：4
目标口传教士人数m2：4
目标口野蛮人人数c2：4
第9次渡河后
登船口传教士人数m1：3
登船口野蛮人人数c1：4
目标口传教士人数m2：5
目标口野蛮人人数c2：4
第10次渡河后
登船口传教士人数m1：3
登船口野蛮人人数c1：3
目标口传教士人数m2：5
目标口野蛮人人数c2：5
第11次渡河后
登船口传教士人数m1：2
登船口野蛮人人数c1：3
目标口传教士人数m2：6
目标口野蛮人人数c2：5
第12次渡河后
登船口传教士人数m1：2
登船口野蛮人人数c1：2
目标口传教士人数m2：6
目标口野蛮人人数c2：6
第13次渡河后
登船口传教士人数m1：1
登船口野蛮人人数c1：2
目标口传教士人数m2：7
目标口野蛮人人数c2：6
第14次渡河后
登船口传教士人数m1：1
登船口野蛮人人数c1：1
目标口传教士人数m2：7
目标口野蛮人人数c2：7
第15次渡河后
登船口传教士人数m1：0
登船口野蛮人人数c1：1
目标口传教士人数m2：8
目标口野蛮人人数c2：7
至于有的人疑问为什么登船口或的野蛮人比传教士多的问题，其实很简单，因为那一趟回来的那个肯定是野蛮人，所以回来之后的瞬间就形成了登船口的野蛮人比传教士多。但是大家请注意题目，本题描述的是过河时，指的就是过河的这个过程中，而不是上下岸的时候。所以在我列举的这些结果里面只要登船口的人数传教士比野蛮人少一个或者平等或者多都是正确的。在目标口的时候传教士的人数就一定要不少于野蛮人。
花了1个多小时写出来的。思路上其实很简单，就是对代码的运用还不是很熟，所以还是稍微有点棘手。
不知道360要求的是多长时间。
不是M&C么，一直让一个传教士当船工然后野人传教士不断轮换的运送就完了啊
虚心学习的人路过！
源码源码元吗为了你妈逼
貌似很简单的问题
挺！！！！！！！！！！！！！！！
你们大家说的是什么
不明觉厉啊～
http://img.my.csdn.net/uploads//_6449.gif
进来看了一下，倒觉得真有意思！？
最纯粹的Hadoop技术盛会
好的，推荐了
引用&100&楼&&的回复:不是M&C么，一直让一个传教士当船工然后野人传教士不断轮换的运送就完了啊
你想的太简单了。
假设&传教士比野人多一个人。
第一个传教士上船当开船的,岸上剩下的传教士和野人一样多。
第一次拉传教士就不可能了。
那么第一次必须拉野人，但是当你第二次拉野人回来的时候，岸对面的野人就比传教士多了。。。
这个问题问得好啊
之前玩过类似的游戏，现在都用代码啦玩，真有趣，顶一个~~~
引用&45&楼&&的回复:每次船上都是一个传教士和一个野人
第一次传教士到目的
第二次传野人到目的
第三次传教士到目的
第四次传野人到目的
依次循环下去即可。
需要这么麻烦吗&
每次一个野人一个传教士过去&空船回来&什么情况都解决了
空船要是能回来，这个问题没有难度了。
第1次过河，1个M&1个C&一起过去，然后过河的这个C做船夫，回去运输一个C过来，再回去运输一个M过来，再回去运输一个C过来，再回去运输一个M过来，直到岸上剩下M，然后每次运输一个M过来，直至结束
有问题吗？
引用&119&楼&&的回复:需要这么麻烦吗&
每次一个野人一个传教士过去&空船回来&什么情况都解决了
估计没船夫吧，船也不是无人机......
垃圾的360压根儿就没说清题目。
引用&99&楼&&的回复:最后的结果我测试了，下面是结果
我的输入是：PersonList&p=new&PersonList(8,&0,&8,&0);//分别指的是过河前的人数，
分别指的是（登船口的传教士，目标口的传教士，登船口的野蛮人，目标口的野蛮人）;
结果我测试了，应该是正确的，当然，我这里的渡河方法只是随机生成的一种，要全列举出来有点麻烦，那个就不写出来了。
下面是测试结果：
第1次渡河后
登船口传……
你这第一次登船口的C就大于M了，这个把M吃了吗？
虚心学习的人路过！
引用&48&楼&&的回复:为啥m&c都为4的时候无解？
第一次不运牧师(m)，只运两个野蛮人(Y)过河，左岸2*Y+4*m，右岸2*Y
第二次只运两个牧师过河，左岸2*Y+2*m，右岸2*Y+2*m
然后就简单了，第三次&第四次分别运送1*Y+1*m过河，然后空船返回，左岸和右岸人数变化分别是
1*Y+1*m&&&3*Y+3*m
0&&&&&&&&&4*Y+4*m
这题和“狼、羊与萝卜过河……
如果空船能返回，这问题还有啥难的，每次运一个传教士和一个野蛮人，空船返回，最后如果只剩下还有传教士，一船两个，直至运完。
这都不行&？？？当真&吗&&？？&
船不是可以自己运行的，那么，如果M==C，船上那个必须是野人，否则必然会出现目的地或者始发地，野人数大于传教士人数的情况；而船上只能承载两人，所以应该是交替渡传教士和野人
人家又没有限定野人不会开船，一些个人啊，SB的很！！！！
引用&100&楼&&的回复:不是M&C么，一直让一个传教士当船工然后野人传教士不断轮换的运送就完了啊
这确实是一种方法，但是这种方法肯定是错误的，你只考虑了登船的那边的，没考虑到目标口岸的人数。
即使单纯的回答了一种正确答案，估计一般也就没回应了，出题的人主要想考的是解题的算法，而不是单纯结果。
引用&123&楼&&的回复:引用&99&楼&&的回复:
最后的结果我测试了，下面是结果
我的输入是：PersonList&p=new&PersonList(8,&0,&8,&0);//分别指的是过河前的人数，
分别指的是（登船口的传教士，目标口的传教士，登船口的野蛮人，目标口的野蛮人）;
结果我测试了，应该是正确的，当然，我这里的渡河方法只是随机生成的一种，要全列举出来有点麻烦，那个就不写出来了。
下面是测试……
请看完我全部的回复再看。C大约M只是在上下船的时候，而不是渡河的时候。而且出题的人指的肯定仅仅是渡河的时候，要不M=C的话无解，不信你试试。
数据结构我看的头疼
木有几分啊&。几分啊&
有没说传教士一定要大于野人数，不少于&那么等于也可以，所以一个传教士和一个野人两个人坐船过河就好了。
知道船上无论如何装都不会吃人现象，
所以在船上存一个野蛮人，
那么传教士的个数&野蛮人的数量
一次运一个,一个传教士后,一个野蛮人,循环反复。结束。
看到2楼，我不知道对不对，这样在船上岂不是被吃了。所以果断应该两个传教士或者两个野蛮人一起过河，同时保证两岸都满足传教士多过野蛮人即可。
引用&2&楼&&的回复:1、首先由1传教士+1野蛮人过河，船在目的地；
2、此时始发地传教士&野蛮人，目的地传教士=野蛮人；
3、无论后续如何装卸，都必须是1个人回，两个人去，那么可以经过一定的等效转换，也就是一回一去的周期内，只过一个人；
4、由于目的地两种人数相等，因此需要考虑先运传教士；
5、循环运送传教士、野蛮人、传教士、野蛮人，知道始发地只剩下传教士；
6、由一个野蛮人不断将所有传教士运往目的地。
同意7楼说法
好像是a*算法
说实在的，代码生成器的技术含量是最低的，其原理就是字符串拼接，如果做出通用型的，那么势必要涉及到很多配置处理，用起来很麻烦，个人建议把所有配置省略，写属于自己的代码生成器，打开就能用，那才能提高效率。
WPF&我一直看好它的，虽然有人总说它BUG多而不喜。不过WPF的学习难度也不小，本以为很容易上手的，但是思路一改常态，等理解了依赖属性后，估计就可以顺手了。
草，不能回复
很好奇&为什么&M=4的时候&不能过河&
1&一个野人&一个商人&
2&一个商人&回去
3&两个商人过去
4&一个商人&回去
5&一个野人&一个商人
不知道是不是我理解错了，代码我还不会写，但是我感觉这样应该可以过河吧？求指导
public&static&void&main(String[]&args)&{
&&&&&&&&int[]&to&=&{&0,&0&};&//&对岸的人数
&&&&&&&&int[]&from&=&new&int[2];&//&剩下的人数
&&&&&&&&Scanner&sc&=&new&Scanner(System.in);
&&&&&&&&System.out.println("输入传教士和野人个数:");
&&&&&&&&from[0]&=&sc.nextInt();
&&&&&&&&from[1]&=&sc.nextInt();
&&&&&&&&try&{
&&&&&&&&&&&&if&(from[0]&==&from[1])&{&//&教士和野人相等必须先走2教士
&&&&&&&&&&&&&&&&go(from,&to,&0,&2);
&&&&&&&&&&&&}&else&{&//&教士&野人无压力
&&&&&&&&&&&&&&&&go(from,&to,&1,&1);
&&&&&&&&&&&&}
&&&&&&&&&&&&back(from,&to,&0,&1);
&&&&&&&&&&&&while&(true)&{
&&&&&&&&&&&&&&&&if&(from[1]&!=&0)&{
&&&&&&&&&&&&&&&&&&&&if&(to[0]&&&to[1])&{
&&&&&&&&&&&&&&&&&&&&&&&&go(from,&to,&2,&0);
&&&&&&&&&&&&&&&&&&&&}&else&{
&&&&&&&&&&&&&&&&&&&&&&&&go(from,&to,&1,&1);
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&}&else&{
&&&&&&&&&&&&&&&&&&&&if&(from[0]&&&1)&{
&&&&&&&&&&&&&&&&&&&&&&&&go(from,&to,&2,&0);
&&&&&&&&&&&&&&&&&&&&}&else&{
&&&&&&&&&&&&&&&&&&&&&&&&go(from,&to,&1,&0);
&&&&&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&if&(from[0]&==&0&&&&from[1]&==&0)&{
&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&&&&&if&(to[0]&&&to[1])&{
&&&&&&&&&&&&&&&&&&&&back(from,&to,&1,&0);
&&&&&&&&&&&&&&&&}&else&{
&&&&&&&&&&&&&&&&&&&&back(from,&to,&0,&1);
&&&&&&&&&&&&&&&&}
&&&&&&&&&&&&}
&&&&&&&&&&&&System.out.println("成功过河！");
&&&&&&&&}&catch&(Exception&e)&{
&&&&&&&&&&&&System.out.print(e.getMessage());
&&&&&&&&&&&&System.out.println("无解");
&&&&public&static&void&go(int[]&from,&int[]&to,&int&m,&int&n)&throws&Exception&{
&&&&&&&&System.out.println("--&"&+&m&+&"个传教士&"&+&n&+&"个野人&"&+&"过河");
&&&&&&&&from[0]&-=&m;
&&&&&&&&from[1]&-=&n;
&&&&&&&&System.out.println("剩下:&"&+&from[0]&+&"个传教士&"&+&from[1]&+&"个野人");
&&&&&&&&to[0]&+=&m;
&&&&&&&&to[1]&+=&n;
&&&&&&&&System.out.println("对岸:&"&+&to[0]&+&"个传教士&"&+&to[1]&+&"个野人");
&&&&&&&&checkIsSafe(from,&to);
&&&&public&static&void&back(int[]&from,&int[]&to,&int&m,&int&n)
&&&&&&&&&&&&throws&Exception&{
&&&&&&&&if&(m&==&1)&{
&&&&&&&&&&&&System.out.println("&--"&+&"1个传教士&回去");
&&&&&&&&&&&&from[0]&+=&m;
&&&&&&&&&&&&System.out.println("剩下:&"&+&from[0]&+&"个传教士&"&+&from[1]&+&"个野人");
&&&&&&&&&&&&to[0]&-=&m;
&&&&&&&&&&&&System.out.println("对岸:&"&+&to[0]&+&"个传教士&"&+&to[1]&+&"个野人");
&&&&&&&&&&&&checkIsSafe(from,&to);
&&&&&&&&}&else&if&(n&==&1)&{
&&&&&&&&&&&&System.out.println("&--"&+&"1个野人&回去");
&&&&&&&&&&&&from[1]&+=&n;
&&&&&&&&&&&&System.out.println("剩下:&"&+&from[0]&+&"个传教士&"&+&from[1]&+&"个野人");
&&&&&&&&&&&&to[1]&-=&n;
&&&&&&&&&&&&System.out.println("对岸:&"&+&to[0]&+&"个传教士&"&+&to[1]&+&"个野人");
&&&&&&&&&&&&checkIsSafe(from,&to);
&&&&private&static&void&checkIsSafe(int[]&from,&int[]&to)&throws&Exception&{
&&&&&&&&if&(from[1]&&&from[0]&&&&from[0]&!=&0)&{
&&&&&&&&&&&&throw&new&Exception("剩下的野人吃了传教士！！");
&&&&&&&&if&(to[1]&&&to[0]&&&&to[0]&!=&0)&{
&&&&&&&&&&&&throw&new&Exception("对岸的野人吃了传教士！！");
引用&143&楼&&的回复:很好奇&为什么&M=4的时候&不能过河&
1&一个野人&一个商人&
2&一个商人&回去
3&两个商人过去
4&一个商人&回去
5&一个野人&一个商人
不知道是不是我理解错了，代码我还不会写，但是我感觉这样应该可以过河吧？求指导
剩下的教士表示压力很大
引用&99&楼&&的回复:最后的结果我测试了，下面是结果
我的输入是：PersonList&p=new&PersonList(8,&0,&8,&0);//分别指的是过河前的人数，
分别指的是（登船口的传教士，目标口的传教士，登船口的野蛮人，目标口的野蛮人）;
结果我测试了，应该是正确的，当然，我这里的渡河方法只是随机生成的一种，要全列举出来有点麻烦，那个就不写出来了。
下面是测试结果：
第1次渡河后
登船口传教……。。。
你不算过了河之后给吃了的？
所以你第一次就错了！
第一次应该是1传教士&1野蛮人
然后1野蛮人回来！
第二次是1传教士&1野蛮人
然后1野蛮人回来！
我也考到这道题，题目我都理解错了，我以为靠岸船上的人不参与吃人or被吃，，
好像是a*算法
真是人才济济啊&&全是人才
多年前笔试碰到这个题交了白卷，当时一点思路都没有，也不知道M和C是什么（全英文），只看懂了M要吃C。现在用蛋疼的方法试试，有如下的问题：
1.没有回溯，所以如果某个初始值会引起回溯，必须保留状态信息，这个算法就是错的。
2.没保留上次的操作，可能引起死循环；测试中发现了，所以当M&C时用了另一种策论。
3.编译器递归有限，我机器上只能到200多层；无法解决大于这个数字的问题。
4.策略本想写成数组，mpl::vector&pair&2,0&,pair&1,1&,pair&0,2&&格式，用算法遍历，这里直接写死了，没实现。
5.只生成了这些类，operator()完全是为产生这些对象，在构造函数中打印类信息，没其他用。也可以使用继承直接构造出这些对象，没尝试。
6.没有对1特化，初始只有1个无法做。
7.这个解法除了最快速判断能否有解外，好像没其他优点。
#include&&iostream&
using&namespace&
#include&boost/mpl/int.hpp&
#include&boost/mpl/pair.hpp&
#include&boost/mpl/bool.hpp&
#include&boost/mpl/if.hpp&
#include&boost/mpl/transform.hpp&
namespace&boost{namespace&mpl&{}}
namespace&mpl&=&boost::
template&&int&m,int&c,typename&side,int&M,int&C&
struct&l{};
struct&r{};
template&typename&T&
struct&otherside
typedef&l&
template&&
struct&otherside&l&
typedef&r&
//是否可移动
//左边&new(c)==0或者new(m)&=new(c)
#define&_value_left(v1,v2)&(c-v2==0&||&(m-v1&=c-v2)&)
//右边&C-new(c)==0或者M-new(m)&=C-new(c)
#define&_value_right(v1,v2)&(C-c+v2==0&||&(M-m+v1&=C-c+v2)&)
//数量够并且left()&&right()
#define&_value(v1,v2)&(&m&=v1&&&&c&=v2&&&&_value_left(v1,v2)&&&&_value_right(v1,v2)&)
//&参数T&为mpl::pair&mpl::int_&v1&,mpl::int_&v2&&&类型
//&v1为将上船的m数量,v2为将上船的c数量
//&value返回是否可用
template&&typename&T,int&m,int&c,int&M,int&C&
struct&policy
static&const&int&v1&=&T::first::
static&const&int&v2&=&T::second::
static&const&int&value&=&_value(T::first::value,T::second::value);
//中止计算
struct&err_{&
static&const&int&value&=&0;
typedef&err_&&
void&operator()(){std::cout&&"error"&&std::}
static&const&int&v1&=&-1;
static&const&int&v2&=&-1;
#define&_v(v1,v2)&policy&&mpl::pair&mpl::int_&v1&,mpl::int_&v2&&&,m,c,M,C&&&
//左边策略
template&&int&m,int&c,int&M,int&C&
struct&leftpolicy
//算法优先级:&2C,1M1C,2M
typedef&typename&mpl::if_c&
_v(0,2)::value,
typename&mpl::if_c&
_v(1,1)::value,
typename&mpl::if_c&
_v(2,0)::value,
static&const&int&value&=&policy::
typedef&typename&mpl::if_c&
mc&M-m+policy::v1,C-c+policy::v2,r,M,C&,
//左边策略
template&&int&m,int&c,int&M,int&C&
struct&leftpolicy1
//算法优先级:&2M,2C,1M1C
typedef&typename&mpl::if_c&
_v(2,0)::value,
typename&mpl::if_c&
_v(0,2)::value,
typename&mpl::if_c&
_v(1,1)::value,
static&const&int&value&=&policy::
typedef&typename&mpl::if_c&
mc&M-m+policy::v1,C-c+policy::v2,r,M,C&,
//右边策略
template&&int&m,int&c,int&M,int&C&
struct&rightpolicy
//算法优先级:&1M,1C,,2M,1M1C,2C
typedef&typename&mpl::if_c&
_v(1,0)::value,
typename&mpl::if_c&
_v(0,1)::value,
typename&mpl::if_c&
_v(2,0)::value,
typename&mpl::if_c&
_v(1,1)::value,
typename&mpl::if_c&
_v(0,2)::value,
static&const&int&value&=&policy::
typedef&typename&mpl::if_c&
mc&M-m+policy::v1,C-c+policy::v2,l,M,C&,
template&&int&m,int&c,typename&side,int&M,int&C&
struct&mc_imp:public
boost::is_same&side,l&,
typename&mpl::if_c&&(C&M&&&&C&2),
typename&leftpolicy&m,c,M,C&,
typename&leftpolicy1&m,c,M,C&
typename&rightpolicy&m,c,M,C&
template&&int&m,int&c,typename&side=l,int&M=m,int&C=c&
struct&mc //public&bwl?
mc(){std::cout&&m&&"&"&&c&&"&"&&side()&&std::}
typedef&mc&
typedef&typename&mc_imp&m,c,side,M,C&::type&
static&const&int&value&=&nextside::
void&operator()()
nextside()();
//全部到达对岸
template&int&m,int&c&
struct&mc&m,c,r,m,c&
mc(){std::cout&&m&&"&"&&c&&"&"&&r()&&"&&OK!"&&std::}
static&const&int&value&=&1;
typedef&mc&
void&operator()(){}
ostream&&operator&&(ostream&&stream,l&&)
stream&&"left";
ostream&&operator&&(ostream&&stream,r&&)
stream&&"right";
int&main()
mc&3,3,l,3,3&::nextside&a1;
mc&3,3,l,3,3&::nextside::nextside&a2;
mc&3,3,l,3,3&::nextside::nextside::nextside&a3;
mc&3,3,l,3,3&::nextside::nextside::nextside::nextside&a4;
mc&3,3,l,3,3&::nextside::nextside::nextside::nextside::nextside&a5;
mc&3,3,l,3,3&::nextside::nextside::nextside::nextside::nextside::nextside&a6;
mc&3,3,l,3,3&::nextside::nextside::nextside::nextside::nextside::nextside::nextside&a7;
mc&3,3,l,3,3&::nextside::nextside::nextside::nextside::nextside::nextside::nextside::nextside&a8;
mc&3,3,l,3,3&::nextside::nextside::nextside::nextside::nextside::nextside::nextside::nextside::nextside&a9;
mc&3,3,l,3,3&::nextside::nextside::nextside::nextside::nextside::nextside::nextside::nextside::nextside::nextside&a10;
mc&2,2&&()();
mc&3,100&&()();
mc&3,3&&()();
mc&4,3&&()();
mc&44,100&&()();
mc&100,44&&()();
mc&4,5&&()();
mc&23,50&&()();
该回复于 10:11:19被版主删除
感觉此题的限定条件不明确，船可不可以空船返回很关键，否则只要传教士和野人相等时，无解
好贴&要好好想想
元芳，你认为呢？
该回复于 09:31:54被版主删除
回复能有积分，不好意思。
积分有用。
据说，M&==&C&&&3&无解，然后我想了下M&==&C&==&3&的情况，
可以这样：
1,&M+C&过河,&M&&&回来,此时,&A:&3M+2C,&B:&0M+1C
2,&C+C&过河,&C&&&回来,此时,&A:&3M+1C,&B:&0M+2C
3,&M+M&过河,&M+C&回来,此时,&A:&2M+2C,&B:&1M+1C
4,&M+M&过河,&C&&&回来,此时,&A:&0M+2C,&B:&3M+0C
5,&C+C&过河
M&&&C&的解法参考&2&楼
该回复于 14:24:02被版主删除
这篇文章不错哦，谢谢
学习！学习！
膜拜楼上各种大神
咋都说我整的不对，说我不对的，你们当真仔细看了么？
纯高人啊，学习中。
这个是用哪个写更加方便呢
先将牧师全部运到对岸，然后由野人自己渡河。中间保证途中要求条件即可。
引用&100&楼&&的回复:不是M&C么，一直让一个传教士当船工然后野人传教士不断轮换的运送就完了啊
就目前阶段，乍一看，也是这么想的，，，但是稍微研究了一下这道在我看来是新题（各位大神眼中的“经典”），感觉肯定有一种过程是出题者忽略的，也许这个题本身就存在问题，只要补充解释清楚一下题目要求，就像可以空船的那层楼，那就是没有矛盾的解题思路。也许是水平不够，，，我认为，这题木有绝对正解~~~哈哈哈，学习就好~~~&&&&&&&&&&&&&&
&&&&&&元芳：这件事你怎么看？
引用&165&楼&&的回复:先将牧师全部运到对岸，然后由野人自己渡河。中间保证途中要求条件即可。
那河这边的牧师怎么办？？？就是说只能活两个牧师了。。。
大家看看小弟的解释正确不：(假设传道士比野蛮人大1)
1.先1传道士和1野蛮人过河。此时目的地1:1，始发地传道士&=野蛮人
2.传道士回去接一个传道士。此时目的地2:1，始发地传道士=野蛮人
3.传道士回去接一个野蛮人。此时目的地2:2，始发地传道士&=野蛮人
4.野蛮人回去接一个传道士。此时目的地3:2，始发地传道士=野蛮人
5.传道士回去接一个野蛮人。此时目的地3:3，始发地传道士&=野蛮人
6.野蛮人回去接一个传道士。此时目的地4:3，始发地传道士=野蛮人
7.传道士回去接一个野蛮人。此时目的地4:4，始发地传道士&=野蛮人
。。。。。
请各位帮小弟看看自己思路对不对
程序还在写着，先帮小弟看看思路。
狄仁杰:此题目弯弯转转，此起彼伏，扰得大人我彻夜未眠。&&&&元芳，你怎么看?&&&&&&&&&&&&&
就像要点积分&&&不好意
不会用绳子将野人捆住？&
看看，学习下。
引用&15&楼&&的回复:某侧只剩下野人，没有传教士的话，会不会跑啊？:)如果跑了一定是去吃了360出题的人！
引用&4&楼&&的回复:看看这个
http://hi.baidu.com/urzalknsyzchrur/item/538f25f19417adb630c199e1那算法我就不懂了。不过这让我想起了曾经一个传说：当一个老师问学生：“24小时之内分钟与时钟的指针有多少次重叠？”时，中国学生马上拿纸拿笔写起高数代数二次方程%￥#在运算，而外国学生则是马上拿出手表让手表转24小时！
野人与传教士&的游戏：
有懂的与不懂的都可以玩一下，体会一下“算法”
============以下是我个人的答案先别看，我相信你的方法更好==================
1、2野人上船运到对面（其中一人带船返回）
2、同上（此时两野人在对面）
3、船上野人下船，两传教士上船
4、到对面后，一传教士下船，换一野人上船返回（重点）
5、返回后，野人又下船换传教士上船
6、这样全部传教士已经到对岸，换野人去接剩下的野人...
对问题解法二进制编码，给个遗传算法让计算机撞运气去。
这个题的算法不难呀
这个很简单，用野人来回运送就ok，每次先送一个人，再送一个野人,就能保证两边都是人比野人个人不会少
高人啊&学习了
该回复于 08:42:07被版主删除
正在学习当中……
引用&151&楼&&的回复:感觉此题的限定条件不明确，船可不可以空船返回很关键，否则只要传教士和野人相等时，无解
如果可以空船返回的话，那这道题就不是问题了。如果可以空船，因为传教士&=野蛮人，所以每次一传教士一野蛮人过河，再空船返回，所以目的地传教士：野蛮人=1：1，而出发地传教士&=野蛮人，这样还用做么……
该回复于 09:32:34被版主删除
一直让一个传教士当船工然后野人传教士不断轮换的运送就完了啊，不行吧这样
该回复于 10:05:47被管理员删除
学习中，希望有所收获
从到达对岸有三种方式：两个传教士、两个野人、一个传教士一个野人
从对岸回来有两种方式：一个传教士、一个野人
条件两岸的传教士的数量不能少于野人
经典题目拿出来分享。。。
这个问题好
学习&学习~~
很经典，顶一下。
这只能算是个数学问题，用计算机实现其实已经是用数学解决好了，只是按步骤一步一步执行而已
这个是个老问题了,不难啊!
楼上的不对吧，要是传教士只比野人多一人，把一个传教士当船夫，始终会出现一岸野人多余传教士的。
小时候听过一个一农夫带一只羊和一只狼和一棵白菜过河的比这个简单。
引用&6&楼&&的回复:很基础的人工智能例题，定义出状态与转换规则，就可以等价变换为一道搜索题
比如可以用2维坐标(传教士，狼)来表示数量，那刚开始的时候，出发地就是S=(M,C)，目的地是T=(0,0)，船上的人是B=(b1,b2)。所以这道题就变成了:遍历所有T=T+B,&T-B的情况，最终让T变为(M,C)，相应的S=(0,0)
还有些限制条件，“船上能载2人”：b1+b2&=2
“过河时，传……
好像很厉害
回复}