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

use std::io;
use std::cmp;
use std::collections::BinaryHeap;
use std::collections::HashMap;
use std::collections::HashSet;
use std::f64::consts::PI;

fn read_line() -> String {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).ok();
    buf
}

struct BIT<T> {
    n: usize,
    bits: Vec<T>,
}

impl BIT<i64> {
    fn new(n: usize) -> Self {
        let mut m = 1;
        while m < n {
            m *= 2;
        }
        BIT {
            n: m,
            bits: vec![0; m + 1],
        }
    }

    fn add(&mut self, a: usize, w: i64) {
        let mut x = a as i32;
        while x <= self.n as i32 {
            self.bits[(x as usize)] += w;
            x += x&-x;
        }
    }

    fn sum(&self, a: usize) -> i64 {
        let mut ret = 0;
        let mut x = a as i32;
        while x > 0 {
            ret += self.bits[x as usize];
            x -= x&-x;
        }
        ret
    }
}


fn main() {
    let line: Vec<usize> = read_line().split_whitespace().map(|s| s.parse().unwrap()).collect();
    let n = line[0];
    let mut s: Vec<char> = read_line().trim().chars().collect();
    let line: Vec<usize> = read_line().split_whitespace().map(|s| s.parse().unwrap()).collect();
    let q = line[0];
    let mut memo = HashMap::new();
    for i in 0..26 {
        memo.insert(('a' as u8 + i) as char, BIT::new(n+1));
    }
    for i in 0..n {
        let c = s[i];
        let mut tar = memo.get_mut(&c).map(|tar| tar.add(i+1, 1));
    }

    for i in 0..q {
        let line: Vec<String> = read_line().split_whitespace().map(|s| s.clone().to_owned()).collect();
        let p: usize = line[0].parse().unwrap();
        if p==1 {
            let i: usize = line[1].parse().unwrap();
            let i = i-1;
            let c = line[2].chars().nth(0).unwrap();
            let d = s[i];
            s[i] = c;
            let mut tar = memo.get_mut(&d).map(|tar| tar.add(i+1, -1));
            let mut tar = memo.get_mut(&c).map(|tar| tar.add(i+1, 1));
        } else {
            let l: usize = line[1].parse().unwrap();
            let r: usize = line[2].parse().unwrap();
            let c = s[l-1];
            let d = s[r-1];

            let mut ans = 0;
            for (_, tar) in memo.iter() {
                if tar.sum(r) - tar.sum(l-1) > 0 {
                    ans += 1;
                }
            }
            println!("{}", ans);
        }
    }

}