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 <bits/stdc++.h>
using namespace std;

#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP0(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define RREP0(i, n) for (int i = (n)-1; i >= 0; --i)
#define REP1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define RREP1(i, n) for (int i = (n); i >= 1; --i)
#define pow10(n) int(1e##n + n)

typedef long long LL;
typedef pair<int, int> P;

const int INTINF = int(1e9) + 1;
const LL LLINF = LL(1e15) + 1;
long double eps = 1.0E-14;

LL dp[2 * pow10(5)][3];

void solve()
{
    int N;
    cin >> N;
    vector<LL> A(N);
    REP0 (i, N)
    {
        cin >> A[i];
        REP0 (j, 3)
        {
            dp[i][j] = -LLINF;
        }
    }

    // if (N % 2 == 0)
    // {
    //     dp[0][0] = A[0];
    //     dp[1][1] = A[1];
    //     LL ans = -LLINF;

    //     for (int i = 2; i < N; i++)
    //     {
    //         dp[i][1] = max(dp[i][1], dp[i - 2][1] + A[i]);
    //         if (i - 3 >= 0)
    //             dp[i][1] = max(dp[i][1], dp[i - 3][0] + A[i]);

    //         dp[i][0] = max(dp[i][0], dp[i - 2][0] + A[i]);
    //     }

    //     ans = max(ans, dp[N - 1][0]);
    //     ans = max(ans, dp[N - 1][1]);
    //     ans = max(ans, dp[N - 2][0]);

    //     std::cout << ans << endl;
    //     return;
    // }

    dp[0][0] = A[0];
    dp[1][1] = A[1];
    dp[2][2] = A[2];
    LL ans = -LLINF;

    for (int i = 3; i < N; i++)
    {
        dp[i][2] = max(dp[i][2], dp[i - 2][2] + A[i]);
        dp[i][2] = max(dp[i][2], dp[i - 3][1] + A[i]);
        if (i - 4 >= 0)
            dp[i][2] = max(dp[i][2], dp[i - 4][0] + A[i]);

        dp[i][1] = max(dp[i][1], dp[i - 2][1] + A[i]);
        dp[i][1] = max(dp[i][1], dp[i - 3][0] + A[i]);

        dp[i][0] = max(dp[i][0], dp[i - 2][0] + A[i]);
    }

    ans = max(ans, dp[N - 1][0]);
    ans = max(ans, dp[N - 1][1]);
    ans = max(ans, dp[N - 1][2]);

    ans = max(ans, dp[N - 2][1]);
    ans = max(ans, dp[N - 2][0]);

    ans = max(ans, dp[N - 3][0]);

    std::cout << ans << endl;
}

int main(int argc, char const *argv[])
{
    cin.tie(0);
    ios::sync_with_stdio(false);
    std::cout << std::fixed << std::setprecision(20);
    solve();
    return 0;
}