字典序问题

#include <iostream>
#include <string>

using namespace std;

namespace
{

constexpr int count(int row, int col);

constexpr int countSum(int row, int scol, int ecol)
{
	return scol != ecol ?
			count(row, scol) + countSum(row, scol + 1, ecol)
			: count(row, scol);
}

constexpr int count(int row, int col)
{
	return col > (25 - row) ?
			0 : (row ? countSum(row - 1, col + 1, 25 - row + 1) : 1);
}

constexpr int total(int row)
{
	return row ? countSum(row, 0 , 25) + total(row - 1)
			: countSum(row, 0 , 25);
}

constexpr int base[11]
{
	0, 0, total(0), total(1), total(2), total(3),
	total(4), total(5), total(6), total(7), total(8)
};

constexpr int offset[10][26]
{
	{
		count(0, 0), count(0, 1), count(0, 2), count(0, 3),
		count(0, 4), count(0, 5), count(0, 6), count(0, 7),
		count(0, 8), count(0, 9), count(0, 10), count(0, 11),
		count(0, 12), count(0, 13), count(0, 14), count(0, 15),
		count(0, 16), count(0, 17), count(0, 18), count(0, 19),
		count(0, 20), count(0, 21), count(0, 22), count(0, 23),
		count(0, 24), count(0, 25)
	},
	{
		count(1, 0), count(1, 1), count(1, 2), count(1, 3),
		count(1, 4), count(1, 5), count(1, 6), count(1, 7),
		count(1, 8), count(1, 9), count(1, 10), count(1, 11),
		count(1, 12), count(1, 13), count(1, 14), count(1, 15),
		count(1, 16), count(1, 17), count(1, 18), count(1, 19),
		count(1, 20), count(1, 21), count(1, 22), count(1, 23),
		count(1, 24), count(1, 25)
	},
	{
		count(2, 0), count(2, 1), count(2, 2), count(2, 3),
		count(2, 4), count(2, 5), count(2, 6), count(2, 7),
		count(2, 8), count(2, 9), count(2, 10), count(2, 11),
		count(2, 12), count(2, 13), count(2, 14), count(2, 15),
		count(2, 16), count(2, 17), count(2, 18), count(2, 19),
		count(2, 20), count(2, 21), count(2, 22), count(2, 23),
		count(2, 24), count(2, 25)
	},
	{
		count(3, 0), count(3, 1), count(3, 2), count(3, 3),
		count(3, 4), count(3, 5), count(3, 6), count(3, 7),
		count(3, 8), count(3, 9), count(3, 10), count(3, 11),
		count(3, 12), count(3, 13), count(3, 14), count(3, 15),
		count(3, 16), count(3, 17), count(3, 18), count(3, 19),
		count(3, 20), count(3, 21), count(3, 22), count(3, 23),
		count(3, 24), count(3, 25)
	},
	{
		count(4, 0), count(4, 1), count(4, 2), count(4, 3),
		count(4, 4), count(4, 5), count(4, 6), count(4, 7),
		count(4, 8), count(4, 9), count(4, 10), count(4, 11),
		count(4, 12), count(4, 13), count(4, 14), count(4, 15),
		count(4, 16), count(4, 17), count(4, 18), count(4, 19),
		count(4, 20), count(4, 21), count(4, 22), count(4, 23),
		count(4, 24), count(4, 25)
	},
	{
		count(5, 0), count(5, 1), count(5, 2), count(5, 3),
		count(5, 4), count(5, 5), count(5, 6), count(5, 7),
		count(5, 8), count(5, 9), count(5, 10), count(5, 11),
		count(5, 12), count(5, 13), count(5, 14), count(5, 15),
		count(5, 16), count(5, 17), count(5, 18), count(5, 19),
		count(5, 20), count(5, 21), count(5, 22), count(5, 23),
		count(5, 24), count(5, 25)
	},
	{
		count(6, 0), count(6, 1), count(6, 2), count(6, 3),
		count(6, 4), count(6, 5), count(6, 6), count(6, 7),
		count(6, 8), count(6, 9), count(6, 10), count(6, 11),
		count(6, 12), count(6, 13), count(6, 14), count(6, 15),
		count(6, 16), count(6, 17), count(6, 18), count(6, 19),
		count(6, 20), count(6, 21), count(6, 22), count(6, 23),
		count(6, 24), count(6, 25)
	},
	{
		count(7, 0), count(7, 1), count(7, 2), count(7, 3),
		count(7, 4), count(7, 5), count(7, 6), count(7, 7),
		count(7, 8), count(7, 9), count(7, 10), count(7, 11),
		count(7, 12), count(7, 13), count(7, 14), count(7, 15),
		count(7, 16), count(7, 17), count(7, 18), count(7, 19),
		count(7, 20), count(7, 21), count(7, 22), count(7, 23),
		count(7, 24), count(7, 25)
	},
	{
		count(8, 0), count(8, 1), count(8, 2), count(8, 3),
		count(8, 4), count(8, 5), count(8, 6), count(8, 7),
		count(8, 8), count(8, 9), count(8, 10), count(8, 11),
		count(8, 12), count(8, 13), count(8, 14), count(8, 15),
		count(8, 16), count(8, 17), count(8, 18), count(8, 19),
		count(8, 20), count(8, 21), count(8, 22), count(8, 23),
		count(8, 24), count(8, 25)
	},
	{
		count(9, 0), count(9, 1), count(9, 2), count(9, 3),
		count(9, 4), count(9, 5), count(9, 6), count(9, 7),
		count(9, 8), count(9, 9), count(9, 10), count(9, 11),
		count(9, 12), count(9, 13), count(9, 14), count(9, 15),
		count(9, 16), count(9, 17), count(9, 18), count(9, 19),
		count(9, 20), count(9, 21), count(9, 22), count(9, 23),
		count(9, 24), count(9, 25)
	}
};

inline bool check(const string &str)
{
	if (str.size() == 1) return true;
	for (size_t idx = 1; idx != str.size(); ++idx)
		if (str[idx] < str[idx - 1]) return false;
	return true;
}

int indexAux(const string &str, size_t pos, char preCh, int val)
{
	int len = str.size() - pos;
	if (len == 1) return val + (str[pos] - preCh);

	--len;
	for (int idx = preCh + 1 - 'a', end = str[pos] - 'a'; idx != end; ++idx)
		val += offset[len][idx];
	return indexAux(str, pos + 1, str[pos], val);
}

inline int index(const string &str)
{
	return check(str) ?
			base[str.size()] + indexAux(str, 0, 'a' - 1, 0) : 0;
}

}

int main(int argc, char **argv)
{
	int times;
	for (cin >> times; times; --times)
	{
		string str;
		cin >> str;

		int code = index(str);
		cout << code << endl;
	}

	return 0;
}