一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时 ，则不会发生这种问题。编程解决猫狗鱼过河问题。
一开始看到这道题以为是多线程的题，做了做，没做出来。然后上网看了一下别人的思路，然后自己写了一下，也不知道对不对，下面是我的代码，你们都用的什么方法。

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. import java.util.Random;
   
6. 
   
7. public class Test10 {
   
8. 
   
9.         static List<String> riverBank1 = new ArrayList<String>();
   
10.         static List<String> riverBank2 = new ArrayList<String>();
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 riverBank1.add("cat");
    
14.                 riverBank1.add("dog");
    
15.                 riverBank1.add("fish");
    
16.                 take();
    
17.         }
    
18. 
    
19.         private static void take() {
    
20.                 String animal = riverBank1.remove(0);
    
21.                
    
22.                 if (animal.equals("cat")) {
    
23.                         //如果取到的是猫，并且河岸1没有动物了，说明猫是最后一个取到的
    
24.                         if (riverBank1.size() == 0) {
    
25.                                 riverBank2.add(animal);
    
26.                                 System.out.println("最后把" + animal + "带走！");
    
27.                         } else {
    
28.                                 riverBank2.add(animal);
    
29.                                 System.out.println("首先把" + animal + "带走！");
    
30.                                 take();
    
31.                         }
    
32.                 }
    
33.                 if (animal.equals("dog")) {
    
34.                         riverBank2.add(animal);
    
35.                         System.out.println("再把狗带走！");
    
36.                         if (!issafe(riverBank2)) {
    
37.                                 System.out.println("再把" + riverBank2.get(0) + "带回！");
    
38.                                 riverBank1.add(riverBank2.remove(0));
    
39.                         }
    
40.                         take();
    
41.                 }
    
42.                 if (animal.equals("fish")) {
    
43.                                 riverBank2.add(animal);
    
44.                                 System.out.println("然后把" + animal + "带走！");
    
45.                         take();
    
46.                 }
    
47.         }
    
48. 
    
49.         public static boolean issafe(List<String> animals) {
    
50.                 if (animals.contains("dog") && animals.contains("cat")
    
51.                                 || animals.contains("cat") && animals.contains("fish")) {
    
52.                         return false;
    
53.                 }
    
54.                 return true;
    
55.         }
    
56. }
    

复制代码

我用了最土的方法，可是老师给的分还挺高的，谢谢老师，同时也给大家分享一下吧：
package com.itheima;

import java.util.ArrayList;

/**
*   第10题：
*   一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
*   当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，
*   则不会发生这种问题。编程解决猫狗鱼过河问题。
*   思路：
*   //1--先带猫过去
*     2--然后回来把鱼带过
*     3--把猫带回来
*     4--再把狗带过去
*     5--再回来带猫
*/
public class Test10 {

        public static void main(String[] args) {
                //定义河的两岸——here+there，狗，猫，鱼作为集合变量存入
                ArrayList<String> here = new ArrayList<String>();  
                ArrayList<String> there = new ArrayList<String>();
       //狗，猫，鱼全在here
       here.add("狗");
       here.add("猫");
       here.add("鱼");
       System.out.println("农夫和"+here+"都在此岸，此时开始渡河------");
   //    overRiver(here,there,"猫");
       while(here.size()>0){   //只要此岸还有动物就要不断运送,运输遵循先进先出的原则。
               String lastAnimal = null;
              //第1次随机运送一只动物过到对岸
               for(int i=0;i<here.size();i++){
                       if((lastAnimal=overRiver(here,there,here.get(0)))!=null){
                               System.out.println("第1次：运输成功！");
                               break;
                       }
               }
               //第2次随机运送一只动物过到对岸
               for(int i=0;i<here.size();i++){
                       if((lastAnimal=overRiver(here,there,here.get(0)))!=null){
                               System.out.println("第2次：运输成功！");
                               break;
                       }
               }
               System.out.println("此岸："+here+"---彼岸："+there);
          //第3次，对岸有猫和鱼，把猫运输过来此岸
               for(int i=0;i<here.size();i++){
                       String getAnimal = null;   //定义要带走的动物
                       if((getAnimal=there.get(0))==lastAnimal)
                               continue;              //若是上一次的动物就再选择一次
                       if((lastAnimal=overRiver(there,here,getAnimal))!=null){   //对岸有猫和鱼，把猫运输过来此岸
                               System.out.println("第3次：运输成功！");
                               break;
                       }
               }
               //第4次，返回的时候把狗运送到对岸
               for(int i=0;i<here.size();i++){
                       String getAnimal = null;   //定义要带走的动物
                       if((getAnimal=here.get(0))==lastAnimal)
                               continue;              //若是上一次的动物就再选择一次
                       if((lastAnimal=overRiver(here,there,getAnimal))!=null){
                               System.out.println("第4次：运输成功！");
                               break;
                       }
               }
               //第5次，回去再把把猫运送到对岸
               for(int i=0;i<here.size();i++){
                       if((lastAnimal=overRiver(here,there,here.get(0)))!=null){
                               System.out.println("第5次：运输成功！");
                               break;
                       }
               }
   
       }
       System.out.println("已经成功渡河！农夫和"+there+"都成功到达彼岸。------");
        }
    public static String overRiver(ArrayList start,ArrayList end,String animal){
       if(start.remove(animal))
               end.add(animal);       //运送一只动物
            if(isSafety(start)){
                   System.out.println("农夫成功带着["+animal+"]去往目的地,出发地"+"剩下"+start);
                   return animal;
           }else{  //不和谐，把动物放回
                   if(end.remove(animal))
                       start.add(animal);       //返回原来那只动物
                   System.out.println("不安全，返回，把["+animal+"]放回,"+"出发地剩下"+start);
                   return null;
           }
    }
    public static boolean isSafety(ArrayList<String> arr) {// 判断是能否共存.
        if ((arr.contains("猫") && arr.contains("狗"))
                        || (arr.contains("鱼") && arr.contains("猫"))) {
                return false;
        } else {
                return true;
        }
}
   
}