Design a system that manages the reservation state of n seats that are numbered from 1 to n.

Implement the SeatManager class:


	SeatManager(int n) Initializes a SeatManager object that will manage n seats numbered from 1 to n. All seats are initially available.
	int reserve() Fetches the smallest-numbered unreserved seat, reserves it, and returns its number.
	void unreserve(int seatNumber) Unreserves the seat with the given seatNumber.


&nbsp;
Example 1:

Input
["SeatManager", "reserve", "reserve", "unreserve", "reserve", "reserve", "reserve", "reserve", "unreserve"]
[[5], [], [], [2], [], [], [], [], [5]]
Output
[null, 1, 2, null, 2, 3, 4, 5, null]

Explanation
SeatManager seatManager = new SeatManager(5); // Initializes a SeatManager with 5 seats.
seatManager.reserve();    // All seats are available, so return the lowest numbered seat, which is 1.
seatManager.reserve();    // The available seats are [2,3,4,5], so return the lowest of them, which is 2.
seatManager.unreserve(2); // Unreserve seat 2, so now the available seats are [2,3,4,5].
seatManager.reserve();    // The available seats are [2,3,4,5], so return the lowest of them, which is 2.
seatManager.reserve();    // The available seats are [3,4,5], so return the lowest of them, which is 3.
seatManager.reserve();    // The available seats are [4,5], so return the lowest of them, which is 4.
seatManager.reserve();    // The only available seat is seat 5, so return 5.
seatManager.unreserve(5); // Unreserve seat 5, so now the available seats are [5].


&nbsp;
Constraints:


	1 &lt;= n &lt;= 105
	1 &lt;= seatNumber &lt;= n
	For each call to reserve, it is guaranteed that there will be at least one unreserved seat.
	For each call to unreserve, it is guaranteed that seatNumber will be reserved.
	At most 105 calls in total will be made to reserve and unreserve.


class SeatManager:
    def __init__(self, n: int):
        self.lis = list(range(1,n+1))
    def reserve(self) -> int:
        mini = min(self.lis)
        self.lis.remove(mini)
        return mini

    def unreserve(self, seatNumber: int) -> None:
        self.lis.append(seatNumber)
class SeatManager {
    PriorityQueue<Integer> pq;
    int count;
    public SeatManager(int n) {
        count = 1;
        pq = new PriorityQueue();
    }

    public int reserve() {
        if(pq.size()==0)
            return count++;

        return pq.poll();
    }

    public void unreserve(int seatNumber) {
        pq.add(seatNumber);
    }
}
class SeatManager {
public:
    priority_queue<int, vector<int>, greater<int> > pq;
    SeatManager(int n) {
        for(int i = 1; i <= n; i++) pq.push(i);
    }

    int reserve() {
        int top = pq.top(); pq.pop();
        return top;
    }

    void unreserve(int seatNumber) {
        pq.push(seatNumber);
    }
};
var SeatManager = function(n) {
    
    this.min = 1
    this.n = n
    this.seat = []
    
};

SeatManager.prototype.reserve = function() {

    let res
	
    if( !this.seat[this.min] ){
        
        res = this.min
        this.min = this.n < this.min ? NaN : this.min + 1

    } else {
        
        res = this.min
        this.min = this.seat[this.min]
        
    }
    
    return res
};

SeatManager.prototype.unreserve = function(seatNumber) {
    
    if (this.min < seatNumber ) {
        
        let pre_inx = this.min 
        let next_inx = this.seat[this.min]
        
        while(next_inx < seatNumber){
            pre_inx = next_inx
            next_inx = this.seat[next_inx]
        }
        
        [ this.seat[pre_inx], this.seat[seatNumber] ] = [ seatNumber, this.seat[pre_inx] ]
        
    } else {
        
        [ this.seat[seatNumber], this.min ] = [ this.min, seatNumber ]
        
    }
};
Seat Reservation Manager