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;
}