Problem:
Score: 400 points

Problem Statement

AtCoder Inc. has decided to lock the door of its office with a 3-digit PIN code.

The company has an N-digit lucky number, S. Takahashi, the president, will erase N-3 digits from S and concatenate the remaining 3 digits without changing the order to set the PIN code.

How many different PIN codes can he set this way?

Both the lucky number and the PIN code may begin with a 0.

Constraints

4 \leq N \leq 30000

S is a string of length N consisting of digits.

Input

Input is given from Standard Input in the following format:

N
S

Output

Print the number of different PIN codes Takahashi can set.

Sample Input 1

4
0224

Sample Output 1

3

Takahashi has the following options:

Erase the first digit of S and set 224.

Erase the second digit of S and set 024.

Erase the third digit of S and set 024.

Erase the fourth digit of S and set 022.

Thus, he can set three different PIN codes: 022, 024, and 224.

Sample Input 2

6
123123

Sample Output 2

17

Sample Input 3

19
3141592653589793238

Sample Output 3

329

Solution in Haskell (GHC 7.10.3) (judge verdict: Accepted)

{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeFamilies #-}
import           Data.Maybe
import           Data.Int
import           Data.List
import           Data.Char
  -- import qualified Data.Vector.Unboxing as VU
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.ByteString.Char8 as BS
import           Data.List (scanl')
import           Data.IORef
import           Control.Monad
import           Control.Monad.ST
import           Control.Monad.State.Strict
import           Control.Applicative

readInt = BS.readInt . BS.dropWhile isSpace
getVector f = VU.unfoldr f <$> BS.getLine
getIntVector = getVector readInt
getBSVector = getVector BS.uncons

solve' n s = do
  digit1 <- VUM.replicate 1001 False
  forM_ [0..n-3] $ \i -> do
    forM_ [i+1..n-2] $ \j -> do
      forM_ [j+1..n-1] $ \k -> do
        let n1 = s VU.! i
            n2 = s VU.! j
            n3 = s VU.! k
            index = n1*100 + n2*10 + n3
        b <- VUM.read digit1 index
        unless b $ do
          VUM.write digit1 index True
  print . VU.length . VU.filter (\n -> n) =<< VU.freeze digit1

solve :: String -> IO ()
solve s = do
  digit <- VUM.replicate 1000 False

  forM_ [0..999] $ \i -> do
    let v = intToString i
    when ( test s v ) $ do
      VUM.write digit i True

  print . VU.length . VU.filter (\n -> n) =<< VU.freeze digit

intToString v
  | 0 <= v && v <= 9 = '0':'0':show v
  | 10 <= v && v <= 99 = '0':show v
  | 100 <= v && v <= 999 = show v


test s v = loop s v
  where
    loop _ [] = True
    loop [] _ = False
    loop (x:xs) (vj:vs) = if x == vj
                          then loop xs vs
                          else loop xs (vj:vs)


main = do
  _ <- readLn :: IO Int
  s <- getLine
  solve s