1. Pipeline

1. Problem description

There is a length of $\text{len}$ The horizontal pipe of $len$ $\text{len}$ segments, each segment has a switchable valve and a sensor for detecting water flow in the center.

Initially the pipe is empty and located at $L_i$ The valve will be at $S_i$ Leave it open at all times and keep water flowing into the pipe.

For $L_i$ valve, the water it flows into is at $T_i$ ( $T_i \geq S_i$ ) moment will make the starting point from $L_i - (T_i - S_i)$ stage $L_i + (T_i - S_i)$ segment sensor detects water flow.

Find the earliest time at which the sensor in the middle of each section of the pipe detects water flow.

2. Input format

The first line of input contains two integers $n,\text{len}$ , separated by a space, respectively represent the number of valves that will be opened and the length of the pipe.

nextnn Each line of $n$ $L_i,S_i$ , separated by a space, indicates that it is located at $L_i$ The valve in the center of the pipeline segment will be at $S_i$ Always open.

3. Output format

One line of output contains an integer representing the answer.

4. Sample input

5. Sample output

6. Evaluation use case scale and conventions

for $30$ % of evaluation cases, $\leq 200$ ， $S_i, \text{len} \leq 3000$ ；

for $70$ % of evaluation cases, $\leq 5000$ ， $S_i, \text{len} \leq 10^5$ ；

For all evaluation cases, $\leq n \leq 10^5$ ， $\leq S_i,\text{len} \leq 10^9$ ， $\leq L_i \leq \text{len}$ ， $L_{i-1} < L_i$ 。

2. Problem-solving ideas

For a time point $x$ , if all sensors can detect water flow at this time, then when the time point is greater than $When x$ , it must also be ensured that all sensors can detect water flow. The question requires us to find the smallest time point that meets the conditions. Because the answer is bipartite, we can think of a dichotomous answer.

After having the dichotomous idea, the problem is converted to a certain time point $x$ , how do we judge that all sensors can detect water flow at this time? Think carefully, when the time is determined, for a person located in $a_i$ And the opening time is $S_i(S_i \leq x)$ valve, its water flow is actually a coverage interval $a_i-(x-S_i),a_i+(x-S_i)]$ line segment.

We can take all $S_i \leq x$ are all converted, and what is actually obtained is several line segments. Determining whether all sensors can detect water flow is equivalent to determining whether these several line segments can cover the interval $[1,\text{len}]$ , the problem is then transformed into an interval coverage problem.

Interval coverage is a classic problem. We can sort these intervals by their left endpoint. Next, we check whether these intervals cover the entire pipeline. If the left endpoint of the first interval is greater than $1$ , then it means that the beginning of the pipeline is not covered and returns directlyfalse. Otherwise we set a variable $r$ represents the farthest reachable distance, $The initial value of r$ is the right endpoint of the first interval. We then check whether other intervals are consistent with $r$ adjacent or overlapping. If the current interval and $r$ is adjacent or overlapping, we add the right endpoint of the current interval and $r$ takes the maximum value. Finally if $\geq \text{len}$ means that all intervals are successfully covered, otherwise it means that it is not.

Let’s go back and consider how to write dichotomy. Let $l$ is the lower bound of the answer, $r$ is the upper bound of the answer. If the time point obtained by dichotomy is $\text{mid}$ is eligible because it is greater than $\text{mid}$ must also meet the conditions, so update $r=\text{mid}$ , otherwise update $l=\text{mid+1}$ . We repeat this process until the left and right endpoints of the search range are equal, at which point the earliest time is found. Of course $l,$ We also need to think about the initial value of $r$ $l$ is obviously $1$ , while $rWe$ need to consider the limit situation, that is, there is only one leftmost or rightmost valve that opens at the latest time point. Obviously, the time required at this time is $\times 10^9$ , soThe initial value of $r$ $\times 10^9$ 。

Time complexity: $O(n\log n^2)$ 。

3. AC_Code

#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;
        }
    }
}

Python

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)

The 14th Lanqiao Cup Provincial Competition Python Group B Question D - Pipeline (AC)

Table of contents