Problem:
Score : 400 points

Problem Statement

One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend.

Find the following:

Constraints

1 ≦ N ≦ 200,000

(a_1, a_2, ..., a_N) is a permutation of (1, 2, ..., N).

Input

The input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

Print the answer.

Note that the answer may not fit into a 32-bit integer.

Sample Input 1

3
2 1 3

Sample Output 1

9

Sample Input 2

4
1 3 2 4

Sample Output 2

19

Sample Input 3

8
5 4 8 1 2 6 7 3

Sample Output 3

85

Solution in Scala (2.11.7) (judge verdict: Runtime Error)

import java.io._
import java.util
import java.util.StringTokenizer

import scala.collection.mutable
import scala.util.Sorting
import math.{abs, max, min}
import scala.collection.mutable.{ArrayBuffer, ListBuffer}
import scala.reflect.ClassTag

object Main {
  val MOD = 1000000007
  val out = new PrintWriter(System.out)

  def solve(): Unit = {
    val sc = new InputReader(System.in)
    val N = sc.nextInt()
    val A = map(N)(_ => sc.nextInt())
    val toIx = Array.ofDim[Int](N + 1)
    rep(N)(i => toIx(A(i)) = i)
    val rmq = new SegmentTree(N)
    rep(N)(i => rmq.update(i, A(i)))

    var sum = 0L
    case class Arg(l: Int, r: Int)
    val q = mutable.Stack[Arg]()
    q.push(Arg(0, N))
    while(q.nonEmpty) {
      val Arg(l, r) = q.pop()
      val ms = rmq.query(l, r)
      val i = toIx(ms)
      sum += (i - l + 1) * (r - i) * ms
      if (i > l) q.push(Arg(l, i))
      if (i + 1 < r) q.push(Arg(i + 1, r))
    }

    out.println(sum)
  }


  def main(args: Array[String]): Unit = {
    solve()
    out.flush()
  }


  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = null

    def next(): String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next().toInt
    def nextLong(): Long = next().toLong
    def nextChar(): Char = next().charAt(0)
  }
  def rep(n: Int)(f: Int => Unit): Unit = {
    var i = 0
    while(i < n) { f(i); i += 1 }
  }
  def rep_r(n: Int)(f: Int => Unit): Unit = {
    var i = n - 1
    while(i >= 0) { f(i); i -= 1 }
  }

  def map[@specialized A: ClassTag](n: Int)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    rep(n)(i => res(i) = f(i))
    res
  }

  implicit class ArrayOpts[A](val as: Array[A]) extends AnyVal {
    // todo Orderingだとboxing発生するので自作Orderを用意したい
    def maxByOpt[B: Ordering](f: A => B): Option[A] = {
      if (as.nonEmpty) Some(as.maxBy(f)) else None
    }

    def grpBy[K](f: A => K): mutable.Map[K, ArrayBuffer[A]] = {
      val map = mutable.Map.empty[K, ArrayBuffer[A]]
      rep(as.length)(i => map.getOrElseUpdate(f(as(i)), ArrayBuffer()) += as(i))
      map
    }

    def sumBy[B](f: A => B)(implicit num: Numeric[B]): B = {
      var sum = num.zero
      rep(as.length)(i => sum = num.plus(sum, f(as(i))))
      sum
    }

    def minByEx[B](f: A => B, ixRange: Range = as.indices)(implicit cmp: Ordering[B]): (A, B) = {
      limit(f, ixRange)(cmp.lt)
    }

    def maxByEx[B](f: A => B, ixRange: Range = as.indices)(implicit cmp: Ordering[B]): (A, B) = {
      limit(f, ixRange)(cmp.gt)
    }

    private def limit[B](f: A => B, ixRange: Range)(cmp: (B, B) => Boolean): (A, B) = {
      var limA = as(ixRange.head)
      var limB = f(limA)

      for (i <- ixRange.tail) {
        val a = as(i)
        val b = f(a)
        if (cmp(b, limB)) {
          limA = a
          limB = b
        }
      }
      (limA, limB)
    }
  }

  implicit class IterableOpts[A](val as: Iterable[A]) extends AnyVal {
    def sumBy[B](f: A => B)(implicit num: Numeric[B]): B = {
      as.foldLeft(num.zero)((acc, a) => num.plus(acc, f(a)))
    }
  }

  class SegmentTree(n: Int) {
    val N = Integer.highestOneBit(n - 1) << 1
    val dat: Array[Int] = Array.fill(2 * N - 1)(Integer.MAX_VALUE)

    def update(k: Int, a: Int): Unit = {
      var i = N - 1 + k
      dat(i) = a
      while(i > 0) {
        i = (i - 1) / 2
        dat(i) = min(dat(2 * i + 1), dat(2 * i + 2))
      }
    }

    def query(a: Int, b: Int): Int = {
      def step(a: Int, b: Int, k: Int, l: Int, r: Int): Int = {
        if (r <= a || b <= l) {
          Integer.MAX_VALUE
        } else if (a <= l && r <= b) {
          dat(k)
        } else {
          val vl = step(a, b, k * 2 + 1, l, (l + r) / 2)
          val vr = step(a, b, k * 2 + 2, (l + r) / 2, r)
          min(vl, vr)
        }
      }

      step(a, b, 0, 0, N)
    }
  }
}