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 C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using Yorukatsu021.Questions;
using Yorukatsu021.Extensions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

namespace Yorukatsu021.Questions
{
    /// <summary>
    /// ABC157 E
    /// </summary>
    public class QuestionE : AtCoderQuestionBase
    {
        public override IEnumerable<object> Solve(TextReader inputStream)
        {
            var n = inputStream.ReadInt();
            var s = inputStream.ReadLine();
            var q = inputStream.ReadInt();

            var segmentationTree = new SegmentationTree(s);

            for (int i = 0; i < q; i++)
            {
                var query = inputStream.ReadLine().Split(' ');

                switch (query[0])
                {
                    case "1":
                        segmentationTree.Update(int.Parse(query[1]) - 1, query[2][0]);
                        break;
                    case "2":
                        yield return segmentationTree.GetVariety(int.Parse(query[1]) - 1, int.Parse(query[2]) - 1);
                        break;
                    default:
                        break;
                }
            }
        }
    }

    public class SegmentationTree
    {
        private readonly int _bufferLength;
        private readonly int _leafCount;
        private readonly int[,] _charCount;
        private readonly char[] _rawString;
        const int alphabetCount = 'z' - 'a' + 1;

        public SegmentationTree(string s)
        {
            _leafCount = GetMinimumPow2(s.Length);
            _bufferLength = 2 * _leafCount - 1;
            _charCount = new int[_bufferLength, alphabetCount];

            for (int i = 0; i < s.Length; i++)
            {
                Update(i, s[i]);
            }

            _rawString = s.ToCharArray();

        }

        public void Update(int index, char newChar)
        {
            var oldChar = _rawString?[index];
            if (oldChar != null)
            {
                _rawString[index] = newChar;
            }
            index += _leafCount - 1;
            var tempIndex = index;

            _charCount[index, newChar - 'a']++;
            while (index > 0)
            {
                index = (index - 1) / 2;
                _charCount[index, newChar - 'a']++;
            }

            index = tempIndex;
            if (oldChar != null)
            {
                _charCount[index, oldChar.Value - 'a']++;
                while (index > 0)
                {
                    index = (index - 1) / 2;
                    _charCount[index, oldChar.Value - 'a']++;
                }
            }
        }

        public int GetVariety(int begin, int end) => GetVariety(begin, end + 1, 0, 0, _leafCount).Count();

        private IEnumerable<char> GetVariety(int begin, int end, int currentIndex, int currentLeft, int currentRight)
        {
            if (currentRight <= begin || end <= currentLeft)    // 全く被らない
            {
                return Enumerable.Empty<char>();
            }
            else if (begin <= currentLeft && currentRight <= end)   // 全部被る
            {
                return GetCharsAt(currentIndex).ToArray();
            }
            else    // 一部被る
            {
                var leftChars = GetVariety(begin, end, currentIndex * 2 + 1, currentLeft, (currentLeft + currentRight) / 2).ToArray();
                var rightChars = GetVariety(begin, end, currentIndex * 2 + 2, (currentLeft + currentRight) / 2, currentRight).ToArray();
                return leftChars.Union(rightChars);
            }
        }

        private IEnumerable<char> GetCharsAt(int index)
        {
            for (int i = 0; i < alphabetCount; i++)
            {
                if (_charCount[index, i] > 0)
                {
                    yield return (char)(i + 'a');
                }
            }
        }

        private int GetMinimumPow2(int n)
        {
            var p = 1;
            while (p < n)
            {
                p *= 2;
            }
            return p;
        }
    }
}


namespace Yorukatsu021
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionE();    // 問題に合わせて書き換え
            var answers = question.Solve(Console.In);
            foreach (var answer in answers)
            {
                Console.WriteLine(answer);
            }
        }
    }
}

#region Base Classes

namespace Yorukatsu021.Questions
{

    public interface IAtCoderQuestion
    {
        IEnumerable<object> Solve(string input);
        IEnumerable<object> Solve(TextReader inputStream);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public IEnumerable<object> Solve(string input)
        {
            var stream = new MemoryStream(Encoding.Unicode.GetBytes(input));
            var reader = new StreamReader(stream, Encoding.Unicode);

            return Solve(reader);
        }

        public abstract IEnumerable<object> Solve(TextReader inputStream);
    }

}

#endregion

#region Extensions

namespace Yorukatsu021.Extensions
{
    internal static class TextReaderExtensions
    {
        internal static int ReadInt(this TextReader reader) => int.Parse(ReadString(reader));
        internal static long ReadLong(this TextReader reader) => long.Parse(ReadString(reader));
        internal static double ReadDouble(this TextReader reader) => double.Parse(ReadString(reader));
        internal static string ReadString(this TextReader reader) => reader.ReadLine();

        internal static int[] ReadIntArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(int.Parse).ToArray();
        internal static long[] ReadLongArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(long.Parse).ToArray();
        internal static double[] ReadDoubleArray(this TextReader reader, char separator = ' ') => ReadStringArray(reader, separator).Select(double.Parse).ToArray();
        internal static string[] ReadStringArray(this TextReader reader, char separator = ' ') => reader.ReadLine().Split(separator);
    }
}

#endregion