【BZOJ 1701】Cow School（斜率优化/动态凸包/分治优化）

最新推荐文章于 2019-07-08 12:49:00 发布

dingguayi7025

最新推荐文章于 2019-07-08 12:49:00 发布

阅读量153

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/flipped/p/7724079.html

版权

原题题解和数据下载 Usaco2007 Jan

题意

小牛参加了n个测试，第i个测试满分是$p_i$,它的得分是$t_i$。老师去掉$t_i/p_i$最小的d个测试，将剩下的总得分/总满分作为小牛的得分。

小牛想知道多少个d存在比老师计算的分数更高的选择测试的方案，并输出这些d。

题解

基础思路

排好序后，$ \frac {t_1} {p_1} < \frac {t_2} {p_2}<..< \frac {t_n} {p_n}$。

如果d==j，老师给的分数是$r_j=\frac {t_{j+1}+t_{j+2}+..t_{n}} {p_{j+1}+p_{j+2}+..p_{n}}=\frac{st_j}{sp_j}$。

要找的就是是否存在一个集合$S(|S|=n-j)$，满足：
\[ \frac {\sum_{i\in S}t_i} {\sum_{i\in S}p_i}>r_j \]
等价于$\sum_{i\in S}t_i- {\sum_{i\in S}p_i} \cdot r_j>0$。也就是：
\[ \sum_{i\in S}(t_i-p_i \cdot r_j)>0 \Rightarrow \sum_{i\in S}t_i\cdot sp_j-p_i\cdot st_j>0 \]
贪心地找最大的 n-j 个加起来，复杂度是$O(n^2\log n)$。

法1 平衡树维护动态凸包

一个优化的方法是，考虑$z=t_i\cdot sp_j-p_i\cdot st_j$在$1..j$里最大值$g[j]$ 和$j+1..n$里的最小值$f[j]$。

如果$f[j]$ 小于$g[j]$，那么意味着从$j+1..n$中取出最小值换为$1..j$中的最大值，可以更优。

$g[j]=\max\{a_j\cdot x_i+b_j\cdot y_i\}$实际上就是斜率优化的形式。

这里$x_i=p_i,y_i=t_i,a_j=-st_j,b_j=sp_j$。

直线为$y=st_j/sp_j\cdot x+z/sp_j$。

所以每个点坐标为$(p_i,t_i)$，要找一个点，斜率为$-a_j/b_j$的直线经过它时，纵截距最大。需要维护一个上凸壳。x不是单调的，需要用平衡树来维护这个凸壳。

$f[j]$同理求。总复杂度$O(n\log n)$。

法2 普通维护凸包

实际上还可以更优。

求$g[j]$时加入上凸壳的点$(p_j,t_j)$和原点连线的斜率$t_j/p_j$，一定比之前加入的任意点$(p_{j'},t_{j'})$的要大，于是新点一定可以保留在凸壳上。直线斜率$st_j/sp_j$一定比$t_j/p_j$大。于是当前点右边的点就没有用了。因为直线斜率递增，所以最优解的位置递减。

求$f[j]$时加入下凸壳的点$(p_j,t_j)$和原点连线的斜率$t_j/p_j$，一定比之前加入的任意点$(p_{j'},t_{j'})$的要小，于是新点一定可以保留在凸壳上。直线斜率$st_j/sp_j$一定比$t_j/p_j$大。于是当前点左边的点就没有用了。因为直线斜率递增，所以最优解的位置递增。

于是只要用$Graham$算法维护凸壳即可。点排序后复杂度是$O(n)$。

法3 分治dp

由于决策单调，计算$f[j],g[j]$时还可以分治计算。

代码

//平衡树动态维护凸包
#include <bits/stdc++.h>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))
#define rep(i,l,r) for(int i=l,_=r;i<_;++i)
#define per(i,l,r) for(int i=r-1,_=l;i>=_;--i)
typedef long long ll;
typedef double dd;
const int INF=0x3f3f3f3f;
const int N=50100;

struct nd{
    ll t,p;
    bool operator < (const nd&b)const{
        return t*b.p<p*b.t;
    }
}a[N];

struct DynmcCnvx{
    int rot,fa[N],c[N][2];
    dd lk[N],rk[N],x[N],y[N];
    void zigzag(int x,int &rot){
        int y=fa[x],z=fa[y];
        int p=(c[y][1]==x),q=p^1;
        if (y==rot) rot=x;
        else if (c[z][0]==y) c[z][0]=x; 
        else c[z][1]=x;
        fa[x]=z; fa[y]=x; fa[c[x][q]]=y;
        c[y][p]=c[x][q]; c[x][q]=y; 
    }
    void splay(int x,int &rot){
        while (x!=rot){
            int y=fa[x],z=fa[y];
            if (y!=rot) zigzag(((c[y][0]==x)^(c[z][0]==y))?x:y,rot);
            zigzag(x,rot);
        }
    }
    void insert(int &t,int anc,int now){//加入平衡树
        if (!t) t=now, fa[t]=anc;
        else insert(c[t][x[now]>x[t]],t,now);
    }
    void update(int t){//加入点(x[t],y[t])，维护上凸壳。
        splay(t,rot);
        if (c[t][0]){//向左求凸包
            int left=prev(rot);
            splay(left,c[rot][0]); c[left][1]=0;
            lk[t]=rk[left]=getk(left,t);
        }
        else lk[t]=INF;
        if (c[t][1]){//向右求凸包
            int right=succ(rot);
            splay(right,c[rot][1]); c[right][0]=0;
            rk[t]=lk[right]=getk(t,right);
        }
        else rk[t]=-INF;
        if (lk[t]<=rk[t]){//在原凸包内部的情况，直接删掉该点 
            rot=c[t][0]; c[rot][1]=c[t][1]; fa[c[t][1]]=rot; fa[rot]=0;
            lk[rot]=rk[c[t][1]]=getk(rot,c[t][1]);
        }
    }
    dd getk(int i,int j){//求斜率
        if (x[i]==x[j]) return -INF;
        return (y[j]-y[i])/(x[j]-x[i]);
    }
    int prev(int rot){//求可以和当前点组成凸包的右边第一个点
        int t=c[rot][0],tmp=t;
        while (t){
            if (getk(t,rot)<=lk[t]) tmp=t,t=c[t][1];
            else t=c[t][0];
        }
        return tmp;
    }
    int succ(int rot){//求可以和当前点组成凸包的左边第一个点
        int t=c[rot][1],tmp=t;
        while (t){
            if (getk(rot,t)>=rk[t]) tmp=t,t=c[t][0];
            else t=c[t][1];
        }
        return tmp;
    }
    int find(int t,dd k){//找到当前斜率的位置，即找到最优值
        if (!t) return 0;
        if (lk[t]>=k && k>=rk[t]) return t;
        return find(c[t][lk[t]>=k],k);
    }
  
    void Init(){
        rot=0;mem(fa,0);mem(c,0);
    }
    dd GetMax(dd a,dd b){//max{ax+by}
        int j=find(rot,-a/b);
        return a*x[j]+b*y[j];
    }
    void InsertPoint(int i,dd _x,dd _y){//插入点(x,y)
        x[i]=_x,y[i]=_y;
        insert(rot,0,i);
        update(i);
    }
}s;

dd st,sp;
dd f[N],g[N];
int ans[N],cnt;
int n;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n;
    rep(i,1,n+1)
        cin>>a[i].t>>a[i].p;
    sort(a+1,a+n+1);
    per(i,1,n+1){
        s.InsertPoint(i,-a[i].p,-a[i].t);
        f[i-1]=-s.GetMax(-(st+=a[i].t),sp+=a[i].p);
    }
    s.Init();
    rep(i,1,n){
        s.InsertPoint(i,a[i].p,a[i].t);
        g[i]=s.GetMax(-(st-=a[i].t),sp-=a[i].p);
        if(g[i]>f[i]) ans[cnt++]=i;
    }
    cout<<cnt<<endl;
    rep(i,0,cnt)cout<<ans[i]<<endl;
    return 0;
}

//直接维护凸包
#include <bits/stdc++.h>
using namespace std;
#define rep(i,l,r) for(int i=l,_=r;i<_;++i)
#define per(i,l,r) for(int i=r-1,_=l;i>=_;--i)
typedef long long ll;
const int N=50100;

struct nd{
    ll t,p;
    bool operator < (const nd&b)const{
        return t*b.p<p*b.t;
    }
}a[N];

struct Po{
    ll x,y;
    Po(ll x=0,ll y=0):x(x),y(y){}
    Po operator -(const Po&b)const {return Po(x-b.x,y-b.y);}
    Po operator +(const Po&b)const {return Po(x+b.x,y+b.y);}
    ll operator ^(const Po&b)const {return x*b.y-y*b.x;}
    ll operator *(const Po&b)const {return x*b.x+y*b.y;}
}p[N];
ll xmul(const Po&a,const Po&b,const Po&o){
    return (a-o)^(b-o);
}

struct DownCnvx{
    Po q[N];int top;
    //顺时针方向维护下凸壳
    void Insert(Po p){
        while(top && q[top].x<=p.x) --top;
        while(top>1 && xmul(q[top],p,q[top-1])>=0)--top;
        q[++top]=p;
    }
    ll GetMin(Po p){
        while(top>1 && p*q[top]>=p*q[top-1])--top;
        return q[top]*p;
    }
}d;

struct UpCnvx{
    Po q[N];int top;
    //顺时针方向维护上凸壳
    void Insert(Po p){
        while(top && q[top].x>=p.x) --top;
        while(top>1 && xmul(q[top],p,q[top-1])>=0)--top;
        q[++top]=p;
    }
    ll GetMax(Po p){
        while(top>1 && p*q[top]<=p*q[top-1])--top;
        return q[top]*p;
    }
}u;

ll st,sp;
ll f[N],g[N];
int cnt,ans[N];
int n;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n;
    rep(i,1,n+1)
        cin>>a[i].t>>a[i].p;
    sort(a+1,a+n+1);
    per(i,1,n+1){
        d.Insert(Po(a[i].p,a[i].t));
        f[i-1]=d.GetMin(Po(-(st+=a[i].t),sp+=a[i].p));
    }
    rep(i,1,n+1){
        u.Insert(Po(a[i].p,a[i].t));
        g[i]=u.GetMax(Po(-(st-=a[i].t),sp-=a[i].p));
        if(g[i]>f[i]) ans[cnt++]=i;
    }
    cout<<cnt<<endl;
    rep(i,0,cnt)cout<<ans[i]<<endl;
    return 0;
}

//分治优化
#include <bits/stdc++.h>
using namespace std;
#define rep(i,l,r) for(int i=l,_=r;i<_;++i)
#define per(i,l,r) for(int i=r-1,_=l;i>=_;--i)
typedef long long ll;
const ll LINF=0x3f3f3f3f3f3f3f3f;
const int N=50100;

struct nd{
    ll t,p;
    bool operator < (const nd&b)const{
        return t*b.p<p*b.t;
    }
}a[N];

ll st[N],sp[N];
ll f[N],g[N];
int cnt,ans[N];
int n;
void solveMax(int l,int r,int optL,int optR){
    if(l>r)return;
    int j=l+r>>1,u=optL;
    rep(i,optL,min(optR,j)+1){
        ll tmp=sp[j]*a[i].t-st[j]*a[i].p;
        if(tmp>g[j])g[j]=tmp,u=i;
    }
    solveMax(l, j-1, optL, u);
    solveMax(j+1, r, u, optR);
}
void solveMin(int l,int r,int optL,int optR){
    if(l>r)return;
    int j=l+r>>1,u=optL;
    rep(i,max(optL,j+1),optR+1){
        ll tmp=sp[j]*a[i].t-st[j]*a[i].p;
        if(tmp<f[j])f[j]=tmp,u=i;
    }
    solveMin(l, j-1, optL, u);
    solveMin(j+1, r, u, optR);
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n;
    rep(i,1,n+1)
        cin>>a[i].t>>a[i].p;
    sort(a+1,a+n+1);
    per(i,1,n+1){
        st[i-1]=st[i]+a[i].t;sp[i-1]=sp[i]+a[i].p;
        f[i]=LINF;g[i]=-LINF;
    }
    solveMax(1,n,1,n);
    solveMin(1,n,1,n);
    rep(i,1,n)
        if(f[i]<g[i])ans[cnt++]=i;
    cout<<cnt<<endl;
    rep(i,0,cnt)cout<<ans[i]<<endl;
    return 0;
}

转载于:https://www.cnblogs.com/flipped/p/7724079.html

dingguayi7025

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【BZOJ 1701】Cow School（斜率优化/动态凸包/分治优化）

原题题解和数据下载 Usaco2007 Jan题意小牛参加了n个测试，第i个测试满分是$p_i$,它的得分是$t_i$。老师去掉$t_i/p_i$最小的d个测试，将剩下的总得分/总满分作为小牛的得分。小牛想知道多少个d存在比老师计算的分数更高的选择测试的方案，并输出这些d。题解基础思路排好序后，$ \frac {t_1} {p_1} < \frac {t_2...
复制链接

扫一扫