SinglyLinkedListNode* condense(SinglyLinkedListNode* head) {
    if (!head) return nullptr;

    unordered_set<int> seen;
    SinglyLinkedListNode* current = head;
    SinglyLinkedListNode* prev = nullptr;

    while (current) {
        if (seen.find(current->data) != seen.end()) {
            prev->next = current->next;
        } else {
            seen.insert(current->data);
            prev = current;
        }
        current = current->next;
    }

    return head;
}

int numPlayers(int k, vector<int> scores) {
  sort(scores.begin(), scores.end(), greater<int>());
  int rank = 1, s = 1, i = 0;
  int count = 0;
  
  while(i < int(scores.size())) {
    //cout << scores[i] << endl;
    int temp = scores[i];
    if(scores[i] == 0) {
      i++;
      continue;
    }
    scores[i] = i + 1;
    int val = i + 1;
    if((i + 1) <= k)
      count++;
    else
      break;
    i++;
    
    while(i < int(scores.size()) && temp == scores[i]) {
      scores[i] = scores[i - 1];
      i++;
      if(scores[i] <= k)
        count++;
    }
  }
return count;
}

#include <bits/stdc++.h>
using namespace std;
class UnionFind {
    vector<int> parent;
    vector<int> rank;
    vector<int> maxStrength;
    
public:
    UnionFind(int n) {
        parent.resize(n + 1);
        rank.resize(n + 1, 0);
        maxStrength.resize(n + 1);
        for (int i = 1; i <= n; ++i) {
            parent[i] = i;
            maxStrength[i] = i; 
        }
    }

    int find(int u) {
        if (parent[u] != u) {
            parent[u] = find(parent[u]);
        }
        return parent[u];
    }

    void unionSets(int u, int v) {
        int rootU = find(u);
        int rootV = find(v);
        
        if (rootU != rootV) {
            if (rank[rootU] > rank[rootV]) {
                parent[rootV] = rootU;
                maxStrength[rootU] = max(maxStrength[rootU], maxStrength[rootV]);
            } else if (rank[rootU] < rank[rootV]) {
                parent[rootU] = rootV;
                maxStrength[rootV] = max(maxStrength[rootU], maxStrength[rootV]);
            } else {
                parent[rootV] = rootU;
                maxStrength[rootU] = max(maxStrength[rootU], maxStrength[rootV]);
                rank[rootU]++;
            }
        }
    }

    int getMaxStrength(int u) {
        return maxStrength[find(u)];
    }
};

vector<int> networkSums(int n, int e, vector<int>& from, vector<int>& to) {
    UnionFind uf(n);
    vector<int> results;
    int totalSum = 0;
    
    for (int i = 0; i < e; ++i) {
        int u = from[i];
        int v = to[i];
        uf.unionSets(u, v);

        unordered_set<int> uniqueRoots;
        totalSum = 0;
        
        for (int j = 1; j <= n; ++j) {
            uniqueRoots.insert(uf.find(j));
        }
        
        for (int root : uniqueRoots) {
            totalSum += uf.getMaxStrength(root);
        }
        
        results.push_back(totalSum);
    }
    
    return results;
}

def equalize(power):
    power.sort()
    n = len(power)
    median = power[n // 2] if n % 2 == 1 else (power[n // 2 - 1] + power[n // 2]) // 2
    total_time = sum(abs(p - median) for p in power)
    return total_time

def getMinimumTime(requestedServers, transitionTime):
    n = len(requestedServers)
    m = len(transitionTime)
    min_time = 0
    
    for i in range(1, n):
        current = requestedServers[i] - 1  
        previous = requestedServers[i-1] - 1  
        distance = min((current - previous) % m, (previous - current) % m)
        min_time += distance * transitionTime[previous]
    return min_time

#include <vector> 
#include <algorithm> 

int getMinimumTime(const std::vector<int>& requestedServers, const std::vector<int>& transitionTime) { 
    int n = requestedServers.size(); 
    int m = transitionTime.size(); 
    int min_time = 0; 

    for (int i = 1; i < n; i++) { 
        int current = requestedServers[i] - 1;   
        int previous = requestedServers[i - 1] - 1;   
        int distance = std::min((current - previous + m) % m, (previous - current + m) % m); 
        min_time += distance * transitionTime[previous]; 
    } 
     
    return min_time; 
}

import heapq

class GPUAllocator:
    def __init__(self):
        self.available_gpus = []
        self.max_gpu_id = 10**6
        self.next_gpu_id = 1
        self.add_gpus(self.max_gpu_id)

    def add_gpus(self, count):
        for _ in range(count):
            heapq.heappush(self.available_gpus, self.next_gpu_id)
            self.next_gpu_id += 1

    def smallestUnoccupied(self):
        if not self.available_gpus:
            self.add_gpus(100)
        return self.available_gpus[0] if self.available_gpus else -1

# Example usage
allocator = GPUAllocator()
print(allocator.smallestUnoccupied())
print(allocator.smallestUnoccupied())