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)

fn read_stdin() -> String {
    use std::io::Read;
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input).unwrap();
    input
}

fn scan<'a, I: Iterator<Item = &'a str>, T: std::str::FromStr>(tokens: &mut I) -> T {
    tokens.next().unwrap().parse().ok().unwrap()
}

fn vec<T, F: FnMut(usize) -> T>(n: usize, mut f: F) -> Vec<T> {
    (0..n).map(|i| f(i)).collect()
}

fn main() {
    let input = read_stdin();
    let tokens = &mut input.split_whitespace();
    let n: usize = scan(tokens);
    let a: Vec<i64> = vec(n, |_| scan(tokens));
    let mut c: Vec<i64> = vec![0; n + 2];
    for i in 0..n {
        c[i + 2] = c[i] + a[i];
    }
    if n % 2 == 0 {
        // find i which maximize (c[2 * i] - c[0]) + (c[n + 1] - c[2 * i + 1])
        let mut ans = c[n + 1] - c[1];
        for i in 1..=n / 2 {
            ans = std::cmp::max(ans, (c[2 * i] - c[0]) + (c[n + 1] - c[2 * i + 1]));
        }
        println!("{}", ans);
    } else {
        // find i, j which maximize (c[2 * i] - c[0]) + (c[2 * j + 1] - c[2 * i + 1]) + (c[n + 1] - c[2 * j + 2])
        let mut ans = c[n + 1] - c[2];
        let mut d = 0;
        for j in 1..=n / 2 {
            d = std::cmp::max(d + a[2 * j - 1], c[2 * j] - c[0]);
            ans = std::cmp::max(ans, d + c[n + 1] - c[2 * j + 2]);
        }
        println!("{}", ans);
    }
}