用JAVA编一个关于猛兽过河问题的程序

六种动物过河,是大小虎,大小豹,大小熊,大熊大狮大虎小熊会划船,只有一只船并且一次只能载两只动物,注意，小的旁边如果有其他大的而没有自己大的就会被欺负(大不吃大,小不吃小),怎么能使它们全过河?（最好有原代码提供，谢了~~）

10多年的乌海网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。全网营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整乌海建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。创新互联建站从事“乌海网站设计”,“乌海网站推广”以来，每个客户项目都认真落实执行。

附：

猛兽过河的过程为：

第一步：小熊和小虎过去————小雄回来送船

第二步：小熊和小豹过去————小熊回来送船

第三步：大豹子和大虎过去————大虎和小虎送船

第四步：小熊和大熊过去--------大豹和小豹回来送船

第五步：大豹和大虎过去-------小熊回来送船

第六步：小熊和小虎过去---------小熊回来

第七步:小熊和小豹过去

微软的一条面试题（和猛兽过河问题很相似,供参考）：

三只母鸡，三只小鸡在河东岸，一条小舟每次最多载两只鸡（大小不论）。

条件：

1、母鸡都会划船。

2、只有一只小鸡会划船，其余两只不会。

3、当小鸡母亲不在身边时，其余母鸡就会啄死这只小鸡。

其算法为：

int 过河前数组,把鸡放进去

int 过河后数组

再定义一个结构

{鸡1;

鸡2;

int *pnext;

}

及结构指针

结构指针开辟内存

void 过河(过河前数组,过河后数组,结构指针)

{if(过河前数组全为0)

{输出链表中的内容

return;

}

else

{ int i,j,m,n;

int temp过河前数组;

int temp过河后数组;

temp过河前数组=过河前数组;

temp过河后数组=过河后数组

for(i=0;i上标-1;i++)

for(j=i+1;j上标;j++)

{m=过河前数组[i];

n=过河前数组[j];

if(判取出两个数后剩下的数及这两个数满足过河条件别忘了判这两个数与过河后数组满不满足)

{把m,n放入结构;

if(判结构指针中的pnext是否为null)

是结构指针开辟内存 形成新结构组成链表;

否就把指针向下移;

把m,n放入temp过河后数组

temp过河前数组中把m,n变为0;

回河(temp过河前数组,temp过河后数组,结构指针);

}

}

}

}

void 回河(过河前数组,过河后数组,结构指针)

{int i,j,m,n;

int temp过河前数组;

int temp过河后数组;

int temp结构指针=结构指针;

temp过河前数组=过河前数组;

temp过河后数组=过河后数组;

for(i=0;i上标-1;i++)

for(j=i+1;j上标;j++)

{m=过河后数组[i];

n=过河后数组[j];

if(判取出2个数后剩下的数及这两个数满足回河条件别忘了判这2个数与过河前数组满不满足)

{把m,n放入结构;

if(判结构指针中的pnext是否为null)

是开辟内存 形成新结构组成链表;

否就把指针向下移;

把m,n放入temp过河前数组

temp过河后数组中把m,n变为0;

过河(temp过河前数组,temp过河后数组,结构指针);

}

}

temp过河前数组=过河前数组;

temp过河后数组=过河后数组;

for(i=0;i上标-1;i++)

{m=过河后数组[i];

if(判取出1个数后剩下的数及这1个数满足回河条件别忘了判这1个数与过河前数组满不满足)

{if(判temp结构指针中的pnext是否为null)

是开辟内存 形成新结构组成链表;

否就把指针向下移;

把m放入temp过河前数组

temp过河后数组中把m变为0;

过河(temp过河前数组,temp过河后数组,temp结构指针);

}

}

急求！！！

猴子过河 java算法

import java.util.Arrays;

import java.util.List;

import java.util.Stack;

public class Monkey {

public String[] monkeys = { "a", "b", "c", "A", "B", "C" };

Rule rule1 = new Rule1();

Rule rule2 = new Rule2();

public int count = 0;

public StringBuffer success = new StringBuffer(2000);

public void boat() {

StackString left = new StackString();

StackString right = new StackString();

for (int i = 0; i  monkeys.length; i++) {

left.add(monkeys[i]);

}

go(left, right, "");

System.out.println("***********************共" + count + "种成功方案***********************");

System.out.println(success.toString());

System.out.println("***********************共" + count + "种成功方案***********************");

}

private void go(StackString left, StackString right, String s) {

for (int i = 0; i  left.size(); i++) {

String monkey1 = left.get(i);

for (int j = i + 1; j  left.size(); j++) {

StringBuffer sb = new StringBuffer();

String monkey2 = left.get(j);

sb.append(s);

sb.append(monkey1);

sb.append(monkey2);

sb.append("-");

sb.append(" ");

if ((rule1.isCanBoat(monkey1, monkey2, sb))  (rule2.isCanBoat(monkey1, monkey2, sb))) {

StackString nextLeft = new StackString();

StackString nextRight = new StackString();

nextLeft.addAll(left);

nextRight.addAll(right);

nextLeft.remove(monkey1);

nextLeft.remove(monkey2);

nextRight.push(monkey1);

nextRight.push(monkey2);

if (nextLeft.size() == 0) {

success.append(sb.toString() + nextLeft.toString() + nextRight.toString());

success.append("\n");

count++;

continue;

}

back(nextLeft, nextRight, sb.toString());

}

}

}

}

private void back(StackString left, StackString right, String s) {

for (int i = 0; i  right.size(); i++) {

String monkey1 = right.get(i);

StringBuffer sb = new StringBuffer();

sb.append(s);

sb.append(monkey1);

sb.append("-");

sb.append(" ");

if (rule2.isCanBoat(monkey1, monkey1, sb)) {

StackString nextLeft = new StackString();

StackString nextRight = new StackString();

nextLeft.addAll(left);

nextRight.addAll(right);

nextLeft.push(monkey1);

nextRight.remove(monkey1);

go(nextLeft, nextRight, sb.toString());

}

}

}

public static void main(String[] args) {

Monkey monkey = new Monkey();

monkey.boat();

}

}

interface Rule {

boolean isCanBoat(String m1, String m2, StringBuffer sb);

}

class Rule1 implements Rule {

String[] childMonkeys = { "a", "b", "c" };

String[] monkeys = { "A", "B", "C" };

public boolean isCanBoat(String m1, String m2, StringBuffer sb) {

if (m1.toLowerCase().equals(m2.toLowerCase())) {

return true;

}

ListString childMonkeysList = Arrays.asList(childMonkeys);

ListString monkeysList = Arrays.asList(monkeys);

if ((monkeysList.contains(m1)  monkeysList.contains(m2))

|| (childMonkeysList.contains(m1)  childMonkeysList.contains(m2))) {

return true;

}

sb.append("大猴欺负小猴！");

System.out.println(sb.toString());

return false;

}

}

class Rule2 implements Rule {

String[] smartMonkeys = { "A", "B", "C", "a" };

public boolean isCanBoat(String m1, String m2, StringBuffer sb) {

ListString smartMonkeysList = Arrays.asList(smartMonkeys);

if (smartMonkeysList.contains(m1) || smartMonkeysList.contains(m2)) {

return true;

}

sb.append("没有会划船的猴子！");

System.out.println(sb.toString());

return false;

}

}

用java实现野人传教士过河问题

//CrossRiverQuestion.java

import java.util.ArrayList;

import java.util.List;

public class CrossRiverQuestion {

public static void main(String[] args) {

CrossRiverQuestion q = new CrossRiverQuestion(5, 4);

q.solveQuestion();

}

private int peoNum;

private int savageNum;

private ListNode resultList = new ArrayListNode();

public ListNode solveQuestion() {

Node n = new Node(peoNum,savageNum,0,0,0,new ArrayListInteger(),0,0);

boolean dfsResult = dfs(n);

if(dfsResult) {

resultList.add(0,n);

for(Node node : resultList) {

System.out.println("左岸传教士："+node.getLeftPeo()+"左岸野人： "+node.getLeftSavage()+" 右岸传教士： "+node.getRightPeo()+"右岸野人："+node.getRightSavage()+"船上传教士："+node.getOnBoatPeoNum()+"船上野人："+node.getOnBoatSavageNum());

}

return resultList;

}

return null;

}

public CrossRiverQuestion(int peoNum, int savageNum) {

super();

this.peoNum = peoNum;

this.savageNum = savageNum;

}

private boolean dfs(Node n) {

if(n.hasVisited()) return false;

n.addCheckSum();

if(n.getLeftPeo()==0n.getLeftSavage()==0) return true;

if(n.getLeftPeo()0||n.getRightPeo()0||n.getLeftSavage()0||n.getRightSavage()0) {

return false;

}

if(n.getLeftPeo()n.getLeftSavage()n.getLeftPeo()0) return false;

if(n.getRightPeo()n.getRightSavage()n.getRightPeo()0) return false;

if(n.getCURR_STATE()==n.getStateBoatLeft()) {

Node n1 = new Node(n.getLeftPeo()-1,n.getLeftSavage()-1,n.getRightPeo()+1,n.getRightSavage()+1,n.getStateBoatRight(),n.getNodesCheckSum(),1,1);

if(dfs(n1)) {

resultList.add(0,n1);

return true;

}

Node n4 = new Node(n.getLeftPeo()-2,n.getLeftSavage(),n.getRightPeo()+2,n.getRightSavage(),n.getStateBoatRight(),n.getNodesCheckSum(),2,0);

if(dfs(n4)) {

resultList.add(0,n4);

return true;

}

Node n5 = new Node(n.getLeftPeo(),n.getLeftSavage()-2,n.getRightPeo(),n.getRightSavage()+2,n.getStateBoatRight(),n.getNodesCheckSum(),0,2);

if(dfs(n5))  {

resultList.add(0,n5);

return true;

}

} 

else {

Node n6 = new Node(n.getLeftPeo(),n.getLeftSavage()+1,n.getRightPeo(),n.getRightSavage()-1,n.getStateBoatLeft(),n.getNodesCheckSum(),0,1);

if(dfs(n6)) {

resultList.add(0,n6);

return true;

}

Node n7 = new Node(n.getLeftPeo()+1,n.getLeftSavage(),n.getRightPeo()-1,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),1,0);

if(dfs(n7)) {

resultList.add(0,n7);

return true;

}

Node n1 = new Node(n.getLeftPeo()+1,n.getLeftSavage()+1,n.getRightPeo()-1,n.getRightSavage()-1,n.getStateBoatLeft(),n.getNodesCheckSum(),1,1);

if(dfs(n1)) {

resultList.add(0,n1);

return true;

}

Node n4 = new Node(n.getLeftPeo()+2,n.getLeftSavage(),n.getRightPeo()-2,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),2,0);

if(dfs(n4)) {

resultList.add(0,n4);

return true;

}

Node n5 = new Node(n.getLeftPeo(),n.getLeftSavage()+2,n.getRightPeo(),n.getRightSavage()-2,n.getStateBoatLeft(),n.getNodesCheckSum(),0,2);

if(dfs(n5))  {

resultList.add(0,n5);

return true;

}

}

return false;

}

public ListNode getResultList() {

return resultList;

}

}

Node.java

import java.util.ArrayList;

import java.util.List;

public class Node {

private ListInteger nodesCheckSum = new ArrayListInteger();

private int leftPeo;

private int rightPeo;

private int leftSavage;

private int rightSavage;

private int CURR_STATE = 0;

private int onBoatPeoNum = 0;

private int onBoatSavageNum = 0;

private final int STATE_BOAT_LEFT = 0;

private final int STATE_BOAT_RIGHT = 1;

public Node(int leftPeo, int leftSavage, int rightPeo, int rightSavage, int state, List checkSumList, int onBoatPeoNum, int onBoatSavageNum) {

this.CURR_STATE = state;

this.leftPeo = leftPeo;

this.leftSavage = leftSavage;

this.rightPeo = rightPeo;

this.rightSavage = rightSavage;

this.nodesCheckSum.addAll(checkSumList);

this.onBoatPeoNum = onBoatPeoNum;

this.onBoatSavageNum = onBoatSavageNum;

}

public int getLeftPeo() {

return leftPeo;

}

public void setLeftPeo(int leftPeo) {

this.leftPeo = leftPeo;

}

public int getRightPeo() {

return rightPeo;

}

public void setRightPeo(int rightPeo) {

this.rightPeo = rightPeo;

}

public int getLeftSavage() {

return leftSavage;

}

public void setLeftSavage(int leftSavage) {

this.leftSavage = leftSavage;

}

public int getRightSavage() {

return rightSavage;

}

public void setRightSavage(int rightSavage) {

this.rightSavage = rightSavage;

}

@Override

public String toString() {

return leftPeo+","+leftSavage+","+rightPeo+","+rightSavage+","+CURR_STATE;

}

public int getCURR_STATE() {

return CURR_STATE;

}

public void setCURR_STATE(int cURR_STATE) {

CURR_STATE = cURR_STATE;

}

public int getStateBoatLeft() {

return STATE_BOAT_LEFT;

}

public int getStateBoatRight() {

return STATE_BOAT_RIGHT;

}

public int calcCheckSum() {

return 1*getCURR_STATE()+10*getLeftPeo()+100*getLeftSavage()+1000*getRightPeo()+10000*getRightSavage();

}

public void addCheckSum() {

int checkSum = calcCheckSum();

nodesCheckSum.add(checkSum);

}

public boolean hasVisited() {

int sum = calcCheckSum();

for (Integer checkSum : nodesCheckSum) {

if(checkSum==sum) return true;

}

return false;

}

public ListInteger getNodesCheckSum() {

return nodesCheckSum;

}

public int getOnBoatPeoNum() {

return onBoatPeoNum;

}

public void setOnBoatPeoNum(int onBoatPeoNum) {

this.onBoatPeoNum = onBoatPeoNum;

}

public int getOnBoatSavageNum() {

return onBoatSavageNum;

}

public void setOnBoatSavageNum(int onBoatSavageNum) {

this.onBoatSavageNum = onBoatSavageNum;

}

}

跪求手机版FINAL FANTASY （java)攻略~Q聊~能帮到我就有分~份不是问题！！！！790092231

剧情之后，四位勇士踏上了旅程。开始直接进入城堡2层，和一个堵门的卫兵对话。就会被带到城里。得知公主被骑士嘉兰得绑架了。国王希望光之战士前往混沌神殿，救出公主，作为报酬，他会修好北面的断桥。为了拯救这个腐朽的世界，勇士们答应了国王的要求（不答应也不行）。先去在村庄里买好道具，装备和LV1魔法。这里的魔法只能通过金钱购买，越后面能买到魔法的威力越大，当然也越贵。魔法的效果在游戏中有介绍，不清楚可以跟帖询问。之后可以在村庄周围练练级，没血没魔了就回村里的旅店里睡一觉。大概5，6级后，往西北方向走，来到混沌神殿。向上走一直走，BOSS战没什么难度。之后久出公主，然后自动会到城里。国王履行承诺，把桥修好了。剧情完之后和公主对话，得到贵重品琵琶。走到桥上时，序章结束，勇士们的真正旅程从现在开始。

过桥后往右走，来到港町，从村民口中得知这里已经被海盗占领了，来到左上角与海盗头目对话后，发生战斗，这里推荐用黑魔法催眠，会使战斗异常简单，胜利之后得到贵重品船。这里可以买LV2的魔法。坐船从港口出发后沿着下方的山脉向下，之后一路向左，在新的港口上岸后往下来到精灵城堡，在中间的房间从御医处得知精灵王子被诅咒，一睡不醒。得想办法找让王子醒过来的药才行。这里可以买LV3和LV4的魔法。准备一下之后从左上方的道路迂回来到沼之洞窟。这里最好有个是12级左右，而且要带够解毒药。从上方的道路来到2F，拿完宝箱后走右下来到3F。这里有16个房间，在第三排左数第2个房间进行强制战斗后拿到贵重品皇冠。这里的其他房间都有宝箱，注意搜刮。出洞窟之后向北走，来到西之城。在里面房间里遇到BOSS，他有即死魔法，需要买一些凤凰之尾。胜利得到贵重品水晶之目。

之后回到最开始的城堡，过桥之后向左走，来到最北端的洞窟，和里面的魔女对话后得到贵重品苏醒药

之后就可以回去给精灵王子服用。之后得到神秘钥匙。有了钥匙就可以去打开之前不能打开的房间了。回到最初的城堡里，打开需要用神秘钥匙的房间后，从里面拿到贵重品硝基炸药。之后前往矮人洞窟，在右下下找一个老头对话。老头拿炸药把大陆炸出一条运河出来

之后从缺口一直往左就可以出海来到一个很萧条村庄。从村民口中得知这是吸血鬼破坏地之水晶的结果。在这里补充一下装备，道具，买点LV5的魔法，如果之前没学解毒的魔法，这里一定要带够解毒药。然后经过狭长通路后前往下方半岛的洞穴。这里有些宝箱周围都会强制遇敌，要注意。而且还有些小的区域也会强制遇敌，走一步遇一次。碰到这种地方就换路走吧。（不过基本上这种区域都是存在与宝箱周围的。后面的迷宫这种地方也存在）。来到3F，大概20级左右就能很轻松的杀掉吸血鬼（白魔的圣属性对其有特效）

宝箱里得到贵重品红宝石。

出洞窟向西走，来到巨人洞窟。给巨人吃了红宝石后，巨人让开了路，出去后到贤者洞窟。与贤者对话后得到贵重品土之杖。之后回到刚才的洞窟。在打败吸血鬼后面的石板处使用土之杖，出现新的通道，这里需要带够金针防止石化。一直往里面走，到5F最深出发生BOSS战。白魔的圣属性魔法对这个BOSS有特效。打败BOSS之后，土之水晶发光，土之祭坛开启，可以去土之隐藏迷宫了。不过由于隐藏迷宫对于现在的勇士们还太BT，所以还是等流程后期再去挑战。

从祭坛后边的魔法阵直接出洞窟，坐船来到大地图右下方的港口。这里可以买LV6魔法。村子东边有12个老头，问穿蓝衣服右边那个老头，得到贵重品独木舟。 之后就可以在小河里划船了。沿着河往上走，在依次走右左左的是岔口来到火山。 岩浆可以走，但是要掉血，掉血量是走一步掉一滴。火山有5层，最深处BOSS战。这里的敌人大多怕冰属性，包括Boss。胜利之后，火之水晶亮了，火之祭坛开启，可以去火之隐藏迷宫了。出洞窟之后，回到港口，坐船往北走，在大海和河流的交汇处，划小船进去。依次走上上左左的岔口来到冰之洞窟。要注意的是2F的房间里有碎冰，记得把宝箱开完后在才碎冰到3F去。从3F上楼到1F，才碎冰下到2楼四处都是碎冰的中间，拿到贵重品浮游石。

出洞穴之后，前往南部的沙漠地带，在那里使用浮游石就能获得飞空艇了。有了飞空艇就可以周游世界了，快坐上去爽一把吧！不过虽然飞空艇移动的时候不受地形影响，但是飞空艇只能降落在平原地带，所以某些地方就算用飞空艇还是得走很长的路````

来到地图左上方的群岛，在洞穴中找到龙王巴哈姆特，得知了转职条件后，到群岛东部的试练之城。

进去之后遇见一个老头，对话之后就可以用左边的台座传送到F2去了。迷宫里有很多传送器，进入之后就会传送到其他地方，而且只能传送过去，不能传送回来。所以还是尽量把宝箱收集完之后再传送吧。有时会遇到有2个或多个传送器的地方，走错的话就回到之前传送的地方。到了3F一直走下去，尽头的宝箱是贵重品老鼠尾巴。（老鼠尾巴居然是勇气之证````没搞懂龙王是怎么想的- -）之后去找龙王就可以转职了。

转职之后可以到左上方的大陆的湖泊下游，徒步上去，进入沙漠后再到北部和帐篷里面的人对话，可以得到贵重品精灵瓶（要花钱的，40000）。然后到世界东北大陆的村庄，进去之后妖精被释放。然后到湖边和妖精对话，得到贵重品空气之水（这里可以买到LV7的魔法）。之后前往西北大陆的村庄（这里可以买到LV7的魔法）。在村庄最右边和少女对话，少女消失之后就可以坐潜水艇到海底神殿去了。

这里的敌人大多怕火属性，辗转来到5F，在最左上方的宝箱里拿到贵重品玫瑰石。之后来到1F灭掉BOSS，胜利后水之水晶亮了，水之祭坛开启，可以去水之隐藏迷宫了。之后可以到群岛西部大陆，顺着小河上去，进入瀑布尽头的洞窟，和里面的机器人对话，可以得到贵重品跳跃方块。接着回到大地被腐蚀了的那个村庄，在墓地旁边找这个人对话，把玫瑰石交给他，在他解读石头之后，他就会教勇士们天空族的语言。之后到东北大陆半岛上的村庄，但是飞空艇只能停在小糊旁边的一小块平原处，需要一直往下。到了村庄之后，与右下角的人对话得到贵重品和谐钟，之后就可以去通天塔了（右上的缺口可以去买到最强的魔法)。

通天塔位于这块大陆的沙漠中心。1，2F中心的房间有不少好东西，来到3F通过传送石传送到浮游城。在浮游城2F拿到贵重品幻质金属。通过3F的水晶球得知4个神殿的力量都流向了一个地方，那就是混沌神殿。

4F是个循环区域，按照左上左上或者右下右下走就可以到达5F。然后就是BOSS战。攻击力加强魔法配合白魔的7级群体恢复，很轻松搞定后，风之水晶亮了，风之祭坛开启，可以去风之隐藏迷宫了。

回到矮人的洞穴，和上方的工匠矮人对话之后，得到石中剑（战士专用剑）（这把剑可以不去找矮人要，不过有总比没有的强，还是先拿着吧）然后就是最后的迷宫了。

来到混沌神殿里面的水晶那里，观察水晶后，水晶出现传送阵。里面是2000年前的混沌神殿。

在3F石碑前使用古之杖，出现楼梯。 一路走下去，在每层楼下楼处，都会和之前四个水晶神殿的BOSS战斗。第一层是大骷髅，第二层是蛇妖，第三层是章鱼，四层是龙（4F最右边可以拿到最强剑）。

最后，终于迎来了最终BOSS--混沌之嘉兰得。此BOSS十分强悍，拥有各种属性终极魔法，最无耻的是可以使用强大的全恢复魔法，一次给自己恢复9999的HP，相当BT- - 如果没有自虐倾向的朋友请等级高了再来挑战。

本文名称：java划船代码 java代码被划上横线
本文网址：http://ybzwz.com/article/dosjiei.html