Problem:
Score : 600 points

Problem Statement

In Dwango Co., Ltd., there is a content distribution system named 'Dwango Media Cluster', and it is called 'DMC' for short.

The name 'DMC' sounds cool for Niwango-kun, so he starts to define DMC-ness of a string.

Given a string S of length N and an integer k (k \geq 3),
he defines the k-DMC number of S as the number of triples (a, b, c) of integers that satisfy the following conditions:

0 \leq a < b < c \leq N - 1

S[a] = D

S[b] = M

S[c] = C

c-a < k

Here S[a] is the a-th character of the string S. Indexing is zero-based, that is, 0 \leq a \leq N - 1 holds.

For a string S and Q integers k_0, k_1, ..., k_{Q-1}, calculate the k_i-DMC number of S for each i (0 \leq i \leq Q-1).

Constraints

3 \leq N \leq 10^6

S consists of uppercase English letters

1 \leq Q \leq 75

3 \leq k_i \leq N

All numbers given in input are integers

Input

Input is given from Standard Input in the following format:

N
S
Q
k_{0} k_{1} ... k_{Q-1}

Output

Print Q lines.
The i-th line should contain the k_i-DMC number of the string S.

Sample Input 1

18
DWANGOMEDIACLUSTER
1
18

Sample Output 1

1

(a,b,c) = (0, 6, 11) satisfies the conditions.

Strangely, Dwango Media Cluster does not have so much DMC-ness by his definition.

Sample Input 2

18
DDDDDDMMMMMCCCCCCC
1
18

Sample Output 2

210

The number of triples can be calculated as 6\times 5\times 7.

Sample Input 3

54
DIALUPWIDEAREANETWORKGAMINGOPERATIONCORPORATIONLIMITED
3
20 30 40

Sample Output 3

0
1
2

(a, b, c) = (0, 23, 36), (8, 23, 36) satisfy the conditions except the last one, namely, c-a < k_i.

By the way, DWANGO is an acronym for "Dial-up Wide Area Network Gaming Operation".

Sample Output 4

30
DMCDMCDMCDMCDMCDMCDMCDMCDMCDMC
4
5 10 15 20

Sample Output 4

10
52
110
140

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_imports)]
use std::io::{ self, Write };
use std::str::FromStr;
use std::cmp::{ min, max };
use std::collections::{ BinaryHeap, VecDeque };

#[allow(unused_macros)]
macro_rules! trace {
    ($var:expr) => {
        let _ = writeln!(&mut std::io::stderr(), ">>> {} = {:?}", stringify!($var), $var);
    };
    ($($args:expr),*) => { trace!(($($args),*)) }
}

#[allow(unused_macros)]
macro_rules! put {
    ($var:expr) => {
        let _ = writeln!(&mut std::io::stdout(), "{}", $var);
    };
    ($var:expr, $($args:expr),*) => {
        let _ = write!(&mut std::io::stdout(), "{} ", $var);
        put!($($args),*);
    };
}

/*
 * an implementation of https://qiita.com/hamko/items/92660ac5aed9df4d346d
 */
#[derive(Debug, Copy, Clone)]
struct DM {
    d: i64,
    m: i64,
    dm: i64
}

use std::ops;
impl ops::Add<DM> for DM {
    type Output = DM;
    fn add(self, rhs: DM) -> DM {
        DM {
            d: self.d + rhs.d,
            m: self.m + rhs.m,
            dm: self.dm + rhs.dm + self.d * rhs.m
        }
    }
}

impl DM {
    fn from_char(c: char) -> DM {
        match c {
            'D' => DM { d: 1, m: 0, dm: 0 },
            'M' => DM { d: 0, m: 1, dm: 0 },
            _ => DM { d: 0, m: 0, dm: 0 },
        }
    }

    fn inverse(self) -> DM {
        DM {
            d: -self.d,
            m: -self.m,
            dm: -self.dm + self.d * self.m
        }
    }

    fn e() -> DM {
        DM { d: 0, m: 0, dm: 0 }
    }
}

fn main() {
    let mut sc = Scanner::new();
    let n: usize = sc.cin();
    let s: String = sc.cin();
    let cs: Vec<_> = s.chars().collect();

    let mut memo = vec![];
    {
        let mut ac = DM::e();
        memo.push(ac);
        for &c in cs.iter() {
            let x = DM::from_char(c);
            ac = ac + x;
            memo.push(ac);
        }
        // trace!(memo);
    }

    let q: usize = sc.cin();
    for _ in 0..q {
        let k: usize = sc.cin();
        let mut ans: u64 = 0;
        for c in 2..n {
            if cs[c] == 'C' {
                if c+1 >= k {
                    let y = memo[c+1-k].inverse() + memo[c];
                    // trace!(c+1-k, c);
                    ans += y.dm as u64;
                } else {
                    let y = memo[c];
                    // trace!(c, y);
                    ans += y.dm as u64;
                }
            }
        }
        put!(ans);
    }
}

#[allow(dead_code)]
struct Scanner { stdin: io::Stdin, buffer: VecDeque<String>, }
#[allow(dead_code)]
impl Scanner {
    fn new() -> Scanner { Scanner { stdin: io::stdin(), buffer: VecDeque::new() } }
    fn reserve(&mut self) {
        while self.buffer.len() == 0 {
            let mut line = String::new();
            let _ = self.stdin.read_line(&mut line);
            for w in line.split_whitespace() {
                self.buffer.push_back(String::from(w));
            }
        }
    }
    fn cin<T: FromStr>(&mut self) -> T {
        self.reserve();
        match self.buffer.pop_front().unwrap().parse::<T>() {
            Ok(a) => a,
            Err(_) => panic!("parse err")
        }
    }
}