Problem:
問題 6: 小籠包 (Xiao Long Bao)

問題

JOI 君はお昼ごはんに，中華料理屋で小籠包を食べることにした．
小籠包とは，具と熱いスープを小麦粉の皮で包んだ料理であり，食べるときにスープが周囲に飛び散ることで知られている．

JOI 君が注文した小籠包のセットは，具やスープの異なる N 個の小籠包からなる．
N 個の小籠包は等間隔に一列に並んでおり，順番に 1 から N の番号がつけられている．
i 番目の小籠包と j 番目の小籠包の間の距離は絶対値 |i - j| である．

JOI 君は小籠包をある順番で食べていく．
最初，すべての小籠包のおいしさは 0 である．
i 番目の小籠包を食べると，周囲にその汁が飛び散り，まだ食べられていない小籠包のうち，小籠包 i からの距離が Di 以下の小籠包に汁がかかる．汁がかかった小籠包はおいしさが
Ai 増える．すなわち， i 番目の小籠包を食べたときに，
j 番目の小籠包 (1 ≤ j ≤ N かつ i - Di ≤ j ≤ i + Di) がまだ食べられずに残っているならば，
j 番目の小籠包のおいしさが Ai 増える．

JOI 君は，食べる順番を工夫することで，食べる小籠包のおいしさの合計を最大化したい．
もっとも良い順番で食べたときの，JOI 君が食べる小籠包のおいしさの合計を求めるプログラムを作成せよ．

入力

入力ファイルは 3 行からなる．

1 行目には 1 つの整数 N (1 ≤ N ≤ 100) が書かれている．

2 行目には， N 個の整数 D1, D2, ..., DN (0 ≤ Di ≤ 7) が空白を区切りとして書かれている．

3 行目には， N 個の整数 A1, A2, ..., AN (0 ≤ Ai ≤ 1000) が空白を区切りとして書かれている．

出力

JOI 君が食べる小籠包のおいしさの合計の最大値を 1 行で出力せよ．

入出力例

入力例 1

5
1 0 1 1 2
0 2 6 3 4

出力例 1

20

入出力例 1 では，5 番目 → 3 番目 → 1 番目 → 2 番目 → 4 番目 の順番で食べると，
おいしさの合計が 20 になる．合計が 20 を超えるような食べ方は存在しないので，これが最善である．

入力例 2

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

出力例 2

237

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in Rust (judge verdict: Accepted)

#[allow(unused_imports)]
use std::io::{stdin, Read, StdinLock};
#[allow(unused_imports)]
use std::cmp::{max, min, Ordering};
#[allow(unused_imports)]
use std::str::FromStr;
#[allow(unused_imports)]
use std::collections::{HashSet, HashMap, BinaryHeap, VecDeque};
#[allow(unused_imports)]
use std::vec::Vec;

struct Scanner<'a> {
    cin: StdinLock<'a>,
}

#[allow(dead_code)]
impl<'a> Scanner<'a> {
    fn new(cin: StdinLock<'a>) -> Scanner<'a> {
        Scanner {cin: cin}
    }
    fn read1<T: FromStr>(&mut self) -> Option<T> {
        let token = self.cin.by_ref().bytes().map(|c| c.unwrap() as char)
                    .skip_while(|c| c.is_whitespace())
                    .take_while(|c| !c.is_whitespace())
                    .collect::<String>();
        token.parse::<T>().ok()
    }
    fn read<T: FromStr>(&mut self) -> T {
        self.read1().unwrap()
    }
}

#[allow(dead_code)]
fn next_permutation<T: Ord>(v: &mut Vec<T>) -> bool {
    if v.len() == 0 || v.len() == 1 {
        return false
    }
    let mut i: usize = v.len() - 1;
    let n = v.len();
    loop {
        let ii = i;
        i -= 1;
        if v[i].cmp(&v[ii]) == Ordering::Less {
            let mut j = n - 1;
            while v[i].cmp(&v[j]) != Ordering::Less {
                j -= 1;
            }
            v.swap(i, j);
            for k in 0..(n - ii) / 2 { // reverse
                v.swap(ii + k, n - k - 1);
            }
            return true
        }
        if i == 0 { // i == first
            v.reverse();
            return false
        }
    }
}

fn main() {
    let cin = stdin();
    let cin = cin.lock();
    let mut sc = Scanner::new(cin);

    let n: usize = sc.read();
    let mut d: Vec<usize> = vec![0; n];
    let mut a: Vec<usize> = vec![0; n];
    for i in 0..n {
        d[i] = sc.read();
    }
    for i in 0..n {
        a[i] = sc.read();
    }
    let d = d;
    let a = a;

    let mut dp: Vec<HashMap<Vec<usize>, usize>> = vec![HashMap::new(); n];
    let mut perm: Vec<usize> = (0..7).collect();
    while {
        dp[0].insert(perm.clone(), 0);
        next_permutation(&mut perm)
    } {}

    for i in 0..n-1 {
        let mut nxt: HashMap<Vec<usize>, usize> = HashMap::new();
        for (p, r) in &mut dp[i] {
            let mut np: Vec<usize> = vec![0; 7];
            for j in 0..6 {
                np[j] = p[j + 1];
                if p[0] > p[j + 1] {
                    np[j] += 1;
                }
            }
            for _j in 0..7 {
                let mut rr = *r;
                for kk in 0..6 {
                    if i >= kk {
                        if np[6 - kk - 1] < np[6] && d[i - kk] >= kk + 1 {
                            rr += a[i - kk];
                        }
                        if np[6 - kk - 1] > np[6] && d[i + 1] >= kk + 1 {
                            rr += a[i + 1];
                        }
                    }
                }
                if i >= 6 && p[0] == np[6] {
                    let t1 = if d[i - 6] == 7 { a[i - 6] } else { 0 };
                    let t2 = if d[i + 1] == 7 { a[i + 1] } else { 0 };
                    rr += max(t1, t2);
                } else if i >= 6 && p[0] > np[6] {
                    rr += if d[i + 1] == 7 { a[i + 1] } else { 0 };
                } else if i >= 6 && p[0] < np[6] {
                    rr += if d[i - 6] == 7 { a[i - 6] } else { 0 };
                }
                if nxt.contains_key(&np) {
                    let r2: usize = *nxt.get(&np).unwrap();
                    nxt.insert(np.clone(), max(rr, r2));
                } else {
                    nxt.insert(np.clone(), rr);
                }
                np[6] += 1;
                for k in 0..6 {
                    if np[k] == np[6] {
                        np[k] -= 1;
                    }
                }
            }
        }
        dp[i + 1] = nxt;
    }

    println!("{}", dp[n - 1].iter().fold(0, |ans, (_, a)| max(ans, *a)));
}