Problem:
図画工作

イヅア大学附属小学校は日本有数の競技プログラマー養成校として有名です。この学校の教員は幅広い
アルゴリズムの知識を持ち、日々それを活用しています。教員であるあなたは、今年は図画工作の授業
を担当することになりました。この授業では、児童全員がそれぞれ１年間で一つの課題を完成させることになっています。授業の概要は以下のとおりです。

１年間で授業は D 回（同じ日に2 回以上授業はない）あり、その全てが課題制作に充てられる。

制作する課題は M 種類用意されている。

それぞれの児童に、M 種類の中から課題を１つずつ割り当てる。

児童は N 人であり、N 人それぞれに異なる課題が割り当てられる。

児童は、K 種類ある部品のうちいくつかの種類の部品を使用して課題を完成させます。課題の制作の概要は以下のとおりです。

課題ごとに、使用すべき部品の種類と数はあらかじめ決められている。

課題が完成するまでに使用する部品の種類と数は、その課題で使用すべき部品の種類と数に、過不足なく一致していなければならない。

異なる課題でも、使われる部品の種類と数がすべて同じ場合もある。

どの課題も、同じ種類の部品は２個までしか使用できない。

部品を使用する順序は課題の完成に影響を与えない。

いくつかの部品が入っている袋が事前に P 個用意されている。ただし、異なる袋でも、入っている部品の種類と数がすべて同じ場合もある。

教員は、児童１人につき袋を１つだけ渡すことができる（袋を渡さない児童がいてもよい）。

２人以上の児童に同じ袋を渡すことはできない（反対に、誰にも渡されない袋があってもよい）。

袋を渡された児童は、袋の中に入っている部品をすべて、自分が制作する課題に使わなければならない。

袋に入っている部品以外で課題に使用する部品は、別途購入する必要があります。部品の購入に関する条件は以下のとおりです。

部品は授業の日だけ購入でき、その日にしか使えない。

それぞれの課題について、１回の授業でＬ個までの部品を購入することができる。

部品の種類によって価格が設定されており、購入する日によって価格が変動する。ただし、どの種類も品切れになることはない。

あなたは、このような条件下で、授業にかかる経費をなるべく抑えたいと考えています。そこで、児童全員の部品購入費の合計の最小値を計算するプログラムを作成することにしました。

入力

入力は複数のデータセットからなる。入力の終わりはゼロ３つの行で示される。各データセットは以下の形式で与えられる。

D K L
c1,1 c1,2 ... c1,K
c2,1 c2,2 ... c2,K
:
cD,1 cD,2 ... cD,K
M N P
r1,1 r1,2 ... r1,K
r2,1 r2,2 ... r2,K
:
rM,1 rM,2 ... rM,K
t1,1 t1,2 ... t1,K
t2,1 t2,2 ... t2,K
:
tP,1 tP,2 ... tP,K

各行で与えられる数値は１つの空白で区切られている。

D（1 ≤ D ≤ 8）は授業の回数、K（1 ≤ K ≤ 8）は部品の種類の数、L（1 ≤ L ≤ 8）は１日に購入することができる部品の数を示す。cd,k （1 ≤ cd,k ≤ 100）は d 日目の部品k の価格を示す。

M（1 ≤ M ≤ 200）は課題の種類の数、N（1 ≤ N ≤ M）は生徒の人数、P（1 ≤ P ≤ 200）は袋の数を示す。

rm,k （0 ≤ rm,k ≤ 2）は課題 m に必要な部品 k の個数、tp,k （0 ≤ tp,k ≤ 2）は袋 p に入っている部品 k の個数を示す。

部品を１つも必要としない課題や、空の袋は与えられないものとする。

データセットの数は20 を超えない。

出力

データセットごとに、生徒全員の部品購入費の合計の最小値を１行に出力する。Ｎ種類の作品を完成させることができない場合は -1 を出力する。

入力例

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

出力例

-1
9
6
7

Solution in Scala (judge verdict: Accepted)

import scala.collection.mutable
import scala.collection.mutable.ArrayBuffer
import scala.reflect.ClassTag

object Main extends App {

  import scala.io.StdIn._
  implicit object G extends Group[Int] {
    override def plus(a: Int, b: Int): Int = a + b

    override def minus(a: Int, b: Int): Int = a - b

    override def times(a: Int, b: Int): Int = a * b

    override def maxSentinel: Int = Int.MaxValue

    override def zero: Int = 0
  }
  solve
  def solve: Unit = {
    val Array(d, k, l) = readLine.trim.split(' ').map(_.toInt)
    if (d == 0) return
    val prices = Array.tabulate(d){_ ⇒ readLine.trim.split(' ').map(_.toInt)}
    val Array(m, n, p) = readLine.trim.split(' ').map(_.toInt)
    val crafts = Array.tabulate(m){_ ⇒ readLine.trim.split(' ').map(_.toInt)}
    val bags = Array.tabulate(p){_ ⇒ readLine.trim.split(' ').map(_.toInt)} :+ Array.tabulate(k){_ ⇒ 0}
    val forDays = Array.tabulate(d){i ⇒ (0, i + 1, l, 0)}
    val costs = crafts.map{
      case craft ⇒
        bags.indices.withFilter{i ⇒
          bags(i).indices.forall(j ⇒ craft(j) >= bags(i)(j))
        }.flatMap{i ⇒
          val needs = bags(i).indices.map(j ⇒ craft(j) - bags(i)(j)).toArray
          val edges = ArrayBuffer[(Int, Int, Int, Int)](forDays:_*)
          for (item ← needs.indices if needs(item) > 0){
            edges.append((item + d + 1, k + d + 1, needs(item), 0))
            for (day ← prices.indices){
              edges.append((day + 1, item + d + 1, needs(item), prices(day)(item)))
            }
          }
          //from, to, capacity, cost, source=> 0 drain => k + d + 1
          // day(1 to d), item(d + 1 to d + k)
          val (flow, cost) = minCostFlowMatching(0, k + d + 1, k + d + 2, edges.toArray)
          if (flow == needs.sum) Some((i, cost))
          else None
        }.toArray
    }
    //source = 0 drain = m + p + 2
    //craft(1 to m), bag(m + 1 to m + p + 1)
    val edge = ArrayBuffer[(Int, Int, Int, Int)]()
    for (craft ← costs.indices) {
      edge.append((0, craft + 1, 1, 0))
      for (bag ← costs(craft).indices) {
        val (i, c) = costs(craft)(bag)
        edge.append((craft + 1, i + m + 1, 1, c))
      }
    }
    for (i ← 0 until p) edge.append((m + i + 1, m + p + 2, 1, 0))
    edge.append((m + p + 1, m + p + 2, n, 0))
    val (flow, cost) = minCostFlowMatching(0, m + p + 2, m + p + 3, edge.toArray, n)
    if (flow == n) println(cost)
    else println(-1)
    solve
  }
  implicit class Extend[T](value: T){
    def let[R](func: T ⇒ R): R = func(value)
    def also(func: T ⇒ Unit): T = {func(value); value}
  }

  trait Group[T]{
    def plus(a: T, b: T): T
    def minus(a: T, b: T): T
    def times(a: T, b: Int): T
    def maxSentinel: T
    def zero: T
  }

  //edge => (from, to, capacity, cost)
  def minCostFlowMatching[N : ClassTag](source: Int, drain: Int, size: Int, edge: Array[(Int, Int, Int, N)], flowLimit: Int = Int.MaxValue)(implicit m: Group[N], o: Ordering[N]): (Int, N) = {
    val edges = makeGraph(size, edge)
    val potential = Array.tabulate(size){_ ⇒ m.maxSentinel}
    for (e ← edges) for (Edge(to, cap, _, c) ← e if cap > 0 && o.compare(potential(to), c) > 0) potential(to) = c
    potential(source) = m.zero
    potential(drain) = m.zero
    val prevEdge = Array.tabulate(size){_ ⇒ (Edge(-1, -1, -1, m.zero), Int.MaxValue)}
    val minCost = Array.tabulate(size){_ ⇒ m.maxSentinel}
    val queue = mutable.PriorityQueue()(Ordering.by[(Int, N), N](_._2).reverse)
    var canMatch = true
    var result = m.zero
    var totalFlow = 0
    while(canMatch) {
      canMatch = false
      queue.enqueue((source, m.zero))
      minCost.indices.foreach(i ⇒ minCost(i) = m.maxSentinel)
      minCost(source) = m.zero
      while(queue.nonEmpty){
        val (prev, cost) = queue.dequeue()
        if (prev != drain && o.compare(minCost(prev), cost) == 0){
          for (e@Edge(to, cap, pair, c) ← edges(prev) if cap > 0){
            //minCost(to) > potential(prev) + c - potential(to) + cost
            if (o.equiv(minCost(to), m.maxSentinel) || o.compare(m.minus(m.minus(minCost(to), potential(prev)), cost), m.minus(c, potential(to))) > 0) {
              minCost(to) = m.plus(m.minus(potential(prev), potential(to)), m.plus(c, cost))
              prevEdge(to) = (edges(to)(pair), math.min(prevEdge(prev)._2, cap))
              queue.enqueue((to, minCost(to)))
            }
          }
        }
      }
      if (!o.equiv(minCost(drain), m.maxSentinel)) {
        canMatch = true
        var last = drain
        val bottleNeck = prevEdge(drain)._2
        //var current = minCost(drain)
        while (last != source) {
          val (r, _) = prevEdge(last)
          val e = edges(r.to)(r.pair)
          edges(last)(e.pair) = r.copy(capacity = r.capacity + bottleNeck)
          edges(r.to)(r.pair) = e.copy(capacity = e.capacity - bottleNeck)
          last = r.to
        }
        if (totalFlow + bottleNeck <= flowLimit) {
          totalFlow += bottleNeck
          result = m.plus(result, m.times(minCost(drain), bottleNeck))
        } else {
          result = m.plus(result, m.times(minCost(drain), flowLimit - totalFlow))
          totalFlow = flowLimit
          canMatch = false
        }
        for (x ← 0 until size if x != source && x != drain){
          potential(x) = m.plus(potential(x), minCost(x))
        }
      }
    }
    (totalFlow, result)
  }
  private case class Edge[N](to: Int, capacity: Int, pair: Int, cost: N)
  private def makeGraph[N](size: Int, edge: Array[(Int, Int, Int, N)])(implicit m: Group[N]): Array[Array[Edge[N]]] = {
    val nodes = Array.tabulate(size){_ ⇒ ArrayBuffer[Edge[N]]()}
    for ((from, to, capacity, cost) ← edge){
      nodes(from).append(Edge(to, capacity, nodes(to).length, cost))
      nodes(to).append(Edge(from, 0, nodes(from).length - 1, m.minus(m.zero, cost)))
    }
    nodes.map{_.toArray}
  }
}