Minimum Average Waiting Time

Problem Statement

Tieu owns a pizza restaurant and he manages it in his own way. While in a normal restaurant, a customer is served by following the first-come, first-served rule, Tieu simply minimizes the average waiting time of his customers. So he gets to decide who is served first, regardless of how sooner or later a person comes.

Different kinds of pizzas take different amounts of time to cook. Also, once he starts cooking a pizza, he cannot cook another pizza until the first pizza is completely cooked. Let's say we have three customers who come at time t=0, t=1, & t=2 respectively, and the time needed to cook their pizzas is 3, 9, & 6 respectively. If Tieu applies first-come, first-served rule, then the waiting time of three customers is 3, 11, & 16 respectively. The average waiting time in this case is (3 + 11 + 16) / 3 = 10. This is not an optimized solution. After serving the first customer at time t=3, Tieu can choose to serve the third customer. In that case, the waiting time will be 3, 7, & 17 respectively. Hence the average waiting time is (3 + 7 + 17) / 3 = 9.

Help Tieu achieve the minimum average waiting time. For the sake of simplicity, just find the integer part of the minimum average waiting time.

Input Format

• The first line contains an integer N, which is the number of customers.
• In the next N lines, the ith line contains two space separated numbers Ti and Li. Ti is the time when ith customer order a pizza, and Li is the time required to cook that pizza.

Output Format

• Display the integer part of the minimum average waiting time.

Constraints

• 1 ≤ N ≤ 105
• 0 ≤ Ti ≤ 109
• 1 ≤ Li ≤ 109

Note

• The waiting time is calculated as the difference between the time a customer orders pizza (the time at which they enter the shop) and the time she is served.

• Cook does not know about the future orders.

Sample Input #00

3
0 3
1 9
2 6

Sample Output #00

9

Sample Input #01

3
0 3
1 9
2 5

Sample Output #01

8

Explanation #01

Let's call the person ordering at time = 0 as A, time = 1 as B and time = 2 as C. By delivering pizza for A, C and B we get the minimum average wait time to be

(3 + 6 + 16)/3 = 25/3 = 8.33 

the integer part is 8 and hence the answer.

这道题我看了两个小时，十分简单的一道题，原因是我把题意给理解错了。我原先的理解是根据这怎样安排这N个顾客的服务顺序使得平均等待时间最短。其实问题不是这样的，问题是在当前时间t内，对所有已经到达的顾客中选择一个进行服务，最终使得平均等待时间最短，Heap的应用。

不能预知未来的程序：

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 100010;
typedef long long ll;

inline ll max(ll a, ll b) {
    return a > b ? a : b;
}

struct Node1 {
    ll a, b;
    Node1() {}
    Node1(ll t_a, ll t_b) : a(t_a), b(t_b) {}
    bool operator < (const Node1 &p) const {
        return a < p.a;
    }
}node[maxn];

struct Node2 {
    ll a, b;
    Node2() {}
    Node2(ll t_a, ll t_b) : a(t_a), b(t_b) { }
    bool operator < (const Node2 &p) const {
        return b > p.b;
    }
};


int main() {

    //freopen("aa.in", "r", stdin);

    int n;
    ll t = 0;
    ll ans = 0;
    int id = 1;
    Node2 p;
    priority_queue<Node2> pq;
    scanf("%d", &n);
    for(int i = 0; i < n; ++i) {
        scanf("%lld %lld", &node[i].a, &node[i].b);
        ans -= node[i].a;
    }
    sort(node, node + n);
    t = node[0].a;
    pq.push(Node2(node[0].a, node[0].b));
    while(!pq.empty() || id < n) {
        while(id < n) {
            if(node[id].a <= t) {
                pq.push(Node2(node[id].a, node[id].b));
                id++;
            } else {
                break;
            }
        }
        p = pq.top();
        pq.pop();
        t = t + p.b;
        ans += t;
    }
    printf("%lld\n", ans / n);
    return 0;
}

能够预知未来的程序：

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;
const int maxn = 100010;
typedef long long ll;

struct Node1 {
    ll a, b;
    Node1() {}
    Node1(ll t_a, ll t_b) : a(t_a), b(t_b) {}
    bool operator < (const Node1 &p) const {
        return a + b > p.a + p.b;
    }
};

struct Node2 {
    ll a, b;
    Node2() {}
    Node2(ll t_a, ll t_b) : a(t_a), b(t_b) {}
    bool operator < (const Node2 &p) const {
        return b > p.b;
    }
};

inline ll max(ll a, ll b) {
    return a > b ? a : b;
}

int main() {

    priority_queue<Node1> pq1;
    priority_queue<Node2> pq2;
    int n;
    ll a, b;
    ll t = 0;
    ll ans = 0;
    Node1 p1;
    Node2 p2;
    scanf("%d", &n);
    for(int i = 0; i < n; ++i) {
        scanf("%lld %lld", &a, &b);
        ans -= a;
        pq1.push(Node1(a, b));
    }
    while(!pq1.empty() || !pq2.empty()) {
        if(!pq1.empty()) {
            if(pq1.top().a < t) {
                while(!pq1.empty() && pq1.top().a < t) {
                    p1 = pq1.top();
                    pq1.pop();
                    p2.a = p1.a;
                    p2.b = p1.b;
                    pq2.push(p2);
                }
                if(!pq1.empty()) {
                    p1 = pq1.top();
                    p2 = pq2.top();
                    if(p1.a + p1.b <= t + p2.b) {
                        if(p1.a + p1.b == t + p2.b && p1.b < p2.b) {
                            t = t + p2.b;
                            pq2.pop();
                        } else {
                            t = p1.a + p1.b;
                            pq1.pop();
                        }
                    } else {
                        t = t + p2.b;
                        pq2.pop();
                    }
                } else {
                    p2 = pq2.top();
                    pq2.pop();
                    t = t + p2.b;
                }
            } else {
                p1 = pq1.top();
                if(!pq2.empty()) p2 = pq2.top();
                if(pq2.empty() || p1.a + p1.b <= t + p2.b) {
                    if(!pq2.empty() && p1.a + p1.b == t + p2.b && p1.b < p2.b) {
                        t = t + p2.b;
                        pq2.pop();
                    } else {
                        pq1.pop();
                        t = p1.a + p1.b;
                    }
                } else {
                    t = t + p2.b;
                    pq2.pop();
                }
            }
            ans += t;
            continue;
        }
        if(!pq2.empty()) {
            p2 = pq2.top();
            pq2.pop();
            t = t + p2.b;
            ans += t;
        }
    }
    printf("%lld\n", ans / n);
    return 0;
}