Submission #1026294

---

Source Code Expand

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;
use std::io::*;
#[allow(dead_code)]
fn getline() -> String {
    let mut ret = String::new();
    std::io::stdin().read_line(&mut ret).ok();
    return ret;
}
fn get_word() -> String {
    let mut stdin = std::io::stdin();
    let mut u8b: [u8; 1] = [0];
    loop {
        let mut buf: Vec<u8> = Vec::with_capacity(16);
        loop {
            let res = stdin.read(&mut u8b);
            if res.is_err() || res.ok().unwrap() == 0 || u8b[0] <= ' ' as u8 {
                break;
            } else {
                buf.push(u8b[0]);
            }
        }
        if buf.len() >= 1 {
            let ret = std::string::String::from_utf8(buf).unwrap();
            return ret;
        }
    }
}
fn parse<T: std::str::FromStr>(s: &str) -> T { s.parse::<T>().ok().unwrap() }

#[allow(dead_code)]
fn get<T: std::str::FromStr>() -> T { parse(&get_word()) }

/**
 * Sparse Table.
 * BiOp should be the type of a binary operator which is
 * associative, commutative and idempotent.
 * (For example, both min and gcd satisfy these properties.)
 */
struct SparseTable<T, BiOp> {
    biop: BiOp,
    st: Vec<Vec<T>>,
}

impl<T, BiOp> SparseTable<T, BiOp>
    where BiOp: Fn(T, T) -> T,
          T: Copy {
    pub fn new(ary: &[T], biop: BiOp) -> Self {
        let n = ary.len();
        let mut h = 1;
        while 1 << h < n {
            h += 1;
        }
        let mut st: Vec<Vec<T>> = vec![Vec::from(ary); h + 1];
        for i in 0 .. n {
            st[0][i] = ary[i];
        }
        for b in 1 .. (h + 1) {
            if n + 1 < 1 << b {
                break;
            }
            for i in 0 .. (n + 1 - (1 << b)) {
                let next_idx = (1 << (b - 1)) + i;
                st[b][i] = biop(st[b - 1][i], st[b - 1][next_idx]);
            }
        }
        SparseTable {biop: biop, st: st}
    }
    fn top_bit(t: usize) -> usize {
        let mut h = 0;
        while 1 << h <= t {
            h += 1;
        }
        h - 1
    }
    pub fn query(&self, f: usize, s: usize) -> T {
        assert!(f <= s);
        let b = Self::top_bit(s + 1 - f);
        let endpoint = s + 1 - (1 << b);
        (self.biop)(self.st[b][f], self.st[b][endpoint])
    }
}

fn sol_spt(n: usize, a: &[i64], s: &[char]) -> Option<i64> {
    let mut idx = 0;
    for i in 0 .. (n - 1) {
        if s[i] == 'm' {
            idx = i;
            break;
        }
    }
    for i in 0 .. idx {
        if s[i] != 'M' {
            return None;
        }
    }
    for i in idx .. (n - 1) {
        if s[i] != 'm' {
            return None;
        }
    }
    let spt: SparseTable<i64, _> = SparseTable::new(&a, |x, y| max(x, y));
    let mut b: Vec<i64> = vec![0; n - idx];
    for i in 0 .. (n - idx) {
        b[i] = spt.query(i, i + idx);
    }
    let spt2: SparseTable<i64, _> = SparseTable::new(&b, |x, y| min(x, y));
    return Some(spt2.query(0, n - idx - 1));
}

fn main() {
    let n: usize = get();
    let a: Vec<i64> = (0 .. n).map(|_| get()).collect();
    let s: String = get_word();
    let sc: Vec<char> = s.chars().collect();
    let res1 = sol_spt(n, &a, &sc);
    println!("{}", res1.unwrap());
}

Submission Info

Judge Result