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 Go (1.6) (judge verdict: Accepted)

package main

import (
  "bufio"
  "fmt"
  "os"
  "sort"
  "strconv"
  "strings"
)

func main() {
  input := Input{bufio.NewReaderSize(os.Stdin,100)}
  n,k := input.NextInts()
  a := make([]int64,n)
  b := make([]int64,n+1)
  for i:=0;i<n;i++ {
    a[i] = input.NextInt()-k
    b[i+1] = b[i]+a[i]
  }
  c := compress(b)
  m := int64(0)
  bit := BinaryIndexTree{make([]int,n+1)}
  for i:=0;i<n+1;i++ {
    m += int64(bit.Sum(c[i]))
    bit.Add(c[i],1)
  }
  fmt.Print(m)
}
func compress(a []int64) []int {
  b := make([]int64,len(a))
  copy(b,a)
  sort.Sort(Int64Slice(b))
  m := map[int64]int{}
  v := 1
  for i:=0;i<len(b);i++ {
    if _,ok := m[b[i]];ok { continue }
    m[b[i]] = v
    v++
  }
  c := make([]int,len(a))
  for i:=0;i<len(a);i++ { c[i] = m[a[i]] }
  return c
}

type Int64Slice []int64
func(s Int64Slice) Len() int { return len(s) }
func(s Int64Slice) Less(i,j int) bool { return s[i] < s[j] }
func(s Int64Slice) Swap(i,j int) { s[i],s[j] = s[j],s[i] }

type BinaryIndexTree struct { bit []int }
func(b *BinaryIndexTree) Add(i,v int) {
  for x:=i;x<=len(b.bit);x+=x&-x { b.bit[x-1] += v }
}
func(b *BinaryIndexTree) Sum(i int) int {
  r := 0
  for x:=i;x>0;x-=x&-x { r += b.bit[x-1] }
  return r
}

type Input struct { reader *bufio.Reader }
func(i *Input) NextLine() string {
  var buffer []byte
  for {
    line,isPrefix,err := i.reader.ReadLine()
    if err != nil { panic(err) }
    buffer = append(buffer,line...)
    if !isPrefix { break }
  }
  return string(buffer)
}
func(i *Input) NextInt() int64 {
  n,_ := strconv.ParseInt(i.NextLine(),10,64)
  return n
}
func(i *Input) NextInts() (int,int64) {
  s := strings.Split(i.NextLine()," ")
  n,_ := strconv.Atoi(s[0])
  k,_ := strconv.ParseInt(s[1],10,64)
  return n,k
}