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 Rust (1.15.1) (judge verdict: Accepted)

fn main() {
	let mut s = String::new();
	use std::io::Read;
	std::io::stdin().read_to_string(&mut s).unwrap();
	let mut s = s.split_whitespace();
	let n: usize = s.next().unwrap().parse().unwrap();
	let k: i64 = s.next().unwrap().parse().unwrap();
	let a: Vec<_> = s.map(|a| a.parse::<i64>().unwrap() - k).collect();
	let mut cum: Vec<_> = vec![(0, 0)].into_iter().chain(a.iter().scan((0, 0u32), |s, a|{ *s = (s.0 + a, s.1 + 1); Some(*s) })).collect();
	cum.sort();
	let c: Vec<_> = {
		let mut r = vec![(0, 0); n + 1];
		let mut last = cum.first().unwrap().0;
		let mut j = 0;
		for (a, i) in cum {
			if a != last {
				last = a;
				j += 1;
			}
			r[i as usize] = (i, j);
		}
		r.sort();
		r.into_iter().map(|r| r.1).collect()
	};
	let mut bit = BIT::new(n + 1);
	let mut ans = 0;
	for i in c {
		ans += bit.sum(i + 1) as u64;
		bit.add(i, 1);
	}
	println!("{}", ans);
}

struct BIT<T> {
	data: Vec<T>
}

impl<T> BIT<T>
where
	T: Clone + Default + std::ops::AddAssign
{
	fn new(n: usize) -> BIT<T> {
		BIT { data: vec![T::default(); n + 1] }
	}
	fn sum(&self, i: usize) -> T {
		let mut r = T::default();
		let mut i = i;
		while i > 0 {
			r += self.data[i].clone();
			i &= i - 1;
		}
		r
	}
	fn add(&mut self, i: usize, value: T) {
		let mut i = i + 1;
		while i < self.data.len() {
			self.data[i] += value.clone();
			i += i & (!i + 1);
		}
	}
}