#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstring>
#include <functional>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <istream>
#include <istream>
#include <map>
#include <math.h>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
using namespace std;
 
const int maxn = 10000;
const int maxm = 20000;
const int maxk = 10;
const int inf = 25;
 
int tot_edge, sz;
int head[maxn];
int nxt[maxm];
int to[maxm];
int cap[maxm];
int flow[maxk + 1][maxm];
int qu[maxn];
int prv[maxn];
int when[maxn];
int pass_flow[maxn];
int last_time;
 
void add_edge(int u, int v, int w)
{
    nxt[tot_edge] = head[u];
    head[u] = tot_edge;
    to[tot_edge] = v;
    cap[tot_edge] = w;
    tot_edge++;
}
 
int augment(int s, int t, int *flow)
{
    last_time++;
    sz = 0;
    qu[sz++] = s;
    when[s] = last_time;
 
    int pnt = 0;
 
    pass_flow[s] = inf;
    pass_flow[t] = 0;
 
    while (pnt < sz && when[t] != last_time)
    {
        int u = qu[pnt++];
        assert(pass_flow[u] > 0);
 
        for (int e = head[u]; e >= 0; e = nxt[e])
        {
            int v = to[e];
 
            if (when[v] != last_time && flow[e] < cap[e])
            {
                pass_flow[v] = min(pass_flow[u], cap[e] - flow[e]);
                prv[v] = e;
                when[v] = last_time;
                qu[sz++] = v;
                if (v == t)
                    break;
            }
        }
    }
 
    int f = pass_flow[t];
 
    if (f == 0)
        return f;
 
    do
    {
        int e = prv[t];
        flow[e] += f;
        flow[e ^ 1] -= f;
        assert(to[e] == t);
        t = to[e ^ 1];
    } while (t != s);
 
    return f;
}
 
int max_flow(int s, int t, int *flow)
{
    int res = 0, cur = 0;
 
    do
    {
        cur = augment(s, t, flow);
        res += cur;
    } while (cur);
 
    return res;
}
 
int n, m, k, q;
int masked[1 << maxk];
 
void go(int n, int m, int mask, int pointer)
{
    for (int i = 0; (mask >> i & 1) == 0 && i < k; ++i)
    {
        int n_mask = mask | (1 << i);
        copy(flow[pointer], flow[pointer] + m, flow[pointer + 1]);
        cap[2 * i] = inf;
        masked[n_mask] = masked[mask] + max_flow(0, n - 1, flow[pointer + 1]);
        go(n, m, n_mask, pointer + 1);
        cap[2 * i] = 0;
    }
}
 
int wei[maxk];
int suma[1 << maxk];
 
int main()
{
    memset(head, -1, sizeof head);
 
    scanf("%d%d%d%d", &n, &m, &k, &q);
 
    for (int i = 0; i < m; ++i)
    {
        int u, v, w;
 
        scanf("%d%d%d", &u, &v, &w);
        u--;
        v--;
 
        add_edge(u, v, w);
        add_edge(v, u, 0);
    }
 
    masked[0] = max_flow(0, n - 1, flow[0]);
 
    go(n, 2 * m, 0, 0);
 
    int top = (1 << k) - 1;
 
    for (int i = 0; i < q; ++i)
    {
        for (int j = 0; j < k; ++j)
            scanf("%d", wei + j);
 
        int answer = 1e9;
 
        for (int j = 1; j < (1 << k); j++)
        {
            int x = __builtin_ctz(j);
            suma[j] = suma[j ^ (1 << x)] + wei[x];
        }
        for (int i = 0; i < (1 << k); i++)
        {
            answer = min(answer, masked[i] + suma[top ^ i]);
        }
        printf("%d\n", answer);
    }
 
    return 0;
}