有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。
木杆很细，不能同时通过一只蚂蚁。开始 时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，
但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。
编写程序，求所有蚂蚁都离开木杆 的最小时间和最大时间。

分析:题目中的蚂蚁只可能相遇在整数点,不可以相遇在其它点,比如3.5cm处之类的,也就是可以让每只蚂蚁走 1秒,然后
* 查看是否有相遇的即可.
*
* 这样我的程序实现思路就是,初始化5只蚂蚁,让每只蚂蚁走1秒,然后看是否有相遇的,如果有则做相应处理.当每只蚂蚁都
* 走出木杆时,我就记录当前时间.这样就可以得到当前状态情况下,需要多久可以走出木杆,然后遍历所有状态则可以得到所胡
* 可能.

这个题，在ACM中貌似见过。。用排序，好像吧。。

这么难啊。。。

坐等代码 求长见识~~~

来围观一下，果断发现看完就懵了...

好难啊~~

先上代码

1. /**
   
2. * 模拟蚂蚁运行的木棒，木棒长度为l，有l个点，每个点上的蚂蚁数量初始化为0
   
3. * @author Administrator
   
4. *
   
5. */
   
6. class L{
   
7.         static int l = 27;
   
8.         static int[] point = new int[l + 1];
   
9.         static{
   
10.                 for(int i = 0; i < l + 1; i++){
    
11.                         point[i] = 0;
    
12.                 }
    
13.         }
    
14. }
    
15. 
    
16. /**
    
17. * 蚂蚁类，有运动方向，初始位置，以及运动的方法及Thread的run方法，
    
18. * run方法模拟蚂蚁的实际运动
    
19. * @author Administrator
    
20. *
    
21. */
    
22. class Ant extends Thread{
    
23.         private static int[] F = {1, -1};//1向右，-1向左
    
24.         private int f;
    
25.         private int place;
    
26.         private String name = "";
    
27.         private static Object obj = new Object();
    
28.         int time = 0;
    
29.        
    
30.         //蚂蚁编号
    
31.         static int num = 0;
    
32.        
    
33.         //初始化蚂蚁的名称、运动方向（0向右，1向左）和位置
    
34.         Ant(String name, int i, int place){
    
35.        
    
36.                
    
37.                 this.name = name;
    
38.                 this.f = F[i];
    
39.                 this.place = place;
    
40.                 if(L.point[place] != 0){
    
41.                         System.out.println("Error");
    
42.                 }
    
43.                 L.point[place] = 1;
    
44.         }
    
45.         //蚂蚁运动
    
46.         public void run(){       
    
47.                 //获取当前蚂蚁的编号
    
48.                 int c = num++;
    
49.                
    
50.                 while(place > 0 || place < L.l){
    
51.                         try {Thread.sleep(600);} catch (InterruptedException e) {}       
    
52.                         //如果两只蚂蚁相遇，则调转方向，相遇设计成如果L上的某个点的蚂蚁数量大于1，
    
53.                         //为了保证这段代码能被安全的执行，将1s的sleep时间分成两个部分，使线程有足够的时间完成判断和调转方向
    
54.                         if(L.point[place] > 1){
    
55.                                 f = -f;
    
56.                                 System.out.println(name + " turn foward in " + place);                               
    
57.                         }       
    
58.                         try {Thread.sleep(300);} catch (InterruptedException e) {}       
    
59.                        
    
60.                         place += f;       
    
61.                         //如果已经抵达0点或者第27点，那么就离开，即设置0点和27点上的蚂蚁个数为0
    
62.                         //以及1和26点上的蚂蚁个数为0
    
63.                         if(place <= 0 || place >= L.l){               
    
64.                                 if(place <= 0){
    
65.                                         L.point[place + 1] = 0;
    
66.                                 }
    
67.                                 if(place >= L.l){
    
68.                                         L.point[L.l - 1] = 0;
    
69.                                 }
    
70.                                 //从1和26到0和27也需要1s的时间
    
71.                                 time++;
    
72.                                 break;
    
73.                         }       
    
74.                         //加锁避免同时操作place，尤其两只蚂蚁到同一个点相遇的时
    
75.                         synchronized (obj) {
    
76.                                 //蚂蚁到place点，则数量加1
    
77.                                 L.point[place]++;       
    
78.                                 //蚂蚁所在的前一个位置的蚂蚁数量编程0
    
79.                                 L.point[place - f] = 0;               
    
80.                         }
    
81.                         //时间加1
    
82.                         time++;                                       
    
83.                 }               
    
84.                 System.out.println(name + " Time:" + time);
    
85.                 //保存结果到SearchTime中
    
86.                 SearchTime.runTime[c % 5] = time;
    
87.         }
    
88. }
    
89. 
    
90. /**
    
91. * 搜索线程，可以搜索指定蚂蚁运动方向组合的所有蚂蚁都离开的时间
    
92. * @author Administrator
    
93. *
    
94. */
    
95. class SearchTime extends Thread{
    
96.         private int tag;
    
97.         static int[] runTime = new int[5];
    
98.         //搜索运动方向为tag指示的情况时的所有蚂蚁都离开L的时间
    
99.         SearchTime(int tag){
    
100.                 this.tag = tag;
     
101.         }
     
102.        
     
103.         public void run(){
     
104.                 System.out.println("Start tag = " + tag);
     
105.                 //5只蚂蚁，方向一共有32种可能，因此tag应当是小于32大于0的数，tag的二进制
     
106.                 //每一个位代表一只蚂蚁的运动方向
     
107.                 if(tag >= 32 || tag < 0){
     
108.                         System.out.println("error");                       
     
109.                 }else{                       
     
110.                         Ant ant1 = new Ant("Ant1", tag & 1, 3);
     
111.                         Ant ant2 = new Ant("Ant2", (tag & 2) >> 1, 7);
     
112.                         Ant ant3 = new Ant("Ant3", (tag & 4) >> 2, 11);
     
113.                         Ant ant4 = new Ant("Ant4", (tag & 8) >> 3, 17);
     
114.                         Ant ant5 = new Ant("Ant5", (tag & 16) >> 4, 23);       
     
115.                        
     
116.                         ant1.start();
     
117.                         ant2.start();
     
118.                         ant3.start();
     
119.                         ant4.start();
     
120.                         ant5.start();
     
121.                 }
     
122.         }
     
123. }
     
124. public class BaiduEm {
     
125. 
     
126.         public static void main(String[] args) throws InterruptedException {
     
127.                 int[] result = new int[32];
     
128.                 for(int i = 0; i < 32; i++){
     
129.                         SearchTime st = new SearchTime(i);
     
130.                         st.start();
     
131.                         try {Thread.sleep(30000);} catch (InterruptedException e) {}       
     
132.                         result[i] = findMax(SearchTime.runTime);
     
133.                         System.out.println("Max:" + result[i]);
     
134.                 }
     
135.                 System.out.println("所有蚂蚁都离开的最短时间：" + findMin(result) + "s" );
     
136.                 System.out.println("所有蚂蚁都离开的最长时间：" + findMax(result) + "s" );
     
137.         }
     
138.        
     
139.         /*
     
140.          * 寻找一个数组中的最大值
     
141.          */
     
142.         public static int findMax(int[] array){
     
143.                 int max = array[0];
     
144.                 for(int i = 0; i < array.length; i++){
     
145.                         max = array[i] > max ? array[i] : max;
     
146.                 }
     
147.                 return max;
     
148.         }
     
149.        
     
150.         /*
     
151.          * 寻找一个数组中的最小值
     
152.          */
     
153.         public static int findMin(int[] array){
     
154.                 int min = array[0];
     
155.                 for(int i = 0; i < array.length; i++){
     
156.                         min = array[i] < min ? array[i] : min;
     
157.                 }
     
158.                 return min;
     
159.         }
     
160. 
     
161. }

复制代码

运行结果摘要：
Start tag = 29
Ant3 turn foward in 9
Ant2 turn foward in 9
Ant1 Time:3
Ant4 turn foward in 12
Ant3 turn foward in 12
Ant5 turn foward in 15
Ant4 turn foward in 15
Ant2 Time:11
Ant3 Time:17
Ant5 Time:20
Ant4 Time:23
Max:23
Start tag = 30
Ant2 turn foward in 5
Ant1 turn foward in 5
Ant2 turn foward in 7
Ant3 turn foward in 7
Ant1 Time:7
Ant4 turn foward in 10
Ant3 turn foward in 10
Ant4 turn foward in 13
Ant5 turn foward in 13
Ant2 Time:11
Ant3 Time:17
Ant4 Time:23
Ant5 Time:24
Max:24
Start tag = 31
Ant1 Time:3
Ant2 Time:7
Ant3 Time:11
Ant4 Time:17
Ant5 Time:23
Max:23
所有蚂蚁都离开的最短时间：11s
所有蚂蚁都离开的最长时间：24s


这题的重点应该不是看你编程能力，而是搜索的思想，最小值很容易确定，最大值是3到27的时间，也就是第一只蚂蚁到第27点的时间，最小值容易证明，最大值是这个应该也可以证

果断学习下 。。。。。

赞一个！！！

这道题很有意思，惠存了，等有时间了思考下。

长长见识，看看各位大神的回答！嘿嘿嘿

百度就是百度，好难

学习了！！！