二分+动态规划 POJ 1973 Software Company

Software Company

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 1112		Accepted: 482

Description

A software developing company has been assigned two programming projects. As both projects are within the same contract, both must be handed in at the same time. It does not help if one is finished earlier.

This company has n employees to do the jobs. To manage the two projects more easily, each is divided into m independent subprojects. Only one employee can work on a single subproject at one time, but it is possible for two employees to work on different subprojects of the same project simultaneously.

Our goal is to finish the projects as soon as possible.

Input

The first line of the input file contains a single integer t (1 <= t <= 11), the number of test cases, followed by the input data for each test case. The first line of each test case contains two integers n (1 <= n <= 100), and m (1 <= m <= 100). The input for this test case will be followed by n lines. Each line contains two integers which specify how much time in seconds it will take for the specified employee to complete one subproject of each project. So if the line contains x and y, it means that it takes the employee x seconds to complete a subproject from the first project, and y seconds to complete a subproject from the second project.

Output

There should be one line per test case containing the minimum amount of time in seconds after which both projects can be completed.

Sample Input

1
3 20
1 1
2 4
1 6

Sample Output

18

 /*既然动态规划方程中要转移的量太多，那么我们就把时间作为二分的对象，对时间进行二分，假设一个最短时间（每个人都不能超过的时间），进行DP，f[i][j]表示是前i个人做j个A项目所能做的最多的B项目的数目，
 方程：d[i][j] = max { d[i][j] ,  d[i][j - k] +  (time - A[i] * k) / B[i] }
 枚举第i个人做k个A项目，剩下的时间用来做B项目，只要检查d[i][m]》=m就是能够到这个时间。
 当然我们也可以用滚动数组压缩空间。*/
 #define N 101
 #include<iostream>
 using namespace std;
 #include<cstdio>
 #include<cstring>
 struct QU{
     int n,m,A[N],B[N],f[N];
     void init(int x,int y)
     {
         n=x;m=y;
         memset(A,,sizeof(A));
         memset(B,,sizeof(B));
         memset(f,,sizeof(f));
     }
     void add(int a,int b,int i)
     {
         A[i]=a;B[i]=b;
     }
     bool check(int V)
     {
         memset(f,-,sizeof(f));
         for(int i=;i<=m;++i)
         {/*初始化第一个人的做i个A项目的情况*/
             if(i*A[]>V) break;
             f[i]=max(f[i],(V-i*A[])/B[]);
         }
         if(f[m]>=m) return true;
         for(int i=;i<=n;++i)
         {
             for(int j=m;j>=;--j)
             {/*枚举前i-1人做了多少个A*/
                 for(int k=;k<=j;++k)
                 {/*枚举第i个人做了k个A项目*/
                     if(V<k*A[i]) break;
                     if(f[j-k]!=-)
                     f[j]=max(f[j],f[j-k]+(V-k*A[i])/B[i]);
                 /*注意前-1个人可能做不到j-k个项目，这时候如果转移，那就是前i-1个人总共花了-1时间，显然不合题意*/
                                 }
             }
             if(f[m]>=m) return true;
         }
         return false;
     }
 }Q;
 int main()
 {
     int tes;
     scanf("%d",&tes);
     int n,m;
     while(tes--)
     {
         scanf("%d%d",&n,&m);
         Q.init(n,m);
         int a,b;
         int maxx=-;
         for(int i=;i<=n;++i)
         {
             scanf("%d%d",&a,&b);
             Q.add(a,b,i);
             maxx=max(maxx,max(a,b));
         }
         int l=,r=maxx*m*;
         int mid;
         while(l<=r)
         {
             mid=(l+r)>>;
             if(Q.check(mid))
             r=mid-;
             else l=mid+;
         }
         printf("%d\n",l);

     }
     return ;
 }