//import java.util.Scanner

import java.io._
import java.nio.file.Files._
import java.nio.file.Path
import java.util.StringTokenizer

import scala.collection.immutable._
import scala.io.Codec

/**
  * Scala implementation of a faster java.util.Scanner
  * See: http://codeforces.com/blog/entry/7018
  */

class Scanner(reader: LineNumberReader) extends Iterable[String] with AutoCloseable {
  def this(reader: BufferedReader) = this(new LineNumberReader(reader))

  def this(reader: Reader) = this(new BufferedReader(reader))

  def this(inputStream: InputStream)(implicit codec: Codec) = this(new InputStreamReader(inputStream, codec.charSet))

  def this(path: Path)(implicit codec: Codec) = this(newBufferedReader(path, codec.charSet))

  def this(file: File)(implicit codec: Codec) = this(file.toPath)(codec)

  def this(str: String) = this(new StringReader(str))

  override def iterator: Iterator[String] = for {
    line <- Iterator.continually(reader.readLine()).takeWhile(_ != null)
    tokenizer = new StringTokenizer(line)
    tokens <- Iterator.continually(tokenizer).takeWhile(_.hasMoreTokens)
  } yield tokens.nextToken()

  private[this] var current = iterator

  def hasNext: Boolean = current.hasNext

  @inline def next(): String = current.next()

  /**
    * This is different from Java's scanner.nextLine
    * The Java one is a misnomer since it actually travel to end of current line
    * This one actually does fetch the next line
    */
  def nextLine(): String = {
    val line = reader.readLine()
    current = iterator
    line
  }

  def lineNumber: Int = reader.getLineNumber

  def nextString(): String = next()

  def nextBoolean(): Boolean = next().toBoolean

  def nextByte(radix: Int = 10): Byte = java.lang.Byte.parseByte(next(), radix)

  def nextShort(radix: Int = 10): Short = java.lang.Short.parseShort(next(), radix)

  def nextInt(radix: Int = 10): Int = java.lang.Integer.parseInt(next(), radix)

  def nextLong(radix: Int = 10): Long = java.lang.Long.parseLong(next(), radix)

  def nextBigInt(radix: Int = 10): BigInt = BigInt(next(), radix)

  def nextFloat(): Float = next().toFloat

  def nextDouble(): Double = next().toDouble

  def nextBigDecimal(): BigDecimal = BigDecimal(next())

  override def close(): Unit = reader.close()
}

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(Node(None, treeSize = 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) =>
      nodes(t).parent = Some(root(p))
      nodes(t).parent.get
  }
}

object Main {
  def solve(sc: => Scanner): Unit = {
    val A = Array.fill(sc.nextInt())(sc.nextLong())
    val t = A.max
    val B = (1L to t).filter(i => t % i == 0)
    println(A.map(x => B.filter(i => x <= i).min - x).sum)
  }

  def getPermutation(begin: Long = 0): Stream[Long] =
    Stream.cons(begin, getPermutation(begin + 1))

  def calc(S: Int, T: Int): Boolean = {
    1 <= S && S <= 12
  }

  var memo: Map[(Long, Long), Long] = Map[(Long, Long), Long]()

  def recursive(n: Long, k: Long): Long = {

    if (n == 1) k else recursive(n - 1, k) * k % 1000000007L
  }

  def recursive2(X: Set[Long], Y: Stream[Long]): Long = if (X.contains(Y.head)) X.size else recursive2(X + Y.head, Y.tail)

  def check(s: String): Boolean = {
    if (s == "0") true
    else s(0) != '0' && 0 <= s.toInt && s.toInt <= 255
  }

  def shift(n: Long): Long = {
    if (n == 0) 0
    else if (n == 1) 1
    else shift(n - 1) << 1
  }

  def unShift(n: Long): Long = {
    if (n == 0) 0
    else unShift(n >> 1) + 1
  }

  def gcd(i: Long, j: Long): Long = {
    if (i < j) gcd(j, i)
    else if (j == 0) i
    else gcd(j, i % j)
  }

  def primeFactors(i: Long): List[Long] = primeFactors_(i, 1).sorted

  def primeFactors_(i: Long, j: Long): List[Long] = {
    if (j * j > i) List.empty else if (i % j == 0) primeFactors_(i, j + 1) ++ List[Long](j, i / j) else primeFactors_(i, j + 1)
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    solve(sc)
  }
}

object Util {
  def getPermutation(begin: Long = 0): Stream[Long] =
    Stream.cons(begin, getPermutation(begin + 1))

  def getPrimeList: Stream[Long] =
    getPrimeListRecursive(getPermutation(begin = 2))

  private def getPrimeListRecursive(A: Stream[Long]): Stream[Long] =
    Stream.cons(A.head, getPrimeListRecursive(A.tail.filter(_ % A.head != 0)))

  def fib(a: Long = 0, b: Long = 1, mod: Long = Long.MaxValue): Stream[Long] = a #:: fib(b % mod, (a + b) % mod, mod)
}

object ArabicRoman {

  type =?>[A, B] = PartialFunction[A, B]

  val codeTable = List(
    (1000, "M"), (900, "CM"), (500, "D"), (400, "CD"), (100, "C"),
    (90, "XC"), (50, "L"), (40, "XL"), (10, "X"), (9, "IX"), (5, "V"), (4, "IV"), (1, "I"))

  val arabicToRoman: Int =?> String = {
    case src if src >= 1 && src <= 3999 =>

      def convert(left: Int, cont: String = "", code: List[(Int, String)] = codeTable): String = {
        val (unitVal, unitChar) = code.head
        left - unitVal match {
          case n if n == 0 => cont + unitChar
          case n if n > 0 => convert(n, cont + unitChar, code)
          case _ => convert(left, cont, code.tail)
        }
      }

      convert(src)
  }

  val romanToArabic: String =?> Int = {
    case src if Option(src).exists { s => {
      s.nonEmpty && """[^MDCLXVI]""".r.findFirstMatchIn(s.toUpperCase).isEmpty
    }
    } =>

      def convert(left: String, cont: Int = 0, code: List[(Int, String)] = codeTable): Int = {
        val (unitVal, unitChar) = code.head
        left.splitAt(unitChar.length) match {
          case ("", _) => cont
          case (`unitChar`, tail) => convert(tail, cont + unitVal, code)
          case _ => convert(left, cont, code.tail)
        }
      }

      convert(src.toUpperCase())
  }
}

Electric Metronome

A boy PCK is playing with N electric metronomes. The i-th metronome is set to tick every t_i seconds. He started all of them simultaneously.

He noticed that, even though each metronome has its own ticking interval, all of them tick simultaneously from time to time in certain intervals. To explore this interesting phenomenon more fully, he is now trying to shorten the interval of ticking in unison by adjusting some of the metronomes’ interval settings. Note, however, that the metronomes do not allow any shortening of the intervals.

Given the number of metronomes and their preset intervals t_i (sec), write a program to make the tick-in-unison interval shortest by adding a non-negative integer d_i to the current interval setting of the i-th metronome, and report the minimum value of the sum of all d_i.

Input

The input is given in the following format.

N
t_1
t_2
:
t_N

The first line provides the number of metronomes N (1 ≤ N ≤ 105). Each of the subsequent N lines provides the preset ticking interval t_i (1 ≤ t_i ≤ 104) of the i-th metronome.

Output

Output the minimum value.

Sample Input 1

3
3
6
8

Sample Output 1

3

If we have three metronomes each with a ticking interval of 3, 6, and 8 seconds, respectively, simultaneous activation of these will produce a tick in unison every 24 seconds. By extending the interval by 1 second for the first, and 2 seconds for the second metronome, the interval of ticking in unison will be reduced to 8 seconds, which is the shortest possible for the system.

Sample Input 2

2
10
10

Sample Output 2

0

If two metronomes are both set to 10 seconds, then simultaneous activation will produce a tick in unison every 10 seconds, which is the shortest possible for this system.


import scala.annotation.tailrec

object Main extends App {
  import scala.io.StdIn._

  val Array(a, n, m) = readLine.trim.split(' ').map(_.toInt)
  println(
    count(a, n, m)
  )
  @tailrec def count(a: Int, n: Int, m: Int, y: Long = 1, res: Int = 0): Int = {
    val x = exponent(a + y, n)
    if (x > m) res
    else count(a, n, m, y + 1, if (sumDigits(x) == y) res + 1 else res)
  }
  def sumDigits(x: Long): Long = {
    x match {
      case 0L ⇒ 0
      case _ ⇒ x % 10 + sumDigits(x / 10)
    }
  }
  def exponent(a: Long, e: Int): Long = {
    e match {
      case 1 ⇒ a
      case _ ⇒ a * exponent(a, e - 1)
    }
  }
}

Global OOD problem IDs are disjoint from train, validation, and in-distribution test problem IDs.

Dudeney Number

A Dudeney number is a positive integer for which the sum of its decimal digits is equal to the cube root of the number. For example, $512$ is a Dudeney number because it is the cube of $8$, which is the sum of its decimal digits ($5 + 1 + 2$).

In this problem, we think of a type similar to Dudeney numbers and try to enumerate them.

Given a non-negative integer $a$, an integer $n$ greater than or equal to 2 and an upper limit $m$, make a program to enumerate all $x$’s such that the sum of its decimal digits $y$ satisfies the relation $x = (y + a)^n$, and $x \leq m$.

Input

The input is given in the following format.

$a$ $n$ $m$

The input line provides three integers: $a$ ($0 \leq a \leq 50$), $n$ ($2 \leq n \leq 10$) and the upper limit $m$ ($1000 \leq m \leq 10^8$).

Output

Output the number of integers that meet the above criteria.

Sample Input 1

16 2 1000

Sample Output 1

2

Two: $400 = (4 + 0 + 0 + 16)^2$ and $841 = (8 + 4 + 1 + 16)^2$

Sample Input 2

0 3 5000

Sample Output 2

3

Three: $1=1^3$, $512 = (5 + 1 + 2)^3$ and $4913 = (4 + 9 + 1 + 3)^3$.

Sample Input 3

2 3 100000

Sample Output 3

0

There is no such number $x$ in the range below $100,000$ such that its sum of decimal digits $y$ satisfies the relation $(y+2)^3 = x$.

Submitted source-code file size, in bytes.

Execution CPU time reported by official Project CodeNet metadata, in milliseconds.

Peak memory usage reported by official Project CodeNet metadata, in kilobytes.


object Main extends App {
  import scala.io.StdIn._
  val mod = 1000000007L
  val n = readLine.trim.toInt
  val planets: Array[Planet] = readLine.trim.toCharArray.zip(readLine.trim.toCharArray).map{case (f, t) ⇒ new Planet(f, t)}
  val pattern = Array.tabulate(26){_ ⇒ 0L}.also(a ⇒ a(planets(0).in.toIndex) = 1)
  for (i ← 1 until planets.length - 1){
    pattern(planets(i).in.toIndex) = (pattern(planets(i).out.toIndex) + pattern(planets(i).in.toIndex)) % mod
  }
  println(pattern(planets(n - 1).out.toIndex))
  class Planet(val in: Char, val out: Char)
  implicit class CharToInt(val value: Char){
    def toIndex: Int = value - 'a'
  }
  implicit class ScopedFunc[T](val value: T){
    def let[A](func: T ⇒ A): A = func(value)
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
  }
}
//http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0386

Transporter

In the year 30XX, an expedition team reached a planet and found a warp machine suggesting the existence of a mysterious supercivilization. When you go through one of its entrance gates, you can instantaneously move to the exit irrespective of how far away it is. You can move even to the end of the universe at will with this technology!

The scientist team started examining the machine and successfully identified all the planets on which the entrances to the machine were located. Each of these N planets (identified by an index from $1$ to $N$) has an entrance to, and an exit from the warp machine. Each of the entrances and exits has a letter inscribed on it.

The mechanism of spatial mobility through the warp machine is as follows:

If you go into an entrance gate labeled with c, then you can exit from any gate with label c.

If you go into an entrance located on the $i$-th planet, then you can exit from any gate located on the $j$-th planet where $i < j$.

Once you have reached an exit of the warp machine on a planet, you can continue your journey by entering into the warp machine on the same planet. In this way, you can reach a faraway planet. Our human race has decided to dispatch an expedition to the star $N$, starting from Star $1$ and using the warp machine until it reaches Star $N$. To evaluate the possibility of successfully reaching the destination. it is highly desirable for us to know how many different routes are available for the expedition team to track.

Given information regarding the stars, make a program to enumerate the passages from Star $1$ to Star $N$.

Input

The input is given in the following format.

$N$
$s$
$t$

The first line provides the number of the stars on which the warp machine is located $N$ ($2 \leq N \leq 100,000$). The second line provides a string $s$ of length $N$, each component of which represents the letter inscribed on the entrance of the machine on the star. By the same token, the third line provides a string $t$ of length $N$ consisting of the letters inscribed on the exit of the machine. Two strings $s$ and $t$ consist all of lower-case alphabetical letters, and the $i$-th letter of these strings corresponds respectively to the entrance and exit of Star $i$ machine.

Output

Divide the number of possible routes from Star $1$ to Star $N$ obtained above by 1,000,000,007, and output the remainder.

Sample Input 1

6
abbaba
baabab

Sample Output 1

5

Sample Input 2

25
neihsokcpuziafoytisrevinu
universityofaizupckoshien

Sample Output 2

4


object Main extends App {
  import scala.io.StdIn._
  val Array(n, k) = readLine.trim.split(' ').map(_.toLong)
  val numbers = 0 +: readLine.trim.split(' ').map(_.toInt)//numbers(i) == [0, i)の排他的論理和
  for (i ← numbers.indices.tail) numbers(i) ^= numbers(i - 1)
  var rest = k
  var result = 0
  val maxDigit = 20
  val count = Array.tabulate(1 << maxDigit){_ ⇒ 0}
  for (topDigit ← 1 to maxDigit){
    val next = result * 2 + 1
    var sum = 0L
    for (num ← numbers){
      count(num >> (maxDigit - topDigit)) += 1
      sum += count((num >> (maxDigit - topDigit)) ^ next)
    }
    if (sum >= rest){
      result = result * 2 + 1
    }else {
      result = result * 2
      rest -= sum
    }
    (0 until (1 << topDigit)).foreach(i ⇒ count(i) = 0)
  }
  println(result)
  implicit class Scope[T](val value: T) extends AnyVal {
    @inline
    def also(@inline func: T ⇒ Unit): T = {
      func(value)
      value
    }
    @inline
    def let[A](@inline func: T ⇒ A): A = func(value)
  }
}

K-th Exclusive OR

Exclusive OR (XOR) is an operation on two binary numbers $x$ and $y$ (0 or 1) that produces 0 if $x = y$ and $1$ if $x \ne y$. This operation is represented by the symbol $\oplus$. From the definition: $0 \oplus 0 = 0$, $0 \oplus 1 = 1$, $1 \oplus 0 = 1$, $1 \oplus 1 = 0$.

Exclusive OR on two non-negative integers comprises the following procedures: binary representation of the two integers are XORed on bit by bit bases, and the resultant bit array constitute a new integer. This operation is also represented by the same symbol $\oplus$. For example, XOR of decimal numbers $3$ and $5$ is equivalent to binary operation $011 \oplus 101$ which results in $110$, or $6$ in decimal format.

Bitwise XOR operation on a sequence $Z$ consisting of $M$ non-negative integers $z_1, z_2, . . . , z_M$ is defined as follows:

$v_0 = 0, v_i = v_{i - 1} \oplus z_i$ ($1 \leq i \leq M$)

Bitwise XOR on series $Z$ is defined as $v_M$.

You have a sequence $A$ consisting of $N$ non-negative integers, ample sheets of papers and an empty box. You performed each of the following operations once on every combinations of integers ($L, R$), where $1 \leq L \leq R \leq N$.

Perform the bitwise XOR operation on the sub-sequence (from $L$-th to $R$-th elements) and name the result as $B$.

Select a sheet of paper and write $B$ on it, then put it in the box.

Assume that ample sheets of paper are available to complete the trials. You select a positive integer $K$ and line up the sheets of paper inside the box in decreasing order of the number written on them. What you want to know is the number written on the $K$-th sheet of paper.

You are given a series and perform all the operations described above. Then, you line up the sheets of paper in decreasing order of the numbers written on them. Make a program to determine the $K$-th number in the series.

Input

The input is given in the following format.

$N$ $K$
$a_1$ $a_2$ ... $a_N$

The first line provides the number of elements in the series $N$ ($1 \leq N \leq 10^5$) and the selected number $K$ ($1 \leq K \leq N(N+1)/2$). The second line provides an array of elements $a_i$ ($0 \leq a_i \leq 10^6$).

Sample Input 1

3 3
1 2 3

Sample Output 1

2

After all operations have been completed, the numbers written on the paper inside the box are as follows (sorted in decreasing order)

$3,3,2,1,1,0$

3番目の数は2であるため、2を出力する。

Sample Input 2

7 1
1 0 1 0 1 0 1

Sample Output 2

1

Sample Input 3

5 10
1 2 4 8 16

Sample Output 3

7


object Main extends App {
  import scala.io.StdIn._
  val c = readInt()
  println(
    c match {
      case _ if (65 to 90).contains(c) ⇒ 1
      case _ if (97 to 122).contains(c) ⇒ 2
      case _ ⇒ 0
    }
  )
}

アスキー文字

コンピュータの内部ではすべての情報が数値として扱われています。たとえば、アスキーコードでは、アルファベットの大文字Aに数値の65が割り当てられています。同様にアルファベットの大文字Bに66、Cに67というように、AからZには連続してそれぞれ65から90が割り当てられています。また、アスキーコードでは、アルファベットの小文字aに97が割り当てられています。同様にアルファベットの小文字bに98、cに99というように、aからzには連続してそれぞれ97から122が割り当てられています。

与えられたアスキーコードの数値が、アルファベットの大文字と小文字のどちらを表すか判定するプログラムを作成せよ。

入力

入力は以下の形式で与えられる。

$N$

１行に数値$N$ ($0 \leq N \leq 127$)が与えられる。

出力

大文字なら「1」を、小文字なら「2」を、それ以外なら「0」を１行に出力する。

入出力例

入力例１

67

出力例１

1

入力例２

110

出力例２

2

入力例３

32

出力例３

0


import scala.io.Source._
import scala.io.StdIn._

object Main {
  def main(args: Array[String]): Unit = {
    while (true) {
      val n = readInt
      if (n == 0) return

      var map = scala.collection.mutable.HashMap[Char, Char]()
      for (i <- 0 until n) {
        val s = readLine.split(' ').map(x => x.head)
        map += (s.head -> s(1))
      }

      val nn = readInt
      for (i <- 0 until nn) {
        val x = readLine.head
        print(map.get(x).getOrElse(x))
      }
      println
    }
  }
}

与えられた変換表にもとづき，データを変換するプログラムを作成しなさい．

データに使われている文字は英字か数字で，英字は大文字と小文字を区別する．変換表に現れる文字の順序に規則性はない．

変換表は空白をはさんで前と後ろの 2 つの文字がある(文字列ではない)．変換方法は，変換表のある行の前の文字がデータに現れたら，そのたびにその文字を後ろの文字に変換し出力する．変換は 1 度だけで，変換した文字がまた変換対象の文字になっても変換しない．変換表に現れない文字は変換せず，そのまま出力する．

入力ファイルには，変換表（最初の n + 1 行）に続き変換するデータ（n + 2 行目以降）が書いてある． 1 行目に変換表の行数 n，続く n 行の各行は，空白をはさんで 2 つの文字，さらに続けて， n + 2 行目に変換するデータの行数 m，続く m 行の各行は 1 文字である． m ≤ 105 とする．出力は，出力例のように途中に空白や改行は入れず 1 行とせよ．

入力例

3

A a

0 5

5 4

10

A

B

C

0

1

4

5

a

b

A

出力例

aBC5144aba

入力

入力は複数のデータセットからなる．n が 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、変換後の文字列を１行に出力する．

入力例

3
A a
0 5
5 4
10
A
B
C
0
1
4
5
a
b
A
3
A a
0 5
5 4
10
A
B
C
0
1
4
5
a
b
A
0

出力例

aBC5144aba
aBC5144aba

各データセットの出力（変換後の文字列）の後に改行を入れること．

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


object Main extends App {
    val in = io.Source.stdin.getLines.map(_.split(" ").map(_.toInt))
    for (Array(n, m) <- in if n != 0) {
        println(in.take(n).toList.transpose.zipWithIndex.sortWith((a, b) => a._1.sum > b._1.sum).map(_._2+1).mkString(" "))
    }
}

ある学校で修学旅行へ行く計画がある.そのためにアンケート調査を行った.
生徒は 1 から n までの生徒番号を持ち,旅行候補の場所を 1 から m までの番号で表し,行きたい場所に ○,行きたくない場所に×の印をつけて提出している.

このとき, 行きたい場所の人数が多い順に,場所の番号を出力するプログラムを作成せよ.人数が同じときは,場所の番号順とする.

入力データ の 1 行目は生徒の人数 n と旅行候補の場所の数 m が空白で区切られ, i + 1 行に生徒 i のアンケート結果を ○ は 1 で×は 0 で表し,空白で区切られた m 個の数字が並んでいる.1 ≤ n ≤ 1000, 1 ≤ m ≤ 100 とする.

入力例１

4 6

1 0 1 0 1 1

1 1 0 1 0 0

1 1 1 0 0 0

1 0 1 0 1 0

出力例１

1 3 2 5 4 6

入力

入力は複数のデータセットからなる．n, m がともに 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、場所の番号 を１行に出力する．

入力例

4 6
1 0 1 0 1 1
1 1 0 1 0 0
1 1 1 0 0 0
1 0 1 0 1 0
4 6
1 0 1 0 1 1
1 1 0 1 0 0
1 1 1 0 0 0
1 0 1 0 1 0
0 0

出力例

1 3 2 5 4 6
1 3 2 5 4 6

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


object Main {
    def main(args: Array[String]) = {
        val in = io.Source.stdin.getLines.map(_.split(" ").map(_.toInt))
        println(in.next.sum max in.next.sum)
    }
}

得点

問題

JOI高校の2人の生徒 A さんと B さんは，情報，数学，理科，英語の4教科の試験を受けた． A さんと B さんのこれら4教科の得点が与えられると， Aさんの合計点 S と Bさんの合計点 T のうち大きな方を出力するプログラムを作成せよ．ただし，同点の場合は S (= T) を出力せよ．

入力

入力は2行からなる．

1行目は4つの整数が1つの空白を区切りとして書かれており，それぞれ順に， A さんの情報の得点，数学の得点，理科の得点，英語の得点を表している．

2行目は4つの整数が1つの空白を区切りとして書かれており，それぞれ順に， B さんの情報の得点，数学の得点，理科の得点，英語の得点を表している．

どの教科の得点も100点満点で，負の得点が与えられることはない．

出力

出力は, 求める1つの整数からなる.

入出力例

入力例1

100 80 70 60
80 70 80 90

出力例1

320

入力例2

100 80 70 60
80 70 60 100

出力例2

310

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


import scala.io.StdIn.{readLine,readInt}

object Main {
  def cut(c:Array[Int],n:Int,k:Int) = {
    c.slice(k,2*n) ++ c.slice(0,k)
  }

  def rif(c:Array[Int],n:Int) = {
    val a = c.slice(0,n)
    val b = c.slice(n,n+n)
    (0 until 2*n).map{ i=> if(i%2==0) a(i/2) else b((i-1)/2) }.toArray
  }

  def main(args:Array[String]) = {
    val n = readInt
    val m = readInt
    var a = (0 until 2*n).map { i => i+1 }.toArray
    for(i<-0 until m) {
      val k = readInt
      if(k==0) a = rif(a,n)
      else a = cut(a,n,k)
    }
    println(a.mkString("\n"))
  }

}

カードの並び替え

問題

1 から 2n の数が書かれた 2n 枚のカードがあり，上から 1, 2, 3, ... , 2n の順に積み重なっている．

このカードを，次の方法を何回か用いて並べ替える．

整数 k でカット

上から k 枚のカードの山 A と 残りのカードの山 B に分けた後， 山 A の上に山 B をのせる．

リフルシャッフル

上から n 枚の山 A と残りの山 B に分け， 上から A の1枚目， B の1枚目， A の2枚目， B の2枚目， …， A の n枚目， B の n枚目， となるようにして， 1 つの山にする．

入力の指示に従い，カードを並び替えたあとのカードの番号を，上から順番に出力するプログラムを作成せよ．

入力

1 行目には n （1 ≦ n ≦ 100）が書かれている． すなわちカードの枚数は 2n 枚である．

2 行目には操作の回数 m （1 ≦ m ≦ 1000）が書かれている．

3 行目から m + 2 行目までの m 行には， 0 から 2n-1 までのいずれか 1 つの整数 k が書かれており， カードを並べ替える方法を順に指定している．

k = 0 の場合は， リフルシャッフルを行う．

1 ≦ k ≦ 2n-1 の場合は， k でカットを行う．

出力

出力は2n 行からなる． 1 行目には並べ替え終了後の一番上のカードの番号， 2 行目には並べ替え終了後の上から 2 番目のカードの番号というように， i 行目には上から i 番目のカードの番号を出力せよ．

入出力例

入力例 1

2
2
1
0

出力例 1

2
4
3
1

入力例 2

3
4
2
4
0
0

出力例 2

1
5
4
3
2
6

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


import java.util.Scanner

object Main {

  def check(input: Array[Array[Int]]): Int = {
    var ret = 0
    for (j <- 0 until input(0).length) {
      var N = 0
      for (i <- 0 until input.length) {
        N += input(i)(j)
      }
      ret += math.max(N, input.length - N)
    }
    ret
  }

  def check2(num: Int, input: Array[Array[Int]]): Int = {
    var ret = 0
    for (j <- 0 until input(0).length) {
      var N = 0
      for (i <- 0 until input.length) {
        if ((num >> i) % 2 == 1) {
          N += 1 - input(i)(j)
        } else {
          N += input(i)(j)
        }
      }
      ret += math.max(N, input.length - N)
    }
    ret
  }

  //  /*
  def rev(num: Int, input: Array[Array[Int]]): Array[Array[Int]] = {
    Array.tabulate(input.length)(i => if ((num >> i) % 2 == 1) (Array.tabulate(input(i).length)(j => 1 - input(i)(j))) else (input(i)))
  }

  // */
  /*
def rev(num: Int, input: Array[Array[Int]]): Array[Array[Int]] = {
  for (i <- 0 until input.length) {
    if ((num >> i) % 2 == 1) (
      Array.copy(Array.tabulate(input(i).length)(j => 1 - input(i)(j)), 0, input(i), 0, input(i).length)
      )
  }
  input
}

//  */

  def make(input: Array[Array[Int]]): Int = {
    var max: Int = 0
    for (i <- 0 to (1 << (input.length - 2))) {
      max = math.max(max, check2(i, input.clone))
    }
    max
  }

  def solve(sc: Scanner): Boolean = {
    val R: Int = sc.nextInt
    val C: Int = sc.nextInt
    if (R != 0 && C != 0) {
      println(make(Array.fill(R)(Array.fill(C)(sc.nextInt))))

      true
    } else {
      false
    }
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    while (solve(sc)) ()
  }
}

おせんべい

問題

IOI製菓では，創業以来の伝統の製法で煎餅（せんべい）を焼いている．この伝統の製法は，炭火で一定時間表側を焼き，表側が焼けると裏返して，炭火で一定時間裏側を焼くというものである．この伝統を守りつつ，煎餅を機械で焼いている．この機械は縦 R (1 ≤ R ≤ 10) 行, 横 C (1 ≤ C ≤ 10000) 列の長方形状に煎餅を並べて焼く．通常は自動運転で，表側が焼けたら一斉に煎餅を裏返し裏側を焼く．

ある日，煎餅を焼いていると，煎餅を裏返す直前に地震が起こり何枚かの煎餅が裏返ってしまった．幸いなことに炭火の状態は適切なままであったが，これ以上表側を焼くと創業以来の伝統で定められている焼き時間を超えてしまい，煎餅の表側が焼けすぎて商品として出荷できなくなる．そこで，急いで機械をマニュアル操作に変更し，まだ裏返っていない煎餅だけを裏返そうとした．この機械は，横の行を何行か同時に裏返したり縦の列を何列か同時に裏返したりすることはできるが，残念なことに，煎餅を１枚ごと裏返すことはできない．

裏返すのに時間がかかると，地震で裏返らなかった煎餅の表側が焼けすぎて商品として出荷できなくなるので，横の何行かを同時に１回裏返し，引き続き，縦の何列かを同時に１回裏返して，表側を焼きすぎずに両面を焼くことのできる煎餅，つまり，「出荷できる煎餅」の枚数をなるべく多くすることにした．横の行を１行も裏返さない，あるいは，縦の列を１列も裏返さない場合も考えることにする．出荷できる煎餅の枚数の最大値を出力するプログラムを書きなさい．

地震の直後に，煎餅が次の図のような状態になったとする．黒い丸が表側が焼ける状態を，白い丸が裏側が焼ける状態を表している．

1行目を裏返すと次の図のような状態になる．

さらに， 1列目と5列目を裏返すと次の図のような状態になる．この状態では，出荷できる煎餅は9枚である．

ヒント

R の上限 10 は C の上限 10000 に比べて小さいことに注意せよ．

入力

入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．

入力の1行目には2つの整数 R, C (1 ≤ R ≤ 10, 1 ≤ C ≤ 10 000) が空白を区切りとして書かれている．続く R 行は地震直後の煎餅の状態を表す． (i+1) 行目 (1 ≤ i ≤ R) には， C 個の整数 ai,1, ai,2, ……, ai,C が空白を区切りとして書かれており， ai,j は i 行 j 列 の煎餅の状態を表している. ai,j が 1 なら表側が焼けることを， 0 なら裏側が焼けることを表す．

C, R がともに 0 のとき入力の終了を示す.　データセットの数は 5 を超えない．

出力

データセットごとに，出荷できる煎餅の最大枚数を1行に出力する．

入出力例

入力例

2 5
0 1 0 1 0
1 0 0 0 1
3 6
1 0 0 0 1 0
1 1 1 0 1 0
1 0 1 1 0 1
0 0

出力例

9
15

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


import scala.annotation.tailrec

object Main extends App {

  import scala.io.StdIn._
  f

  def f: Unit = {
    val n = readLine.trim.toInt
    if (n == 0) return
    val num = toCh(List.tabulate(n){ _ ⇒ readLine.trim.toInt})
    println(n - search(num))
    f
  }
  def search(list: List[Ch]): Int = {
    def sub(prev: List[Ch], current: Ch, post: List[Ch], max: Int = 0): Int = {
      prev match {
        case c::t ⇒ sub(t, c, current::post, List(max, changeFirst(prev, current, post), changeLast(prev, current, post)).max)
        case _ ⇒ List(max, changeFirst(prev, current, post), changeLast(prev, current, post)).max
      }
    }
    list match {
      case Nil ⇒ 0
      case h::t ⇒ sub(t, h, Nil)
    }
  }
  def changeFirst(prev: List[Ch], current: Ch, post: List[Ch]): Int = {
    (prev, current, post) match {
      case (Ch(a, n)::t, Ch(_, 1), Ch(b, m)::u) if a == b && n + m >= 3 ⇒ n + m + 1 + remove(t, u)
      case (Ch(_, n)::t, Ch(a, m), _) if n >= 3 ⇒ if (m == 1) n + 1 + remove(t, post) else n + 1 + remove(t, Ch(a, m - 1)::post)
      case _ ⇒ 0
    }
  }
  def changeLast(prev: List[Ch], current: Ch, post: List[Ch]): Int = {
    (prev, current, post) match {
      case (Ch(a, n)::t, Ch(_, 1), Ch(b, m)::u) if a == b && n + m >= 3 ⇒ n + m + 1 + remove(t, u)
      case (_, Ch(a, n), Ch(_, m)::t) if m >= 3 ⇒ if (n == 1) m + 1 + remove(prev, t) else m + 1 + remove(Ch(a, n - 1)::prev, t)
      case _ ⇒ 0
    }
  }
  def remove(prev: List[Ch], post: List[Ch]): Int = {
    (prev, post) match {
      case (Ch(a, n)::t, Ch(b, m)::u) if a == b && n + m >= 4 ⇒ n + m + remove(t, u)
      case _ ⇒ 0
    }
  }
  @tailrec
  def toCh(list:List[Int], res: List[Ch] = Nil): List[Ch] = {
    list match {
      case Nil ⇒ res
      case h::t ⇒ res match {
        case Nil ⇒ toCh(t, Ch(h, 1)::res)
        case Ch(c, n)::rt if c == h ⇒ toCh(t, Ch(c, n + 1)::rt)
        case _ ⇒ toCh(t, Ch(h, 1)::res)
      }
    }
  }
  case class Ch(color: Int, num: Int)
}

連鎖

問題

次のようなゲームがある．

あるキャラクターが縦 1 列に N 個並んでいる．これらのキャラクターの色は赤，青，黄のいずれかであり，初期状態で同じ色のキャラクターが4つ以上連続して並んでいることはない．プレーヤーは，ある位置のキャラクターを選び他の色に変更することができる．この操作により同じ色のキャラクターが4つ以上連続して並ぶとそれらのキャラクターは消滅する．キャラクターが消滅することにより新たに同じ色のキャラクターが4つ以上連続して並ぶとそれらのキャラクターも消滅し，同じ色のキャラクターが4つ以上連続して並んでいる箇所がなくなるまでこの連鎖は続く．このゲームの目的は，消滅しないで残っているキャラクター数をなるべく少なくすることである．

例えば，下図の左端の状態で，上から6番目のキャラクターの色を黄色から青に変更すると，青のキャラクターが5つ連続するので消滅し，最終的に3つのキャラクターが消滅せずに残る．

初期状態における N 個のキャラクターの色の並びが与えられたとき， 1箇所だけキャラクターの色を変更した場合の，消滅しないで残っているキャラクター数の最小値 M を求めるプログラムを作成せよ．

入力

入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．

1行目はキャラクター数 N (1 ≤ N ≤ 10000) だけからなる．続く N 行には 1, 2, 3 のいずれか1つの整数が書かれており， i + 1 行目 (1 ≤ i ≤ N) は初期状態における上から i 番目のキャラクターの色を表す（1 は赤を，2 は青を，3は黄を表す）．

N が 0 のとき入力の終了を示す．データセットの数は 5 を超えない．

出力

データセットごとに, 消滅しないで残っているキャラクター数の最小値 M を１行に出力せよ．

入出力例

入力例

12
3
2
1
1
2
3
2
2
2
1
1
3
12
3
2
1
1
2
3
2
1
3
2
1
3
0

出力例

3
12

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


import scala.io.StdIn.{readInt,readLine}

object Main {
  def main(args:Array[String]) = {
    val s = readLine
    println {
      (1 to readInt).count{ _ => (readLine*2).contains(s) }
    }
  }
}

指輪 (Ring)

問題

あなたは N 個の指輪を持っている．どの指輪にも，アルファベットの大文字 10 文字からなる文字列が刻印されている．指輪には文字列の最初と最後がつながった形で文字が刻印されている．指輪に刻印された文字列を逆順に読む心配はない．

探したい文字列が与えられたとき，その文字列を含む指輪が何個あるかを求めるプログラムを作成せよ．

入力

入力は 2+N 行からなる．

1 行目には，1 文字以上 10 文字以下のアルファベットの大文字からなる探したい文字列が書かれている．

2 行目には，指輪の個数 N ( 1 ≦ N ≦ 100 )が書かれている．

2+i 行目(1 ≤ i ≤ N )には， i 個目の指輪に刻印されている 10 文字からなる文字列が書かれている．

出力

探したい文字列を含む指輪の個数を表す整数を 1 行で出力せよ．

入出力例

入力例 1

ABCD
3
ABCDXXXXXX
YYYYABCDXX
DCBAZZZZZZ

出力例 1

2

入力例 2

XYZ
1
ZAAAAAAAXY

出力例 2

1

入力例 2 の指輪には「XYZ」という文字列が 1 つ含まれている．これは、指輪の文字列の最初と最後がつながっているためである．

入力例 3

PQR
3
PQRAAAAPQR
BBPQRBBBBB
CCCCCCCCCC

出力例 3

2

入力例 3 の 1 個目の指輪には「PQR」という文字列が 2 つ含まれており， 2 個目の指輪には「PQR」という文字列が 1 個含まれており， 3 個目の指輪には「PQR」という文字列が含まれていない．そのため「PQR」という文字列が含まれている指輪の数は 2 個となる．

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


object Main extends App {

  import scala.io.StdIn._
  val n = readLine.trim.toInt
  val points = Array.tabulate(n){_ ⇒ 0}
  for (_ ← 0 until (n * (n - 1) / 2)) {
    val Array(a, b, c, d) = readLine.trim.split(' ').map(_.toInt)
    if (c > d){
      points(a - 1) += 3
    }else if (c < d){
      points(b - 1) += 3
    }else {
      points(a - 1) += 1
      points(b - 1) += 1
    }
  }
  val scores = Array.tabulate(n * 3 + 1){_ ⇒ 0}
  points.foreach(scores(_) += 1)
  for (i ← (1 to 3 * n).reverse){
    scores(i - 1) += scores(i)
  }
  points.foreach{score ⇒
    println(scores(score + 1) + 1)
  }
}

サッカー (Soccer)

問題

JOI 国ではサッカーが人気であり，JOI リーグというリーグ戦が毎週行われている．

JOI リーグには N 個のチームが所属していて，1 から N までの番号がつけられている．すべての組み合わせの試合がちょうど一度ずつ行われる．つまり， N × (N - 1) / 2 試合が行われる．各試合の勝敗はそれぞれのチームの得点で決まる．勝ったチームの勝ち点は 3 点であり，負けたチームの勝ち点は 0 点である．引き分けの場合，両チームの勝ち点は 1 点である．順位は各チームの獲得した勝ち点の合計で決定し，得失点差は考えない．勝ち点の合計が等しいチームの順位は上位に揃える．

例として， 4 チームでのリーグ戦を考える．4 × (4 - 1) / 2 = 6 試合が行われる．それらの結果が以下の表のようになったとする．ハイフンの左側はその横のチームの得点であり，右側はその縦のチームの得点である．

  チーム 1

  チーム 2

  チーム 3

  チーム 4

  勝ち数

  負け数

  引き分け数

  勝ち点

  チーム 1

---

0 - 1

2 - 1

2 - 2

1

1

1

4

  チーム 2

1 - 0

---

1 - 1

3 - 0

2

0

1

7

  チーム 3

1 - 2

1 - 1

---

1 - 3

0

2

1

1

  チーム 4

2 - 2

0 - 3

3 - 1

---

1

1

1

4

このとき，勝ち点の最も多いチーム 2 が 1 位である．

その次に勝ち点が多いチームはチーム 1 とチーム 4 であり，これらのチームの順位は共に 2 位である．

そして勝ち点が最も少ないチーム 3 が 4 位である．

全ての試合の結果が与えられたとき，各チームの順位を求めるプログラムを作成せよ．

入力

入力ファイルの 1 行目にはチームの個数 N (2 ≦ N ≦ 100) が書かれている．続く N × (N - 1) / 2 行には各試合の結果が書かれている．i + 1 行目 (1 ≦ i ≦ N × (N - 1) / 2) には整数 Ai，Bi，Ci，Di (1 ≦ Ai ≦ N，1 ≦ Bi ≦ N，0 ≦ Ci ≦ 100，0 ≦ Di ≦ 100) が空白を区切りとして書かれており，チーム Ai とチーム Bi が対戦し，チーム Ai の得点が Ci 点，チーム Bi の得点が Di 点であったことを表す．全ての i について Ai ≠ Bi であり，同じ組み合わせの対戦が書かれていることはない．

出力

出力は N 行からなる．各行は 1 つの整数からなり， i 行目 (1 ≦ i ≦ N) の整数はチーム i の順位を表す．

入出力例

入力例 1

4
1 2 0 1
1 3 2 1
1 4 2 2
2 3 1 1
2 4 3 0
3 4 1 3

出力例 1

2
1
4
2

入出力例 1 は問題文中の例に対応している．

入力例 2

5
1 2 1 1
3 4 3 1
5 1 1 2
2 3 0 0
4 5 2 3
1 3 0 2
5 2 2 2
4 1 4 5
3 5 4 0
2 4 0 1

出力例 2

2
4
1
4
3

入出力例 2 における結果は以下の通りである．

  勝ち数

  負け数

  引き分け数

  勝ち点

  チーム 1

2

1

1

7

  チーム 2

0

1

3

3

  チーム 3

3

0

1

10

  チーム 4

1

3

0

3

  チーム 5

1

2

1

4

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


import java.util.Scanner

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.immutable.Queue

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(new Node(None, 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  @tailrec
  private def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) => root(p)
  }
}

object Main {
  def solve(sc: => Scanner): Unit = {
    val s = sc.next
    var ans = 0
    for (i <- Range(1, 101)) {
      if (s.contains("J" * i + "O" * i + "I" * i)) (ans = i)
    }
    println(ans)
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    solve(sc)
  }
}

JJOOII (JJOOII)

JOI (日本情報オリンピック) の本選に向けてプログラミングの練習をしていたあなたは，今年度のJOI の予選の問題には数値を扱う問題ばかりが出題され，文字列を扱う問題がなかったことに気がついた．そこであなたは，こっそり文字列の問題に強くなってライバルたちに差をつけることにした．

JOI の過去問を眺めていると，J, O, I の3 種類の文字からなる文字列に慣れておく必要がありそうなことがわかった．そこで，そのような文字列について考えよう．あなたは「与えられた文字列がJOI という部分文字列をもつかどうかを答えよ」という問題を思いついたものの，これはすぐに解けてしまった．もっとレベルの高い問題を解きたいあなたは，以下のような問題を作った．

文字列t が文字列s の部分文字列であるとは，t の先頭および末尾に何文字か(0 文字でもよい) を付け足すとs になることである．たとえば，JJOOII はOJJOOIIOJOI の部分文字列である．一方，JOI はJOOI の部分文字列ではない．

また，0 以上の整数k に対し，レベルk のJOI 列とは，k 個の文字J，k 個の文字O，k 個の文字I をこの順に並べた文字列のことであるとする．たとえば，JJOOII はレベル2 のJOI 列である．与えられた文字列の部分文字列であるJOI 列のうち，レベルが最大のものを求めたい．

課題

J, O, I の3 種類の文字からなる長さN の文字列S が与えられたとき，レベルk のJOI 列がS の部分文字列であるような最大のk の値を求めるプログラムを作成せよ．

制限

1 ≤ N ≤ 1000000 (= 106)   S の長さ

入力

標準入力から以下のデータを読み込め．

1 行目にはJ, O, I の3 種類の文字からなる文字列S が書かれている．

出力

標準出力に，レベルk のJOI 列がS の部分文字列であるような最大のk の値を表す整数を1 行で出力せよ．

採点基準

採点用データのうち，配点の20%分については，N ≤ 100 を満たす．

入出力例

入力例 1

OJJOOIIOJOI

出力例 1

2

OJJOOIIOJOI はレベル2 のJOI 列であるJJOOII を部分文字列として含んでおり，レベル3 以上のJOI列は部分文字列として含まない．

入力例 2

IJJIIJJJ

出力例 2

0

入力例 3

JOIJOIJOIJOIJOI

出力例 3

1

入力例 4

OOJJJJJJJOOOOIIIII

出力例 4

4

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


import java.util.Scanner

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.immutable.Queue

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(new Node(None, 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  @tailrec
  private def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) => root(p)
  }
}

object Main {
  def solve(sc: => Scanner) = {
    val N = sc.nextInt
    val S = sc.next
    var count = 0
    for (_ <- Range(0, N)) {
      val s = sc.next
      var flag = true
      for (i <- Range(0, math.max(0, s.length - S.length) + 1)) {
        if (flag) {
          for (j <- Range(1, 200)) {
            if (i + j * (S.length - 1) < s.length) {
              //println(i, j)
              var f = true

              for (k <- Range(0, S.length)) {
                if (s(i + j * k) != S(k)) (f = false)
              }

              if (f) {
                count += 1
                flag = false
              }
            }
          }
        }
      }
    }
    println(count)
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    solve(sc)
  }
}

看板 (Signboard)

問題

JOI 君はお店の看板を作ることにした．

文字が等間隔に書かれた古い看板が N 枚ある．JOI 君は古い看板からいくつかの文字を消すことで看板を作る．残った文字列がお店の名前になっていて，しかも残った文字が等間隔に並んでいるようにしたい．看板は 1 枚の古い看板から作らなければならず，古い看板を切ったりつなげたりしてはならない．

お店の名前と N 枚の古い看板の情報が与えられた時，JOI 君が作ることができる看板の枚数を求めるプログラムを作成せよ．ただし， 1 枚の古い看板から作ることができる看板が複数考えられる場合も，作ることができる看板は 1 枚であると考える．

入力

入力は 2 + N 行からなる．

1 行目には，整数 N (1 ≦ N ≦ 100) が書かれており，古い看板の枚数を表す．

2 行目には，3 文字以上 25 文字以下のアルファベット小文字からなる文字列が書かれており，お店の名前を表す．

続く N 行のうちの i 行目 (1 ≦ i ≦ N) には 1 文字以上 100 文字以下のアルファベット小文字からなる文字列が書かれており，i 枚目の古い看板に書かれている文字列を表す．

出力

JOI 君が作ることができる看板の枚数を表す整数を 1 行で出力せよ．

入出力例

入力例

4
bar
abracadabra
bear
bar
baraxbara

出力例

3

お店の名前は bar である．

1 枚目の古い看板には文字列 abracadabra が書かれている．
この古い看板から 2 文字目，6 文字目，10 文字目以外を消すことで看板を作ることができる．

2 枚目は，2 文字目を消すと bar という文字列を作ることができるが，これは残った文字が等間隔に並んでいない．

3 枚目は，文字を何も消さなくても看板になっている．

4 枚目の古い看板から看板を作る方法は 2 通りある．
1 つの方法は，1 文字目，2 文字目，3 文字目以外を消すことである．
もう 1 つの方法は，6 文字目，7 文字目，8 文字目以外を消すことである．

よって，JOI 君は 1 枚目，3 枚目，4 枚目の古い看板から看板を作ることができるので，3 を出力する．

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


import scala.io.StdIn.readInt

object Main {
  def makeup(n:Int) = if(n<40) 40 else n

  def main(args:Array[String]) = {
    println({for(i<-1 to 5) yield makeup(readInt)}.sum/5)
  }
}

問題 1: 平均点 (Average Score)

問題

JOI 高校の授業には，太郎君，次郎君，三郎君，四郎君，花子さんの 5 人の生徒が参加した．

この授業では，期末試験を実施した．期末試験は，5 人全員が受験した．期末試験の点数が 40 点以上の生徒は，期末試験の点数がそのまま成績になった．期末試験の点数が 40 点未満の生徒は全員，補習を受け，成績が 40 点になった．

5 人の生徒の期末試験の点数が与えられたとき，5 人の成績の平均点を計算するプログラムを作成せよ．

入力

入力は 5 行からなり，1 行に 1 つずつ整数が書かれている．

1 行目には 太郎君の期末試験の点数が書かれている．

2 行目には 次郎君の期末試験の点数が書かれている．

3 行目には 三郎君の期末試験の点数が書かれている．

4 行目には 四郎君の期末試験の点数が書かれている．

5 行目には 花子さんの期末試験の点数が書かれている．

生徒の期末試験の点数はすべて 0 点以上 100 点以下の整数である．

生徒の期末試験の点数はすべて 5 の倍数である．

5 人の生徒の成績の平均点は必ず整数になる．

出力

5 人の生徒の成績の平均点をあらわす整数を 1 行で出力せよ．

入出力例

入力例 1

10
65
100
30
95

出力例 1

68

入出力例 1 では，太郎君と四郎君の期末試験の点数は 40 点未満なので，太郎君と四郎君の成績は 40 点になる．次郎君と三郎君と花子さんの期末試験の点数は 40 点以上なので，次郎君の成績は 65 点，三郎君の成績は 100 点，花子さんの成績は 95 点となる．5 人の成績の合計は 340 なので，平均点は 68 点となる．

入力例 2

40
95
0
95
50

出力例 2

64

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


object Main extends App {

  import scala.io.StdIn._
  import scala.math._

  solve
  def solve: Unit ={
    val Array(h, w) = readLine.trim.split(' ').map(_.toInt)
    if (h == 0) return
    val state = Array.tabulate(h){_ ⇒ readLine.trim}
    val girl = state.indices.flatMap(h ⇒ state(h).indices.map{w ⇒ Coordinate(w, h)}).find{c ⇒ state(c.y)(c.x) == 'A'}.get
    val minTime = Array.tabulate(h){_ ⇒ Array.tabulate(w){_ ⇒ Int.MaxValue}}.also{arr ⇒ arr(girl.y)(girl.x) = 0}
    var current = List(girl)
    while (current.nonEmpty){
      var next = Nil: List[Coordinate]
      for {c ← current; n ← c.neighbor} {
        if ((0 until h).contains(n.y) && (0 until w).contains(n.x) && state(n.y)(n.x) != '#' && minTime(n.y)(n.x) > minTime(c.y)(c.x) + 1) {
          minTime(n.y)(n.x) = minTime(c.y)(c.x) + 1
          next ::= n
        }
      }
      current = next
    }
    val pattern = readLine.trim.map{_.asDigit}.toArray
    val count = Array.tabulate(h){_ ⇒ Array.tabulate(w){_ ⇒ 0}}
    var ghost = state.indices.flatMap(h ⇒ state(h).indices.map{w ⇒ Coordinate(w, h)}).find{c ⇒ state(c.y)(c.x) == 'B'}.get

    var time = 0
    var firstContact: Option[(Int, Int, Int)] = None
    while (count(ghost.y)(ghost.x) <= pattern.length && firstContact.isEmpty){
      count(ghost.y)(ghost.x) += 1
      if (minTime(ghost.y)(ghost.x) <= time){
        firstContact = Some(time, ghost.y, ghost.x)
      }
      ghost = move(ghost, pattern(time % pattern.length), h, w)
      time += 1
    }
    var additional = 0
    while (firstContact.isEmpty && additional <= h * w){
      if (minTime(ghost.y)(ghost.x) <= time + additional){
        firstContact = Some(time + additional, ghost.y, ghost.x)
      }
      ghost = move(ghost, pattern((time + additional) % pattern.length), h, w)
      additional += 1
    }
    println(
      firstContact match {
        case Some((t, y, x)) ⇒ s"$t $y $x"
        case None ⇒ "impossible"
      }
    )
    solve
  }
  def move(coordinate: Coordinate, direction: Int, h: Int, w: Int): Coordinate = {
    (direction match {
      case 8 ⇒ Coordinate(0, -1) + coordinate
      case 6 ⇒ Coordinate(1, 0) + coordinate
      case 4 ⇒ Coordinate(-1, 0) + coordinate
      case 2 ⇒ Coordinate(0, 1) + coordinate
      case _ ⇒ coordinate
    }).let{c ⇒
      if ((0 until h).contains(c.y) && (0 until w).contains(c.x)) c
      else coordinate
    }
  }
  case class Coordinate(x: Int, y: Int) {
    def +(that: Coordinate): Coordinate = Coordinate(x + that.x, y + that.y)
    def neighbor: List[Coordinate] = List(Coordinate(x + 1, y), Coordinate(x - 1, y), Coordinate(x, y + 1), Coordinate(x, y - 1))
    def nextPosition: List[Coordinate] = this::neighbor
  }
  implicit class Extension[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}

Problem 06: Ghost Buster!

一般人には知る由も無いことだが、この街は幽霊で溢れている。そのほとんどは無害なのだが、困ったことに、人を呪う悪霊も少なからずいるのだ。

あるところに、そんな悪霊と戦う少女がいた。彼女は昼間は何食わぬ顔で高校に通いながらも、夜になると街中を歩き回り、彷徨える魂を見付けては成仏させるのだ。

幽霊を成仏させるためにはまずその幽霊に接近する必要があるのだが、それは簡単なことではない。幽霊は物をすり抜けられるからだ。幽霊は民家に壁から侵入して勝手口から出て行ったり、信号の無い大通りを悠々と横断したりする。人間である彼女にはそんなことはできないので、幽霊を追跡するのはとても難しいのだ。

彼女は経験上、幽霊が規則的な動きをすることを知っていた。そこで彼女は、この情報を活用して幽霊を追跡することを考えた。

彼女のいる街は、(H × W)マスのグリッドとして表される。彼女も幽霊も、1分間に1回、次の5つの行動

東へ1マス進む

西へ1マス進む

南へ1マス進む

北へ1マス進む

その場に留まる

のうちどれか1つを行うことができる。ただし、彼女は街の周囲に結界を張ったので、彼女も幽霊も街の外に出ることはできない。また、そのような行動をしようとした場合、代わりにその場に留まる。

それぞれのマスは '#' または '.' という文字によって表され、前者は幽霊だけが進入できるマスを、後者は両者が進入できるマスを表す。

幽霊の行動パターンは、L個の行動の列として与えられる。幽霊はこれらの行動を最初から順番に実行していき、全ての行動を実行し終わるとまた最初の行動に戻り、順に実行し続ける。

彼女と幽霊が N 分後に同じマスにいたならば、彼女と幽霊は時刻 N で遭遇したと言うことが出来る。幽霊は放っておくとどんな被害をもたらすか分からないので、彼女は出来るだけ早い時刻に幽霊を捕まえたい。なので、彼女は頼れる先輩であるあなたに、彼女と幽霊が遭遇できる最も早い時刻とその遭遇場所を求めるプログラムを書いてほしいと思っている。

さあ、彼女を助けて、彼女のありがたい言葉で彷徨える魂を極楽浄土へと導くのだ！

Input

複数のデータセットが与えられる。
各データセットの形式を以下に示す。

H W （グリッドの南北方向のマスの数、グリッドの東西方向のマスの数：　空白区切りの２つの整数）

H × W の文字　（マスの種類：'.', '#', 'A', または 'B'）

pattern （幽霊の行動パタン：文字列）

'A' は少女の初期位置、'B' は幽霊の初期位置を示す。両者の初期位置は、 '.' のマスの上にある。

pattern は '5', '2', '4', '6', '8' から成る文字列で、各文字の意味は以下の通りである：

'5'

その場に留まる

'8'

北に1マス進む

'6'

東に1マス進む

'4'

西に1マス進む

'2'

南に1マス進む

例えば、pattern が "8544" の場合、幽霊は「北に1マス進む」「その場に留まる」「西に1マス進む」「西に1マス進む」の行動パタンを繰り返す。

H, W は 1 以上 20 以下であり、pattern の長さは 10 以下である。

H, W がともに 0 のとき、入力は終了する。

Output

もし少女が幽霊と遭遇できるならば、最も早い遭遇時刻と、その遭遇場所の南北方向の座標、東西方向の座標を空白で区切って1行に出力せよ。グリッドの最北西を座標(0, 0)とし、最南東を座標(H-1, W-1) とする。

どのように行動しても絶対に遭遇できない場合は、 "impossible" と出力せよ。

Sample Input

4 7
A#...#B
.#.#.#.
.#.#.#.
...#...
5
4 7
A#...#B
.#.#.#.
.#.#.#.
...#...
2
4 7
A#...#B
.#.#.#.
.#.#.#.
...#...
4
4 7
A#...#B
.#.#.#.
.#.#.#.
...#...
442668
1 10
A#.......B
55555554
1 10
A#.......B
55555555
0 0

Output for the Sample Input

18 0 6
15 3 6
6 0 0
14 0 4
72 0 0
impossible


import scala.io.StdIn.readLine
import scala.io.StdIn.readInt

object Main {
  def main(args: Array[String]): Unit = {
    loop()

    def loop(): Unit = {
      val n = readInt()
      if (n != 0) {
        var t = readLine().split(' ').map(s => s.toInt)
        t = t :+ Int.MaxValue
        var ans: Seq[String] = Seq[String]()
        var preIdx = 0

        for (i <- 1 to n) {
          if (t(i - 1) + 1 != t(i)) {
            if (i - preIdx == 1) {
              ans = ans :+ t(i - 1).toString
            } else {
              ans = ans :+ s"${t(preIdx)}-${t(i - 1)}"
            }
            preIdx = i
          }
        }
        println(ans.mkString(" "))
        loop()
      }
    }
  }
}

Problem A: Citation Format

To write a research paper, you should definitely follow the structured format. This format, in many cases, is strictly defined, and students who try to write their papers have a hard time with it.

One of such formats is related to citations. If you refer several pages of a material, you should enumerate their page numbers in ascending order. However, enumerating many page numbers waste space, so you should use the following abbreviated notation:

When you refer all pages between page a and page b (a < b), you must use the notation "a-b". For example, when you refer pages 1, 2, 3, 4, you must write "1-4" not "1 2 3 4". You must not write, for example, "1-2 3-4", "1-3 4", "1-3 2-4" and so on. When you refer one page and do not refer the previous and the next page of that page, you can write just the number of that page, but you must follow the notation when you refer successive pages (more than or equal to 2). Typically, commas are used to separate page numbers, in this problem we use space to separate the page numbers.

You, a kind senior, decided to write a program which generates the abbreviated notation for your junior who struggle with the citation.

Input

Input consists of several datasets.

The first line of the dataset indicates the number of pages n.

Next line consists of n integers. These integers are arranged in ascending order and they are differ from each other.

Input ends when n = 0.

Output

For each dataset, output the abbreviated notation in a line. Your program should not print extra space. Especially, be careful about the space at the end of line.

Constraints

1 ≤ n ≤ 50

Sample Input

5
1 2 3 5 6
3
7 8 9
0

Output for the Sample Input

1-3 5-6
7-9


import java.util.Scanner

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.immutable.Queue

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(new Node(None, 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  @tailrec
  private def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) => root(p)
  }
}

object Main {
  def solve(sc: => Scanner): Unit = {
    val n, S = sc.nextInt
    if (n != 0 && S != 0) {
      val r = Array.fill(n)(sc.nextInt)
      var ans = 0
      var i = 0
      for (i <- 0 until n) {
        for (j <- i + 1 until n) {
          if (r(i) + r(j) > S) (ans += 1)
        }
      }
      println(ans)
      System.gc()
      solve(sc)
    }
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    solve(sc)
  }
}

Problem B: Spellcasters

n 人の魔法使いがいる。彼らには 1 から n までの番号があり、i 番目の魔法使いは魔力 ri ( 1 ≤ i ≤ n ) を持っている。いま彼らは強力な魔法使いと対峙しており、その敵の魔力は S である。n 人の魔法使いは協力して戦うのが得意で、特に 2 人で協力して戦うことを好む。2 人の魔法使いが協力した場合、魔力は単純にその和となり、強力な魔法などを駆使してある程度強い敵にも勝てるようになる。あなたの仕事は魔力 S を持つ敵に対して勝つことができる魔法使いのペア (i, j) ( i ≠ j かつ 1 ≤ i ≤ n かつ 1 ≤ j ≤ n ) の総数を出力することである。ただし (i, j) と (j, i) は同じ組として数える。一方の魔力が他方の魔力よりも大きいとき、大きい魔力を持っている側が勝つ。等しい場合は相打ちで勝ったことにならない。

Input

入力は複数のテストケースからなる。 各テストケースは以下の形式に従う。

n S
r1
r2
…
rn

各変数の意味は問題文中の通りである。
入力の終わりは、ふたつの0が一文字の空白で区切られる一行で示される。

Constraints

入力はすべて整数

1 ≤ n ≤ 20,000

1 ≤ ri ≤ 100 ( 1 ≤ i ≤ n )

1 ≤ S ≤ 100

テストケースの数は 100 を超えない。

Output

条件を満たす組 (i, j) (i ≠ j) の総数を各ケースに付き 1 行に出力せよ。

Sample Input

3 7
1
3
10
0 0

Sample Output

2


import java.util.Scanner

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.immutable.Queue

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(new Node(None, 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  @tailrec
  private def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) => root(p)
  }
}

object Main {
  def solve(sc: => Scanner): Unit = {
    var n, S = sc.nextInt
    val r = Array.fill(20001)(0)
    var count = 0
    while (n != 0 && S != 0) {
      //val r = Array.fill(n)(0)
      for (i <- 0 until n) {
        r(i) = sc.nextInt
      }
      var ans = 0
      var i = 0
      var j = 0
      while (i < n) {
        j = i + 1
        while (j < n) {
          if (r(i) + r(j) > S) (ans += 1)
          j += 1
        }
        i += 1
      }
      println(ans)

      if (count % 10 == 0) {
        System.gc()
      }
      n = sc.nextInt
      S = sc.nextInt
      count += 1
    }
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    solve(sc)
  }
}


import java.util.Scanner

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.immutable.Queue

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(new Node(None, 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  @tailrec
  private def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) => root(p)
  }
}

object Main {
  def solve(sc: => Scanner): Unit = {
    var n, S = sc.nextInt
    val r = Array.fill(20001)(0)
    var count = 0
    while (n != 0 && S != 0) {
      //val r = Array.fill(n)(0)
      for (i <- 0 until n) {
        r(i) = sc.nextInt
      }
      var ans = 0
      var i = 0
      var j = 0
      while (i < n) {
        j = i + 1
        while (j < n) {
          if (r(i) + r(j) > S) (ans += 1)
          j += 1
        }
        i += 1
      }
      println(ans)

      if (count % 20 == 0) {
        System.gc()
      }
      n = sc.nextInt
      S = sc.nextInt
      count += 1
    }
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    solve(sc)
  }
}


object Main extends App {
    val in = io.Source.stdin.getLines.map(_.split(" ").map(_.toInt))
    for (Array(n, r) <- in if n > 0 && r > 0) {
        val m = in.take(r).foldRight(0){
            case (Array(p, c), i) => if (i >= p - 1 + c) i else if (i >= c) i - c else i + p - 1
        }
        println(n - m)
    }
}

Problem A: Hanafuda Shuffle

There are a number of ways to shuffle a deck of cards. Hanafuda
shuffling for Japanese card game 'Hanafuda' is one such example.
The following is how to perform Hanafuda shuffling.

There is a deck of n cards. Starting from the p-th card
from the top of the deck, c cards are pulled out
and put on the top of the deck, as shown in Figure 1.
This operation, called a cutting operation, is repeated.

Write a program that simulates Hanafuda shuffling and answers which
card will be finally placed on the top of the deck.

Figure 1: Cutting operation

Input

The input consists of multiple data sets.
Each data set starts with a line containing two positive integers n
(1 <= n <= 50) and r (1 <= r <= 50); n and
r are the number of cards in the deck and the number of cutting
operations, respectively.

There are r more lines in the data set, each of which
represents a cutting operation. These cutting operations
are performed in the listed order.
Each line contains two positive integers p and c
(p + c <= n + 1).
Starting from the p-th card from the top of the deck, c
cards should be pulled out and put on the top.

The end of the input is indicated by a line which contains two zeros.

Each input line contains exactly two integers separated by a space
character.
There are no other characters in the line.

Output

For each data set in the input, your program
should write the number of the top card after the shuffle.
Assume that at the beginning the cards
are numbered from 1 to n, from the bottom to the top.
Each number should be written in a separate line
without any superfluous characters such as leading or following spaces.

Sample Input

5 2
3 1
3 1
10 3
1 10
10 1
8 3
0 0

Output for the Sample Input

4
4


import scala.annotation.tailrec
import scala.collection.mutable
import scala.io.StdIn._
object Main extends App {
  loop
  def loop: Unit = {
    val Array(w, h) = readLine.trim.split(' ').map(_.toInt)
    if (w == 0) return
    val state = Array.tabulate(h){_ ⇒ readLine.trim.toCharArray}
    val start = (0 until h).flatMap(y ⇒ (0 until w).find(x ⇒ state(y)(x) == '@').map(x ⇒ Point(x, y))).head
    val queue = mutable.Queue[Point](start)
    var count = 1
    while(queue.nonEmpty){
      val p = queue.dequeue()
      for (n ← p.neighbor if (0 until h).contains(n.y) && (0 until w).contains(n.x) && state(n.y)(n.x) == '.') {
        state(n.y)(n.x) = '#'
        queue.enqueue(n)
        count += 1
      }
    }
    println(count)
    loop
  }
  case class Point(x: Int, y: Int) {
    def neighbor = Array(Point(x + 1, y), Point(x - 1, y), Point(x, y + 1), Point(x, y - 1))
  }
}

Problem B: Red and Black

There is a rectangular room, covered with square tiles. Each tile is
colored either red or black. A man is standing on a black tile.
From a tile, he can move to one of four adjacent tiles. But he can't
move on red tiles, he can move only on black tiles.

Write a program to count the number of black tiles which he can reach
by repeating the moves described above.

Input

The input consists of multiple data sets.
A data set starts with a line containing two positive integers W and H;
W and H are the numbers of tiles in the x-
and y- directions, respectively. W and H are
not more than 20.

There are H more lines in the data set, each of which
includes W characters. Each character represents the color of a
tile as follows.

'.' - a black tile

'#' - a red tile

'@' - a man on a black tile(appears exactly once in a data set)

The end of the input is indicated by a line consisting of two zeros.

Output

For each data set, your program
should output a line which contains the number of
tiles he can reach from the initial tile (including itself).

Sample Input

6 9
....#.
.....#
......
......
......
......
......
#@...#
.#..#.
11 9
.#.........
.#.#######.
.#.#.....#.
.#.#.###.#.
.#.#..@#.#.
.#.#####.#.
.#.......#.
.#########.
...........
11 6
..#..#..#..
..#..#..#..
..#..#..###
..#..#..#@.
..#..#..#..
..#..#..#..
7 7
..#.#..
..#.#..
###.###
...@...
###.###
..#.#..
..#.#..
0 0

Output for the Sample Input

45
59
6
13


import scala.io.StdIn.readInt
import scala.collection.mutable.ArrayBuffer

object Main {
  def main(args:Array[String]) = {
    val b = new ArrayBuffer[Int]
    var n = 0
    while({n=readInt;n} != 0) {
      val m = { for(i<-1 to n) yield readInt }.sorted.dropRight(1).drop(1)
      b += m.sum/m.length
    }
    println(b.mkString("\n"))
  }

}

Problem A: ICPC Score Totalizer Software

The International Clown and Pierrot Competition (ICPC), is one of the
most distinguished and also the most popular events on earth in the
show business.

One of the unique features of this contest is the great number of
judges that sometimes counts up to one hundred. The number of judges
may differ from one contestant to another, because judges with any
relationship whatsoever with a specific contestant are temporarily
excluded for scoring his/her performance.

Basically, scores given to a contestant's performance by the judges
are averaged to decide his/her score. To avoid letting judges with
eccentric viewpoints too much influence the score, the highest and the
lowest scores are set aside in this calculation. If the same highest
score is marked by two or more judges, only one of them is ignored.
The same is with the lowest score. The average, which may contain
fractions, are truncated down to obtain final score as an integer.

You are asked to write a program that computes the scores of
performances, given the scores of all the judges, to speed up the event
to be suited for a TV program.

Input

The input consists of a number of datasets, each corresponding to a
contestant's performance. There are no more than 20 datasets in the input.

A dataset begins with a line with an integer n, the number of
judges participated in scoring the performance (3 ≤ n ≤
100). Each of the n lines following it has an integral
score s (0 ≤ s ≤ 1000) marked by a judge. No
other characters except for digits to express these numbers are in the
input. Judges' names are kept secret.

The end of the input is indicated by a line with a single zero in it.

Output

For each dataset, a line containing a single decimal integer
indicating the score for the corresponding performance should be
output. No other characters should be on the output line.

Sample Input

3
1000
342
0
5
2
2
9
11
932
5
300
1000
0
200
400
8
353
242
402
274
283
132
402
523
0

Output for the Sample Input

342
7
300
326


import scala.collection.mutable._
import io.StdIn.readInt
import io.StdIn.readLine

object Main extends App {
  val out = new java.io.PrintWriter(System.out)

  def calculate(q:Array[Int],d:Array[Array[Int]]):Int = {
    val ts = q(0)
    val te = q(1)
    val st = q(2)

    val a = d.filter(_(2) == st)
    val map = new HashMap[Int,Array[Int]]
    val log = ListBuffer.empty[Tuple2[Int,Int]]
    a.foreach(l => {
      if(l(3) == 1) map.put(l(1),l)
      else {
        val e = map.remove(l(1)).get
        log += {( e(0), l(0) )}
        }
    })
    // println(log.mkString)

    val time = Array.ofDim[Byte](721)
    log.par.foreach(t => {
      val s = math.max(ts, t._1) -540
      val e = math.min(te, t._2) -540
      (s until e).foreach(time(_) = 1)
    })
    time.sum
  }

  def solve(s:String):Unit = {
    val Array(n, m) = s.split(" ").map(_.toInt)
    val r = readInt
    val d = Iterator.continually(readLine)
      .take(r)
      .map(_.split(" ").map(_.toInt))
      .toArray
    val q = readInt
    Iterator.continually(readLine)
      .take(q)
      .map(_.split(" ").map(_.toInt))
      .foreach(qd => out.println(calculate(qd,d)))
  }

  Iterator.continually(readLine)
    .takeWhile(_ != "0 0")
    .foreach(solve(_))

  out.flush
}

Problem B: Analyzing Login/Logout Records

You have a computer literacy course in your university. In the computer
system, the login/logout records of all PCs in a day are stored in a
file. Although students may use two or more PCs at a time, no one can
log in to a PC which has been logged in by someone who has not
logged out of that PC yet.

You are asked to write a program that calculates the total time of a
student that he/she used at least one PC in a given time period
(probably in a laboratory class) based on the records in the file.

The following are example login/logout records.

The student 1 logged in to the PC 1 at 12:55

The student 2 logged in to the PC 4 at 13:00

The student 1 logged in to the PC 2 at 13:10

The student 1 logged out of the PC 2 at 13:20

The student 1 logged in to the PC 3 at 13:30

The student 1 logged out of the PC 1 at 13:40

The student 1 logged out of the PC 3 at 13:45

The student 1 logged in to the PC 1 at 14:20

The student 2 logged out of the PC 4 at 14:30

The student 1 logged out of the PC 1 at 14:40

For a query such as "Give usage of the student 1 between 13:00 and
14:30", your program should answer "55 minutes", that is, the sum of
45 minutes from 13:00 to 13:45 and 10 minutes from 14:20 to 14:30, as
depicted in the following figure.

Input

The input is a sequence of a number of datasets.
The end of the input is indicated by a line containing two zeros
separated by a space.
The number of datasets never exceeds 10.

Each dataset is formatted as follows.

N M

r

record1

...

recordr

q

query1

...

queryq

The numbers N  and M  in the first line are the numbers of
PCs and the students, respectively. r  is the number of
records. q  is the number of queries. These four are integers
satisfying the following.

1 ≤ N  ≤ 1000, 1 ≤ M  ≤ 10000, 2 ≤ r  ≤ 1000, 1 ≤ q  ≤ 50

Each record consists of four integers, delimited by a space, as follows.

t  n  m  s

s  is 0 or 1.
If s  is 1, this line means that the student m  logged in
to the PC n  at time t . If s  is 0, it means that
the student m  logged out of the PC n  at time t .
The time is expressed as elapsed minutes from 0:00 of the day.
t , n  and m  satisfy the following.

540 ≤ t  ≤ 1260,
1 ≤ n  ≤ N , 1 ≤ m  ≤ M

You may assume the following about the records.

Records are stored in ascending order of time t.

No two records for the same PC has the same time t.

No PCs are being logged in before the time of the first record
nor after that of the last record in the file.

Login and logout records for one PC appear alternatingly, and each of the login-logout record pairs is for the same student.

Each query consists of three integers delimited by a space, as follows.

ts  te  m

It represents "Usage of the student m  between
ts  and te ".
ts , te  and m
satisfy the following.

540 ≤ ts  < te  ≤ 1260,
1 ≤ m  ≤ M

Output

For each query, print a line having a decimal integer indicating the
time of usage in minutes. Output lines should not have any character
other than this number.

Sample Input

4 2
10
775 1 1 1
780 4 2 1
790 2 1 1
800 2 1 0
810 3 1 1
820 1 1 0
825 3 1 0
860 1 1 1
870 4 2 0
880 1 1 0
1
780 870 1
13 15
12
540 12 13 1
600 12 13 0
650 13 15 1
660 12 15 1
665 11 13 1
670 13 15 0
675 11 13 0
680 12 15 0
1000 11 14 1
1060 12 14 1
1060 11 14 0
1080 12 14 0
3
540 700 13
600 1000 15
1000 1200 11
1 1
2
600 1 1 1
700 1 1 0
5
540 600 1
550 650 1
610 620 1
650 750 1
700 800 1
0 0

Output for the Sample Input

55
70
30
0
0
50
10
50
0


import scala.collection.mutable._
import io.StdIn.readInt
import io.StdIn.readLine

object Main extends App {
  val out = new java.io.PrintWriter(System.out)

  def calculate(q:Array[Int],d:Array[Array[Int]]):Int = {
    val ts = q(0)
    val te = q(1)
    val st = q(2)

    val a = d.filter(_(2) == st)
    val map = HashMap.empty[Int,Array[Int]]
    val log = ListBuffer.empty[Tuple2[Int,Int]]
    a.foreach(l => {
      if(l(3) == 1) map.put(l(1),l)
      else {
        val e = map(l(1))
        log += {( e(0), l(0) )}
        }
    })
    // println(log.mkString)

    val time = Array.ofDim[Boolean](721)
    log.foreach(t => {
      val s = math.max(ts, t._1) -540
      val e = math.min(te, t._2) -540
      (s until e).foreach(time(_) = true)
    })
    time.count(_ == true)
  }

  def solve(s:String):Unit = {
    val Array(n, m) = s.split(" ").map(_.toInt)
    val r = readInt
    val d = Iterator.continually(readLine)
      .take(r)
      .map(_.split(" ").map(_.toInt))
      .toArray
    val q = readInt
    Iterator.continually(readLine)
      .take(q)
      .map(_.split(" ").map(_.toInt))
      .foreach(qd => out.println(calculate(qd,d)))
  }

  Iterator.continually(readLine)
    .takeWhile(_ != "0 0")
    .foreach(solve(_))

  out.flush
}


import scala.collection.mutable._
import io.StdIn.readInt
import io.StdIn.readLine

object Main extends App {
  val out = new java.io.PrintWriter(System.out)

  def calculate(q:Array[Int],d:Array[Array[Int]]):Int = {
    val ts = q(0)
    val te = q(1)
    val st = q(2)

    val a = d.filter(_(2) == st)
    val map = new HashMap[Int,Array[Int]]
    val log = new ListBuffer[Tuple2[Int,Int]]
    a.foreach(l => {
      if(l(3) == 1) map.put(l(1),l)
      else {
        val e = map(l(1))
        log += {( e(0), l(0) )}
        }
    })
    // println(log.mkString)

    val time = Array.ofDim[Boolean](721)
    log.foreach(t => {
      val s = math.max(ts, t._1) -540
      val e = math.min(te, t._2) -540
      (s until e).foreach(time(_) = true)
    })
    time.count(_ == true)
  }

  def solve(s:String):Unit = {
    // val Array(n, m) = s.split(" ").map(_.toInt)
    val r = readInt
    val d = Iterator.continually(readLine)
      .take(r)
      .map(_.split(" ").map(_.toInt))
      .toArray
    val q = readInt
    Iterator.continually(readLine)
      .take(q)
      .map(_.split(" ").map(_.toInt))
      .foreach(qd => out.println(calculate(qd,d)))
  }

  Iterator.continually(readLine)
    .takeWhile(_ != "0 0")
    .foreach(solve(_))

  out.flush
}


import scala.io.StdIn._

object Main extends App {
  var n = readInt()
  while (n != 0) {
    val parents = readLine.trim.split(' ').map(_.toInt - 1)
    val lengths = readLine.trim.split(' ').map(_.toInt)
    val allRemove = lengths.sum
    if (n == 2) {
      println(allRemove)
    }else {
      val islands = Array.fill(n) {
        Nil: List[Bridge]
      }
      for (i ← parents.indices) {
        islands(i + 1) ::= Bridge(parents(i), lengths(i))
        islands(parents(i)) ::= Bridge(i + 1, lengths(i))
      }
      val isLeaf = islands.map {
        _.lengthCompare(1) == 0
      }
      val minLength = Array.fill(n) {
        Int.MaxValue
      }

      def setMax(current: Int, len: Int = 0): Unit = {
        if (minLength(current) > len) {
          minLength(current) = len
          for (Bridge(next, length) ← islands(current)) {
            setMax(next, len + length)
          }
        }
      }

      setMax(0)
      val start = islands.indices.filterNot(isLeaf).maxBy(minLength)
      minLength.indices.foreach(i ⇒ minLength(i) = Int.MaxValue)
      setMax(start)
      val doubleMove = islands.indices.map { i ⇒ if (isLeaf(i)) 0 else islands(i).filterNot(e ⇒ isLeaf(e.to)).map(_.length).sum }.sum
      val singleMove = islands.indices.filterNot(isLeaf).map(minLength).max
      println(allRemove + doubleMove - singleMove)
    }
    n = readInt()
  }

  case class Bridge(to: Int, length: Int)

}

Bridge Removal

ICPC islands once had been a popular tourist destination.
For nature preservation, however, the government decided to prohibit entrance to the islands,
and to remove all the man-made structures there.
The hardest part of the project is to remove all the bridges connecting the islands.

There are n islands and n-1 bridges.
The bridges are built so that all the islands are reachable from all the other islands by
crossing one or more bridges.
The bridge removal team can choose any island as the starting point, and can repeat either of the
following steps.

Move to another island by crossing a bridge that is connected to the current island.

Remove one bridge that is connected to the current island, and stay at the same island after the removal.

Of course, a bridge, once removed, cannot be crossed in either direction.
Crossing or removing a bridge both takes time proportional to the length of the bridge.
Your task is to compute the shortest time necessary for removing all the bridges.
Note that the island where the team starts can differ from where the team finishes the work.

Input

The input consists of at most 100 datasets.
Each dataset is formatted as follows.

n

p2 p3 ... pn

d2 d3 ... dn

The first integer n (3 ≤ n ≤ 800) is the number of the islands.
The islands are numbered from 1 to n.
The second line contains n-1 island numbers pi
(1 ≤ pi < i), and tells that for each i
from 2 to n the island i and the island pi are connected by a bridge.
The third line contains n-1 integers di (1 ≤ di ≤ 100,000)
each denoting the length of the corresponding bridge.
That is, the length of the bridge connecting the island i and pi
is di. It takes di units of time to cross the bridge, and
also the same units of time to remove it.

Note that, with this input format, it is assured that all the islands are reachable each other by
crossing one or more bridges.

The input ends with a line with a single zero.

Output

For each dataset, print the minimum time units required to remove all the bridges in a single line.
Each line should not have any character other than this number.

Sample Input

4
1 2 3
10 20 30
10
1 2 2 1 5 5 1 8 8
10 1 1 20 1 1 30 1 1
3
1 1
1 1
0

Output for the Sample Input

80
136
2


import scala.annotation.tailrec

object Main extends App {

  override def main(args: Array[String]): Unit = {
    val answerMap = Solver.solveAll

    import scala.io.{StdIn => in}
    Iterator.continually(in.readLine()).takeWhile(_ != "0 0 0").map(_.split(" ")).map(arr => new Solver(arr(0).toInt, arr(1).toInt, arr(2).toInt))
      .map(solver => solver.solve(answerMap)).foreach(println)
  }

}

sealed trait Coordination {
  val x: Int
  val y: Int
}

object Coordination {
  def apply(x: Int, y: Int): Coordination =
    if (((x + y) & 1) == 1) OddCoordination(x, y)
    else EvenCoordination(x, y)

}

case class OddCoordination(x: Int, y: Int) extends Coordination {}

case class EvenCoordination(x: Int, y: Int) extends Coordination {}

case class Face(buttom: Int, southOrNoth: Int)

sealed trait CoordinationAndFace {
  val coordination: Coordination
  val face: Face

  def next: Seq[CoordinationAndFace]

  val toKeySring:String = List(coordination.x,coordination.y,face.buttom,face.southOrNoth).mkString(",")
}

object CoordinationAndFace {
  def apply(coordination: Coordination, face: Face): CoordinationAndFace = {
    coordination match {
      case e: EvenCoordination => EvenCoordinationAndFace(e, face)
      case o: OddCoordination => OddCoordinationAndFace(o, face)
    }
  }

  def apply(string: String): CoordinationAndFace  = {
    val arr = string.split(",")
    CoordinationAndFace(Coordination(arr(0).toInt,arr(1).toInt),Face(arr(2).toInt,arr(3).toInt))
  }
}

case class EvenCoordinationAndFace(coordination: EvenCoordination, face: Face) extends CoordinationAndFace {
  override def next = Seq(toNorth, toSouthEast, toSouthWest)

  val now = IcosahedronFaces(face.buttom)(face.southOrNoth)

  def toNorth: CoordinationAndFace = {
    val newCoordination = Coordination(coordination.x, coordination.y + 1)
    val nextFace = IcosahedronFaces(now.top)(now.n)
    val newFace = Face(nextFace.n, nextFace.top)
    CoordinationAndFace(newCoordination, newFace)
  }

  def toSouthWest: CoordinationAndFace = {
    val newCoordination = Coordination(coordination.x - 1, coordination.y)
    val nextFace = IcosahedronFaces(now.right)(now.n)
    val newFace = Face(nextFace.n, nextFace.left)
    CoordinationAndFace(newCoordination, newFace)
  }

  def toSouthEast: CoordinationAndFace = {
    val newCoordination = Coordination(coordination.x + 1, coordination.y)
    val nextFace = IcosahedronFaces(now.left)(now.n)
    val newFace = Face(nextFace.n, nextFace.right)
    CoordinationAndFace(newCoordination, newFace)
  }
}

case class OddCoordinationAndFace(coordination: OddCoordination, face: Face) extends CoordinationAndFace {
  override def next = Seq(toSouth, toNorthEast, toNorthWest)

  val now = IcosahedronFaces(face.buttom)(face.southOrNoth)

  def toSouth: CoordinationAndFace = {
    val newCoordination = Coordination(coordination.x, coordination.y - 1)
    val nextFace = IcosahedronFaces(now.top)(now.n)
    val newFace = Face(nextFace.n, nextFace.top)
    CoordinationAndFace(newCoordination, newFace)
  }

  def toNorthWest: CoordinationAndFace = {
    val newCoordination = Coordination(coordination.x - 1, coordination.y)
    val nextFace = IcosahedronFaces(now.left)(now.n)
    val newFace = Face(nextFace.n, nextFace.right)
    CoordinationAndFace(newCoordination, newFace)
  }

  def toNorthEast: CoordinationAndFace = {
    val newCoordination = Coordination(coordination.x + 1, coordination.y)
    val nextFace = IcosahedronFaces(now.right)(now.n)
    val newFace = Face(nextFace.n, nextFace.left)
    CoordinationAndFace(newCoordination, newFace)
  }

}

sealed case class IcosahedronFace(n: Int, top: Int, left: Int, right: Int) {
  def apply(asTop: Int): IcosahedronFace = {
    asTop match {
      case `top` => this
      case `left` => IcosahedronFace(n, left, right, top)
      case `right` => IcosahedronFace(n, right, top, left)
    }
  }
}

object IcosahedronFaces {
  private val list = List(
    IcosahedronFace(0, 5, 1, 4),
    IcosahedronFace(1, 6, 2, 0),
    IcosahedronFace(2, 7, 3, 1),
    IcosahedronFace(3, 8, 4, 2),
    IcosahedronFace(4, 9, 0, 3),
    IcosahedronFace(5, 0, 10, 11),
    IcosahedronFace(6, 1, 11, 12),
    IcosahedronFace(7, 2, 12, 13),
    IcosahedronFace(8, 3, 13, 14),
    IcosahedronFace(9, 4, 14, 10),
    IcosahedronFace(10, 15, 5, 9),
    IcosahedronFace(11, 16, 6, 5),
    IcosahedronFace(12, 17, 7, 6),
    IcosahedronFace(13, 18, 8, 7),
    IcosahedronFace(14, 19, 9, 8),
    IcosahedronFace(15, 10, 19, 16),
    IcosahedronFace(16, 11, 15, 17),
    IcosahedronFace(17, 12, 16, 18),
    IcosahedronFace(18, 13, 17, 19),
    IcosahedronFace(19, 14, 18, 15)
  )

  def apply(n: Int): IcosahedronFace = n match {
    case n: Int if ((0 to 19).contains(n)) => list(n)
  }
}

class Solver(x: Int, y: Int, n: Int) {
  def solve(answerMap: Map[String, Int]): Int = {
    val coordination = Coordination(x, y)
    val missing = coordination match {
      case e: EvenCoordination => 100
      case o: OddCoordination => 99
    }

    val iface = IcosahedronFaces(n)

    val keys = List(
      CoordinationAndFace(coordination, Face(n, iface.top)),
      CoordinationAndFace(coordination, Face(n, iface.left)),
      CoordinationAndFace(coordination, Face(n, iface.right))
    )

    keys.map(cf => answerMap.getOrElse(cf.toKeySring, missing)).min
  }

}

object Solver {

  def solveAll: Map[String, Int] = {

    val init: CoordinationAndFace = CoordinationAndFace(Coordination(0, 0), Face(0, 5))

    val itr =
      Iterator.iterate[(Map[String, Int], Vector[(String, Int)])](Map(init.toKeySring -> 0), Vector(init.toKeySring -> 0))(mv => solveInner(mv._1, mv._2)).takeWhile(_._2.head._2 < 98)

    itr.foldLeft((Map[String,Int](), Vector[(String, Int)]()))((z, n) => n)._1
  }

  private def solveInner(map: Map[String, Int], queue: Vector[(String, Int)]): (Map[String, Int], Vector[(String, Int)]) =
    queue match {
      case Vector(head, rest@_*) if (head._2 < 98) =>
        val candidate = CoordinationAndFace(head._1).next
        val nextCost = head._2 + 1
        val (newMap, newQueue) =
          candidate.filterNot(cf => map.contains(cf.toKeySring)).foldLeft((map, queue))((mq, next) => {
            (mq._1 + (next.toKeySring -> nextCost), mq._2 :+ (next.toKeySring, nextCost))
          })
        (newMap, newQueue.drop(1))
      case _ => (map, queue)
    }
}

Problem E: Driving an Icosahedral Rover

After decades of fruitless efforts, one of the expedition teams of ITO (Intersolar Tourism Organization) finally found a planet that would surely provide one of the best tourist attractions
within a ten light-year radius from our solar system. The most attractive feature of the planet,
besides its comfortable gravity and calm weather, is the area called Mare Triangularis. Despite
the name, the area is not covered with water but is a great plane. Its unique feature is that it is
divided into equilateral triangular sections of the same size, called trigons. The trigons provide
a unique impressive landscape, a must for tourism. It is no wonder the board of ITO decided
to invest a vast amount on the planet.

Despite the expected secrecy of the staff, the Society of Astrogeology caught this information
in no time, as always. They immediately sent their president's letter to the Institute of Science
and Education of the Commonwealth Galactica claiming that authoritative academic inspections
were to be completed before any commercial exploitation might damage the nature.

Fortunately, astrogeologists do not plan to practice all the possible inspections on all of the
trigons; there are far too many of them. Inspections are planned only on some characteristic
trigons and, for each of them, in one of twenty different scientific aspects.

To accelerate building this new tourist resort, ITO's construction machinery team has already succeeded in putting their brand-new
invention in practical use. It is a rover vehicle of the shape of an icosahedron, a regular polyhedron with twenty faces of equilateral triangles.
The machine is customized
so that each of the twenty faces exactly fits each of the trigons.
Controlling the high-tech gyromotor installed inside its body, the rover can roll onto one of the three trigons neighboring the one its bottom is
on.

Figure E.1: The Rover on Mare Triangularis

Each of the twenty faces has its own function. The set of equipments installed on the bottom
face touching the ground can be applied to the trigon it is on. Of course, the rover was meant to accelerate construction of the luxury hotels to host rich interstellar travelers, but, changing
the installed equipment sets, it can also be used to accelerate academic inspections.

You are the driver of this rover and are asked to move the vehicle onto the trigon specified by
the leader of the scientific commission with the smallest possible steps. What makes your task
more difficult is that the designated face installed with the appropriate set of equipments has to
be the bottom. The direction of the rover does not matter.

Figure E.2:The Coordinate System

Figure E.3: Face Numbering

The trigons of Mare Triangularis are given two-dimensional coordinates as shown in Figure E.2.
Like maps used for the Earth, the x axis is from the west to the east, and the y axis is from the
south to the north. Note that all the trigons with its coordinates (x , y) has neighboring trigons
with coordinates (x - 1 , y) and (x + 1 , y). In addition to these, when x + y is even, it has a
neighbor (x , y + 1); otherwise, that is, when x + y is odd, it has a neighbor (x , y - 1).

Figure E.3 shows a development of the skin of the rover. The top face of the development
makes the exterior. That is, if the numbers on faces of the development were actually marked
on the faces of the rover, they should been readable from its outside. These numbers are used
to identify the faces.

When you start the rover, it is on the trigon (0,0) and the face 0 is touching the ground. The
rover is placed so that rolling towards north onto the trigon (0,1) makes the face numbered 5
to be at the bottom.

As your first step, you can choose one of the three adjacent trigons, namely those with coordinates (-1,0), (1,0),
and (0,1), to visit. The bottom will be the face numbered 4, 1, and 5,
respectively. If you choose to go to (1,0) in the first rolling step, the second step can bring
the rover to either of (0,0), (2,0), or (1,-1). The bottom face will be either of 0, 6, or 2,
correspondingly. The rover may visit any of the trigons twice or more, including the start and the goal trigons, when appropriate.

The theoretical design section of ITO showed that the rover can reach any goal trigon on the
specified bottom face within a finite number of steps.

Input

The input consists of a number of datasets. The number of datasets does not exceed 50.

Each of the datasets has three integers x, y, and n in one line, separated by a space. Here, (x,y)
specifies the coordinates of the trigon to which you have to move the rover, and n specifies the
face that should be at the bottom.

The end of the input is indicated by a line containing three zeros.

Output

The output for each dataset should be a line containing a single integer that gives the minimum
number of steps required to set the rover on the specified trigon with the specified face touching
the ground. No other characters should appear in the output.

You can assume that the maximum number of required steps does not exceed 100. Mare Triangularis
is broad enough so that any of its edges cannot be reached within that number of
steps.

Sample Input

0 0 1
3 5 2
-4 1 3
13 -13 2
-32 15 9
-50 50 0
0 0 0

Output for the Sample Input

6
10
9
30
47
100


import scala.util.Random

object Main extends App {

  import scala.io.StdIn._
  import Tree._

  val Array(n, q) = readLine.trim.split(' ').map(_.toInt)
  val elements = List.tabulate(n){_ ⇒ readLine.trim.toInt}
  val tree = treeOf(elements:_*)
  for (_ ← 0 until q){
    val Array(x, y, z) = readLine.trim.split(' ').map(_.toInt)
    x match {
      case 0 ⇒
        val value = tree.find(z)
        tree.erase(z)
        tree.insert(y, value)
      case 1 ⇒
        println(tree.min(y, z))
      case 2 ⇒
        tree.erase(y)
        tree.insert(y, z)
      case _ ⇒ ???
    }
    //println(tree.toList.mkString(" "))
  }
  implicit class ScopeFunc[T](val value: T) {
    def let[A](func: T ⇒ A): A = func(value)

    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
  }
}
package object Tree{
  private val rand: Random = new Random(1)
  def treeOf(elements: Int*): Tree = {
    val tree = new TreeImpl()
    for ((v,i) ← elements.zipWithIndex) {
      tree.insert(i, v)
    }
    tree
  }
  sealed trait Tree{
    def size: Int
    def insert(rank: Int, value: Int): Unit
    def erase(rank: Int): Unit
    def find(rank: Int): Int
    def min(from: Int, to: Int): Int
    def toList: List[Int]
  }
  private class TreeImpl(var tree: Option[Tree] = None) extends Tree{
    override def size: Int = tree.map(_.size).getOrElse(0)

    override def insert(rank: Int, value: Int): Unit = {
      tree match {
        case None ⇒ tree = Some(new Node(0.5, value, None, None))
        case Some(t) ⇒ t.insert(rank, value)
      }
    }

    override def erase(rank: Int): Unit = {
      tree match {
        case Some(t) if t.size == 1 ⇒ tree = None
        case Some(t) ⇒ t.erase(rank)
      }
    }

    override def find(rank: Int): Int = tree.map(_.find(rank)).get

    override def min(from: Int, to: Int): Int = tree.map(_.min(from, to)).get

    override def toList: List[Int] = tree.map(_.toList).getOrElse(Nil)
  }
  private class Node(var priority: Double, var value: Int, var left: Option[Node], var right: Option[Node]) extends Tree{
    var size: Int = List(left, right).flatMap{_.map(_.size)}.sum + 1
    var min: Int = math.min(value, List(left, right).flatMap(_.map(_.min)).fold(Int.MaxValue){case (a, b) ⇒ if (a > b) b else a})
    private def _renewMin: Unit = {
      min = math.min(value, List(left, right).flatMap(_.map(_.min)).fold(Int.MaxValue){case (a, b) ⇒ if (a > b) b else a})
    }
    private def _isLeaf: Boolean = size == 1
    private def _insert(rank: Int, value: Int, priority: Double): Unit = {
      size += 1
      (left, right) match {
        case (None, None) ⇒ rank match {
          case 0 ⇒
            if (priority > this.priority) {
              right = Some(new Node(this.priority, this.value, None, None))
              this.priority = priority
              this.value = value
            } else {
              left = Some(new Node(priority, value, None, None))
            }
          case 1 ⇒
            if (priority > this.priority){
              left = Some(new Node(this.priority, this.value, None, None))
              this.priority = priority
              this.value = value
            }else{
              right = Some(new Node(priority, value, None, None))
            }
        }
        case (Some(l), None) ⇒
          if (l.size >= rank) {
            l._insert(rank, value, priority)
            if (priority > this.priority) {
              right = Some(new Node(this.priority, this.value, l.right, right))
              this.priority = l.priority
              this.value = l.value
              left = l.left
            }
          } else {
            if (priority > this.priority){
              left = Some(new Node(this.priority, this.value, left, right))
              this.priority = priority
              this.value = value
            }else {
              right = Some(new Node(priority, value, None, None))
            }
          }
        case (None, Some(r)) ⇒
          if (rank == 0){
            if (priority > this.priority){
              right = Some(new Node(this.priority, this.value, left, right))
              this.priority = priority
              this.value = value
            }else {
              left = Some(new Node(priority, value, None, None))
            }
          }else {
            r._insert(rank - 1, value, priority)
            if (priority > this.priority) {
              left = Some(new Node(this.priority, this.value, left, r.left))
              this.priority = priority
              this.value = value
              right = r.right
            }
          }
        case (Some(l), Some(r)) ⇒
          if (l.size >= rank){
            l._insert(rank, value, priority)
            if (priority > this.priority){
              right = Some(new Node(this.priority, this.value, l.right, right))
              this.priority = priority
              this.value = value
              left = l.left
            }
          } else {
            r._insert(rank - l.size - 1, value, priority)
            if (priority > this.priority){
              left = Some(new Node(this.priority, this.value, left, r.left))
              this.priority = priority
              this.value = value
              right = r.right
            }
          }
      }
      _renewMin
    }

    override def toString: String = toList.mkString(" ")
    private def _erase(rank: Int): Unit = {
      //println(s"rank = $rank, left = (${left.map(_.toString).getOrElse("")}) current = $value right = ${right.map(_.toString).getOrElse("")}")
      size -= 1
      (left, right) match {
        case (Some(l), Some(r)) ⇒ {
          l.size.compare(rank) match {
            case 1 ⇒ {
              if (l._isLeaf) {
                left = None
              } else {
                l._erase(rank)
              }
            }
            case -1 ⇒ {
              if (r._isLeaf){
                right = None
              }else {
                r._erase(rank - l.size - 1)
              }
            }
            case 0 ⇒ {
              if (l.priority > r.priority) {
                right = Some(new Node(this.priority, this.value, l.right, right))
                this.priority = l.priority
                this.value = l.value
                left = l.left
                right.foreach(_._erase(rank - l.left.map(_.size).getOrElse(0) - 1))
              } else {
                left = Some(new Node(this.priority, this.value, left, r.left))
                this.priority = r.priority
                this.value = r.value
                right = r.right
                left.foreach(_._erase(rank))
              }
            }
            case _ ⇒ ???
          }
        }
        case (Some(l), None) ⇒ {
          l.size.compare(rank) match {
            case 0 ⇒ {
              this.priority = l.priority
              this.value = l.value
              left = l.left
              right = l.right
            }
            case 1 ⇒ {
              if (l._isLeaf) {
                left = None
              }else{
                l._erase(rank)
              }
            }
            case _ ⇒ ???
          }
        }
        case (None, Some(r)) ⇒ {
          0.compare(rank) match {
            case 0 ⇒ {
              this.priority = r.priority
              this.value = r.value
              left = r.left
              right = r.right
            }
            case -1 ⇒ {
              if (r._isLeaf){
                right = None
              }else{
                r._erase(rank - 1)
              }
            }
            case _ ⇒ ???
          }
        }
        case _ ⇒ ???
      }
      _renewMin
    }
    private def _find(rank: Int): Int = {
      (left, right) match {
        case (Some(l), Some(r)) ⇒ {
          l.size.compare(rank) match {
            case 0 ⇒ value
            case -1 ⇒ r._find(rank - l.size - 1)
            case 1 ⇒ l._find(rank)
            case _ ⇒ ???
          }
        }
        case (Some(l), None) ⇒ {
          l.size.compare(rank) match {
            case 0 ⇒ value
            case 1 ⇒ l._find(rank)
            case _ ⇒ ???
          }
        }
        case (None, Some(r)) ⇒ {
          0.compare(rank) match {
            case 0 ⇒ value
            case -1 ⇒ r._find(rank - 1)
            case _ ⇒ ???
          }
        }
        case (None, None) ⇒ value
      }
    }
    private def _min(from: Int, to: Int): Int = {
      if (from <= 0 && to >= size - 1) min
      else if (from >= size || to < 0) Int.MaxValue
      else {
        (left, right) match {
          case (Some(l), Some(r)) ⇒
            List(l._min(from, to), r._min(from - l.size - 1, to - l.size - 1), if ((from to to).contains(l.size)) value else Int.MaxValue).min
          case (Some(l), None) ⇒
            List(l._min(from, to), if ((from to to).contains(l.size)) value else Int.MaxValue).min
          case (None, Some(r)) ⇒
            List(r._min(from - 1, to - 1), if ((from to to).contains(0)) value else Int.MaxValue).min
          case (None, None) ⇒ value
        }
      }
    }

    private def _toList(list: List[Int]): List[Int] = {
      (left, right) match {
        case (Some(l), Some(r)) ⇒ l._toList(value::r._toList(list))
        case (Some(l), None) ⇒ l._toList(value::list)
        case (None, Some(r)) ⇒ value::r._toList(list)
        case (None, None) ⇒ value::list
      }
    }

    override def insert(rank: Int, value: Int): Unit = {
      require((0 to size).contains(rank))
      assert(List(left, right).flatMap(_.map(_.size)).sum + 1 == size)
      val priority = rand.nextDouble()
      _insert(rank, value, priority)
    }
    override def erase(rank: Int): Unit = {
      require((0 to size).contains(rank))
      assert(List(left, right).flatMap(_.map(_.size)).sum + 1 == size)
      _erase(rank)
    }
    def find(rank: Int): Int = {
      require((0 until size).contains(rank))
      _find(rank)
    }

    override def min(from: Int, to: Int): Int = {
      require((0 until size).contains(from) && (0 until size).contains(to) && from <= to)
      _min(from, to)
    }

    override def toList: List[Int] = {
      _toList(Nil)
    }
  }

}
/*
 */

Problem I : RMQ

n 個の数字a0 ,a1 , ... ,an-1 とq が与えられる。

q 個のクエリーに対して適切な処理を行なって欲しい。

クエリーは以下の3種類の操作が存在する。

値のシフトを行う

l とr のペアが与えられる。(l < r )
al から ar までの値を Circular Shiftさせる。

0 1 2 3 4 5 6 7 8 9

に対してl=2,r=5というクエリーが与えられたとする。

シフトを行った数字列は

0 1 5 2 3 4 6 7 8 9

となる。

最小値を求める

l とr のペアが与えられる。(l ≤ r )

al から arまでの値の中で最小の値を求める。

値の更新

pos と val のペアが与えられる。
apos の値を val に更新する。

Input

入力は以下のフォーマットで与えられる。

n q
a0
a1
.
.
.
an-1
x1 y1 z1
x2 y2 z2
.
.
.
xq yq zq

xi = 0 なら、シフトのクエリーを表す。このとき、l = yi , r = zi とする。

xi = 1 なら、最小値を求めるクエリーを表す。このとき、l = yi , r = zi とする。

xi = 2 なら、値を更新するクエリーを表す。このとき、pos = yi , val = zi とする。

入力は以下の制約を満たす

1 ≤ n , q ≤ 200,000

0 ≤ ai ≤ 10,000,000

値を更新するクエリーについて、0 ≤ val ≤ 10,000,000

Output

クエリーとしてxi = 1 が与えられたときに、答えの値を１行に出力せよ。

Sample Input 1

10 3
0
1
2
3
4
5
6
7
8
9
1 5 7
0 2 5
1 5 7

Sample Output 1

5
4

Sample Input 2

10 10
289383
930886
692777
636915
747793
238335
885386
760492
516649
641421
2 7 368690
1 3 6
0 2 6
1 1 8
0 2 9
2 2 665123
1 5 9
0 2 8
2 7 961393
1 1 2

Sample Output 2

238335
238335
238335
368690


object Main extends App {

  import scala.io.StdIn._
  import scala.math._
  val Array(w, h) = readLine.trim.split(' ').map(_.toInt)
  val n = readLine.trim.toInt
  val order = readLine.trim.split(' ').map(_.toInt == 0)
  var outside = 2 * w + h - 2
  var inside = outside - 4
  var count = 0
  for (isOutside ← order){
    if (isOutside) outside -= 1
    else inside -= 1
    if (isNeighbor(inside, outside)) count += 1
  }
  println(count)
  def isNeighbor(inside:Int, outside: Int): Boolean = {
    if (outside.isOutsideBottom && inside.isInsideBottom) outside.outsideBottomPosition == inside.insideBottomPosition
    else if (outside.isOutsideRight && inside.isInsideRight) outside.outsideRightPosition == inside.insideRightPosition
    else if (outside.isOutsideUp && inside.isInsideUp) outside.outsideUpPosition == inside.insideUpPosition
    else false
  }
  implicit class INT(val value: Int){
    def isOutsideBottom: Boolean = (1 until w).contains(value)
    def outsideBottomPosition: Int = value - 0
    def isOutsideRight: Boolean = (w + 1 to (w + h - 2)).contains(value)
    def outsideRightPosition: Int = value - w
    def isOutsideUp: Boolean = ((w + h) to (2 * w + h - 2)).contains(value)
    def outsideUpPosition: Int = value - w - h + 1
    def isInsideBottom: Boolean = (1 to w - 1).contains(value)
    def insideBottomPosition: Int = value - 0
    def isInsideRight: Boolean = (w - 1 to (w + h - 4)).contains(value)
    def insideRightPosition: Int = value - w + 2
    def isInsideUp: Boolean = (w + h - 4 to 2 * w + h - 6).contains(value)
    def insideUpPosition: Int = value - w - h + 5
  }

  implicit class Extension[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}

Product Sale Lines

Problem

ウニクロ卯月さんと目黒凛さんはSEARIGHT LIVE FESの物販に来ている。下図のように、物販列は二列からなり、横にW人、縦にH人並べる大きさでコの字の形をしている。列の先頭の人は買い物をした後に列からはけ、同じ列の後ろの人々はそれぞれ一人分ずつ列を詰める。

二人は最初に物販列の最後尾に隣同士で、それぞれ違う列に（下図オレンジと濃い青色の位置）並んでいる。二人はとても仲がよいため、常にできるだけ近くにいたい。しかし、人のはけ方は列によって違うため、違う列に並んでいる二人の位置は離れてしまう可能性がある。

あなたの仕事は、列のはけ方が与えられたとき、二人が隣同士になる回数を求めることである。
ただし、二人ともコの字の角にいる（上図の黒色の状態の）ときは、隣同士とみなさない。また、並んだ直後は隣同士に並んでいるが、これは数えない。

Input

入力は以下の形式で与えられる。

W H
N
p1 p2 ... pN

1行目に列の大きさを表す整数WとHが空白区切りで与えられる。Wはコの字の横に並べる外側の人数を、Hは縦に並べる外側の人数を表す。2行目に人が一人どちらかの列からはける回数Nが与えられる。3行目には列のはけ方についての情報p1...pNが空白区切りで与えられる。piに’0’または’1’であり、’0’のとき、外側の人が一人はけることを、’1’のとき内側の人が一人はけることを表す。ただし、ウニクロ卯月さんまたは目黒凛さんが列から出ることはない。

Constraints

4 ≤ W ≤ 100

4 ≤ H ≤ 100

0 ≤ N ≤ 100

Output

二人が隣同士になる回数を一行に出力せよ。

Sample Input 1

11 11
5
0 0 0 0 0

Sample Output 1

0

Sample Input 2

11 11
5
0 0 1 1 1

Sample Output 2

1


import scala.collection.mutable

object Main extends App {

  import scala.io.StdIn._

  val Array(n, m) = readLine.trim.split(' ').map(_.toInt)
  val islands = Array.tabulate(n) { _ ⇒ Nil: List[(Int, Int)]}
  for (_ ← 0 until m){
    val Array(a, b, c) = readLine.trim.split(' ').map(_.toInt)
    islands(a - 1) ::= (b - 1, c)
  }
  val minTime = Array.tabulate(n){_ ⇒ Int.MaxValue}.also{ar ⇒ ar(0) = 0}
  val queue = mutable.PriorityQueue()(Ordering.by[(Int, Int), Int](_._2).reverse).also{q ⇒ q.enqueue((0, 0))}
  while (queue.nonEmpty){
    val (current, time) = queue.dequeue()
    if (minTime(current) == time && current != n - 1){
      for ((next, c) ← islands(current)) {
        if (time <= c && minTime(next) > c) {
          minTime(next) = c
          queue.enqueue((next, c))
        }
      }
    }
  }

  var lastTime = -1
  for (from ← islands.indices){
    islands(from).filter(_._1 == n - 1).foreach{
      case (_, c) if minTime(from) <= c && lastTime < c ⇒ lastTime = c
      case _ ⇒
    }
  }
  println(lastTime)
  implicit class Extend[T](value: T){
    def also(func: T ⇒ Unit): T = {func(value); value}
    def let[A](func: T ⇒ A): A = func(value)
  }
}

Problem D: One-Time Path

Problem

N個の島とM本の橋がある。
N個の島にはそれぞれ1からNまでの番号が割り振られている。
M本の橋にもそれぞれ1からMまでの番号が割り振られている。

がっちょ君は現在(時刻0の時点で)、1番目の島にいる。
がっちょ君はi番目の橋を利用することにより、ai番目の島からbi番目の島へと単方向に移動することができる。

しかし、時刻0の時点では、すべての橋は潮が満ちていて海の中に沈んでしまっている。
i番目の橋は、時刻ciになると潮が引いて渡れるようになる。
そして、時刻ciを過ぎると、すぐにまた潮が満ちてi番目の橋は再び沈んでしまう。
再び沈んでしまうと、またいつ潮が引いて渡れるようになるかはわからない。
そこで、がっちょ君はそうなった橋は永遠に渡れなくなると考えるようにした。

がっちょ君は、できるだけ長い間、1からN-1番目の島の景色を眺めていたいのだが、N番目の島に船を泊めてあるので、最終的にはN番目の島に到着していなければならない。また、船の中で両親を待たせているため、がっちょ君はN番目の島についたらすぐに船で出発して家へと帰らなければならない。

がっちょ君が橋を渡ったり島の中を移動する時間はとても短いので、0と仮定してよい。がっちょ君が1からN-1番目のいずれかの島にいることのできる時間の最大値を求めよ。ただし、どのように移動してもがっちょ君がN番目の島へと移動できない場合は代わりに-1を出力せよ。

Input

入力は以下の形式で与えられる。

N M
a1 b1 c1
a2 b2 c2
…
aM bM cM

1行目には、2つの整数N, Mが空白区切りで与えられる。

2行目からM+1行目のそれぞれの行iには、3つの整数ai, bi, ciが空白区切りで与えられる。

Constraints

2 ≤ N ≤ 105

1 ≤ M ≤ 2 × 105

1 ≤ ai < N

1 ≤ bi ≤ N

1 ≤ ci ≤ 109

ai ≠ bi

Output

がっちょ君がN番目の島へと移動できる場合は、がっちょ君が1からN-1番目のいずれかの島にいることのできる時間の最大値を出力する。N番目の島へと移動できない場合は、代わりに-1を出力する。

Sample Input 1

3 2
1 2 10
2 3 20

Sample Output 1

20

まず、1番目の島で時刻が10になるまで待ってから、2番目の島へと移動する。

次に、2番目の島で時刻が20になるまで待ってから、3番目の島へと移動する。

以上より、1から2番目のいずれかの島にいる時間は20となる。

Sample Input 2

4 4
1 2 27
1 3 37
2 3 47
3 1 57

Sample Output 2

-1

4番目の島に繋がる橋がないため、4番目の島へ移動することができない。

Sample Input 3

3 3
1 2 13
2 3 17
2 3 15

Sample Output 3

17

Sample Input 4

3 2
1 2 20
2 3 10

Sample Output 4

-1

Sample Input 5

3 2
1 2 10
2 3 10

Sample Output 5

10


object Main {

  def main(args: Array[String]) {
    val source = scala.io.Source.stdin.getLines

    while(true) {
      val  input: Array[Int] = source.next().split(" ").map(_.toInt)

      if (input.forall(_ == 0)) {
        return
      }

      val datas: Array[Int] = source.take(input(0)).map(_.toInt).toArray
      val maximum: (Int, Int) =  (input(1) to input(2)).map(n => (n, datas(n - 1) - datas(n))).reverse.maxBy(v => v._2)

      println(maximum._1)

    }
  }
}

Entrance Examination

The International Competitive Programming College (ICPC) is famous
for its research on competitive programming.
Applicants to the college are required to take its entrance examination.

The successful applicants of the examination are chosen as follows.

The score of any successful applicant is higher than that of any unsuccessful applicant.

The number of successful applicants n must be between nmin and nmax, inclusive.
We choose n within the specified range that maximizes the gap.
Here, the gap means the difference between the lowest score of
successful applicants and the highest score of unsuccessful applicants.

When two or more candidates for n make exactly the same gap,
use the greatest n among them.

Let's see the first couple of examples given in Sample Input below.
In the first example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 82, 70, and 65.
For n of two, three and four, the gaps will be 8, 12, and 5, respectively.
We must choose three as n, because it maximizes the gap.

In the second example, nmin and nmax are two and four, respectively, and there are five applicants whose scores are 100, 90, 80, 75, and 65.
For n of two, three and four, the gap will be 10, 5, and 10,
respectively. Both two and four maximize the gap, and we must choose the
greatest number, four.

You are requested to write a program that computes the number of successful applicants that satisfies the conditions.

Input

The input consists of multiple datasets. Each dataset is formatted as follows.

m nmin nmax

P1

P2

...

Pm

The first line of a dataset contains three integers separated by single spaces.
m represents the number of applicants, nmin represents the minimum number of successful applicants, and nmax represents the maximum number of successful applicants.
Each of the following m lines contains an integer
Pi, which represents the score of each applicant.
The scores are listed in descending order.
These numbers satisfy 0 < nmin < nmax < m ≤ 200, 0 ≤ Pi ≤ 10000 (1 ≤ i ≤ m) and Pnmin > Pnmax+1. These ensure that there always exists an n satisfying the conditions.

The end of the input is represented by a line containing three zeros separated by single spaces.

Output

For each dataset, output the number of successful applicants in a line.

Sample Input

5 2 4
100
90
82
70
65
5 2 4
100
90
80
75
65
3 1 2
5000
4000
3000
4 2 3
10000
10000
8000
8000
4 2 3
10000
10000
10000
8000
5 2 3
100
80
68
60
45
0 0 0

Output for the Sample Input

3
4
2
2
3
2