当前位置：首页 » 数据智能 » 人工智能过河问题

人工智能过河问题

发布时间: 2021-03-28 14:17:39

A. 一个简单的人工智能题：用问题归约法求解野人与修道士的问题

问题归约法从目标(要解决的问题)出发，逆向推理，通过一系列变换把初始问题变换为子问题集合和子子问题集合，直至最后归约为一个平凡的本原问题集合。

已知条件1：最后一次乘船的一定是两人。
已知条件2：往与返的组合不能重复，否则没有意义。
已知条件3：左岸人数除最末次外，不为零。

目标0：
右岸有3个野人3个修道士，船在右。

逆向推理：
最后一次乘船到右岸的组合有以下几种：
1个野人1个修道士；2个野人。

目标-1：
a、左岸1野1修，右岸2野2修，船在左；
b、左岸2野，右岸1野3修，船在左。

逆向推理：
a、左岸1野，1修驶向左岸，右岸2野2修；
b、左岸1野，1野驶向左岸，右岸1野3修。

目标-2：
左岸1野，右岸2野3修，船在右。

逆向推理：
c、左岸1野，1修驶向右岸，右岸2野2修；
d、左岸1野，1野驶向右岸，右岸1野3修；
e、左岸1野，2野驶向右岸，右岸3修。

目标-3：
左岸3野，右岸3修，船在左。

逆向推理：
f、左岸1野，2野驶向左岸，右岸3修；
g、左岸2野，1野驶向左岸，右岸3修。

目标-4：
左岸2野，右岸1野3修，船在右。

逆向推理：
h、左岸2野，1野驶向右岸，右岸3修；
i、左岸2野，2修驶向右岸，右岸1野1修。

目标-5：
左岸2野2修，右岸1野1修，船在左。

逆向推理：
j、左岸2野，2修驶向左岸，右岸1野1修；
k、左岸1野1修，1野1修驶向左岸，右岸1野1修。

目标-6：
左岸1野1修，右岸2野2修，船在右。（与目标-5对称）

逆向推理：
l、左岸1野1修，2修驶向右岸，右岸2野。

目标-7：
左岸1野3修，右岸2野，船在左。（与目标-4对称）

逆向推理：
m、左岸3修，1野驶向左岸，右岸2野。

目标-8：
左岸3修，右岸3野，船在右。（与目标-3对称）

逆向推理：
n、左岸3修，2野驶向右岸，右岸1野。

目标-9：
左岸3修2野，右岸1野，船在左。（与目标-2对称）

逆向推理：
左岸3修1野，1野驶向左岸，右岸1野。

目标-10：
左岸3修1野，右岸2野，船在右。

逆向推理：
左岸3修1野，2野驶向右岸，右岸无人。

达到期望的初始状态^^

结论：

1、2野向右：结果左3修1野，右2野，船在右。（目标-10）
2、1野向左：结果左3修2野，右1野，船在左。（目标-9）
3、2野向右：结果左3修，右3野，船在右。（目标-8）
4、1野向左：结果左3修1野，右2野，船在左。（目标-7）
5、2修向右：结果左1修1野，有2修2野，船在右。（目标-6）
6、1修1野向左：结果左2修2野，右1修1野，船在左。（目标-5）
7、2修向右：结果左2野，右3修1野，船在右。（目标-4）
8、1野向左：结果左3野，右3修，船在左。（目标-3）
9、2野向右：结果左1野，右2野3修，船在右。（目标-2）
10、1野向左：结果左2野，右1野3修，船在左。
或1修向左：结果左1野1修，右2野2修，船在左。（目标-1）
11、2野向右，或1修1野向右，达到目的。

B. 急求人工智能野人传教士过河问题，详解！！！！

我来试着回答一下前三问:

(1)完整的规则集合

if(MR,CR,LR=1)then(MR-1,CR,LR-1);

if(MR,CR,LR=1)then(MR,CR-1,LR-1);

if(MR,CR,LR=1)then(MR-1,CR-1,LR-1);

if(MR,CR,LR=1)then(MR-2,CR,LR-1);

if(MR,CR,LR=1)then(MR,CR-2,LR-1);

if(MR,CR,LR=0)then(MR+1,CR,LR+1);

if(MR,CR,LR=0)then(MR,CR+1,LR+1);

if(MR,CR,LR=0)then(MR+1,CR+1,LR+1);

if(MR,CR,LR=0)then(MR+2,CR,LR+1);

if(MR,CR,LR=0)then(MR,CR+2,LR+1);

(2)状态空间的总状态数为4×4×2=32，只有20个合法状态，其中有4个合法状态达不到，最终解空间由16个状态组成，下面给出说明

(MR,CR,LR)(MR,CR,LR)

(001)达不到(000)

(011)(010)

(021)(020)

(031)(030)达不到

(101)不合法(100)不合法

(111)(110)

(121)不合法(120)不合法

(131)不合法(130)不合法

(201)不合法(200)不合法

(211)不合法(210)不合法

(221)(220)

(231)不合法(230)不合法

(301)达不到(300)

(311)(310)

(321)(320)

(331)(330)达不到

(3)2个野人去，1个野人回

2个野人去，1个野人回

2个传教士去，1个野人与1个传教士回

2个传教士去，1个野人回

2个野人去，1个野人回

2个野人去，完成

不合法的状态和重复状态，我都没画出，你可以自己加一下，也可以结合图

说明一下

C. 人工智能会统治地球吗

研究历史，我们知道，人类历史的发展，没有什么必然，它是由一个一个的偶然事件逐渐推动发展方向的，没有谁能保证人类文明能够万古长青，君不见，有那么多考古证据揭示了曾经有那么多的文明都淹没于历史的长河中了吗，不过，有一点是肯定的，人类社会，一定趋向于越来越复杂，人类社会的每一次进步，本质上都是趋向于更复杂，这种复杂是维度的上升，也就是我们平时说的指数级的上升，每一次进步的前夕，人们都有过恐慌，这是人类对未知的正常反应，过去的农业文明，工业文明，信息文明，无不如此，只是，人们每一次恐慌上升的程度，也是指数级别的。这一次人工智能时代，当然也是史上最大的一次。但是，据说人类的大脑只开发了百分之几，所以，人类有足够的资源来应对这种恐慌。对于科学家们担心由于人工智能的运用，未来人类社会会被撕裂，我有不同的看法，他们担心人类会因为基因技术改变富人和穷人的竞争优势，从而使人类社会被撕裂，可是，没有任何证据表明，哪一个基因优于另一个基因，过去的历史也证明了，基因，不是人类进化的原因，选择，没有对错，只不过是你追求什么结果，你就如何选择，任何一个选择，都不可能只有好处，没有坏处，我们要做的是，接受选择的好处，也要准备好接受选择的坏处。对基因的选择，同样如此。而其他的担心理由，不再一一论述。（顺带一句题外话——不选择的优势，在于可以一直拥有选择权，但是也拒绝了进步的可能——我们认为我们是进步的——不可取也）。另外，从过去的历史看，人类社会进步的发展方向，一直是趋于更加的统一，更加的社会化大分工，更广泛的社会协作，不如此，不进步。所以，人类社会的复杂所产生的弥合力量，一定大于社会分裂的力量。当然，人类社会不被撕裂，也不意味着就是美好和大同，历史表明，人类社会的贫富差距一直是越来越大，这很正常，它与宇宙的进化方向相一致，就是越来越复杂。对于我们来说，就是问题越来越多，不过，这是进步的代价，也是选择的代价。所以，贫穷，是不可能被消灭的，因为，它是人类社会生态的一分子。只不过，有可能在不同的时代，不同的社会发展阶段，贫穷的概念，或者说定义不同，但是，也许也可能我们将来会对贫穷进行分级，也就是说最原始的那种贫穷会一直存在，只不过不同的贫穷占比不同。贫穷，不可以被消灭，正如疾病，也不可以被消灭一样，因为，那是我们的一分子，是我们进步的原因。
最后，我们用古老的小马过河的故事做结尾吧，未来，不是天堂，也不是地狱，他，只是未来，我们要做的，是面对他大踏步的前进，因为，我们别无选择。

D. 用Visual Prolog实现一个人工智能程序。问题如下。

看你是中法的告诉你吧，，，我是你玺哥
三个传教士和三个野人的示例程序如下：

move(1,0).

move(0,1).

move(0,2).

move(2,0).

move(1,1).

legal((X,Y,_)):-legal1(X),legal1(Y).

legal1((X,Y)):-X=:=0,Y>=0,!.

legal1((X,Y)):-Y=:=0,X>=0,!.

legal1((X,Y)):-X>=Y,X>=0,Y>=0.

update((X,Y,0),Move,Statu1):-

(A,B)=X,

(C,D)=Y,

(E,F)=Move,

C1 is C+E,

D1 is D+F,

A1 is A-E,

B1 is B-F,

Statu1=((A1,B1),(C1,D1),1).

update((X,Y,1),Move,Statu1):-

(A,B)=X,

(C,D)=Y,

(E,F)=Move,

C1 is C-E,

D1 is D-F,

A1 is A+E,

B1 is B+F,

Statu1=((A1,B1),(C1,D1),0).

connect(Statu,Statu1):-

move(X,Y),

update(Statu,(X,Y),Statu1),

legal(Statu1).

findroad(X,X,L,L):-write(L).

findroad(X,Y,L,L1):-

connect(X,Z),

not(member(Z,L)),

findroad(Z,Y,[Z|L],L1).

E. 人工智能野人与传教士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&p=0
csdn的论坛，自己找，有答案。

F. 野人过河新问题算法

楼主，我怀疑你问题打错了，有几个野人啊？如果只有一个，那怎么渡都行，还版有，如果把条件改为在河上权野人和僧人的数量相同，野人才不会吃掉僧人，是什么意思啊，船上只能有两个人，当然最多一僧一野，没被吃的可能啊

G. 如何解决野人过河问题

差不多，你参考下：
野人过河问题属于人工智能学科中的一个经典问题，问题描述如下：有三个牧师（也有的翻译为传教士）和三个野人过河，只有一条能装下两个人的船，在河的任何一方或者船上，如果野人的人数大于牧师的人数，那么牧师就会有危险. 你能不能找出一种安全的渡河方法呢？
一、算法分析
先来看看问题的初始状态和目标状态，假设和分为甲岸和乙岸：
初始状态：甲岸，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。

H. 求助人工智能农夫过河问题的prolog语言程序

/*
PROBLEM:
A farmer with his goat, wolf and cabbage come to a river that they
wish to cross. There is a boat, but it only has room for two, and
the farmer is the only one that can row. If the goat and cabbage
get in the boat at the same time, the cabbage gets eaten.
Similarly, if the wolf and goat are together without the farmer,
the goat is eaten. Devise a series of crossings of the river so that all
concerned make it across safely.
The state of the system is indicated by stating where the farmer, the goat
the wolf and the cabbage are located.
state( Farmer, Wolf, Goat, Cabbage )
The problem is that a state must only be visited once, and some states
are illegal. This is checked by 'unsafe' and 'member'.
The Predicate "go" can be called with a start state and a final state
go( state(east,east,east,east), state(west,west,west,west) ).
*/
DOMAINS
LOC = east ; west
STATE = state(LOC,LOC,LOC,LOC)
PATH = STATE*

PREDICATES
go(STATE,STATE) /* Start of the algorithm */
path(STATE,STATE,PATH,PATH) /* Finds a path from one state to another */
move(STATE,STATE) /* Transfer a system from one side to another */
opposite(LOC,LOC) /* Gives a location on the opposite side */
unsafe(STATE) /* Gives the unsafe states */
member(STATE,PATH) /* Checks if the state is already visited */
write_path(PATH)
write_move(STATE,STATE)
show_move(STATE,STATE)
showside(LOC,LOC,string)
s_river
GOAL
makewindow(4,7,0,"",0,0,24,80),
makewindow(3,7,7," The River ",15,0,10,80),
makewindow(2,112,0,"",0,0,1,80),
write("press any key for each step of solution"),
makewindow(1,7,7," Solutions ",2,0,13,80),

show_move(state(west,west,west,west),state(west,west,west,west)),
go(state(east,east,east,east),state(west,west,west,west)),
write("solved press any key to continue"),
readchar(_),
exit.
CLAUSES
go(S,G):-
path(S,G,[S],L),
nl,write("A solution is:"),nl,
write_path(L),
fail.
go(_,_).
path(S,G,L,L1):- move(S,S1),
not( unsafe(S1) ),
not( member(S1,L) ),
path( S1,G,[S1|L],L1),!.
path(G,G,T,T):- !. /* The final state is reached */

move(state(X,X,G,C),state(Y,Y,G,C)):-opposite(X,Y). /* FARMER + WOLF */
move(state(X,W,X,C),state(Y,W,Y,C)):-opposite(X,Y). /* FARMER + GOAT */
move(state(X,W,G,X),state(Y,W,G,Y)):-opposite(X,Y). /* FARMER + CABBAGE */
move(state(X,W,G,C),state(Y,W,G,C)):-opposite(X,Y). /* ONLY FARMER */
opposite(east,west).
opposite(west,east):-!.
unsafe( state(F,X,X,_) ):- opposite(F,X). /* The wolf eats the goat */
unsafe( state(F,_,X,X) ):- opposite(F,X). /* The goat eats the cabbage */

member(X,[X|_]).
member(X,[_|L]):-member(X,L).
write_path( [H1,H2|T] ) :- !,
readchar(_),
write_move(H1,H2),
show_move(H1,H2),
write_path([H2|T]).
write_path( [] ).

write_move( state(X,W,G,C), state(Y,W,G,C) ) :-!,
write("The farmer crosses the river from ",X," to ",Y),nl.
write_move( state(X,X,G,C), state(Y,Y,G,C) ) :-!,
write("The farmer takes the Wolf from ",X," of the river to ",Y),nl.
write_move( state(X,W,X,C), state(Y,W,Y,C) ) :-!,
write("The farmer takes the Goat from ",X," of the river to ",Y),nl.
write_move( state(X,W,G,X), state(Y,W,G,Y) ) :-!,
write("The farmer takes the cabbage from ",X," of the river to ",Y),nl.
/* Show them move across the river.*/
show_move( state(F,W,G,C), state(F1,W1,G1,C1) ) :-!,
s_river,
showside(F,F1,"Farmer "),
showside(W,W1," Wolf "),
showside(G,G1," Goat "),
showside(C,C1,"Cabbage"),
shiftwindow(1).

showside(east,east,Item):-!,
write(" ~~~~~ ",Item),nl.
showside(west,west,Item):-!,
write(" ",Item," ~~~~~ "),nl.
showside(east,west,Item):-!,
write(" ",Item," <= <= <= ",Item),nl.
showside(west,east,Item):-!,
write(" ",Item," => => => ",Item),nl.
s_river:-
shiftwindow(3),clearwindow,
write(" WEST river EAST"),nl,
write(" ----------------------------------------------------------------------"),
nl.

I. 过河问题

J. 人工智能野人传教士过河

第一次俩个野人过来河，留下一个源野人，回一个野人
第二次一野人一传教士过河，留下一个传教士，回一个野人
第三次俩个教士过河，回一个野人
剩下的就好办了...
(错)
*************************************************************************
汗。。。火星微生物说得对哈，我差点就闹出人命了
试一试：(x:野人,o:传教士)
第一次俩个野人过河，留下一个野人，回一个野人（ xxooo｜x ）
第二次俩个野人过河，留下一个野人，回一个野人(xooo|xx)
第三次俩个传教士过河,回一个野人,一传教士(xxoo|xo)
第四次俩个传教士过河（xx|xooo）........
大家看看，有没有问题（这几天脑袋发昏），欢迎指教：）

阅读全文

人工智能过河问题

与人工智能过河问题相关的阅读推荐