Problem:
Score : 200 points

Problem Statement

You are given a string S of length N consisting of lowercase English letters.
We will cut this string at one position into two strings X and Y.
Here, we would like to maximize the number of different letters contained in both X and Y.
Find the largest possible number of different letters contained in both X and Y when we cut the string at the optimal position.

Constraints

2 \leq N \leq 100

|S| = N

S consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

N
S

Output

Print the largest possible number of different letters contained in both X and Y.

Sample Input 1

6
aabbca

Sample Output 1

2

If we cut the string between the third and fourth letters into X = aab and Y = bca, the letters contained in both X and Y are a and b.
There will never be three or more different letters contained in both X and Y, so the answer is 2.

Sample Input 2

10
aaaaaaaaaa

Sample Output 2

1

However we divide S, only a will be contained in both X and Y.

Sample Input 3

45
tgxgdqkyjzhyputjjtllptdfxocrylqfqjynmfbfucbir

Sample Output 3

9

Solution in Rust (1.42.0) (judge verdict: Accepted)

#[allow(unused_imports)] use proconio::{input, marker::{Bytes, Chars, Usize1, Isize1}};
#[allow(unused_imports)] use std::cmp::{min, max};
#[allow(unused_imports)] use superslice::Ext as _;

#[proconio::fastout]
fn main() {
	input! {
		n: usize,
		mut cs: Chars,
	}

	let mut ans = 0;
	for i in 1..n {
		let mut x = cs.clone();
		let mut y = x.split_off(i);
		x.sort();
		x.dedup();
		y.sort();
		y.dedup();
//		println!("{:?}", x);
//		println!("{:?}", y);
		let mut count = 0;
		for j in 0..x.len() {
			for k in 0..y.len() {
				if x[j] == y[k] {
					count += 1;
					break;
				}
			} 
		}
//		println!("{}", count);
//		println!("");
		ans = max(ans, count);
	}

	println!("{}", ans);
}