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 Rust (1.42.0) (judge verdict: Wrong Answer)

macro_rules !read_value {($iter :expr ,($($t :tt ) ,*) ) =>{($(read_value !($iter ,$t ) ) ,*) } ;($iter :expr ,[$t :tt ;$len :expr ] ) =>{(0 ..$len ) .map (|_ |read_value !($iter ,$t ) ) .collect ::<Vec <_ >>() } ;($iter :expr ,{chars :$base :expr } ) =>{read_value !($iter ,String ) .chars () .map (|c |(c as u8 -$base as u8 ) as usize ) .collect ::<Vec <usize >>() } ;($iter :expr ,{char :$base :expr } ) =>{read_value !($iter ,{chars :$base } ) [0 ] } ;($iter :expr ,chars ) =>{read_value !($iter ,String ) .chars () .collect ::<Vec <char >>() } ;($iter :expr ,char ) =>{read_value !($iter ,chars ) [0 ] } ;($iter :expr ,usize1 ) =>{read_value !($iter ,usize ) -1 } ;($iter :expr ,$t :ty ) =>{$iter .next () .unwrap () .parse ::<$t >() .unwrap () } ;}
macro_rules !input_inner {($iter :expr ) =>{} ;($iter :expr ,) =>{} ;($iter :expr ,mut $var :ident :$t :tt $($r :tt ) *) =>{let mut $var =read_value !($iter ,$t ) ;input_inner !{$iter $($r ) *} } ;($iter :expr ,mut $var :ident $($r :tt ) *) =>{input_inner !{$iter ,mut $var :usize $($r ) *} } ;($iter :expr ,$var :ident :$t :tt $($r :tt ) *) =>{let $var =read_value !($iter ,$t ) ;input_inner !{$iter $($r ) *} } ;($iter :expr ,$var :ident $($r :tt ) *) =>{input_inner !{$iter ,$var :usize $($r ) *} } ;}
macro_rules !input {(source =$s :expr ,$($r :tt ) *) =>{let mut iter =$s .split_whitespace () ;input_inner !{iter ,$($r ) *} } ;(iter =$iter :ident ,$($r :tt ) *) =>{let s ={use std ::io ::Read ;let mut s =String ::new () ;std ::io ::stdin () .read_to_string (&mut s ) .unwrap () ;s } ;let mut $iter =s .split_whitespace () ;input_inner !{$iter ,$($r ) *} } ;($($r :tt ) *) =>{let s ={use std ::io ::Read ;let mut s =String ::new () ;std ::io ::stdin () .read_to_string (&mut s ) .unwrap () ;s } ;let mut iter =s .split_whitespace () ;input_inner !{iter ,$($r ) *} } ;}
fn main() {
    input! { n, a: [i64; n] };
    let s = a.iter().sum::<i64>();
    if n % 2 == 0 {
        let mut c = 0;
        for i in 0..n {
            if i % 2 == 0 {
                c += a[i];
            }
        }
        println!("{}", std::cmp::max(s - c, c));
    } else {
        // let mut dp = vec![vec![vec![std::i64::MIN; 2]; 2]; n + 1];
        // dp[0][0][0] = 0;
        // dp[0][0][1] = 0;
        // dp[0][1][0] = 0;
        // dp[0][1][1] = 0;
        // for i in 0..n {
        //     let ni = i + 1;
        //     dp[ni][0][0] = dp[i][1][0];
        //     dp[ni][0][1] = std::cmp::max(dp[i][0][0], dp[i][1][1]);
        //     if dp[i][0][0] > std::i64::MIN {
        //         dp[ni][1][0] = dp[i][0][0] + a[i];
        //     }
        //     if dp[i][0][1] > std::i64::MIN {
        //         dp[ni][1][1] = dp[i][0][1] + a[i];
        //     }
        // }
        // println!("{}", std::cmp::max(dp[n][0][1], dp[n][1][1]));
        let mut dp = vec![vec![vec![std::i64::MIN; 2]; 4]; n + 1];
        dp[0][2][0] = 0;
        dp[0][2][1] = 0;
        for i in 0..n {
            let ni = i + 1;
            for j in 1..4 {
                let nj = j - 1;
                for k in 0..2 {
                    dp[ni][nj][0] = std::cmp::max(dp[ni][nj][0], dp[i][j][k]);
                }
            }
            for j in 0..3 {
                let nj = j + 1;
                if dp[i][j][0] == std::i64::MIN {
                    continue;
                }
                dp[ni][nj][1] = std::cmp::max(dp[ni][nj][1], dp[i][j][0] + a[i]);
            }
        }
        println!("{}", std::cmp::max(dp[n][1][0], dp[n][1][1]));
    }
}