Problem:
Range Minimum Query (RMQ)

Write a program which manipulates a sequence A = {a0, a1, . . . , an-1} with the following operations:

find(s, t): report the minimum element in as, as+1, . . . ,at.

update(i, x): change ai to x.

Note that the initial values of ai (i = 0, 1, . . . , n−1) are 231-1.

Input

n q
com0 x0 y0
com1 x1 y1
...
comq−1 xq−1 yq−1

In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, q queries are given where com represents the type of queries. '0' denotes update(xi, yi) and '1' denotes find(xi, yi).

Output

For each find operation, print the minimum element.

Constraints

1 ≤ n ≤ 100000

1 ≤ q ≤ 100000

If comi is 0, then 0 ≤ xi < n, 0 ≤ yi < 231-1.

If comi is 1, then 0 ≤ xi < n, 0 ≤ yi < n.

Sample Input 1

3 5
0 0 1
0 1 2
0 2 3
1 0 2
1 1 2

Sample Output 1

1
2

Sample Input 2

1 3
1 0 0
0 0 5
1 0 0

Sample Output 2

2147483647
5

Solution in Rust (judge verdict: Accepted)

use std::io::Read;
fn main() {
    let buf = {
        let mut s = String::new();
        std::io::stdin().read_to_string(&mut s).unwrap();
        s
    };
    let out = solve(buf);
    print!("{}", out);
}
fn solve(buf: String) -> String {
    let mut sc = io::Scanner::new(&buf);
    let n: usize = sc.read();
    let q: usize = sc.read();
    let queries: Vec<(usize, usize, usize)> =
        (0..q).map(|_| (sc.read(), sc.read(), sc.read())).collect();

    let mut seg = SegmentTree::<Min>::new(n);
    let mut res = String::new();

    for query in queries {
        if query.0 == 0 {
            seg.update(query.1, query.2);
        } else {
            res.push_str(&seg.query(query.1, query.2 + 1).to_string());
            res.push_str("\n");
        }
    }
    res
}
pub mod io {
    use std::str::{FromStr, SplitWhitespace};
    pub struct Scanner<'a> {
        iter: SplitWhitespace<'a>,
    }
    impl<'a> Scanner<'a> {
        pub fn new(s: &'a str) -> Scanner<'a> {
            Scanner {
                iter: s.split_whitespace(),
            }
        }
        pub fn read<T: FromStr>(&mut self) -> T {
            self.iter
                .next()
                .unwrap()
                .parse()
                .ok()
                .expect("parsing failed")
        }
        pub fn read_vec<T: FromStr>(&mut self, n: usize) -> Vec<T> {
            (0..n).map(|_| self.read()).collect()
        }
    }
}

type Min = usize;

impl Monoid for Min {
    fn mempty() -> Min {
        2147483647 //  == 2^31 - 1
    }

    fn mappend(a: Min, b: Min) -> Min {
        std::cmp::min(a, b)
    }
}

pub trait Monoid: Copy {
    fn mempty() -> Self;
    fn mappend(a: Self, b: Self) -> Self;
}
pub struct SegmentTree<M> {
    n: usize,
    data: Vec<M>,
}
impl<M: Monoid> SegmentTree<M> {
    pub fn new(n: usize) -> SegmentTree<M> {
        let mut m = 1;
        while m < n {
            m *= 2;
        }

        SegmentTree {
            n: m,
            data: vec![M::mempty(); 2 * m],
        }
    }
    pub fn update(&mut self, k: usize, a: M) {
        let mut k = k + self.n - 1;
        self.data[k] = a;
        while k > 0 {
            k = (k - 1) / 2;
            self.data[k] = M::mappend(self.data[k * 2 + 1], self.data[k * 2 + 2]);
        }
    }
    pub fn query(&self, l: usize, r: usize) -> M {
        self.query_range(l, r, 0, 0, self.n)
    }
    pub fn query_range(&self, a: usize, b: usize, k: usize, l: usize, r: usize) -> M {
        if r <= a || b <= l {
            M::mempty()
        } else if a <= l && r <= b {
            self.data[k]
        } else {
            let vl = self.query_range(a, b, k * 2 + 1, l, (l + r) / 2);
            let vr = self.query_range(a, b, k * 2 + 2, (l + r) / 2, r);
            M::mappend(vl, vr)
        }
    }
}