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

class SegmentTreeBase
  def initialize(arr, l = 0, r = arr.size - 1)
    @l, @r = l, r
    if @l == @r
      @agg = arr[l]
    else
      c = (l + r) / 2
      @left_child = self.class.new(arr, l, c)
      @right_child = self.class.new(arr, c + 1, r)
      @agg = aggregation_of(@left_child.agg, @right_child.agg)
    end
  end

  attr_reader :agg, :l, :r

  def update(i, x)
    if @l == @r
      update_single(x)
    else
      (i <= @left_child.r ? @left_child : @right_child).update(i, x)
      @agg = aggregation_of(@left_child.agg, @right_child.agg)
    end
  end

  def query(l, r)
    return @agg if l == @l && r == @r
    return @left_child.query(l, r) if r <= @left_child.r
    return @right_child.query(l, r) if @right_child.l <= l
    agg_left = @left_child.query(l, @left_child.r)
    agg_right = @right_child.query(@right_child.l, r)
    return aggregation_of(agg_left, agg_right)
  end
end

class SegmentTree < SegmentTreeBase
  def aggregation_of(x, y)
    [x, y].min
  end

  def update_single(x)
    @agg = x
  end
end

n, q = gets.split.map(&:to_i)
seg = SegmentTree.new(Array.new(n, 2 ** 31 - 1))
q.times do
  c, x, y = gets.split.map(&:to_i)
  if c == 0
    seg.update(x, y)
  else
    puts seg.query(x, y)
  end
end