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# (Mono-mcs 6.8.0.105) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Linq;

namespace contest_Csharp
{
    class Program
    {
        static void Main(string[] args)
        {

            int N = int.Parse(Console.ReadLine());
            
            var A = Console.ReadLine().Split(' ')
              .Select(x => long.Parse(x)).ToList();
            List<long> sumeven=new List<long>(), sumodd=new List<long>();
            long se = 0, so = 0;
            sumodd.Add(so);
            sumeven.Add(se);
            for (int i = 0; i < N; i++)
            {
                if (i%2==0)
                {
                    se += A[i];
                    sumeven.Add(se);
                }
                else 
                {
                    so += A[i];
                    sumodd.Add(so);
                }
            }

            List<int> firstlimit = new List<int>(new int[N/2]), secondlimit = new List<int>(new int[N/2]);
            long f = 0;
            firstlimit[0] = (sumeven[1] > sumodd[1]) ? 0 : -1;//evenをA[i]まで数える
            for (int i = 1; i < N/2; i++)
            {
                if(sumeven[i+1]< sumeven[firstlimit[i-1] +1]+
                    (sumodd[i+1]- sumodd[firstlimit[i - 1] +1]))
                {
                    firstlimit[i] = firstlimit[i-1];
                }
                else
                {
                    firstlimit[i] = i;
                }
            }
            if (N%2==0)
            {
                long ans;
                ans = Math.Max(sumeven[N / 2],
                    sumeven[firstlimit[N / 2 - 1] + 1] +
                    (sumodd[N / 2] - sumodd[firstlimit[N / 2 - 1] + 1]));
                Console.WriteLine(ans);

            }
            /*else
            {
                var sumevenI = sumeven.Select(x => (sumeven[sumeven.Count() - 1] - x)).ToList();
                sumevenI.Reverse();
                var sumoddI = sumodd.Select(x => (sumodd[sumodd.Count() - 1] - x)).ToList();
                sumoddI.Reverse();

                secondlimit[0] = (sumevenI[1] > sumodd[1]) ? 0 : -1;//evenをA[i]まで数える
                for (int i = 1; i < N / 2; i++)
                {
                    if (sumevenI[i + 1] < sumeven[secondlimit[i - 1] + 1] +
                        (sumoddI[i + 1] - sumoddI[secondlimit[i - 1] + 1]))
                    {
                        secondlimit[i] = secondlimit[i - 1];
                    }
                    else
                    {
                        secondlimit[i] = i;
                    }
                }
                long ans = long.MinValue;
                for (int i = 0; i < N/2; i++)
                {
                    if (N / 2 - firstlimit[i] - 2 < 0)
                    {
                        ans = Math.Max(ans, sumeven[N / 2 - 1]);
                    }
                    else
                    {
                        long a = sumeven[firstlimit[i] + 1];
                        long b = +sumevenI[secondlimit[N / 2 - firstlimit[i] - 2] + 1] + sumoddI[N / 2 - firstlimit[i] - 1];
                       long c=- sumoddI[secondlimit[N / 2 - firstlimit[i]] + 1];
                        ans = Math.Max(a, ans);
                    }
                }
                Console.WriteLine(ans);
            }*/
            //long ans = long.MinValue;
            


        }
        static long power(long a, long b, long modulo)
        {
            long result = 1;
            long buff = a;
            for (int i = 1; i <= b; i *= 2)
            {
                result = result * ((b / i % (2) == 1) ? buff : 1)%modulo;
                buff =(buff * buff)%modulo;
            }
            return result%modulo;
        }

    }
}