Problem:
C: 一致

問題

長さ $N$ の数列 $a_i$ が与えられる。
次の条件を満たす整数 $K (1 \le K \le N)$ を全て出力せよ。

条件:
$a_1, \cdots, a_K$ をうまく並び替えると $a_{N-K+1}, \cdots, a_N$ と一致する。

制約

$1 \le N \le 10^5$

$1 \le a_i \le 10^9$

入力は全て整数

入力:

$N$

$a_1 \cdots a_N$

出力:

条件を満たす $K$ を昇順に空白区切りで出力せよ。また末尾に改行を出力せよ。

サンプル

サンプル入力 1

8
5 2 4 9 4 9 2 5

サンプル出力 1

1 2 4 6 7 8

サンプル入力 2

3
5 7 5

サンプル出力 2

1 2 3

サンプル入力 3

9
118 118 97 116 97 97 114 110 101

サンプル出力 3

9

Solution in Scala (judge verdict: Accepted)

object Main extends App {

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

  val n = readLine.trim.toInt
  val numbers = readLine.trim.split(' ').map(_.toInt)
  val sorted = numbers.zipWithIndex.map{case (v, i) ⇒ ValueWithIndex(v, i)}.sorted
  val canMake = Array.tabulate(n){_ ⇒ 0}
  for (number ← numbers.distinct){
    val indices = (lowerBound(sorted, ValueWithIndex(number, 0)) until upperBound(sorted, ValueWithIndex(number, n))).map{i ⇒ sorted(i).index}
    for (k ← indices.indices){
      val left = indices(k) // (0 to left) にnumberがk
      val right = n - 1 - indices(indices.length - 1 - k) //(n - 1 - right until n) にnumberがk個含まれる最小インデックス
      if (right < left){
        canMake(right) -= 1
        canMake(left) += 1
      }else {
        canMake(left) -= 1
        canMake(right) += 1
      }
    }
  }
  for (i ← 1 until n){
    canMake(i) += canMake(i - 1)
  }
  println(
    canMake.zipWithIndex.filter{case (n, i) ⇒ n == 0}.map{case (_, i) ⇒ i + 1}.mkString(" ")
  )


  def lowerBound[T](array: Array[T], target: T)(implicit ordering: Ordering[T]): Int = {
    var left = 0
    var right = array.length
    while (left < right){
      val mid = (left + right) / 2
      if (ordering.compare(array(mid), target) < 0){
        left = mid + 1
      }else {
        right = mid
      }
    }
    right
  }
  def upperBound[T](array: Array[T], target: T)(implicit ordering: Ordering[T]): Int = {
    var left = 0
    var right = array.length
    while (left < right){
      val mid = (left + right) / 2
      if (ordering.compare(array(mid), target) <= 0){
        left = mid + 1
      }else {
        right = mid
      }
    }
    right
  }

  case class ValueWithIndex(value: Int, index: Int) extends Ordered[ValueWithIndex] {
    override def compare(that: ValueWithIndex): Int = if (value == that.value) index.compare(that.index) else value.compare(that.value)
  }

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