Problem:
Score : 600 points

Problem Statement

You are given an integer sequence of length N, a = {a_1, a_2, …, a_N}, and an integer K.

a has N(N+1)/2 non-empty contiguous subsequences, {a_l, a_{l+1}, …, a_r} (1 ≤ l ≤ r ≤ N). Among them, how many have an arithmetic mean that is greater than or equal to K?

Constraints

All input values are integers.

1 ≤ N ≤ 2 \times 10^5

1 ≤ K ≤ 10^9

1 ≤ a_i ≤ 10^9

Input

Input is given from Standard Input in the following format:

N K
a_1
a_2
:
a_N

Output

Print the number of the non-empty contiguous subsequences with an arithmetic mean that is greater than or equal to K.

Sample Input 1

3 6
7
5
7

Sample Output 1

5

All the non-empty contiguous subsequences of a are listed below:

{a_1} = {7}

{a_1, a_2} = {7, 5}

{a_1, a_2, a_3} = {7, 5, 7}

{a_2} = {5}

{a_2, a_3} = {5, 7}

{a_3} = {7}

Their means are 7, 6, 19/3, 5, 6 and 7, respectively, and five among them are 6 or greater. Note that {a_1} and {a_3} are indistinguishable by the values of their elements, but we count them individually.

Sample Input 2

1 2
1

Sample Output 2

0

Sample Input 3

7 26
10
20
30
40
30
20
10

Sample Output 3

13

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.IO;
using System.Linq;
using System.Collections.Generic;

public class Program
{

	public void Proc()
	{
        long[] inpt = Reader.ReadLine().Split(' ').Select(a => long.Parse(a)).ToArray();
        int inputCount = (int)inpt[0];
        this.Target = inpt[1];
        this.Items = new long[inputCount];
        long ans = 0;
        for (int i = 0; i < inputCount; i++) {
            this.Items[i] = long.Parse(Reader.ReadLine());
            if(this.Items[i] >= this.Target) {
                ans++;
                dic.Add(i, new Dictionary<int, long>());
                dic[i].Add(0, this.Items[i]);
            }
        }
        for (int i = 1; i <= inputCount - 1; i++) {
            int add = 0;
            int[] keys = dic.Keys.ToArray();
            foreach(int key in keys) {
                if(key + i < inputCount && dic[key].ContainsKey(i-1) && (!dic[key].ContainsKey(i))) {
                    long tmp = dic[key][i - 1] + this.Items[key + i];
                    if(tmp >= Target * (i+1)) {
                        add++;
                        dic[key][i] = tmp;
                        if(!dic.ContainsKey(key+i)) {
                            dic.Add(key+i, new Dictionary<int, long>());
                        }
                        dic[key + i][i * -1] = tmp;
                    }
                }
                int idx = i * -1;
                if(key - i >= 0 && (dic[key].ContainsKey(idx+1)) && (!dic[key].ContainsKey(idx))) {
					long tmp = dic[key][idx+1] + this.Items[key + idx];
					if (tmp >= Target * (i + 1))
					{
                        add++;
						dic[key][idx] = tmp;
						if (!dic.ContainsKey(key - i))
						{
							dic.Add(key - i, new Dictionary<int, long>());
						}
						dic[key - i][i] = tmp;
					}
				}
            }
            if(add == 0) {
                break;
            }
            ans += add;
        }
        Console.WriteLine(ans);

    }
    private long[] Items;
    private long Target = 0;
    private Dictionary<int, Dictionary<int, long>> dic = new Dictionary<int, Dictionary<int, long>>();

	public class Reader
	{
		private static StringReader sr;
		public static bool IsDebug = false;
		public static string ReadLine()
		{
			if (IsDebug)
			{
				if (sr == null)
				{
					sr = new StringReader(InputText.Trim());
				}
				return sr.ReadLine();
			}
			else
			{
				return Console.ReadLine();
			}
		}
		private static string InputText = @"



3 6
7
5
7


";
	}

	public static void Main(string[] args)
	{
#if DEBUG
		Reader.IsDebug = true;
#endif
		Program prg = new Program();
		prg.Proc();
	}
}