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: Accepted)

use std::io;
use std::collections::*;
#[allow(dead_code)]
fn read() -> String
{
    let mut res = String::new();
    io::stdin().read_line(&mut res).unwrap();
    res
}
#[allow(unused_macros)]
macro_rules! read 
{
    () => 
    {
        read().trim().parse().unwrap();       
    };
}
#[allow(dead_code)]
fn read_vec() -> Vec<i64>
{
    read().split_whitespace().map(|x| x.parse::<i64>().unwrap()).collect()
}
fn solve(a : &Vec<i64>, rem : usize, pos : usize, m : &mut HashMap<(usize, usize), i64>) -> i64
{
    let cur = (rem, pos);
    if let Some(val) = m.get(&cur)
    {
        return *val;
    }
    if rem == 0
    {
        m.insert(cur, 0);
        return 0;
    }
    if rem > (a.len() - pos + 1) / 2
    {
        m.insert(cur, std::i64::MIN);
        return std::i64::MIN;
    }
    let res = solve(a, rem, pos + 1, m).max(solve(a, rem - 1, pos + 2, m) + a[pos]);
    m.insert(cur, res);
    res
}
fn main()
{
    let (n, a, mut m) : (usize, Vec<i64>, HashMap<(usize, usize), i64>) = (read!(), read_vec(), HashMap::default());
    println!("{}", solve(&a, n / 2, 0, &mut m));
}