// Задача AT5 — МУХЪЛ
// Решение за подзадача 1 (всички T[i] = 1).  Сложност: O(M log M).
//
// При еднакъв ден всяко пръскане е отсечка [L, R] с цена C и търсим най-евтиното
// покритие на [1, N]: dp[i] = C[i] + min{ dp[j] : R[j] >= L[i]-1 }. Минимумът се намира
// с дърво за интервали над компресираните стойности на R.

#include "mold.h"
#include <algorithm>
#include <vector>
using llong = long long;

namespace {
const int MAXM = 100000 + 10;
const llong INF = 1e18;

int coords[2 * MAXM], coordCount;
llong tree[1 << 19];          // дърво за минимум; размерът покрива до 2*10^5 листа
int treeSize;
int order[MAXM];

int compress(int x) {
    return (int)(std::lower_bound(coords, coords + coordCount, x) - coords);
}
void update(int pos, llong value) {
    pos += treeSize;
    if (tree[pos] <= value) return;
    tree[pos] = value;
    for (pos >>= 1; pos; pos >>= 1) tree[pos] = std::min(tree[2 * pos], tree[2 * pos + 1]);
}
llong query(int l, int r) {    // минимум в [l, r]
    if (l > r) return INF;
    llong res = INF;
    for (l += treeSize, r += treeSize + 1; l < r; l >>= 1, r >>= 1) {
        if (l & 1) res = std::min(res, tree[l++]);
        if (r & 1) res = std::min(res, tree[--r]);
    }
    return res;
}
}

long long min_cost(int N, std::vector<int> T, std::vector<int> L,
                   std::vector<int> R, std::vector<int> C) {
    int M = (int)T.size();

    // компресия на координатите R[i] и L[i]-1
    coordCount = 0;
    for (int i = 0; i < M; i++) { coords[coordCount++] = R[i]; coords[coordCount++] = L[i] - 1; }
    std::sort(coords, coords + coordCount);
    coordCount = (int)(std::unique(coords, coords + coordCount) - coords);

    treeSize = 1;
    while (treeSize < std::max(1, coordCount)) treeSize <<= 1;
    for (int i = 0; i < 2 * treeSize; i++) tree[i] = INF;

    for (int i = 0; i < M; i++) order[i] = i;
    std::sort(order, order + M, [&](int a, int b) { return R[a] < R[b]; });

    llong answer = INF;
    for (int idx = 0; idx < M; idx++) {
        int i = order[idx];
        llong base = (L[i] == 1) ? 0 : INF;
        int lo = compress(L[i] - 1);
        int hi = (int)(std::lower_bound(coords, coords + coordCount, R[i]) - coords) - 1;
        llong best = std::min(base, query(lo, hi));
        if (best < INF) {
            llong total = best + C[i];
            update(compress(R[i]), total);
            if (R[i] >= N) answer = std::min(answer, total);
        }
    }
    return answer >= INF ? -1 : answer;
}
