Problem:
G: エレベータ

問題

株式会社AORは $N$ 階建てのビルである。地下階は存在しない。

AORイカちゃんはイカであるため、階段を下りることは可能だが、上ることは不可能である。

上の階に登れないと不便なため、$M$ 個のエレベータをビルに設置することにした。

エレベータを設置するには時間がかかり、$i$ 番目のエレベータは $D_i$ 日後の夜に設置が完了し、 $A_i$ 階以上 $B_i$ 階以下の全ての階を移動可能にする。

あなたはAORイカちゃんに $Q$ 個の質問をされた。$i$ 番目の質問は「 $E_i$ 日後の昼に、$S_i$ 階から $T_i$ 階に移動可能か？」という質問である。

移動に使える手段は階段とエレベータのみである。また移動にかかる時間は無視できるものとする。

制約

$2 \le N \le 10^5$

$1 \le M \le 10^5$

$1 \le Q \le 10^5$

$1 \le D_i , E_i \le 10^9$

$1 \le A_i < B_i \le N$

$1 \le S_i , T_i \le N$

入力は全て整数

入力

$N \ M\ Q$

$D_1 \ A_1 \ B_1$

$\vdots$

$D_M \ A_M \ B_M$

$E_1 \ S_1 \ T_1$

$\vdots$

$E_Q \ S_Q \ T_Q$

出力

各質問ごとに一行で Yes または No を出力せよ。ただし質問された順に答えること。また末尾に改行を出力せよ。

サンプル

サンプル入力 1

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

サンプル出力 1

No
Yes

エレベータが設置されるのは三日目の夜であるため、三日目の昼に移動することはできない。

サンプル入力 2

8 6 5
30 6 7
21 3 8
5 2 4
10 1 2
2 7 8
15 5 7
16 5 8
11 1 3
22 3 7
30 6 7
15 5 8

サンプル出力 2

Yes
Yes
Yes
Yes
No

Solution in Scala (judge verdict: Accepted)


object Main extends App {

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


  val Array(n, m, q) = readLine.trim.split(' ').map(_.toInt)
  val floors = SegTree(1, n)
  for (_ ← 0 until m) {
    val Array(d, a, b) = readLine.trim.split(' ').map(_.toInt)
    floors.setUpperLimit(a, b - 1, d)
  }
  for (_ ← 0 until q){
    val Array(e, s, t) = readLine.trim.split(' ').map(_.toInt)
    val day = floors.maxBetween(s, t - 1)
    println(
      if (day < e) "Yes"
      else "No"
    )
  }
  object SegTree{
    def apply(from: Int, to: Int, default: Int = Int.MaxValue): SegTree = {
      if (from == to) new Leaf(default, from)
      else new Node(from, to, SegTree(from, (from + to) / 2, default), SegTree((from + to) / 2 + 1, to, default))
    }
  }
  sealed trait SegTree{
    def maxBetween(from: Int, to: Int): Int
    def setUpperLimit(from: Int, to: Int, limit: Int): Unit
    def upper: Int
  }
  class Node(private val mFrom: Int, private val mTo: Int, private val mLeft: SegTree, private val mRight: SegTree) extends SegTree {
    override def upper: Int = mUpper
    private var mUpper = math.max(mLeft.upper, mRight.upper)

    override def setUpperLimit(from: Int, to: Int, limit: Int): Unit = {
      if (mUpper > limit) {
        if (from <= mFrom && mTo <= to) {
          mUpper = limit
        } else if (from <= mTo && mFrom <= to) {
          mLeft.setUpperLimit(mFrom, mTo, mUpper)
          mLeft.setUpperLimit(from, to, limit)
          mRight.setUpperLimit(mFrom, mTo, mUpper)
          mRight.setUpperLimit(from, to, limit)
          mUpper = math.max(mLeft.upper, mRight.upper)
        }
      }
    }
    override def maxBetween(from: Int, to: Int): Int = {
      if (to < mFrom || mTo < from) Int.MinValue
      else if (from <= mFrom && mTo <= to) mUpper
      else {
        mLeft.setUpperLimit(mFrom, mTo, mUpper)
        mRight.setUpperLimit(mFrom, mTo, mUpper)
        math.max(mLeft.maxBetween(from, to), mRight.maxBetween(from, to))
      }
    }
  }
  class Leaf(private var mValue: Int, private val mPosition: Int) extends SegTree {
    override def maxBetween(from: Int, to: Int): Int = {
      if ((from to to).contains(mPosition)) mValue
      else Int.MinValue
    }

    override def setUpperLimit(from: Int, to: Int, limit: Int): Unit = {
      if ((from to to).contains(mPosition) && limit < mValue) mValue = limit
    }

    override def upper: Int = mValue
  }
  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)
  }
}