|
|
#include <algorithm>
|
|
|
#include <cstdio>
|
|
|
#include <cstring>
|
|
|
#include <vector>
|
|
|
using namespace std;
|
|
|
|
|
|
//快读
|
|
|
int read() {
|
|
|
int x = 0, f = 1;
|
|
|
char ch = getchar();
|
|
|
while (ch < '0' || ch > '9') {
|
|
|
if (ch == '-') f = -1;
|
|
|
ch = getchar();
|
|
|
}
|
|
|
while (ch >= '0' && ch <= '9') {
|
|
|
x = (x << 3) + (x << 1) + (ch ^ 48);
|
|
|
ch = getchar();
|
|
|
}
|
|
|
return x * f;
|
|
|
}
|
|
|
|
|
|
const int N = 500010;
|
|
|
const int M = 50010;
|
|
|
|
|
|
int n; //点的数量
|
|
|
vector<int> a[M]; //记录每个点的坐标
|
|
|
|
|
|
//主席树的结构体
|
|
|
struct Node {
|
|
|
int cnt;
|
|
|
int l, r;
|
|
|
} tr[N << 5]; //主席树，一般开32倍空间
|
|
|
int idx; //主席树的节点生成器
|
|
|
int root[M]; //版本与根节点的对应关系
|
|
|
int ver[M]; //记录y坐标是在哪个版本加入进去的,这是一个桶，性能用静态数组模拟应该是最强的，不要使用什么unordered_map之流
|
|
|
|
|
|
//标准的主席树insert
|
|
|
int insert(int p, int l, int r, int x) {
|
|
|
int q = ++idx;
|
|
|
tr[q] = tr[p];
|
|
|
tr[q].cnt++;
|
|
|
if (l == r) return q;
|
|
|
int mid = (l + r) >> 1;
|
|
|
if (x <= mid)
|
|
|
tr[q].l = insert(tr[p].l, l, mid, x);
|
|
|
else
|
|
|
tr[q].r = insert(tr[p].r, mid + 1, r, x);
|
|
|
return q;
|
|
|
}
|
|
|
|
|
|
//功能：主席树，在两个版本间 查询 某个区间中数字的增加个数
|
|
|
int query(int q, int p, int ql, int qr, int l, int r) {
|
|
|
if (ql <= l && qr >= r) return tr[p].cnt - tr[q].cnt; //完整区间包含,直接返回两个版本的数字个数差，表示两个版本间增加的数字数量
|
|
|
int ans = 0;
|
|
|
int mid = (l + r) >> 1;
|
|
|
if (ql <= mid) ans = query(tr[q].l, tr[p].l, ql, qr, l, mid); //递归查询左半区间
|
|
|
if (qr > mid) ans += query(tr[q].r, tr[p].r, ql, qr, mid + 1, r); //递归查询右半区间
|
|
|
return ans;
|
|
|
}
|
|
|
|
|
|
bool solve() {
|
|
|
//对于主席树的0号版本进行清空
|
|
|
root[0] = idx = tr[0].l = tr[0].r = tr[0].cnt = 0; //索引号生成器idx修改为0，主席树中0号结点左儿子，右儿子都不存在，0号版本中数字个数为0, 0号版本的根节点是0
|
|
|
memset(ver, 0, sizeof(ver)); //清空ver数组
|
|
|
|
|
|
for (int i = 1; i <= 50000; i++) { //从小到大枚举每一个x坐标
|
|
|
for (int j = 0; j < a[i].size(); j++) { //从小到大枚举每一个y坐标
|
|
|
//如果是第一个y坐标，那么l=0,这个0是哨兵的意思。如果不是第一个y坐标，那么l=当前y坐标的前一个y坐标，prev_y,
|
|
|
int l = j == 0 ? 0 : a[i][j - 1];
|
|
|
|
|
|
//如果是最后一个y坐标，那么r=50001,否则r=当前y坐标的下一个y坐标，next_y
|
|
|
int r = j == a[i].size() - 1 ? 50001 : a[i][j + 1];
|
|
|
|
|
|
// root[i]:当前版本的根
|
|
|
// root[x[a[i][j]]]:前一版本的根
|
|
|
// query的返回值是个整数，表示两个版本间两个区间内增加的数字个数，如果个数大于0，就return false
|
|
|
if (query(root[i - 1], root[ver[a[i][j]]], l + 1, r - 1, 1, 50000) > 0) return false;
|
|
|
}
|
|
|
|
|
|
root[i] = root[i - 1];
|
|
|
for (int j = 0; j < a[i].size(); j++) { //从小到大枚举每一个y坐标
|
|
|
root[i] = insert(root[i], 1, 50000, a[i][j]);
|
|
|
ver[a[i][j]] = i; //记录a[i][j]这个y坐标，是第i个版本中增加进去的
|
|
|
}
|
|
|
}
|
|
|
//如果上面所有的坐标点都讨论过，全都没有返回false,那就只能返回true
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
NO
|
|
|
YES
|
|
|
*/
|
|
|
int main() {
|
|
|
//文件输入输出
|
|
|
#ifndef ONLINE_JUDGE
|
|
|
freopen("HDU5820.in", "r", stdin);
|
|
|
#endif
|
|
|
|
|
|
while (n = read(), n) { //在使用快读时，要注意使用 ,n 而不是使用 && n!!!! read没有返回值！！！！
|
|
|
|
|
|
// a数组装的是坐标(x,y),只不过它是以x坐标为第一维，第二维的y1,y2,y3,... 通过push_back加入到一维的x中
|
|
|
for (int i = 0; i < M; i++) a[i].clear(); //二维vector的清空操作，不用循环还真不行
|
|
|
|
|
|
int x, y;
|
|
|
while (n--) {
|
|
|
x = read(), y = read(); // 每个点的坐标
|
|
|
a[x].push_back(y); // 记录每个点的坐标，记录的方法很有意思，是一个vector,一维是x坐标，二维是y坐标
|
|
|
}
|
|
|
|
|
|
//枚举每个可能的x坐标，对x坐标相同的点，按y坐标小由到大进行排序，这样，就是一个二维有序的数组啦，和结构体两个属性进行排序效果和速度是一样的
|
|
|
for (int i = 1; i <= 50000; i++) { //这样是以x从小到大排序的
|
|
|
sort(a[i].begin(), a[i].end()); //对y也要从小到大排序,这和整一个Node{x,y},然后自定义sort operator < 定义先按x，后按y是一个意思，有时间再写一个结构体版本的
|
|
|
a[i].erase(unique(a[i].begin(), a[i].end()), a[i].end()); //对于相同的(x,y)进行排序+去重
|
|
|
}
|
|
|
|
|
|
//开始每一轮计算的主函数solve
|
|
|
puts(solve() ? "YES" : "NO"); //存在题目要求的答案，返回YES，否则返回NO
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
} |
