贪心

比较巧妙的贪心。。先把所有机器和任务按时间是第一关键字，等级为第二关键字排序。
然后用机器去匹配每一个任务。
排序之后，在时间上满足当前任务的机器，必定也在时间上满足后面的机器，所以我们每次把时间满足当前任务的机器放进候选项中，再在候选项里选出当前任务等级的前驱即可
（时间和等级最大的任务先处理，且尽可能的不浪费机器）

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define full(a, b) memset(a, b, sizeof a)
using namespace std;
typedef long long ll;
inline int lowbit(int x){ return x & (-x); }
inline int read(){
    int X = 0, w = 0; char ch = 0;
    while(!isdigit(ch)) { w |= ch == '-'; ch = getchar(); }
    while(isdigit(ch)) X = (X << 3) + (X << 1) + (ch ^ 48), ch = getchar();
    return w ? -X : X;
}
inline int gcd(int a, int b){ return a % b ? gcd(b, a % b) : b; }
inline int lcm(int a, int b){ return a / gcd(a, b) * b; }
template<typename T>
inline T max(T x, T y, T z){ return max(max(x, y), z); }
template<typename T>
inline T min(T x, T y, T z){ return min(min(x, y), z); }
template<typename A, typename B, typename C>
inline A fpow(A x, B p, C lyd){
    A ans = 1;
    for(; p; p >>= 1, x = 1LL * x * x % lyd)if(p & 1)ans = 1LL * x * ans % lyd;
    return ans;
}

const int N = 100005;
struct Node{
    int t, l;
    bool operator < (const Node &rhs) const {
        if(t != rhs.t) return t > rhs.t;
        return l > rhs.l;
    }
}pc[N], task[N];
int vis[N];
int main(){

    int n, m;
    while(scanf("%d%d", &n, &m) != EOF){
        full(vis, 0);
        for(int i = 0; i < n; i ++) pc[i].t = read(), pc[i].l = read();
        for(int i = 0; i < m; i ++) task[i].t = read(), task[i].l = read();
        sort(pc, pc + n), sort(task, task + m);
        ll ans = 0; int cnt = 0, j = 0;
        for(int i = 0; i < m; i ++){
            while(j < n && pc[j].t >= task[i].t) vis[pc[j].l] ++, j ++;
            for(int w = task[i].l; w <= 100; w ++){
                if(!vis[w]) continue;
                vis[w] --, cnt ++;
                ans += task[i].t * 500 + task[i].l * 2;
                break;
            }
        }
        printf("%d %lld\n", cnt, ans);
    }
    return 0;
}

HDU4864 Task(算竞进阶习题)

原文：https://www.cnblogs.com/onionQAQ/p/10638958.html