一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，   狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。


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();
  }
}
}
执行结果如下图所示：

这个问题有点意思.我之前做了下,跟一学霸思维不太一样,他把猫狗鱼都封装了对象,并继承动物类,做的比较符合面向对象.
我的代码面向对象痕迹不够深.发给你参考下.

1. 
   
2. /*
   
3. * 需求:
   
4. * 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
5. * 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。
   
6. * 编程解决猫狗鱼过河问题。
   
7. * 分析:
   
8. * 定义猫,狗,鱼元素.定义两岸集合.定义方法判断不和谐状况.
   
9. * 步骤:
   
10. * 1.将猫狗鱼抽象为三个String型变量.将两岸抽象为两个集合.
    
11. * 2.定义判断是否和谐方法.
    
12. * */
    
13. 
    
14. public class Test10 {
    
15.         public static void main(String[] args) {
    
16.                 //开始过河.
    
17.                 doTransport();
    
18.         }
    
19. 
    
20.         public static void doTransport() {
    
21.                 // 抽象出猫,鱼,狗和两岸.
    
22.                 ArrayList<String> arr1 = new ArrayList<String>();
    
23.                 ArrayList<String> arr2 = new ArrayList<String>();
    
24.                 arr1.add("鱼");
    
25.                 arr1.add("猫");
    
26.                 arr1.add("狗");
    
27.                 // 农夫将要携带到船上动物.(前一字符表示农夫当前携带动物,后一字符表示上次农夫携带的动物,为了让农夫不出现重复拿同一个动物的情况)
    
28.                 System.out.println("农夫,猫,鱼,狗都在此岸,开始过河.\n");
    
29.                 String[] boat ={"-","-"};
    
30.                 while (arr1.size() > 0) {
    
31.                         move(arr1, arr2, boat);
    
32.                 }
    
33.                 System.out.println("\n农夫,猫,鱼,狗都到达彼岸.");
    
34.         }
    
35. 
    
36.         public static void move(ArrayList<String> arr1, ArrayList<String> arr2,String[] boat) {
    
37.                 //农夫船上是否有动物,有则不需随机选择携带.
    
38.                 if (boat[0].equals("-")) {
    
39.                 int one=0;
    
40.                 do{
    
41.                                 // 农夫从此岸随机带上一个动物.
    
42.                                 one = new Random().nextInt(arr1.size());
    
43.                         }while(arr1.get(one).equals(boat[1]));
    
44.                         boat[1]=boat[0];
    
45.                         boat[0] = arr1.get(one);
    
46.                         arr1.remove(one);
    
47.                 }
    
48.                 // 判断此岸是否和谐
    
49.                 if (ifNice(arr1)) {
    
50.                         // 此岸和谐,农夫则将动物送去彼岸.
    
51.                         arr2.add(boat[0]);
    
52.                         System.out.println("--->农夫带" + boat[0] + "去彼岸    ");
    
53.                         //首先判断是否将三个动物都放彼岸,是则无需判断是否和谐.
    
54.                         if(arr2.size()==3){
    
55.                                 return;
    
56.                         }
    
57.                         // 判断彼岸是否和谐.
    
58.                         if (ifNice(arr2)) {
    
59.                                 // 彼岸和谐,农夫则完成此次运送.
    
60.                                 boat[1]=boat[0];
    
61.                                 boat[0] ="-";
    
62.                                 System.out.println("    农夫单独回此岸<---");
    
63.                         } else {
    
64.                                 // 彼岸不和谐,农夫则将岸上动物与携带动物交换.送回此岸.
    
65.                                 boat[0]=arr2.get(0);
    
66.                                 System.out.println("    农夫带" +boat[0]+ "回此岸<---");
    
67.                                 arr2.remove(0);
    
68.                                 arr1.add(boat[0]);
    
69.                                 boat[1]=boat[0];
    
70.                                 boat[0]="-";
    
71.                         }
    
72.                 } else {
    
73.                         // 如果此岸不和谐则放回此岸.
    
74.                         arr1.add(boat[0]);
    
75.                         boat[1]=boat[0];
    
76.                         boat[0]="-";
    
77.                 }
    
78.         }
    
79. 
    
80.         public static boolean ifNice(ArrayList<String> arr) {// 判断是能否共存.
    
81.                 if ((arr.contains("猫") && arr.contains("狗"))
    
82.                                 || (arr.contains("鱼") && arr.contains("猫"))) {
    
83.                         return false;
    
84.                 } else {
    
85.                         return true;
    
86.                 }
    
87.         }
    
88. }
    
89.        

复制代码

保证了农夫的随机携带动物,两次操作不为同一个动物,以及最高效率过河.
应该有两种过法.都可以出现.

强悍！学习了

这道题就是绕了点

好帖子，学习了:)

我的基础测试也有这道题。楼上两位的代码粗略的看了一下。因为时间关系我也随便写了一个（意思是不严谨，一些健壮性的判断没做），希望能给其他同学一点灵感。我觉得我的代码很啰嗦。但是自认为我的思路比较简单。

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. 
   
6. /*10、 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
7. * 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。*/
   
8. 
   
9. /* 思路：这个问题需要先带走猫再带走狗，下次回来的时候带上猫这样
   
10. * 1.定义两个集合模拟两个地方，里面装的都是String用来模拟四种动物
    
11. * 2.定义一个方法判断集合的安全情况ture为安全false为部安全
    
12. * 3.这里由于时间比较紧张我就不和老师您互动了，我自己带着他们走一遍您看。如果中途出现打印false的情况就说嘛不安全。
    
13. * 麻烦老师您改代码试一下了。
    
14. */
    
15. public class Test10 {
    
16. 
    
17.         public static void main(String[] args) {
    
18.                 // TODO Auto-generated method stub
    
19.                 ArrayList<String> zheer = new ArrayList<String>();
    
20.                 ArrayList<String> naer = new ArrayList<String>();
    
21.                 zheer.add("farmer");
    
22.                 zheer.add("dog");
    
23.                 zheer.add("cat");                //初始化的时候大家都在zheer
    
24.                 zheer.add("fish");
    
25.                 //接下来模拟操作两地动物的变化情况。每当集合变化一次我们就判断一下此地是否安全，并打印出来。true代表安全 false代表不安全
    
26.                
    
27.                 //先让农夫带猫过去，zheer删除农夫和猫
    
28.                 zheer.remove("farmer");
    
29.                 zheer.remove("cat");
    
30.                 System.out.println(safety(zheer));  //判断zheer的安全情况
    
31.                 //农夫带猫到了naer，naer增加
    
32.                 naer.add("farmer");
    
33.                 naer.add("cat");
    
34.                 System.out.println(safety(naer));        //判断naer的安全情况
    
35.                 //农夫自己从naer回zheer
    
36.                 naer.remove("farmer");
    
37.                 zheer.add("farmer");
    
38.                 System.out.println(safety(naer));
    
39.                 System.out.println(safety(zheer));                //判断两地安全情况。以下都是重复步骤就不做注解了
    
40.                 //农夫从zheer带走狗到naer
    
41.                 zheer.remove("farmer");
    
42.                 zheer.remove("dog");
    
43.                 System.out.println(safety(zheer));
    
44.                 naer.add("farmer");
    
45.                 naer.add("dog");
    
46.                 System.out.println(safety(naer));
    
47.                 //农夫从naer带走猫到zheer
    
48.                 naer.remove("farmer");
    
49.                 naer.remove("cat");
    
50.                 System.out.println(safety(naer));
    
51.                 zheer.add("farmer");
    
52.                 zheer.add("cat");
    
53.                 System.out.println(safety(zheer));
    
54.                 //农夫从zheer带走鱼到naer
    
55.                 zheer.remove("farmer");
    
56.                 zheer.remove("fish");        //鱼等了这么久才得到农夫的关爱，搞不好都死掉了
    
57.                 System.out.println(safety(zheer));
    
58.                 naer.add("farmer");
    
59.                 naer.add("fish");
    
60.                 System.out.println(safety(naer));
    
61.                 //农夫自己过去把猫带过来
    
62.                 naer.remove("farmer");
    
63.                 System.out.println(safety(naer));
    
64.                 zheer.add("farmer");
    
65.                 System.out.println(safety(zheer));
    
66.                 //农夫带着猫终于过去了
    
67.                 zheer.remove("farmer");
    
68.                 zheer.remove("cat");
    
69.                 System.out.println(safety(zheer));
    
70.                 naer.add("farmer");
    
71.                 naer.add("cat");
    
72.                 System.out.println(safety(naer));
    
73.                
    
74.                 //最后打印一下集合两遍的成员，看看是否都在
    
75.                 System.out.println(zheer);
    
76.                 System.out.println(naer);
    
77.         }
    
78.         public static boolean safety(ArrayList<String> arr){        //调用此方法判断集合是否安全，true为安全flase不安全
    
79.                 if(arr.indexOf("farmer")!=-1)  //如果农夫存在这个集合，那么肯定是太平的
    
80.                         return true;
    
81.                 if(arr.indexOf("dog")!=-1&&arr.indexOf("cat")!=-1)        //如果农夫不在狗在猫也在就不太平
    
82.                         return false;
    
83.                 if(arr.indexOf("cat")!=-1&&arr.indexOf("fish")!=-1)        //如果农夫不在猫和鱼同时存在也是不安全的
    
84.                         return false;
    
85.                 return true;        //如果以上情况都没有发生那么此地也是安全的               
    
86.         }
    
87. }

复制代码

好难啊！

好一额汗