蓝桥杯第十四届蓝桥杯省赛Python B组-管道题解

xrqqqqq

已于 2024-03-15 08:03:57 修改

阅读量1.7k

点赞数 35

文章标签：蓝桥杯开发语言 java eclipse

于 2024-03-14 23:46:05 首次发布

本文链接：https://blog.csdn.net/2301_79935713/article/details/136693826

版权

经典的二分+优化差分（map）/区间合并

题目描述

有一根长度为 len 的横向的管道，该管道按照单位长度分为 len 段，每一段的中央有一个可开关的阀门和一个检测水流的传感器。

一开始管道是空的，位于 Li 的阀门会在 Si 时刻打开，并不断让水流入管道。

对于位于 Li 的阀门，它流入的水在 Ti（Ti≥Si）时刻会使得从第 Li−(Ti−Si)段到第 Li+(Ti−Si) 段的传感器检测到水流。

求管道中每一段中间的传感器都检测到有水流的最早时间。

输入格式
输入的第一行包含两个整数 n,len，用一个空格分隔，分别表示会打开的阀门数和管道长度。

接下来 n 行每行包含两个整数 Li,Si，用一个空格分隔，表示位于第 Li段管道中央的阀门会在 Si 时刻打开。

输出格式
输出一行包含一个整数表示答案。

数据范围
对于 30%的评测用例，n≤200，Si,len≤3000；
对于 70%的评测用例，n≤5000，Si,len≤1e5；
对于所有评测用例，1≤n≤1e5，1≤Si,len≤1e9，1≤Li≤len，Li−1<Li。

样例

in:
3 10
1 1
6 5
10 2

out:
5

算法

随着时间的推移，区间的覆盖会越大，
也就是说二分时间，取能完全覆盖整段区间的最小时间。

check内容:
对mid时间，进行区间是否完全覆盖判断，无法完全覆盖返回false,反之返回true.
算法一：区间合并
1存已知覆盖区间的左右端点
2以覆盖区间左端排序
3建两个变量，s = -1 为起点，e = -1,为终点，遍历有序的覆盖区间，更新s,e
4返回s == 1&& e == len;

算法二：优化差分 
易知区间长度过长。不能通过数组方式一个一个累加，
应用map存下改变的端点
以端点的加和是否小于0来判断

算法一：区间合并

时间复杂度

$O m l o g n l o g m$

java 代码



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.Scanner;

public class Main {
	static final int  N  = (int)1e5+5;
	static int len;
	static long l,r;
	static int n;
	static int a[] = new int [N];
	static int t[] = new int [N];
	static int b[] = new int [N];

	public static void main(String args[]) throws IOException {
		StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		n = (int)in.nval;
		in.nextToken();
		len = (int)in.nval;
		for(int i = 0 ; i < n; ++i) {
			in.nextToken();
			a[i] = (int)in.nval;
			in.nextToken();
			t[i] = (int)in.nval;
		}
		l = 0;
		r = (long)2e9;
		while(l<r) {
			
			long mid = (l+r)/2; 
	
			
			if(check(mid)) r = mid;
			else {
				
				l = mid +1;
			}

		}
		
		out.print(l);
		out.flush();
	}
	static boolean check(long m) {
		A p[] = new A[n];
		int count = 0;
		for(int i = 0 ; i < n ;  ++i) {
			if(m>=t[i]) {
				int l = (int)Math.max(1, a[i]-m+t[i]);
				int r = (int)Math.min(len, a[i]+m-t[i]);
				p[count++] = new A(l,r);
			}
		}
		Arrays.sort(p,0,count);
		// (a, b) -> { return a.l-b.l;});
		
		int s = -1,e = -1;
		for(int i = 0 ; i  <  count ; ++i) {
			if(p[i].l<=e+1) e = Math.max(e, p[i].r);
			else {
			
				s = p[i].l;
				e = p[i].r;
			}
		}
	
		return s==1&&e ==len;
	}

}
class A implements Comparable<A> {
    int l, r;

    A(int a, int b) {
        l = a;
        r = b;
    }

    @Override
    public int compareTo(A o) {
        return this.l - o.l;
    }
}

算法二：优化差分

时间复杂度

$O m l o g n l o g m$

java 代码



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;
import java.util.Scanner;
import java.util.TreeMap;

public class Main {
	static final int N = (int) 1e5 + 5;
	static int len;
	static long l, r;
	static int n;
	static int a[] = new int[N];
	static int t[] = new int[N];
	static int b[] = new int[N];

	public static void main(String args[]) throws IOException {
		StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
		in.nextToken();
		n = (int) in.nval;
		in.nextToken();
		len = (int) in.nval;
		for (int i = 0; i < n; ++i) {
			in.nextToken();
			a[i] = (int) in.nval;
			in.nextToken();
			t[i] = (int) in.nval;
		}
		l = 0;
		r = (long) 1e11;
		while (l < r) {

			long mid = (l + r) / 2;

			if (check(mid))
				r = mid;
			else {

				l = mid + 1;
			}

		}

		out.print(l);
		out.flush();
	}

	static boolean check(long m) {
		TreeMap<Integer, Integer> M = new TreeMap<>();// 有序map
		M.put(1,0);//保证M是非空（时间都不大于t时，可以返回false）;
		for (int i = 0; i < n; ++i) {
			if (m >= t[i]) {
				int l = (int) Math.max(1, a[i] - m + t[i]);
				int r = (int) Math.min(len, a[i] + m - t[i]);
				if (M.get(l) == null)
					M.put(l, 1);
				else
					M.put(l, M.get(l) + 1);
				if (M.get(r + 1) == null)
					M.put(r + 1, -1);
				else
					M.put(r + 1, M.get(r + 1) - 1);
			}
		}
		int ans = 0;	
		for (int k : M.keySet()) {
			ans+=M.get(k);
			if (k <= len && ans <= 0)
				return false;
		}
		return true;
	}

}