#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T SQR(T x) {
  return x * x;
}
template <class T>
inline string TOSTR(const T &x) {
  stringstream ss;
  ss << x;
  return ss.str();
}
template <class T>
void UPDATE_MIN(T &x, T y) {
  if (y < x) {
    x = y;
  }
}
template <class T>
void UPDATE_MAX(T &x, T y) {
  if (x < y) {
    x = y;
  }
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long p, long long m) {
  long long r = 1;
  while (p) {
    if (p & 1) r = r * a % m;
    p >>= 1;
    a = a * a % m;
  }
  return r;
}
const int MOD = 1000 * 1000 * 1000 + 7;
const double PI = 3.1415926535897932384626433832795l;
int N, Q;
int A[100000];
int M[100000][20];
void RMQ_prepair() {
  int i, j;
  for (i = 0; i < N; i++) M[i][0] = i;
  for (j = 1; (1 << j) <= N; j++) {
    assert(j < 20);
    int window = 1 << j;
    int halfwindow = 1 << (j - 1);
    for (i = 0; i + window <= N; i++) {
      int x = M[i][j - 1];
      int y = M[i + halfwindow][j - 1];
      M[i][j] = (A[x] > A[y]) ? x : y;
    }
  }
}
int RMQ(int i, int j) {
  assert(j >= i + 1);
  int diff = j - i;
  int k = 0;
  while (1 << (k + 1) <= diff) k++;
  assert((1 << k) <= diff);
  assert(2 * (1 << k) > diff);
  assert(k < 20);
  int x = M[i][k];
  int y = M[j - (1 << k)][k];
  return (A[x] > A[y]) ? x : y;
}
typedef struct {
  int l;
  int r;
  double p;
  int mx;
  int next_seg_i;
  bool calculated;
  double a[5099];
} Seg;
typedef struct {
  int l;
  int r;
  double p;
} Miniseg;
Miniseg minisegs[5099];
Seg segs[5099];
int seg_i = 0;
bool compare(Miniseg a, Miniseg b) {
  if (a.l < b.l) return true;
  if (a.l > b.l) return false;
  if (a.r > b.r) return true;
  if (a.r < b.r) return false;
  return false;
}
int calc(int curseg_i) {
  Seg &seg = segs[curseg_i];
  if (seg.calculated) {
    seg_i = seg.next_seg_i;
    return seg.mx;
  }
  int mx = A[RMQ(seg.l, seg.r)];
  seg.mx = mx;
  double prod_p[5099];
  double prod_q[5099];
  for (int(i) = 0; (i) < (int)(Q + 1); (i)++) prod_p[i] = 1.0;
  for (int(i) = 0; (i) < (int)(Q + 1); (i)++) prod_q[i] = 1.0;
  prod_p[0] = 0.0;
  while (1) {
    int next_seg_i = seg_i;
    if (next_seg_i >= Q) break;
    Seg &next_seg = segs[next_seg_i];
    if (!(seg.l <= next_seg.l && next_seg.r <= seg.r)) break;
    seg_i++;
    int ch_mx = calc(next_seg_i);
    int diff = mx - ch_mx;
    assert(next_seg.mx == ch_mx);
    assert(diff >= 0);
    for (int(i) = diff + 1; (i) < (int)(Q + 1); (i)++) {
      prod_p[i - diff] *= next_seg.a[i - 1];
    }
    for (int(i) = diff; (i) < (int)(Q + 1); (i)++) {
      prod_q[i - diff] *= next_seg.a[i];
    }
  }
  double q = 1 - seg.p;
  for (int(i) = 0; (i) < (int)(Q + 2); (i)++) {
    seg.a[i] = prod_p[i] * seg.p + prod_q[i] * q;
  }
  seg.calculated = true;
  seg.next_seg_i = seg_i;
  return mx;
}
int main() {
  cin >> N >> Q;
  for (int(i) = 0; (i) < (int)(N); (i)++) cin >> A[i];
  for (int(i) = 0; (i) < (int)(Q); (i)++) {
    int l, r;
    double p;
    cin >> l >> r >> p;
    l--;
    r;
    minisegs[i] = {l, r, p};
  }
  RMQ_prepair();
  sort(minisegs, minisegs + Q, compare);
  for (int(i) = 0; (i) < (int)(Q); (i)++) {
    segs[i] = {minisegs[i].l, minisegs[i].r, minisegs[i].p};
    segs[i].calculated = false;
  }
  segs[Q] = {0, N, 0.0};
  segs[Q].calculated = false;
  for (int i = Q - 1; i >= 0; i--) {
    seg_i = i + 1;
    calc(i);
  }
  seg_i = 0;
  int mx = calc(Q);
  Seg &seg = segs[Q];
  double res = seg.a[0] * mx;
  for (int(j) = 1; (j) < (int)(Q + 1); (j)++) {
    res += (mx + j) * (seg.a[j] - seg.a[j - 1]);
  }
  printf("%.10f\n", res);
  return 0;
}
