1. package com.itheima;
   
2. /*
   
3.   一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
   
4. 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，
   
5. 则不会发生这种问题。编程解决猫狗鱼过河问题。
   
6. 需求分析：狗会咬猫，猫会吃鱼
   
7. 步骤：
   
8. 1.先将猫拿过去
   
9. 2.将鱼(狗)拿过去，不过要带着猫回来
   
10. 3.放下猫，再带着狗(鱼)过去
    
11. 4.最后带着猫过去
    
12. */
    
13. class PassRiver
    
14. {               
    
15.          String thisway =new String();
    
16.          String thatway =new String();
    
17.          String boxi=new String();
    
18.          String boxa=new String();int x ,y,time;
    
19.          boolean locate =true;
    
20.          String all[]={"猫","狗","鱼","老农"};
    
21.          
    
22. PassRiver()
    
23. {
    
24. thisway="猫狗鱼老农";
    
25. thatway="";
    
26. }
    
27.          
    
28. void re(){
    
29.         thisway= boxi;
    
30.         thatway=boxa;
    
31. }
    
32. 
    
33.                          String go(String str)
    
34.                          {
    
35.                                  if(locate=true)
    
36.                                  {
    
37.                                  thisway=thisway.replace(str, "");
    
38.                                  thatway=thatway.concat(str);
    
39.                                  thisway=thisway.replace("老农", "");
    
40.                                  thatway=thatway.concat("老农");
    
41.                                  }
    
42.                                  else if(safe()){ System.out.println("农夫带着"+str+"去对面了，这边还剩下"+thisway);}
    
43.                                         else re();
    
44.                                 y++;locate=false;
    
45.                                  return str;
    
46.                         
    
47.                          }
    
48.                         
    
49.                           String back(String str)
    
50.                          {        
    
51.                                  if(locate=false)
    
52.                                  {
    
53.                                  thatway=thatway.replace(str, "");
    
54.                                  thisway=thisway.concat(str);
    
55.                         
    
56.                                  thatway=thatway.replace("老农", "");
    
57.                                  thisway=thisway.concat("老农");
    
58.                                  }
    
59.                                  else if(safe()){
    
60.                                          System.out.println("农夫带着"+str+"回来了");}//这边有:"+thisway+",那边还剩下:"+thatway
    
61.                                 else {System.out.println("农夫空手回来了,这边有:"+thisway+",那边还剩下:"+thatway) ;re();};y++;
    
62.                                 locate=false; return str;
    
63.                          }
    
64.   boolean safe()//判断动物是否安全
    
65.   {                boolean sa;
    
66.                   sa=judge(thisway)&&judge(thatway);
    
67.                   if(sa);
    
68.                   else re();
    
69.                   return sa;
    
70.   }
    
71.         
    
72.          String printState()//输出状态方法
    
73.          {
    
74.                  String ps="现在本岸有："+thisway+"\n对岸有："+thatway;//
    
75.                  return ps;
    
76.          }
    
77.         
    
78.          
    
79. void play()//开始过河
    
80. //{        while((thatway.contains("猫")&&thatway.contains("鱼")&&thatway.contains("狗")&&thatway.contains("老农"))==false)
    
81.         {//System.out.println("1"+printState());
    
82.                 System.out.println("农夫,猫,鱼,狗都在这边,开始过河.\n");
    
83.                 while(thisway.contains(all[1])
    
84.                                 || thisway.contains(all[2])
    
85.                                 ||thisway.contains(all[0])||thisway.contains(all[3]))
    
86.                 {//        System.out.println("2"+printState());
    
87.                         //System.out.println("88");
    
88.                  while(locate&&thisway.contains(all[x])&safe())
    
89.                          {x=y%4;
    
90.                          System.out.println(time+printState());
    
91.                          go(all[x]);
    
92.                
    
93.                          System.out.println("333"+printState()); y++;
    
94.                         }
    
95.                 while((locate==false)&&thatway.contains(all[x])&safe())
    
96.                  {        x=y%4;
    
97.                         // System.out.println("4"+printState());
    
98.                          back(all[x]);
    
99.                         System.out.println("444"+printState()); y++;
    
100.                  }
     
101.                
     
102.                 }
     
103. 
     
104.                 //if(locate)locate=false;else locate=true;
     
105.          }
     
106. //}
     
107.                 Boolean judge(String str)
     
108.                 {        
     
109.                         if(str.contains("老农"))
     
110.                         {
     
111.                                 return true;
     
112.                         }
     
113.                                 else if(str.contains("猫")&str.contains("鱼"))
     
114.                                 {
     
115.                                         return false;
     
116.                                 }
     
117.                                         else if(str.contains("猫")&str.contains("狗"))
     
118.                                         {
     
119.                                                 return false;
     
120.                                         }
     
121.                         return true;
     
122.                 }
     
123. }
     
124. 
     
125. public class Test10 {
     
126. 
     
127.         public static void main(String[] args) {
     
128.                 // TODO Auto-generated method stub
     
129.                  PassRiver aa=new  PassRiver();
     
130.                  aa.play();
     
131.                  
     
132.                  System.out.println(aa.printState());
     
133.         }
     
134. 
     
135. }
     

复制代码

求助啊，面试题最后一题做不出来啊！！！做了半天做了个死循环出来啊！！！

我看了你一看到你的代码就头大，，我试着自己写了下，给你个思路：  首先有个动物接口，动物类有个判断天敌的方法。 把河抽为一个对象， 有两个list集合，分别存放过河 和没有过河的狗猫人鱼，  河有个方法，判断过河的动物是否存在天敌，如果有人在就没有天敌。   

1. cat过桥
   
2. fish不能过河，从头开始
   
3. 
   
4. cat过桥
   
5. dog不能过河，从头开始
   
6. 
   
7. fish过桥
   
8. dog过桥
   
9. cat过桥
   
10. 全部过河

复制代码

榨菜 发表于 2014-3-6 01:43
我看了你一看到你的代码就头大，，我试着自己写了下，给你个思路：  首先有个动物接口，动物类有个判断天敌 ...

{:3_53:}{:3_53:}多谢了！

zengming13 发表于 2014-3-6 14:07
这个问题应该是这样的思路：
1.要过河，肯定不能一次过，因此会有过去和回来两个方法。
2.猫狗鱼他们之间有 ...

:handshake 谢了~

楼主遇到的基础题和我一样，我刚刚写完。因为手机就不交流了

基础题第10题，今天刚写完，提交申请了

老貓钓鱼 发表于 2014-3-6 20:53
基础题第10题，今天刚写完，提交申请了

:( 咋做的？

bigbean 发表于 2014-3-6 23:18
咋做的？

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 题目10： 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。
   
8. *
   
9. * 步骤：
   
10. *                 1、先带猫过去，然后回来把狗带过，把猫带回来
    
11. *                 2、再把鱼带过去，再回来带猫
    
12. *
    
13. * 分析：
    
14. *                 1、定义2个集合，分别代表河二岸的动物
    
15. *                 2、定义一个判断动物和谐的方法
    
16. *                 3、先从集合中拿出一只动物准备过河，此时判断集合中余下的动物的和谐关系，如果和谐，则将此动物带过河，如果不和谐则重新换一只动物，直到取到和谐的动物为止
    
17. *                 4、将动物放入对岸的集合中，然后判断集合当中有没有不和谐的关系，如果有的话就带回，否则空手带回
    
18. */
    
19. 
    
20. public class Test10 {
    
21.        
    
22.         static int i = 0;
    
23.         public static void main(String[] args) {
    
24.                 //定义两个集合，分别代表河的这边(here)和对岸(there)
    
25.                 ArrayList<String> here = new ArrayList<String>();  
    
26.                 ArrayList<String> there = new ArrayList<String>();
    
27.                 here.add("狗");
    
28.                 here.add("猫");
    
29.                 here.add("鱼");
    
30.                
    
31.                 toTake(here, there);
    
32.         }
    
33. 
    
34.        
    
35. //判断集合中动物之间的和谐关系
    
36.         public static boolean isSafty(List<String> list) {
    
37.                 if((list.contains("狗")&&list.contains("猫")) || (list.contains("猫")&&list.contains("鱼")))
    
38.                         return false;
    
39.                 return true;
    
40.         }
    
41. 
    
42.         public static void toThere(String s, List<String> here, List<String> there) {
    
43.                 //判断对岸(there)集合中的动物：如果here集合中还有剩余的动物，则说明农夫还需要回去取，则说明还存在需要判断动物之间的和谐
    
44.                 //将动物放入对岸(there)的集合中，然后判断集合当中有没有不和谐的关系，如果有的话就带回一只动物（需要判断和谐关系），否则空手带回
    
45.                 if(!here.isEmpty()) {
    
46.                         String take2Here = null;
    
47.                         String temp = null;
    
48.                         there.add(s);
    
49.                        
    
50.                         while(!isSafty(there)) {
    
51.                                 if(temp != null) {
    
52.                                         there.add(temp);
    
53.                                 }
    
54.                                 take2Here =there.remove(0);
    
55.                                 temp = take2Here;
    
56.                         }
    
57.                        
    
58.                         if(take2Here != null) {
    
59.                                 System.out.println("            同时把" + take2Here + "带回来" );
    
60.                                 here.add(take2Here);
    
61.                         }else {
    
62.                                 System.out.println("            农夫空手回来");
    
63.                         }
    
64.                                
    
65.                 }else {
    
66.                         System.out.println("            动物已全部带过河了");
    
67.                 }
    
68.                
    
69.         }
    
70.        
    
71.         public static void toTake(List<String> here, List<String> there) {
    
72.                 //先从here集合中拿出一只动物准备过河，此时判断集合中余下的动物的和谐关系，如果和谐，则将此动物带过河，如果不和谐则重新换一只动物，直到取到和谐的动物为止
    
73.                 while(!here.isEmpty()) {
    
74.                         String take2There = here.remove(0);
    
75.                         if(isSafty(here)) {
    
76.                                 System.out.println("第" + (++i) + "步：把" + take2There + "带到对岸");
    
77.                                 toThere(take2There, here, there);//取到和谐的动物过河
    
78.                         }else {
    
79.                                 here.add(take2There);
    
80.                         }
    
81.                 }
    
82. 
    
83.         }
    
84. }
    

复制代码

这是我写的，仅做参考

老貓钓鱼 发表于 2014-3-7 09:11
这是我写的，仅做参考

http://blog.csdn.net/guangzhaolove/article/details/17636319
你和他做的一样

bigbean 发表于 2014-3-7 09:20
http://blog.csdn.net/guangzhaolove/article/details/17636319
你和他做的一样

对啊，借鉴了思想，然后没看代码，自己写的