# define _SCL_SECURE_NO_WARNINGS

# include <iostream>
# include <string>
# include <iomanip>
# include <stdio.h>
# include <array>
# include <numeric>
# include <algorithm>
# include <vector>
# include <functional>
# include <fstream>
# include <random>
# include <bitset>




using Ull = unsigned long long;
using Ll  = long long;

template<typename T>
using Vec = std::vector<T>;

namespace
{


    template<typename T>
    std::istream& operator >> (std::istream& is, std::vector<T>& vec)
    {
        for (T& x : vec) is >> x;
        return is;
    }

    template<typename T>
    std::string to_string(std::vector<T> vec, std::string sep = " ")
    {
        using std::to_string;

        std::string result;
        for (T& x : vec) result += to_string(x) + sep;
        if (!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }
    template<>
    std::string to_string(std::vector<char> vec, std::string sep)
    {
        using std::to_string;

        std::string result;
        for (char c : vec) result += std::string{c} + sep;
        if(!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L>
    std::string to_string(T(&ary)[L], std::string sep = " ", size_t size = L)
    {
        using std::to_string;

        std::string result;
        for (int i = 0; i < size; ++i) result += to_string(ary[i]);
        if (!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }
    template<size_t L>
    std::string to_string(char(&ary)[L], std::string sep = " ", size_t size = L)
    {
        using std::to_string;

        std::string result;
        for (int i = 0; i < size; ++i) result += ary[i];
        if (!result.empty()) result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L, typename Function>
    void for_each(T(&ary)[L], Function lambda)
    {
        for (size_t i{}; i < L; ++i)
            lambda(static_cast<T&>(ary[i]));
    }

    template<typename T>
    void SetAll(T container, typename T::value_type value = typename T::value_type{})
    {
        for (typename T::reference content : container)
            content = value;
    }

    template<typename T, size_t L>
    void SetAll(T(&ary)[L], T value = T{})
    {
        for (size_t i{}; i < L; ++i)
            ary[i] = value;
    }

    template<typename T, size_t L>
    std::array<T, L> AsContainer(T(&ary)[L], bool isSwap = true)
    {
        std::array<T, L> result;

        if (isSwap)
        {
            for (size_t i{}; i < L; ++i)
                std::swap(result[i], ary[i]);
        }
        else
        {
            for (size_t i{}; i < L; ++i)
                result[i] = ary[i];
        }

        return result;
    }

    template<size_t length>
    constexpr std::array<size_t, length> range()
    {
        std::array<size_t, length> range{};

        for (size_t i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    template<typename T>
    const std::vector<T> range(const T length)
    {
        std::vector<T> range(length);

        for (T i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    template<typename T>
    const std::vector<T> range(const T start, const T end)
    {
        if (start >= end) return std::vector<T>{};

        std::vector<T> range(end - start);

        for (T i{start}; i < end; ++i)
            range[i - start] = i;

        return range;
    }

    bool IsPrime(const Ull n)
    {
        switch (n)
        {
        case 0: case 1:
            return false;
        case 2:
            return true;
        default:

            if (n % 2 == 0) return false;

            for (Ull i{3}; i * i <= n; i += 2)
            {
                if (n % i == 0) return false;
            }
        }

        return true;
    }

    // 最大公約数
    int EuclideanAlg(int n1, int n2)
    {
        if (n1 < 0 || n2 < 0) return 0;
        if (n2 > n1) std::swap(n1, n2);

        int r;
        while ((r = n1 % n2) != 0)
        {
            n1 = n2;
            n2 = r;
        }

        return n2;
    }

    // 最小公倍数
    Ull LCM(const std::vector<Ull>& values)
    {
        if (values.size() == 0)
            return 0;
        if (values.size() == 1)
            return values[0];
        if (values.size() == 2)
            return values[0] * values[1] / EuclideanAlg(values[0], values[1]);

        auto mid = values.cbegin() + values.size() / 2;

        return LCM(std::vector<Ull>{LCM(std::vector<Ull>(values.begin(), mid)), LCM(std::vector<Ull>(mid, values.end()))});
    }


    void Solve();
}

# if true
int main()
{
    Solve();
    return 0;
}
# endif

namespace
{
    int count(std::vector<char> str, std::vector<char> str2)
    {
        str.erase(std::unique(str.begin(), str.end()), str.end());
        str2.erase(std::unique(str2.begin(), str2.end()), str2.end());

        std::sort(str.begin(), str.end());
        std::sort(str2.begin(), str2.end());

        //std::cout << to_string(str) << std::endl;
        //std::cout << to_string(str2) << std::endl;

        std::vector<char> result;
        std::set_intersection(str.begin(), str.end(), str2.begin(), str2.end(), std::back_inserter(result));
        result.erase(std::unique(result.begin(), result.end()), result.end());

        //std::cout << to_string(result) << std::endl;
        
        return result.size();
    }

    void Solve()
    {


        int num;
        std::cin >> num;
        Vec<char> str(num);
        std::cin >> str;

        int max{};
        int index{};
        for (int i{0}; i < num; ++i)
        {
            max = std::max(max, count(std::vector<char>(str.begin(), str.begin() + i), std::vector<char>(str.begin() + i, str.end())));
        }

        std::cout << max;
    }
}

Measured memory_bytes: 256