编程解决猫狗鱼过河问题！求指教！

我都还没学到，呜呜！

感觉好高大上

经典题目啊

mengzi987 发表于 2014-10-20 17:13
应该可以称为不作死就不会死吧！！

哈哈，加油

李贵栋 发表于 2014-10-20 16:58
那么小的细节。。。。。。。。。

应该可以称为不作死就不会死吧！！;P

那么小的细节。。。。。。。。。

new999 发表于 2014-10-20 00:27
老农带---cat---从左岸到右岸
  老农单独从右岸返回左岸
老农带---pesrson---从左岸到右岸

已经解决啦！就是最后面有一个left.add(person),写成了left。add(pesrson)啦！
不够细心，不作死就不会死！！！:'(:'(

没有弄清楚你的思路。我自己的实现，没有随机取，按顺序取，尝试过河

1. package com.itheima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. import org.junit.Test;
   
6. 
   
7. /*
   
8. 一位老农带着猫、狗、鱼过河，河边有一条船，
   
9. 每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，
   
10. 狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。
    
11. 编程解决猫狗鱼过河问题。
    
12. 
    
13. 解决思路：老农不在，只有狗和鱼能和谐共处
    
14. 第一步：老农把猫带到右岸
    
15. [狗,鱼]---[老农,猫]
    
16. 第二步：老农回到左岸***right.remove("老农");...;if(right.size()>1){}
    
17. [狗,鱼,老农]---[猫]
    
18. 第三步：老农把狗或者鱼带到右岸，假设是狗
    
19. [鱼]---[老农,狗,猫]
    
20. 第四步：老农把猫带回左岸
    
21. [老农,猫,鱼]---[狗]
    
22. 第五步：老农把鱼带到右岸
    
23. [猫]---[老农,狗,鱼]
    
24. 第六步：老农回到左岸***
    
25. [老农,猫]---[狗,鱼]
    
26. 第七步：老农把猫带到右岸
    
27. */
    
28. public class Test10 {
    
29.        
    
30.         List<String> left = new ArrayList<String>();//表示河左岸
    
31.         List<String> right = new ArrayList<String>();//表示河右岸
    
32.        
    
33.         public Test10(){
    
34.                 left.add("老农");
    
35.                 left.add("猫");
    
36.                 left.add("狗");
    
37.                 left.add("鱼");
    
38.         }
    
39.         @Test
    
40.         public void crossRiver(){
    
41.                 System.out.println("------开始渡河------");
    
42.                 System.out.print(left+"---");
    
43.                 System.out.println(right);
    
44.                 while(true){
    
45.                         left2right();
    
46.                         if(left.size()==0)
    
47.                                 break;
    
48.                         right2left();
    
49.                 }
    
50.                 System.out.print("------渡河成功！------");
    
51.         }
    
52. 
    
53.         private void left2right() {
    
54.                 left.remove("老农");
    
55.                 right.add("老农");
    
56.                 String temp;
    
57.                 for(int i=0;i<left.size();i++){
    
58.                         temp = left.get(i);
    
59.                         left.remove(i);
    
60.                         if (isRight(left) && isRight(right)) {
    
61.                                 right.add(temp);
    
62.                                 break;
    
63.                         } else{
    
64.                                 left.add(temp);
    
65.                         }
    
66.                 }
    
67. 
    
68.                 System.out.print(left+"---");
    
69.                 System.out.println(right);
    
70.         }
    
71. 
    
72.         private void right2left(){
    
73.                 right.remove("老农");
    
74.                 left.add("老农");
    
75.                 if (isRight(left) && isRight(right)){
    
76.                         return;
    
77.                 }
    
78.                 if(right.size()>1){
    
79.                         String temp;
    
80.                         for(int i=0;i<right.size();i++){
    
81.                                 temp = right.get(i);
    
82.                                 right.remove(i);
    
83.                                 if (isRight(left) && isRight(right)) {
    
84.                                         left.add(temp);
    
85.                                         break;
    
86.                                 } else{
    
87.                                         right.add(temp);
    
88.                                 }
    
89.                         }
    
90.                 }
    
91.                 System.out.print(left+"---");
    
92.                 System.out.println(right);
    
93.         }
    
94. 
    
95.         private boolean isRight(List<String> list){
    
96.                 if(list.size()==0 || list.size()==1 || list.contains("老农") || (list.contains("狗") && list.contains("鱼")))
    
97.                         return true;
    
98.                 return false;
    
99.         }
    
100.        
     
101.         public static void main(String[] args) {
     
102.                 new Test10().crossRiver();       
     
103.         }
     
104. }
     

复制代码

------开始渡河------
[老农, 猫, 狗, 鱼]---[]
[狗, 鱼]---[老农, 猫]
[鱼]---[猫, 老农, 狗]
[鱼, 老农, 猫]---[狗]
[猫]---[狗, 老农, 鱼]
[]---[狗, 鱼, 老农, 猫]
------渡河成功！------

老农带---cat---从左岸到右岸
  老农单独从右岸返回左岸
老农带---pesrson---从左岸到右岸
  老农带cat从右岸返回左岸
。。。
死循环

mudao 发表于 2014-10-19 23:52
很有意思的题目哦，用排除法

其实方法各有千秋，，我只是想知道我这种方法哪里出问题啦！！！:'(

很有意思的题目哦，用排除法

小子考驾照 发表于 2014-10-19 23:08
我不看了，感觉头大。。。。。那么麻烦阿阿

...........................................

小子考驾照 发表于 2014-10-19 23:02
你发来看看。。。。

程序已发，求指教！！

mengzi987 发表于 2014-10-19 23:01
package ruxue.jccs;

import java.util.ArrayList;

我不看了，感觉头大。。。。。那么麻烦阿阿

mengzi987 发表于 2014-10-19 22:57
我可不可以发一份我参考其他代码做的给你看看，里面有一些小问题，找不出原因呢！ ...

你发来看看。。。。

小子考驾照 发表于 2014-10-19 22:58
1.猫过去
2.狗过去，毛过来
3.鱼过去，

package ruxue.jccs;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/*题目：10.一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
*                         当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，
*                         则不会发生这种问题。编程解决猫狗鱼过河问题。
* 思路：1.通过题目的逻辑可以得出，猫是不能和狗或者是鱼单独在一起的
*                 2.我们可以想象成左右两岸，人和动物开始都是在左岸的，所以我们
*                         可以将左右两岸想象成两个集合。
*                 3.定义一个方法isSafe()，方法内规定了集合中不安全的条件，并且返回相应值，以备调用
*                 4.定义一个过河的方法cross()，通过往两个集合增加，移除的元素的方法，模拟农民带动物过河,
*                         过河的过程中时刻对集合进行安全判断。当右岸的元素大小为4，即表示农名与动物全部过河成功
*                 5.主函数分别调用isSafe(),和cross()两个方法。
**/

public class test11 {
        /*
         *
         * @param args
         */
       
        //先定义两个List集合，用于模拟正岸和对岸
        List<String> left=new ArrayList<String>();//正岸
        List<String> right=new ArrayList<String>();//对岸
        //定义其构造函数，使它一创建对象就正岸就有人，fish，cat，dog这四种
        public test11(){
                left.add("person");
                left.add("fish");
                left.add("dog");
                left.add("cat");
                System.out.println(left.size());
                }
        //创建一个过河的方法，持续过河的条件就是左岸还存在物种，即左岸的集合大小大于1；
        public void cross()
        {        //System.out.println(left.size());
                while(left.size()>1)
                {       
                        left.remove("person");//人过河
                        //System.out.println("：：：：：：：：：：：移除person");
                        //System.out.println(left.size());
                        Random rd=new Random();//产生随机对象
                        int index=rd.nextInt(left.size());//获取0——left.size()之间的随机数，不包括left.size()它本身
                       
                        if(index==left.size()-1 && left.size()>1)
                        {//判断随机取出的是不是刚才；老农带回来的
                                        left.add("person");
                                        continue;//如果条件成立则将会跳出单次循环，回到整个循环开始阶段，相当于再一次的进行随机取
                        }
                        String s=left.get(index);//如果不是刚才老农带回来的则获取该元素，并取走该元素
                        left.remove(s);
                        if(isSafe(left))//判断元素取走后正左岸是否安全
                        {
                                                right.add("person");//如果取走后左岸安全，则将元素添加至右岸
                                                right.add(s);
                                                System.out.println("老农带---" + s + "---成功从左岸通过河");
                                                //判断右岸是否所有元素到齐，即right.size()==4,如果条件成立，则表示所有都已成功过河，跳出整个循环，break
                                                if(right.size()==4)
                                                {
                                                        break;
                                                }
                                                //则农民从右岸返回左岸，判断单独农民走后右岸是否安全，如果不安全则得随机取走一元素
                                                right.remove("person");
                                                if(isSafe(right))
                                                {
                                                        left.add("person");
                                                        System.out.println("  老农单独从右岸返回左岸");
                                                }
                                                else{//不安全
                                                                        String sr=right.get(rd.nextInt(right.size()));//随机选出元素
                                                                        while(sr.equals(s))
                                                                        {//判断取出的是否和刚才放入的相等，如果相等的话则再进行随机取样，否则则取出
                                                                                        sr=right.get(rd.nextInt(right.size()));
                                                                        }
                                                                        right.remove(sr);
                                                                        left.add(sr);
                                                                        left.add("person");
                                                                        System.out.println("  老农带" + sr + "从右岸返回左岸");
                                                        }
                        }
                        else
                        {//如果之前取出元素后左岸不安全，则将之前取出的元素重新放入左岸集合然后重新进行while循环判断
                                left.add(s);
                                left.add("pesrson");
                        }
          }
        System.out.println(        "------已全部成功渡河----------！！");
  }
       
        /*创建一个对没有人的情况下的岸上是否安全的方法,判断的条件是
         * 1.该岸上没有人
         * 2.该岸上至少有两种物种
         * 3.因为狗不能和猫在一起，猫不能和鱼在一起，所以通过分析可以得出只要前两个条件满足的基础上
         * 只要某一岸上有猫则就会不安全，则有：
         *  */
        public boolean isSafe(List<String> list){
                boolean a=true;
                if(list.size()>1&&!list.contains("person")&&list.contains("cat")){
                        a=false;
                }
                return a;
        }
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                test11 t11=new test11();
       
                t11.cross();
        }
}

1.猫过去
2.狗过去，毛过来
3.鱼过去，
4.毛过去