#include <bits/stdc++.h>

using namespace std;

#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (a) - 1; i >= (b); i--)
#define SZ(a) int(a.size())
#define ALL(a) a.begin(), a.end()
#define PB push_back
#define MP make_pair
#define F first
#define S second

typedef long long LL;
typedef vector<int> VI;
typedef pair<int, int> PII;
typedef double db;

const db EPS = 1e-9;
const db LINF = 1.1e18;

const int INF = 1.01e9;

typedef vector<db> VD;

struct Simplex
{
	void pivot(int l, int e)
	{
		assert(0 <= l && l < m);
		assert(0 <= e && e < n);
		assert(abs(a[l][e]) > EPS);
		b[l] /= a[l][e];
		FOR(j, 0, n)
			if (j != e)
				a[l][j] /= a[l][e];
		a[l][e] = 1 / a[l][e];
		FOR(i, 0, m)
		{
			if (i != l)
			{
				b[i] -= a[i][e] * b[l];
				FOR(j, 0, n)
					if (j != e)
						a[i][j] -= a[i][e] * a[l][j];
				a[i][e] *= -a[l][e];
			}
		}
		v += c[e] * b[l];
		FOR(j, 0, n)
			if (j != e)
				c[j] -= c[e] * a[l][j];
		c[e] *= -a[l][e];
		swap(nonBasic[e], basic[l]);
	}
	void findOptimal()
	{
		VD delta(m);
		while (true)
		{
			int e = -1;
			FOR(j, 0, n)
				if (c[j] > EPS && (e == -1 || nonBasic[j] < nonBasic[e]))
					e = j;
			if (e == -1)
				break;
			FOR(i, 0, m)
				delta[i] = a[i][e] > EPS ? b[i] / a[i][e] : LINF;
			int l = min_element(ALL(delta)) - delta.begin();
			if (delta[l] == LINF)
			{
				// unbounded
				assert(false);
			}
			pivot(l, e);
		}
	}
	void initializeSimplex(const vector<VD>& _a, const VD& _b, const VD& _c)
	{
		m = SZ(_b);
		n = SZ(_c);
		nonBasic.resize(n);
		iota(ALL(nonBasic), 0);
		basic.resize(m);
		iota(ALL(basic), n);
		a = _a;
		b = _b;
		c = _c;
		v = 0;
		int k = min_element(ALL(b)) - b.begin();
		if (b[k] > -EPS)
			return;
		nonBasic.PB(n);
		iota(ALL(basic), n + 1);
		FOR(i, 0, m)
			a[i].PB(-1);
		c.assign(n, 0);
		c.PB(-1);
		n++;
		pivot(k, n - 1);
		findOptimal();
		if (v < -EPS)
		{
			// infeasible
			assert(false);
		}
		int l = find(ALL(basic), n - 1) - basic.begin();
		if (l != m)
		{
			int e = -1;
			while (abs(a[l][e]) < EPS)
				e++;
			pivot(l, e);
		}
		n--;
		int p = find(ALL(nonBasic), n) - nonBasic.begin();
		assert(p < n + 1);
		nonBasic.erase(nonBasic.begin() + p);
		FOR(i, 0, m)
			a[i].erase(a[i].begin() + p);
		c.assign(n, 0);
		FOR(j, 0, n)
		{
			if (nonBasic[j] < n)
				c[j] = _c[nonBasic[j]];
			else
				nonBasic[j]--;
		}
		FOR(i, 0, m)
		{
			if (basic[i] < n)
			{
				v += _c[basic[i]] * b[i];
				FOR(j, 0, n)
					c[j] -= _c[basic[i]] * a[i][j];
			}
			else
				basic[i]--;
		}
	}
	pair<VD, db> simplex(const vector<VD>& _a, const VD& _b, const VD& _c)
	{
		initializeSimplex(_a, _b, _c);
		assert(SZ(a) == m);
		FOR(i, 0, m)
			assert(SZ(a[i]) == n);
		assert(SZ(b) == m);
		assert(SZ(c) == n);
		assert(SZ(nonBasic) == n);
		assert(SZ(basic) == m);
		findOptimal();
		VD x(n);
		FOR(i, 0, m)
			if (basic[i] < n)
				x[basic[i]] = b[i];
		return {x, v};
	}
private:
	int m, n;
	VI nonBasic, basic;
	vector<VD> a;
	VD b;
	VD c;
	db v;
} simplex;

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout << fixed << setprecision(15);
	int n;
	cin >> n;
	vector<VI> g(n, VI(n)), dist(n, VI(n)), lastEdge(n, VI(n));
	vector<pair<int, int>> edges;
	FOR(i, 0, n)
	{
		FOR(j, 0, n)
		{
			cin >> g[i][j];
			if (i == j)
				assert(g[i][j] == 0);
			else if (g[i][j] == -1)
				dist[i][j] = INF;
			else
			{
				dist[i][j] = g[i][j];
				lastEdge[i][j] = SZ(edges);
				edges.emplace_back(i, j);
			}
		}
	}
	FOR(k, 0, n)
		FOR(i, 0, n)
			FOR(j, 0, n)
			{
				if (dist[i][k] + dist[k][j] < dist[i][j])
				{
					dist[i][j] = dist[i][k] + dist[k][j];
					lastEdge[i][j] = lastEdge[k][j];
				}
			}
	int m = SZ(edges);
	vector<VD> a;
	VD b;
	FOR(i, 0, m)
	{
		auto [u, v] = edges[i];
		VD ai(m);
		ai[i] = -1;
		a.PB(ai);
		b.PB(-g[u][v]);
		ai[i] = 1;
		a.PB(ai);
		b.PB(2 * g[u][v]);
	}
	int r;
	cin >> r;
	while (r--)
	{
		int s, d, t;
		cin >> s >> d >> t;
		VD ai(m);
		while (s != d)
		{
			int e = lastEdge[s][d];
			ai[e] = 1;
			d = edges[e].F;
		}
		a.PB(ai);
		b.PB(t);
		FOR(i, 0, m)
			ai[i] *= -1;
		a.PB(ai);
		b.PB(-t);
	}
	int q;
	cin >> q;
	while (q--)
	{
		int s, d;
		cin >> s >> d;
		VD c(m);
		cout << s << " " << d;
		while (s != d)
		{
			int e = lastEdge[s][d];
			c[e] = -1;
			d = edges[e].F;
		}
		cout << " " << -simplex.simplex(a, b, c).S;
		FOR(i, 0, m)
			c[i] *= -1;
		cout << " " << simplex.simplex(a, b, c).S << "\n";
	}
	return 0;
}