Untitled

#define MAXN        100
#define MAXL        8
#include <queue>
#include <unordered_map>
#include <string>
using namespace std;
struct Customer
{
    int ticketEnd;
    int rentStart;
    int durability;
}user[10010];
int maxRideTime;
 
struct Bike
{
    int timeUsed;
    bool operator < (const Bike &other) const {return timeUsed < other.timeUsed;}
};
 
 
struct Station
{
    int deliverTime;
    int newBike;
    priority_queue<Bike> bikeUsed;
    queue<int> bikeDeliver;
}S[110];
int uID, sID;
unordered_map<string,int> hashUser;
 
void init(int N, int durableTime, int deliveryTimes[MAXN])
{
    maxRideTime = durableTime;
    hashUser.clear();
    for (int i = 0; i < N; i++)
    {
        S[i].deliverTime = deliveryTimes[i];
        S[i].newBike = 0;
        S[i].bikeDeliver = queue<int>();
        S[i].bikeUsed = priority_queue<Bike> ();
    }
    uID = 0;
}
 
void addBicycle(int cTimestamp, int pID, int bicycleNum)
{
    S[pID].newBike += bicycleNum;
}
 
void buyTicket(int cTimestamp, char uName[MAXL], int validTime)
{
    int uid = hashUser[uName];
    if (uid == 0) // chưa có user -> tạo user
    {
        uID++;
        uid = uID;
        hashUser[uName] = uid;
        user[uid].rentStart = 0;
        user[uid].ticketEnd = 0;
    }
    if (user[uid].ticketEnd > cTimestamp) user[uid].ticketEnd += validTime;
    else user[uid].ticketEnd = cTimestamp + validTime;
}
 
int rentBicycle(int cTimestamp, char uName[MAXL], int pID)
{
    int uid = hashUser[uName];
    if (/*uid == 0 ||*/ user[uid].ticketEnd <= cTimestamp || user[uid].rentStart != 0) return -1;
    //auto &s = S[pID];
    if (S[pID].newBike > 0)
    {
        S[pID].newBike--;
        user[uid].durability = maxRideTime;
    }
    else if (!S[pID].bikeDeliver.empty() && S[pID].bikeDeliver.front() <= cTimestamp)
    {
        S[pID].bikeDeliver.pop();
        user[uid].durability = maxRideTime;
    }
    else
    {
        if (S[pID].bikeUsed.empty()) return -1;
        Bike b(S[pID].bikeUsed.top());
        S[pID].bikeUsed.pop();
        user[uid].durability = b.timeUsed;
    }
    user[uid].rentStart = cTimestamp;
    return maxRideTime - user[uid].durability;
}
 
int returnBicycle(int cTimestamp, char uName[MAXL], int pID)
{
    int uid = hashUser[uName];
    if (uid == 0 || user[uid].rentStart == 0) return -1;
    auto &u = user[uid];
    int overdue = cTimestamp - u.ticketEnd + 1;
    int durableLeft = u.durability - (cTimestamp-u.rentStart);
    auto &s = S[pID];
    if (durableLeft < 0)
    {
        s.bikeDeliver.push(cTimestamp + s.deliverTime);
    }
    else
    {
        Bike b = {durableLeft};
        s.bikeUsed.push(b);
    }
    u.rentStart = 0;
    if (overdue < 0) overdue = 0;
    return overdue;
	return 0;
}
////////////////////////////////////////////
#define MAXN		100
#define MAXL		8
#include<unordered_map>
#include<queue>
#include<string>
using namespace std;

struct user{
	int ticket_end;
	int rent_start;
	int durability;
};
struct Bike
{
    int timeUsed;
    bool operator < (const Bike &other) const {return timeUsed < other.timeUsed;}
};
struct station{
	int deliver_time;
	int new_bike;
	queue<int> bike_deliver;
	priority_queue<Bike> bike_user;
};
station Sta[105];
user User[10005];
unordered_map<string,int> map_user;
int idx;
int max_TimeRide;
void init(int N, int durableTime, int deliveryTimes[MAXN])
{
	idx=0;
	map_user.clear();
	max_TimeRide = durableTime;
	for(int i=0;i<N;i++)
	{
		Sta[i].deliver_time=deliveryTimes[i];
		Sta[i].new_bike=0;
		Sta[i].bike_user = priority_queue<Bike>();
		Sta[i].bike_deliver = queue<int>();
	}

}

void addBicycle(int cTimestamp, int pID, int bicycleNum)
{
	Sta[pID].new_bike+=bicycleNum;
}

void buyTicket(int cTimestamp, char uName[MAXL], int validTime)
{
	int id =map_user[uName];
	if (id==0) 
	{
		idx++;
		map_user[uName] = idx;
		User[idx].rent_start = 0;
		User[idx].ticket_end = 0;
	}
	if (User[idx].ticket_end > cTimestamp) 
	{
		User[idx].ticket_end+= validTime;
	}
	else 
		User[idx].ticket_end = cTimestamp + validTime;
}

int rentBicycle(int cTimestamp, char uName[MAXL], int pID)
{
	int id = map_user[uName];
	if(id==0||User[id].ticket_end<=cTimestamp || User[id].rent_start!=0) return -1;
	if(Sta[pID].new_bike>0) // Neu con xe moi
	{
		Sta[pID].new_bike--;
		User[id].durability=max_TimeRide;
	}
	else if(!Sta[pID].bike_deliver.empty() && Sta[pID].bike_deliver.front()<=cTimestamp)//neu xe moi da ve
	{
		Sta[pID].bike_deliver.pop();
		User[id].durability=max_TimeRide;
	}
	else {
		if(Sta[pID].bike_user.empty()) return -1;//neu danh sach xe rong
		Bike b = Sta[pID].bike_user.top();
		Sta[pID].bike_user.pop();
		User[id].durability = b.timeUsed;
	}
	User[id].rent_start=cTimestamp;
	return max_TimeRide-User[id].durability;
	
}

int returnBicycle(int cTimestamp, char uName[MAXL], int pID)
{
	int id = map_user[uName];
	if(id==0 || User[id].rent_start==0) return -1;
	if(User[id].ticket_end>cTimestamp) return 0;
	
    int overdue = cTimestamp - User[id].ticket_end + 1;
	int durableLeft = User[id].durability - (cTimestamp-User[id].rent_start);
   
    if (durableLeft < 0)
    {
		Sta[pID].bike_deliver.push(cTimestamp + Sta[pID].deliver_time);
    }
    else
    {
		 Bike b = {durableLeft};
		Sta[pID].bike_user.push(b);
    }
	User[id].rent_start = 0;
    if (overdue < 0) overdue = 0;
    return overdue;
	return 0;
}