#include <bits/stdc++.h>
using namespace std;

#define FOR(n, a, b) for(int n = (a); n < (b); ++n)
#define ALL(x) x.begin(), x.end()
#define pb push_back
#define st first
#define nd second

const int maxN = 1 << 19, maxTS = 1 << 20, Alph = 26, INF = 1 << 20;

int chartoint(char a)
{   return a - 'a'; }

struct Aho
{
    int n, T[maxN][Alph], F[maxN], N[maxN], o[maxN];
    queue <int> Q;

    void add(char* t, int m, int ind)
    {
        int v = 1;
        FOR(i, 0, m)
        {
            int& u = T[v][chartoint(t[i])];
            if (u == 0) u = ++n;
            v = u;
        }
        o[v] = ind + 1;
    }

    void calF()
    {
        F[1] = 1;
        FOR(c, 0, Alph)
        {
            int& u = T[1][c];
            if (u == 0) u = 1;
            else        F[u] = 1, Q.push(u);
        }

        while (!Q.empty())
        {
            int v = Q.front(); Q.pop();
            FOR(c, 0, Alph)
            {
                int& u = T[v][c], w = F[v];
                if ( u== 0)
                    continue;
                while (T[w][c] == 0)    w = F[w];
                F[u] = T[w][c];
                N[u] = o[F[u]] == 0 ? N[F[u]] : F[u];
                Q.push(u);
            }
        }
    }

    void query(char* t, int m, int* res)
    {
        int v = 1;
        FOR(i, 0, m)
        {
            int c = chartoint(t[i]);
            while(T[v][c] == 0) v = F[v];
            v = T[v][c];
            int u = o[v] == 0 ? N[v] : v;
            res[i] = u == 0 ? -1 : o[u] - 1;
        }
    }
    void clean()
    {   n = 1;  }
}alg;

struct Tree
{
    int T[maxTS], qbegin, qend, offset, res;

    void qpriv(int v,int left, int right)
    {
        if (left >= qend or right <=qbegin)
            return;

        if (left >= qbegin and right <= qend)
        {
            res = min(res, T[v]);
            return;
        }

        qpriv(v * 2, left, (left  +right)/  2);
        qpriv(v*2+1, (left + right) / 2, right);
    }

    void resize(int n)
    {
        for (offset = 1; offset < n; offset *= 2);

        FOR(i, 1, offset * 2)
            T[i] = INF;
    }

    int query(int a, int b)
    {
        qbegin = a + offset;
        qend = b + offset;
        res = INF;
        qpriv(1, offset, offset * 2);
        return res;
    }

    void updt(int v, int val)
    {
        v += offset;
        T[v] = val;
        for (v /= 2; v != 0; v /= 2)
            T[v] = min(T[v * 2], T[v*2+1]);
    }
} tree;

char text[maxN], temp[maxN];
int len[maxN], dp[maxN], res[maxN];

int main()
{
    int q;
    scanf ("%d", &q);

    scanf ("%s", text);
    int n = strlen(text);

    alg.clean();
    FOR(i, 0, q)
    {
        scanf ("%s", temp);
        len[i] = strlen(temp);
        alg.add(temp, len[i], i);
    }

    alg.calF();
    alg.query(text, n, res);

    tree.resize(n + 42);

    FOR(i, 0, n)
    {
        dp[i] = INF;

        if (res[i] == -1)
            continue;
        int beg = i - len[res[i]];
        dp[i] = 1;
        if (beg != -1)
            dp[i] += tree.query(beg, i);
        tree.updt(i, dp[i]);
    }

    if (dp[n-1] >= INF)
        dp[n-1] = -1;

    printf("%d\n", dp[n-1]);
    return 0;
}