训练赛---土地改革

题目大意

A 村的土地十分狭长，可以把它看成一个数轴，每个人的土地可以看作数轴上的一段区间。A 村有 N 位村民，在解放之前，他们就已经有了属于自己的土地。第 i 位村民的土地为 (Ai,Bi)。

由于各种各样的历史问题，可能有一些土地被几位村民同时拥有，但是不会出现一位村民的土地被另一位村民完全包含的情况，也就是对于任意两个不同的 i 和 j, 不会存在 Ai ≤ Aj 且Bj ≤ Bi 的情况。

小 H 看到 A 村的土地分配十分不均匀而且存在交叉管理的现象，他想重新分配 A 村的土地，使得每位村民的土地长度都相等且任意两个农民的土地不相交。注意到由于村民们不想到不熟悉的地方去种田，因此每位村民新分配的土地必须是他原来土地的子区间。

为了让土地充分被利用, 小 H 想让重新分配后每位村民的土地长度尽可能大, 你能帮帮他吗？

输入格式

第一行一个整数 T, 代表数据组数。
对于每一组数据:
第一行一个整数 N，之后 N 行每行两个整数 Ai,Bi。

输出格式

对于每一组数据，输出一行最简分数 p/q 表示答案。

样例输入

2
3
2 6
1 4
8 12
2
0 3
1 4

样例输出

5/2
2/1

数据规模

对于 20% 的数据， N ≤ 10。
对于 40% 的数据， N ≤ 100。
对于 60% 的数据， N ≤ 1000。
对于 100% 的数据， 1 ≤ T ≤ 4; 1 ≤ N ≤ 100000; 0 ≤ Ai < Bi ≤ 10^9

评分方式

对于每个测试点:
如果输出的每一行与答案之间的相对误差都不超过 1e-6，能够获得 50% 的分数。
如果输出完全正确，能够获得 100% 的分数。
请注意输出的分子与分母都不要超过 10^18。

题解

按照题目的意思，如果我们把区间按左端点升序排序，那么右端点也必然是升序的。

首先最容易想到二分答案.
我们二分最后的长度x，只需要O(n)验证即可。
验证的时候利用贪心原则：在放得下的情况下，尽量靠左放(即尽量往坐标小的方向靠).
显然二分出来的答案只是一个近似值，只有50%的分数，如果要得到准确的最简分数，还需要用别的办法。

我们发现，在验证x是否成立的过程中，我们实际上是在验证这些等是是否成立(a为左端点，b为右端点):
a1+x≤b1
max(a1+x,a2)+x≤b2
max(max(a1+x,a2)+x,a3)+x≤b3
……
我们可以把max拆开：
a1+x≤b1
a2+x≤b2
a1+2x≤b2
a3+x≤b3
a2+2x≤b3
a1+3x≤b3
……
于是我们可以归纳得到，x是下列不等式组的最大解：

x≤bj−aij−i+1

此时用O(n^2)的算法求解，结合二分答案的算法，可以得到80分，已经很不错了。

我们可以再进行优化：
上面的式子，实际上是(j,bj)到(i−1,ai)的斜率.
显然这些最优的(j,b[j])是在一个下凸壳上的。我们可以维护这样的一个下凸壳，然后对于每一个(i-1,a[i])我们三分答案就可以找出最小的斜率。注意维护凸壳的顺序，应该是按照i从大到小依次加入。具体原因，画个图就可以看出来了。时间复杂度O(nlog n)。

代码

#include<cstdio>#include<cstring>#include<algorithm>using namespace std;#define MAXN 110000void _r(int& x){    char c=getchar();    while(c<'0'||c>'9')    {        c=getchar();    }    for(x=0;c>='0'&&c<='9';c=getchar())    {        x=(x<<1)+(x<<3)+c-'0';    }    return ;}struct node{    int x,y;    node(int _x=0,int _y=0)    {        x=_x;        y=_y;    }    bool operator < (const node& p) const    {        return x<p.x;    }}T[MAXN];int casenum,tt,n,P[MAXN];bool check(int c,int b,int a){    return 1ll*(T[c].y-T[b].y)*(b-a)<1ll*(c-b)*(T[b].y-T[a].y);}struct PQ{    int p,q;    PQ(int _p=0,int _q=0)    {        p=_p;        q=_q;    }    bool operator < (const PQ& x) const    {        return 1.0*p/(1.0*q)<1.0*x.p/(1.0*x.q);    }};PQ cal(int i){    int L=1,R=tt,M1,M2;    PQ a,b;    while(R-L>3)    {        M1=(L+R)>>1;        M2=(M1+R)>>1;        a=PQ(T[P[M1]].y-T[i].x,P[M1]-i+1);        b=PQ(T[P[M2]].y-T[i].x,P[M2]-i+1);        if(a<b)        {            R=M2;        }        else        {            L=M1;        }    }    a=PQ(T[P[L]].y-T[i].x,P[L]-i+1);    for(int j=L+1;j<=R;j++)    {        b=PQ(T[P[j]].y-T[i].x,P[j]-i+1);        if(b<a)        {            a=b;        }    }    return a;}int gcd(int x,int y){    int t;    while(y)    {        t=x;        x=y;        y=t%y;    }    return x;}void work(){    _r(n);    for(int i=1,x,y;i<=n;i++)    {        _r(x);        _r(y);        T[i]=node(x,y);    }    sort(T+1,T+1+n);    PQ ans,tmp;    ans.p=-1;    ans.q=1;    for(int i=n;i>=1;i--)    {        while(tt>1&&check(P[tt-1],P[tt],i))        {            --tt;        }        P[++tt]=i;        tmp=cal(i);        if(ans.p<0||tmp<ans)        {            ans=tmp;        }    }    int gg=gcd(ans.p,ans.q);    printf("%d/%d\n",ans.p/gg,ans.q/gg);    return ;}void clear(){    memset(T,0,sizeof(T));    memset(P,0,sizeof(P));    tt=0;    return ;}int main(){    //freopen("field.in","r",stdin);    //freopen("field.out","w",stdout);    _r(casenum);    for(;casenum;--casenum)    {        work();        clear();    }    return 0;}