一个算法题，求高手给个优化思路，谢啦

[hey_finley]

海上有许多灯塔，为过路船只照明。从平面上看，海域范围是[1, 10^7] × [1, 10^7] 。


（图一）

如图一所示，每个灯塔都配有一盏探照灯，照亮其东北、西南两个对顶的直角区域。探照灯的功率之大，足以覆盖任何距离。灯塔本身是如此之小，可以假定它们不会彼此遮挡。

（图二）

若灯塔A、B均在对方的照亮范围内，则称它们能够照亮彼此。比如在图二的实例中，蓝、红灯塔可照亮彼此，蓝、绿灯塔则不是，红、绿灯塔也不是。

现在，对于任何一组给定的灯塔，请计算出其中有多少对灯塔能够照亮彼此。

输入
共n+1行。

第1行为1个整数n，表示灯塔的总数。

第2到n+1行每行包含2个整数x, y，分别表示各灯塔的横、纵坐标。

输出
1个整数，表示可照亮彼此的灯塔对的数量。


我的思路是先对X方向进行排序然后逐一比对Y方向的大小，如果x1<x2 && y1 < y2 则可互相照亮。
但是在OJ上测试超时了，这么比对的话是O(n²)复杂度，有没有好的优化方法啊？

[buyong]

确定是算法原因，而不是实现上有bug?

[FancyMouse]

计算x1<x2并且y1<y2有经典的nlogn分治法。

[hey_finley]

引用 3 楼 u012872817 的回复:

AB互亮且BC互亮是否能推出AC互亮

不能吧，比如这个图 AC就不能互亮

[hey_finley]

引用 4 楼 buyong 的回复:

确定是算法原因，而不是实现上有bug?

不是，OJ上显示的是超时了，而且小数据输入都是correct，大输入就超时了

[buyong]

对x方向和y方向分别预排序一次，记录每个元素在这两个结果中的相对位置。 然后取x最小的，他的y所在y序列的位置就知道了，y序列比他大的肯定是1（互亮），标记这个元素用过了。 然后取x第二小的，他的y所在y序列的位置就知道了，y序列比他大的，没有标记用过的，都是1. ...... 直到x完成。 这样复杂度貌似O（N）,你可以试试。

[buyong]

排序一般是O(NlogN)

[hey_finley]

引用 1 楼 FancyMouse 的回复:

计算x1<x2并且y1<y2有经典的nlogn分治法。

能具体一点吗，小弟刚刚学算法还有好多东西不懂。

[wwzhzh]

AB互亮且BC互亮是否能推出AC互亮

[FancyMouse]

引用 7 楼 buyong 的回复:

对x方向和y方向分别预排序一次，记录每个元素在这两个结果中的相对位置。 然后取x最小的，他的y所在y序列的位置就知道了，y序列比他大的肯定是1（互亮），标记这个元素用过了。 然后取x第二小的，他的y所在y序列的位置就知道了，y序列比他大的，没有标记用过的，都是1. ...... 直到x完成。 这样复杂度貌似O（N）,你可以试试。

标记用过以后，后面y序列的位置就会变化。如果用这个大框架的话，维护这个y序列的位置是最难的部分。你ms没解决这问题（

[hey_finley]

引用 9 楼 FancyMouse 的回复:

[quote=引用 7 楼 buyong 的回复:] 对x方向和y方向分别预排序一次，记录每个元素在这两个结果中的相对位置。 然后取x最小的，他的y所在y序列的位置就知道了，y序列比他大的肯定是1（互亮），标记这个元素用过了。 然后取x第二小的，他的y所在y序列的位置就知道了，y序列比他大的，没有标记用过的，都是1. ...... 直到x完成。 这样复杂度貌似O（N）,你可以试试。

标记用过以后，后面y序列的位置就会变化。如果用这个大框架的话，维护这个y序列的位置是最难的部分。你ms没解决这问题（[/quote] 对y序列进行判断的话还是得遍历一遍额，那个经典的nlog(n)的经典法大概的思路能说说吗？

[hey_finley]

引用 1 楼 FancyMouse 的回复:

计算x1<x2并且y1<y2有经典的nlogn分治法。

很感谢！ 不过我先对x方向排序，然后用归并计算y逆序对，的确比开始的快很多了，20个测例中只剩最后一个超时了，可能是数据量过于巨大了。 我对x的排序用qsort和归并都不行，还能再继续优化吗？

[FancyMouse]

引用 10 楼 pengtc1994 的回复:

[quote=引用 9 楼 FancyMouse 的回复:] [quote=引用 7 楼 buyong 的回复:] 对x方向和y方向分别预排序一次，记录每个元素在这两个结果中的相对位置。 然后取x最小的，他的y所在y序列的位置就知道了，y序列比他大的肯定是1（互亮），标记这个元素用过了。 然后取x第二小的，他的y所在y序列的位置就知道了，y序列比他大的，没有标记用过的，都是1. ...... 直到x完成。 这样复杂度貌似O（N）,你可以试试。

标记用过以后，后面y序列的位置就会变化。如果用这个大框架的话，维护这个y序列的位置是最难的部分。你ms没解决这问题（[/quote] 对y序列进行判断的话还是得遍历一遍额，那个经典的nlog(n)的经典法大概的思路能说说吗？[/quote] 你去搜逆序数对的nlogn解法就有了。

[FancyMouse]

引用 12 楼 pengtc1994 的回复:

[quote=引用 1 楼 FancyMouse 的回复:] 计算x1<x2并且y1<y2有经典的nlogn分治法。

很感谢！ 不过我先对x方向排序，然后用归并计算y逆序对，的确比开始的快很多了，20个测例中只剩最后一个超时了，可能是数据量过于巨大了。 我对x的排序用qsort和归并都不行，还能再继续优化吗？[/quote] 放代码，放oj的数据范围

[hey_finley]

引用 13 楼 FancyMouse 的回复:

[quote=引用 12 楼 pengtc1994 的回复:] [quote=引用 1 楼 FancyMouse 的回复:] 计算x1<x2并且y1<y2有经典的nlogn分治法。

很感谢！ 不过我先对x方向排序，然后用归并计算y逆序对，的确比开始的快很多了，20个测例中只剩最后一个超时了，可能是数据量过于巨大了。 我对x的排序用qsort和归并都不行，还能再继续优化吗？[/quote] 放代码，放oj的数据范围[/quote]

#include<cstdio>
#include<cstdlib>
class lighthouse{
public:
	long x;
	long y;
};
int cmp(const void* a, const void* b)
{
	if (((lighthouse *)a)->x < ((lighthouse *)b)->x)
		return -1;
	else if (((lighthouse *)a)->x > ((lighthouse *)b)->x)
		return 1;
	else
		return 0;
}
void merge(lighthouse * A, long lo, long mi, long hi, long & n)
{
	lighthouse * a = A + lo;
	long lb = mi - lo;
	lighthouse * B = new lighthouse[lb];
	for (long i = 0; i < lb; B[i] = a[i++]);
	long lc = hi - mi;
	lighthouse * C = A + mi;
	for (long i = 0, j = 0, k = 0; j < lb;){
		if (k < lc && C[k].y < B[j].y)
			a[i++] = C[k++];
		if (lc <= k || B[j].y <= C[k].y){
			a[i++] = B[j++];
			n += lc - k;
		}
	}
	delete[] B;
}
void mergesort(lighthouse * A, long lo, long hi, long & n)
{
	if (hi - lo < 2)
		return;
	long mi = (lo + hi) >> 1;
	mergesort(A, lo, mi, n);
	mergesort(A, mi, hi, n);
	merge(A, lo, mi, hi, n);
}
int main()
{
	long n;
	scanf("%ld",&n);
	lighthouse * p = new lighthouse[n];
	for(long i = 0; i < n; ++i)
		scanf("%ld%ld",&p[i].x,&p[i].y);
	qsort(p, n, sizeof(lighthouse), cmp);
	long num = 0;
	mergesort(p, 0, n, num);
	printf("%ld",num);
	return 0;
}

限制 对于90%的测例：1 ≤ n ≤ 3×10^5 对于95%的测例：1 ≤ n ≤ 10^6 全部测例：1 ≤ n ≤ 4×10^6 灯塔的坐标x, y是整数，且不同灯塔的x, y坐标均互异 1 ≤ x, y ≤ 10^7 提醒 注意机器中整型变量的范围，C/C++中的int类型通常被编译成32位整数，其范围为[-231, 231 - 1]，不一定足够容纳本题的输出。 时间：2s，内存：256MB 就是最后一个测例超时了，一共20个测例

[hey_finley]

引用 15 楼 FancyMouse 的回复:

4e6……看来得出点常数优化了。 xy的类型、所有下标的类型改成int *B不要new，直接开个原长的新数组，然后直接用这个新数组当temp hi-lo<32的时候考虑用朴素算法。 可以的话用STL的sort而不是stdlib的qsort 坐标都互异，那么在按照x排序以后，x可以直接丢掉，只针对y来做merge。

虽然还是不行但是已经非常感谢了！学到了很多东西，谢谢！

[FancyMouse]

4e6……看来得出点常数优化了。 xy的类型、所有下标的类型改成int *B不要new，直接开个原长的新数组，然后直接用这个新数组当temp hi-lo<32的时候考虑用朴素算法。 可以的话用STL的sort而不是stdlib的qsort 坐标都互异，那么在按照x排序以后，x可以直接丢掉，只针对y来做merge。