La 14ª Competencia Provincial de la Copa Lanqiao Python Grupo B Pregunta D - Pipeline (AC)

1. Tubería

1. Descripción del problema

Hay una longitud de len \text{len}La tubería horizontal de$\text{len}$$\text{Segmentos len}$ , cada segmento tiene una válvula conmutable y un sensor para detectar el flujo de agua en el centro.

Inicialmente la tubería está vacía y ubicada en $l_{}$La válvula estará en $S_{}$Déjelo abierto en todo momento y mantenga el agua fluyendo hacia la tubería.

Para $l_{}$válvula, el agua por la que fluye está en $t_{}$( $t_{}\ge S_{}$) momento hará que el punto de partida sea $l_{}-(t_{}-S_{})$ etapa$l_{}+(t_{}-S_{})$ el sensor de segmento detecta el flujo de agua.

Encuentre el momento más temprano en el que el sensor en el medio de cada sección de la tubería detecta el flujo de agua.

2. Formato de entrada

La primera línea de entrada contiene dos números enteros $norte,\text{len}$ , separados por un espacio, representan respectivamente el número de válvulas que se abrirán y la longitud de la tubería.

siguientenn _Cada línea de$n$$l_{},S_{}$, separados por un espacio, indica que está ubicado en $l_{}$La válvula en el centro del segmento de tubería estará en $S_{}$Siempre abierto.

3. Formato de salida

Una línea de salida contiene un número entero que representa la respuesta.

4. Entrada de muestra

3 10
1 1
6 5
10 2

5. Salida de muestra

5

6. Escala de casos de uso y convenciones de evaluación

por $30$ % de los casos de evaluación,$norte\le 200$，$S_{},\text{len}\le 3000$；

por $70$ % de los casos de evaluación,$norte\le 5000$，$S_{},\text{len}\le 10^5$；

Para todos los casos de evaluación, $1\le norte\le 10^5$ ​，$1\le S_{},\text{len}\le 10^9$ ​，$1\le l_{}\le \text{len}$ ​，$l_{yo-}<l_{}$​。

2. Ideas para resolver problemas

Para un momento $x$ , si todos los sensores pueden detectar el flujo de agua en este momento, entonces cuando el punto de tiempo sea mayor que$Cuando\; x$ , también se debe garantizar que todos los sensores puedan detectar el flujo de agua. La pregunta requiere que encontremos el punto temporal más pequeño que cumpla las condiciones. Como la respuesta es bipartita, podemos pensar en una respuesta dicotómica.

Después de tener la idea dicotómica, el problema se convierte a un determinado momento $x$ , ¿cómo juzgamos que todos los sensores pueden detectar el flujo de agua en este momento? Piense detenidamente, cuando se determine el tiempo, para una persona ubicada en$a_{}$Y el tiempo de apertura es $S_{}(s_{}\le x)$ , su flujo de agua es en realidad un intervalo de cobertura$[{un}_{}-(x-S_{}),a_{}+(x-S_{})]$ segmento de línea.

Podemos tomar todos $S_{}\le Todas\; las\; válvulas\; de\; x$ se convierten y lo que realmente se obtiene son varios segmentos de línea. Determinar si todos los sensores pueden detectar el flujo de agua equivale a determinar si estos diversos segmentos de línea pueden cubrir el intervalo$[1,\text{len}]$ , el problema se transforma en un problema de cobertura de intervalo.

La cobertura de intervalos es un problema clásico. Podemos ordenar estos intervalos por su punto final izquierdo. A continuación comprobamos si estos intervalos cubren todo el oleoducto. Si el punto final izquierdo del primer intervalo es mayor que $1$ , entonces significa que el inicio del oleoducto no está cubierto y regresa directamentefalse. De lo contrario configuramos una variable$r$ representa la distancia más lejana alcanzable,$El\; valor\; inicial\; de\; r$ es el punto final derecho del primer intervalo. Luego comprobamos si otros intervalos son consistentes con$r$ adyacentes o superpuestos. Si el intervalo actual y$r$ es adyacente o se superpone, agregamos el punto final derecho del intervalo actual y$r$ toma el valor máximo. Finalmente si$r\ge \text{len}$ significa que todos los intervalos se cubren con éxito; de lo contrario, significa que no.

Volvamos atrás y consideremos cómo escribir dicotomía $l$ es el límite inferior de la respuesta,$r$ es el límite superior de la respuesta. Si el punto temporal obtenido por dicotomía es$\text{mid}$ es elegible porque es mayor que$\text{El punto de tiempo de mid}$ también debe cumplir las condiciones, por lo que actualice$r=\text{mid}$ , de lo contrario actualice$yo=\text{medio+1}$ . Repetimos este proceso hasta que los extremos izquierdo y derecho del rango de búsqueda sean iguales, momento en el que se encuentra el momento más temprano. Por supuesto$yo,$También debemos pensar en el valor inicial de$r$ , llobviamente soy$1$$1$ , mientras que$rNecesitamos$ considerar la situación límite, es decir, solo hay una válvula más a la izquierda o más a la derecha que se abre en el último momento. Obviamente, el tiempo requerido en este momento es$2\times 10^9$ , entoncesrrEl valor inicial de$r$$2\times 10^9$ .

Complejidad del tiempo: $O(n.iniciarsesión{norte}^2)$。

3. Código_AC

• C++

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define sz(s) ((int)s.size())

int n, m;
int main()
{
    
    
	ios_base :: sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n >> m;
	vector<int> a(n), s(n);
	for (int i = 0; i < n; ++i) {
    
    
		cin >> a[i] >> s[i];
	}
	auto check = [&](LL t) {
    
    
		std::vector<pair<LL, LL>> v;
		for (int i = 0; i < n; ++i) {
    
    
			if (t >= s[i]) v.push_back({
    
    a[i] - (t - s[i]), a[i] + (t - s[i])});
		}
		sort(v.begin(), v.end());
		if (sz(v) == 0 || v[0].first > 1) return false;
		LL r = v[0].second;
		for (int i = 1; i < sz(v); ++i) {
    
    
			if (v[i].first <= r + 1) r = max(r, v[i].second);
			else break;
		}
		return r >= m;
	};
	LL l = 1, r = 2e9;
	while (l < r) {
    
    
		LL mid = l + r >> 1;
		if (check(mid)) r = mid;
		else l = mid + 1;
	}
	cout << r << '\n';
	return 0;
}

• Java

import java.util.*;

public class Main {
    
    
    static int n, m;

    public static void main(String[] args) {
    
    
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        int[] a = new int[n];
        int[] s = new int[n];
        for (int i = 0; i < n; ++i) {
    
    
            a[i] = sc.nextInt();
            s[i] = sc.nextInt();
        }
        long l = 1, r = 2_000_000_000;
        while (l < r) {
    
    
            long mid = l + r >>> 1;
            if (check(mid, a, s)) r = mid;
            else l = mid + 1;
        }
        System.out.println(r);
    }

    private static boolean check(long t, int[] a, int[] s) {
    
    
        List<Pair<Long, Long>> v = new ArrayList<>();
        for (int i = 0; i < n; ++i) {
    
    
            if (t >= s[i]) {
    
    
                v.add(new Pair<>(a[i] - (t - s[i]), a[i] + (t - s[i])));
            }
        }
        v.sort(Comparator.comparingLong(Pair::getKey));
        if (v.size() == 0 || v.get(0).getKey() > 1) return false;
        long r = v.get(0).getValue();
        for (int i = 1; i < v.size(); ++i) {
    
    
            if (v.get(i).getKey() <= r + 1) r = Math.max(r, v.get(i).getValue());
            else break;
        }
        return r >= m;
    }

    static class Pair<K, V> {
    
    
        private final K key;
        private final V value;

        public Pair(K key, V value) {
    
    
            this.key = key;
            this.value = value;
        }

        public K getKey() {
    
    
            return key;
        }

        public V getValue() {
    
    
            return value;
        }
    }
}

• Pitón

n, m = map(int, input().split())
a = []
s = []
for i in range(n):
    a_i, s_i = map(int, input().split())
    a.append(a_i)
    s.append(s_i)

def check(t):
    v = []
    for i in range(n):
        if t >= s[i]:
            v.append((a[i] - (t - s[i]), a[i] + (t - s[i])))
    v.sort()
    if len(v) == 0 or v[0][0] > 1:
        return False
    r = v[0][1]
    for i in range(1, len(v)):
        if v[i][0] <= r + 1:
            r = max(r, v[i][1])
        else:
            break
    return r >= m

l = 1
r = 2_000_000_000
while l < r:
    mid = (l + r) // 2
    if check(mid):
        r = mid
    else:
        l = mid + 1

print(r)