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

#pragma region Macros
using ll = long long;
#define int ll
using pii = pair<int, int>;
using tiii = tuple<int, int, int>;
template<class T = ll> using V = vector<T>;
template<class T = ll> using VV = V<V<T>>;
#define IOS\
    ios::sync_with_stdio(false);\
    cin.tie(0);\
    cout.tie(0);
#define FOR(i,l,r) for(ll i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
#define REPS(i,n) FOR(i,1,n+1)
#define RFOR(i,l,r) for(ll i=(l);i>=(r);--i)
#define RREP(i,n) RFOR(i,n-1,0)
#define RREPS(i,n) RFOR(i,n,1)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(),(x).end()
#define SORT(name) sort(name.begin(), name.end())
#define RSORT(name)\
    SORT(name);\
    reverse(all(name));
#define ZERO(p) memset(p, 0, sizeof(p))
#define MINUS(p) memset(p, -1, sizeof(p))
inline void Yes(bool b = true) {cout << (b ? "Yes" : "No") << '\n';}
inline void YES(bool b = true) {cout << (b ? "YES" : "NO") << '\n';}
template <class T> inline void print(T x){ cout << x << '\n';}
template<typename T1,typename T2> inline void chmin(T1 &a, T2 b){ if(a > b) a = b; }
template<typename T1,typename T2> inline void chmax(T1 &a, T2 b){ if(a < b) a = b; }

const ll LLINF = (1LL<<60);
const int INF = (1LL<<30);
const double DINF = std::numeric_limits<double>::infinity();
#pragma endregion

template <typename T>
class Dijkstra {
    private:
        struct Edge {
            int to;   // 有向辺の行先頂点
            T cost;  // 辺の重み
        };
        typedef pair<int, T> P;       // first: 最短距離 second: 頂点 id
    public:
        // コンストラクタ
        // v … 頂点数, inf: …「無限大」とする値
        Dijkstra() {}
        Dijkstra(int v, T inf) { Init(v, inf); }
        void Init(int v, T inf) {
            assert(v > 0);
            m_V = v;
            m_Inf = inf;
            m_G.assign(m_V, vector<Edge>());
        }
        // 有向辺の追加。負のコストは未対応
        void AddDirEdge(int from, int to, T cost) {
            assert(0 <= from && from < m_V);
            assert(0 <= to && to < m_V);
            m_G[from].push_back({to, cost});
        }
        // 無向辺の追加。負のコストは未対応
        void AddUndirEdge(int from, int to, T cost) {
            AddDirEdge(from, to, cost);
            AddDirEdge(to, from, cost);
        }
        // 始点 s から各頂点への最短経路の導出 O(E log V)
        // Calc を連続で行うことはできない。その場合は m_Dist と m_Prev の再初期化が必要
        void Calc(int s) {
            assert(0 <= s && s < m_V);
            m_Dist.assign(m_V, m_Inf);
            m_PrevP.assign(m_V, -1);
            // 最短距離が短い順で cand を取り出す
            // 頂点 P.second まで P.first のコストで来れたことを情報として入れておく
            priority_queue<P, vector<P>, greater<P> > cand;
            m_Dist[s] = 0;  // 始点のコストは 0
            cand.push(P(0, s));
            while(!cand.empty()) {
                P p = cand.top(); cand.pop();     // cand のトップを取り出す
                T v = p.second;
                // 頂点 v まで最短経路が、 cand から取り出したものより既に小さいなら何もしない
                if(m_Dist[v] < p.first){ continue; }
                // 現在見ている頂点から延びている辺を全て見る
                for(Edge e : m_G[v]) {
                    if(m_Dist[e.to] > m_Dist[v] + e.cost) {
                        // 現在の最短経路より短くなるなら更新
                        m_Dist[e.to] = m_Dist[v] + e.cost;
                        m_PrevP[e.to] = v;
                        cand.push(P(m_Dist[e.to], e.to));
                    }
                }
            }
        }
        // 始点 s から頂点 t への最短距離を返す O(1)
        // 前処理として Calc(s) が必要
        T GetDist(int t) { return m_Dist[t]; }
        // 始点 s から頂点 t までの経路を vector に入れて返す (s と t 含む)
        // O(V') … V' は最短経路の頂点数
        // 前処理として Calc(s) が必要
        vector<int> GetPath(int t) {
            vector<T> path;
            for(; t != -1; t = m_PrevP[t]) { path.push_back(t); }  // t が s になるまで prev_p[t] を辿っていく
            // このままだと t->s の順になっているので逆順にする
            reverse(path.begin(), path.end());
            return path;
        }
    private:
        int m_V;                    // 頂点の数
        T m_Inf;                    // 無限の代わりとして扱う値
        vector< vector<Edge> > m_G; // 頂点 i から延びている辺の vector(隣接リスト)
        vector<T> m_Dist;           // 各頂点への最短コスト。つまり答え
        vector<int> m_PrevP;        // 最短経路の各頂点を保存(経路復元で利用)
};

#if 0
#  define DBG(fmt, ...) printf(fmt, ##__VA_ARGS__)
#else
#  define DBG(fmt, ...)
#endif

const int MOD = 1000000007;
const int MAX_N = 100010;

int N;
V<string> S;
V<> C;

V<string> S_r;  // S の reverse

// s の reverse を返す
string rev(string s) {
    string ret = s;
    reverse(all(ret));
    return ret;
}

// 回分なら true
bool isPal(string s) {
    return s == rev(s);
}

signed main() {
    IOS;

    cin >> N;
    S.resize(N);
    C.resize(N);
    S_r.resize(N);
    REP(i, N) {
        cin >> S[i] >> C[i];
        S_r[i] = rev(S[i]);
    }

    // グラフの作成
    int node_size = 0;  // 頂点数
    V< V< V<> > > id;   // 頂点 id
                        // k = 0 -> Si の [j, Si.length()-1] 文字が左側に余っているときの頂点
                        // k = 1 -> S_ri の [j, S_ri.length()-1] 文字が右側に余っているときの頂点
    REP(i, N) {
        id.eb(V< V<> >(S[i].length(), V<>(2, 0)));
        REP(j, S[i].length()) {
            id[i][j][0] = node_size;
            node_size++;
            id[i][j][1] = node_size;
            node_size++;
        }
    }

    // 辺の追加
    Dijkstra<int> dk(node_size + 10, LLINF);
    int n_start = node_size + 2;
    int n_goal = node_size + 3;

    REP(i, N) {
        dk.AddDirEdge(n_start, id[i][0][0], C[i]);
        DBG("0 n_start -> [%lld][%lld][%lld] %lld\n", i, 0LL, 0LL, C[i]);
        if(isPal(S[i])) {
            dk.AddDirEdge(id[i][0][0], n_goal, 0);
            dk.AddDirEdge(id[i][0][1], n_goal, 0);
            DBG("1 [%lld][%lld][%lld] -> n_goal %lld\n", i, 0LL, 0LL, 0LL);
            DBG("2 [%lld][%lld][%lld] -> n_goal %lld\n", i, 0LL, 1LL, 0LL);
        }
    }

    REP(i, N) {
        REP(j, S[i].length()) {
            // k: 0 のとき
            // 余っている文字
            string rem = S[i].substr(j, S[i].length() - j);
            if(isPal(rem)) {
                // 余りが回文ならこれ以上追加する必要はない
                dk.AddDirEdge(id[i][j][0], n_goal, 0);
                DBG("3 [%lld][%lld][%lld] -> n_goal %lld\n", i, j, 0LL, 0LL);
            }
            // 余っている文字の prefix が S_r の prefix に出てくる頂点に遷移できる
            REP(k, N) {
                if(rem.length() > S_r[k].length()) {
                    string cand = rem.substr(0, S_r[k].length());
                    if(cand == S_r[k]) {
                        int n_from = id[i][j][0];
                        int n_to = id[i][j + cand.length()][0];
                        dk.AddDirEdge(n_from, n_to, C[k]);
                        DBG("4 [%lld][%lld][%lld] -> [%lld][%lld][%lld] %lld\n",
                            i, j, 0LL, i, j + cand.length(), 0LL, C[k]);
                    }
                }
                else if(rem.length() < S_r[k].length()) {
                    string cand = S_r[k].substr(0, rem.length());
                    if(rem == cand) {
                        int n_from = id[i][j][0];
                        int n_to = id[k][cand.length()][1]; // 余りがでるサイドが変わる
                        dk.AddDirEdge(n_from, n_to, C[k]);
                        DBG("5 [%lld][%lld][%lld] -> [%lld][%lld][%lld] %lld\n",
                            i, j, 0LL, k, (ll)cand.length(), 1LL, C[k]);
                    }
                }
                else if(rem == S_r[k]) {
                    // ゴール
                    dk.AddDirEdge(id[i][j][0], n_goal, C[k]);
                    DBG("6 [%lld][%lld][%lld] -> n_goal %lld\n", i, j, 0LL, C[k]);
                }
            }

            // k: 1 のとき
            rem = S_r[i].substr(j, S_r[i].length() - j);
            if(isPal(rem)) {
                dk.AddDirEdge(id[i][j][1], n_goal, 0);
                DBG("7 [%lld][%lld][%lld] -> n_goal %lld\n", i, j, 1LL, 0LL);
            }
            REP(k, N) {
                if(rem.length() > S[k].length()) {
                    string cand = rem.substr(0, S[k].length());
                    if(cand == S[k]) {
                        int n_from = id[i][j][1];
                        int n_to = id[i][j + cand.length()][1];
                        dk.AddDirEdge(n_from, n_to, C[k]);
                        DBG("8 [%lld][%lld][%lld] -> [%lld][%lld][%lld] %lld\n",
                            i, j, 1LL, i, j + cand.length(), 1LL, C[k]);
                    }
                }
                else if(rem.length() < S[k].length()) {
                    string cand = S[k].substr(0, rem.length());
                    if(rem == cand) {
                        int n_from = id[i][j][1];
                        int n_to = id[k][cand.length()][0];
                        dk.AddDirEdge(n_from, n_to, C[k]);
                        DBG("9 [%lld][%lld][%lld] -> [%lld][%lld][%lld] %lld\n",
                            i, j, 1LL, k, (ll)cand.length(), 0LL, C[k]);
                    }
                }
                else if(rem == S[k]) {
                    // ゴール
                    dk.AddDirEdge(id[i][j][1], n_goal, C[k]);
                    DBG("10 [%lld][%lld][%lld] -> n_goal %lld\n", i, j, 1LL, C[k]);
                }
            }
        }
    }

    dk.Calc(n_start);
    int ans = dk.GetDist(n_goal);
    if(ans >= LLINF) {
        print(-1);
        return 0;
    }
    print(ans);

    return 0;
}


Measured memory_bytes: 3856