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: Wrong Answer)

use std::cmp::{self, Reverse};
use std::mem;
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 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)));
            }
        };    

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

    let mut ans = std::i64::MAX;
    while let Some((Reverse(c0), (mut s0, t))) = heap.pop() {
        for (mut s1, c1) in s.clone().into_iter().zip(c.clone().into_iter()) {
            let c2 = c0 + c1;
            if s0.len() == s1.len() {
                if s0 == s1 {
                    ans = cmp::min(ans, c2);
                }
                continue;
            }
            if s0.len() > s1.len() {
                mem::swap(&mut s0, &mut s1);
            }

            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() < s1.len() && s1.starts_with(&s0)  {
                    let s2 = (&s1[(s0.len())..]).chars().rev().collect::<String>();
                    if s2.chars().eq(s2.chars().rev()) {
                        ans = cmp::min(ans, c2);
                        continue;    
                    }
                    f(&s2, c2, 's');
                }
                if s0.len() > s1.len() && s0.starts_with(&s1) {
                    let s2 = (&s0[(s1.len())..]).chars().collect::<String>();
                    if s2.chars().eq(s2.chars().rev()) {
                        ans = cmp::min(ans, c2);
                        continue;    
                    }
                    f(&s2, c2, 'p');
                }
            }
            if t == 's' {
                if s0.len() < s1.len() && s1.ends_with(&s0) {
                    let s2 = (&s1[..(s1.len() - s0.len())]).chars().rev().collect::<String>();
                    if s2.chars().eq(s2.chars().rev()) {
                        ans = cmp::min(ans, c2);
                        continue;    
                    }
                    f(&s2, c2, 'p');
                }
                if s0.len() > s1.len() && s0.ends_with(&s1) {
                    let s2 = (&s0[..(s0.len() - s1.len())]).chars().collect::<String>();
                    if s2.chars().eq(s2.chars().rev()) {
                        ans = cmp::min(ans, c2);
                        continue;    
                    }
                    f(&s2, c2, 's');
                }
            }
        }
    }
    println!("{}", if ans == std::i64::MAX { -1 } else { ans });
}