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

import java.util.Arrays;
import java.util.Scanner;

public class Main{

	public static void main(String[] args) {
		Main main=new Main();
		main.run();
	}

	void run() {

		Scanner sc=new Scanner(System.in);

		int N=sc.nextInt();
		int Q=sc.nextInt();

		int[] A=new int[N];
		Arrays.fill(A,Integer.MAX_VALUE);

		SegmentTree seg=new SegmentTree(A);

		int min=0;
		for (int i = 0; i < Q; i++) {

			int query=sc.nextInt();
			int X=sc.nextInt();
			int Y=sc.nextInt();

			if(query==0) {
				seg.updata(X, Y);
			}else {
				min=seg.getmin(X,Y+1,0,0,-1);
				System.out.println(min);
			}

		}
	}
}




class SegmentTree {
	private int N;
	private int[] node;
	private static int INF=Integer.MAX_VALUE;

	SegmentTree(int[] v){

		int size=v.length;

		N=1;

		//NはNを超えるなかで最小の2のべき乗。
		while(N<size) {
			N*=2;
		}

		node=new int[2*N-1];

		Arrays.fill(node,INF);

		for (int i = 0; i < size; i++) {
			node[i+N-1]=v[i];
		}

		for (int i = N-2; i >= 0; i--) {
			node[i]=Math.min(node[2*i+1],node[2*i+2]);
		}

	}

	void updata(int index,int val) {
		//元の配列の要素番号から、セグ木の葉に変換する。
		index+=(N-1);

		//まず葉を更新。
		node[index]=val;

		//そこから順番に親をたどりながら更新していく
		while(index>0) {
			index=(index-1)/2;
			node[index]=Math.min(node[2*index+1],node[2*index+2]);
		}
	}

	int getmin(int a,int b,int k,int l,int r) {

		if(r<0) {r=N;};

		if(r<=a || b<=l) {
			return INF;
		}

		if(a<=l && r<=b) {
			return node[k];
		}

		int vl=getmin(a,b,2*k+1,l,(l+r)/2);
		int vr=getmin(a,b,2*k+2,(l+r)/2,r);

		return Math.min(vl,vr);
	}
}