#include <bits/stdc++.h>
using namespace std;
const int MAXI = numeric_limits<int>::max() / 2;
const int MINI = numeric_limits<int>::min() / 2;
const long long MAXL = numeric_limits<long long>::max() / 2;
const long long MINL = numeric_limits<long long>::min() / 2;
static const int S = 5001;
int N;
long long m[S];
double dp[S][S];
vector<int> T[S];
int q;
class ST {
 public:
  ST() {}
  void init() { a.assign(2 * N - 1, 0); }
  void update(int k, long long x) {
    k += N - 1;
    a[k] = x;
    while (k > 0) {
      k = (k - 1) / 2;
      a[k] = max(a[2 * k + 1], a[2 * k + 2]);
    }
  }
  long long query(int k, int l, int r, int s, int t) {
    if (r <= s || t <= l)
      return 0;
    else if (r <= t && s <= l)
      return a[k];
    else {
      int mid = (l + r) / 2;
      return max(query(2 * k + 1, l, mid, s, t),
                 query(2 * k + 2, mid, r, s, t));
    }
  }

 private:
  vector<long long> a;
};
struct seg {
  seg(int a, int b, double c) : l(a), r(b), p(c) {}
  int l, r;
  double p;
};
bool comp(const seg &lhs, const seg &rhs) {
  return lhs.l != rhs.l ? lhs.l < rhs.l : lhs.r > rhs.r;
}
inline bool ol(const seg &lhs, const seg &rhs) {
  return lhs.l <= rhs.l && lhs.r >= rhs.r;
}
ST st;
vector<seg> ss;
void build(int p, int x) {
  for (int i = 0; i != T[p].size(); ++i) {
    if (ol(ss[T[p][i]], ss[x])) {
      build(T[p][i], x);
      return;
    }
  }
  T[p].push_back(x);
}
double find(int a, int b) {
  if (b > q) return 1;
  double &val = dp[a][b];
  if (val >= 0) return val;
  val = 0.0;
  if (T[a].size() == 0) return val = b == 0 ? 1 - ss[a].p : 1;
  double x = ss[a].p, y = 1 - x;
  for (int i = 0; i != T[a].size(); ++i) {
    int c = T[a][i];
    long long &mp = m[a], &mc = m[c];
    if (mp < 0) mp = st.query(0, 0, N, ss[a].l, ss[a].r + 1);
    if (mc < 0) mc = st.query(0, 0, N, ss[c].l, ss[c].r + 1);
    x *= b == 0 ? 0 : find(c, mp - mc + b - 1);
    y *= find(c, mp - mc + b);
  }
  return val = x + y;
}
int main(int argc, char *argv[]) {
  int i, j;
  int n, x, l, r;
  double p;
  cin >> n >> q;
  N = 1;
  while (N < n) N <<= 1;
  st.init();
  for ((i) = (0); (i) < (n); ++(i)) {
    cin >> x;
    st.update(i, x);
  }
  ss.push_back(seg(0, n - 1, 0.0));
  for ((i) = (0); (i) < (q); ++(i)) {
    cin >> l >> r >> p;
    --l;
    --r;
    ss.push_back(seg(l, r, p));
  }
  sort(ss.begin() + 1, ss.end(), comp);
  for ((i) = (1); (i) < (q + 1); ++(i)) build(0, i);
  for ((i) = (0); (i) < (q + 1); ++(i))
    for ((j) = (0); (j) < (q + 1); ++(j)) dp[i][j] = -1.0;
  memset(m, -1, sizeof(m));
  ;
  double pre = find(0, 0), ans = pre * m[0];
  for ((i) = (1); (i) < (q + 1); ++(i)) {
    double cur = find(0, i);
    ans += (cur - pre) * (m[0] + i);
    pre = cur;
  }
  cout.setf(ios::fixed);
  cout << setprecision(7) << ans << endl;
  return 0;
}
