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)

use std::io;


fn main() {
    let (n, k) = {
        let i = read::<usize>();
        (i[0], i[1] as isize)
    };

    let mut an = Vec::new();
    for _ in 0..n { an.push(read_one::<isize>() - k); }

    // cumsum
    let mut bn = vec![0; n];
    bn[0] = an[0];
    for i in 1..n { bn[i] = bn[i - 1] + an[i]; }

    // compress
    let mut bn_s = bn.clone();
    bn_s.sort();
    bn_s.dedup();

    let cn = bn.iter()
        .map(|b| bn_s.binary_search(b).unwrap())
        .collect::<Vec<usize>>();

    let mut bit = FenwickTree::new(bn_s.len());
    // append {single} >= K elements
    let mut ans = bn.into_iter().filter(|&b| b >= 0).count();

    for c in cn {
        ans += bit.sum(c + 1);
        bit.add(c, 1);
    }

    println!("{}", ans);
}


#[derive(Debug)]
struct FenwickTree {
    n: usize,
    bit: Vec<usize>,
}

impl FenwickTree {
    fn new(n: usize) -> Self {
        FenwickTree { n: n, bit: vec![0; n] }
    }

    // [0, k)
    fn sum(&self, i: usize) -> usize {
        let mut s = 0;
        let mut i = i as isize;
        while i > 0 {
            i -= 1;
            s += self.bit[i as usize];
            i &= i + 1;
        }
        s
    }

    fn add(&mut self, i: usize, x: usize) {
        let mut i = i;
        while i < self.n {
            self.bit[i] += x;
            i |= i + 1;
        }
    }
}

#[allow(dead_code)]
fn read<T>() -> Vec<T>
where T:
std::str::FromStr,
T::Err: std::fmt::Debug {

    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    buf.split_whitespace()
        .map(|s| s.trim().parse().unwrap())
        .collect()
}

#[allow(dead_code)]
fn read_one<T>() -> T
where T:
std::str::FromStr,
T::Err: std::fmt::Debug {

    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    buf.trim().parse().unwrap()
}