Language: C++

#include <vector>
#include <set>
#include <iostream>

struct segment_tree {
    void build(std::string const &a) {
        t.resize(4 * a.size());
        build(0, 0, a.size(), a);
    }

    void update(size_t pos, char new_value) {
        update(0, 0, t.size() / 4, pos, new_value);
    }

    int32_t get(size_t l, size_t r) {
        return get(0, 0, t.size() / 4, l, r + 1).size();
    }

private:
    std::vector<std::set<char>> t;
    void build(size_t v, size_t l, size_t r, std::string const &a) {
        if (l + 1 == r) {
            std::set<char> m;
            m.insert(a[l]);
            t[v] = m;
        } else {
            size_t mid = (l + r) / 2;
            build(2 * v + 1, l, mid, a);
            build(2 * v + 2, mid, r, a);
            for (auto elem : t[2 * v + 1]) {
                t[v].insert(elem);
            }
            for (auto elem : t[2 * v + 2]) {
                t[v].insert(elem);
            }
        }
    }

    void update(size_t v, size_t l, size_t r, size_t pos, char new_value) {
        if (l + 1 == r) {
            std::set<char> m;
            m.insert(new_value);
            t[v] = m;
        } else {
            size_t mid = (l + r) / 2;
            if (pos < mid) {
                update(2 * v + 1, l, mid, pos, new_value);
            } else {
                update(2 * v + 2, mid, r, pos, new_value);
            }
            for (auto elem : t[2 * v + 1]) {
                t[v].insert(elem);
            }
            for (auto elem : t[2 * v + 2]) {
                t[v].insert(elem);
            }
        }
    }

    std::set<char> get(size_t v, size_t l, size_t r, size_t req_l, size_t req_r) {
        if (req_l >= req_r) {
            return std::set<char> ();
        } else if (l == req_l && r == req_r) {
            return t[v];
        } else {
            size_t mid = (l + r) / 2;
            std::set<char> cur = get(2 * v + 1, l, mid, req_l, std::min(mid, req_r));
            for (auto elem : get(2 * v + 2, mid, r, std::max(mid, req_l), req_r)) {
                cur.insert(elem);
            }
            return cur;
        }
    }
};

int main() {
    std::ios_base::sync_with_stdio(false);
    segment_tree chr;
    size_t n;
    char current_n;
    std::cin >> n >> current_n;
    std::string a;
    std::cin >> a;
    chr.build(a);
    size_t k;
    std::cin >> k;
    while (k-- > 0) {
        size_t type;
        std::cin >> type;
        if (type == 1) {
            size_t pos;
            char ch;
            std::cin >> pos >> ch;
            chr.update(pos - 1, ch);
        } else {
            size_t l, r;
            std::cin >> l >> r;
            std::cout << chr.get(l - 1, r - 1) << '\n';
        }
    }

    return 0;
}
#include <vector>
#include <set>
#include <iostream>

struct segment_tree {
    void build(std::string const &a) {
        t.resize(4 * a.size());
        build(0, 0, a.size(), a);
    }

    void update(size_t pos, char new_value) {
        update(0, 0, t.size() / 4, pos, new_value);
    }

    int32_t get(size_t l, size_t r) {
        return get(0, 0, t.size() / 4, l, r + 1).size();
    }

private:
    std::vector<std::set<char>> t;
    void build(size_t v, size_t l, size_t r, std::string const &a) {
        if (l + 1 == r) {
            std::set<char> m;
            m.insert(a[l]);
            t[v] = m;
        } else {
            size_t mid = (l + r) / 2;
            build(2 * v + 1, l, mid, a);
            build(2 * v + 2, mid, r, a);
            for (auto elem : t[2 * v + 1]) {
                t[v].insert(elem);
            }
            for (auto elem : t[2 * v + 2]) {
                t[v].insert(elem);
            }
        }
    }

    void update(size_t v, size_t l, size_t r, size_t pos, char new_value) {
        if (l + 1 == r) {
            std::set<char> m;
            m.insert(new_value);
            t[v] = m;
        } else {
            size_t mid = (l + r) / 2;
            if (pos < mid) {
                update(2 * v + 1, l, mid, pos, new_value);
            } else {
                update(2 * v + 2, mid, r, pos, new_value);
            }
            for (auto elem : t[2 * v + 1]) {
                t[v].insert(elem);
            }
            for (auto elem : t[2 * v + 2]) {
                t[v].insert(elem);
            }
        }
    }

    std::set<char> get(size_t v, size_t l, size_t r, size_t req_l, size_t req_r) {
        if (req_l >= req_r) {
            return std::set<char> ();
        } else if (l == req_l && r == req_r) {
            return t[v];
        } else {
            size_t mid = (l + r) / 2;
            std::set<char> cur = get(2 * v + 1, l, mid, req_l, std::min(mid, req_r));
            for (auto elem : get(2 * v + 2, mid, r, std::max(mid, req_l), req_r)) {
                cur.insert(elem);
            }
            return cur;
        }
    }
};

int main() {
    std::ios_base::sync_with_stdio(false);
    segment_tree chr;
    size_t n;
    char current_n;
    std::cin >> n >> current_n;
    std::string a;
    std::cin >> a;
    chr.build(a);
    size_t k;
    std::cin >> k;
    while (k-- > 0) {
        size_t type;
        std::cin >> type;
        if (type == 1) {
            size_t pos;
            char ch;
            std::cin >> pos >> ch;
            chr.update(pos - 1, ch);
        } else {
            size_t l, r;
            std::cin >> l >> r;
            std::cout << chr.get(l - 1, r - 1) << '\n';
        }
    }

    return 0;
}


Compiler output:
a.cc:108:8: error: redefinition of 'struct segment_tree'
  108 | struct segment_tree {
      |        ^~~~~~~~~~~~
a.cc:5:8: note: previous definition of 'struct segment_tree'
    5 | struct segment_tree {
      |        ^~~~~~~~~~~~
a.cc:179:5: error: redefinition of 'int main()'
  179 | int main() {
      |     ^~~~
a.cc:76:5: note: 'int main()' previously defined here
   76 | int main() {
      |     ^~~~