AirBnB春招笔试题

试题说明

笔试题只有一道，限时1小时。

模拟一个战争外交游戏，游戏中定义了三种操作:

A city1 Hold ： 军队A 占领了city1

A city1 Move city2 : 军队A从city1移动到city2

A city1 Support B ： 占领了city1的军队A增援军队B，得到增援的军队B的strength+1;

注意:

1. 每支军队的初始strength为1；

2. 如果有多个军队到达了同一个城市，则strength高的军队存活并占领该城市，strength低军队死亡；

3. 如果某支军队正在交战（即其所在的城市除自己外还有其他军队），则该军队的任何增援行动无效；

输入：

一系列字符串表示的的Action，如:

A Munich Hold
B Bohemia Move Munich
C Warsaw Support B

输出：

按字母表顺序排列的各个军队的状态(死亡或者存活，如果存活输出驻扎地点)，上面用例的输出为:

A [dead]
B Munich
C Warsaw

下面是原题:

JAVA题解:

 //游戏的规则是把所有的动作执行之后再判断状态，每个回合之中的所有动作没有先后之分。
 import java.util.*;

 public class testAirBnB {
     static List<String> evaluateActions(List<String> actions) {
         Map<String, army> armies = new TreeMap();
         Map<String, city> cities = new HashMap<>();
         ArrayList<String[]> manu = new ArrayList<>();
         ArrayList<String[]> supportList = new ArrayList<>();

         for (String action : actions) {
             //将每个aciton拆解
             String[] s = action.split(" ");
             //注册每个军队
             army a = new army(s[0]);
             armies.put(s[0], a);
             manu.add(s);
         }

         for (String[] str : manu) {
             //遍历每个action, 执行每个action
             //获取当前action的执行主体军队
             army a = armies.get(str[0]);
             //记录该军队当前所在城市
             a.whereNow = str[1];
             //保存目前军队所在城市
             city tmpCity;

             //为a当前所在的城市注册，如果记录中不存在该城市，新建一个记录，并将a军队加入其hold军队表
             if (!cities.containsKey(a.whereNow)) {//该城市之前未被注册过
                 tmpCity = new city(a.whereNow, a.strength, a.name);
                 cities.put(a.whereNow, tmpCity);
             } else {
                 //该城市之前注册过，但因为之前的战斗所有军队都死亡，现在可以重新hold；这里假设
                 //所有的操作都是有效的，即不存在向已有军队驻扎的城市hold的action发生
                 tmpCity = cities.get(a.whereNow);
                 tmpCity.holdArmies.put(a.name, a.strength);
             }

             if (str[2].equals("Hold")) {
                 //keep default;
             } else if (str[2].equals("Move")) {
                 //从当前的城市撤退
                 tmpCity.holdArmies.remove(a.name);
                 //进军到目的城市
                 a.whereNow = str[3];
                 //如果要去的城市已经被注册，直接加入驻扎名单
                 if (cities.containsKey(a.whereNow)) {
                     tmpCity = cities.get(a.whereNow);
                     tmpCity.holdArmies.put(a.name, a.strength);
                 }
                 //否则说明要去的城市未被驻扎过，直接注册该城市并记录驻扎信息
                 else {
                     tmpCity = new city(a.whereNow, a.strength, a.name);
                     cities.put(a.whereNow, tmpCity);
                 }

             } else if (str[2].equals("Support")) {
                 //必须等到所有的军队移动完毕才能确定是否可以增援
                 supportList.add(str);
 //                //为友军加buf
 //                army friend = armies.get(str[3]);
 //                friend.strength++;
 //                //更新友军所在城市注册表中友军的strength
 //                city friendCity = cities.get(friend.whereNow);
 //                friendCity.holdArmies.put(friend.name, friend.strength);
             }
         }

         //处理增援
         //如果A没有underAttack, 则可以增援
         //否则不可以增援
         for(String[] sptAction: supportList){
             //如果A所在城市的驻扎军队大于1只，说明A正在underAttack, A的增援行动无效

             if(cities.get(armies.get(sptAction[0]).whereNow).holdArmies.size()>1)
                 continue;
             //否则增援有效
             else{
                 //为友军加buf
                 army friend = armies.get(sptAction[3]);
                 friend.strength++;
                 //更新友军所在城市注册表中友军的strength
                 city friendCity = cities.get(friend.whereNow);
                 friendCity.holdArmies.put(friend.name, friend.strength);
             }
         }

         //跟据城市来判断每只军队的生存状况
         for (city tmpCity : cities.values()) {
             //当前城市的驻扎军队少于两支，不会发生战争
             if (tmpCity.holdArmies.size() < 2)
                 continue;
                 //驻扎军队大于两支

             else {
                 List<Map.Entry<String, Integer>> list = new ArrayList<>(tmpCity.holdArmies.entrySet());
 //                按treeMap的值从大到小排序
                 Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
                     @Override
                     public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                         return -o1.getValue().compareTo(o2.getValue());
                     }
                 });
                 //如果该城市的驻扎军队表中战力靠前的两支军队的战力相等，则驻扎在该城市的所有军队都回死亡(包括战力更低的)
                 if (list.get(0).getValue().equals(list.get(1).getValue())) {
                     //该城市所有军队都死亡
                     for (int i = 0; i < list.size(); i++) {
                         armies.get(list.get(i).getKey()).isAlive = false;
                     }
                 } else {
                     //否则除了第一支军队（战力最高的军队），其余军队死亡
                     for (int i = 1; i < list.size(); i++) {
                         armies.get(list.get(i).getKey()).isAlive = false;

                     }
                 }
             }
         }

         // 循环检查每个城市的状态，如果isAlive为false, 输出城市名+[dead]
         // 否则输出城市名+whereNow
         List<String> result = new ArrayList<>();
         for (army unit : armies.values()) {
             //如果状态标记为dead，直接输出
             if (!unit.isAlive)
                 result.add(unit.name + " " + "[dead]");
             else {
                 result.add(unit.name + " " + unit.whereNow);
             }
         }

         for (String s : result)
             System.out.println(s);

         return result;
     }

     public static void main(String[] args) {

         List<String> input = new ArrayList<>();
         //测试数据1
 //        input.add("A Munich Hold");input.add("B Warsaw Move Bohemia");
         //测试数据2
         input.add("A Munich Hold");input.add("B Bohemia Move Munich");input.add("C Warsaw Support B");
         //测试数据3
 //        input.add("A Munich Hold");input.add("B Bohemia Move Munich");input.add("C Prussia Move Munich");input.add("D Warsaw Hold");
         //测试数据4
 //        input.add("A Munich Support B");input.add("B Bohemia Move Prussia");input.add("C Prussia Hold");input.add("D Warsaw Move Munich");
         //测试数据5
 //        input.add("A Munich Support B");input.add("B Oakland Move Munich");
         evaluateActions(input);
     }

     static class army {
         String name;
         String whereNow;
         int strength = 1;
 //        boolean underAttack = false;
         boolean isAlive = true;

         army(String _name) {
             name = _name;
         }
     }

     static class city {
         String name;
         TreeMap<String, Integer> holdArmies = new TreeMap<>();

         city(String city_name, int strength, String army_name) {
             name = city_name;
             holdArmies.put(army_name, strength);
         }
     }

 }