Intervalo de combinación de método anti-prueba

Intervalo de fusión

La solución oficial de hebilla se publicó hace 2 días 11.7k clasificación oficial de C ++ Python

Método 1: ordenar

Ideas

Si ordenamos por el extremo izquierdo del intervalo, en la lista ordenada, los intervalos que se pueden fusionar deben ser continuos. Como se muestra en la siguiente figura, los intervalos marcados con azul, amarillo y verde se pueden combinar en un intervalo grande, que es continuo en la lista ordenada:

Algoritmo

Usamos matrices para  merged almacenar la respuesta final.

Primero, ordenamos los intervalos en la lista en orden ascendente del punto final izquierdo. Luego agregamos el primer intervalo a la  merged matriz y consideramos cada intervalo posterior en orden:

• Si el punto final izquierdo del intervalo actual es merged posterior al punto final derecho del último intervalo en la matriz  , entonces no coincidirán, podemos agregar directamente este intervalo al merged final de la matriz  ;

• De lo contrario, coinciden, y necesitamos actualizar el extremo derecho merged del último intervalo en la matriz con el extremo derecho del intervalo actual y  establecerlo en el mayor de los dos.

Prueba de corrección

La corrección del algoritmo anterior se puede demostrar mediante el método de prueba contraria: en la matriz ordenada, los dos intervalos que se deben fusionar no se pueden fusionar, entonces significa que existe un triple (i, j, k) (i, j, k) y los tres intervalos en la matriz a [i], a [j], a [k] a [i], a [j], a [k] satisfacen i <j <ki <j <k y (a [i], a [k]) (a [i], a [k]) se pueden combinar, pero (a [i], a [j]) (a [i], a [j]) y ( a [j], a [k]) (a [j], a [k]) no se pueden fusionar. Esto muestra que satisfacen las siguientes desigualdades:

a [i] .end <a [j] .start \ quad (a [i] \ text {y} a [j] \ text {no se puede combinar}) \\ a [j] .end <a [k]. inicio \ quad (a [j] \ text {y} a [k] \ text {no se puede combinar}) \\ a [i] .end \ geq a [k] .start \ quad (a [i] \ text { Y} a [k] \ text {se puede combinar}) \\ a [i] .end <a [j] .start (a [i] y a [j] no se pueden combinar) a [j] .end <a [ k] .start (a [j] y a [k] no pueden fusionarse) a [i] .end≥a [k] .start (a [i] y a [k] pueden fusionarse)

Combinamos estas desigualdades (tenga en cuenta que existe una desigualdad obvia a [j] .start \ leq a [j] .enda [j] .start≤a [j] .end), podemos obtener:

a [i] .end <a [j] .start \ leq a [j] .end <a [k] .starta [i] .end <a [j] .start≤a [j] .end <a [ k] .start

¡Hay una contradicción! Esto muestra que la suposición no es cierta. Por lo tanto, todos los intervalos que pueden fusionarse son necesariamente continuos.

• Python3
• C ++

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key=lambda x: x[0])

        merged = []
        for interval in intervals:
            # 如果列表为空，或者当前区间与上一区间不重合，直接添加
            if not merged or merged[-1][1] < interval[0]:
                merged.append(interval)
            else:
                # 否则的话，我们就可以与上一区间进行合并
                merged[-1][1] = max(merged[-1][1], interval[1])

        return merged

Análisis de complejidad.

• Complejidad de tiempo: O (n \ log n) O (nlogn), donde nn es el número de intervalos. Además de la sobrecarga de la ordenación, solo necesitamos una exploración lineal, por lo que la sobrecarga del tiempo principal es la ordenación O (n \ log n) O (nlogn).

• Complejidad del espacio: O (\ log n) O (logn), donde nn es el número de intervalos. Lo que se calcula aquí es el espacio extra utilizado además de almacenar la respuesta. O (\ log n) O (logn) es la complejidad de espacio requerida para la ordenación.