Problem:
Score : 100 points

Problem Statement

There are N children, numbered 1, 2, \ldots, N.

They have decided to share K candies among themselves.
Here, for each i (1 \leq i \leq N), Child i must receive between 0 and a_i candies (inclusive).
Also, no candies should be left over.

Find the number of ways for them to share candies, modulo 10^9 + 7.
Here, two ways are said to be different when there exists a child who receives a different number of candies.

Constraints

All values in input are integers.

1 \leq N \leq 100

0 \leq K \leq 10^5

0 \leq a_i \leq K

Input

Input is given from Standard Input in the following format:

N K
a_1 a_2 \ldots a_N

Output

Print the number of ways for the children to share candies, modulo 10^9 + 7.

Sample Input 1

3 4
1 2 3

Sample Output 1

5

There are five ways for the children to share candies, as follows:

(0, 1, 3)

(0, 2, 2)

(1, 0, 3)

(1, 1, 2)

(1, 2, 1)

Here, in each sequence, the i-th element represents the number of candies that Child i receives.

Sample Input 2

1 10
9

Sample Output 2

0

There may be no ways for the children to share candies.

Sample Input 3

2 0
0 0

Sample Output 3

1

There is one way for the children to share candies, as follows:

(0, 0)

Sample Input 4

4 100000
100000 100000 100000 100000

Sample Output 4

665683269

Be sure to print the answer modulo 10^9 + 7.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
	static long  MOD = 1000000007;

	static void updateBIT(long bit[], int i, long val)
	{
		while(i<bit.length)
		{
			bit[i]+=val;
			bit[i]=bit[i]%MOD;
			i+=(i&(-i));
		}
	}

	static long queryBIT(long bit[], int i)
	{
		long ans=0;
		while(i>0)
		{
			ans+=bit[i];
			i-=(i&(-i));
			ans=ans%MOD;
		}
		return ans;
	}

	public static void main(String[] args)
	{
		FastReader scan=new FastReader();
		int n=scan.nextInt();
		int k=scan.nextInt();

		int ar[]=new int[n];
		for(int i=0;i<n;i++)
			ar[i]=scan.nextInt();

		/*
		dp=new Long[n+1][k+1];
		System.out.println(numOfWays(ar, n, k));
		*/

		long dp[][]=new long[n+1][k+1];

		for(int i=0;i<=n;i++)
			dp[i][0]=1;

		long bit[][]=new long[n+1][k+2];

		for(int i=0;i<=n;i++)
			updateBIT(bit[i], 1, 1);

		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=k;j++)
			{
				int st=Math.max(0, j-ar[i-1]);
				int end=j;

				dp[i][j] = (queryBIT(bit[i-1], end+1)-queryBIT(bit[i-1], st)+MOD)%MOD;
				updateBIT(bit[i], j+1, dp[i][j]);
			}
		}

		System.out.println(dp[n][k]);

	}
}


 class FastReader
{
    BufferedReader br;
    StringTokenizer st;
 
    public FastReader()
    {
        br = new BufferedReader(new
                InputStreamReader(System.in));
    }
 
    String next()
    {
        while (st == null || !st.hasMoreElements())
        {
            try
            {
                st = new StringTokenizer(br.readLine());
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }
 
    int nextInt()
    {
        return Integer.parseInt(next());
    }
 
    long nextLong()
    {
        return Long.parseLong(next());
    }
 
    double nextDouble()
    {
        return Double.parseDouble(next());
    }
 
    String nextLine()
    {
        String str = "";
        try
        {
            str = br.readLine();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
        return str;
    }
}