Problem:
アルゴリズム検定試験

あなたはイズア地区におけるアルゴリズム検定試験を運営しており、運営費を最小にしたいと考えています。運営費は、会場使用料、バスの使用料、移動補助金の総和です。

今年は N 人の受験者登録があり、それぞれ ci 人まで受け入れ可能な M 個の会場を確保しました。あなたは各受験者を必ずどこかの会場に割り当てなければなりません。1 人以上割り当てた会場については、人数にかかわらず fi 円の会場使用料を支払う必要があります。

イズア地区は図に示すように東西方向と南北方向に 1 km 間隔で道が走っており、受験者の家と会場は交差点上にあると考えます。各受験者は家から会場まで道に沿って徒歩で移動できます。また、この検定試験では、1 人以上受験者を受け入れる各会場につき 1 台のシャトルバスが運行されるので、受験者はバスを利用することもできます。ただし、自分が受験する会場行きのバスにしか乗れません。

各シャトルバスは、会場からの東西方向の距離と南北方向の距離の和が D 以内のすべての交差点に停車します（図は D = 3 の場合）。バスの使用料は D に比例し、D が 1 km 増えると B 円上がります。つまり、シャトルバスを運行するには 1 会場あたり D × B 円の費用を支払う必要があります。なお、D 及び B はすべての会場で共通の値を用います。

移動補助金とは、各受験者に必要な最低限の徒歩での移動に対して運営者が受験者に支払う費用で、1 km について 1 円を払う必要があります。

あなたは受験者の家と会場の位置、会場の受け入れ可能人数と使用料、D が 1 km 増えたときに加算される料金 B の情報を入力データとして持っており、各受験者への会場割り当てと D を決定することができます（ただし、D は 0 以上の整数)。このとき、運営費の最小値を求めてください。

入力

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

N M B
ax1 ay1
ax2 ay2
:
axN ayN
bx1 by1 c1 f1
bx2 by2 c2 f2
:
bxM byM cM fM

1 行目は３つの整数からなる。N (1 ≤ N ≤ 100) は受験者の人数、M (1 ≤ M ≤ 5) は会場数である。B (0 ≤ B ≤ 1000) はシャトルバスを運行する際に、Dが 1 km 増えたときに加算される料金である。続く N 行に各受験者の家の座標が与えられる。axi, ayi (-1000 ≤ axi, ayi ≤ 1000) はそれぞれ受験者 i の家の x 座標と y 座標を示す。続く M 行に各会場の情報が与えられる。bxi, byi (-1000 ≤ bxi, byi ≤ 1000) はそれぞれ会場 i の x 座標と y 座標を示す。ci(1 ≤ ci ≤ 100) は会場 i の受け入れ可能人数、fi (0 ≤ fi ≤ 100000) は会場 i の使用料を示す。ただし、c1 からcM までの合計は N 以上である。

入力は以下の条件を満たすと考えてよい。

使用する会場を決めたとき、D = i におけるそれらの会場への受験者の割り当て方のうち移動補助金が最小となるときの金額を F(i) とする。このとき、F(i+2) - F(i+1) ≥ F(i+1)-F(i) が成立する。

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

出力

データセットごとに試験の運営費の最小値を 1 行に出力する。

入出力例

入力例

1 1 1
0 0
0 0 1 0
1 1 0
0 0
-3 0 2 3
1 3 1
0 0
-3 0 2 3
0 -5 2 0
4 0 2 1
4 3 1
0 0
0 0
0 0
0 0
-3 0 2 3
0 -5 2 0
4 0 2 1
6 3 1
0 0
0 0
0 0
0 0
0 0
0 0
-3 0 2 3
0 -5 2 0
4 0 2 1
6 3 2
0 0
0 0
0 0
0 0
0 0
0 0
-3 0 2 3
0 -5 2 0
4 0 2 1
10 5 1
0 0
2 0
4 0
8 0
100 0
100 0
100 0
100 0
100 0
100 0
-3 0 1 0
1 0 1 0
3 0 2 0
15 0 1 0
105 0 6 0
10 5 2
0 0
2 0
4 0
8 0
100 0
100 0
100 0
100 0
100 0
100 0
-3 0 1 0
1 0 1 0
3 0 2 0
15 0 1 0
105 0 6 0
0 0 0

出力例

0
3
5
11
18
28
20
38

Solution in C++11 (judge verdict: Wrong Answer)

#include<bits/stdc++.h>
using namespace std;

const int MAX_N = 100;
const int MAX_M = 5;
const int MAX_V = MAX_N + MAX_M + 2;
// const int MAX_D = 4181;
// const int FIBONACCI = 20;
const int MAX_D = 2584;
const int FIBONACCI = 19;

const int INF = 1000000000;
const int NIL = -1;

struct Home {int x, y;};
struct Hall {int x, y, c, f;};

int Fibonacci[FIBONACCI];

int N, M, B;
Home home[MAX_N];
Hall hall[MAX_M];

int V;
int source, sink;
int weight[MAX_V][MAX_V];
int capacity[MAX_V][MAX_V];
int flow[MAX_V][MAX_V];
int potential[MAX_V];
int d[MAX_V];
int p[MAX_V];

typedef tuple<int, int, int> Node;

int answer;

int residue(int from, int to) {return capacity[from][to] - flow[from][to];}
int relative_weight(int from, int to) {return weight[from][to] + potential[from] - potential[to];}

// ???????????????????°??????¨???
int PrimalDual() {
  int result = 0;
  for(int i = 0; i < V; ++i) potential[i] = 0;
  for(int i = 0; i < V; ++i) for(int j = 0; j < V; ++j) flow[i][j] = 0;
  while(true) {
    // Dijkstra O(E + V log V)
    for(int i = 0; i < V; ++i) {
      d[i] = INF;
      p[i] = NIL;
    }
    priority_queue<Node, vector<Node>, greater<Node>> q;
    q.emplace(0, source, NIL);
    while(!q.empty()) {
      int w;
      int current, previous;
      tie(w, current, previous) = q.top();
      q.pop();
      if(d[current] != INF) continue;
      d[current] = w;
      p[current] = previous;
      if(current < N) {
        for(int to = N; to < N + M; ++to) if(0 < residue(current, to)) q.emplace(w + relative_weight(current, to), to, current);
      } else if(current < N + M) {
        for(int to = 0; to < N; ++to) if(0 < residue(current, to)) q.emplace(w + relative_weight(current, to), to, current);
        if(0 < residue(current, sink)) q.emplace(w + relative_weight(current, sink), sink, current);
      } else if(current == source) {
        for(int to = 0; to < N; ++to) if(0 < residue(current, to)) q.emplace(w + relative_weight(current, to), to, current);
      } else {
        for(int to = N; to < N + M; ++to) if(0 < residue(current, to)) q.emplace(w + relative_weight(current, to), to, current);
      }
    }
    if(p[sink] == NIL) break;
    for(int i = 0; i < V; ++i) potential[i] += d[i];
    for(int v = sink; p[v] != NIL; v = p[v]) {
      ++flow[p[v]][v];
      --flow[v][p[v]];
      result += weight[p[v]][v];
    }
    if(answer <= result) return INF;
  }
  return result;
}

// ?§?????£???????
int allowance(int from, int to, int D) {
  int res = 0;
  res += abs(hall[to].x - home[from].x) + abs(hall[to].y - home[from].y);
  res -= D;
  return max(res, 0);
}

// ??????
int cost(int bit, int D) {
  int result = 0;
  for(int i = 0; i < V; ++i) for(int j = 0; j < V; ++j) weight[i][j] = capacity[i][j] = 0;
  for(int i = 0; i < N; ++i) {
    capacity[source][i] = 1;
  }
  for(int i = 0; i < M; ++i) if((bit >> i) & 1) {
    capacity[N + i][sink] = hall[i].c;
    result += hall[i].f;
    result += D * B;
  }
  for(int i = 0; i < N; ++i) for(int j = 0; j < M; ++j) if((bit >> j) & 1) {
    capacity[i][N + j] = 1;
    weight[i][N + j] = allowance(i, j, D);
    weight[N + j][i] = -weight[i][N + j];
  }
  result += PrimalDual();
  return result;
};

int solve() {
  answer = INF;
  // ?????´?????¨??¢?´¢
  for(int bit = 0; bit < (1 << M); ++bit) {
    int total_capacity = 0;
    int total_fee = 0;
    for(int i = 0; i < M; ++i) if((bit >> i) & 1) {
      total_capacity += hall[i].c;
      total_fee += hall[i].f;
    }
    if(total_capacity < N) continue;
    if(answer <= total_fee) continue;
    // ?????¢???????????¢?´¢
    int low = 0;
    int high = Fibonacci[FIBONACCI - 1];
    int n = FIBONACCI - 3;
    int left = low + Fibonacci[n];
    int right = high - Fibonacci[n];
    int f_left = cost(bit, right);
    int f_right = cost(bit, right);
    while(0 < n--) {
//       cout << setw(8) << low << setw(8) << left << setw(8) << right << setw(8) << high << endl;
      if(f_left > f_right) {
        low = left;
        left = right;
        right = high - Fibonacci[n];
        f_left = f_right;
        f_right = cost(bit, right);
      } else {
        high = right;
        right = left;
        left = low + Fibonacci[n];
        f_right = f_left;
        f_left = cost(bit, left);
      }
    }
    answer = min({answer, f_left, f_right});
  }
  return answer;
}

int main() {
  Fibonacci[0] = 0;
  Fibonacci[1] = 1;
  for(int i = 2; i < FIBONACCI; ++i) Fibonacci[i] = Fibonacci[i - 1] + Fibonacci[i - 2];

  while(cin >> N >> M >> B, N | M | B) {
    for(int i = 0; i < N; ++i) cin >> home[i].x >> home[i].y;
    for(int i = 0; i < M; ++i) cin >> hall[i].x >> hall[i].y >> hall[i].c >> hall[i].f;
    V = N + M + 2;
    source = N + M;
    sink = N + M + 1;
    cout << solve() << endl;
  }
}