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 Java8 (OpenJDK 1.8.0) (judge verdict: Time Limit Exceeded)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class Main {
    static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));  
    static PrintWriter out=new PrintWriter(new OutputStreamWriter(System.out));  
      
    public static int nextInt()throws IOException {in.nextToken();return (int)in.nval;}  
    public static long nextLong()throws IOException {in.nextToken(); return (long)in.nval;}
    public static String next()throws IOException {in.nextToken();return (String)in.sval;}

	static int[] a = new int[200100];
	static int[] num = new int[200100];
	static int[] b = new int[200100];
	static long[] sum = new long[200100];
	static long[] c = new long[200100];

    public static void main(String[] args) throws IOException {
    	int n = nextInt(), k = nextInt();
    	num[1] = 1;
    	for (int i = 2; i <= n + 1; i++) {
    		sum[i] = sum[i - 1] + nextInt() - k;
    		num[i] = i;
    	} 
    	qsort(1, n + 1);
    	for (int i = 1; i <= n + 1; i++)
    		b[num[i]] = i;
    	long ans = 0;
    	for (int i = 1; i <= n + 1; i++) {
			int p = b[i];
			while (p > 0) {
				ans += c[p];
				p -= lowbit(p);
			}
			p = b[i];
			while (p <= n + 1) {
				c[p]++;
				p += lowbit(p);
			}
		}
    	out.println(ans);
    	out.flush();
    	out.close();
    }
    public static int lowbit(int x) {
    	return x & -x;
    }
    public static void qsort(int s, int t) {
    	long x = sum[(s + t) / 2];
    	int y = num[(s + t) / 2];
    	int i = s, j = t;
    	while (i < j) {
    		while (sum[i] < x || sum[i] == x && num[i] < y) i++;
    		while (sum[j] > x || sum[j] == x && num[j] > y) j--;
    		if (i <= j) {
    			long k = sum[i];
    			sum[i] = sum[j];
    			sum[j] = k;
    			int p = num[i];
    			num[i] = num[j];
    			num[j] = p;
    			i++;
    			j--;
    		}
    	}
    	if (i < t) qsort(i, t);
    	if (s < j) qsort(s, j);
    }
}