Problem:
Score : 300 points

Problem Statement

In a flower bed, there are N flowers, numbered 1,2,......,N. Initially, the heights of all flowers are 0.
You are given a sequence h=\{h_1,h_2,h_3,......\} as input. You would like to change the height of Flower k to h_k for all k (1 \leq k \leq N), by repeating the following "watering" operation:

Specify integers l and r. Increase the height of Flower x by 1 for all x such that l \leq x \leq r.

Find the minimum number of watering operations required to satisfy the condition.

Constraints

1 \leq N \leq 100

0 \leq h_i \leq 100

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
h_1 h_2 h_3 ...... h_N

Output

Print the minimum number of watering operations required to satisfy the condition.

Sample Input 1

4
1 2 2 1

Sample Output 1

2

The minimum number of watering operations required is 2.
One way to achieve it is:

Perform the operation with (l,r)=(1,3).

Perform the operation with (l,r)=(2,4).

Sample Input 2

5
3 1 2 3 1

Sample Output 2

5

Sample Input 3

8
4 23 75 0 23 96 50 100

Sample Output 3

221

Solution in Haskell (GHC 7.10.3) (judge verdict: Accepted)

import Data.List

data S = Up | Down | Other deriving (Eq)

countBandT :: Ord a => S -> [a] -> ([a],[a])
countBandT _ [] = ([],[])
countBandT status [a] | status == Up   = ([], [a])
                      | status == Down = ([], []) 
                      | otherwise = ([],[a])
countBandT Other (a:b:ls) | a < b = ((fst $ countBandT Up (b:ls)), snd $ countBandT Up (b:ls))
                          | a > b = ((fst $ countBandT Down (b:ls)), (a : (snd $ countBandT Down (b:ls))))
                          | otherwise = countBandT Other (b:ls)
countBandT status (a:b:ls) | status == Down && a < b = ((a : (fst $ countBandT Up (b:ls))), snd $ countBandT Up (b:ls))
                           | status == Up && a > b   = ((fst $ countBandT Down (b:ls)), (a : (snd $ countBandT Down (b:ls))))
                           | otherwise = countBandT status (b:ls)

water :: Int -> Int -> ([Int],[Int]) -> Int
water _ _ ([],[]) = 0
water count n (bs,ts) = n + (water (count+1) (n+(fst $ numOf count bs)-(fst $ numOf count ts)) (snd $ numOf count bs, snd $ numOf count ts))

numOf0 :: Int -> Int -> [Int] -> (Int,[Int])
numOf0 c _ [] = (c,[])
numOf0 c n (x:xs) | n == x    = numOf0 (c+1) n xs
                  | otherwise = (c,(x:xs))

numOf = numOf0 0

main :: IO ()
main = do
  n <- read <$> getLine :: IO Int
  hs <- map read.words <$> getLine :: IO [Int]
  let bt = countBandT Other hs
  putStrLn $ show $ (water 0 1 (sort $ fst bt, sort $ snd bt)) - 1