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::*;
use std::str::FromStr;
use std::cmp;
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

struct Segtree{
    n:i64,
    t:i64,
    node:Vec<i64>,
}
impl Segtree{
    fn init(&mut self){
        for i in 0..2*self.n+1{
            self.node.push(self.t);
        }
    }
    fn update(&mut self,k:i64,x:i64){
        let mut k=k+self.n;
        let mut i=k as usize;
        self.node[i]=x;
        k>>=1;
        while k>0{
            i=k as usize;
            self.node[i]=cmp::min(self.node[i<<1],self.node[i<<1|1]);
            k>>=1;
        }
    }
    fn query(&mut self,l:i64,r:i64)->i64{
        let mut vl:i64=self.t;
        let mut vr:i64=self.t;
        let mut l=l+self.n;
        let mut r=r+self.n;
        while l<r{
            if (l&1)>0{
                let i:usize=l as usize;
                vl=cmp::min(vl,self.node[i]);
                l=l+1;
            }
            if (r&1)>0{
                r=r-1;
                let i:usize=r as usize;
                vr=cmp::min(vr,self.node[i]);
            }
            l>>=1;
            r>>=1;
        }
        cmp::min(vl,vr)
    }
}
fn main() {
    let n:i64=read();
    let q:i32=read();
    let mut tree=Segtree{
        n:n,
        t:2147483647,
        node:Vec::new(),
    };
    tree.init();
    for i in 0..q{
        let com:i32=read();
        let mut x:i64=read();
        let mut y:i64=read();
        if com==0{
            tree.update(x,y);
        }else{
            println!("{}",tree.query(x,y+1));
        }
    }
}