训练赛---土地改革

最新推荐文章于 2025-01-20 14:51:04 发布

lym01803

最新推荐文章于 2025-01-20 14:51:04 发布

阅读量481

点赞数 2

CC 4.0 BY-SA版权

分类专栏：题解文章标签：贪心二分答案斜率优化凸包区间问题

本文链接：https://blog.youkuaiyun.com/lym01803/article/details/73656295

题解专栏收录该内容

31 篇文章

订阅专栏

题目大意

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为右端点):
$a_1+x\leq b_1$
$max(a_1+x,a_2)+x\leq b_2$
$max(max(a_1+x,a_2)+x,a3)+x\leq b_3$
……
我们可以把max拆开：
$a_1+x\leq b_1$
$a_2+x\leq b_2$
$a_1+2x\leq b_2$
$a_3+x\leq b_3$
$a_2+2x\leq b_3$
$a_1+3x\leq b_3$
……
于是我们可以归纳得到，x是下列不等式组的最大解：

x \leq b j - a i j - i + 1

$x\leq \frac{b_j-a_i}{j-i+1}$
此时用O(n^2)的算法求解，结合二分答案的算法，可以得到80分，已经很不错了。

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

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAXN 110000
void _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;
}