黑马程序员技术交流社区

标题: 猫狗鱼过河问题 [打印本页]
作者: 刘晟伟    时间: 2015-9-25 09:56
标题: 猫狗鱼过河问题
本帖最后由 刘晟伟 于 2015-9-26 13:29 编辑

     一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。编程解决猫狗鱼过河问题。
     我想到了解决方案，先带走猫过河到对岸，然后空船回来带狗（或鱼），到达对岸回来时带着猫，把毛猫放下，再带着鱼（或狗），最后回来带猫。
      代码我就不会写了，希望高手指点。给出代码和注释
作者: mars314    时间: 2015-9-25 10:19
在论坛里看一下其它同学写的吧。
作者: DD_vincent    时间: 2015-9-25 10:58
当时我花了一个下午做这个题....
给你一些思路吧：
1.用两个集合来定义两岸的动物
2.要有一个方法，来判断老农离岸后剩下来的动物是否不会打起来
3.定义几个方法，将动物从A岸带到B岸，和从B岸带到A岸
4.最重要的一点：你是希望把动物从A岸带到B岸去，所以从B岸回A岸时应该先判断什么都不带安全不安全
作者: 刘晟伟    时间: 2015-9-25 12:42
DD_vincent 发表于 2015-9-25 10:58
当时我花了一个下午做这个题....
给你一些思路吧：
1.用两个集合来定义两岸的动物

怎么判断啊？我想不到方法
作者: DD_vincent    时间: 2015-9-25 15:48
刘晟伟 发表于 2015-9-25 12:42
怎么判断啊？我想不到方法

当猫、狗或者猫、鱼在一起的时候就不安全，返回false就行了啊
作者: 天涯莫名    时间: 2015-9-25 21:22
路过，顶一下
作者: zhaopengfei    时间: 2015-9-25 21:46
名捕吉林可疼了咯你不透诺路
作者: 915816106    时间: 2015-9-25 22:30
public class Test10 {
    int farmer,cat,dog,fish; //刚开始都为0，也就是都在河的这岸
    String type = ""; //记录农夫上一步带的是什么，防止出现死循环,当农夫自己走时type不改变
    String isnull = "";//当农夫自己走时，isnull会记录下来，防止出现死循环。
    boolean boo = false;
    public static void main(String[] args) {
            Test10 test = new Test10();
            int x = 1;//记录移动的数次
            while(true){
               test.move();
       System.out.println("第"+x+"步");
       System.out.println("河这岸有："+test.print(0));
       System.out.println("河对岸有："+test.print(1));
       x++;
       //当把全部东西都移动到对岸时，即可停止移动。
       if(test.farmer==1&&test.cat==1&&test.dog==1&&test.fish==1){
           break;
       }
       }
               
        
    }
   
    //农夫过河时需要判断能带什么不能带什么
    public void move(){
            
            if(farmer==0){
                    if(cat==0){
                            if(!type.equals("cat")){
                                    farmer = 1;
                                    cat = 1;
                                    if(isSafe()){
                                            type = "cat";
                                            return;
                                    }else{
                                            farmer = 0;
                                            cat = 0;
                                    }
                            }
                    }
                    if(dog==0){
                            if(!type.equals("dog")){
                                    farmer = 1;
                                    dog = 1;
                                    if(isSafe()){
                                            type = "dog";
                                            return;
                                    }else{
                                            farmer = 0;
                                            dog = 0;
                                    }
                            }
                    }
                    if(fish==0){
                            if(!type.equals("fish")){
                                    farmer = 1;
                                    fish = 1;
                                    if(isSafe()){
                                            type = "fish";
                                            return;
                                    }else{
                                            farmer = 0;
                                            fish = 0;
                                    }
                            }
                    }
                            farmer = 1;
                    
            }else if(farmer==1){
                    //当人在河对岸时需要优先考虑自已到这岸来，从而把东西带到对岸。
                    if(isnull != "farmer"){
                            farmer = 0;
                            isnull = "farmer";
                            if(isSafe()){
                                    return;
                            }else{
                                    farmer = 1;
                            }
                    }
                           
                    if(cat==1){
                            if(!type.equals("cat")){
                                    farmer = 0;
                                    cat = 0;
                                    if(isSafe()){
                                            type = "cat";
                                            isnull = "";
                                            return;
                                    }else{
                                            farmer = 1;
                                            cat = 1;
                                    }
                            }
                    }
                    if(dog==1){
                            if(!type.equals("dog")){
                                    farmer = 0;
                                    dog = 0;
                                    if(isSafe()){
                                            type = "dog";
                                            isnull = "";
                                            return;
                                    }else{
                                            farmer = 1;
                                            dog = 1;
                                    }
                            }
                    }
                    if(fish==1){
                            if(!type.equals("fish")){
                                    farmer = 0;
                                    dog = 0;
                                    if(isSafe()){
                                            type = "fish";
                                            isnull = "";
                                            return;
                                    }else{
                                            farmer = 1;
                                            fish = 1;
                                    }
                            }
                    }
            }
    }
   
    //判断现在的状态是否有冲突
    public boolean isSafe(){
            if(farmer==1){
                    if(cat==0&&fish==0)return false;
                    if(cat==0&&dog==0)return false;
            }else if(farmer==0){
                    if(cat==1&&fish==1)return false;
                    if(cat==1&&dog==1)return false;
            }
            return true;
    }
   
    //打印现在河的两岸都有什么
    public String print(int i){
            if(i==0){
                    String str = "";
                    if(farmer==0)str += "农夫    ";
                    if(dog==0)str += "狗    ";
                    if(cat==0)str += "猫    ";
                    if(fish==0)str += "鱼    ";
                    return str;
            }else if(i==1){
                    String str = "";
                    if(farmer==1)str += "农夫    ";
                    if(dog==1)str += "狗    ";
                    if(cat==1)str += "猫    ";
                    if(fish==1)str += "鱼    ";
                    return str;
            }
            return null;
    }

}
作者: Orangeapp    时间: 2015-9-25 22:55
这个问题我也是想了好久，大概的步奏想出来了，就是不知道怎么去用代码去实现。看了上面的大神写的步奏，顿时豁然开朗
作者: 芝麻糊    时间: 2015-9-25 23:05
我觉得我写的不错
  1. package com.itheima;

  3. import java.util.ArrayList;

  5. public class Test10 {
  6.        
  7.         String person = "person";
  8.         String dog = "dog";
  9.         String cat = "cat";
  10.         String fish = "fish";
  11.        
  12.         String animal,animal2;  // 后面用于得到集合中元素的临时变量
  13.        
  14. //        bank opbank 分别表示河岸和对岸
  15.         ArrayList<String> bank = new ArrayList<String>();
  16.         ArrayList<String> opbank = new ArrayList<String>();
  17.        

  19. //        初始化河岸,让人、猫、狗、鱼位于河岸, 顺序可以改变
  20.         public Test10() {
  21.                
  22.                 bank.add(person);
  23.                 bank.add(dog);
  24.                 bank.add(fish);
  25.                 bank.add(cat);
  26.                
  27.         }
  28.        
  29. //        判断和谐条件
  30.         public boolean isSafety(ArrayList<String> list) {
  31.                
  32. //                人在和谐
  33.                 if(list.contains(person)) {
  34.                         return true;
  35.                 }
  36.                
  37. //                人不在, 猫狗或猫鱼同在不和谐
  38.                 else if(list.contains(dog) && list.contains(cat) ||
  39.                                 list.contains(cat) && list.contains(fish)) {
  40.                         return false;
  41.                 }
  42. //                其他条件和谐,如何集合为空,说明岸上没有动物,自然也和谐
  43.                 return true;       
  44.         }
  45.        
  46. //        人带一只动物带到对岸
  47.         public boolean toOpbank(String animal) {
  48.                                
  49.                 bank.remove(person);
  50.                 bank.remove(animal);
  51. //                人走后岸边和谐,则去对岸
  52.                 if(isSafety(bank)) {
  53.                         opbank.add(person);
  54.                         opbank.add(animal);
  55.                         System.out.println("老农把" + animal + "带到对岸");
  56.                         return true;
  57.                        
  58. //                岸边不和谐,则回来
  59.                 } else {
  60.                         bank.add(animal);
  61.                         bank.add(person);
  62.                         return false ;
  63.                 }
  64.         }
  65.        
  66. //        如果人走后对岸和谐,人则自己回到岸边继续送其他动物
  67.         public boolean toBank() {
  68.                
  69.                 opbank.remove(person);
  70.                 if(isSafety(opbank)) {
  71.                         bank.add(person);
  72.                         System.out.println("老农一个人回到岸边");
  73.                         return true;
  74.                 } else {
  75.                         opbank.add(person);
  76.                         return false;
  77.                 }
  78.                
  79.         }
  80.        
  81. //        如果人走后对岸不和谐,人将带一只动物回岸边
  82.         public boolean toBank(String animal) {
  83.                
  84.                 opbank.remove(person);
  85.                 opbank.remove(animal);
  86.                 if(isSafety(opbank)) {
  87.                         bank.add(person);
  88.                         bank.add(animal);
  89.                         System.out.println("老农带着" + animal + "回到岸边");
  90.                         return true;
  91.                        
  92.                 } else {
  93.                         opbank.add(animal);
  94.                         opbank.add(person);
  95.                         return false;
  96.                 }
  97.         }
  98.        
  99.        
  100. //        开始渡河
  101.         public void crossRiver() {
  102.                
  103. //                岸边集合为空,则渡河成功
  104.                 if(bank.isEmpty()) {
  105.                         System.out.println("渡河成功");
  106.                         return ;
  107.                 }
  108.                
  109. //                每次都带岸边集合中第一只不是人的动物去对岸
  110.                
  111.                 animal = bank.get(0);
  112.                 if(person.equals(animal)) {
  113.                         animal = bank.get(1);
  114.                 }
  115.                 if(toOpbank(animal)){
  116.                        
  117. //                        人如果可以自己回来就自己回来,不能则带对岸集合第一只不是人的动物回来
  118.                        
  119.                         animal2 = opbank.get(0);
  120.                         if(person.equals(animal2)) {
  121.                                 animal = opbank.get(1);
  122.                         }
  123.                        
  124.                         if(!toBank()) {
  125.                                 toBank(animal2);
  126.                         }
  127.                 }
  128.                        
  129. //                递归渡河,直到岸边集合为空
  130.                 crossRiver();       
  131. }
  132.        
  133.         public static void main(String[] args) {
  134.                
  135.                 new Test10().crossRiver();
  136.         }

  138. }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2