Problem:
Daruma Otoshi

You are playing a variant of a game called "Daruma Otoshi (Dharma Block Striking)".

At the start of a game, several wooden blocks of the same size but with varying weights
are stacked on top of each other, forming a tower.
Another block symbolizing Dharma is placed atop.
You have a wooden hammer with its head thicker than the height of a block,
but not twice that.

You can choose any two adjacent blocks, except Dharma on the top,
differing at most 1 in their weight,
and push both of them out of the stack with a single blow of your hammer.
The blocks above the removed ones then fall straight down,
without collapsing the tower.

You cannot hit a block pair with weight difference of 2 or more,
for that makes too hard to push out blocks while keeping the balance of the tower.
There is no chance in hitting three blocks out at a time,
for that would require superhuman accuracy.

The goal of the game is to remove as many blocks as you can.
Your task is to decide the number of blocks that can be removed
by repeating the blows in an optimal order.

Figure D1. Striking out two blocks at a time

In the above figure, with a stack of four blocks weighing 1, 2, 3, and
1, in this order from the bottom, you can hit middle
two blocks, weighing 2 and 3, out from the stack. The blocks above will
then fall down, and two blocks weighing 1 and the Dharma block will remain.
You can then push out the remaining pair of weight-1 blocks after that.

Input

The input consists of multiple datasets.
The number of datasets is at most 50.
Each dataset is in the following format.

n

w1 w2 … wn

n is the number of blocks, except Dharma on the top.
n is a positive integer not exceeding 300.
wi gives the weight of the i-th block counted from the bottom.
wi is an integer between 1 and 1000, inclusive.

The end of the input is indicated by a line containing a zero.

Output

For each dataset, output in a line the maximum number of blocks you can remove.

Sample Input

4
1 2 3 4
4
1 2 3 1
5
5 1 2 3 6
14
8 7 1 4 3 5 4 1 6 8 10 4 6 5
5
1 3 5 1 3
0

Output for the Sample Input

4
4
2
12
0

Solution in Rust (judge verdict: Accepted)

use std::cmp::*;
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::io::*;
use std::str::FromStr;
use std::string::String;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();

    token.parse().ok().expect("failed to parse token")
}

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct Rev<T>(pub T);

impl<T: PartialOrd> PartialOrd for Rev<T> {
    fn partial_cmp(&self, other: &Rev<T>) -> Option<std::cmp::Ordering> {
        other.0.partial_cmp(&self.0)
    }
}

impl<T: Ord> Ord for Rev<T> {
    fn cmp(&self, other: &Rev<T>) -> std::cmp::Ordering {
        other.0.cmp(&self.0)
    }
}

struct DP {
    w: Vec<i32>,
    memo: Vec<Vec<i32>>,
}

impl DP {
    fn new(n: usize, w: Vec<i32>) -> Self {
        DP {
            w: w,
            memo: vec![vec![-1; n + 10]; n + 10],
        }
    }

    fn dfs(&mut self, l: usize, r: usize) -> i32 {
        if self.memo[l][r] != -1 {
            return self.memo[l][r];
        }

        if r - l <= 1 {
            return 0;
        }

        let mut res = 0i32;

        if (self.w[l] - self.w[r - 1]).abs() <= 1 && self.dfs(l + 1, r - 1) == (r - l - 2) as i32 {
            res = (r - l) as i32;
        }

        for mid in l + 1..r {
            res = max(res, self.dfs(l, mid) + self.dfs(mid, r));
        }

        self.memo[l][r] = res;

        return self.memo[l][r];
    }
}

fn main() {
    loop {
        let n: usize = read();
        if n == 0 {
            return;
        }

        let w: Vec<i32> = (0..n).map(|_| read()).collect();
        let mut dp = DP::new(n, w);

        dp.dfs(0, n);

        println!("{}", dp.memo[0][n]);
    }
}