[HDU6240]Server

题目大意：
　　用$n$条线段覆盖区间$[1,t]$上的整点。每条线段有4个属性$(S_i,T_i,A_i,B_i)$，表示用第$i$条线段可以覆盖区间$[S_i,T_i]$。若选取线段的集合为$S$，最后总代价为$\frac{\sum_{i\in S}A_i}{\sum_{i\in S}B_i}$。问区间$[1,t]$全部覆盖时，最小代价为多少？

思路：
　　分数规划经典模型。
　　二分答案$k$，表示代价为$k$。若$k$为可行的，则我代价们需要找到一个合法的$S$，满足$\frac{\sum_{i\in S}A_i}{\sum_{i\in S}B_i}\leq k$。移项得$\sum_{i\in S}(A_ik-B_i)\geq 0$。
　　可以将所有线段按照左端点排序，然后考虑每个线段对答案的贡献。
　　若$A_ik-B_i\geq 0$，则选了这个线段肯定能够让答案尽可能大于$0$，因此把它选上。
　　如果把所有$A_ik-B_i\geq 0$的线段选上后能够覆盖完整个区间，那么$k$为可行的代价。
　　如果不能覆盖完，那么我们要考虑选上一些$A_ik-B_i<0$的线段，使得代价增加最少的情况下，能把区间覆盖完。
　　若用$sum$表示必选线段$A_ik-B_i$的和，$f_i$表示覆盖完$i$点后，$sum$要减少的值。那么对于必选线段$i$，$f_{r_i}=\min\{f_j\mid S_i\leq j\leq t\}$（选了以后并不会影响$sum$），对于其它线段，$f_{r_i}=\min\{f_j|S_i\leq j\leq t\}+B_i-A_ik$。由于$f_{r_i}$，可能会被计算多次，因此取最小值即可。转移的时候相当于后缀最小值，显然可以使用树状数组优化。最后只需要判断$sum-f_t\geq 0$即可。

#include<cstdio>
#include<cctype>
#include<algorithm>
inline int getint() {
    register char ch;
    while(!isdigit(ch=getchar()));
    register int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int N=100001;
const double eps=1e-5,inf=1e10;
struct Node {
    int l,r,w,a;
    bool operator < (const Node &another) const {
        return l<another.l||(l==another.l&&r<another.r);
    }
};
Node node[N];
int n,m;
struct SuffixFenwickTree {
    double val[N];
    int lowbit(const int &x) const {
        return x&-x;
    }
    void reset() {
        for(register int i=1;i<=m;i++) {
            val[i]=-inf;
        }
    }
    void modify(int p,const double &x) {
        while(p) {
            val[p]=std::max(val[p],x);
            p-=lowbit(p);
        }
    }
    double query(int p) const {
        if(!p) return 0;
        double ret=-inf;
        while(p<=m) {
            ret=std::max(ret,val[p]);
            p+=lowbit(p);
        }
        return ret;
    }
};
SuffixFenwickTree t;
inline bool check(const double &k) {
    t.reset();
    int last=0;
    for(register int i=1;i<=n;i++) {
        if(node[i].a*k-node[i].w<0) continue;
        if(node[i].l-1<=last) last=std::max(last,node[i].r);
    }
    if(last>=m) return true;
    double sum=0;
    t.modify(last,0);
    for(register int i=1;i<=n;i++) {
        if(node[i].a*k-node[i].w<0) {
            t.modify(node[i].r,t.query(node[i].l-1)+node[i].a*k-node[i].w);
        } else {
            sum+=node[i].a*k-node[i].w;
            t.modify(node[i].r,t.query(node[i].l-1));
        }
    }
    return sum+t.query(m)>=0;
}
int main() {
    for(register int T=getint();T;T--) {
        n=getint(),m=getint();
        int sumw=0,suma=0;
        for(register int i=1;i<=n;i++) {
            const int l=getint(),r=getint(),w=getint(),a=getint();
            sumw+=w,suma+=a;
            node[i]=(Node){l,r,w,a};
        }
        std::sort(&node[1],&node[n+1]);
        double l=0,r=sumw*1./suma;
        while(r-l>=eps) {
            const double mid=(l+r)/2;
            (check(mid)?r:l)=mid;
        }
        printf("%.3f\n",r);
    }
    return 0;
}