解决N对N关系算法问题的最佳方法是什么？

如何解决解决N对N关系算法问题的最佳方法是什么？

我正在尝试编写一种算法，以将N个房间的日程安排给N个专业人员。我有一个“房间”对象列表和另一个“专业人员”列表。这样做的想法是能够为一天中的特定房间分配专业人员。这里的问题是专业人员可以是“专业”（由布尔属性表示）。这个专业人员需要特殊的房间。客房的属性为“ SpecialtyRoom”。理想情况下，该算法会尝试首先将专业客房与专业人士进行匹配，但是如果房间空缺，可以与常规专业人士一起预订。

这段代码是我一直在努力的工作，但每次都会遇到异常。我想知道解决这样的问题的最佳方法是什么？

private List<Room> generateDailySchedule(List<Room> roomList,List<Professional> professionalList) {
    if (roomList.size() <= 0 || professionalList.size() <=0) return roomList;

    //first run to find matches.
    int pIndex = 0;
  
    for (Room room : roomList) {
        if (pIndex < professionalList.size()) {
            if ((!room.isspecialtyRoom() && !professionalList.get(pIndex).isRequiresspecialtyRoom()) ||
                    (room.isspecialtyRoom() && professionalList.get(pIndex).isRequiresspecialtyRoom())) {
                room.setProfessional(professionalList.get(pIndex));
                professionalList.get(pIndex).setRoom(room);
            
                pIndex++;
            }
        }
    }
   
    //search for remaining professionals
    List<Professional> professionalsWaitingList = professionalList.stream()
            .filter(professional -> professional.getRoom() == null).collect(Collectors.toList());
   
    //search for remaining empty rooms
    List<Room> vacantRooms = roomList.stream().filter(room -> room.getProfessional() == null).collect(Collectors.toList());

    if (vacantRooms.size() > 0 && professionalsWaitingList.size() > 0) {
        for (Room vacantRoom : vacantRooms) {
            if (!vacantRoom.isspecialtyRoom()) {
                vacantRoom.setProfessional(professionalsWaitingList.stream().findFirst().get());
            } else {
                Optional<Professional> specialtyProfessional = professionalsWaitingList.stream()
                        .filter(professional -> (professional.isRequiresspecialtyRoom() && professional.getRoom() == null))
                        .findFirst();
                if (specialtyProfessional.isPresent()) {
                    vacantRoom.setProfessional(specialtyProfessional.get());
                    specialtyProfessional.get().setRoom(vacantRoom);
                } else {
                    System.out.println("No specialty professional found for room " + vacantRoom.getRoomName());
                    Optional<Professional> anyProfessional = professionalsWaitingList.stream()
                            .filter(professional -> professional.getRoom() == null)
                            .findFirst();
                    if(anyProfessional.isPresent()) {
                        vacantRoom.setProfessional(anyProfessional.get());
                        anyProfessional.get().setRoom(vacantRoom);
                    } else {
                        System.out.println("No professional found for room " + vacantRoom.getRoomName());
                    }
                }
            }
        }
    }
    return roomList;
}

这是“专业”和“房间”模型的简化代码：

@Entity
public class Professional {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@NotNull
private String name;

@OnetoOne(cascade = CascadeType.ALL)
@JoinTable( name = "professional_room",joinColumns = { @JoinColumn(name = "professional_id",referencedColumnName = "id") },inverseJoinColumns = { @JoinColumn(name = "room_id",referencedColumnName = "id") })
private Room room;

private Boolean requiresspecialtyRoom;

@Entity
public class Room {

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@NotBlank
private String roomName;

@NotNull
private boolean specialtyRoom;

@OnetoOne(mappedBy = "room")
private Professional professional;