Problem:
B - ライオン

あなたは動物園に来てライオンを見ている。
この動物園にはn個のライオンのオリがある。
あなたはライオンが全部で何頭いるのか知りたくなったのだが、
一人で数えるのは大変だ。
そこで近くにいた動物園の来園者m人に協力してもらうことにした。

ライオンのオリは、それぞれ1番からn番までの数字がついており、
順番に並んでいる。
一つのオリには0頭以上x頭以下のライオンがいる。

m人の来園者でi番目の人(1 ≤ i ≤ m)には
l_i番から
r_i番までの
両端を含むすべてのオリのライオンの数の総和を数えてもらった。

この情報を元に、1からn
各オリの中のライオンの数を求めることにした。

入力形式

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

n x m
l_1 r_1 s_1
...
l_m r_m s_m

1行目は3つの整数n x mで、
それぞれオリの数、一つのオリの中のライオンの最大の数、
数えるのに協力した人の数である。
2行目から続くm行は各行3つの整数で、
それぞれi番目の人が数えた結果
l_i r_is_iである。
l_i番からr_i番までのオリのライオンを数えたら
合計s_i頭いたことを表している。

出力形式

数えてもらった結果が全て正しいとして、
1からnの
各オリの中のライオンの数を空白区切りのn個の整数で出力せよ。
そのような答が複数あるときは、
ライオンの数の合計が最大になるものをどれでも良いので一つ出力せよ。
条件を満たすライオンの配置が一つもないときは-1を出力せよ。

制約

1 ≤ n ≤ 6

1 ≤ x ≤ 10

1 ≤ m ≤ 10

1 ≤ l_i ≤ r_i ≤ n

0 ≤ s_i ≤ 60

入力値はすべて整数である。

入出力例

入力例 1

3 5 1
1 2 5

出力例 1

2 3 5

その他"4 1 5"や"0 5 5"なども正しい出力である。

入力例 2

4 5 2
1 3 15
3 4 3

出力例 2

-1

条件を満たすライオンの配置が一つもないときは-1を出力せよ。

Solution in Scala (judge verdict: Wrong Answer)

object Main extends App {

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

  val Array(n, x, m) = readLine.trim.split(' ').map(_.toInt)
  val gages = Array.tabulate(n + 1){_ ⇒ new Gage}
  for (_ ← 0 until m){
    val Array(l, r, s) = readLine.trim.split(' ').map(_.toInt)
    gages(l - 1).addRelation(r, s)
    gages(r).addRelation(l - 1, -s)
  }
  implicit val suspect = Array.tabulate(n + 1){_ ⇒ None: Option[Position]}
  var counter = 0
  val isNonParadoxical = (for (i ← suspect.indices) yield {
    suspect(i) match {
      case None ⇒
        suspect(i) = Some(Absolute(counter))
        counter += 1
        searchSub(gages, suspect, i)
      case _ ⇒ true
    }
  }).forall(i ⇒ i)

  val nonOptionalSuspects = suspect.flatten
  val rangesOfOrigin = Array.tabulate(counter){_ ⇒ Nil: List[(Int, Int)]}.also{arr ⇒
    for (i ← 1 until arr.length){
      // i - x <= 0
      // 0 - 0 <= i
      arr(0) ::= (i, x * i)
      arr(i) ::= (0, 0)
  }}
  for (i ← 1 to n){
    val left = nonOptionalSuspects(i - 1)
    val right = nonOptionalSuspects(i)
    val (lOrient, lDiff) = left match {
      case Absolute(id) ⇒ (id, 0)
      case Relation(orient, diff) ⇒ (nonOptionalSuspects(orient).asInstanceOf[Absolute].id, diff)
    }
    val (rOrient, rDiff) = right match {
      case Absolute(id) ⇒ (id, 0)
      case Relation(orient, diff) ⇒ (nonOptionalSuspects(orient).asInstanceOf[Absolute].id, diff)
    }
    // 0 <= rOrient + rDiff - lOrient - lDiff <= x
    //lOrient <= rOrient + rDiff - lDiff
    //rOrient <= lOrient + lDiff - rDiff + x
    rangesOfOrigin(rOrient) ::= (lOrient, rDiff - lDiff)
    rangesOfOrigin(lOrient) ::= (rOrient, lDiff - rDiff + x)
  }
  val memo = Array.tabulate(counter){_ ⇒ Int.MaxValue.toLong}.also{_(0) = 0L}
  var isChanged = false
  for (_ ← 0 to counter){
    isChanged = false
    for (from ← rangesOfOrigin.indices){
      for ((to, diff) ← rangesOfOrigin(from)){
        if (memo(from) + diff < memo(to)){
          isChanged = true
          memo(to) = memo(from) + diff
        }
      }
    }
  }
  val res = nonOptionalSuspects.map{
    case Absolute(id) ⇒ memo(id)
    case Relation(orient, diff) ⇒ memo(nonOptionalSuspects(orient).asInstanceOf[Absolute].id) + diff
  }.let{arr ⇒ for (i ← 1 until arr.length) yield {arr(i) - arr(i - 1)}}
  println(
    if (!isNonParadoxical || res.exists(i ⇒ i < 0 || x < i) || isChanged) -1
    else {
      res.mkString(" ")
    }
  )

  def searchSub(gages: Array[Gage], suspects: Array[Option[Position]], current: Int): Boolean = {
    val (orient, diff) = suspects(current) match {
      case Some(Absolute(_)) ⇒ (current, 0)
      case Some(Relation(o, d)) ⇒ (o, d)
      case None ⇒ ???
    }
    (for (relation ← gages(current).relations) yield {
      suspects(relation.orient) match {
        case Some(r@Relation(_, _)) ⇒ orient == r.orient && diff + relation.diff == r.diff
        case Some(Absolute(_)) ⇒ relation.orient == orient && diff + relation.diff == 0
        case None ⇒
          suspects(relation.orient) = Some(Relation(orient, diff + relation.diff))
          searchSub(gages, suspects, relation.orient)
      }
    }).let{it ⇒ it.isEmpty || it.forall(i ⇒ i)}
  }
  sealed trait Position {
    def getAbsolute(implicit s: Array[Option[Position]]): Option[Int] = {
      this match {
        case Absolute(_) ⇒ Option(0)
        case Relation(orient, diff) ⇒ s(orient).flatMap{_.getAbsolute(s).map{_ + diff}}
      }
    }
  }
  case class Relation(orient: Int, diff: Int) extends Position
  case class Absolute(id: Int) extends Position
  class Gage{
    private var mRelations: List[Relation] = Nil
    def addRelation(to: Int, diff: Int): Unit = {
      mRelations ::= Relation(to, diff)
    }
    def relations: List[Relation] = mRelations
  }
  implicit class Extenion[T](val value :T){
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
    def let[R](func: T ⇒ R): R = func(value)
  }
}