洛谷1083（差分+二分 or 线段树）

第一种方法：可以二分最大天数订单的答案然后通过差分求一下是否可行。

 const int maxn = 1e6 + ;
 int n, m, a[maxn], ans;
 struct section {
     int cnt, l, r;
 }b[maxn];
 int c[maxn], sum[maxn];

 inline bool ok(int now) {
     init(c, );
     rep(i, , now) {
         auto tmp = b[i];
         c[tmp.l] -= tmp.cnt;
         c[tmp.r + ] += tmp.cnt;
     }
     rep(i, , n) {
         sum[i] = sum[i - ] + c[i];
         if (sum[i] + a[i] < )    return false;
     }
     return true;
 }

 int main() {
     read(n), read(m);
     rep(i, , n)    read(a[i]);
     rep(i, , m) {
         read(b[i].cnt);
         read(b[i].l);
         read(b[i].r);
     }

     int l = , r = m;
     while (l <= r) {
         int mid = (l + r) >> ;
         if (ok(mid)) {
             l = mid + ;
         } else {
             ans = mid;
             r = mid - ;
         }
     }    

     if (!ans)    writeln();
     else {
         writeln(-);
         writeln(ans);
     }
     return ;
 }

第二种方法：无脑插一棵残缺的线段树板子即可：

 const int maxn = 1e6 + ;
 int n, m;
 struct Node {
     int l, r, minn, tag;
 }t[maxn << ];
 #define ls(p)    p << 1
 #define rs(p)    p << 1 | 1

 void Build(int l, int r, int p) {
     t[p].l = l, t[p].r = r;
     if (l == r) {
         read(t[p].minn);
         t[p].tag = ;
         return;
     }
     int mid = (l + r) >> ;
     Build(l, mid, ls(p));
     Build(mid + , r, rs(p));
     t[p].minn = min(t[ls(p)].minn, t[rs(p)].minn);
 }

 void Push_down(int p) {
     if (t[p].tag) {
         t[ls(p)].minn += t[p].tag;
         t[rs(p)].minn += t[p].tag;
         t[ls(p)].tag += t[p].tag;
         t[rs(p)].tag += t[p].tag;
         t[p].tag = ;
     }
 }

 void Modify(int l, int r, int p, int k) {
     if (l <= t[p].l && t[p].r <= r) {
         t[p].minn += k;
         t[p].tag += k;
         return;
     }
     Push_down(p);
     int mid = (t[p].l + t[p].r) >> ;
     if (l <= mid)    Modify(l, r, ls(p), k);
     if (mid < r)    Modify(l, r, rs(p), k);
     t[p].minn = min(t[ls(p)].minn, t[rs(p)].minn);
 }

 int main() {
     read(n), read(m);
     Build(, n, );
     rep(i, , m) {
         int cnt, l, r;
         read(cnt), read(l), read(r);
         Modify(l, r, , -cnt);
         if (t[].minn < ) {
             writeln(-);
             writeln(i);
             return ;
         }
     }
     writeln();
     return ;
 }