HDU 4406 GPA

GPA

Time Limit: 1000ms

Memory Limit: 32768KB

This problem will be judged on HDU. Original ID: 4406
64-bit integer IO format: %I64d      Java class name: Main

 

GPA(Grade-Point Average) is one way to measure students’ academic performance in PKU. Each course has an integer credit, ranges from 1 to 99. For each course, you will get a score at the end of the semester, which is an integer ranges from 0 to 100. Then you can calculate the Grade-Point of this course with the following formula. (Your score is x and your Grade-Point is p, using real arithmetic)

Then you can get the GPA with the following formula (the Grade-Point of course i is pi, and the credit of course i is wi).

Now it is not far from the final exam, if you do not review, you can only get a basic score in each course.

You have n days to review. There are K classes in each day. For each class, only one course can be reviewed. After the review, your score in this course will exactly increase by 1. You can get more increment by spending more classes in this course. But the score may not exceed 100.

For some reasons, not any course can be reviewed in any class. Each day you can only review some of the courses.

Now you want your GPA to be as high as possible, and at the same time, you do not want to fail in any course. Please calculate the highest GPA you can get.

 

Input

The input consists of several test cases. Each test case begins with 3 integers N (0<=N<=40), K(0<K<=20), M (0<M<=20), representing the number of days, the number of classes in each day and the number of courses. Next line contains M integers representing credits of each course and M integers representing basic scores of each course (0<=score<=100). Next N lines contain an N*M matrix, the jth element in ith row means whether you can review course j in ith day, 1 means you can review course j in ith day, 0 means you cannot. The Input ends with 0 0 0.

 

Output

For each test case, output the highest possible GPA, round to 6 digits after decimal point. If you have to fail a course, output 0.000000 instead.

 

Sample Input

2 10 3
1 1 2
50 60 90
1 1 0
1 0 1
2 20 4
1 1 1 1
50 50 50 40
1 1 1 0
0 0 0 1
0 0 0

Sample Output

2.757813
0.000000

Source

2012 ACM/ICPC Asia Regional Jinhua Online

 

解题:最小费用最大流，最大费用最大流

 我们求最长路，所以越大越先被选！

为什么计算now - pre呢，因为分母是固定的，只要分子越大，GPA也就越大，我们贪心，优先选取使自己增幅大的，也就是now - pre增加大的。

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <cmath>
 #include <algorithm>
 #include <climits>
 #include <vector>
 #include <queue>
 #include <cstdlib>
 #include <string>
 #include <set>
 #include <stack>
 #define LL long long
 #define pii pair<int,int>
 #define INF 0x3f3f3f3f
 using namespace std;
 const int maxn = ;
 struct arc {
     int to,flow,next;
     double cost;
     arc(int x = ,int y = ,double z = ,int nxt = -) {
         to = x;
         flow = y;
         cost = z;
         next = nxt;
     }
 };
 arc e[maxn<<];
 int head[maxn],p[maxn],tot,S,T,n,k,m;
 bool in[maxn];
 double d[maxn];
 int credit[maxn],basic[maxn],can[maxn][maxn];
 void add(int u,int v,int flow,double cost) {
     e[tot] = arc(v,flow,cost,head[u]);
     head[u] = tot++;
     e[tot] = arc(u,,-cost,head[v]);
     head[v] = tot++;
 }
 bool spfa() {
     for(int i = S; i <= T; ++i) {
         d[i] = ;
         p[i] = -;
         in[i] = false;
     }
     queue<int>q;
     q.push(S);
     while(!q.empty()) {
         int u = q.front();
         q.pop();
         in[u] = false;
         for(int i = head[u]; ~i; i = e[i].next) {
             if(e[i].flow && d[e[i].to] < d[u] + e[i].cost) {
                 d[e[i].to] = d[u] + e[i].cost;
                 p[e[i].to] = i;
                 if(!in[e[i].to]) {
                     in[e[i].to] = true;
                     q.push(e[i].to);
                 }
             }
         }
     }
     return p[T] > -;
 }
 void solve() {
     while(spfa()) {
         int minF = INF;
         for(int i = p[T]; ~i; i = p[e[i^].to])
             minF = min(minF,e[i].flow);
         for(int i = p[T]; ~i; i = p[e[i^].to]) {
             e[i].flow -= minF;
             e[i^].flow += minF;
         }
     }
 }
 double calc(int x,int w){
     return (4.0 - 3.0*( - x)*( - x)/1600.0)*w;
 }
 int main() {
     while(scanf("%d %d %d",&n,&k,&m),n||m||k) {
         memset(head,-,sizeof(head));
         S = tot = ;
         T = n + m + ;
         int sum = ;
         double ans = ;
         for(int i = ; i <= m; ++i){
             scanf("%d",credit+i);
             sum += credit[i];
         }
         for(int i = ; i <= m; ++i)
             scanf("%d",basic+i);
         for(int i = ; i <= n; ++i) {
             add(i+m,T,k,);
             for(int j = ; j <= m; ++j) {
                 scanf("%d",can[i]+j);
                 if(can[i][j]) add(j,i+m,k,);
             }
         }
         for(int i = ; i <= m; ++i) {
             int h = basic[i];
             if(h < ) {
                 add(S,i, - basic[i],INF);
                 h = ;
             }
             double pre = calc(h,credit[i]);
             for(++h; h <= ; ++h){
                 double now = calc(h,credit[i]);
                 add(S,i,,now - pre);
                 pre = now;
             }
         }
         solve();
         for(int i = head[S]; ~i; i = e[i].next)
             basic[e[i].to] += e[i^].flow;
         bool flag = true;
         for(int i = ; i <= m; ++i){
             if(basic[i] < ){
                 flag = false;
                 break;
             }
             ans += calc(basic[i],credit[i])/sum;
         }
         printf("%.6f\n",flag?ans:);
     }
     return ;
 }