SRM 586

dp[55][26][26]，三个下标分别表示dp到第i位，用了前k个字母，已经结束了j个字母（后面不会再用）。

为什么这样的状态？首先我们前面用什么字母这个无所谓，然后到了这个位置，哪些字母结束也无所谓。。。所以只要记录当前在用的是几个字母：k-j，已经用过，不能再用的是几个字母：j，就够了

然后枚举当前这个串用多少字母来操作：use、有多少字母在这个串结束：ed

可以算出

新增多少字母：nw=use-(k-j)

刚开始就结束有多少字母（如果有）：sudden_end：nw+ed-use

从这一段不是开始也不是结束的，即从前面就有并且持续到下面的（如果有）：last=use-nw-ed

然后加加减减来算个代价dp就好了

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>

using namespace std;

class StringWeight {
public:
	int getMinimum(vector<int> );
};
int dp[55][30][30];
int StringWeight::getMinimum(vector<int> a) {
	int i, j, k;
	int use, ed;
	int jj, kk;
	int cost;
	int n = a.size();
	memset(dp, -1, sizeof(dp));
	dp[0][0][0] = 0;
	for (i = 0; i < n; ++i) {
		for (j = 0; j <= 26; ++j) {
			for (k = 0; k <= 26; ++k) {
				if (dp[i][j][k] == -1)
					continue;
				for (use = max(k - j, min(a[i], 26)); use <= 26 - j; ++use) {
					for (ed = 0; ed <= use; ++ed) {
						jj = j + ed;
						kk = j + use;
						int nw = use - (k - j);
						if (nw + ed >= use) {
							int sudden_end = nw + ed - use;
							cost = (1 + (nw - sudden_end)) * (nw - sudden_end)
									/ 2 - (nw - sudden_end) + (1 + (ed
									- sudden_end)) * (ed - sudden_end) / 2
									+ max(a[i] - use, 0);
						} else {
							int last = use - nw - ed;
							cost = last * a[i] + (1 + nw) * nw / 2 - nw + (1
									+ ed) * ed / 2;
						}
						if (dp[i + 1][jj][kk] == -1 || dp[i + 1][jj][kk]
								> dp[i][j][k] + cost)
							dp[i + 1][jj][kk] = dp[i][j][k] + cost;
					}
				}
			}
		}
	}
	int ans = 1000000000;
	for (k = 0; k <= 26; ++k) {
		if (dp[n][k][k] != -1)
			ans = min(ans, dp[n][k][k]);
	}
	return ans;
}