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 Rust (1.15.1) (judge verdict: Accepted)

use std::io::stdin;
use std::time::SystemTime;
use std::collections::HashMap;

#[allow(dead_code)]
fn read_line() -> String {
    let mut s = String::new();
    stdin().read_line(&mut s).unwrap();
    s.trim().to_string()
}

#[allow(dead_code)]
fn read<T>() -> T
where T: std::str::FromStr
{
    read_line().parse::<T>().ok().unwrap()
}

#[allow(dead_code)]
fn read_vec<T>() -> Vec<T>
where T: std::str::FromStr
{
    read_line().split(" ").map(|n| n.parse::<T>().ok().unwrap()).collect()
}

#[allow(dead_code)]
fn read_chars() -> Vec<char>
{
    read_line().chars().collect()
}

#[allow(dead_code)]
fn print_time() -> () {
    println!("{:?}", SystemTime::now());
}

#[allow(unused_variables)]
fn main() {
    read::<u64>();
    let mut v: Vec<u64> = read_vec();
    let mut group = vec![v];
    
    let mut count = 0;
    loop {
        for i in 0..group.len() {
            let g = group[i].clone();
            if g.contains(&0) {
                if g.len() == 1 {
                    continue;
                }
                let mut t = vec![];
                for n in g {
                    if n == 0 {
                        if t.len() > 0 {
                            group.push(t);
                            t = vec![];
                        }
                    } else {
                        t.push(n);
                    }
                }
                if t.len() > 0 {
                    group.push(t);
                }
                group[i] = vec![0];
            }
        }
        
        for mut g in &mut group {
            let mut min = g[0];
            for i in 0..g.len() {
                let v = g[i];
                if min > v {
                    min = v;
                }
            }
            for i in 0..g.len() {
                g[i] = g[i] - min;
            }
            count = count + min;
        }
        if group.iter().all(|v| v == &[0]) {
            break;
        }
    }
    println!("{}", count);
}