加快算法速度以达到 1 秒

你不必将所有事情都进行比较。

看看你的照片

假设您沿着坐标 (0,ai) 从左向右移动，您会发现如果 a0=1 且 b0=4，则 ai >= a0 且 bi<=b0 的任何其他线段都将与第一条线段相交。

由于我们是从左到右，这意味着在处理下一对ai、bi时，为了了解这对是否与另一对相交，我们只需要知道之前所有值中的最大值aMax和bMax即可。如果 ai == aMax - 那么这些线段与前面的线段在点 ai 处相交。如果 bi <= bmax - 则线段 bi 与已处理的某个线段相交。

这样，我们就得到了一个线性算法（除了 NlogN 排序之外）。C# 中的一个示例，我首先从左到右，然后从右到左。

public int[][] NotIntersects(int[][] data)
{
    Array.Sort(data, Comparer<int[]>.Create( (a,b) => a[0].CompareTo(b[0]) ));
    
    var edge = data[0][1];  
    var idexes = new HashSet<int>();
    
    for(int i=1; i<data.Length; i++)
    {
        if (data[i][1] <= edge || data[i][0] == data[i-1][0]) idexes.Add(i);
        edge = Math.Max(edge, data[i][1]);
    }
    
    edge = data[data.Length-1][1];

    for (int i = data.Length - 2; i >=0; i--)
    {
        if (data[i][1] >= edge || data[i][0] == data[i+1][0]) idexes.Add(i);
        edge = Math.Min(edge, data[i][1]);
    }
    
    return data.Where((x, i) => !idexes.Contains(i)).ToArray();
}

考试

NotIntersects(new[] { 
    new[] { 1, 4 }, 
    new[] { 2, 5 }, 
    new[] { 3, 1 }, 
    new[] { 4, 5 }, 
    new[] { 5, 6 } })
    .Dump();

结论

令a _i为线段的下端，构造索引i _k使得序列a _{i k}不减少。

类似地，索引j _k使得序列b _{j k}不减。

对于一个线段 ( a _m , b _m ) 来说，它是孤独的，所有其他线段必须完全位于它的左侧或右侧。设它的左边有k 个线段，其余的都在右边。则i _k = m - k个线段下端中单个线段下端的左侧。类似地，j _k = m - k 个线段上端中单个线段上端的左侧。m的具体值并不重要。重要的是所有孤独段都有i _k = j _k。

孤独线段的相邻线段的下端与它不重合：a _{i k-1} < a _{i k} < a _{i k+1}。同样，上端也不重合： b _{j k-1} < b _{j k} < b _{j k+1}。

我们迭代k。在孤独片段之前开始的所有片段都必须在它之前结束。为此，我们根据段数创建一个标志数组。当段开始或结束时，相应的标志被反转。在孤独段之前，必须重置所有标志。

下面的程序体现了这三个想法。运行时间为O(nlogn)。

import java.util.*;

public class Temp {
    private static class Index {
        private final boolean[] flags;
        private final int n;
        private final int[] a;
        private final int[] i; // a[i[k]] перечислены по возрастанию

        public Index(boolean[] flags, int[] a) {
            this.flags = flags;
            this.n = a.length;
            this.a = a;
            Integer[] index = new Integer[this.n];
            for (int i = 0; i < this.n; ++i) {
                index[i] = i;
            }
            Arrays.sort(index, Comparator.comparingInt(i -> a[i]));
            this.i = new int[this.n];
            for (int k = 0; k < this.n; ++k) {
                this.i[k] = index[k];
            }
        }

        // инвертирует флаг для отрезка на позиции k
        // возвращает один, если флаг установлен
        // возвращает минус один, если флаг снят
        public int flip(int k) {
            flags[i[k]] = !flags[i[k]];
            return (flags[i[k]]) ? 1 : -1;
        }

        // индекс отрезка на позиции k
        public int i(int k) {
            return i[k];
        }

        // конец отрезка на позиции k не пересекается с другими отрезками 
        public boolean distinct(int k) {
            return 
                (k == 0     || a[i[k - 1]] < a[i[k]]              ) &&
                (k == n - 1 ||               a[i[k]] < a[i[k + 1]])
            ;
        }
    }

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        int[] a = new int[n];
        int[] b = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = s.nextInt();
            b[i] = s.nextInt();
        }
        boolean[] flags = new boolean[n];
        Index ia = new Index(flags, a);
        Index ib = new Index(flags, b);

        int answer = 0; // число одиноких отрезков
        int nFlags = 0; // число отрезков, которые начались и не закончились
        for (int k = 0; k < n; ++k) {
            if (
                nFlags == 0        && // все отрезки завершились
                ia.i(k) == ib.i(k) && // это концы одного отрезка
                ia.distinct(k)     && // конец a не пересекается с другими
                ib.distinct(k)        // конец b не пересекается с другими
            ) {
                ++answer;
            }
            // перевернуть флаги и поправить счётчик установленных флагов
            nFlags += ia.flip(k) + ib.flip(k);
        }
        System.out.println(answer);
    }
}