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 Haskell (judge verdict: Accepted)

import Data.Monoid
import Control.Monad.State

data Seg a = Nil | Seg Int a (Seg a) (Seg a) deriving (Show, Eq)

initSeg :: (Monoid m) => Int -> Seg m
initSeg 0 = Nil
initSeg n = Seg n mempty (initSeg (n-1)) (initSeg (n-1))

updateSeg :: (Monoid m) => Int -> m -> Seg m -> Seg m
updateSeg 0 a (Seg 1 _ _ _) = Seg 1 a Nil Nil
updateSeg _ _ s@(Seg 1 _ _ _) = s
updateSeg k a (Seg n b l@(Seg _ al _ _) r@(Seg _ ar _ _))
  | k < c = Seg n (mappend al' ar) l' r
  | otherwise = Seg n (mappend al ar') l r'
  where 
    c = 2^(n-2)
    l'@(Seg _ al' _ _) = updateSeg k a l
    r'@(Seg _ ar' _ _) = updateSeg (k-c) a r

querySeg :: (Monoid m) => Int -> Int -> Seg m -> m
querySeg 0 1 (Seg 1 a _ _) = a
querySeg _ _ (Seg 1 _ _ _) = mempty
querySeg i j s@(Seg n a l r)
  | i == 0 && j == 2*c = a
  | j < c = querySeg i j l
  | c <= i = querySeg (i-c) (j-c) r
  | otherwise = mappend (querySeg i c l) (querySeg 0 (j-c) r)
  where
    c = 2^(n-2)

newtype Min = Min Int deriving Show
instance Monoid Min where
  mempty = Min (2^31 - 1)
  mappend (Min a) (Min b) = Min (min a b)

fromMin (Min a) = a

getNums :: IO [Int]
getNums = liftM (map read . words) getLine

main = do
  n:q:_ <- getNums
  let depth = 1 + ((ceiling $ logBase 2 (fromIntegral n))) in
    evalStateT (replicateM_ q proc) $ initSeg depth

proc :: StateT (Seg Min) IO ()
proc = do
  com:x:y:_ <- lift $ getNums
  case com of
    0 -> modify $ updateSeg x (Min y)
    1 -> do
      s <- get
      lift $ print $ fromMin $ querySeg x (y+1) s