一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。
求大神跟我说说具体思路，一点思路也没有，谢谢了

顶一下，求大神

第一次，先吧猫带过河，然后回来再带一样（狗和鱼随便一样）过河，在第二次返回的时候，吧猫再带回来，吧另外一个带回去，最后在吧猫带过去ok啦

帮你顶一下，加油

实在不会，可以百度搜一下思路，只要自己理解了，我感觉也行，这样你也可以学习到新知识。

怎么又是这个题?

这个也把我难住了，到现在没解决

学习一下

舍我其谁 发表于 2014-8-20 08:58
第一次，先吧猫带过河，然后回来再带一样（狗和鱼随便一样）过河，在第二次返回的时候，吧猫再带回来，吧另 ...

                               +1

1. class  Scheme
   
2. {      
   
3.         //String[] left = new String[3];
   
4.         //String[] right = new String[3];
   
5.    
   
6.         static String[] left = {"狗","猫","鱼"};
   
7.         static String[] right = {"" ,"",""};
   
8.        
   
9.         static int number = 0;//记录河在那边，运动物的次数
   
10. 
    
11.         public static void main(String[] args)
    
12.         {
    
13.                 String str = "";
    
14.                 while (leftJudge(left))//判断数组是否为空
    
15.                 {
    
16.                         int i = 0;
    
17.                         number++;
    
18.                         if (number%2 == 1)//判断船在那一般 当number为1的时候船运往右边
    
19.                         {
    
20.                                 for (;i<3;i++)
    
21.                                 {
    
22. 
    
23.                                         if (array(left,i)==false||left[i]==str)//判断数组是否有空，就代表没有动物并且在运回去的动物不能和运回来的动物一样
    
24.                                         {
    
25.                                                 continue;
    
26.                                         }else{
    
27.                                                 str = left[i];//把动物给船
    
28.                                                 leftRi(left,right,i);//运过去河右边
    
29.                                                 if (arrayJ(left)==false)//判断猫和狗。猫和鱼是否在一起，在一起的话则需要另外换一个去运；这以上三行都是试运
    
30.                                                 {
    
31.                                                         rightLe(left,right,i);
    
32.                                                         continue;
    
33.                                                 }else{
    
34.                                                         break;//有合适的运到河右边则直接运过去，跳出循环
    
35.                                                 }                                               
    
36.                                         }
    
37.                                 }
    
38.                                 System.out.println("第" + number + "次, 老农用船将" +str+ "运到河右岸" );
    
39.                         }else{
    
40.                                         if (arrayJ(right)==true)//船运往左边的时候，如果右边不打架的话，则不需要运动物到左边，直接去河左边
    
41.                                         {
    
42.                                                 System.out.println("第" + number + "次, 老农用船回到了河左边");
    
43.                                         }else{
    
44.                                                         for (; i<3; i++)
    
45.                                                         {
    
46.                                                                 if (right[i]==str||array(right,i)==false)//河右边打架的，没有合适的的话判断是否带哪只会河左边，并且不能与上次带过来的动物重复，如果有一样的话，则直接跳过这只动物
    
47.                                                                 {
    
48.                                                                         continue;
    
49.                                                                 }else{
    
50.                                                                         str = right[i];//将动物放在船上运往右边
    
51.                                                                         rightLe(left,right,i);
    
52.                                                                         if (arrayJ(right)==false)//判断这只动物是否合适在右边，如果不行，则换下一只
    
53.                                                                         {
    
54.                                                                                 leftRi(left,right,i);
    
55.                                                                                 continue;
    
56.                                                                         }else{
    
57.                                                                                 break;//如果条件全部符合，则直接运过去。
    
58.                                                                 }
    
59.                                                         }
    
60.                                                 }
    
61.                                                         System.out.println("第" + number + "次, 老农用船将" +str+ "运到河左岸" );
    
62.                                 }
    
63.                 }
    
64.         }
    
65. 
    
66. }
    
67. 
    
68. 
    
69.         //判断左边数组是不是没有内容了；
    
70.         public static boolean leftJudge(String[] left){
    
71.                 if (left[0]==""&&left[1]==""&&left[2]=="")
    
72.                 {
    
73.                         return false;
    
74.                 }else{
    
75.                         return true;
    
76.                 }
    
77.         }
    
78. 
    
79.         //把数组A中的字符串，移动到B中
    
80.         public static void leftRi(String[] left,String[] right,int i){
    
81.                 right[i] = left[i];
    
82.                 Scheme.right[i] = right[i];
    
83.                 Scheme.left[i] = "";
    
84.         }
    
85. 
    
86.         //把数组B中的字符串，移动到A中
    
87.         public static void rightLe(String[] left,String[] right,int i){
    
88.                 left[i] = right[i];
    
89.                 Scheme.left[i] = left[i];
    
90.                 Scheme.right[i] = "";
    
91.         }
    
92. 
    
93.         //判断数组中狗和猫，猫跟鱼是否在一起
    
94.         public static boolean arrayJ(String[] array){
    
95.                 if ((array[0]=="狗"&&array[1]=="猫")||(array[1]=="猫"&&array[2]=="鱼"))
    
96.                 {
    
97.                         return false;
    
98.                 }else{
    
99.                         return true;
    
100.                 }
     
101.         }
     
102. 
     
103.         //判断数组中的元素那个为空，
     
104.         public static boolean array(String[] array,int i){
     
105.                 if (array[i]=="")
     
106.                 {
     
107.                         return false;
     
108.                 }else{
     
109.                         return true;
     
110.                 }
     
111.         }
     
112. }

复制代码

别人是用集合做的，我做的时候还没学集合，船去左边就右边，船去右边就判断左边，把两边分开来思考

加油吧 我也米搞定

表示不懂！

1. import java.util.*;
   
2. import java.lang.*;
   
3. 
   
4. public class AcrossRiver
   
5. {
   
6.     public static void main(String[] args){
   
7. 
   
8.                 new AcrossRiver().acrossRiver();
   
9.         }
   
10.    
    
11.         //狗猫鱼过河问题
    
12.         public  void acrossRiver(){
    
13.             List<String> right = new ArrayList<String>();
    
14.                 right.add("狗");
    
15.                 right.add("猫");
    
16.                 right.add("鱼");
    
17.                 List<String> left = new ArrayList<String>();
    
18.                 String animR = "";  //向左岸带的动物
    
19.                 String animL = "";  //向右岸带的动物
    
20.         int k = 0;          //记录转运的次数
    
21.                 Random random = new Random();
    
22.         while(right.size()>0){ //在右岸还有动物的情况下 循环运送
    
23.                         k++;
    
24.                 for(int i=0;i<right.size();i++){  
    
25.                   
    
26.                   
    
27.                    if(contains(right, i, true) && !right.get(i).equals(animL)){//如果右岸不冲突 就渡河
    
28.                      
    
29.                           animR = right.get(i);         
    
30.                           left.add(animR);               //将右岸的动物带到左岸
    
31.               right.remove(i);               //同时删除右岸已经带走的动物
    
32. 
    
33.               System.out.println("第" + k + "次将"+ animR +"带到左岸 左岸现有动物为：" + getString(left) + " 右岸动物还有：" + getString(right));
    
34.             
    
35.                           //在右岸还有动物的情况下判断左岸动物是否冲突，如果是则带走一个动物回右岸
    
36.                           if(!contains(left, i, false) && right.size()!=0){           
    
37.                              
    
38.                                  int index = random.nextInt(left.size());
    
39.                  animL = left.get(index);
    
40.                  //判断是否是刚刚过河的那只动物 如果是 则换一只 并且判断剩下的动物不冲突
    
41.                                  while(animR.equals(animL) && contains(left, index, true)){
    
42.                                  
    
43.                                        index = random.nextInt(left.size());
    
44.                        animL = left.get(index);
    
45.                                  }
    
46.                                  
    
47.                                  right.add(animL);   //将动物带回右岸
    
48.                                  left.remove(index);  //同时删除已带走的动物
    
49.                  System.out.println("第" + k + "次返回将"+ animR +"带到右岸 右岸现有动物：" + getString(right) + " 左岸动物还有：" + getString(left));
    
50.                           }else animL = "";    //左岸动物不冲突 则不带回
    
51.                          
    
52.                  System.out.println("第" + k + "次返回没有带动物 两边动物不变");
    
53.                          
    
54.                            break; //一次过河结束
    
55.                    }
    
56.                                 
    
57.                 }
    
58.                
    
59.                 }
    
60.         }
    
61. 
    
62.     /**
    
63.           * 判断是否狗和猫 或者 猫和鱼在一起 是则返回false 否则返回true
    
64.           *@param rList 需要是否有冲突判断的集合 i 集合中需要删除的索引 isRight 判断是否用到参数i
    
65.           */
    
66.         public static boolean contains(List<String> rList, int i, boolean isRight){
    
67.                 List<String> tempList = new ArrayList<String>(rList); //为了防止改变参数的内部对象 所以在这里复制一个新的引用
    
68.                 if(isRight)
    
69.             tempList.remove(i);
    
70. 
    
71.                 if(tempList.contains("狗")&&tempList.contains("猫") || tempList.contains("猫")&&tempList.contains("鱼")){
    
72.                    return false;
    
73.                 }else return true;
    
74.        
    
75.         }
    
76.    
    
77.         //将list转换成字符串
    
78.         public static String getString(List<String> list){
    
79.            StringBuffer sb = new StringBuffer();
    
80.            if(list!=null){
    
81.               for(int i=0;i<list.size();i++){
    
82.                      sb.append(list.get(i)+" ");
    
83.                   }
    
84.            }
    
85.            return sb.toString();
    
86.         }
    
87. }[img][/img]

复制代码

测试结果
第1次将猫带到左岸 左岸现有动物为：猫  右岸动物还有：狗 鱼
第1次返回没有带动物 两边动物不变
第2次将狗带到左岸 左岸现有动物为：猫 狗  右岸动物还有：鱼
第2次返回将狗带到右岸 右岸现有动物：鱼 猫  左岸动物还有：狗
第2次返回没有带动物 两边动物不变
第3次将鱼带到左岸 左岸现有动物为：狗 鱼  右岸动物还有：猫
第3次返回没有带动物 两边动物不变
第4次将猫带到左岸 左岸现有动物为：狗 鱼 猫  右岸动物还有：
第4次返回没有带动物 两边动物不变

楼上的犀利，膜拜

xplcc 发表于 2014-8-27 13:44
测试结果
第1次将猫带到左岸 左岸现有动物为：猫  右岸动物还有：狗 鱼
第1次返回没有带动物 两边动物不 ...

多谢指正。这里System打印成从右岸带走的动物了 并且else没有加大括号 这里改成


System.out.println("第" + k + "次返回将"+ animL +"带到右岸 右岸现有动物：" + getString(right) + "                                     左岸动物还有：" + getString(left));
                          }else {animL = "";    //左岸动物不冲突 则不带回
                        
                             System.out.println("第" + k + "次返回没有带动物 两边动物不变");
                        }

新手报道 先收下了

我表示我的基础测试题也抽到了，编程不知道怎么实现，没思路

mmmmmmmmmmmm

好考验智商。