A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

  1. package com.itheima;

  2. import java.util.LinkedList;

  3. /*
  4. * 需求:  10、一位老农带着猫、狗、鱼过河,河边有一条船,每次老农只能带一只动物过河。
  5. * 当老农不和猫狗鱼在一起时,狗会咬猫,猫会吃鱼,当老农和猫狗鱼在一起时,则不会发生这种问题。编程解决猫狗鱼过河问题。
  6. */
  7. public class Test10 {
  8.         public static void main(String[] args) {
  9.                 // 定义两个LinkedList集合,用于表示此岸和彼岸
  10.                 LinkedList<String> ciAn = new LinkedList<String>();
  11.                 LinkedList<String> biAn = new LinkedList<String>();

  12.                 // 初始时,此岸具有cat、dog、fish、person
  13.                 ciAn.add("cat");
  14.                 ciAn.add("dog");
  15.                 ciAn.add("fish");
  16.                 ciAn.add("person");

  17.                 while (true) {
  18.                         // 当此岸没有任何动物,就说明过河成功了,跳出循环
  19.                         if (ciAn.size() == 0) {
  20.                                 break;
  21.                         }
  22.                         // 过河
  23.                         if (ciAn.contains("person")) {// peron在此案的情况
  24.                                 ciAn.remove("person");
  25.                                 String animal = ciAn.removeFirst();
  26.                                 biAn.addLast(animal);
  27.                                 biAn.addLast("person");

  28.                                 boolean flag = isDaJia(ciAn, biAn);
  29.                                 if (flag) {
  30.                                         // 如果打架
  31.                                         biAn.remove("person");
  32.                                         biAn.remove(animal);
  33.                                         ciAn.addLast(animal);
  34.                                         ciAn.addLast("person");
  35.                                 } else {
  36.                                         // 否则
  37.                                         System.out.println("person将" + animal + "带过河");
  38.                                 }

  39.                         } else {// person在彼岸的情况
  40.                                 // person自己先回去
  41.                                 biAn.remove("person");
  42.                                 ciAn.addLast("person");

  43.                                 boolean flag = isDaJia(ciAn, biAn);
  44.                                 if (flag) {
  45.                                         while (true) {
  46.                                                 // 如果打架,就带走一个动物
  47.                                                 String animal = biAn.removeFirst();
  48.                                                 ciAn.add(animal);

  49.                                                 if (isDaJia(ciAn, biAn)) {
  50.                                                         // 如果还是打架,那个动物就回来
  51.                                                         ciAn.remove(animal);
  52.                                                         biAn.addLast(animal);
  53.                                                 } else {
  54.                                                         System.out.println("person将" + animal + "带回来");
  55.                                                         break;
  56.                                                 }
  57.                                         }

  58.                                 } else {
  59.                                         // 不打架
  60.                                         System.out.println("person自己回来");
  61.                                 }
  62.                         }
  63.                 }

  64.                 System.out.println("过河成功!");

  65.         }

  66.         // 判断河两岸是否有"打架"行为
  67.         public static boolean isDaJia(LinkedList<String> ciAn,
  68.                         LinkedList<String> biAn) {
  69.                 if (!ciAn.contains("person")) {
  70.                         if (ciAn.contains("cat")
  71.                                         && (ciAn.contains("fish") || ciAn.contains("dog"))) {
  72.                                 return true;
  73.                         }
  74.                 }

  75.                 if (!biAn.contains("person")) {
  76.                         if (biAn.contains("cat")
  77.                                         && (biAn.contains("fish") || biAn.contains("dog"))) {
  78.                                 return true;
  79.                         }
  80.                 }

  81.                 return false;
  82.         }
  83. }
复制代码


评分

参与人数 1技术分 +1 收起 理由
杨佳名 + 1 赞一个!

查看全部评分

16 个回复

倒序浏览
太好了,正好不会这道题,我要好好学习下
回复 使用道具 举报
这是第几天的知识点,我基础测试页有这题,,现还在看IO
回复 使用道具 举报
2014heima 发表于 2014-10-20 20:53
这是第几天的知识点,我基础测试页有这题,,现还在看IO

集合那块的吧
回复 使用道具 举报
mark了,,,:lol 楼主码的一手好码,支持一下。。。
回复 使用道具 举报
赞个啊!!
回复 使用道具 举报
我来学习了:lol
回复 使用道具 举报
本帖最后由 香草芭芙 于 2014-10-21 15:44 编辑
  1. package com.itheima.test;

  2. import java.util.*;

  3. public class Test30
  4. {
  5.         public static void main(String[] args)
  6.         {
  7.                 String nong = "农", dog = "狗", cat = "猫", fish = "鱼";
  8.                 LinkedList<String> anA = new LinkedList<String>();
  9.                 LinkedList<String> anB = new LinkedList<String>();
  10.                 anA.addFirst(nong);anA.addFirst(dog);anA.addFirst(cat);anA.addFirst(fish);
  11.                 System.out.println("原始状态-这边海岸: " + anA);
  12.                 System.out.println("原始状态-那边海岸: " + anB);
  13.                 fgx();// ----------------------------------------------------------------------------
  14.                 String[] s = new String[1];
  15.                 while (anA.size() != 0)
  16.                 {
  17.                         if (anA.contains(nong))
  18.                         {
  19.                                 if (!isDanger(anB)) // B岸不危险.
  20.                                 {
  21.                                         anA2anB(nong, anA, anB);
  22.                                         s[0] = anA.getFirst();
  23.                                         anA2anB(s[0], anA, anB);
  24.                                         System.out.println("农 & " + s[0] + " 去B岸");
  25.                                         System.out.println("A岸: " + anA);
  26.                                         System.out.println("B岸: " + anB);
  27.                                         fgx();// --------
  28.                                 }
  29.                         }
  30.                         else if (anB.contains(nong))
  31.                         {
  32.                                 if (isDanger(anA)) // A岸危险.
  33.                                 {
  34.                                         System.out.print("A岸危险: ");
  35.                                         System.out.println(anA.getFirst() + " 与 " + anA.getLast() + " 不和谐, " + "回到上一步");
  36.                                         reSet(nong, anA, anB);
  37.                                         reSet(s[0], anA, anB);
  38.                                         System.out.println("A岸: " + anA);
  39.                                         System.out.println("B岸: " + anB);
  40.                                         fgx();// --------
  41.                                         continue;
  42.                                 }
  43.                                 else
  44.                                 // A岸不危险.
  45.                                 {
  46.                                         anB2anA(nong, anB, anA);
  47.                                         if (isDanger(anB)) // 判断农夫一个人走是否可以?
  48.                                         {
  49.                                                 System.out.print("农 1个人 走的话岸B危险: ");
  50.                                                 System.out.println(anB.getFirst() + " 与 " + anB.getLast() + " 不和谐");
  51.                                                 s[0] = anB.getFirst();
  52.                                                 anB2anA(s[0], anB, anA);
  53.                                                 System.out.println("所以 农 & " + s[0] + " 去 A岸");
  54.                                         }
  55.                                         else
  56.                                                 System.out.println("农 1个人 去 A岸");
  57.                                         System.out.println("A岸: " + anA);
  58.                                         System.out.println("B岸: " + anB);
  59.                                         fgx();// --------
  60.                                 }
  61.                         }
  62.                 }
  63.                 System.out.println("搬运结束");
  64.         }
  65.         public static void fgx()
  66.         {
  67.                 System.out.println("-------------------------------");
  68.         }
  69.         public static boolean anA2anB(String s, LinkedList<String> anA, LinkedList<String> anB)
  70.         {
  71.                 if (anA.contains(s))
  72.                 {
  73.                         anA.remove(s);
  74.                         anB.addLast(s);
  75.                         return true;
  76.                 }
  77.                 else
  78.                         return false;
  79.         }
  80.         public static boolean anB2anA(String s, LinkedList<String> anB, LinkedList<String> anA)
  81.         {
  82.                 if (anB.contains(s))
  83.                 {
  84.                         anB.remove(s);
  85.                         anA.addLast(s);
  86.                         return true;
  87.                 }
  88.                 else
  89.                         return false;
  90.         }
  91.         public static void reSet(String s, LinkedList<String> listHere, LinkedList<String> listThere)
  92.         {
  93.                 if (listHere.contains(s))
  94.                 {
  95.                         listHere.remove(s);
  96.                         listThere.addLast(s);
  97.                 }
  98.                 else if (listThere.contains(s))
  99.                 {
  100.                         listThere.remove(s);
  101.                         listHere.addLast(s);
  102.                 }
  103.         }
  104.         public static boolean isDanger(LinkedList<String> list)
  105.         {
  106.                 if (!list.contains("农"))
  107.                 {
  108.                         if (list.contains("猫") && list.contains("狗") || list.contains("猫") && list.contains("鱼"))
  109.                                 return true;
  110.                 }
  111.                 return false;
  112.         }
  113. }
复制代码


回复 使用道具 举报
  1. import java.util.*;
  2. class CrossRiver
  3. {
  4.         public static void main(String[] args)
  5.         {               
  6.                 LinkedList<String> here=new LinkedList<String>();
  7.                 LinkedList<String> there=new LinkedList<String>();
  8.                 here.addFirst("猫");
  9.                 here.addFirst("鱼");
  10.                 here.addFirst("狗");
  11.                 int time=1;
  12.                 while(true)
  13.                 {
  14.                         String temp=here.pollFirst();
  15.                         if(here.isEmpty())
  16.                         {
  17.                                 System.out.println("第"+time+++"次老农带"+temp+"过河。");
  18.                                 break;
  19.                         }
  20.                         if(isSafety(here))
  21.                         {
  22.                                 System.out.println("第"+time+++"次老农带"+temp+"过河。");
  23.                                 there.addFirst(temp);
  24.                         }
  25.                         else
  26.                         {
  27.                                 here.addLast(temp);
  28.                                 continue;
  29.                         }
  30.                         if(!isSafety(there))
  31.                         {
  32.                                 temp=there.pollLast();
  33.                                 System.out.println("返回时把"+temp+"带回来。");
  34.                                 here.addLast(temp);
  35.                         }

  36.                        
  37.                                
  38.                        
  39.                
  40.                 }

  41.         }
  42.         public static boolean isSafety(LinkedList lt)
  43.         {
  44.                 if(lt.contains("猫")&&lt.contains("狗"))
  45.                         return false;
  46.                 if(lt.contains("猫")&&lt.contains("鱼"))
  47.                         return false;
  48.                 return true;
  49.         }

  50. }
复制代码

这问题我觉得,老农作为调解者和操作者,和猫狗鱼一样放入集合中是不是不太合适?因为他们属性是不一样的。也就是说我们只需要替老农确定带三种动物过河的顺序即可。上面代码中基本上是这样一个模型:here 和there分别代表这边和对岸,相当于两个容器,老农离开岸边的情况有两种,一种是从这边出发,一种是从对岸返回。
先说第一种:
当老农从here到there去的时候,先取here中第一个元素(用temp存储),然后判断here中是否有安全问题,如果有,就把该元素放回到here的尾部,然后再取here的第一个元素,重复刚才的步骤直到没有安全问题,此时,将取到的元素放到there的顶部。
然后是第二种:
当农夫从there返回here的时候,先判断there中是否有安全问题,如果有,则将there中尾部(因为刚才放入的元素在顶部,为了确保不重复,所以从尾部取)的元素取出,此时则不再需要判断安全问题,因为此时there中只有一个元素,然后将该元素放回到here的尾部,如果没有安全问题,则农夫自己返回即可。
重复上面两个步骤,直到here为空即可。


回复 使用道具 举报 1 0
李天富 发表于 2014-10-21 15:24
这问题我觉得,老农作为调解者和操作者,和猫狗鱼一样放入集合中是不是不太合适?因为他们属性是不一样的 ...

<<如果有,就把该元素放回到here的尾部,然后再取here的第一个元素,>>
太谢谢你了, 一直觉得LinkedList 没有什么出彩的地方, 今天才知道 它能这么用, 再次感谢. 膜拜.
回复 使用道具 举报
看不懂!
回复 使用道具 举报
李天富 发表于 2014-10-21 15:24
这问题我觉得,老农作为调解者和操作者,和猫狗鱼一样放入集合中是不是不太合适?因为他们属性是不一样的 ...

嗯,我觉得是考虑问题的思路不同吧,我是站在自己"玩游戏"的角度,比如有调条河,初始时这岸有老农、猫、狗、鱼,然后我用鼠标点击老农和相应的动物上船过河......你可能是站在"老农"的角度想我要带谁过河......而且因为不是主要考察面向对象的设计,所以我都用字符串表示的人和动物。但这样你的代码更精简!:)
回复 使用道具 举报
顶一个,人品爆发
回复 使用道具 举报
现在学习一下,希望不会是面试的问题,短时间不好形成思路
回复 使用道具 举报
Dream. 中级黑马 2014-10-23 14:20:24
15#
正好这个题没思路呢
回复 使用道具 举报
大家怎么都有这道题
回复 使用道具 举报
践行渐远 发表于 2014-10-23 12:42
现在学习一下,希望不会是面试的问题,短时间不好形成思路

这个问题思路很简单的   小学时候的数学题嘛、只是看你会不会把数学思想转变为编程算法而已
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马