n,f,r = map(int,input().split())

a = list(range(f))
b = list(range(f))
c = list(range(f))
for x in range(f):
    a[x],b[x],c[x] = map(int,input().split())

i = list(range(r))
j = list(range(r))
k = list(range(r))
for x in range(r):
    i[x],j[x],k[x] = map(int,input().split())

#cria o GRAPH baseado nas entradas
graph = {}
for x in range(1,n+1):
    paths = {}
    for y in range(f):
        paths2 = {}
        if a[y] == x:
            if not b[y] in paths.keys():
                paths[b[y]] = {}

            #irá verificar se a nova aresta informada é maior ou menor do que
            #uma possível aresta já informada e manterá a menor
            checkEqual = paths[b[y]]
            newWeight = c[y]
            if 'rail' in checkEqual.keys():
                if checkEqual['rail'] < c[y]:
                    newWeight = checkEqual['rail']
            checkEqual.update({'rail':newWeight})

        if b[y] == x:
            if not a[y] in paths.keys():
                paths[a[y]] = {}
            checkEqual = paths[a[y]]
            newWeight = c[y]
            if 'rail' in checkEqual.keys():
                if checkEqual['rail'] < c[y]:
                    newWeight = checkEqual['rail']
            checkEqual.update({'rail':newWeight})


    for y in range(r):
        paths2 = {}
        if i[y] == x:
            if not j[y] in paths.keys():
                paths[j[y]] = {}
            checkEqual = paths[j[y]]
            newWeight = k[y]
            if 'road' in checkEqual.keys():
                if checkEqual['road'] < k[y]:
                    newWeight = checkEqual['road']
            checkEqual.update({'road':newWeight})


        if j[y] == x:
            if not i[y] in paths.keys():
                paths[i[y]] = {}
            checkEqual = paths[i[y]]
            newWeight = k[y]
            if 'road' in checkEqual.keys():
                if checkEqual['road'] < k[y]:
                    newWeight = checkEqual['road']
            checkEqual.update({'road':newWeight})

    graph[x] = paths

# input(graph)

# GRAPH INPUT TEST
# graph = {1: {2: {'rail': 40}, 3: {'rail': 50}}, 2: {1: {'rail': 40}, 3: {'rail': 30}, 4: {'road': 40}}, 3: {1: {'rail': 50}, 2: {'rail': 30}, 4: {'rail': 50}}, 4: {3: {'rail': 50}, 2: {'road': 40}}}
# n = 4

#inicializa um dicionário para:
# - uma QUEUE de vértices, que será analizada, item a item, para verificar os EDGES
# - KEYS, que representa o menor WEIGHT encontrado para chegar
# naquele vértice até então
# - condicinal EDGEROAD que é um caso específico do problema, onde
# o peso não é prioridade, mas sim se o EDGE é rail ou roads
# - PARENT, que não é exigência do problema, mas permite rastrear as EDGES

vertexQueue = {}
vertexKeys = {}
vertexEdgeRoad = {}
vertexParent = {}
#para armazenar os EDGES (apenas para facilitar conferência), o problema
#não pede
mstEdges = {}
edgesCounter = 0

for x in range(1,n+1):
    #inicializa todos os dicionários com valores máximos pra KEYS e roads
    #e zera o Parent
    vertexQueue[x] = x
    vertexKeys[x] = float('inf')
    vertexEdgeRoad[x] = 1
    vertexParent[x] = None


vertexKeys[1] = 0
edges = {}

while vertexQueue:

    #vai verificar qual a menor KEY dos vértices que ainda estão no vertexQueue
    minKey = float('inf')
    minRoad = 1
    for v in vertexQueue.keys():
        if vertexEdgeRoad[v] <= minRoad and vertexKeys[v] <= minKey:
            minRoad = vertexEdgeRoad[v]
            minKey = vertexKeys[v]
            minV = v
    #fixaremos o vértice em análise (menor KEY em vertexQueue) como u
    u = minV
    vertexQueue.pop(u)

    if vertexParent[u] != None:
        if vertexEdgeRoad[u] == 1:
            pathType = 'road'
        else:
            pathType = 'rail'
        edgesCounter += 1
        mstEdges.update({edgesCounter:str(vertexParent[u])+'-'+str(u)+' ('+pathType+' / w:'+str(vertexKeys[u])+')'})


        #origem do edge até o vértice u

    #como não temos somente o WEIGHT da EDGE, extraímos o dicionário
    #de dentro da iteração do graph[u] para poder trabalhar tanto com
    #o WEIGHT quanto com o ROAD do EDGE
    edgesU = graph[u]

    #vamos iterar todos os vértices conectados a [u]
    #edge recebe um inteiro chave do dicionário graph[u], como o graph
    #está em ordem crescente, vai equivaler ao vértice certo
    for edge in edgesU.keys():

        #verifica se a edge ainda percente a QUEUE ou se já foi iterada
        if edge in vertexQueue.keys():

            if 'rail' in edgesU[edge].keys():
                edgeWeight = edgesU[edge].get('rail')
                edgeRoad = 0
            else:
                edgeWeight = edgesU[edge].get('road')
                edgeRoad = 1

            #Condições para atualização de valores
            #Se for FERROVIA sobrescreve RODOVIA independente do peso
            #Se for o mesmo tipo, avalia o peso
            update = False
            if vertexEdgeRoad[edge] > edgeRoad:
                update = True
            elif vertexEdgeRoad[edge] == edgeRoad and vertexKeys[edge] > edgeWeight:
                update = True

            if update:
                vertexKeys[edge] = edgeWeight
                vertexEdgeRoad[edge] = edgeRoad
                vertexParent[edge] = u

# print(mstEdges)

edgeTotalWeight = sum(vertexKeys.values())
print(edgeTotalWeight)