Problem:
Score : 300 points

Problem Statement

Given are positive integers N, M, Q, and Q quadruples of integers ( a_i , b_i , c_i , d_i ).

Consider a sequence A satisfying the following conditions:

A is a sequence of N positive integers.

1 \leq A_1 \leq A_2 \le \cdots \leq A_N \leq M.

Let us define a score of this sequence as follows:

The score is the sum of d_i over all indices i such that A_{b_i} - A_{a_i} = c_i. (If there is no such i, the score is 0.)

Find the maximum possible score of A.

Constraints

All values in input are integers.

2 ≤ N ≤ 10

1 \leq M \leq 10

1 \leq Q \leq 50

1 \leq a_i < b_i \leq N ( i = 1, 2, ..., Q )

0 \leq c_i \leq M - 1 ( i = 1, 2, ..., Q )

(a_i, b_i, c_i) \neq (a_j, b_j, c_j) (where i \neq j)

1 \leq d_i \leq 10^5 ( i = 1, 2, ..., Q )

Input

Input is given from Standard Input in the following format:

N M Q
a_1 b_1 c_1 d_1
:
a_Q b_Q c_Q d_Q

Output

Print the maximum possible score of A.

Sample Input 1

3 4 3
1 3 3 100
1 2 2 10
2 3 2 10

Sample Output 1

110

When A = \{1, 3, 4\}, its score is 110. Under these conditions, no sequence has a score greater than 110, so the answer is 110.

Sample Input 2

4 6 10
2 4 1 86568
1 4 0 90629
2 3 0 90310
3 4 1 29211
3 4 3 78537
3 4 2 8580
1 2 1 96263
1 4 2 2156
1 2 0 94325
1 4 3 94328

Sample Output 2

357500

Sample Input 3

10 10 1
1 10 9 1

Sample Output 3

1

Solution in Kotlin (1.3.71) (judge verdict: Accepted)

@file:Suppress("DuplicatedCode", "UNUSED_VARIABLE", "SpellCheckingInspection")

import java.io.IOException
import java.io.InputStream
import java.io.PrintWriter
import java.util.NoSuchElementException
import kotlin.math.max

fun main() {
    PrintWriter(System.out).use { out ->
        A.solve(A.FastScanner(), out)
        out.flush()
    }
}

private fun A.solve(sc: A.FastScanner, out: PrintWriter) {
    val (n, m, q) = sc.readIntArray(3)
    val abcd = Array(q) { sc.readIntArrayWithMinus1(4) }

    fun calc(arr: IntArray): Int {
        return abcd.fold(0) { acc, (a, b, c, d) ->
            if (arr[b] - arr[a] == c + 1) acc + d + 1 else acc
        }
    }

    fun loop(pos: Int, min: Int, lst: IntArray): Int {
        if (pos == n) {
            return calc(lst)
        }

        lst[pos] = min

        return if (min == m) loop(pos + 1, min, lst)
        else {
            val a = loop(pos + 1, min, lst)
            lst[pos] = min + 1
            val b = loop(pos, min + 1, lst)
            max(a, b)
        }
    }

    println(loop(0, 1, IntArray(n) { 1 }))
}

@Suppress("MemberVisibilityCanBePrivate")
private object A {
    class FastScanner {
        private val `in`: InputStream = System.`in`
        private val buffer = ByteArray(1024)
        private var ptr = 0
        private var buflen = 0
        private fun hasNextByte(): Boolean {
            if (ptr < buflen) {
                return true
            } else {
                ptr = 0
                try {
                    buflen = `in`.read(buffer)
                } catch (e: IOException) {
                    e.printStackTrace()
                }
                if (buflen <= 0) {
                    return false
                }
            }
            return true
        }

        private fun readByte(): Int {
            return if (hasNextByte()) buffer[ptr++].toInt() else -1
        }

        operator fun hasNext(): Boolean {
            while (hasNextByte() && !isPrintableChar(buffer[ptr].toInt())) ptr++
            return hasNextByte()
        }

        operator fun next(): String {
            if (!hasNext()) throw NoSuchElementException()

            return buildString {
                var b = readByte()

                while (isPrintableChar(b)) {
                    appendCodePoint(b)
                    b = readByte()
                }
            }
        }

        fun nextLong(): Long {
            if (!hasNext()) throw NoSuchElementException()
            var n: Long = 0
            var minus = false
            var b = readByte()

            if (b == '-'.toInt()) {
                minus = true
                b = readByte()
            }

            if (b < '0'.toInt() || '9'.toInt() < b) {
                throw NumberFormatException()
            }

            while (true) {
                if ('0'.toInt() <= b && b <= '9'.toInt()) {
                    n *= 10
                    n += b - '0'.toInt().toLong()
                } else if (b == -1 || !isPrintableChar(b)) {
                    return if (minus) -n else n
                } else {
                    throw NumberFormatException()
                }

                b = readByte()
            }
        }

        fun nextInt(): Int {
            val nl = nextLong()
            if (nl < Int.MIN_VALUE || nl > Int.MAX_VALUE) throw NumberFormatException()
            return nl.toInt()
        }

        fun nextDouble(): Double {
            return next().toDouble()
        }

        fun readIntArray(n: Int): IntArray {
            val arr = IntArray(n)

            for (i in 0 until n) {
                arr[i] = nextInt()
            }

            return arr
        }

        fun readIntArrayWithMinus1(n: Int): IntArray {
            val arr = IntArray(n)

            for (i in 0 until n) {
                arr[i] = nextInt() - 1
            }

            return arr
        }

        companion object {
            private fun isPrintableChar(c: Int): Boolean {
                return c in 33..126
            }
        }
    }
}