poj 2976 Dropping tests (二分搜索之最大化平均值之01分数规划)

Description

In a certain course, you take n tests. If you get ai out of bi questions correct on test i, your cumulative average is defined to be   

.

.

Given your test scores and a positive integer k, determine how high you can make your cumulative average if you are allowed to drop any k of your test scores.

Suppose you take  tests with scores of /, /, and /. Without dropping any tests, your cumulative average is . However, if you drop the third test, your cumulative average becomes  

.

Input

The input test file will contain multiple test cases, each containing exactly three lines. The first line contains two integers,  ≤ n ≤  and  ≤ k < n. The second line contains nintegers indicating ai for all i. The third line contains n positive integers indicating bi for all i. It is guaranteed that  ≤ ai ≤ bi ≤ , , , . The end-of-file is marked by a test case with n = k =  and should not be processed.

Output

For each test case, write a single line with the highest cumulative average possible after dropping k of the given test scores. The average should be rounded to the nearest integer.

Sample Input

Sample Output

Hint

To avoid ambiguities due to rounding errors, the judge tests have been constructed so that all answers are at least 0.001 away from a decision boundary (i.e., you can assume that the average is never 83.4997).

Source

Stanford Local 2005

 

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<math.h>
 #include<stdlib.h>
 using namespace std;
 #define N 1006
 int n,k;
 double ratio;
 struct Node{
     double a,b;
     bool friend operator <(Node x,Node y){
         return x.a-ratio*x.b>y.a-ratio*y.b;
     }
 }node[N];
 bool solve(double mid){
     ratio=mid;
     sort(node,node+n);
     double sum1=;
     double sum2=;
     for(int i=;i<n-k;i++){
         sum1+=node[i].a;
         sum2+=node[i].b;
     }
     return sum1/sum2>=mid;
 }

 int main()
 {
     while(scanf("%d%d",&n,&k)== && n+k!=){
         for(int i=;i<n;i++){
             scanf("%lf",&node[i].a);
         }
         for(int i=;i<n;i++){
             scanf("%lf",&node[i].b);
         }
         double low=;
         double high=;
         for(int i=;i<;i++){
             double mid=(low+high)/;
             if(solve(mid)){
                 low=mid;
             }
             else{
                 high=mid;
             }
         }
         printf("%.0lf\n",high*);
     }
     return ;
 }

乍看以为贪心或dp能解决，后来发现贪心策略与当前的总体准确率有关，行不通，于是二分解决。

依然需要确定一个贪心策略，每次贪心地去掉那些对正确率贡献小的考试。如何确定某个考试[a_i, b_i]对总体准确率x的贡献呢？a_i / b_i肯定是不行的，不然例子里的[0,1]会首当其冲被刷掉。在当前准确率为x的情况下，这场考试“额外”对的题目数量是a_i – x * b_i，当然这个值有正有负，恰好可以作为“贡献度”的测量。于是利用这个给考试排个降序，后k个刷掉就行了。

之后就是二分搜索了，从0到1之间搜一遍，我下面的注释应该很详细，不啰嗦了。

 #ifndef ONLINE_JUDGE
 #pragma warning(disable : 4996)
 #endif
 #include <iostream>
 #include <algorithm>
 #include <cmath>
 #include <iomanip>
 using namespace std;

 #define MAX_N 1000
 int n, k;
 double x;    // 搜索过程中的正确率
 struct Test
 {
     int a, b;
     bool operator < (const Test& other) const
     {
         return a - x * b > other.a - x * other.b;    // 按照对准确率的贡献从大到小排序
     }
 };
 Test test[MAX_N];

 // 判断是否能够获得大于mid的准确率
 bool C(double mid)
 {
     x = mid;
     sort(test, test + n);
     double total_a = , total_b = ;
     for (int i = ; i < n - k; ++i)                    // 去掉后k个数计算准确率
     {
         total_a += test[i].a;
         total_b += test[i].b;
     }

     return total_a / total_b  > mid;
 }

 ///////////////////////////SubMain//////////////////////////////////
 int main(int argc, char *argv[])
 {
 #ifndef ONLINE_JUDGE
     freopen("in.txt", "r", stdin);
     freopen("out.txt", "w", stdout);
 #endif
     while (cin >> n >> k && (n || k))
     {
         for (int i = ; i < n; ++i)
         {
             cin >> test[i].a;
         }
         for (int i = ; i < n; ++i)
         {
             cin >> test[i].b;
         }

         double lb = ; double ub = ;
         while (abs(ub - lb) > 1e-)
         {
             double mid = (lb + ub) / ;
             if (C(mid))
             {
                 lb = mid;    // 行，说明mid太小
             }
             else
             {
                 ub = mid;    // 不行，说明mid太大
             }
         }

         cout << fixed << setprecision() << lb *  << endl;
     }
 #ifndef ONLINE_JUDGE
     fclose(stdin);
     fclose(stdout);
     system("out.txt");
 #endif
     return ;
 }
 ///////////////////////////End Sub//////////////////////////////////