Problem:
Score : 400 points

Problem Statement

We have a string s consisting of lowercase English letters.
Snuke can perform the following operation repeatedly:

Insert a letter x to any position in s of his choice, including the beginning and end of s.

Snuke's objective is to turn s into a palindrome.
Determine whether the objective is achievable. If it is achievable, find the minimum number of operations required.

Notes

A palindrome is a string that reads the same forward and backward.
For example, a, aa, abba and abcba are palindromes, while ab, abab and abcda are not.

Constraints

1 \leq |s| \leq 10^5

s consists of lowercase English letters.

Input

Input is given from Standard Input in the following format:

s

Output

If the objective is achievable, print the number of operations required.
If it is not, print -1 instead.

Sample Input 1

xabxa

Sample Output 1

2

One solution is as follows (newly inserted x are shown in bold):

xabxa → xaxbxa → xaxbxax

Sample Input 2

ab

Sample Output 2

-1

No sequence of operations can turn s into a palindrome.

Sample Input 3

a

Sample Output 3

0

s is a palindrome already at the beginning.

Sample Input 4

oxxx

Sample Output 4

3

One solution is as follows:

oxxx → xoxxx → xxoxxx → xxxoxxx

Solution in C++14 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include <iostream>
#include <vector>
#include <map>
#include <cmath>
#include <algorithm>
#include <queue>
#include <unordered_set>
#include <unordered_map>

using namespace std;

struct Node {
	string str;
	int depth;
	Node(string _str, int _depth) {
		str = _str;
		depth = _depth;
	}
};

class Solver
{
private:
	string str;
	unordered_map<char, int> um;
public:
	Solver() {
		cin >> str;
	}

	bool check(string st) {
		for (int i = 0; i < st.size(); ++i)
		{
			if(st[i] != st[st.size() - 1 - i]) {
				return false;
			}
		}
		return true;
	}

	void exec() {
		string new_str = str;
		for (int i = 0; i < new_str.size(); ++i)
		{
			if(new_str[i] == 'x') {
				new_str.erase(i, 1);
				i--;
			}
		}
		if(check(new_str) == false) {
			cout << -1 << endl;
			return;
		}

		int x_cnt = 0;
		for (int i = 0; i < str.size(); ++i)
		{
			if(str[i] == 'x') {
				x_cnt++;
			} else {
				um[str[i]]++;
			}
		}
		int odd_cnt = 0;
		for (auto itr : um) {
			// cout << itr.first << " " << itr.second << endl;
			if(itr.second % 2 == 1) {
				odd_cnt++;
			}
		}
		if(check(str)) {
			cout << 0 << endl;
			return;
		}
		if(odd_cnt > 1) {
			// cout << odd_cnt << endl;
			cout << -1 << endl;
			return;
		} 
		unordered_map<string, bool> dp;
		Node start = {str, 0};
		queue<Node> q;
		q.push(start);
		while(!q.empty()) {
			Node cur = q.front();
			q.pop();
			if(check(cur.str)) {
				cout << cur.depth << endl;
				return;
			}
			for (int j = 0; j < cur.str.size(); ++j)
			{
				string tmp = cur.str;
				// cout << tmp << endl;
				// cout << tmp[j] << endl;
				if(tmp[j] == 'x') {
					tmp.erase(j, 1);
					// cout << tmp << endl;
					if(dp.find(tmp) == dp.end()){
						dp[tmp] = true;
						// cout << tmp << endl;
						q.push(Node(tmp, cur.depth + 1));
					}
				}
			}
		}
		cout << -1 << endl;
	}
	
};

int main() {
	Solver ce = Solver();
	ce.exec();
}