/*
    copy http://hi.baidu.com/matrush/blog/item/4a8f1d3c430e773370cf6cd4.html
    题意：给定n(n<=5)个必选点，和m(m<=1000)个辅助点，每个点有权值，以及带权无向边若干，求一棵代价最小的生成子树，使得n个必选点连通并且总权值最小。

    分析：这题比较巧妙，首先因为又有边权又有点权不好处理，所以我们先建一个虚拟点0，
    把所有点与0点连边，边权为该点的点权，那么就转化成了有n+m+1个点，
    求出这些点中使0-n这n+1个点连通的最小生成树。这个定义其实就是所谓的斯坦纳树。
    Steiner Tree是NP的，但是当必选点较少时，可以通过状态压缩DP来解，
    具体的DP状态是dp[x][1<<m] 代表以x为根的树并且包含state里的点的最小权值。
    那么求一棵树就可以枚举连接点，以及两个子树的覆盖状态，通过一个很漂亮的转移方程来进行转移：
    dp[i][j]=min(dp[i][j],dp[i][k]+dp[i][j^k])，其中k是j的一个子集，而这个子集又可以通过位运算枚举子集来实现：
    for (int sub = state;sub != 0;sub = (sub-1) & state)

*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>

using namespace std;

const int MAXN = 1010;
const int INF = 1000000000;

struct Edge
{
    int u,v,w;
    Edge *next;
};

//dp[x][1<<m] 代表以x为根的树并且包含state里的点的最小费用
int dp[MAXN][1<<6];
int dist[MAXN][MAXN];
int chg[MAXN];
Edge edges[MAXN*20] , *E[MAXN] , *pE;
bool inQ[MAXN];

void init(int n)
{
    pE = edges;
    for(int i=0;i<=n;i++)E[i] = NULL;
}

inline void addE(int u,int v,int w)
{
    pE->v = v;
    pE->w = w;
    pE->next = E[u];
    E[u] = pE++;
}    

void spfa(int now,int n)
{
    fill(inQ,inQ+n+1,false);
    fill(dist[now],dist[now]+n+1,INF);
    queue<int>Q;
    Q.push(now);
    inQ[now] = 1;
    dist[now][now] = 0;
    while(!Q.empty())
    {
        int u = Q.front();
        Q.pop();
        inQ[u] = 0;
        for( Edge *it = E[u]; it ;it = it->next)
        {
            int v = it->v,w=it->w;
            if(dist[now][v] > dist[now][u] + w)
            {
                dist[now][v] = dist[now][u] + w;
                if(!inQ[v])
                {
                    inQ[v] = true;
                    Q.push(v);
                }
            }
        }
    }
}

int steiner(int m,int n,int chg[])//[0,m] [0,n] 0~n共n个点里面选出p中的m个点
{
    for(int i=0;i<=n;i++)
    {
        spfa(i,n);
    }

    for(int i=0;i<=m;i++)
        for(int j=0;j<=n;j++)
            dp[j][1<<i] = dist[chg[i]][j];

    int limit = 1<<(m+1);
    for(int state = 1; state < limit; state++)
    {
        if((state - 1) & state)//二进制不止一个1
        {
            for(int j = 0; j<=n; j++)
            {
                dp[j][state] = INF;
                for(int _state = (state-1) & state ; _state ; _state = (_state-1) & state)    //枚举子集
                    dp[j][state] = min(dp[j][state] , dp[j][_state] + dp[j][_state ^ state]);
            }
            for(int j=0;j<=n;j++)
                for(int k=0;k<=n;k++)
                    dp[j][state] = min(dp[j][state],dp[k][state] + dist[k][j]);
        }
    }

    return dp[0][limit-1];
}
int main()
{
#ifdef ONLINE_JUDGE
#else 
    freopen("in","r",stdin);
#endif
    int n,m,p;
    while( ~scanf("%d%d%d",&n,&m,&p))
    {
        init(n+m);
        for(int i=1,val;i<=n+m;i++)
        {
            scanf("%d",&val);
            addE(i,0,val);
            addE(0,i,val);
        }
        for(int i=0,u,v,w;i<p;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            addE(u,v,w);
            addE(v,u,w);
        }
        for(int i=0;i<=n+m;i++)chg[i] = i;
        printf("%d\n",steiner(n,n+m,chg));
    }
    return 0;
}