数据结构刷题 -- 客房预约

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
该酒店所有房间的价格总和

 

2. api调用次数

[Constraints]
1. N, the number of hotels, is 1,000 at maximum.
2. init() is called once in the very beginning of each test case.
3. addRoom() is called all at once after init() and is no longer called after findRoom() or riseCosts() is called.
4. The number of rooms in each hotel is 100 at most.
5. findRoom() is called up to 10,000 times.
6. riseCosts() is called up to 500 times.

 

 

3. 单个测试数据

1 100
3 2 6 10 
100 1 1 2 2 2 1 14629
100 1 2 2 3 1 2 10203
100 2 3 2 3 1 1 15374
100 2 4 1 2 2 1 10795
100 2 5 2 2 1 2 17701
100 2 6 1 3 2 2 13757
100 2 7 1 3 1 2 13569
100 2 8 1 3 2 2 17424
100 3 9 1 3 2 1 18267
100 3 10 2 3 1 2 11378
100 3 11 1 3 1 1 11800
100 3 12 2 3 2 2 16613
100 3 13 1 3 2 1 13157
100 3 14 2 3 1 2 10064
100 3 15 1 3 2 1 12999
100 3 16 1 3 1 2 13642
100 3 17 2 2 2 2 14388
100 3 18 2 2 2 2 16089
200 7 11 2 3 1 2 14
200 4 9 2 3 2 1 -1
200 12 13 2 3 1 2 14
200 21 25 1 2 2 2 -1
200 21 24 2 2 1 2 5
200 9 13 1 2 1 2 -1
300 2 97479
200 27 31 1 2 2 2 -1
300 2 107225
200 16 17 1 3 2 2 6
200 8 11 2 3 1 2 2
200 18 20 2 2 1 2 5
200 9 10 2 3 2 1 -1
200 22 27 2 3 2 2 12
200 27 31 1 3 1 1 11
200 24 25 1 3 1 2 16
300 3 152231
200 4 7 1 2 2 1 4
200 9 13 2 2 1 1 -1
200 14 17 2 2 1 1 -1
400

 

4. 主类

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;


class Solution {
	private static UserSolution user = new UserSolution();
	
	private static int roomCnt[] = new int[1005];
	
	private static final int ADDROOM = 100;
	private static final int FINDROOM = 200;
	private static final int RISECOSTS = 300;
	private static final int END = 400;
	
	private static int hotelID = 0;
	private static int roomID = 0;
	private static int roomInfo[] = new int[5];
	private static int filterInfo[] = new int[6];
	
	private static int run(BufferedReader br, int _score) throws Exception
	{
		int score = _score;
		StringTokenizer st = new StringTokenizer(br.readLine(), " ");
		int n = Integer.parseInt(st.nextToken());
		
		for (int i = 0; i < n; i++)
			roomCnt[i] = Integer.parseInt(st.nextToken());

		user.init(n, roomCnt);

		int cmd, user_ans, correct_ans;
		for(int q = 0;;q++)
		{
			st = new StringTokenizer(br.readLine(), " ");
			cmd = Integer.parseInt(st.nextToken());

			switch (cmd)
			{
			case ADDROOM:
				hotelID = Integer.parseInt(st.nextToken());
				roomID = Integer.parseInt(st.nextToken());
				
				for (int i = 0; i < 5; i++)
					roomInfo[i] = Integer.parseInt(st.nextToken());

				user.addRoom(hotelID, roomID, roomInfo);
				break;
			case FINDROOM:
				for (int i = 0; i < 6; i++)
					filterInfo[i] = Integer.parseInt(st.nextToken());

				user_ans = user.findRoom(filterInfo);
				correct_ans = Integer.parseInt(st.nextToken());

				if (user_ans != correct_ans)
					score = 0;
				break;
			case RISECOSTS:
				hotelID = Integer.parseInt(st.nextToken());
				user_ans = user.riseCosts(hotelID);
				correct_ans = Integer.parseInt(st.nextToken());

				if (user_ans != correct_ans)
					score = 0;
				break;
			case END:
				return score;
			default:
				score = 0;
				break;
			}
		}
	}
	
	public static void main(String[] args) throws Exception {
//		System.setIn(new java.io.FileInputStream("res/sample_input.txt"));
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine(), " ");

		int tc = Integer.parseInt(st.nextToken());
		int score = Integer.parseInt(st.nextToken());

		for (int t = 1; t <= tc; t++)
		{
			System.out.println("#"+ t + " " + run(br, score));
		}

		br.close();
	}

	
	

}

5. 需要实现的api

class UserSolution
{
	void init(int N, int mRoomCnt[])
	{
	
	}
	
	void addRoom(int mHotelID, int mRoomID, int mRoomInfo[])
	{
	
	}
	
	int findRoom(int mFilter[])
	{
		return 0;
	}
	
	int riseCosts(int mHotelID)
	{
		return 0;
	}
}

6. 目前实现的代码（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;
	}

}