HDU-6000

Wash

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 64000/64000 K (Java/Others)
Total Submission(s): 2617    Accepted Submission(s): 703
 

Problem Description

Mr.Panda is about to engage in his favourite activity doing laundry! He’s brought L indistinguishable loads of laundry to his local laundromat, which has N washing machines and M dryers.The ith washing machine takes Wi minutes to wash one load of laundry, and the ith dryer takes Di minutes to dry a load of laundry.
At any point in time, each machine may only be processing at most one load of laundry.
As one might expect, Panda wants to wash and then dry each of his L loads of laundry. Each load of laundry will go through the following steps in order:
1. A non-negative amount of time after Panda arrives at the laundromat, Panda places the load in an unoccupied washing machine i.
2. Wi minutes later, he removes the load from the washing machine, placing it in a temporary holding basket (which has unlimited space)
3. A non-negative amount of time later, he places the load in an unoccupied dryer j
4. Dj minutes later, he removes the load from the dryer Panda can instantaneously add laundry to or remove laundry from a machine. Help Panda minimize the amount of time (in minutes after he arrives at the laundromat) after which he can be done washing and drying all L loads of laundry!

 

 

Input

The first line of the input gives the number of test cases, T.
T test cases follow. Each test case consists of three lines. The first line contains three integer L, N, and M.
The second line contains N integers W1,W2,...,WN representing the wash time of each wash machine.
The third line contains M integers D1,D2,...,DM representing the dry time of each dryer.

 

 

Output

For each test case, output one line containing “Case #x: y”, where x is the test case number (starting from 1) and y is the minimum time it will take Panda to finish his laundry.

limits

∙1≤T≤100 .
∙1≤L≤106 .
∙1≤N,M≤105 .
∙1≤Wi,Di≤109 .

 

 

Sample Input

2

1 1 1

1200

34

2 3 2

100 10 1

10 10

 

 

Sample Output

Case #1: 1234

Case #2: 12

解题思路：

看了好几篇博客终于理解了，洗衣服的过程很简单将输入的洗衣时间存入一个优先队列中，然后弹出第一个加上其对应的洗衣时间，继续放入队列。并用一个time数组记录每次洗完一件衣服的时间（烘干要用）。然后最难理解的就是烘干。要反过来思考，当你最后一件衣服洗完时，若能用到耗时最短的那个烘干机，那么总耗时一定最短（贪心思想来了），和洗衣服一样的道理，将每个烘干机的耗时存到一个优先队列中，每次弹出耗时最短的烘干机，烘干阶段time数组遍历时应该从后往前。让它与弹出的耗时最短的烘干机相加，将这个时间存到MAX中与下一次的比较。循环到下一次时两个时间作比较，依然保留最大的（而且是最优）。这样到最后一定是最优解。

先附上优先队列，结构体的模板：

#include <iostream>  
#include <cstdio>  
#include <vector>  
#include <queue>  
using namespace std;  

struct Node{  
    int x , y;  
    Node(int a = 0 , int b = 0){  
        x = a , y = b;  
    }  
};  

bool operator<(Node a , Node b){  
    if(a.x == b.x) return a.y>b.y;  
    return a.x>b.x;  
}  

int main(){  
    priority_queue<Node> q;  
    q.push(Node(0 , 1));  
    q.push(Node(1 , 1));  
    q.push(Node(1 , 2));  
    while(!q.empty()){  
        Node t = q.top();  
        q.pop();  
        cout << t.x<<" " << t.y << endl;  
    }  
    return 0;  
}  

AC代码：

#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;
typedef long long int LL;
struct node {
    LL x;
    LL over_time;
};
bool operator<(node a, node b)
{
    return a.over_time > b.over_time;
}
LL a[1000010];

LL max1(LL x, LL y)
{
    if(x > y)
        return x;
    else
        return y;
}
int main()
{
    int T;
    struct node temp;
    int n, m, l;
    scanf("%d", &T);
    int num = 0;

    priority_queue<node> p;
    priority_queue<node> q;
    while(T--)
    {
        num++;
       while(!p.empty())
       {
           p.pop();
       }
       while(!q.empty())
       {
           q.pop();
       }
       scanf("%d%d%d", &l, &n, &m);
       for(int i = 0; i < n; ++i)
       {
           scanf("%lld", &temp.x);
           temp.over_time = temp.x;
           p.push(temp);
       }

        for(int i = 0; i < m; ++i)
       {
           scanf("%lld", &temp.x);
           temp.over_time = temp.x;
           q.push(temp);
       }

       for(int i = 0; i < l; ++i)
       {
          temp = p.top();
          a[i] = temp.over_time;
          temp.over_time += temp.x;
          p.pop();
          p.push(temp);
       }

       LL Max = -1;
       LL k;
       for(int i = l - 1; i >= 0; i--)
       {
            temp = q.top();
            k = temp.over_time + a[i];
            Max = max1(k, Max);
            temp.over_time = Max;
            q.push(temp);
       }
       printf("Case #%d: %lld\n", num, Max);
    }

}