这种多条件的区间问题怎么解决呢？

Question

1. 题目描述
您需要实现一个功能，快速找到客户想要的酒店房间。
在系统中注册的酒店数量N，最多为1000家。
酒店ID的值介于1和N之间。这些值彼此不同。
每家旅馆最多有100个房间。
每个房间的ID值介于1和100000之间。给定值彼此不同。
（但是，酒店ID和房间ID的值可以相同。）

每个房间都有以下信息:
Region (1 ~ 10)
Number of Beds (2 ~ 10)
Room Type    (1 ~ 4)
View Type (1 ~ 4)
Initial Price    (10,000 ~ 20,000)

酒店客房搜索系统会返回与客户选择的过滤器选项匹配的房间中最便宜的房间。
客户输入的信息如下:
Check-in Date (1 ~ 9,999)
Check-out Date (Check-in Date +1 ~ 10,000)
Region (1 ~ 10)
Number of Beds (2 ~ 10)
Room Type (1 ~ 4)
View Type (1 ~ 4)

请实现以下API：
void init(int N, int mRoomCnt[])
此函数在每个测试用例开始时调用一次。
参数
N：酒店数量(1 ≤ N≤ 1,000)
mRoomCnt[]：每个酒店的客房数量。该值大于或等于1，但最多为100。
mRoomCnt[k]是酒店ID为k+1的酒店的房间数。(0 ≤ k ≤ N-1)

void addRoom(int mHotelID, int mRoomID, int mRoomInfo[])
此功能可在酒店中添加新房间。
将添加房间的酒店ID的值为mHotelID。
要添加的房间ID的值为mRoomID。
mRoomInfo是关于将添加的房间的信息。
mRoomInfo是一个长度为5的数组。每个索引包含以下值。
[0]：Region
[1]：Number of Beds
[2]：Room Type
[3]：View Type
[4]：Price
每个阵列的值满足本文所述的约束。
保证要添加的房间数量不超过从init()传递的房间数量。
参数
mHotelID：将添加房间的酒店ID（1≤ mHotelID≤ N）
mRoomID：房间ID（1≤ 米隆≤ 100,000 )
mRoomInfo：房间信息

int findRoom(int mFilter[])
此功能用于查找和预订房间。
mFilter是一个包含筛选器选项的数组。
[0]：Check-in Date
[1]：Check-out Date
[2]：Region
[3]：Number of Beds
[4]：Room Type
[5]：View Type 每个阵列的值满足本文所述的约束。
您不能预订从入住日期到退房日期已经被预订的房间。
但是，其他客户也可以在退房日期入住。
在匹配过滤器选项的房间中，预订最便宜的房间。
价格相同时，选择ID值最小的房间。
此函数返回已预订房间的ID值。
当没有可预订的房间时，此函数返回-1。
参数
mFilter：房间的过滤器选项
Return
已预订房间的ID值

int riseCosts(int mHotelID)
该功能将酒店所有房间的价格提高10%。
计算时，删除小数。例如：房价15374提高10%，15374 + 1537 = 16911
参数
mHotelID：价格上涨的酒店ID（1≤ mHotelID≤ N）
Return
该酒店所有房间的价格总和

这是我的作答，但是需要花费10s，希望帮我优化一下

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.TreeSet;

class UserSolution
{
    
    class Hotel {
        
        int nums;
        TreeSet<Room> queue = new TreeSet<>(new MyComparator());
        Hotel(int nums) {
            this.nums = nums;
        }
    }
    
    class Room {
        int roomId;
        int reigon;
        int beds;
        int roomType;
        int viewType;
        int price;
        List<UserDate> userDate = new ArrayList<>();
        Room (int roomId, int reigon, int beds, int roomType, int viewType, int price) {
            this.roomId = roomId;
            this.reigon = reigon;
            this.beds = beds;
            this.roomType = roomType;
            this.viewType = viewType;
            this.price = price;
        }
        
    }
    
    class UserDate {
        int start;
        int end;
        
        UserDate(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }
    
    class MyComparator implements Comparator<Room> {

        @Override
        public int compare(UserSolution.Room o1, UserSolution.Room o2) {
            if (o1.price == o2.price) {
                return o1.roomId - o2.roomId;
            }
            return o1.price - o2.price;
        }
        
    }
    
    
    
    HashMap<Integer, Room> roomMap = new HashMap<>();
    Hotel[] hotels;
    int n;
    
    void init(int N, int mRoomCnt[])
    {
        n = N + 1;
        hotels = new Hotel[n];
        roomMap.clear();
        
        for (int i = 0; i < n; i++) {
            hotels[i] = new Hotel(mRoomCnt[i]);
        }
        
    }
    
    void addRoom(int mHotelID, int mRoomID, int mRoomInfo[])
    {
        Room room = new Room(mRoomID, mRoomInfo[0], mRoomInfo[1], mRoomInfo[2], mRoomInfo[3], mRoomInfo[4]);
        roomMap.put(mRoomID, room);
        hotels[mHotelID].queue.add(room);
    }
    
    int findRoom(int mFilter[])
    {
        int findId = -1;
        int minPrice = Integer.MAX_VALUE;
        for (Hotel hotel : hotels) {
            TreeSet<Room> queue = hotel.queue;
            for (Room room : queue) {
                if (check(room, mFilter)) {
                    if (room.price < minPrice) {
                        minPrice = room.price;
                        findId = room.roomId;
                    }
                    break;
                }
            }
        }
        if (findId != -1) {
            roomMap.get(findId).userDate.add(new UserDate(mFilter[0], mFilter[1]));
        }
        return findId;
    }
    
    boolean check(Room room, int[] mFilter) {
        
        if (mFilter[2] != room.reigon) {
            return false;
        }
        
        if (mFilter[3] != room.beds) {
            return false;
        }
        
        if (mFilter[4] != room.roomType) {
            return false;
        }
        
        if (mFilter[5] != room.viewType) {
            return false;
        }
        
        for (UserDate userDate : room.userDate) {
            if (mFilter[0] >= userDate.start && mFilter[1] <= userDate.end) {
                return false;
            }
            if (mFilter[0] >= userDate.start && mFilter[0] < userDate.end && mFilter[1] > userDate.end) {
                return false;
            }
            if (mFilter[0] < userDate.start && mFilter[1] > userDate.start && mFilter[1] <= userDate.end) {
                return false;
            }
            if (mFilter[0] < userDate.start && mFilter[1] > userDate.end) {
                return false;
            }
        }
        
        return true;
    }
    
    
    
    int riseCosts(int mHotelID)
    {
        int maxValue = 0;
        TreeSet<Room> newQueue = new TreeSet<>(new MyComparator());
        for (Room room : hotels[mHotelID].queue) {
            Room newRoom = room;
            newRoom.price += room.price * 0.1;
            newQueue.add(newRoom);
            maxValue += room.price;
        }
        hotels[mHotelID].queue.clear();
        hotels[mHotelID].queue = newQueue;
        return maxValue;
    }

}

Answer 1

参考通义千问和郭老师的小迷弟雅思莫了-编写提供，主要是为了帮助您快速解决问题，如下回答，您可以参考下，如有问题，评论区留言。

为了解决这个问题，我们可以使用一种数据结构，例如有序集合（平衡搜索树，如红黑树或AVL树）结合哈希表来存储和快速检索房间信息。以下是解决此问题的一种方法：

1. 创建一个类Room，包含酒店ID、房间ID、区域、床数、房间类型、视野类型、价格以及入住/退房日期等字段。

2. 使用一个全局变量rooms作为有序集合，按房间价格排序，同时每个节点关联到一个Room对象。这样可以方便地找到最便宜的符合条件的房间。

3. 创建一个哈希表hotel_rooms，键是酒店ID，值是一个链表，链表中存储的是该酒店的所有房间。

4. init()函数初始化全局变量，并根据输入的每个酒店的房间数量创建并添加房间。

5. addRoom()函数将新房间按照上述结构添加到rooms有序集合和对应的hotel_rooms哈希表中。

6. findRoom()函数首先根据过滤条件（入住/退房日期、区域、床数、房间类型、视野类型）筛选出所有符合条件的房间。然后在这些房间中找到价格最低且未被预订的房间进行预订，返回其房间ID。若无符合条件的房间，则返回-1。

7. riseCosts()函数获取指定酒店ID的房间链表，遍历并将每个房间的价格提高10%，同时更新rooms有序集合中的相关信息。最后计算并返回所有房间的新总价格。

注意：为了判断房间是否已被预订，可以在Room类中增加一个预订状态字段，并在findRoom()函数中检查这个字段。另外，在实现时需要处理好并发预订的情况以确保数据一致性。