2017年10月23日提高组T3 询问

Descripiton

---

Input

---

Output

---

Hint

---

Solution

---

妙啊

先说一个结论：两个操作[l1,r1] k1和[l2,r2] k2，若l1 < l2 < r2 < r1，那么一定有k1<=k2 (1)
通俗地说，大区间的最小值不大于被包含小区间的最小值
有了这个结论再加上题目中的隐藏条件:每个数字只出现一次 (2)。我们就可以愉快(并不)地做题了。

二分一个答案，把相同k的放在一起操作分别求并区间核交区间，若他们的交区间为空说明存在两段不相邻的区间有相同的数字，违反了(2)。若他们的交区间已经被更大的区间完全覆盖了就违反了(1)。否则就用并区间覆盖修改操作就ok。

线段树做法是显然(巨慢)的。可以用并查集，每次合并区间就把区间里的每一个i并到i+1，这样每次判断并区间的l和r是不是同一集合就行。

Code

---

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <queue>
#include <iostream>
#include <algorithm>
#include <vector>
#define rep(i, st, ed) for (int i = st; i <= ed; i += 1)
#define drp(i, st, ed) for (int i = st; i >= ed; i -= 1)
#define erg(i, st) for (int i = ls[st]; i; i = e[i].next)
#define fill(x, t) memset(x, t, sizeof(x))
#define max(x, y) ((x)>(y)?(x):(y))
#define min(x, y) ((x)<(y)?(x):(y))
#define abs(x) ((x)<(0)?(-(x)):(x))
#define ll long long
#define ld lont double
#define db double
#define INF 0x3f3f3f3f
#define N 1002001
#define E 1001
#define L 50001
struct treeNode {int l, r, mn, lazy;} t[N << 2 | 1];
int rank[L], l[L], r[L], k[L];
inline int read() {
    int x = 0, v = 1;
    char ch = getchar();
    for (; ch < '0' || ch > '9'; v *= ((ch == '-')?(-1):(1)), ch = getchar());
    for (; ch <= '9' && ch >= '0'; (x *= 10) += ch - '0', ch = getchar());
    return x * v;
}
inline void pushDown(int now) {
    if (!t[now].lazy) {
        return ;
    }
    t[now << 1].lazy = t[now << 1 | 1].lazy = t[now].lazy;
    t[now << 1].mn = t[now << 1 | 1].mn = t[now].lazy;
    t[now].lazy = 0;
}
inline void modify(int now, int l, int r, int v) {
    if (t[now].l == l && t[now].r == r) {
        t[now].lazy = t[now].mn = v;
    } else {
        pushDown(now);
        int mid = (t[now].l + t[now].r) >> 1;
        if (r <= mid) {
            modify(now << 1, l, r, v);
        } else if (l > mid) {
            modify(now << 1 | 1, l, r, v);
        } else {
            modify(now << 1, l, mid, v);
            modify(now << 1 | 1, mid + 1, r, v);
        }
        t[now].mn = min(t[now << 1].mn, t[now << 1 | 1].mn);
    }
}
inline int query(int now, int l, int r) {
    if (t[now].l == l && t[now].r == r) {
        return t[now].mn;
    } else {
        pushDown(now);
        int mid = (t[now].l + t[now].r) >> 1;
        if (r <= mid) {
            return query(now << 1, l, r);
        } else if (l > mid) {
            return query(now << 1 | 1, l, r);
        } else {
            return min(query(now << 1, l, mid), query(now << 1 | 1, mid + 1, r));
        }
    }
}
inline void buildTree(int now, int l, int r) {
    t[now] = (treeNode) {l, r, 0};
    if (l == r) {
        return ;
    }
    int mid = (l + r) >> 1;
    buildTree(now << 1, l, mid);
    buildTree(now << 1 | 1, mid + 1, r);
}
inline bool cmp(int a, int b) {
    return k[a] > k[b];
}
int main(void) {
    int n = read();
    int q = read();
    rep(i, 1, q) {
        l[i] = read();
        r[i] = read();
        k[i] = read();
    }
    int lower_bound = 0;
    int upper_bound = q;
    int ans = 0;
    while (lower_bound <= upper_bound) {
        int mid = (lower_bound + upper_bound) >> 1;
        rep(i, 1, mid) {
            rank[i] = i;
        }
        std:: sort(rank + 1, rank + mid + 1, cmp);
        bool flag = false;
        buildTree(1, 1, n);
        rep(ri, 1, mid) {
            int rj = ri + 1;
            int nowLj = l[rank[ri]];
            int nowRj = r[rank[ri]];
            int nowLb = nowLj;
            int nowRb = nowRj;
            while (k[rank[rj]] == k[rank[ri]] && rj <= mid) {
                if (r[rank[ri]] < l[rank[rj]] || l[rank[ri]] > r[rank[rj]]) {
                    flag = true;
                    break;
                } else {
                    nowLj = max(max(l[rank[ri]], l[rank[rj]]), nowLj);
                    nowRj = min(min(r[rank[ri]], r[rank[rj]]), nowRj);
                    nowLb = min(min(l[rank[ri]], l[rank[rj]]), nowLb);
                    nowRb = max(max(r[rank[ri]], r[rank[rj]]), nowRb);
                }
                rj += 1;
            }
            if (nowRj < nowLj || flag) {
                flag = true;
                break;
            }
            int ret = query(1, nowLj, nowRj);
            if (ret > k[rank[ri]]) {
                flag = true;
                break;
            }
            modify(1, nowLb, nowRb, k[rank[ri]]);
            ri = rj - 1;
        }
        if (flag) {
            upper_bound = mid - 1;
        } else {
            ans = mid;
            lower_bound = mid + 1;
        }
    }
    if (ans == q) {
        ans = -1;
    }
    printf("%d\n", ans + 1);
    return 0;
}