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-csc 3.5.0) (judge verdict: Wrong Answer)

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

namespace Contest
{
    class Program
    {
        static void Main(string[] args)
        {
            ABC162.F();
        }

        class ABC162
        {
            public static void A()
            {
                var N = Read.Int();
                Console.WriteLine(N%10 == 7 || N/100==7 || (N/10)%10==7 ? "Yes":"No");
            }
            public static void B()
            {
                var N = Read.Int();
                long sum = 0;
                for(int i = 1; i <= N; ++i)
                {
                    if (i % 3 > 0 && i % 5 > 0) { sum += i; }
                }
                Console.WriteLine(sum);
            }
            public static void C()
            {
                var K = Read.Int();
                long sum = 0;
                for(int a = 1; a <= K; ++a)
                {
                    for(int b = 1; b <= K; ++b)
                    {
                        for(int c = 1; c <= K; ++c)
                        {
                            sum += Util.GCD(a, Util.GCD(b, c));
                        }
                    }
                }
                Console.WriteLine(sum);
            }
            public static void D()
            {
                var N = Read.Int();
                var S = Read.Str();
                var Freq = Util.Frequency(S.ToArray());
                var R = Freq.ContainsKey('R') ? Freq['R'] : 0;
                var G = Freq.ContainsKey('G') ? Freq['G'] : 0;
                var B = Freq.ContainsKey('B') ? Freq['B'] : 0;
                long total = (long)R * G * B;
                if (total == 0) { Console.WriteLine(0); return; }
                for(int d = 1; d < 2000; ++d)
                {
                    for(int s = 0; s < 4000; ++s)
                    {
                        var s2 = s + d;
                        var s3 = s + d * 2;
                        if (s3 >= N) { break; }
                        if(S[s]!=S[s2] && S[s] != S[s3]&& S[s2] != S[s3]) { total--; }
                    }
                }
                Console.WriteLine(total);
            }
            public static void E()
            {
                var N = Read.Int();
                var K = Read.Long();
                MOD[] counter = new MOD[K + 1];
                for(long i = K; i > K / 2; --i)
                {
                    counter[i] = 1;
                }
                for(long i = K / 2; i >= 1; --i)
                {
                    long biggerC = 0;
                    MOD biggerS = 0;
                    for(int m = 2; ; ++m)
                    {
                        var j = i * m;
                        if (j > K) { break; }
                        biggerC++;
                        biggerS += counter[j];
                    }
                    MOD c = biggerC + 1;
                    counter[i] = c.Power(N) - biggerS;
                }
                MOD total = 0;
                for(int i = 1; i <= K; ++i)
                {
                    total += i * counter[i];
                }
                Console.WriteLine(total.V);
            }
            public static void F()
            {
                var N = Read.Int();
                var A = Read.LongN();
                if (N % 2 == 0)
                {
                    var v1 = Enumerable.Range(0, N / 2).Select(i => A[i * 2]).Sum();
                    var v2 = Enumerable.Range(0, N / 2).Select(i => A[i * 2 + 1]).Sum();
                    Console.WriteLine(Math.Max(v1, v2));
                    return;
                }
                var dp = new long[N, 4];
                dp[0, 0] = A[0];
                dp[2, 0] = A[0] + A[2];
                dp[1, 1] = A[1];
                dp[2, 2] = A[2];
                if (N > 3)
                {
                    dp[3, 1] = Math.Max(A[0], A[1]) + A[3];
                    //dp[3, 3] = A[3];
                }
                for (int i = 4; i < N; ++i)
                {
                    dp[i, 0] = dp[i - 2, 0] + A[i];
                    dp[i, 1] = Math.Max(dp[i - 2, 1], dp[i - 3, 0]) + A[i];
                    dp[i, 2] = Math.Max(dp[i - 2, 2], Math.Max(dp[i - 3, 1], dp[i - 4, 0])) + A[i];
                }
                Console.WriteLine(Math.Max(dp[N - 1, 2], Math.Max(dp[N - 2, 1], dp[N - 3, 0])));
            }
        }

        class Util
        {
            public static long[] ASum(long[] array)
            {
                var res = new long[array.Length + 1];
                for (int i = 0; i < array.Length; ++i)
                {
                    res[i + 1] = res[i] + array[i];
                }
                return res;
            }
            public static long GCD(long a, long b)
            {
                while (b > 0)
                {
                    var c = a % b;
                    a = b;
                    b = c;
                }
                return a;
            }
            public static Dictionary<T, int> Frequency<T>(T[] array)
            {
                var dict = new Dictionary<T, int>();
                foreach (var a in array)
                {
                    if (!dict.ContainsKey(a)) { dict.Add(a, 0); }
                    dict[a]++;
                }
                return dict;
            }
            public static long Inverse(long a, long p)
            {
                long b = p, c = 1, d = 0, e = 0, f = 0;
                while (b != 0)
                {
                    e = a / b;
                    f = b; b = a - e * b; a = f;
                    f = d; d = c - e * d; c = f;
                }
                c %= p;
                return c + (c < 0 ? p : 0);
            }

            public static long[] Facts(int n, long p)
            {
                var facts = new long[n + 1];
                facts[0] = 1;
                for (int i = 1; i <= n; ++i)
                {
                    facts[i] = (i * facts[i - 1]) % p;
                }
                return facts;
            }
            public static Func<int, int, long> Combin(int n, long P)
            {
                var fact = Facts(n, P);
                var inv = fact.Select(x => Inverse(x, P)).ToArray();
                return (N, M) =>
                {
                    if (N < 0 || N < M || M < 0) { return 0; }
                    return (((fact[N] * inv[M]) % P) * inv[N - M]) % P;
                };
            }
        }
        struct MOD
        {
            public static long P = 1000000007;
            public readonly long V;

            public MOD(long a) { this.V = a; }
            public static implicit operator MOD(long a) { return new MOD(a); }
            public static MOD operator +(MOD a, MOD b) { return new MOD((a.V + b.V) % P); }
            public static MOD operator -(MOD a, MOD b) { return new MOD((a.V - b.V + P) % P); }
            public static MOD operator *(MOD a, MOD b) { return new MOD((a.V * b.V) % P); }
            public static MOD operator /(MOD a, MOD b) { return new MOD((a.V * b.Inverse().V) % P); }
            //public MOD Inverse() { return Util.Inverse(V, P); }
            public MOD Inverse()
            {
                long a = V, p = P;
                long b = p, c = 1, d = 0, e = 0, f = 0;
                while (b != 0)
                {
                    e = a / b;
                    f = b; b = a - e * b; a = f;
                    f = d; d = c - e * d; c = f;
                }
                c %= p;
                return c + (c < 0 ? p : 0);
            }
            //public MOD Power(long n) { return Util.Power(V, n, P); }
            public MOD Power(long n)
            {
                long a = V, p = P;
                long res = 1;
                long mult = a;
                for (int i = 0; i < 40; ++i)
                {
                    if ((n & ((long)1 << i)) > 0)
                    {
                        res = (res * mult) % p;
                    }
                    mult = (mult * mult) % p;
                }
                return res;
            }

            public override string ToString() { return V.ToString(); }
        }


        static class Read
        {
            static Queue<string> queue = new Queue<string>();
            static void Enqueue() { var ss = Console.ReadLine().Split(' '); foreach (var s in ss) { queue.Enqueue(s); } }
            public static int Int() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt32(queue.Dequeue()); }
            public static long Long() { if (queue.Count == 0) { Enqueue(); } return Convert.ToInt64(queue.Dequeue()); }
            public static string Str() { if (queue.Count == 0) { Enqueue(); } return queue.Dequeue(); }
            public static int[] IntN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt32(s)).ToArray(); }
            public static long[] LongN() { return Console.ReadLine().Split(' ').Select(s => Convert.ToInt64(s)).ToArray(); }
            public static string[] StrN() { return Console.ReadLine().Split(' '); }
            public static Tuple<int, int>[] TupleInt(int n) { List<Tuple<int, int>> list = new List<Tuple<int, int>>(); for (int i = 0; i < n; ++i) { var ab = Read.IntN(); list.Add(new Tuple<int, int>(ab[0], ab[1])); } return list.ToArray(); }
            public static Tuple<long, long>[] TupleLong(int n) { List<Tuple<long, long>> list = new List<Tuple<long, long>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<long, long>(ab[0], ab[1])); } return list.ToArray(); }
            public static Tuple<string, string>[] TupleStr(int n) { List<Tuple<string, string>> list = new List<Tuple<string, string>>(); for (int i = 0; i < n; ++i) { var ab = Read.StrN(); list.Add(new Tuple<string, string>(ab[0], ab[1])); } return list.ToArray(); }
            public static Tuple<double, double>[] TupleDouble(int n) { List<Tuple<double, double>> list = new List<Tuple<double, double>>(); for (int i = 0; i < n; ++i) { var ab = Read.LongN(); list.Add(new Tuple<double, double>(ab[0], ab[1])); } return list.ToArray(); }
            public static long[,] LongMatrix(int r, int c)
            {
                var mat = new long[r, c];
                for (int i = 0; i < r; ++i)
                {
                    var x = Read.LongN();
                    for (int j = 0; j < c; ++j)
                    {
                        mat[i, j] = x[j];
                    }
                }
                return mat;
            }
            public static Dictionary<int, HashSet<int>> AdjacencyList(int N, int M, bool isDirectional = false)
            {
                Dictionary<int, HashSet<int>> dict = new Dictionary<int, HashSet<int>>();
                for (int i = 0; i <= N; ++i) { dict.Add(i, new HashSet<int>()); }
                for (int i = 0; i < M; ++i)
                {
                    var ab = Read.IntN(); dict[ab[0]].Add(ab[1]);
                    if (!isDirectional) { dict[ab[1]].Add(ab[0]); }
                }
                return dict;
            }
            public static Dictionary<int, Dictionary<int, long>> AdjacencyListWithWeight(int N, int M)
            {
                Dictionary<int, Dictionary<int, long>> dict = new Dictionary<int, Dictionary<int, long>>();
                for (int i = 0; i <= N; ++i)
                {
                    dict.Add(i, new Dictionary<int, long>());
                }
                for (int i = 0; i < M; ++i)
                {
                    var ab = Read.IntN();
                    dict[ab[0]].Add(ab[1], ab[2]);
                    dict[ab[1]].Add(ab[0], ab[2]);
                }
                return dict;
            }
        }
    }
}