#include<iostream>

#include<cstring>

#include<vector>

#include<algorithm>

#include<queue>

#define MAX_S 1<<19

#define MAX_N 22

using namespace std;

typedef long long ll;

struct edge {

public:

    int to;

    ll cost;

    edge(int t, ll c) : to(t), cost(c) { }

    edge() { }

};

vector<edge> G[MAX_N];

ll g[MAX_N][MAX_N];

ll a[MAX_N];

int n,m,k;

int ones[MAX_S];

ll dp[MAX_N][MAX_S];

struct node {

public:

    ll s;

    int u;

    node(ll ss, int uu) : s(ss), u(uu) { }

    node() { }

};

queue<node> que;

bool inQue[MAX_N][MAX_S];

int main() {

    cin.sync_with_stdio(false);

    cin >> n >> m >> k;

    for (int i = ; i < ( << n); i++) {

        int x = i;

        while (x)ones[i] += (x & ), x >>= ;

    }

    for (int i = ; i < n; i++)

        cin >> a[i];

    for (int i = ; i < k; i++) {

        int x, y;

        ll c;

        cin >> x >> y >> c;

        x--, y--;

        g[y][x] = c;

    }

    for (int i = ; i < n; i++)

        for (int j = ; j < n; j++)

            G[i].push_back(edge(j, g[i][j]));

    ll ans = ;

    for (int i = ; i < n; i++) {

        dp[i][ << i] = a[i];

        que.push(node( << i, i));

        inQue[i][ << i] = ;

    }

    while (!que.empty()) {

        node now = que.front();

        que.pop();

        ll s = now.s;

        int u = now.u;

        inQue[u][s] = ;

        for (int i = ; i < G[u].size(); i++) {

            int v = G[u][i].to;

            ll c = G[u][i].cost;

            if (s & ( << v))continue;

            ll ns = s | ( << v);

            if (ones[ns] > m)continue;

            if (dp[v][ns] < dp[u][s] + a[v] + c) {

                dp[v][ns] = dp[u][s] + a[v] + c;

                que.push(node(ns, v));

                inQue[v][ns] = ;

            }

        }

    }

    for (int i = ; i < n; i++)

        for (int s = ; s < ( << n); s++)

            if (ones[s] == m)

                ans = max(ans, dp[i][s]);

    cout << ans << endl;

    return ;

}