java過河問題

A. 用java實現野人傳教士過河問題

//CrossRiverQuestion.java
importjava.util.ArrayList;
importjava.util.List;

publicclassCrossRiverQuestion{
publicstaticvoidmain(String[]args){
CrossRiverQuestionq=newCrossRiverQuestion(5,4);
q.solveQuestion();
}
privateintpeoNum;
privateintsavageNum;
privateList<Node>resultList=newArrayList<Node>();
publicList<Node>solveQuestion(){
Noden=newNode(peoNum,savageNum,0,0,0,newArrayList<Integer>(),0,0);
booleandfsResult=dfs(n);
if(dfsResult){
resultList.add(0,n);
for(Nodenode:resultList){
System.out.println("左岸傳教士："+node.getLeftPeo()+"左岸野人："+node.getLeftSavage()+"右岸傳教士："+node.getRightPeo()+"右岸野人："+node.getRightSavage()+"船上傳教士："+node.getOnBoatPeoNum()+"船上野人："+node.getOnBoatSavageNum());
}
returnresultList;
}
returnnull;
}

publicCrossRiverQuestion(intpeoNum,intsavageNum){
super();
this.peoNum=peoNum;
this.savageNum=savageNum;
}

privatebooleandfs(Noden){
if(n.hasVisited())returnfalse;
n.addCheckSum();
if(n.getLeftPeo()==0&&n.getLeftSavage()==0)returntrue;
if(n.getLeftPeo()<0||n.getRightPeo()<0||n.getLeftSavage()<0||n.getRightSavage()<0){
returnfalse;
}
if(n.getLeftPeo()<n.getLeftSavage()&&n.getLeftPeo()>0)returnfalse;
if(n.getRightPeo()<n.getRightSavage()&&n.getRightPeo()>0)returnfalse;
if(n.getCURR_STATE()==n.getStateBoatLeft()){
Noden1=newNode(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);
returntrue;
}
Noden4=newNode(n.getLeftPeo()-2,n.getLeftSavage(),n.getRightPeo()+2,n.getRightSavage(),n.getStateBoatRight(),n.getNodesCheckSum(),2,0);
if(dfs(n4)){
resultList.add(0,n4);
returntrue;
}
Noden5=newNode(n.getLeftPeo(),n.getLeftSavage()-2,n.getRightPeo(),n.getRightSavage()+2,n.getStateBoatRight(),n.getNodesCheckSum(),0,2);
if(dfs(n5)){
resultList.add(0,n5);
returntrue;
}
}
else{
Noden6=newNode(n.getLeftPeo(),n.getLeftSavage()+1,n.getRightPeo(),n.getRightSavage()-1,n.getStateBoatLeft(),n.getNodesCheckSum(),0,1);
if(dfs(n6)){
resultList.add(0,n6);
returntrue;
}
Noden7=newNode(n.getLeftPeo()+1,n.getLeftSavage(),n.getRightPeo()-1,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),1,0);
if(dfs(n7)){
resultList.add(0,n7);
returntrue;
}
Noden1=newNode(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);
returntrue;
}
Noden4=newNode(n.getLeftPeo()+2,n.getLeftSavage(),n.getRightPeo()-2,n.getRightSavage(),n.getStateBoatLeft(),n.getNodesCheckSum(),2,0);
if(dfs(n4)){
resultList.add(0,n4);
returntrue;
}
Noden5=newNode(n.getLeftPeo(),n.getLeftSavage()+2,n.getRightPeo(),n.getRightSavage()-2,n.getStateBoatLeft(),n.getNodesCheckSum(),0,2);
if(dfs(n5)){
resultList.add(0,n5);
returntrue;
}
}
returnfalse;
}
publicList<Node>getResultList(){
returnresultList;
}

}

Node.java

importjava.util.ArrayList;
importjava.util.List;

publicclassNode{
privateList<Integer>nodesCheckSum=newArrayList<Integer>();
privateintleftPeo;
privateintrightPeo;
privateintleftSavage;
privateintrightSavage;
privateintCURR_STATE=0;
privateintonBoatPeoNum=0;
privateintonBoatSavageNum=0;
privatefinalintSTATE_BOAT_LEFT=0;
privatefinalintSTATE_BOAT_RIGHT=1;
publicNode(intleftPeo,intleftSavage,intrightPeo,intrightSavage,intstate,ListcheckSumList,intonBoatPeoNum,intonBoatSavageNum){
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;
}
publicintgetLeftPeo(){
returnleftPeo;
}
publicvoidsetLeftPeo(intleftPeo){
this.leftPeo=leftPeo;
}
publicintgetRightPeo(){
returnrightPeo;
}
publicvoidsetRightPeo(intrightPeo){
this.rightPeo=rightPeo;
}
publicintgetLeftSavage(){
returnleftSavage;
}
publicvoidsetLeftSavage(intleftSavage){
this.leftSavage=leftSavage;
}
publicintgetRightSavage(){
returnrightSavage;
}
publicvoidsetRightSavage(intrightSavage){
this.rightSavage=rightSavage;
}
@Override
publicStringtoString(){
returnleftPeo+","+leftSavage+","+rightPeo+","+rightSavage+","+CURR_STATE;
}
publicintgetCURR_STATE(){
returnCURR_STATE;
}
publicvoidsetCURR_STATE(intcURR_STATE){
CURR_STATE=cURR_STATE;
}
publicintgetStateBoatLeft(){
returnSTATE_BOAT_LEFT;
}
publicintgetStateBoatRight(){
returnSTATE_BOAT_RIGHT;
}
publicintcalcCheckSum(){
return1*getCURR_STATE()+10*getLeftPeo()+100*getLeftSavage()+1000*getRightPeo()+10000*getRightSavage();
}
publicvoidaddCheckSum(){
intcheckSum=calcCheckSum();
nodesCheckSum.add(checkSum);
}
publicbooleanhasVisited(){
intsum=calcCheckSum();
for(IntegercheckSum:nodesCheckSum){
if(checkSum==sum)returntrue;
}
returnfalse;
}
publicList<Integer>getNodesCheckSum(){
returnnodesCheckSum;
}
publicintgetOnBoatPeoNum(){
returnonBoatPeoNum;
}
publicvoidsetOnBoatPeoNum(intonBoatPeoNum){
this.onBoatPeoNum=onBoatPeoNum;
}
publicintgetOnBoatSavageNum(){
returnonBoatSavageNum;
}
publicvoidsetOnBoatSavageNum(intonBoatSavageNum){
this.onBoatSavageNum=onBoatSavageNum;
}

}

B. 用JAVA編一個關於猛獸過河問題的程序

六種動物過河,是大小虎,大小豹,大小熊,大熊大獅大虎小熊會劃船,只有一隻船並且一次只能載兩只動物,注意，小的旁邊如果有其他大的而沒有自己大的就會被欺負(大不吃大,小不吃小),怎麼能使它們全過河?（最好有原代碼提供，謝了~~）

附：
猛獸過河的過程為：
第一步：小熊和小虎過去————小雄回來送船
第二步：小熊和小豹過去————小熊回來送船
第三步：大豹子和大虎過去————大虎和小虎送船
第四步：小熊和大熊過去--------大豹和小豹回來送船
第五步：大豹和大虎過去-------小熊回來送船
第六步：小熊和小虎過去---------小熊回來
第七步:小熊和小豹過去

微軟的一條面試題（和猛獸過河問題很相似,供參考）：
三隻母雞，三隻小雞在河東岸，一條小舟每次最多載兩只雞（大小不論）。
條件：
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結構指針);

}
}

急求！！！

C. 我用java寫了一個商人過河的程序，但是有一個錯誤，大家幫我找一下

if((isavilable(a,stage[i],b))&&(mark[i]!=0))

D. java 野人過河問題

完全無難度
野人位置（X），河寬長（w）
過河方法：
runrain（x,y）{
if(x<=w){
x++;
}else（）{
x=w;//剛過完河位置
}

E. 農夫過河問題，從JAVA代碼看演算法

好繁瑣...一堆if else...你不覺得很麻煩嗎? 我給你提個思路. 你每個Goods object裡面都設置一個天敵的list.

Goodsg=newGoods("Sheep");
g.setEnemy(Arrays.asList(newString[]{"wolf"}));
Goodsg2=newGoods("Cabbage");
g2.setEnemy(Arrays.asList(newString[]{"Sheep"}));
Goodsg3=newGoods("Wolf");
g3.setEnemy(Arrays.asList(newString[]{}));

這樣你的在check isFriendly的時候, 只要檢測2個物品的enemyList裡面沒有自己就可以了.

return!good1.getEnemyList().contains(good2.getName())&&!good2.getEnemyList().contains(good1.getName());

F. 猴子過河 java演算法

importjava.util.Arrays;
importjava.util.List;
importjava.util.Stack;

publicclassMonkey{
publicString[]monkeys={"a","b","c","A","B","C"};

Rulerule1=newRule1();

Rulerule2=newRule2();

publicintcount=0;

publicStringBuffersuccess=newStringBuffer(2000);

publicvoidboat(){
Stack<String>left=newStack<String>();
Stack<String>right=newStack<String>();
for(inti=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+"種成功方案***********************");

}

privatevoidgo(Stack<String>left,Stack<String>right,Strings){
for(inti=0;i<left.size();i++){
Stringmonkey1=left.get(i);
for(intj=i+1;j<left.size();j++){
StringBuffersb=newStringBuffer();
Stringmonkey2=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))){
Stack<String>nextLeft=newStack<String>();
Stack<String>nextRight=newStack<String>();
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("
");
count++;
continue;
}
back(nextLeft,nextRight,sb.toString());
}
}
}

}

privatevoidback(Stack<String>left,Stack<String>right,Strings){
for(inti=0;i<right.size();i++){
Stringmonkey1=right.get(i);
StringBuffersb=newStringBuffer();
sb.append(s);
sb.append(monkey1);
sb.append("<-");
sb.append("");
if(rule2.isCanBoat(monkey1,monkey1,sb)){
Stack<String>nextLeft=newStack<String>();
Stack<String>nextRight=newStack<String>();
nextLeft.addAll(left);
nextRight.addAll(right);
nextLeft.push(monkey1);
nextRight.remove(monkey1);
go(nextLeft,nextRight,sb.toString());
}
}
}

publicstaticvoidmain(String[]args){
Monkeymonkey=newMonkey();
monkey.boat();
}
}

interfaceRule{
booleanisCanBoat(Stringm1,Stringm2,StringBuffersb);
}

classRule1implementsRule{

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

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

publicbooleanisCanBoat(Stringm1,Stringm2,StringBuffersb){

if(m1.toLowerCase().equals(m2.toLowerCase())){
returntrue;
}
List<String>childMonkeysList=Arrays.asList(childMonkeys);
List<String>monkeysList=Arrays.asList(monkeys);
if((monkeysList.contains(m1)&&monkeysList.contains(m2))
||(childMonkeysList.contains(m1)&&childMonkeysList.contains(m2))){
returntrue;
}
sb.append("大猴欺負小猴！");
System.out.println(sb.toString());
returnfalse;
}

}

classRule2implementsRule{

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

publicbooleanisCanBoat(Stringm1,Stringm2,StringBuffersb){
List<String>smartMonkeysList=Arrays.asList(smartMonkeys);

if(smartMonkeysList.contains(m1)||smartMonkeysList.contains(m2)){
returntrue;
}
sb.append("沒有會劃船的猴子！");
System.out.println(sb.toString());
returnfalse;
}

}

G. 如何用Java編寫三個線程實現狼羊白菜過河問題

開三個線程，一個代表狼，一個代表羊，一個代表白菜。
一艘船。兩個位置。
河有兩邊，
狼跟羊互斥，羊跟白菜互斥。
即他們不能在船不在此岸邊的時候同時存在。

狼，羊，白菜的線程去搶船的位置。（船在此岸）（2個位置，去搶吧，搶到了就占個座。。。。）
再開一個線程。。。。OYE~
船判斷能不能離岸，不能離就泄空。能就到對岸就把這兩個位置上的泄到對岸，船也到對岸。

然後狼，羊，白菜的線程繼續去搶船的位置。
船線程繼續判能不能離岸。（船上的位置剩餘0或1或2時只要2岸不出現互斥，都可以離岸）
能就走，不能就泄空。。。。

如此往復
直到有一天。。。3個都到對岸了。。OK了。。。

誰會要求寫出這樣沒有邏輯的純靠運氣的程序啊。。。
現在的學校真操蛋。。。。

H. java一個過河搭橋游戲，若木樁之間有木板則小人能到木板上，怎麼記住木板位置以及判斷木樁之間有無木板

判斷木樁的兩點左邊是否在木板上。你用swing。有發放判斷

I. 農夫過河問題(java)

這個是偶寫的 你可以參考下 寫的有點多 你自己優化下吧 之前還不知道農夫過河是啥意思 不過後來知道了 如果有問題的話可以馬上說的 你的50分偶要定咯！！(可以直接運行)

import java.util.Iterator;
import java.util.LinkedList;

public class AcrossTheRiver {
// 定義三個String對象
public static final String rabbitName = "Rabbit";
public static final String wolfName = "Wolf";
public static final String cabbageName = "Cabbage";

// 判斷兩個貨物之間關系是否友好 寫的麻煩了一點= =..
public static boolean isFriendly(Goods goods1, Goods goods2) {
if (goods1 != null) {
if (goods1.getGoodsName().trim().equals(rabbitName)) {
if (goods2 == null) {
return true;
} else {
return false;
}
} else if (goods1.getGoodsName().trim().equals(wolfName)) {
if (goods2 == null || goods2.getGoodsName().trim().equals(cabbageName)) {
return true;
} else {
return false;
}
} else if (goods1.getGoodsName().trim().equals(cabbageName)) {
if (goods2 == null || goods2.getGoodsName().trim().equals(wolfName)) {
return true;
} else {
return false;
}
} else {
return false;
}
} else {
return true;
}
}

// 我就直接寫在主方法里了
public static void main(String[] args) {
boolean isSuccess = false;
LinkedList<Goods> beforeCrossing = new LinkedList<Goods>();
LinkedList<Goods> afterCrossing = new LinkedList<Goods>();
beforeCrossing.add(new Goods(rabbitName));
beforeCrossing.add(new Goods(cabbageName));
beforeCrossing.add(new Goods(wolfName));
while (!isSuccess) {
Goods goods1 = beforeCrossing.getFirst();
System.out.println(goods1.getGoodsName() + " 被取走了");
beforeCrossing.removeFirst();
if (beforeCrossing.isEmpty()) {
afterCrossing.addLast(goods1);
isSuccess = true;
System.out.println("全部移動完畢！");
} else {
Iterator<Goods> it = beforeCrossing.iterator();
Goods[] beforeCro = new Goods[2];
for (int i = 0; it.hasNext(); i++) {
beforeCro[i] = it.next();
System.out.println(beforeCro[i].getGoodsName() + " 留了下來");
}
if (isFriendly(beforeCro[0], beforeCro[1])) {
if (afterCrossing.isEmpty()) {
afterCrossing.addLast(goods1);
System.out.println(goods1.getGoodsName() + " 被成功的放到了對岸");
} else {
Goods goods2 = afterCrossing.getFirst();
if (isFriendly(goods1, goods2)) {
afterCrossing.addLast(goods1);
System.out.println(goods1.getGoodsName() + " 被成功的放到了對岸");
} else {
beforeCrossing.addLast(goods2);
afterCrossing.removeFirst();
System.out.println(goods1.getGoodsName() + " 與 "
+ goods2.getGoodsName() + "並不和睦 於是把 " + goods2.getGoodsName()
+ "帶了回來 並將 " + goods1.getGoodsName() + " 留了下來");
}
}
} else {
beforeCrossing.addLast(goods1);
System.out.println("很可惜 留下來的兩個東西並不和睦 於是 " + goods1.getGoodsName()
+ " 又被放了回去");
}
}
}
}
}

// 貨物類
class Goods {
// 貨物名稱
private String goodsName;

// 默認構造方法
public Goods(String goodsName) {
this.goodsName = goodsName;
}

// 獲得貨物名稱
public String getGoodsName() {
return goodsName;
}

}

J. JAVA編程的邏輯題，大神幫下！謝謝

方法一：
import java.util.ArrayList;
import java.util.List;

public class test10 {

// 解題思路：先帶走貓，後帶走狗，再把貓帶回，把魚帶過去，最後再把貓帶過去即可

// 定義兩個集合，存放，帶過去的動物，和剩下的動物
static List<String> there = new ArrayList<String>();
static List<String> here = new ArrayList<String>();

public static void main(String[] args) {
here.add("cat");
here.add("dog");
here.add("fish");

test10 test10 = new test10();
test10.take();
}

// 判斷動物是否安全
public boolean isSafty(List<String> list) {
// 如果一個集合中同時出現了貓和狗，貓和魚的都認為不安全
if (list.add("dog") && list.add("cat") || list.add("cat")
&& list.add("fish")) {
return false;
}
return true;
}

public void take() {
// 得到要帶走的動物
String anim = here.get(0);
// 從剩下的集合中刪除
here.remove(here.get(0));

if (anim.equals("cat")) {

// 添加到以帶過去的集合裡面
there.add(anim);

// 繼續帶下一個動物
if (here.isEmpty()) {
System.out.println();
System.out.println("最後在把" + anim + "帶走了");
return;
} else {
System.out.println("帶走了" + anim);
System.out.print("剩下：");
for (String s : here) {
System.out.print(s + " ");
}
System.out.println();
System.out.println("----------------------------");
take();
}

} else if (anim.equals("dog")) {
there.add(anim);
System.out.println("然後把" + anim + "帶走");
// 判斷是否安全，之後繼續帶下一個動物
if (isSafty(there)) {
take();
} else {
String animal = there.get(0);
there.remove(animal);
here.add(animal);
System.out.println("然後把" + animal + "帶回");
// 繼續帶下一個動物
take();
}
} else if (anim.equals("fish")) {
System.out.print("之後把" + anim + "帶走");

take();
}
}
}

方法二：
import java.util.ArrayList;
import java.util.Random;

/*
* 需求:
* 一位老農帶著貓、狗、魚過河，河邊有一條船，每次老農只能帶一隻動物過河。
* 當老農不和貓狗魚在一起時，狗會咬貓，貓會吃魚，當老農和貓狗魚在一起時，則不會發生這種問題。
* 編程解決貓狗魚過河問題。
* 分析:
* 定義貓,狗,魚元素.定義兩岸集合.定義方法判斷不和諧狀況.
* 步驟:
* 1.將貓狗魚抽象為三個String型變數.將兩岸抽象為兩個集合.
* 2.定義判斷是否和諧方法.
* */

public class Test10 {
public static void main(String[] args) {
//開始過河.
doTransport();
}

public static void doTransport() {
// 抽象出貓,魚,狗和兩岸.
ArrayList<String> arr1 = new ArrayList<String>();
ArrayList<String> arr2 = new ArrayList<String>();
arr1.add("魚");
arr1.add("貓");
arr1.add("狗");
// 農夫將要攜帶到船上動物.(前一字元表示農夫當前攜帶動物,後一字元表示上次農夫攜帶的動物,為了讓農夫不出現重復拿同一個動物的情況)
System.out.println("農夫,貓,魚,狗都在此岸,開始過河.\n");
String[] boat ={"-","-"};
while (arr1.size() > 0) {
move(arr1, arr2, boat);
}
System.out.println("\n農夫,貓,魚,狗都到達彼岸.");
}

public static void move(ArrayList<String> arr1, ArrayList<String> arr2,String[] boat) {
//農夫船上是否有動物,有則不需隨機選擇攜帶.
if (boat[0].equals("-")) {
int one=0;
do{
// 農夫從此岸隨機帶上一個動物.
one = new Random().nextInt(arr1.size());
}while(arr1.get(one).equals(boat[1]));
boat[1]=boat[0];
boat[0] = arr1.get(one);
arr1.remove(one);
}
// 判斷此岸是否和諧
if (ifNice(arr1)) {
// 此岸和諧,農夫則將動物送去彼岸.
arr2.add(boat[0]);
System.out.println("--->農夫帶" + boat[0] + "去彼岸 ");
//首先判斷是否將三個動物都放彼岸,是則無需判斷是否和諧.
if(arr2.size()==3){
return;
}
// 判斷彼岸是否和諧.
if (ifNice(arr2)) {
// 彼岸和諧,農夫則完成此次運送.
boat[1]=boat[0];
boat[0] ="-";
System.out.println(" 農夫單獨回此岸<---");
} else {
// 彼岸不和諧,農夫則將岸上動物與攜帶動物交換.送回此岸.
boat[0]=arr2.get(0);
System.out.println(" 農夫帶" +boat[0]+ "回此岸<---");
arr2.remove(0);
arr1.add(boat[0]);
boat[1]=boat[0];
boat[0]="-";
}
} else {
// 如果此岸不和諧則放回此岸.
arr1.add(boat[0]);
boat[1]=boat[0];
boat[0]="-";
}
}

public static boolean ifNice(ArrayList<String> arr) {// 判斷是能否共存.
if ((arr.contains("貓") && arr.contains("狗"))
|| (arr.contains("魚") && arr.contains("貓"))) {
return false;
} else {
return true;
}
}
}