#include <iostream>
#include <vector>
#include <queue>
#include <limits>
#include <tuple>

using namespace std;

const long long INF = numeric_limits<long long>::max();

int n, m, k;
vector<int> c;
vector<pair<int, int>> bridge;

long long dijkstra(int start) {
    vector<vector<long long>> dist(n + 1, vector<long long>(k + 1, INF));
    dist[start][0] = 0;

    priority_queue<tuple<long long, int, int>, vector<tuple<long long, int, int>>, greater<>> que;
    que.push({0, start, 0}); // (cost, now, coupon)

    while (!que.empty()) {
        auto [cost, now, coupon] = que.top();
        que.pop();

        if (dist[now][coupon] < cost) {
            continue;
        }

        for (int i = 0; i < m; ++i) {
            int u = bridge[i].first;
            int v = bridge[i].second;

            if (u == now) {
                if (coupon < k && dist[v][coupon + 1] > cost) {
                    dist[v][coupon + 1] = cost;
                    que.push({cost, v, coupon + 1});
                }
                if (dist[v][coupon] > cost + c[i]) {
                    dist[v][coupon] = cost + c[i];
                    que.push({cost + c[i], v, coupon});
                }
            } else if (v == now) {
                if (coupon < k && dist[u][coupon + 1] > cost) {
                    dist[u][coupon + 1] = cost;
                    que.push({cost, u, coupon + 1});
                }
                if (dist[u][coupon] > cost + c[i]) {
                    dist[u][coupon] = cost + c[i];
                    que.push({cost + c[i], u, coupon});
                }
            }
        }
    }

    long long result = INF;
    for (int i = 0; i <= k; ++i) {
        result = min(result, dist[n][i]);
    }
    return result;
}

int main() {
    cin >> n >> m >> k;
    c.resize(m);
    bridge.resize(m);

    for (int i = 0; i < m; ++i) {
        cin >> c[i];
    }

    for (int i = 0; i < m; ++i) {
        int u, v;
        cin >> u >> v;
        bridge[i] = {u, v};
    }

    long long ans = dijkstra(1);
    if (ans == INF) {
        cout << -1 << endl;
    } else {
        cout << ans << endl;
    }

    return 0;
}