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 Rust (1.15.1) (judge verdict: Time Limit Exceeded)

use std::collections::{HashMap, HashSet};
use std::io::{stdin, Read};

macro_rules! parse {
    ($it: ident) => {
        $it.next().unwrap().parse().unwrap()
    };
    ($it: ident,2) => {
        (parse!($it), parse!($it))
    };
    ($it: ident,3) => {
        (parse!($it), parse!($it), parse!($it))
    };
    ($it: ident,4) => {
        (parse!($it), parse!($it), parse!($it), parse!($it))
    };
    ($it: ident, $n: ident) => {
        (&mut $it).take($n).map(|e| e.parse().unwrap()).collect();
    };
}

fn main() {
    let mut s = String::new();
    stdin().read_to_string(&mut s).unwrap();
    let mut it = s.split_whitespace();
    let n: usize = parse!(it);
    let s = it.next().unwrap();
    let q: usize = parse!(it);
    let ns = (n as f64).sqrt() as usize;
    let ng = n / ns + 1;
    let mut groups: Vec<std::collections::HashMap<char, usize>> = vec![HashMap::new(); ng];
    for (i, c) in s.chars().enumerate() {
        let ig = i / ns;
        let ref mut h = groups[ig];
        let mut count = 1;
        if let Some(x) = h.get(&c) {
            count = x + 1;
        }
        h.insert(c, count);
    }
    let mut s: Vec<char> = s.chars().collect();
    for _ in 0..q {
        let t: usize = parse!(it);
        if t == 1 {
            let i: usize = parse!(it);
            let i = i - 1;
            let cq = it.next().unwrap().chars().next().unwrap();
            let prev = s[i];
            s[i] = cq;
            let ig = i / ns;
            let ref mut h = groups[ig];
            let nx = if let Some(x) = h.get(&prev) { x - 1 } else { 0 };
            if nx == 0 {
                h.remove(&prev);
            } else {
                h.insert(prev, nx);
            }
            let ny = if let Some(x) = h.get(&cq) { x + 1 } else { 1 };
            h.insert(cq, ny);
        } else {
            let (l, r): (usize, usize) = parse!(it, 2);
            let l = l - 1;
            let r = r - 1;
            let mut h: HashSet<char> = HashSet::new();
            let ll = l / ns;
            let rr = r / ns;
            if (rr - ll) <= 1 {
                h.extend((&s[l..(r + 1)]).iter());
                println!("{}", h.len());
            } else {
                h.extend(s[l..((ll + 1) * ns)].iter());
                h.extend(s[(rr * ns)..(r + 1)].iter());
                for i in (ll + 1)..rr {
                    h.extend(groups[i].keys());
                }
                println!("{}", h.len());
            }
        }
    }
}