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 Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)


import java.util.Arrays;
import java.util.Scanner;

public class Main {
    private static final long MOD = 998_244_353;

    public static void main(final String[] args) {
        final Scanner scanner = new Scanner(System.in);
        final int n = scanner.nextInt();
        final int s = scanner.nextInt();

        final int[] a = new int[n];
        for (int i = 0; i < n; i++) {
            a[i] = scanner.nextInt();
        }

        final long[][] dpTable = new long[n][s];
        long count = 0;
        if (a[0] < s) {
            dpTable[0][a[0]] = 1;
        } else if (a[0] == s) {
            count = n;
        }

        for (int i = 1; i < n; i++) {
            // a[i]を選ばない場合
            System.arraycopy(dpTable[i - 1], 0, dpTable[i], 0, s);

            // a[i] が s を超過した場合何もしない
            if (a[i] > s) {
                continue;
            }
            // a[i] が s だと，a[i] を含む全ての区間の組み合わせを足す
            else if (a[i] == s) {
                count = (count + (i + 1) * (n - i)) % MOD;
                continue;
            }

            // a[i] を足して s になる場合，始点の距離の総数 * 終点の距離の総数を足せる
            if (dpTable[i - 1][s - a[i]] != 0) {
                count = (count + dpTable[i - 1][s - a[i]] * (n - i)) % MOD;
            }

            // a[i] を選ぶ場合
            for (int j = 1; j < s - a[i]; j++) {
                if (dpTable[i - 1][j] == 0) {
                    continue;
                }
                //
                dpTable[i][j + a[i]] += dpTable[i - 1][j];
            }

            // 新たに始点を始める場合
            dpTable[i][a[i]] += i + 1;
        }

        System.out.println(count);
    }
}