1. import java.util.ArrayList;
   
2. import java.util.HashMap;
   
3. import java.util.List;
   
4. import java.util.Map;
   
5. import java.util.Random;
   
6. 
   
7. /*一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
8. 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。*/
   
9. public class Test10 {
   
10. /**
    
11. * 解题思路
    
12. * 把出发岸边，目的岸边，船都看做一个容器，容器中有动物和农夫
    
13. * 把农夫和动物用map产生与数值对应的关系，用以生成判断条件
    
14. * @param args
    
15. */
    
16.         public static void main(String[] args) {
    
17.                 while(true)
    
18.                 new Test10().move();//创建一个无限循环，在方法中执行终止
    
19.                
    
20.         }
    
21.         public void move()
    
22.         {
    
23.                 Map<String, Integer> solution=new HashMap<String, Integer>();
    
24.                 /*创建一个map，其键为要运动的对象名称
    
25.                  * 值为对应数值，用以将名称对应称数字判断
    
26.                  * 为了让任意两数之和都不同,数值设为2的n次方
    
27.                  */
    
28.                 solution.put("fish",1);
    
29.                 solution.put("cat", 2);
    
30.                 solution.put("dog",4);
    
31.                 solution.put("farmer",8);
    
32.                 Random rand=new Random(41);//创建一个随机类，
    
33.                 String str=new String("fish,cat,dog,farmer");//创建包含了所有对象的容器将其设为初始的出发一侧
    
34.                 String [] strlist=str.split(",");
    
35.                 List<String> origSide=new ArrayList<String>();
    
36.                 for(int p=0;p<strlist.length;p++)
    
37.                 origSide.add(strlist[p]);
    
38.                 /*
    
39.                  * 两个空容器，分别是运输工具船和对岸
    
40.                  */
    
41.                 List<String> boat=new ArrayList<String>();
    
42.                 List<String> destSide=new ArrayList<String>();
    
43.                 System.out.println("初始状态:\n 出发岸边有 :farmer,dog,cat,fish");
    
44.                 int j=1;//计步器
    
45.                 outer://如果第一步条件判断为假，从这里重新开始循环
    
46.                 while(!origSide.isEmpty())//不为空则循环
    
47.                 {       
    
48.                         origSide.remove("farmer");//移除farmer
    
49.                         if(origSide.isEmpty())
    
50.                         break;//如果移除farmer后容器为空，则跳出该循环
    
51.                         String first=origSide.get(rand.nextInt(origSide.size()));//从溢出了famer后的容器中的对象中随机挑取一个
    
52.                         /*
    
53.                          * boat容器中添加
    
54.                          */
    
55.                         boat.add(first);
    
56.                         boat.add("farmer");
    
57.                         System.out.println("第"+j+"步:把"+first+"移到船上，带到对岸");
    
58.                         j++;
    
59.                         origSide.remove(first);//出发一侧移除随机选择的一个对象
    
60.                         /*
    
61.                          * 下面是判断是否执行第二步的条件，根据题意规则
    
62.                          */
    
63.                         int sum=0;
    
64.                         for(int o=0;o<origSide.size();o++)
    
65.                         sum+=solution.get(origSide.get(o));
    
66.                         if(sum==3||sum==6||sum==7)
    
67.                         continue outer;        //直接跳至outer
    
68.                        
    
69.                        
    
70.                         if(!boat.isEmpty())//其实在这一步boat肯定不为空
    
71.                                 /*
    
72.                                  * 卸载boat，移到对岸
    
73.                                  */
    
74.                                         {
    
75.                                         boat.remove("farmer");
    
76.                                         destSide.add(boat.get(0));
    
77.                                         destSide.add("farmer");
    
78.                                         boat.remove(0);
    
79.                                         }
    
80.                                 int size=destSide.size();//进入第三步，判断对岸容器大小       
    
81.                                 if(size==2)
    
82.                                 {
    
83.                                         /*
    
84.                                          * 在对岸大小为2时，即农夫和一个动物,把farmer和动物都移除就毫无意义了，所以只移除farmer
    
85.                                          */
    
86.                                         boat.add("farmer");
    
87.                                         destSide.remove("farmer");
    
88.                                         boat.remove("farmer");
    
89.                                         origSide.add("farmer");
    
90.                                         System.out.println("第"+j+"步：不从对岸带回任何东西");
    
91.                                         j++;
    
92.                                 }
    
93.                                
    
94.                                 else if (size==3)
    
95.                                 {
    
96.                                         //判断对岸大小为3时的情形
    
97.                                         int sum2=0;
    
98.                                         destSide.remove("farmer");
    
99.                                         for(int o=0;o<destSide.size();o++)
    
100.                                         {
     
101.                                         sum2+=solution.get(destSide.get(o));
     
102.                                         }
     
103.                                         //情况1，移除农夫后，剩下两动物有冲突关系,需要带走一个
     
104.                                         if(sum2==3||sum2==6)
     
105.                                                 {
     
106.                                                         boat.add("farmer");
     
107.                                                         String second=destSide.get(rand.nextInt(2));
     
108.                                                         boat.add(second);
     
109.                                                         boat.remove(second);
     
110.                                                         destSide.remove(second);
     
111.                                                         origSide.add("farmer");
     
112.                                                         origSide.add(second);
     
113.                                                         System.out.println("第"+j+"步:把"+second+"移到船上，带回来");
     
114.                                                         j++;
     
115.                                                 }
     
116.                                                 else //情况2,没有冲突关系，则不需要带走剩下的动物
     
117.                                                 {
     
118.                                                         destSide.remove("farmer");
     
119.                                                         boat.add("farmer");
     
120.                                                         boat.remove("farmer");
     
121.                                                         origSide.add("farmer");
     
122.                                                         System.out.println("第"+j+"步：不从对岸带回任何东西");
     
123.                                                         j++;
     
124.                                                 }
     
125.                                         }
     
126.                                 else //当对岸大小为4时，意味着任务已经完成，退出整个循环
     
127.                                         break;
     
128.                 }
     
129.                 System.out.println("任务完成");
     
130.                 System.exit(0);
     
131.         }
     
132. }
     

复制代码

想了一个晚上，终于搞出来了，但是感觉拓展性不够，而且判断条件好别扭的说。

{:3_52:}这题好可怕

林吉前 发表于 2015-3-31 19:05
这题好可怕

我已开始也是这么想，但是后来思路来了，就根本停不下来啊。

我表示还是回去慢慢的看视频吧。

围观一下

还是继续看视频

对于现在的我来说还看不懂，不过还是赞一个！！！！！！！！

确实难

值得学习。

真的很变态，有思路就简单多了

我表示还是回去慢慢的看视频吧。

这题好难啦

跟楼主一比，感觉差距好大。。。。

这题真强。。。学习了。

真的很变态，有思路就简单多了

先拿来参考研究了~