#include <vector>
#include <iostream>
#include <algorithm>
#include <tuple>
#include <set>
#include <map>
#include <queue>
using namespace std;

#define pb push_back
#define mt make_tuple
#define mp make_pair
#define st first
#define nd second

typedef vector<int> vi;
typedef vector<int> vi;
typedef long long ll;
typedef pair<int,int> pii;

#define poka(x) cerr << #x << " = " << x << endl;
#define st first
#define nd second

#define pokav(v) {cerr << "vector " << #v << ": "; for(int i = 0; i < v.size(); ++i) cerr << v[i] << " "; cerr << endl;}
#define pokat(v,n) {cerr << "tablica " << #v << ": "; for(int i = 0; i < n; ++i) cerr << v[i] << " "; cerr << endl;}

const int mxn = 200*1000 + 9;

int gt;
int gwej[3 * mxn];
int num[3 * mxn];		//numer od wej

vector<pii > drz;

vi cykl;

void dfs(int x){											//			poka(x);
	if(x == 0) return;
	gwej[x] = gt;	num[gt] = x;	
	gt++;
	cykl.pb(gwej[x]);
	dfs(drz[x].st);
	cykl.pb(gwej[x]);
	dfs(drz[x].nd);
	cykl.pb(gwej[x]);
}

#define REF &
#define REP(i,n) for(int i = 0; i < n; ++i) 
#define FOR(i,a,b) for(int i = a; i <= b; ++i)
#define FORD(i,a,b) for(int i = a; i >= b; --i)

template<typename T>
class drzewo_przedzialowe_tablicowe{
	private:
		int pot2;				// pierwsza potęga dwójki większa równa niż tab.size()
		vector<T> drz;			// drzewo
		T (*f)(T,T);			// łączne f
		T e;					// f(e, x) = x
	public:
		drzewo_przedzialowe_tablicowe(vector<T> REF tab, T (*__f)(T,T), T __e){
			f = __f;
			e = __e;
			
			pot2 = 1;
			while(pot2 < tab.size()) pot2 *= 2;					
			drz.resize(2*pot2);
			REP(i,tab.size()) drz[pot2 + i] = tab[i];					
			FOR(i,tab.size(),pot2-1) drz[pot2 + i] = e;					
			FORD(i,pot2-1,1)drz[i] = f(drz[2*i], drz[2*i+1]);				
		}
		void wstaw(T elem, int i){
			i += pot2;
			drz[i] = elem;
			for(i /= 2; i; i /= 2) drz[i] = f(drz[2*i], drz[2*i+1]);
		}
		T zapytanie(int a, int b){
			a += pot2;
			b += pot2;
			T wynl = e, wynp = e;
			while(a < b){
				if(a & 1) {wynl = f(wynl, drz[a]); ++a;}		// jeśli a jest prawym dzieckiem
				if(!(b & 1)) {wynp = f(drz[b], wynp); --b;}		// jeśli b jest lewym dzieckiem
				a /= 2;
				b /= 2;
			}
			if(a == b) wynl = f(wynl,drz[a]);
			return f(wynl, wynp);
		}
};

const int inf = 1000*1000*1000 + 9;

int minn(int a, int b){ return min(a,b);}

int main(){
	ios_base::sync_with_stdio(0);
	int n, m, k;
	cin >> n >> m >> k;
	vi  g(n+9), gdzie(n+9);;	// gdzie i - w ktorym wierzcholku jest fiolka i
	drz.resize(n+1);
	for(int i = 1; i <= n; ++i){
		cin >> g[i];
		gdzie[i] = i;
		drz[i] = mp(0,0);
	}
	vi czykorz(n+1, 1); czykorz[0] = 0;
	vector<pii> sek(m);
	for(int i = 0; i < m; ++i){
		cin >> sek[i].st >> sek[i].nd;		//i-ty krok polega na przelaniu zawartosci fiolki numer ai do fiolki numer bi
		int a = sek[i].st;
		int b = sek[i].nd;
		drz.pb(mp(gdzie[a], gdzie[b]));
		
		czykorz.pb(1);
		czykorz[gdzie[a]] = 0;
		czykorz[gdzie[b]] = 0;
		
		gdzie[a] = drz.size()-1;
		gdzie[b] = drz.size()-1;
	}
	gt = 1;																	
	for(int i = 1; i < drz.size(); ++i) if(czykorz[i]) dfs(i);			//	pokat(num, 9);pokav(cykl);
	vector<int> wyst(gt+9);
	for(int i = 0; i < cykl.size(); ++i) wyst[cykl[i]] = i;
																
	drzewo_przedzialowe_tablicowe<int> przed(cykl, minn, inf);	
	vector< vector<pii> > lista(gt + 9);
	vector< set<int> > sety(gt + 9);
	for(int i = 1; i <= n; ++i) sety[i].insert(i);										//	poka("b");
	
	for(int i = 0; i < k; ++i){
		int c, d;
		cin >> c >> d;
		int wejc = gwej[c];		//poka(wejc);			poka(wyst[wejc]);
		int wejd = gwej[d];		//poka(wejd);			poka(wyst[wejd]);
		int weja = przed.zapytanie(min(wyst[wejc], wyst[wejd]), max(wyst[wejc], wyst[wejd]));		//wyst[wejc], wyst[wejd]
		lista[weja].pb(pii(c,d));
	}																		//	poka("a");
	
	for(int i = 1; i <= n; ++i) gdzie[i] = i;
	long long wyn = 0;
	for(int j = 0, akt = n; j < m; ++j){
		//cin >> sek[i].st >> sek[i].nd;		//i-ty krok polega na przelaniu zawartosci fiolki numer ai do fiolki numer bi
		int a = sek[j].st;
		int b = sek[j].nd;
		int ga = gdzie[a];
		int gb = gdzie[b];
		akt++;										//	poka(a); poka(b); poka(akt);
		
		if(sety[ga].size() < sety[gb].size()) swap(sety[ga],sety[gb]); // ga wieksze
		swap(sety[akt], sety[ga]);
		sety[akt].insert(sety[gb].begin(), sety[gb].end());
																		//		poka("x");
		for(int i = 0; i < lista[gwej[akt]].size(); ++i){
			int x = lista[gwej[akt]][i].st;
			int y = lista[gwej[akt]][i].nd;							//	poka(x) poka(y);
			if(sety[akt].count(x) && sety[akt].count(y)){
				int mini = min(g[x],g[y]);
				g[x] -= mini;
				g[y] -= mini;
				wyn += mini;
				wyn += mini;
			}
		}
		
		gdzie[a] = akt;
		gdzie[b] = akt;
	}
	cout << wyn << endl;
	return 0;
}