結果

問題 No.513 宝探し2
ユーザー Goryudyuma
提出日時 2018-07-13 07:53:02
言語 Scala(Beta)
(2.12.7)
結果
AC  
実行時間 373 ms
コード長 4,016 Byte
コンパイル時間 10,125 ms
使用メモリ 50,048 KB
平均クエリ数 3.50
最終ジャッジ日時 2019-02-18 14:38:54

テストケース

テストケース表示
入力 結果 実行時間
使用メモリ
test1.txt AC 353 ms
49,960 KB
test2.txt AC 371 ms
50,000 KB
test3.txt AC 368 ms
49,996 KB
test4.txt AC 368 ms
50,048 KB
test5.txt AC 361 ms
49,972 KB
test6.txt AC 366 ms
49,992 KB
test7.txt AC 373 ms
48,852 KB
test8.txt AC 367 ms
48,860 KB
test9.txt AC 354 ms
49,904 KB
test10.txt AC 359 ms
49,964 KB
test11.txt AC 355 ms
49,792 KB
test12.txt AC 362 ms
49,972 KB
テストケース一括ダウンロード

ソースコード

diff #
import java.util.Scanner

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.mutable
import scala.collection.immutable._
import scala.io.StdIn.readLine

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)

  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 = {
    System.out.println("0 0")
    val xy = sc.nextLong
    if (xy != 0) {
      System.out.println("0 100000")
      val y2 = sc.nextLong
      if (y2 != 0) {
        val y: Long = (xy + y2 - 100000) / 2

        System.out.println("100000 0")
        val x2 = sc.nextLong
        if (x2 != 0) {
          val x: Long = (xy + x2 - 100000) / 2

          System.out.println(y + " " + x)
        }
      }
    }
  }

  def recursive(ax: Long, bx: Long, ay: Long, by: Long): Unit = {

  }

  def recursive2(N: Long): String = {
    if (N == 0) ("") else (('a'.toInt + (N % 26)).toChar + recursive2(N / 26))
  }

  def check(A: Array[List[Int]]): Boolean = {
    A.map(_.size == 0).fold(true)((a, b) => a & b)
  }

  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 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) == None)
    }
    }) => {

      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())
    }
  }
}
0