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 Ruby (2.3.3) (judge verdict: Time Limit Exceeded)

class SegTree
  attr_reader :original_size, :internal_size, :op

  def initialize(original_size, unit, &op)
    @original_size = original_size
    @op = op
    h = 0
    while (1 << h) < original_size
      h += 1
    end
    @internal_size = (1 << h)
    @height = h
    @array = Array.new((1 << (h+1)) - 1, unit)
  end

  def increment(i)
    os = 0
    bs = @internal_size
    @array[i] += 1
    @height.times do
      j = (os + i) | 1
      val = @op.call(@array[j ^ 1], @array[j])
      i >>= 1
      os |= bs
      bs >>= 1
      @array[os+i] = val
    end
    @array[-1]
  end

  def find(a,b)
    lv = nil; rv = nil
    os = 0
    bs = @internal_size
    while a < b
      if (a&1) == 1
        lv = lv ? @op.call(lv, @array[a]) : @array[a]
        a += 1
      end

      if (b&1) == 0
        rv = rv ? @op.call(@array[b], rv) : @array[b]
        b += -1
      end

      a = ((a-os) >> 1) | os | bs
      b = ((b-os) >> 1) | os | bs
      os |= bs
      bs >>= 1
    end

    if a == b
      lv = lv ? @op.call(lv, @array[a]) : @array[a]
    end
    rv ? @op.call(lv, rv) : lv
  end

  def data
    @array[0...@original_size]
  end

  def fulldata
    @array
  end
end

N,K,*A = `dd`.split.map &:to_i
ss = [0]
A.each{ |a| ss << ss[-1] + a - K }
smap = {}
ss[1..-1].sort.each_with_index{ |s,i| smap[s] = i }

st = SegTree.new(N, 0) { |a,b| a + b }
ans = 0
ss[1..-1].each{ |s|
  ans += 1 if s >= 0
  i = smap[s]
  ans += st.find(0, i)
  st.increment(i)
}
p ans