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;
}
}
}