Problem:
Score : 600 points

Problem Statement

Given is an integer sequence A_1, ..., A_N of length N.

We will choose exactly \left\lfloor \frac{N}{2} \right\rfloor elements from this sequence so that no two adjacent elements are chosen.

Find the maximum possible sum of the chosen elements.

Here \lfloor x \rfloor denotes the greatest integer not greater than x.

Constraints

2 \leq N \leq 2\times 10^5

|A_i|\leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 ... A_N

Output

Print the maximum possible sum of the chosen elements.

Sample Input 1

6
1 2 3 4 5 6

Sample Output 1

12

Choosing 2, 4, and 6 makes the sum 12, which is the maximum possible value.

Sample Input 2

5
-1000 -100 -10 0 10

Sample Output 2

0

Choosing -10 and 10 makes the sum 0, which is the maximum possible value.

Sample Input 3

10
1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000 1000000000

Sample Output 3

5000000000

Watch out for overflow.

Sample Input 4

27
18 -28 18 28 -45 90 -45 23 -53 60 28 -74 -71 35 -26 -62 49 -77 57 24 -70 -93 69 -99 59 57 -49

Sample Output 4

295

Solution in C++ (GCC 9.2.1) (judge verdict: Wrong Answer)

#include <map>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <vector>
#include <numeric>
#include <algorithm>
#include <iostream>
#include <string>
#include <cstring>
#include <sstream>
#include <functional>
#include <queue>
#include <deque>
#include <stack>
#include <cassert>
#include <bitset>

using namespace std;

using int64 = long long;

/////////////////////
// Code starts here//
/////////////////////
const int64 INF = (1LL<<59);

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int N;
    cin >> N;
    vector<int64> A(N);
    for (int i = 0; i < N; i++)
        cin >> A[i];

    A.insert(A.begin(), 0);
    A.insert(A.begin(), INF >> 6);

    A.push_back(0);
    A.push_back(INF >> 6);

    N = A.size();
    
    int max_slack = (N & 1) ? 2 : 1;

    vector<vector<int64>> dp(N, vector<int64>(3, -INF));

    dp[0][0] = A[0];

    // for (auto val : A)
    //     cerr << val << " "; cerr << "\n";

    // cerr << "max_slack: " << max_slack << "\n";

    for (int i = 2; i < N; i++) {
        for (int slack = 0; slack <= max_slack; slack++) {
            for (int j = i - 2; j >= 0 && (i - j) - 2 <= slack; j--) {
                dp[i][slack] = max(dp[i][slack], A[i] + dp[j][slack - ((i - j) - 2)]);
            }
            // if (dp[i][slack] >= 0) {
            //     cerr << i << " : " << slack << " = " << dp[i][slack] << "\n";
            // }
        }
    }

    int64 res = 0;
    for (int i = 0; i <= max_slack; i++)
        res = max(res, dp[N-1][i]);
    cout << res - 2 * (INF >> 6) << "\n";
    return 0;
}