Problem:
Score : 500 points

Problem Statement

You are given a string S of length N consisting of lowercase English letters.

Process Q queries of the following two types:

Type 1: change the i_q-th character of S to c_q. (Do nothing if the i_q-th character is already c_q.)

Type 2: answer the number of different characters occurring in the substring of S between the l_q-th and r_q-th characters (inclusive).

Constraints

N, Q, i_q, l_q, and r_q are integers.

S is a string consisting of lowercase English letters.

c_q is a lowercase English letter.

1 \leq N \leq 500000

1 \leq Q \leq 20000

|S| = N

1 \leq i_q \leq N

1 \leq l_q \leq r_q \leq N

There is at least one query of type 2 in each testcase.

Input

Input is given from Standard Input in the following format:

N
S
Q
Query_1
\vdots
Query_Q

Here, Query_i in the 4-th through (Q+3)-th lines is one of the following:

1 i_q c_q

2 l_q r_q

Output

For each query of type 2, print a line containing the answer.

Sample Input 1

7
abcdbbd
6
2 3 6
1 5 z
2 1 1
1 4 a
1 7 d
2 1 7

Sample Output 1

3
1
5

In the first query, cdbb contains three kinds of letters: b , c , and d, so we print 3.

In the second query, S is modified to abcdzbd.

In the third query, a contains one kind of letter: a, so we print 1.

In the fourth query, S is modified to abcazbd.

In the fifth query, S does not change and is still abcazbd.

In the sixth query, abcazbd contains five kinds of letters: a, b, c, d, and z, so we print 5.

Solution in Scala (2.11.7) (judge verdict: Accepted)

object Main extends App {
  val sc = new java.util.Scanner(System.in)
  val n = sc.nextInt()
  val s = sc.next()
  val q = sc.nextInt()
  val seg = new SegmentTree()
  seg.init(n)
  for (i <- 0 until n) {
    seg.update(i, 1 << (s(i) - 'a'))
  }
  for (i <- 0 until q) {
    val t = sc.nextInt()
    if (t == 1) {
      val i = sc.nextInt() - 1
      val c = sc.next()(0)
      seg.update(i, 1 << (c - 'a'))
    } else {
      val l, r = sc.nextInt() - 1
      println(bitCount(seg.query(l, r + 1, 0, 0, seg.n)))
    }
  }
  def bitCount(n: Int): Int = {
    var i = n
    i = i - ((i >>> 1) & 0x55555555)
    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333)
    i = (i + (i >>> 4)) & 0x0f0f0f0f
    i = i + (i >>> 8)
    i = i + (i >>> 16)
    i & 0x3f
  }
  class SegmentTree {
    var n = 1
    val id = 0
    var node = Array[Int]()
    def init(sz: Int) {
      n = 1
      while (n < sz) n *= 2
      node = Array.fill(2 * n - 1)(id)
    }
    def update(i: Int, k: Int) = {
      var x = i + n - 1
      node(x) = k
      while (x > 0) {
        x = (x - 1) / 2
        node(x) = node(2 * x + 1) | node(2 * x + 2)
      }
    }
    def query(a: Int, b: Int, k: Int, l: Int, r: Int): Int = {
      if (r <= a || b <= l) {
        id
      } else if (a <= l && r <= b) {
        node(k)
      } else {
        val lv = query(a, b, 2 * k + 1, l, (l + r) / 2)
        val rv = query(a, b, 2 * k + 2, (l + r) / 2, r)
        (lv | rv)
      }
    }
  }
}