Atascado en un problema de Acepta el Reto

#include <bits/stdc++.h>
using namespace std;
typedef vector<int> vi;
typedef set<int> si;
typedef set<int, greater<int> > rsi;

int main() {
  ios_base::sync_with_stdio(false); cin.tie(0);
  int n;
  while(cin >> n) {
    vi v(n);
    si already;
    rsi future;
    for(int& x : v) {
      cin >>  x;
      future.insert(x);
    }
    bool ok = true;
    future.erase(v[0]);
    already.insert(v[0]);
    for(int i=1; i<n-1 && ok; ++i) {
      future.erase(v[i]);
      int lowest = *already.begin();
      int highest = future.lower_bound(v[i]) == future.end() ? -1 : *future.lower_bound(v[i]);
      ok &= !(lowest < v[i] && v[i] > highest && lowest < highest);
      already.insert(v[i]);
    }
    cout << (ok ? "SIEMPRE PREMIO" : "ELEGIR OTRA") << endl;
  }
}

#pragma GCC push_options
#pragma GCC optimize ("O2")
#include <cstdio>
#include <set>
#include <iostream>
using namespace std;
typedef set<int, greater<int> > rsi;

int v[500009];

int main() {
  ios_base::sync_with_stdio(false);
  int n;
  while( scanf("%d", &n) == 1) {
    rsi future;
    for(int i = 0; i<n; ++i) {
      scanf("%d", &v[i]);
      future.insert(v[i]);
    }
    bool ok = true;
    future.erase(v[0]);
    int minv = v[0];
    for(int i=1; i<n-1 && ok; ++i) {
      future.erase(v[i]);
      int lowest = minv;
      auto x = future.lower_bound(v[i]);
      int highest = x == future.end() ? -1 : *x;
      ok &= !(lowest < v[i] && v[i] > highest && lowest < highest);
      minv = min(minv, v[i]);
    }
    printf("%s", ok ? "SIEMPRE PREMIO\n" : "ELEGIR OTRA\n");
  }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.TreeSet;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.util.Collections;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        NinyosPesaos solver = new NinyosPesaos();
        try {
            int testNumber = 1;
            while (true)
                solver.solve(testNumber++, in, out);
        } catch (UnknownError e) {
            out.close();
        }
    }

    static class NinyosPesaos {
        static int[] v = new int[500002];
        static TreeSet<Integer> future = new TreeSet<>(Collections.reverseOrder());

public void solve(int testNumber, InputReader in, PrintWriter out) {
    int n = 0;
    try {
        n = in.nextInt();
    } catch (Exception e) {
        throw new UnknownError();
    }
    for (int i = 0; i < n; ++i) {
        v[i] = in.nextInt();
        future.add(v[i]);
    }
    boolean ok = true;
    int min_seen = v[0];
    future.remove(v[0]);
    for (int i = 1; i < n - 1 && ok; ++i) {
        future.remove(v[i]);
        int lowest = min_seen;
        Integer tmp = future.ceiling(v[i]);
        int highest = tmp == null ? -1 : tmp;
        ok &= !(lowest < v[i] && highest < v[i] && lowest < highest);
        min_seen = Math.min(min_seen, v[i]);
    }
    future.remove(v[n - 1]);
    if (ok) {
        out.println("SIEMPRE PREMIO");
    } else {
        out.println("ELEGIR OTRA");
    }
}

    }

static class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 65536 / 2);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

}
}