1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
#include <iostream>
#include <string>
#include <stack>
#include <algorithm>
#include <tuple>

int main()
{
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(NULL);

	std::string input;
	std::cin >> input;
	
	const int n = input.size();
	
	int seconds = 0;

	auto isEven = [](size_t num)
	{
		return num % 2 == 0;
	};

	auto countCharacters = [&input](int begin, int end)
	{
		int aCount = 0;
		int bCount = 0;
		for (int i = begin; i < end; i++)
		{
			if (input[i] == 'a')
				aCount++;
			else
				bCount++;
		}
		return std::make_tuple(aCount, bCount);
	};

	auto [aCount, bCount] = countCharacters(0, n);

	auto swap = [&](int index1, int index2)
	{
		std::swap(input[index1], input[index2]);
	};

	auto mirror = [&](int index)
	{
		return input[n - 1 - index];
	};

	auto matches = [&](int index)
	{
		return input[index] == mirror(index);
	};

	if (isEven(n))
	{
		if (!isEven(aCount) || !isEven(bCount))
		{
			std::cout << -1;
			return 0;
		}
	}
	else
	{
		if ((isEven(aCount) && isEven(bCount)) || (!isEven(aCount) && !isEven(bCount)))
		{
			std::cout << -1;
			return 0;
		}
	}

	int mismatches = 0;
	for (int i = 0; i < n / 2; i++)
	{
		if (!matches(i))
		{
			mismatches++;
		}
	}

	const auto [leftACount, leftBCount] = countCharacters(0, n / 2);

	// Character which number is greater on left side
	// const char dominant = leftACount > leftBCount ? 'a' : 'b';

	// If both a and b are even then we don't need that variable ayway
	const char oddCharacter = !isEven(aCount) ? 'a' : 'b';

	const int middleIndex = !isEven(n) ? n / 2 : -1;

	if (!isEven(n))
	{
		// Middle character
		if (input[middleIndex] != oddCharacter)
		{
			mismatches++;
		}
	}

	for (int i = 0; i < n && mismatches > 0; i++)
	{
		if (!matches(i))
		{
			for (int j = i + 1; j < n; j++)
			{
				if ((j == middleIndex && input[j] != input[i] && input[j] != oddCharacter)
					|| (input[j] != input[i] && !matches(j)))
				{
					swap(j, i);
					seconds += j - i;
					mismatches--;
					break;
				}
			}
		}
	}

	std::cout << seconds;

	return 0;
}