Submission #74940832

---

Source Code Expand

#![allow(dead_code)]
#![allow(unused_imports)]
use std::collections::{BTreeMap, BinaryHeap, HashMap, HashSet, VecDeque};
use std::io::stdin;

#[derive(Default)]
struct Scanner {
    buffer: Vec<String>,
}
impl Scanner {
    fn next<T: std::str::FromStr>(&mut self) -> T {
        loop {
            if let Some(token) = self.buffer.pop() {
                return token.parse().ok().expect("Failed parse");
            }
            let mut input = String::new();
            stdin().read_line(&mut input).expect("Failed read");
            self.buffer = input.split_whitespace().rev().map(String::from).collect();
        }
    }
}

fn main() {
    let mut scanner = Scanner::default();
    let n = scanner.next::<usize>();
    let l = scanner.next::<u64>();

    // Read as (value, 1-based index) pairs
    let mut vals: Vec<(u64, usize)> = (0..n).map(|i| (scanner.next::<u64>(), i + 1)).collect();

    // Sort by value ascending, tie-break by index ascending
    vals.sort_by(|a, b| a.0.cmp(&b.0).then(a.1.cmp(&b.1)));

    // Binary search: find the last position where value <= l
    // partition_point gives first index where value > l
    let index = vals.partition_point(|&(v, _)| v <= l);

    if index == 0 {
        // No member with value <= l exists
        println!("-1");
        return;
    }

    // index-1 is the last element with value <= l
    // Among all elements with that maximum value, we want smallest index.
    // Because we sorted by (value asc, index asc), the first occurrence
    // of the maximum value has the smallest index — but partition_point
    // lands us at the END of the max-value group, so we scan back.
    let best_val = vals[index - 1].0;
    // Find the first element in the group with value == best_val
    let group_start = vals.partition_point(|&(v, _)| v < best_val);

    println!("{}", vals[group_start].1);
}

Submission Info

Judge Result