Java实现蓝桥杯历届试题区间移位

问题描述

　　数轴上有n个闭区间D1,…,Dn。其中区间Di用一对整数[ai, bi]来描述，满足ai < bi。已知这些区间的长度之和至少有10000。所以，通过适当的移动这些区间，你总可以使得他们的“并”覆盖[0, 10000]——也就是说[0, 10000]这个区间内的每一个点都落于至少一个区间内。

　　你希望找一个移动方法，使得位移差最大的那个区间的位移量最小。

　　具体来说，假设你将Di移动到[ai+ci, bi+ci]这个位置。你希望使得maxi |ci|　　最小。

输入格式

　　输入的第一行包含一个整数n，表示区间的数量。

　　接下来有n行，每行2个整数ai,　　bi，以一个空格分开，表示区间[ai, bi]。保证区间的长度之和至少是10000。

输出格式

　　输出一个数，表示答案。如果答案是整数，只输出整数部分。如果答案不是整数，输出时四舍五入保留一位小数。

样例输入

2

10 5010

4980 9980

样例输出

20

样例说明

　　第一个区间往左移动10；第二个区间往右移动20。

样例输入

4

0 4000

3000 5000

5001 8000

7000 10000

样例输出

0.5

样例说明

　　第2个区间往右移0.5；第3个区间往左移0.5即可。

数据规模和约定

　　对于30%的评测用例，1 ≤ n ≤ 10；

　　对于100%的评测用例，1 ≤ n ≤ 10000，0 ≤ ai < bi　　≤ 10000。

解法一：

解析：

刚开始想着按区间的左端点排序，二分答案之后依次枚举，使得区间尽量向右就行了，但是写出来只有80分。

想了想发现，选取最左面的区间并不是最优的，比如[1000,2000]和[1200,1300]两个区间当我们的now（当前覆盖的最右端点 ）是900，二分的答案是300，我们选取第一个区间先向左靠，这是now=1900，此时第二个区间就无法派上用场，但是如果先选取第二个区间再选取第一个区间，now就会变成2300.

所以我们得出的结论是在做区间可以到达now的情况下，选取右端点最小的区间。

做法：

先将每个区间按照右端点从小到大排序，

每个区间活动范围是[l-x,r+x]

二分答案之后再二分出满足r+x>=now的右端点最小的区间，然后从这个区间开始依次枚举找到第一个满足l-x<=now的区间，使得区间覆盖now的同时向右靠即可

另外值得一提的是小数只能是0.5，因为刚开始区间都是整数，如果一个区间唯一0.4，那么另一个就是0.6，大于0.5.所以为了方便处理，把区间值乘2，最后再除2即可

import java.io.*;
import java.util.*;

class S implements Comparable<S>
{
	int l;
	int r;
	public S(int l,int r) {
		this.l=l;
		this.r=r;
	}
	@Override
	public int compareTo(S o) {
		// TODO Auto-generated method stub
		if(this.r!=o.r)
			return (int) (this.r-o.r);
		else {
			return (int) (this.l-o.l);
		}
	}
}

public class Main {
	static int N=20000;
	static S[]s=new S[10100];
	static int []vis=new int [10100];
	static int n;
	public static void main(String[] args) throws IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int now =0;
		String str=br.readLine();
		for(int i=0;i<str.length();i++) {
			now=now*10+(int)(str.charAt(i)-'0');
		}
		n=now;
		int sum=0;

		for(int i=0;i<n;i++) {
			now=0;
			str=br.readLine();
			int a = 0,b;
			for(int j=0;j<str.length();j++) {
				if(str.charAt(j)==' ') {
					a=now;
					now=0;
				}
				else {
					now=now*10+(int)(str.charAt(j)-'0');
				}
			}
			b=now;
			sum+=b-a;
			s[i]=new S(a*2,b*2);
		}
		Arrays.sort(s,0,n);
		int l=0,r=N;
		while(l<=r) {
			int mid=(l+r)/2;
			//System.out.println(mid);
			if(check(mid)==true) {
				r=mid-1;
			}
			else {
				l=mid+1;
			}
		}
		if(l%2==0) {
			System.out.println(l/2);
		}
		else
			System.out.println(((double)(l)*1.0)/2.0);
	}
	static boolean check(int x) {
		int now=0;
		for(int i=0;i<10100;i++) {
			vis[i]=0;
		}
		while(true)
		{
			int flag=0;

			int l=0,r=n;
			while(l<=r) {
				int mid=(l+r)/2;
				if(s[mid].r+x>=now) {
					r=mid-1;
				}
				else l=mid+1;
			}
			for(int i=l;i<n;i++) {
				if(s[i].l<=x+now&&vis[i]==0) {
					flag=1;
					vis[i]=1;
					if(now<=s[i].l+x) now+=s[i].r-s[i].l;
					else now =s[i].r+x;
					break;
				}
			}
			if(now>=20000) return true;
			if(flag==0) return false;
		}

	}

}

解法二：

题解:

首先,maxi |ci|最小,求解这种最大值最小的问题应该想到用二分答案试一试.答案呈现一种单调性,比如第一个样例中答案是20,20是以下的数都不满足要求(就是无论怎么移动都无法覆盖所有的点),所以我们把答案的区间分成0—10000进行二分,0–19的结果都无法满足.19–10000都可以满足,而20就是那个临界点,也是要求解的答案.

二分答案模板:

        int left = 0, r = 20000;
        while (left < r) {
            int mid = (left + r) >> 1;
            if (ok(mid)) {
                r = mid;
            } else {
                left = mid + 1;
            }
        }

上面说了答案是0–10000,那为什么这里是0–20000呢.因为题目中可能出现0.5这种结果,而我们二分的区间每次是1增加,1,2,3,4…10000,那怎么才能将0.5这种结果也算上呢.那我们就将区间扩大2倍,从0–20000,这样虽然每次还是递增1,求解出答案后再/2就是最后结果.比如第二个样例,求解出的结果是1,然后我们/2 == 0.5

最后,重点就放在了这个ok()函数上面,先来看下代码:

    static boolean ok(int mid) {
        ArrayList<E> tem = (ArrayList<E>) list.clone();
        int k = 0;//表示到底能不能包括整个区间 0 -- 20000
        while (true) {
            boolean flag = false;
            for (int i = 0; i < tem.size(); i++) {
                int s = tem.get(i).s;
                int end = tem.get(i).end;
                if (s - mid <= k && end + mid >= k) {
                    int len = end - s;
                    if (s + mid >= k) {
                        k += len;
                    } else {
                        k = end + mid;
                    }
                    tem.remove(i);
                    flag = true;
                    break;
                }
            }
            if (!flag || k >= 20000) break;
        }
        return k >= 20000;
    }

mid代表的是二分答案的结果,看这个结果到底满足要求吗.所以每一个mid代表每个区间可以移动的距离,区间可以向左移动,也可以向右移动,那么区间就可以移动成 [left-mid,r-mid] 或 [left + mid,r + mid].第一行tem集合用来存放所有的区间E(E是自己写的类,2个属性left和r,分别代表左端点和右端点),k 表示区间现在覆盖到哪里了,从0开始.

		if (s - mid <= k && end + mid >= k) 

s - mid 表示区间向左移动,移动后看左端点是否能在k的后面,如果不能:那么说明这个区间无论向左都无法覆盖k,所以这个区间不满足. end + mid表示区间向右移动,和上面同理:如果不大于K表示这个区间也不满足条件,因为无论向右如何移动都无法到达k

	if (s + mid >= k)

既然满足上面的条件,那么区间就可以向左移动或向右移动来进行覆盖.

s + mid >= k，那么k可以移动得最大距离就 len = end -mid,这个区间得左端点直接移动到k，所以最终k = k +len

s + mid < k,那么这个区间左端点向右移动都在k后面，所以k最终变成k = end + mid.

上面的情况都是向右移动,下面的情况是向左移动,道理都一样

s + mid >= k,如果是左端点向左移动到k,k最终还是= k + len(向左移动不存在s + mid < k 这种情况)

                  tem.remove(i);
                    flag = true;
                    break;

每次找到一个区间都把区间从tem中删除,然后终端for循环,从头又继续寻找区间.

完整代码

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
    static int n;
    static ArrayList<E> list = new ArrayList<E>();

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            list.add(new E(sc.nextInt() * 2, sc.nextInt() * 2));
        }
        Collections.sort(list);
        int left = 0, r = 20000;
        while (left < r) {
            int mid = (left + r) >> 1;
            if (ok(mid)) {
                r = mid;
            } else {
                left = mid + 1;
            }
        }
        if (left % 2 == 0) {
            System.out.println(left / 2);
        } else {
            System.out.println(left * 1.0 / 2);
        }
    }

    static boolean ok(int mid) {
        ArrayList<E> tem = (ArrayList<E>) list.clone();
        int k = 0;//表示到底能不能包括整个区间 0 -- 20000
        while (true) {
            boolean flag = false;
            for (int i = 0; i < tem.size(); i++) {
                int s = tem.get(i).s;
                int end = tem.get(i).end;
                if (s - mid <= k && end + mid >= k) {
                    int len = end - s;
                    if (s + mid >= k) {
                        k += len;
                    } else {
                        k = end + mid;
                    }
                    tem.remove(i);
                    flag = true;
                    break;
                }
            }
            if (!flag || k >= 20000) break;
        }
        return k >= 20000;
    }

}

class E implements Comparable<E> {
    int s, end;

    public E(int s, int end) {
        this.s = s;
        this.end = end;
    }
    public int compareTo(E o) {  //按照右端点进行排序,小的在前面,大的在后面.
        if (end != o.end)
            return end > o.end ? 1 : -1;
        else
            return s < o.s ? -1 : 1;
    }
}