设序列只剩下a[x]开头到a[y]结尾，令f(x,y)为该情况下先手方能取得的最优分数，g(x,y)为此时后手方能取得的分数
则先手方有两种选择：
1.选a[x]，可以得到 a[x] + g(x + 1, y) 分，对手得到 f(x + 1, y) 分，分差v1 = a[x] + g(x + 1, y) - f(x + 1, y)
2.选a[y]，可以得到 a[y] + g(x, y - 1) 分，对手得到 f(x, y - 1) 分，分差v2 = a[y] + g(x, y - 1) - f(x, y - 1)
选分差大的那种，即
f(x, y) = a[x] + g(x + 1, y) ( v1 >= v2)
= a[y] + g(x, y - 1) ( v1 < v2)
g(x, y) = f(x - 1, y) ( v1 >= v2)
= f(x, y - 1) ( v1 >= v2)
先写个递归搜索理一下思路：
template <typename RanIt>
pair<typename iterator_traits<RanIt>::value_type, typename iterator_traits<RanIt>::value_type> Select(RanIt start, RanIt end)
{
if (distance(start, end) == 1)
{
return make_pair(*start, 0);
}
auto l = *start;
const auto & sl = Select(next(start), end);
auto r = *--end;
const auto & sr = Select(start, end);
auto v1 = l + sl.second - sl.first;
auto v2 = r + sr.second - sr.first;
if (v1 >= v2)
{
return make_pair(l + sl.second, sl.first);
}
else
{
return make_pair(r + sr.second, sr.first);
}
}
然后就可以简单改写成递推式：
pair<int, int> GetResult(const vector<int>& values)
{
//i , j : 从第i个数开始长度为j的序列
//table[i][j] : (先手取得数字和，后手取得数字和)
pair<int, int> ** table = new pair<int, int>*[values.size()];
for (int i = 0; i < values.size(); ++i)
{
table[i] = new pair<int, int>[values.size() - i];
table[i][0] = make_pair(values[i], 0);
}
for (int j = 1; j < values.size(); ++j)
{
for (int i = 0; i + j < values.size(); ++i)
{
int l = values[i];
int r = values[i + j];
const pair<int, int>& sl = table[i + 1][j - 1];
const pair<int, int>& sr = table[i][j - 1];
int v1 = l + sl.second - sl.first;
int v2 = r + sr.second - sr.first;
if (v1 >= v2)
{
table[i][j] = make_pair(l + sl.second, sl.first);
}
else
{
table[i][j] = make_pair(r + sr.second, sr.first);
}
}
}
pair<int, int> result = table[0][values.size() - 1];
for (int i = 0; i < values.size(); ++i)
{
delete[] table[i];
}
delete[] table;
return result;
}
大概是这样吧
