There is a 2D dynamic programming solution for this problem in $$$O(N^2)$$$ time and space complexity as follows.

Initially, you can compute the prefix sum of the numbers in $$$O(N)$$$ time so that sum of the sub-array $$$A[l..r]$$$ can be computed for any $$$1 \leq l \leq r \leq N$$$ in $$$O(1)$$$ time. Then, let $$$DP[l][r]$$$ be the maximum difference that Alice will be able to make when playing the game optimally using the sub-array $$$A[l..r]$$$, i.e. it is the solution of the sub-problem $$$[l,r]$$$. The answer to the original problem is then equal to $$$DP[1][N]$$$.

The base case for $$$DP[l][r]$$$ is when $$$l = r$$$, and the answer is $$$dp[l][l] = A[l]$$$.

There are three different cases for the $$$A[l..r]$$$ sub-problem when $$$l < r$$$:

1. Alice has taken the whole array, and the difference is $$$\sum\limits_{i~=~l}^{r} A[i]$$$.
2. Alice has taken $$$k$$$ numbers from the left-end, where $$$1 \leq k \leq r-l$$$, and the difference is $$$( \sum\limits_{i~=~l}^{l+k-1} A[i] ) - DP[l+k][r]$$$.
3. Alice has taken $$$k$$$ number from the right-end, where $$$1 \leq k \leq r-l$$$, and the difference is $$$( \sum\limits_{i~=~r-k+1}^{r} A[i] ) - DP[l][r-k]$$$.

The value of $$$DP[l][r]$$$ is then computed as the maximum value of these differences.

The following is my accepted C++ implementation of this solution.

#include<bits/stdc++.h>
using namespace std;
 
int main() {   
    using ivector = vector<int>;
    using imatrix = vector<ivector>;
    int T; cin.tie(nullptr)->sync_with_stdio(false), cin >> T;
    for (int test = 1; test <= T; ++test) {
        int N, P; cin >> N, P = N+1;
        ivector prefix(P,0);
        const auto sum = [&](int l, int r) { return prefix[r]-prefix[l-1]; };
        imatrix dp(P,ivector(P,INT_MIN));
        for (int num, i = 1; i < P; ++i)
            cin >> num, dp[i][i] = num, prefix[i] = prefix[i-1]+num;
        const function<int(int,int)> solve = [&](int l, int r) {
            if (dp[l][r] != INT_MIN)
                return dp[l][r];
            dp[l][r] = sum(l,r);
            for (int u = l, v = l+1; u < r; u = v++)
                dp[l][r] = max(dp[l][r],sum(v,r)-solve(l,u)), 
                dp[l][r] = max(dp[l][r],sum(l,u)-solve(v,r));
            return dp[l][r]; };
        cout << "Case " << test << ": " << solve(1,N) << '\n'; }
    return 0; }