Problem:
Score : 600 points

Problem Statement

Given are a sequence of N integers A_1, A_2, \ldots, A_N and a positive integer S.

For a pair of integers (L, R) such that 1\leq L \leq R \leq N, let us define f(L, R) as follows:

f(L, R) is the number of sequences of integers (x_1, x_2, \ldots , x_k) such that L \leq x_1 < x_2 < \cdots < x_k \leq R and A_{x_1}+A_{x_2}+\cdots +A_{x_k} = S.

Find the sum of f(L, R) over all pairs of integers (L, R) such that 1\leq L \leq R\leq N. Since this sum can be enormous, print it modulo 998244353.

Constraints

All values in input are integers.

1 \leq N \leq 3000

1 \leq S \leq 3000

1 \leq A_i \leq 3000

Input

Input is given from Standard Input in the following format:

N S
A_1 A_2 ... A_N

Output

Print the sum of f(L, R), modulo 998244353.

Sample Input 1

3 4
2 2 4

Sample Output 1

5

The value of f(L, R) for each pair is as follows, for a total of 5.

f(1,1) = 0

f(1,2) = 1 (for the sequence (1, 2))

f(1,3) = 2 (for (1, 2) and (3))

f(2,2) = 0

f(2,3) = 1 (for (3))

f(3,3) = 1 (for (3))

Sample Input 2

5 8
9 9 9 9 9

Sample Output 2

0

Sample Input 3

10 10
3 1 4 1 5 9 2 6 5 3

Sample Output 3

152

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

use std::convert::From;
use std::fs;
use std::io::{stdin, Read};
use std::ops::{Add, AddAssign, Mul, Sub};
use std::str::FromStr;
const MOD: usize = 998244353;

#[derive(Debug, Clone, Copy)]
struct musize {
    value: usize,
}

impl std::fmt::Display for musize {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(f, "{}", self.value)
    }
}

impl From<usize> for musize {
    fn from(item: usize) -> Self {
        musize { value: item }
    }
}

impl AddAssign for musize {
    fn add_assign(&mut self, other: Self) {
        *self = *self + other
    }
}

impl Add for musize {
    type Output = Self;
    fn add(self, other: Self) -> Self {
        musize {
            value: (self.value + other.value) % MOD,
        }
    }
}

impl Sub for musize {
    type Output = Self;
    fn sub(self, other: Self) -> Self {
        let value = if self.value >= other.value {
            (self.value - other.value) % MOD
        } else {
            MOD - ((other.value - self.value) % MOD)
        };
        musize { value: value }
    }
}

impl FromStr for musize {
    type Err = std::num::ParseIntError;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let v = s.parse::<usize>()?;
        Ok(musize { value: v })
    }
}

macro_rules! parse {
    ($it: ident) => {
        $it.next().unwrap().parse().unwrap()
    };
    ($it: ident,2) => {
        (parse!($it), parse!($it))
    };
    ($it: ident,3) => {
        (parse!($it), parse!($it), parse!($it))
    };
    ($it: ident,4) => {
        (parse!($it), parse!($it), parse!($it), parse!($it))
    };
    ($it: ident, $n: expr) => {
        (&mut $it).take($n).map(|e| e.parse().unwrap()).collect();
    };
}

fn solve(s: &str) {
    let mut it = s.split_whitespace();
    let (n, s): (usize, usize) = parse!(it, 2);
    let a: Vec<usize> = parse!(it, n);
    let mut dp: Vec<Vec<Vec<musize>>> = vec![vec![vec![0.into(); 3]; s + 1]; n + 1];
    dp[0][0][0] = 1.into();
    for i in 0..n {
        for j in 0..(s + 1) {
            dp[i + 1][j][0] = dp[i][j][0];
            dp[i + 1][j][1] += dp[i][j][1] + dp[i][j][0];
            dp[i + 1][j][2] += dp[i][j][2] + dp[i][j][1] + dp[i][j][0];
            if j + a[i] <= s {
                dp[i + 1][j + a[i]][1] += dp[i][j][1] + dp[i][j][0];
                dp[i + 1][j + a[i]][2] += dp[i][j][1] + dp[i][j][0];
            }
        }
    }
    println!("{}", dp[n][s][2]);
}

fn test() {
    let mut f = fs::File::open("foo.txt").unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();
    solve(&s);
}

fn main() {
    let mut s = String::new();
    stdin().read_to_string(&mut s).unwrap();
    solve(&s);
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_main() {
        test();
    }
    #[test]
    fn test_input() {
        let s = "
        ";
        solve(s);
    }
}