1. package com.itheima;
   
2. 
   
3. import java.util.LinkedList;
   
4. 
   
5. /*
   
6. * 需求：  10、一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
7. * 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。
   
8. */
   
9. public class Test10 {
   
10.         public static void main(String[] args) {
    
11.                 // 定义两个LinkedList集合，用于表示此岸和彼岸
    
12.                 LinkedList<String> ciAn = new LinkedList<String>();
    
13.                 LinkedList<String> biAn = new LinkedList<String>();
    
14. 
    
15.                 // 初始时，此岸具有cat、dog、fish、person
    
16.                 ciAn.add("cat");
    
17.                 ciAn.add("dog");
    
18.                 ciAn.add("fish");
    
19.                 ciAn.add("person");
    
20. 
    
21.                 while (true) {
    
22.                         // 当此岸没有任何动物，就说明过河成功了，跳出循环
    
23.                         if (ciAn.size() == 0) {
    
24.                                 break;
    
25.                         }
    
26.                         // 过河
    
27.                         if (ciAn.contains("person")) {// peron在此案的情况
    
28.                                 ciAn.remove("person");
    
29.                                 String animal = ciAn.removeFirst();
    
30.                                 biAn.addLast(animal);
    
31.                                 biAn.addLast("person");
    
32. 
    
33.                                 boolean flag = isDaJia(ciAn, biAn);
    
34.                                 if (flag) {
    
35.                                         // 如果打架
    
36.                                         biAn.remove("person");
    
37.                                         biAn.remove(animal);
    
38.                                         ciAn.addLast(animal);
    
39.                                         ciAn.addLast("person");
    
40.                                 } else {
    
41.                                         // 否则
    
42.                                         System.out.println("person将" + animal + "带过河");
    
43.                                 }
    
44. 
    
45.                         } else {// person在彼岸的情况
    
46.                                 // person自己先回去
    
47.                                 biAn.remove("person");
    
48.                                 ciAn.addLast("person");
    
49. 
    
50.                                 boolean flag = isDaJia(ciAn, biAn);
    
51.                                 if (flag) {
    
52.                                         while (true) {
    
53.                                                 // 如果打架，就带走一个动物
    
54.                                                 String animal = biAn.removeFirst();
    
55.                                                 ciAn.add(animal);
    
56. 
    
57.                                                 if (isDaJia(ciAn, biAn)) {
    
58.                                                         // 如果还是打架，那个动物就回来
    
59.                                                         ciAn.remove(animal);
    
60.                                                         biAn.addLast(animal);
    
61.                                                 } else {
    
62.                                                         System.out.println("person将" + animal + "带回来");
    
63.                                                         break;
    
64.                                                 }
    
65.                                         }
    
66. 
    
67.                                 } else {
    
68.                                         // 不打架
    
69.                                         System.out.println("person自己回来");
    
70.                                 }
    
71.                         }
    
72.                 }
    
73. 
    
74.                 System.out.println("过河成功！");
    
75. 
    
76.         }
    
77. 
    
78.         // 判断河两岸是否有"打架"行为
    
79.         public static boolean isDaJia(LinkedList<String> ciAn,
    
80.                         LinkedList<String> biAn) {
    
81.                 if (!ciAn.contains("person")) {
    
82.                         if (ciAn.contains("cat")
    
83.                                         && (ciAn.contains("fish") || ciAn.contains("dog"))) {
    
84.                                 return true;
    
85.                         }
    
86.                 }
    
87. 
    
88.                 if (!biAn.contains("person")) {
    
89.                         if (biAn.contains("cat")
    
90.                                         && (biAn.contains("fish") || biAn.contains("dog"))) {
    
91.                                 return true;
    
92.                         }
    
93.                 }
    
94. 
    
95.                 return false;
    
96.         }
    
97. }
    

复制代码

2014heima 发表于 2014-10-20 20:53
这是第几天的知识点，我基础测试页有这题，，现还在看IO

集合那块的吧

李天富 发表于 2014-10-21 15:24
这问题我觉得，老农作为调解者和操作者，和猫狗鱼一样放入集合中是不是不太合适？因为他们属性是不一样的 ...

嗯，我觉得是考虑问题的思路不同吧，我是站在自己"玩游戏"的角度，比如有调条河，初始时这岸有老农、猫、狗、鱼，然后我用鼠标点击老农和相应的动物上船过河......你可能是站在"老农"的角度想我要带谁过河......而且因为不是主要考察面向对象的设计，所以我都用字符串表示的人和动物。但这样你的代码更精简！:)