[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^'';
     while(isdigit(ch=getchar())) x=(((x<<)+x)<<)+(ch^'');
     return x;
 }
 const int N=;
 const double eps=1e-,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=;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 ;
         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=;
     for(register int i=;i<=n;i++) {
         if(node[i].a*k-node[i].w<) continue;
         if(node[i].l-<=last) last=std::max(last,node[i].r);
     }
     if(last>=m) return true;
     double sum=;
     t.modify(last,);
     for(register int i=;i<=n;i++) {
         if(node[i].a*k-node[i].w<) {
             t.modify(node[i].r,t.query(node[i].l-)+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-));
         }
     }
     return sum+t.query(m)>=;
 }
 int main() {
     for(register int T=getint();T;T--) {
         n=getint(),m=getint();
         int sumw=,suma=;
         for(register int i=;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[],&node[n+]);
         double l=,r=sumw*./suma;
         while(r-l>=eps) {
             const double mid=(l+r)/;
             (check(mid)?r:l)=mid;
         }
         printf("%.3f\n",r);
     }
     return ;
 }