Problem:
Score : 2100 points

Problem Statement

There are N jewelry shops numbered 1 to N.

Shop i (1 \leq i \leq N) sells K_i kinds of jewels.
The j-th of these jewels (1 \leq j \leq K_i) has a size and price of S_{i,j} and P_{i,j}, respectively, and the shop has C_{i,j} jewels of this kind in stock.

A jewelry box is said to be good if it satisfies all of the following conditions:

For each of the jewelry shops, the box contains one jewel purchased there.

All of the following M restrictions are met.

Restriction i (1 \leq i \leq M): (The size of the jewel purchased at Shop V_i)\leq (The size of the jewel purchased at Shop U_i)+W_i

Answer Q questions.
In the i-th question, given an integer A_i, find the minimum total price of jewels that need to be purchased to make A_i good jewelry boxes. If it is impossible to make A_i good jewelry boxes, report that fact.

Constraints

1 \leq N \leq 30

1 \leq K_i \leq 30

1 \leq S_{i,j} \leq 10^9

1 \leq P_{i,j} \leq 30

1 \leq C_{i,j} \leq 10^{12}

0 \leq M \leq 50

1 \leq U_i,V_i \leq N

U_i \neq V_i

0 \leq W_i \leq 10^9

1 \leq Q \leq 10^5

1 \leq A_i \leq 3 \times 10^{13}

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
Description of Shop 1
Description of Shop 2
\vdots
Description of Shop N
M
U_1 V_1 W_1
U_2 V_2 W_2
\vdots
U_M V_M W_M
Q
A_1
A_2
\vdots
A_Q

The description of Shop i (1 \leq i \leq N) is in the following format:

K_i
S_{i,1} P_{i,1} C_{i,1}
S_{i,2} P_{i,2} C_{i,2}
\vdots
S_{i,K_i} P_{i,K_i} C_{i,K_i}

Output

Print Q lines.
The i-th line should contain the minimum total price of jewels that need to be purchased to make A_i good jewelry boxes, or -1 if it is impossible to make them.

Sample Input 1

3
2
1 10 1
3 1 1
3
1 10 1
2 1 1
3 10 1
2
1 1 1
3 10 1
2
1 2 0
2 3 0
3
1
2
3

Sample Output 1

3
42
-1

Let (i,j) represent the j-th jewel sold at Shop i.
The answer to each query is as follows:

A_1=1: Making a box with (1,2),(2,2),(3,1) costs 1+1+1=3, which is optimal.

A_2=2: Making a box with (1,1),(2,1),(3,1) and another with (1,2),(2,3),(3,2) costs (10+10+1)+(1+10+10)=42, which is optimal.

A_3=3: We cannot make three good boxes.

Sample Input 2

5
5
86849520 30 272477201869
968023357 28 539131386006
478355090 8 194500792721
298572419 6 894877901270
203794105 25 594579473837
5
730211794 22 225797976416
842538552 9 420531931830
871332982 26 81253086754
553846923 29 89734736118
731788040 13 241088716205
5
903534485 22 140045153776
187101906 8 145639722124
513502442 9 227445343895
499446330 6 719254728400
564106748 20 333423097859
5
332809289 8 640911722470
969492694 21 937931959818
207959501 11 217019915462
726936503 12 382527525674
887971218 17 552919286358
5
444983655 13 487875689585
855863581 6 625608576077
885012925 10 105520979776
980933856 1 711474069172
653022356 19 977887412815
10
1 2 231274893
2 3 829836076
3 4 745221482
4 5 935448462
5 1 819308546
3 5 815839350
5 3 513188748
3 1 968283437
2 3 202352515
4 3 292999238
10
510266667947
252899314976
510266667948
374155726828
628866122125
628866122123
1
628866122124
510266667949
30000000000000

Sample Output 2

26533866733244
13150764378752
26533866733296
19456097795056
-1
33175436167096
52
33175436167152
26533866733352
-1

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

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

template <typename flow_t = int, typename cost_t = int64_t>
struct MCMF_SSPA {
	int N;
	vector<vector<int>> adj;
	struct edge_t {
		int dest;
		flow_t cap;
		cost_t cost;
	};
	vector<edge_t> edges;

	vector<char> seen;
	vector<cost_t> pi;
	vector<int> prv;

	explicit MCMF_SSPA(int N_) : N(N_), adj(N), pi(N, 0), prv(N) {}

	void addVert() {
		N++;
		adj.emplace_back();
		pi.push_back(0);
		prv.emplace_back();
	}

	void addEdge(int from, int to, flow_t cap, cost_t cost) {
		assert(cap >= 0);
		int e = int(edges.size());
		edges.emplace_back(edge_t{to, cap, cost});
		edges.emplace_back(edge_t{from, 0, -cost});
		adj[from].push_back(e);
		adj[to].push_back(e+1);
	}

	const cost_t INF_COST = numeric_limits<cost_t>::max() / 4;
	const flow_t INF_FLOW = numeric_limits<flow_t>::max() / 4;
	vector<cost_t> dist;
	__gnu_pbds::priority_queue<pair<cost_t, int>> q;
	vector<typename decltype(q)::point_iterator> its;
	void path(int s) {
		dist.assign(N, INF_COST);
		dist[s] = 0;

		its.assign(N, q.end());
		its[s] = q.push({0, s});

		while (!q.empty()) {
			int i = q.top().second; q.pop();
			cost_t d = dist[i];
			for (int e : adj[i]) {
				if (edges[e].cap) {
					int j = edges[e].dest;
					cost_t nd = d + edges[e].cost;
					if (nd < dist[j]) {
						dist[j] = nd;
						prv[j] = e;
						if (its[j] == q.end()) {
							its[j] = q.push({-(dist[j] - pi[j]), j});
						} else {
							q.modify(its[j], {-(dist[j] - pi[j]), j});
						}
					}
				}
			}
		}

		swap(pi, dist);
	}

	vector<pair<cost_t, flow_t>> maxflow(int s, int t) {
		assert(s != t);
		vector<pair<cost_t, flow_t>> res;
		while (path(s), pi[t] < INF_COST) {
			flow_t curFlow = numeric_limits<flow_t>::max();
			for (int cur = t; cur != s; ) {
				int e = prv[cur];
				int nxt = edges[e^1].dest;
				curFlow = min(curFlow, edges[e].cap);
				cur = nxt;
			}
			if (!res.empty() && res.back().first == pi[t]) {
				res.back().second += curFlow;
			} else {
				res.emplace_back(pi[t], curFlow);
			}
			for (int cur = t; cur != s; ) {
				int e = prv[cur];
				int nxt = edges[e^1].dest;
				edges[e].cap -= curFlow;
				edges[e^1].cap += curFlow;
				cur = nxt;
			}
		}
		return res;
	}
};

using i64 = int64_t;

int main() {
	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
	int N; cin >> N;

	struct jewel {
		int P;
		i64 S, C;
	};
	vector<vector<jewel>> jewels(N);

	for (int i = 0; i < N; i++) {
		int K; cin >> K;
		jewels[i].resize(K);
		for (int j = 0; j < K; j++) {
			cin >> jewels[i][j].S >> jewels[i][j].P >> jewels[i][j].C;
		}
		sort(jewels[i].begin(), jewels[i].end(), [&](const jewel& a, const jewel& b) -> bool { return a.S < b.S; });
	}

	int V = 3;
	vector<vector<int>> verts(N);
	for (int i = 0; i < N; i++) {
		verts[i].push_back(0);
		for (int j = 1; j < int(jewels[i].size()); j++) {
			verts[i].push_back(V++);
		}
		verts[i].push_back(2);
	}

	MCMF_SSPA<int, i64> mcmf(V);

	int totP = 0;
	for (int i = 0; i < N; i++) {
		int K = int(jewels[i].size());
		for (int j = 0; j < K; j++) {
			totP += jewels[i][j].P;
		}
	}

	// limit it by totP + 2
	int infFlow = totP + 2;
	mcmf.addEdge(2, 1, infFlow, 0);

	for (int i = 0; i < N; i++) {
		int K = int(jewels[i].size());
		for (int j = 0; j < K; j++) {
			mcmf.addEdge(verts[i][j], verts[i][j+1], jewels[i][j].P, 0);
			mcmf.addEdge(verts[i][j+1], verts[i][j], infFlow, 0);
			mcmf.addEdge(verts[i][j], verts[i][j+1], infFlow, jewels[i][j].C);
		}
	}

	int M; cin >> M;
	for (int e = 0; e < M; e++) {
		int u, v; i64 w; cin >> u >> v >> w; u--, v--;
		for (int j = 0; j < int(jewels[u].size()); j++) {
			int k = 0;
			while (k < int(jewels[v].size()) && jewels[v][k].S <= jewels[u][j].S + w) {
				k++;
			}
			mcmf.addEdge(verts[v][k], verts[u][j+1], infFlow, 0);
		}
	}

	auto flows = mcmf.maxflow(0, 1);
	//for (auto it : flows) { cerr << it.first << ' ' << it.second << '\n'; }

	vector<pair<i64, i64>> prefFlows(flows.size()+1);
	prefFlows[0] = {0,0};
	for (int i = 0; i < int(flows.size()); i++) {
		prefFlows[i+1] = {prefFlows[i].first + flows[i].first * flows[i].second, prefFlows[i].second + flows[i].second};
	}
	assert(prefFlows.back().second == infFlow);

	int Q; cin >> Q;
	while (Q--) {
		i64 A; cin >> A;
		int i = int(lower_bound(flows.begin(), flows.end(), pair<i64, int>(A, -1)) - flows.begin());
		if (i == int(flows.size())) {
			cout << -1 << '\n';
		} else {
			cout << A * prefFlows[i].second - prefFlows[i].first << '\n';
		}
	}

	return 0;
}