Problem:
Score : 600 points

Problem Statement

We have N strings of lowercase English letters: S_1, S_2, \cdots, S_N.

Takahashi wants to make a string that is a palindrome by choosing one or more of these strings - the same string can be chosen more than once - and concatenating them in some order of his choice.

The cost of using the string S_i once is C_i, and the cost of using it multiple times is C_i multiplied by that number of times.

Find the minimum total cost needed to choose strings so that Takahashi can make a palindrome.

If there is no choice of strings in which he can make a palindrome, print -1.

Constraints

1 \leq N \leq 50

1 \leq |S_i| \leq 20

S_i consists of lowercase English letters.

1 \leq C_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N
S_1 C_1
S_2 C_2
:
S_N C_N

Output

Print the minimum total cost needed to choose strings so that Takahashi can make a palindrome, or -1 if there is no such choice.

Sample Input 1

3
ba 3
abc 4
cbaa 5

Sample Output 1

7

We have ba, abc, and cbaa.

For example, we can use ba once and abc once for a cost of 7, then concatenate them in the order abc, ba to make a palindrome.
Also, we can use abc once and cbaa once for a cost of 9, then concatenate them in the order cbaa, abc to make a palindrome.

We cannot make a palindrome for a cost less than 7, so we should print 7.

Sample Input 2

2
abcab 5
cba 3

Sample Output 2

11

We can choose abcab once and cba twice, then concatenate them in the order abcab, cba, cba to make a palindrome for a cost of 11.

Sample Input 3

4
ab 5
cba 3
a 12
ab 10

Sample Output 3

8

We can choose a once, which is already a palindrome, but it is cheaper to concatenate ab and cba.

Sample Input 4

2
abc 1
ab 2

Sample Output 4

-1

We cannot make a palindrome, so we should print -1.

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

use std::cmp::{self, Reverse};
use std::collections::{BinaryHeap, HashMap};

fn main() {
    let n: usize = {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        buf.trim_end().parse().unwrap()
    };

    let mut ans = std::i64::MAX;

    let mut heap = BinaryHeap::new();
    let mut map = HashMap::new();

    let mut s: Vec<String> = Vec::with_capacity(n);
    let mut c: Vec<i64> = Vec::with_capacity(n);
    for i in 0..n {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        let mut iter = buf.split_whitespace();
        s.push(iter.next().unwrap().to_string());
        c.push(iter.next().unwrap().parse().unwrap());

        let mut f = |s: &String, c: i64, t: char| {
            let val = map.entry((s.clone(), t)).or_insert(std::i64::MAX);
            if c < *val {
                *val = c;
                heap.push((Reverse(c), (s.clone(), t)));
            }
        };

        if s[i].chars().eq(s[i].chars().rev()) {
            ans = cmp::min(ans, c[i]);
            continue;
        }

        let s0 = s[i].chars().rev().collect::<String>();
        f(&s0, c[i], 'p');
        f(&s0, c[i], 's');
    }

    while let Some((Reverse(c0), (s0, t))) = heap.pop() {
        for i in 0..n {
            let c1 = c0 + c[i];
            if s0.len() == s[i].len() {
                if s0 == s[i] {
                    ans = cmp::min(ans, c1);
                }
                continue;
            }

            let mut f = |s: &String, c: i64, t: char| {
                let val = map.entry((s.clone(), t)).or_insert(std::i64::MAX);
                if c < *val {
                    *val = c;
                    heap.push((Reverse(c), (s.clone(), t)));
                }
            };
        
            if t == 'p' {
                if s0.len() < s[i].len() && s[i].starts_with(&s0)  {
                    let s1 = (&s[i][(s0.len())..]).chars().rev().collect::<String>();
                    if s1.chars().eq(s1.chars().rev()) {
                        ans = cmp::min(ans, c1);
                        continue;
                    }
                    f(&s1, c1, 's');
                }
                if s0.len() > s[i].len() && s0.starts_with(&s[i]) {
                    let s1 = (&s0[(s[i].len())..]).chars().collect::<String>();
                    if s1.chars().eq(s1.chars().rev()) {
                        ans = cmp::min(ans, c1);
                        continue;
                    }
                    f(&s1, c1, 'p');
                }
            }
            if t == 's' {
                if s0.len() < s[i].len() && s[i].ends_with(&s0) {
                    let s1 = (&s[i][..(s[i].len() - s0.len())]).chars().rev().collect::<String>();
                    if s1.chars().eq(s1.chars().rev()) {
                        ans = cmp::min(ans, c1);
                        continue;
                    }
                    f(&s1, c1, 'p');
                }
                if s0.len() > s[i].len() && s0.ends_with(&s[i]) {
                    let s1 = (&s0[..(s0.len() - s[i].len())]).chars().collect::<String>();
                    if s1.chars().eq(s1.chars().rev()) {
                        ans = cmp::min(ans, c1);
                        continue;
                    }
                    f(&s1, c1, 's');
                }
            }
        }
    }
    println!("{}", if ans == std::i64::MAX { -1 } else { ans });
}