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 Control.Monad
import Data.Maybe
import Debug.Trace
import Data.List
import qualified Data.Map.Strict as Map
import qualified Data.IntMap.Strict as IntMap
import qualified Data.Set as Set
import qualified Data.IntSet as IntSet
import Data.Functor
import Data.Array

main :: IO ()
main = do
  n <- readLn :: IO Int
  ss <- fmap (map read . words) getLine :: IO [Int]
  print $ solve ss

solve :: [Int] -> Int
solve hs 
  | all (==0) hs = 0
  | otherwise = 1 + (solve $ deleteSucceeding i m hs)
  where 
    (i, m) = maximumIndex hs
    deleteSucceeding :: Int -> Int -> [Int] -> [Int]
    deleteSucceeding i m hs = a ++ (delete b)
      where
        (a,b) = splitAt i hs
        delete [] = []
        delete (b:bs)
          | b == m = (b-1):(delete bs)
          | otherwise = (b:bs)
  
maximumIndex :: [Int] -> (Int, Int)
maximumIndex xs = go 0 0 0 xs
  where
    go _ i m [] = (i, m)
    go currentIndex i m (y:ys)
      | m < y = go (currentIndex + 1) currentIndex y ys
      | otherwise = go (currentIndex + 1) i m ys