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 Haskell (GHC 8.8.3) (judge verdict: Wrong Answer)

import Data.Maybe
import Data.List
import qualified Data.ByteString.Char8 as C

parseInt :: C.ByteString -> Int
parseInt = fst . fromJust . C.readInt

data State = State
  { stOrd :: Ordering,
    stHas :: Bool,
    stOpt :: Integer
  } deriving (Show)

instance Eq State where
  (==) (State o1 h1 _) (State o2 h2 _) = o1 == o2 && h1 == h2

stPlus :: State -> State -> Integer
stPlus (State _ _ v1) (State _ _ v2) = v1 + v2

isOk :: State -> Bool
isOk (State EQ _ _) = True
isOk _ = False

reduceStates :: [State] -> Integer
reduceStates states = maximum $ (0 : (map stOpt $ filter isOk states))

isMatch :: State -> State -> Bool
isMatch (State o1 _ _) (State o2 _ _) =
  case (o1, o2) of
    (EQ, EQ) -> True
    (LT, GT) -> True
    (GT, LT) -> True
    _ -> False

match :: [State] -> [State] -> Integer
match [] [] = 0
match [] ss = match ss []
match ss [] = reduceStates ss
match ss1 ss2 = maximum $ 0 : [stPlus s t | s <- ss1, t <- ss2, isMatch s t]

f :: [Integer] -> [[State]]
f [] = []
f [x] = [[State LT False 0, State GT True x]]
f (x : xs) =
  foldl' merge [] (ss' >>= trans) : ss' : sss'
  where
  (ss' : sss') = f xs
  trans (State ord has opt) =
    if has
      then case ord of
        LT -> []
        GT -> [State EQ False opt]
        EQ -> [State LT False opt]
      else case ord of
        LT -> [State EQ True (opt + x)]
        GT -> [State EQ False opt]
        EQ -> [State GT True (opt + x), State LT False opt]
  merge states state =
    case partition (==state) states of
      ([], _) -> state : states
      ([State ord' has' opt'], states') -> State ord' has' (max opt' $ stOpt state) : states'
      _ -> error ""

main :: IO ()
main = do
  n <- parseInt <$> C.getLine
  as <- map (fromIntegral . parseInt) . C.words <$> C.getLine
  let s = f as
      t = reverse $ f $ reverse as
      ans = if n `mod` 2 == 0
        then reduceStates $ head s
        else maximum $ zipWith match (tail s ++ [[]]) ([] : init t)
  putStrLn $ show ans