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

昨天刚刚搞定这题目，只要认真分析，将题目中涉及到的事物和行为进行抽象，利用编程语言表达出来，解题思路就清晰了。以下是我参考自刘望望同学回帖自己整理的代码分析：

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.         /**
   
10.          * 10、一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
    
11.          * 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。 编程解决猫狗鱼过河问题。
    
12.          *
    
13.          * @author Cavenzep
    
14.          */
    
15.         // 将河的两岸分别抽象成左右两个装有String的集合左岸（left）和右岸（right）
    
16.         List<String> left = new ArrayList<String>();
    
17.         List<String> right = new ArrayList<String>();
    
18. 
    
19.         // 初始化，老农、猫、狗、鱼都在河左岸准备渡河
    
20.         public Test10() {
    
21.                 left.add("老农");
    
22.                 left.add("猫");
    
23.                 left.add("狗");
    
24.                 left.add("鱼");
    
25. 
    
26.         }
    
27. 
    
28.         // 渡河
    
29.         public void crossRiver() {
    
30.                 while (left.size() > 1) {
    
31.                         left.remove("老农");
    
32.                         Random random = new Random();
    
33.                         // 老农在左岸随机带走一个动物
    
34.                         int index = random.nextInt(left.size());
    
35.                         // 防止老农带走上次带过来的动物，加快效率
    
36.                         if (left.size() > 1 && index == left.size() - 1) {
    
37.                                 left.add("老农");
    
38.                                 continue;
    
39.                         }
    
40.                         String L2R = left.get(index);
    
41.                         left.remove(L2R);
    
42.                         // 如果老农带走L2R后左岸和谐，则老农和L2R到达右岸
    
43.                         if (isSafe(left)) {
    
44.                                 right.add("老农");
    
45.                                 right.add(L2R);
    
46.                                 System.out.println("老农带着" + L2R + "到达右岸"
    
47.                                                 + currentStatus(left, right));
    
48.                                 // 老农到达右岸后判断是否完成渡河
    
49.                                 if (4 == right.size()) {
    
50.                                         break;
    
51.                                 }
    
52.                                 // 老农在右岸放下动物L2R准备返回
    
53.                                 right.remove("老农");
    
54.                                 // 如果老农返回后右岸和谐，则独自返回
    
55.                                 if (isSafe(right)) {
    
56.                                         left.add("老农");
    
57.                                         System.out.println("老农独自返回左岸" + currentStatus(left, right));
    
58.                                 } else { // 否则要在右岸随机带一个动物R2L返回
    
59.                                         String R2L = right.get(random.nextInt(right.size()));
    
60.                                         // 如果第一次随机到的动物R2L和L2R一样，则重新随机
    
61.                                         while (R2L.equals(L2R)) {
    
62.                                                 R2L = right.get(random.nextInt(right.size()));
    
63.                                         }
    
64.                                         right.remove(R2L);
    
65.                                         // 老农带着动物R2L返回
    
66.                                         left.add("老农");
    
67.                                         left.add(R2L);
    
68.                                         System.out.println("老农带着" + R2L + "返回左岸"
    
69.                                                         + currentStatus(left, right));
    
70.                                 }
    
71.                         } else { // 老农带走L2R后左岸不和谐，则放下该动物
    
72.                                 left.add(L2R);
    
73.                                 left.add("老农");
    
74.                         }
    
75. 
    
76.                 }
    
77.                 System.out.println("老农带着猫、狗、鱼成功渡河");
    
78.         }
    
79. 
    
80.         // 根据规则判断当前河岸是否和谐
    
81.         private boolean isSafe(List<String> arrayList) {
    
82.                 boolean flag = true;
    
83.                 // 如果某一岸边没有老农在，并且猫和其他动物在一起，就不和谐
    
84.                 if (arrayList.size() > 1 && arrayList.contains("猫")
    
85.                                 && !arrayList.contains("老农")) {
    
86.                         flag = false;
    
87.                 }
    
88.                 return flag;
    
89.         }
    
90. 
    
91.         // 显示河两岸当前的成员情况
    
92.         public String currentStatus(List<String> left, List<String> right) {
    
93.                 return "\t\t\tL:" + left.toString() + "------R:" + right.toString();
    
94.         }
    
95. 
    
96.         // 主函数
    
97.         public static void main(String[] args) {
    
98. 
    
99.                 Test10 test11 = new Test10();
    
100.                 test11.crossRiver();
     
101.         }
     
102. 
     
103. }
     

复制代码