Problem:
社員旅行

Problem Statement

あなたの会社にはn人の社員が存在する．m個の社員(a_i,b_i)の組について，a_iはb_iの上司である．

社員xが社員yの実質的な上司であるとは，次のうち少なくとも一方が成り立つことをいう．

xがyの上司である．

yの実質的な上司である社員zが存在して，xはzの上司である．

あなたの会社で，自分自身が自分の実質的な上司であるような社員は存在しない．

あなたの会社では社員が全員参加する社員旅行が計画されている．全社員の要求により，旅館での部屋割りは「よい部屋割り」でなければならない．

ある部屋割りが「よい部屋割り」であるとは以下の両方が満たされることをいう．

各社員はどこかの部屋に割り振られる．

社員xと社員yが同じ部屋に割り振られているとき，xはyの実質的な上司でない．

幹事の社員は非常に優秀なので，「よい部屋割り」でかつ必要な部屋の数が最小になるように部屋割りを行った．しかし残念なことに予算が不足している．どうしても必要な部屋の数を減らさなければならないらしい．

そこで，人事部で働くあなたは上司-部下の関係を一つだけ解消することによって，「よい部屋割り」を得るために必要な部屋の数を減らすことにした．

さて，どの関係を解消すればよいのだろう？

Input

入力は以下の形式に従う．与えられる数は全て整数である．

n m
a_1 b_1
...
a_m b_m

Constraints

2≦n≦10^5

1≦m≦2 \times 10^5

1≦a_i<b_i≦n

i \neq jならば(a_i, b_i) \neq (a_j, b_j)

Output

次を満たすようなiを昇順に1行ずつ出力せよ．

「a_iがb_iの上司である」という関係を解消したとき，「よい部屋割り」を得るために必要な部屋の数を減らすことができる．

そのようなiが存在しない場合は-1を1行に出力せよ．

Sample Input 1

5 4
1 2
2 3
3 4
3 5

Output for the Sample Input 1

1
2

Solution in Scala (judge verdict: Accepted)

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

  val Array(n, m) = readLine.trim.split(' ').map(_.toInt)
  val down = Array.tabulate(n){_ ⇒ Nil: List[Int]}
  val up = Array.tabulate(n){_ ⇒ Nil: List[Int]}
  val downCount = Array.tabulate(n){_ ⇒ 0}
  val upCount = Array.tabulate(n){_ ⇒ 0}
  val longestDownPath = Array.tabulate(n){i ⇒ Path(i, 0)}
  val longestUpPath = Array.tabulate(n){i ⇒ Path(i, 0)}
  val edges = Array.tabulate(m){_ ⇒
    val Array(a, b) = readLine.trim.split(' ').map(_.toInt - 1)
    Edge(a, b)
  }
  for (Edge(a, b) ← edges){
    down(a) ::= b
    downCount(a) += 1
    up(b) ::= a
    upCount(b) += 1
  }
  var toUp: Seq[Int] = down.indices.filter(downCount(_) == 0)
  while(toUp.nonEmpty){
    var next = Nil: List[Int]
    toUp.foreach{ d ⇒
      for (u ← up(d)) {
        downCount(u) -= 1
        if (downCount(u) == 0) {
          longestDownPath(u).append(longestDownPath(d))
          next ::= u
        }
      }
    }
    toUp = next
  }
  var toDown: Seq[Int] = up.indices.filter(upCount(_) == 0)
  while(toDown.nonEmpty){
    var next = Nil: List[Int]
    toDown.foreach{u ⇒
      for (d ← down(u)){
        upCount(d) -= 1
        if (upCount(d) == 0){
          longestUpPath(d).append(longestUpPath(u))
          next ::= d
        }
      }
    }
    toDown = next
  }
  val currentMax = longestDownPath.maxBy(_.length).length
  val fromDownLength = Array.tabulate(currentMax + 1){_ ⇒ 0}
  for (p ← 0 until n if longestDownPath(p).length + longestUpPath(p).length == currentMax){
    fromDownLength(longestDownPath(p).length) += 1
  }
  val bottleNeck = edges.indices.filter{i ⇒
    val Edge(u, d) = edges(i)
    longestDownPath(u).length == longestDownPath(d).length + 1 &&
    longestDownPath(u).length + longestUpPath(u).length == currentMax &&
      longestDownPath(d).length + longestUpPath(d).length == currentMax &&
      fromDownLength(longestDownPath(u).length) == 1 &&
      fromDownLength(longestDownPath(d).length) == 1
  }
  if (bottleNeck.isEmpty) println(-1)
  else println(bottleNeck.map(_ + 1).mkString("\n"))



  case class Path(current: Int, var length: Int, var from: List[Int] = Nil) {
    def append(path: Path): Unit = {
      if (length < path.length + 1){
        length = path.length + 1
        from = List(path.current)
      }else if (length == path.length + 1){
        from ::= path.current
      }
    }
  }
  case class Edge(from: Int, to: Int)
  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)
  }

}