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 C++ (GCC 9.2.1) (judge verdict: Accepted)

#include <algorithm>
#include <bitset>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <random>
#include <ratio>
#include <regex>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define ll long long
#define PLL pair<ll,ll>
#define rep(i,n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i,n) for (ll i = 1; i <= (ll)(n); i++)
#define repR(i,n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define rep1R(i,n) for (ll i = (ll)(n); i >= 1; i--)
#define loop(i,a,B) for (ll i = a; i B; i++)
#define loopR(i,a,B) for (ll i = a; i B; i--)
#define all(v) v.begin(), v.end()
#define fcout cout<<fixed<<setprecision(15)
#define PI 3.1415926535897932384626433832795028841971693993751058209749445923078160628620899
const unsigned int BIT_FLAG_0 = (1 << 0);
const unsigned int BIT_FLAG_1 = (1 << 1);
const unsigned int BIT_FLAG_2 = (1 << 2);
const unsigned int BIT_FLAG_3 = (1 << 3);
const unsigned int BIT_FLAG_4 = (1 << 4);
const unsigned int BIT_FLAG_5 = (1 << 5);
const unsigned int BIT_FLAG_6 = (1 << 6);
const unsigned int BIT_FLAG_7 = (1 << 7);
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
const ll INF = 1000000000000000000;

string S, T, U;
char V[1100000];
ll ANS = 0, SUM = 0, NOW = 0, N, M, A, B, C, D, E, F[1100000] = { 0 }, G[1100000] = { 0 }, H[1100000] = { 0 }, I[1100000] = { 0 };
double n, m, a, b, c, d, e;
bool ans = 0, now = 0, sum = 0;
PLL ARM[1100000];

ll mod_pow(ll x, ll y, ll m) {
	ll res = 1;
	while (y) {
		if (y & 1) {
			res = res * x % m;
		}
		x = x * x % m;
		y >>= 1;
	}
	return res;
}

ll kai(ll x, ll y) {
	ll res = 1;
	for (ll i = x - y; i <= x; i++) {
		res *= i;
		res %= MOD;
	}
	return res;
}

ll comb(ll x, ll y) {
	if (y > x) return 0;
	return kai(x, y) * mod_pow(kai(x, y), MOD - 2, MOD) % MOD;
}

ll gcd(ll x, ll y) {
	if (x < y) {
		swap(x, y);
	}
	ll r = x % y;
	while (r != 0) {
		x = y;
		y = r;
		r = x % y;
	}
	return y;
}

ll lcm(ll x, ll y) {
	ll ans = x * y / gcd(x, y);
	return ans;
}

ll ketasu(ll n) {
	ll count = 1;
	while (n >= 10) {
		n /= 10;
		count++;
	}
	return count;
}

string sortS(string s) {
	string sortS;
	vector<char> t(s.size());
	rep(i, s.size()) t[i] = s[i];
	sort(t.begin(), t.end());
	rep(i, s.size()) sortS += t[i];
	return sortS;
}

bool anagram(string a, string b) {
	if (sortS(a) == sortS(b)) return true;
	else return false;
}

ll euclidA(ll a, ll b) {
	bool h = false;
	ll i = 1;
	int ansa;
	while (!h) {
		if (((i * a) - gcd(a, b)) % b == 0) {
			ansa = i;
			h = true;
		}
		i++;
	}
	return ansa;
}

ll eucridB(ll a, ll b) {
	bool h = false;
	ll i = 1;
	ll ansb;
	while (!h) {
		if (((i * a) - gcd(a, b)) % b == 0) {
			ansb = ((i * a - gcd(a, b)) / b);
			h = true;
		}
		i++;
	}
	return ansb;
}

ll twobeki(ll n) {
	if (n == 0) return 1;
	if (n % 2 == 0) {
		int k = twobeki(n / 2);
		return k * k;
	}
	return twobeki(n - 1) * 2;
}

bool isOKlow(ll index, ll key, ll a[]) {
	if (a[index] > key) return true;
	else return false;
}

ll nibutanlowL(ll k, ll a[], ll b, ll c) {
	ll left = b - 1;
ll right = c + 1;
while (right - left > 1) {
	ll mid = left + (right - left + 1) / 2;
	if (a[mid] >= k) right = mid;
	else left = mid;
}
return left;
}

ll nibutanlowR(ll k, ll a[], ll b, ll c) {
	ll left = b - 1;
	ll right = c + 1;
	while (right - left > 1) {
		ll mid = left + (right - left + 1) / 2;
		if (a[mid] >= k) right = mid;
		else left = mid;
	}
	return right;
}

bool isOKup(ll index, ll key, ll a[]) {
	if (a[index] >= key) return true;
	else return false;
}

ll nibutanupL(ll k, ll a[], ll b, ll c) {
	ll left = b - 1;
	ll right = c + 1;
	while (right - left > 1) {
		ll mid = left + (right - left + 1) / 2;
		if (a[mid] > k) right = mid;
		else left = mid;
	}
	return left;
}

ll nibutanupR(ll k, ll a[], ll b, ll c) {
	ll left = b - 1;
	ll right = c + 1;
	while (right - left > 1) {
		ll mid = left + (right - left + 1) / 2;
		if (a[mid] > k) right = mid;
		else left = mid;
	}
	return right;
}

ll mod(ll a, ll b) {
	if (a >= 0) return a % b;
	ll c = 0 - a;
	ll d = c % b;
	return b - d;
}

ll alpNO(char S) {
	vector<char> alp(26);
	alp = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
	rep(i, 26) {
		if (S == alp[i]) {
			return i;
		}
	}
	return 0;
}

char caeser(char S, ll N) {
	vector<char> alp(26);
	alp = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z' };
	ll A = alpNO(S) + N;
	A = mod(A, 26);
	return alp[A];
}

int main(void) {
	cin >> N >> M >> A;
	rep(i, A) cin >> F[i] >> G[i] >> H[i] >> I[i];
	ANS = 0;
	if (N == 10) {
		ll Z[15];
		for (Z[1]= 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++)
			for (Z[4] = Z[3]; Z[4] <= M; Z[4]++)for (Z[5] = Z[4]; Z[5] <= M; Z[5]++)for (Z[6] = Z[5]; Z[6] <= M; Z[6]++)
			for (Z[7] = Z[6]; Z[7] <= M; Z[7]++)for (Z[8] = Z[7]; Z[8] <= M; Z[8]++)for (Z[9] = Z[8]; Z[9] <= M; Z[9]++)for (Z[10] = Z[9]; Z[10] <= M; Z[10]++) {
				SUM = 0;
				rep(i, A) {
					if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
				}
				ANS = max(ANS, SUM);
			}
	}
	if (N == 9) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++)
			for (Z[4] = Z[3]; Z[4] <= M; Z[4]++)for (Z[5] = Z[4]; Z[5] <= M; Z[5]++)for (Z[6] = Z[5]; Z[6] <= M; Z[6]++)
				for (Z[7] = Z[6]; Z[7] <= M; Z[7]++)for (Z[8] = Z[7]; Z[8] <= M; Z[8]++)for (Z[9] = Z[8]; Z[9] <= M; Z[9]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	if (N == 8) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++)
			for (Z[4] = Z[3]; Z[4] <= M; Z[4]++)for (Z[5] = Z[4]; Z[5] <= M; Z[5]++)for (Z[6] = Z[5]; Z[6] <= M; Z[6]++)
				for (Z[7] = Z[6]; Z[7] <= M; Z[7]++)for (Z[8] = Z[7]; Z[8] <= M; Z[8]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	if (N == 7) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++)
			for (Z[4] = Z[3]; Z[4] <= M; Z[4]++)for (Z[5] = Z[4]; Z[5] <= M; Z[5]++)for (Z[6] = Z[5]; Z[6] <= M; Z[6]++)
				for (Z[7] = Z[6]; Z[7] <= M; Z[7]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	if (N == 6) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++)
			for (Z[4] = Z[3]; Z[4] <= M; Z[4]++)for (Z[5] = Z[4]; Z[5] <= M; Z[5]++)for (Z[6] = Z[5]; Z[6] <= M; Z[6]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	if (N == 5) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++)
			for (Z[4] = Z[3]; Z[4] <= M; Z[4]++)for (Z[5] = Z[4]; Z[5] <= M; Z[5]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	if (N == 4) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++)
			for (Z[4] = Z[3]; Z[4] <= M; Z[4]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	if (N == 3) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++)for (Z[3] = Z[2]; Z[3] <= M; Z[3]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	if (N == 2) {
		ll Z[15];
		for (Z[1] = 1; Z[1] <= M; Z[1]++)for (Z[2] = Z[1]; Z[2] <= M; Z[2]++) {
					SUM = 0;
					rep(i, A) {
						if (Z[G[i]] - Z[F[i]] == H[i]) SUM += I[i];
					}
					ANS = max(ANS, SUM);
				}
	}
	cout << ANS << endl;
	return 0;
}