将士兵分配到房间算法问题

Question

所以我有一个搜索问题需要在 Java 中进行优化。这是一个示例，说明了我要解决的问题。

一名士兵到达一个基地并被分配到一个住房单元。每个基地都有一个或多个住房单元。

每个住房单元都有一个或多个房间。每个房间里都有多张床。每个房间都有一个优先级编号（1 是最高优先级）。每个房间的床位数可以不同。

士兵需要分配到一个房间。他被分配到拥有最多可用床位的房间。如果有多个房间的床位数相同，他会去优先级更高的房间。

一旦士兵被分配到一个房间，可用床位的数量当然会更新，并且队列中的下一个士兵将使用相同的过程添加，直到所有士兵都被分配到房间。

如果无法将士兵分配到床位，我们不必担心，因为没有可用的床位。另一个进程负责处理这种溢出情况。

我的问题是哪种 Java 数据结构实现最能解决士兵将被分配到哪个房间的问题？

目前我用的是多维ArrayList，感觉一定有更好的办法。

Answer 1

在设计和时间复杂度方面，您当然可以做得比多维 ArrayList 更好。

从设计的角度来看，您有三个包含类 - Room、House 和 Base。 （也可以是Soldier，尽管出于我们的目的，Soldier 不需要任何额外信息。）

public class Soldier{}

首先，Room 相当简单。它必须包含Soldiers 并知道它还剩下多少个开放房间

public class Room {

    private int totalBeds;
    public final int priority;
    private ArrayList<Soldier> soldiers;

    public Room(int totalBeds, int priority) {
        this.totalBeds = totalBeds;
        this.priority = priority;
        soldiers = new ArrayList<>();
    }

    public boolean add(Solider s) {
        if(soldiers.size() >= totalBeds) {
            return false;
        }
        return soldiers.add(s);
    }

    public int getRemainingBeds() {
        return totalBeds - soldiers.size();
    }

    public boolean isFull() {
        return totalBeds <= soldiers.size();
    }
}

从那里，我们需要一个House 类。这是Rooms 的优先级队列，必须能够根据其优先级将士兵添加到房间。

public class House {

    private final String name;
    private PriorityQueue<Room> rooms;

    public House(String name, Room... rooms) {
        this.name = name;
        this.rooms = new PriorityQueue<>(new Comparator<Room>() {
            public int compare(Room a, Room b) {

                //Always prioritize an open room to a full one
                if(a.isFull() && b.isFull()) {
                    return 0;
                } else if (a.isFull()) {
                    return 1;
                } else if (b.isFull()) {
                    return -1;
                } else {
                    //Now try to get the room with the most available rooms
                    int bedDiff = b.getRemainingBeds() - a.getRemainingBeds();
                    if(bedDiff != 0) {
                        return bedDiff;
                    }
                    return a.priority - b.priority;
                }
           }
       });
       for(Room r : rooms) {
           this.rooms.add(r)
       }
    }

    public boolean add(Soldier s) {
        Room r = rooms.poll();
        boolean ok = r.add(s);
        rooms.add(r);
        return ok;
    }

    public String getName() {
        return name;
    }
}

最后，Base 类应该使用Map<String, House> 来通过名称快速定位房子

public class Base {

    private Map<String, House> houses;

    public Base(House... houses) {
        houses = new HashMap<>();
        for(House h : houses) {
            houses.put(h.getName(), h);
        }
    }

    public boolean add(String houseName, Soldier s) {
        return houses.get(houseName).add(s);
    }
}

将士兵添加到基地的全时复杂度：

- Finding the correct House: O(1)
- Adding to the House:
    - Poll: O(log(#rooms in house))
    - Add to room: O(1)
    - Add: O(log(#rooms in house))

Answer 2

这里有一个建议：

1. 首先，您不必担心“住房单元”，因为它永远不会进入决策过程的方程式。
2. 或许可以创建一个Room 类来保存名称/住房单元（例如“A1”）、可用床位数量和优先级的字段。
3. 创建一个包含Room[] rooms（或等效项）的数组，并按照接下来要带士兵的位置对其进行排序（#beds 和优先级）。
4. 当一名士兵进来时，他在rooms[0] 中取一张床，移走一张床。如果房间现在已满，请将其从列表中删除。
5. 然后取rooms[0] 并通过与它下面的rooms[i] 比较找到它的新索引，直到找到新索引。

继续此操作，直到 rooms 为空

Answer 3

听起来您可以使用 PriorityQueue 并为 Room 类使用自定义比较器：

PriorityQueue<Room> queue = new PriorityQueue<>(new Comparator<Room>() {
  @Override
  public int compare(Room a, Room b) {
    int compareByAvailableBeds = Integer.compare(
        b.getAvailableBeds(), a.getAvailableBeds());
    if (compareByAvailableBeds != 0) {
      return compareByAvailableBeds;
    }

    return Integer.compare(a.getPriority(), b.getPriority());
  }
});

现在，要将士兵分配到房间，您可以采用“最低”优先级Room，将其从队列中删除，将其分配给士兵，然后将其重新添加到队列中：

Room room = queue.poll();
room.assign(soldier);  // Assuming this decrements the number of available beds.
queue.add(room);