UVA 10891 Game of Sum（DP）

This is a two player game. Initially there are n integer numbers in an array and players A and B get chance to take them alternatively. Each player can take one or more numbers from the left or right end of the array but cannot take from both ends at a time. He can take as many consecutive numbers as he wants during his time. The game ends when all numbers are taken from the array by the players. The point of each player is calculated by the summation of the numbers, which he has taken. Each player tries to achieve more points from other. If both players play optimally and player A starts the game then how much more point can player A get than player B?

Input

The input consists of a number of cases. Each case starts with a line specifying the integer n (0 < n ≤100), the number of elements in the array. After that, nnumbers are given for the game. Input is terminated by a line where n=0.

Output

For each test case, print a number, which represents the maximum difference that the first player obtained after playing this game optimally.

题目大意：给n个数，两个人轮流取数，可以从左往右或从右往左取任意多个。两个人都希望自己的取得的数的总和尽量大，都采取最优策略，问第一个人能比第二个人取得的数多多少。

思路：很容易可以想到一个$O(n^3)$的DP，用dp[i][j]代表只剩下a[i..j]的数，先手可以取得的最大值，此时后手取得的最大值为sum[i..j] - dp[i][j]。

那么状态转移方程为：dp[i][j] = max(sum[i..j], sum[i..j] - min(dp[i+1][j], dp[i+2][j]……), sum[i..j] - min(dp[i][j - 1], dp[i, j - 2])。

输出结果为2 * dp[1][n] - sum[1..n]。

代码（0.026S）：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 
 const int MAXN = ;
 
 int dp[MAXN][MAXN];
 int a[MAXN], sum[MAXN];
 int n;
 
 int main() {
     while(scanf("%d", &n) != EOF && n) {
         for(int i = ; i <= n; ++i) scanf("%d", a + i);
         for(int i = ; i <= n; ++i) sum[i] = sum[i - ] + a[i];
         for(int k = ; k < n; ++k) {
             for(int i = ; i + k <= n; ++i) {
                 int j = i + k;
                 dp[i][j] = sum[j] - sum[i - ];
                 for(int p = i + ; p <= j; ++p) dp[i][j] = max(dp[i][j], sum[j] - sum[i - ] - dp[p][j]);
                 for(int p = j - ; p >= i; --p) dp[i][j] = max(dp[i][j], sum[j] - sum[i - ] - dp[i][p]);
             }
         }
         printf("%d\n",  * dp[][n] - sum[n]);
     }
 }

这个DP还有优化的余地，观察状态转移方程可以发现，dp[i][j]使用了min(dp[i+1][j], dp[i+2][j]……)，而dp[i+1][j]=min(dp[i+2][j], dp[i+3][j]……)，有重复的部分。

于是我们可以用l[i][j]记录max(dp[i][j], dp[i+1][j], dp[i+2][j]……)，即从左往右取的后手最小值，则sum[i..j] - min(dp[i+1][j], dp[i+2][j]……)可以写成sum[i..j]-l[i+1][j]。每次更新l[i][j] = min(dp[i][j], l[i+1][j])。

同理用r[i][j]记录从右往左取的后手最小值。

至此DP优化至$O(n^2)$。

代码（0.015S）：

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 
 const int MAXN = ;
 
 int dp[MAXN][MAXN];
 int l[MAXN][MAXN], r[MAXN][MAXN];
 int a[MAXN], sum[MAXN];
 int n;
 
 int main() {
     while(scanf("%d", &n) != EOF && n) {
         for(int i = ; i <= n; ++i) scanf("%d", a + i);
         for(int i = ; i <= n; ++i) sum[i] = sum[i - ] + a[i];
         for(int k = ; k < n; ++k) {
             for(int i = ; i + k <= n; ++i) {
                 int j = i + k;
                 l[i][j] = r[i][j] = dp[i][j] = sum[j] - sum[i - ];
                 if(i != j) {
                     dp[i][j] = max(dp[i][j], sum[j] - sum[i - ] - l[i + ][j]);
                     dp[i][j] = max(dp[i][j], sum[j] - sum[i - ] - r[i][j - ]);
                     l[i][j] = min(dp[i][j], l[i + ][j]);
                     r[i][j] = min(dp[i][j], r[i][j - ]);
                 }
             }
         }
         printf("%d\n",  * dp[][n] - sum[n]);
     }
 }