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: Wrong Answer)

use std::error::Error;
use std::io;

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

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];
    input.clear();
    let mut b = vec![0; 1 + n as usize];
    let mut sorted_array = vec![];
    sorted_array.push(0i64);
    let mut result = 0i64;
    for i in 1..1 + n as usize {
        io::stdin().read_line(&mut input);
        let number: i32 = input.trim().parse().unwrap();
        input.clear();
        b[i] = b[i - 1];
        b[i] += number;
        b[i] -= k;
        let index = sorted_array
            .binary_search(&(b[i] as i64 * 10 + 1))
            .err()
            .unwrap();
        result += index as i64;
        sorted_array.insert(index, b[i] as i64 * 10);
    }
    println!("{:?}", result);
    Ok(())
}