#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

typedef unsigned long long ull;
typedef long long ll;

const static int	BIG		= (int)1e9;
const static ll		BIGLL	= (ll)4e18;
const static double	PI = acos(-1);
const static double EPS = 1e-9;
template<class T> T Sq(T a) { return (a)*(a); }
template<class T> T SqSum(T x, T y) { return x * x + y * y; }
template<class T> bool InRange(T x, T a, T b) { return a <= x && x <= b; }
template<class T> void amin(T &a, T v) { if (a > v) a = v; }
template<class T> void amax(T &a, T v) { if (a < v) a = v; }
bool IsInt(double x) { return fabs(round(x) - x) <= EPS; }
bool IsEqual(double x, double y) { return fabs(x - y) <= EPS * max(1.0, max(fabs(x), fabs(y))); }

template<class T>
vector<T> make_vector(int n, T t) {
	return vector<T>(n, t);
}

template<class ...Ts>
auto make_vector(int n, Ts ... ts) {
	return vector<decltype(make_vector(ts...))>(n, make_vector(ts...));
}

#define SZ(a) ((int)(a).size())
#define ARRAY_NUM(a) (sizeof(a)/sizeof(a[0])) 
#define NG (-1)

#define REP(i,n) for(ll i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()

#define YES(n) cout << ((n) ? "YES" : "NO"  ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No"  ) << endl
#define POSSIBLE(n) cout << ((n) ? "POSSIBLE" : "IMPOSSIBLE"  ) << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible"  ) << endl

#define BitSet(arg,posn) ((arg) |= (1LL << (posn)))
#define BitClr(arg,posn) ((arg) &= ~(1LL << (posn)))
#define BitFlp(arg,posn) ((arg) ^= (1LL << (posn)))
#define IsBit(arg,posn) static_cast<bool>((arg) & (1LL << (posn)))

#define Print(x) cerr<<#x<<": "<<(x)<<endl
#define PrintVec(v) cerr<<#v<<": ";REP(__i,(v).size())cerr<<((v)[__i])<<", ";cerr<<endl


struct in {
	int n;
	in() {}
	in(int n_) : n(n_) {};
	template <class T> operator T() {
		T ret;
		cin >> ret;
		return ret;
	}
	template <class T> operator vector<T>() {
		vector<T> ret(n);
		for (int i = 0; i < n; i++) cin >> ret[i];
		return ret;
	}
};

// modint: mod 計算を int を扱うように扱える構造体
template<int MOD>
struct ModInt {
	long long val;
	constexpr ModInt(long long v = 0) noexcept : val(v % MOD) {
		if (val < 0) v += MOD;
	}
	constexpr int getmod() { return MOD; }
	constexpr ModInt operator - () const noexcept {
		return val ? MOD - val : 0;
	}
	constexpr ModInt operator + (const ModInt& r) const noexcept { return ModInt(*this) += r; }
	constexpr ModInt operator - (const ModInt& r) const noexcept { return ModInt(*this) -= r; }
	constexpr ModInt operator * (const ModInt& r) const noexcept { return ModInt(*this) *= r; }
	constexpr ModInt operator / (const ModInt& r) const noexcept { return ModInt(*this) /= r; }
	constexpr ModInt& operator += (const ModInt& r) noexcept {
		val += r.val;
		if (val >= MOD) val -= MOD;
		return *this;
	}
	constexpr ModInt& operator -= (const ModInt& r) noexcept {
		val -= r.val;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr ModInt& operator *= (const ModInt& r) noexcept {
		val = val * r.val % MOD;
		return *this;
	}
	constexpr ModInt& operator /= (const ModInt& r) noexcept {
		long long a = r.val, b = MOD, u = 1, v = 0;
		while (b) {
			long long t = a / b;
			a -= t * b; swap(a, b);
			u -= t * v; swap(u, v);
		}
		val = val * u % MOD;
		if (val < 0) val += MOD;
		return *this;
	}
	constexpr bool operator == (const ModInt& r) const noexcept {
		return this->val == r.val;
	}
	constexpr bool operator != (const ModInt& r) const noexcept {
		return this->val != r.val;
	}

	friend ostream& operator << (ostream &os, const ModInt<MOD>& x) noexcept {
		return os << x.val;
	}
	friend istream& operator >> (istream &is, ModInt<MOD>& x) noexcept {
		return is >> x.val;
	}
	
	// mint ret = modpow((mint)2, i); のように直接呼べます。
	friend constexpr ModInt<MOD> modpow(const ModInt<MOD> &a, long long n) noexcept {
		if (n == 0) return 1;
		auto t = modpow(a, n / 2);
		t = t * t;
		if (n & 1) t = t * a;
		return t;
	}
};

// 二項係数ライブラリ
template<class T> struct BiCoef
{
	constexpr BiCoef() {}
	constexpr BiCoef(int n) noexcept : mFact(n, 1), mInv(n, 1), mFInv(n, 1)
	{
		Init(n);
	}

	constexpr void Init(int n) noexcept
	{
		mFact.assign(n, 1), mInv.assign(n, 1), mFInv.assign(n, 1);
		int factMod = mFact[0].getmod();
		for (int i = 2; i < n; i++) {
			mFact[i] = mFact[i - 1] * i;
			mInv[i] = -mInv[factMod%i] * (factMod / i);
			mFInv[i] = mFInv[i - 1] * mInv[i];
		}
	}

	constexpr T Fact(int n) const noexcept {
		if (n < 0) return 0;
		return mFact[n];
	}

	constexpr T Comb(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[k] * mFInv[n - k];
	}

	constexpr T Perm(int n, int k) const noexcept {
		if (n < k || n < 0 || k < 0) return 0;
		return mFact[n] * mFInv[n - k];
	}

	constexpr T Homo(int n, int r) const {
		if (n < 0 || r < 0) return 0;
		return r == 0 ? 1 : Comb(n + r - 1, r);
	}

	constexpr T inv(int n) const noexcept {
		if (n < 0) return 0;
		return mInv[n];
	}

	constexpr T finv(int n) const noexcept {
		if (n < 0) return 0;
		return mFInv[n];
	}

	vector<T> mFact;
	vector<T> mInv;
	vector<T> mFInv;
};

const int MOD = 1000000007;
using mint = ModInt<MOD>;
// BiCoef<mint> bc(8*1024*1024); // 8M * 3 * 8B(ll) = 192MB (0.5sec)


template< typename T >
struct Edge {
    int from, to;
    T cost;

    Edge() {}
    Edge(int to, T cost) : from(-1), to(to), cost(cost) {}
    Edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};

template< typename T > using Edges = vector< Edge< T > >;
template< typename T > using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T > using Matrix = vector< vector< T > >;



// ダイクストラ法
// output
// - dist 
// - prev 直前の頂点
template< typename T >
void dijkstra(vector <T>& dist, vector <int>& prev, const int start, const WeightedGraph<T>& adj)
{
    const int V = SZ(adj);
    const auto INF = numeric_limits< T >::max();
    dist = vector <T>(V, INF);
    prev = vector <int>(V, NG);
    dist[start] = 0;

    priority_queue<pair<T, int>, vector< pair<T, int> >, greater< pair<T, int> > > pq;
    pq.push(pair<T, int>(0, start));

    while (!pq.empty())
    {
        pair<T, int> top = pq.top();
        pq.pop();

        const T d = top.first;
        const int v1 = top.second;
        if (d <= dist[v1])
        {
            for (const auto& e : adj[v1])
            {
                int v2 = e.to;
                T cost = e.cost;
                if (dist[v2] > dist[v1] + cost)
                {
                    dist[v2] = dist[v1] + cost;
                    prev[v2] = v1;
                    pq.emplace(pair<T, int>(dist[v2], v2));
                }
            }
        }
    }
}

bool trim(string& left, string& right)
{
    // 何文字削れるか？
    int i;
    for (i=0;i<SZ(left) && i<SZ(right);i++)
    {
        if (left[i] != right[SZ(right) - 1 - i])
        {
            break;
        }
    }

    if (i == 0)
    {
        return false;
    }

    if (SZ(left) - i > 0 && SZ(right) - i > 0)
    {
        return false;
    }

    left = left.substr(i);
    right = right.substr(0, SZ(right)-i);
    return true;
}

bool isKaibun(const string& s)
{
    string t = s;
    reverse(ALL(t));
    return t==s;
}

int main()
{
    ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);cout << fixed << setprecision(15);

    int N;
    cin >> N;
    vector <string> s(N);
    vector <ll> c(N);

    map < pair <string, string>, int> mp;
    for (int i = 0; i < N; ++i)
    {
        cin >> s[i] >> c[i];

        for (int len = 1; len <= SZ(s[i]); len++)
        {
            mp[{"", s[i].substr(0,len)}] = 0;
            mp[{s[i].substr(SZ(s[i])-len, len), ""}] = 0;
        }
    }

    const int V = SZ(mp) + 1;

    {
        int v = 0;
        for (auto& pr : mp)
        {
            pr.second = v;
            v++;
//            cerr << " pr.first.first=" << pr.first.first << " pr.first.second=" << pr.first.second << " pr.second=" << pr.second << endl;

        }
    }

    WeightedGraph<ll> adj(V);
    const int GOAL = V - 1;

    for (int i = 0; i < N; ++i)
    {
        for (int len = 1; len <= SZ(s[i]); len++)
        {
            string left = s[i].substr(SZ(s[i]) - len, len);
            string right = s[i].substr(0, len);

            if (isKaibun(left))
            {
                int v = mp[{left, ""}];
                adj[GOAL].emplace_back(GOAL, v, 0);
            }

            if (isKaibun(right))
            {
                int v = mp[{"", right}];
                adj[GOAL].emplace_back(GOAL, v, 0);
            }
        }
    }

    for (const auto& pr : mp)
    {
        const int v = pr.second;

        {
            string left;
            string right;

            tie(left, right) = pr.first;
            if (SZ(left) + SZ(right) == 1)
            {
                adj[GOAL].emplace_back(GOAL, v, 0);
            }
        }

        {
            for (int i = 0; i < N; ++i)
            {
                string left;
                string right;
                tie(left, right) = pr.first;

                if (SZ(left) > 0 && SZ(right)==0)  // 左が余っている
                {
                    right = s[i];
                }
                else if (SZ(left) == 0 && SZ(right) > 0) // 右が余っている
                {
                    left = s[i];
                }

                if (trim(left, right))
                {
                    if (left == "" && right == "")
                    {
                        adj[GOAL].emplace_back(GOAL, v, c[i]);
//                        cerr << " GOAL=" << GOAL << " v=" << v << " c[i]=" << c[i] << endl;
                    }
                    else
                    {
                        assert(mp.count({ left, right }));
                        const int nextv = mp[{ left, right }];
                        adj[nextv].emplace_back(nextv, v, c[i]);
 //                       cerr << " nextv=" << nextv << " v=" << v << " c[i]=" << c[i] << endl;
                     }
                }
            }
        }
    }

    vector <ll> dist;
    vector <int> prev;
    dijkstra(dist, prev, GOAL, adj);

    ll ret = BIGLL;
    for (int i = 0; i < N; ++i)
    {
        if (dist[mp[{"", s[i]}]] < BIGLL)
        {
            amin(ret, dist[mp[{"", s[i]}]]+c[i]);
        }
        if (dist[mp[{s[i], ""}]] < BIGLL)
        {
            amin(ret, dist[mp[{s[i], ""}]] + c[i]);
        }
    }

    if (ret >= BIGLL)
    {
        ret = NG;
    }

    cout << ret << endl;

	return 0;
}


Measured memory_bytes: 4008