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::error::Error;
use std::io;

struct Bit {
    array: Vec<i32>,
}

impl Bit {
    fn add(&mut self, index: usize, value: i32) {
        let mut next_index = index;
        while next_index < self.array.len() {
            self.array[next_index] += value;
            next_index += (next_index as i64 & -(next_index as i64)) as usize;
        }
    }

    fn sum(&self, index: usize) -> i64 {
        let mut next_index = index as i64;
        let mut result = 0i64;
        while next_index > 0 {
            result += self.array[next_index as usize] as i64;
            next_index -= (next_index as i64 & -(next_index as i64));
        }
        result
    }
}

pub fn main() {
    if let Err(e) = run() {
        panic!("failed.");
    }
}

// find the first item match.
fn find(sorted_array: &Vec<i64>, target: i64) -> usize {
    let mut left = 0usize;
    let mut right = sorted_array.len();
    while left < right {
        let middle = (right - left) / 2 + left;
        if sorted_array[middle] < target {
            left = middle + 1;
        } else {
            right = middle;
        }
    }
    left
}

fn run() -> Result<(), Box<Error>> {
    let mut input = String::new();
    io::stdin().read_line(&mut input);
    let first_line: Vec<i32> = input
        .split_whitespace()
        .map(|s| s.trim().parse::<i32>().unwrap())
        .collect();
    let n = first_line[0];
    let k = first_line[1] as i64;
    input.clear();
    let mut b = vec![0i64; 1 + n as usize];

    for i in 1..1 + n as usize {
        io::stdin().read_line(&mut input);
        let number: i64 = input.trim().parse().unwrap();
        input.clear();
        b[i] = b[i - 1];
        b[i] += number;
        b[i] -= k;
    }

    let mut sorted_array = b.clone();
    sorted_array.sort();
    let mut c = vec![0; 1 + n as usize];
    for i in 0..1 + n as usize {
        c[i] = find(&sorted_array, b[i]);
    }
    let mut result = 0i64;
    let mut bit = Bit {
        array: vec![0; 2 + n as usize],
    };
    for i in 0..1 + n as usize {
        result += bit.sum(c[i] + 1);
        bit.add(c[i] + 1, 1);
    }
    println!("{:?}", result);
    Ok(())
}