#include <bits/stdc++.h>
class Tracker {
 private:
  int32_t size = 0;
  int64_t* segtree;
  int64_t* lazy;
  void propagate(int32_t node) {
    segtree[node * 2 + 1] += lazy[node];
    segtree[node * 2 + 2] += lazy[node];
    lazy[node * 2 + 1] += lazy[node];
    lazy[node * 2 + 2] += lazy[node];
    lazy[node] = 0;
  }
  int64_t get(int32_t node, int32_t left, int32_t right, int32_t index) {
    if (right - left == 1) return segtree[node];
    int32_t m = (left + right) / 2;
    propagate(node);
    if (index >= m) return get(node * 2 + 2, m, right, index);
    return get(node * 2 + 1, left, m, index);
  }
  void update(int32_t node, int32_t left, int32_t right, int32_t index,
              int64_t val) {
    if (right - left == 1) {
      segtree[node] = val;
      return;
    }
    int32_t m = (left + right) / 2;
    propagate(node);
    if (index >= m)
      update(node * 2 + 2, m, right, index, val);
    else
      update(node * 2 + 1, left, m, index, val);
    segtree[node] = std::max(segtree[node * 2 + 1], segtree[node * 2 + 2]);
  }
  void increase_on_pref(int32_t node, int32_t left, int32_t right, int32_t pref,
                        int64_t val) {
    if (right <= pref) {
      segtree[node] += val;
      lazy[node] += val;
      return;
    }
    if (left >= pref) return;
    int32_t m = (left + right) / 2;
    propagate(node);
    increase_on_pref(node * 2 + 1, left, m, pref, val);
    increase_on_pref(node * 2 + 2, m, right, pref, val);
    segtree[node] = std::max(segtree[node * 2 + 1], segtree[node * 2 + 2]);
  }
  int64_t max_on_pref(int32_t node, int32_t left, int32_t right, int32_t pref) {
    if (right <= pref) return segtree[node];
    if (left >= pref) return INT64_MIN;
    int32_t m = (left + right) / 2;
    propagate(node);
    return std::max(max_on_pref(node * 2 + 1, left, m, pref),
                    max_on_pref(node * 2 + 2, m, right, pref));
  }

 public:
  Tracker(int32_t n) {
    size = n;
    segtree = new int64_t[4 * n];
    lazy = new int64_t[4 * n];
    for (int32_t i = 0; i < 4 * n; i++) {
      segtree[i] = 0;
      lazy[i] = 0;
    }
  }
  void increase_on_pref(int32_t pref, int32_t x) {
    increase_on_pref(0, 0, size, pref, x);
  }
  int64_t max_on_pref(int32_t pref) { return max_on_pref(0, 0, size, pref); }
  void update(int32_t idx, int64_t x) { update(0, 0, size, idx, x); }
  int64_t point_val(int32_t x) { return get(0, 0, size, x); }
};
int main() {
  int32_t n, m;
  std::cin >> n >> m;
  int32_t* arr = new int32_t[n];
  for (int32_t i = 0; i < n; i++) std::cin >> arr[i];
  for (int32_t i = 0; i < n; i++) arr[i] = -arr[i];
  std::vector<std::pair<int32_t, int32_t> >* segments_per_end =
      new std::vector<std::pair<int32_t, int32_t> >[n];
  for (int32_t i = 0; i < m; i++) {
    int32_t left, right, cost;
    std::cin >> left >> right >> cost;
    left--;
    right--;
    segments_per_end[right].emplace_back(left, cost);
  }
  Tracker tracker(n + 1);
  int64_t answer = 0;
  for (int32_t i = 1; i <= n; i++) {
    int64_t new_val = tracker.point_val(i - 1);
    tracker.increase_on_pref(i, arr[i - 1]);
    for (int32_t j = 0; j < segments_per_end[i - 1].size(); j++)
      tracker.increase_on_pref(segments_per_end[i - 1][j].first + 1,
                               segments_per_end[i - 1][j].second);
    new_val = std::max(new_val, tracker.max_on_pref(i));
    tracker.update(i, new_val);
    answer = std::max(answer, new_val);
  }
  std::cout << answer;
  return 0;
}
