#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;

#define EACH(i,a) for (auto& i : a)
#define FOR(i,a,b) for (ll i=(a);i<(b);i++)
#define RFOR(i,a,b) for (ll i=(b)-1;i>=(a);i--)
#define REP(i,n) for (ll i=0;i<(n);i++)
#define RREP(i,n) for (ll i=(n)-1;i>=0;i--)
#define debug(x) cout<<#x<<": "<<x<<endl
#define pb push_back
#define ALL(a) (a).begin(),(a).end()

const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);

template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
    EACH(x,vec) is >> x;
    return is;
}
template<typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
    REP(i,vec.size()) {
        if (i) os << " ";
        os << vec[i];
    }
    return os;
}
template<typename T>
ostream& operator<<(ostream& os, vector< vector<T> >& vec) {
    REP(i,vec.size()) {
        if (i) os << endl;
        os << vec[i];
    }
    return os;
}

// SegmentTree<int> seg(n, 0x7FFFFFFF, [](int a, int b){return min(a, b);});
template <typename T>
class SegmentTree {
    using func_t = function<T(T, T)>;
    const int n;
    const T id;
    func_t merge;
    vector<T> data;
    T sub(int l, int r, int node, int lb, int ub) {
        if (ub <= l || r <= lb) return id;
        if (l <= lb && ub <= r) return data[node];
        T vl = sub(l, r, node * 2 + 0, lb, (lb + ub) / 2);
        T vr = sub(l, r, node * 2 + 1, (lb + ub) / 2, ub);
        return merge(vl, vr);
    }
    int size(int n) {
            int res;
            for (res = 1; res < n; res <<= 1);
            return res;
    }
public:
    SegmentTree(int n, T id, func_t merge) :
        n(size(n)), id(id), merge(merge), data(size(n) * 2, id) {}
    void update(int p, T val) {
        assert (0 <= p && p < n);
        p += n;
        data[p] = val;
        while (p /= 2) {
            int l = p * 2, r = p * 2 + 1;
            data[p] = merge(data[l], data[r]);
        }
    }
    T find(int l, int r) {
        return sub(l, r, 1, 0, n);
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    // dp[i][j] : [0, j) テ」ツ?ョテ、ツコツコテ」ツつ?iテヲツ慊ャ テ」ツ?ョテ」ツδ静」ツつケテ」ツ?ァテゥツ?凝」ツ?カテ」ツ?ョテ」ツ?ォテ」ツ?凝」ツ?凝」ツつ凝ヲツ慊?・ツーツ湘」ツつウテ」ツつケテ」ツδ?
    // dp[i+1][j] = min{ dp[i][k] + (j-k)T[j] }
    ll s, n, m; cin >> s >> n >> m;
    vector<ll> x(s); cin >> x;
    vector<ll> T;
    ll ans = 0;
    REP(i, n) {
        ll t, p; cin >> t >> p; --p;
        t -= x[p];
        T.pb(t);
        ans -= t;
    }
    sort( ALL(T) );
    // T.erase(unique(ALL(T)), T.end());
    // seg[r][l] := l -> r テ」ツ?ョテ」ツつウテ」ツつケテ」ツδ?= dp[*][l] + (r-l)*T[r-1]
    // vector<SegmentTree> seg(n+1, SegmentTree<ll>(n, linf, [](const ll& a, const ll& b) {
    //     return min(a, b);
    // }));
    // REP(r, n+1) {
    //     REP(l, n) {
    //         seg[r].update(l,
    //     }
    // }
    vector< vector<ll> > dp(m+1, vector<ll>(n+1, linf));
    REP(i, m+1) dp[i][0] = 0;
    // seg[0].update(0);
    REP(i, m) {
        FOR(j, 1, n+1) {
            REP(k, j) {
                dp[i+1][j] = min(dp[i+1][j], dp[i][k] + (j-k)*T[j-1]);
            }
        }
        //     dp[i+1][j] = seg[j].find(0, j);
        // }
        // FOR(j, 1, n+1) {
        //     seg[j].update(dp[i+1][j] + );
        // }
    }
    // cout << dp << endl;
    ans += dp[m][n];
    cout << ans << endl;
}

Measured memory_bytes: 17828