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 3 tests with scores of 5/5, 0/1, and 2/6. 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, 1 ≤ n ≤ 1000 and 0 ≤ 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 0 ≤ ai ≤ bi ≤ 1, 000, 000, 000. The end-of-file is marked by a test case with n = k = 0 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

3 1
5 0 2
5 1 6
4 2
1 2 7 9
5 6 7 9
0 0

Sample Output

83
100

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=0;
    double sum2=0;
    for(int i=0;i<n-k;i++){
        sum1+=node[i].a;
        sum2+=node[i].b;
    }
    return sum1/sum2>=mid;
}

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

乍看以为贪心或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 = 0, total_b = 0;
    for (int i = 0; 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 = 0; i < n; ++i)
        {
            cin >> test[i].a;
        }
        for (int i = 0; i < n; ++i)
        {
            cin >> test[i].b;
        }
 
        double lb = 0; double ub = 1;
        while (abs(ub - lb) > 1e-4)
        {
            double mid = (lb + ub) / 2;
            if (C(mid))
            {
                lb = mid;    // 行，说明mid太小
            }
            else
            {
                ub = mid;    // 不行，说明mid太大
            }
        }
 
        cout << fixed << setprecision(0) << lb * 100 << endl;
    }
#ifndef ONLINE_JUDGE
    fclose(stdin);
    fclose(stdout);
    system("out.txt");
#endif
    return 0;
}
///////////////////////////End Sub//////////////////////////////////