三个java超级变态逻辑循环编程题

ozrv872

很锻炼思维

ludaos

很有意思，拿回去看看

zhinwai

逻辑问题

keyinzhi

有意思，研究研究

wulingji

这个太变态了，做出来的都是牛人啊

kf38211

蚂蚁问题

1. 
   
2. public class Test {
   
3.         //初始时任意相邻2只蚂蚁之间的距离都是偶数。
   
4.         //每秒钟任意相邻2只蚂蚁之间的距离要么+2，要么-2，要么不变
   
5.         //因此任意相邻2只蚂蚁在碰头的所经历的时间必定是整数秒。
   
6.         //因此可以每秒钟查询一次6只蚂蚁的状态。
   
7.         public static void main(String[] args) {
   
8.                 //初始化 5只蚂蚁，-1表示向左，1表示向右，
   
9.                 //直观感觉最小时间应该是-1，-1，-1，1，1。其他情况就不测试了。
   
10.                 int[] orientations = {-1,-1,-1,+1,+1};
    
11.                 Anti[] antis = new Anti[5];
    
12.                 antis[0] = new Anti();
    
13.                 antis[1] = new Anti();
    
14.                 antis[2] = new Anti();
    
15.                 antis[3] = new Anti();
    
16.                 antis[4] = new Anti();
    
17.                 antis[0].init(null, antis[1], 3, 24, orientations[0], true);
    
18.                 antis[1].init(antis[0], antis[2], 7, 20, orientations[1], true);
    
19.                 antis[2].init(antis[1], antis[3], 11, 16, orientations[2], true);
    
20.                 antis[3].init(antis[2], antis[4], 17, 10, orientations[3], true);
    
21.                 antis[4].init(antis[3], null, 23, 4, orientations[4], true);
    
22.                
    
23.                 int i = 0;
    
24.                 for (;;i++) {//每秒轮询
    
25.                         boolean isDone = true;;
    
26.                         for (Anti anti : antis) {
    
27.                                 if (anti.isOnLine) {
    
28.                                         isDone = false;
    
29.                                         anti.left+=anti.orientation;
    
30.                                         anti.right-=anti.orientation;
    
31.                                         if (anti.left == 0 || anti.right ==0){
    
32.                                                 anti.isOnLine = false;
    
33.                                         }
    
34.                                 }
    
35.                         }
    
36.                         if (isDone) {
    
37.                                 break;
    
38.                         }
    
39.                         for (Anti anti : antis) {
    
40.                                 if (anti.isOnLine) {
    
41.                                         if (anti.leftAnti == null ) {
    
42.                                                 if (anti.rightAnti.isOnLine
    
43.                                                         && anti.rightAnti.left == anti.left) {
    
44.                                                         anti.orientation  = anti.orientation *-1;
    
45.                                                 }
    
46.                                         } else {
    
47.                                                 if (anti.leftAnti.isOnLine
    
48.                                                                 && anti.leftAnti.left == anti.left) {
    
49.                                                         anti.orientation  = anti.orientation *-1;
    
50.                                                 }
    
51.                                         }
    
52.                                 }
    
53.                         }
    
54.                 }
    
55.                 System.out.printf("当初始方向为%d,%d,%d,%d,%d时,一共%d秒",
    
56.                                 orientations[0],orientations[1],orientations[2],orientations[3],orientations[4],i);
    
57.         }
    
58. }
    
59. 
    
60. class Anti {
    
61.         Anti leftAnti;
    
62.         Anti rightAnti;
    
63.         int orientation ;//-1:left, +1:right
    
64.         float left;
    
65.         float right;
    
66.         boolean isOnLine;
    
67.        
    
68.         public Anti(){
    
69.         }
    
70.         public void init(Anti leftAnti, Anti rightAnti, float left, float right,
    
71.                         int orientation, boolean isOnLine) {
    
72.                 this.leftAnti = leftAnti;
    
73.                 this.rightAnti = rightAnti;
    
74.                 this.left = left;
    
75.                 this.right = right;
    
76.                 this.orientation = orientation;
    
77.                 this.isOnLine = isOnLine;
    
78.         }
    
79. }
    

复制代码

遍历可能的初始方向数组可以测试其他情况，然后就可以算出最大最小时间

kf38211

回复 16# shaohuifan


    这个算法测出来的最小时间是13秒，但是直观感觉最小时间应该是11秒。

kf38211

会议问题

1. 
   
2. public class AA {
   
3.         public static void main(String[] args) {
   
4.                 //代表ABCDEF 6人，-1表示不去，1表示会去
   
5.                      //直观感觉是1,1,1,-1,-1,1。其他情况可以更改plan进行验证
   
6.                 int[] plan = {1,1,1,-1,-1,1};
   
7.                 if (checkPlan(plan))
   
8.                         System.out.println("plan is OK");
   
9.                 else
   
10.                         System.out.println("plan is not OK");
    
11.         }
    
12.        
    
13.         public static boolean checkPlan(int[] plan){
    
14.                 if (plan[0]+plan[1] == -2)//AB
    
15.                         return false;
    
16.                 if (plan[0]+plan[4]+plan[5] != 1) //AEF
    
17.                         return false;
    
18.                 if (plan[1]+plan[2] == 0) //BC
    
19.                         return false;
    
20.                 if (plan[0]+plan[3] != 0) //AD
    
21.                         return false;
    
22.                 if (plan[2]+plan[3] != 0) //CD
    
23.                         return false;
    
24.                 if (plan[3]==-1 &&plan[4] ==1)//DE
    
25.                         return false;
    
26.                 return true;
    
27.         }
    
28. }
    

复制代码

遍历所有可能的plan，即可以得到可行的出席计划

nanyil

很锻炼。。。

wulingji

研究了一下，看是看懂了，自己写就有点难了