贪心

比较巧妙的贪心。。先把所有机器和任务按时间是第一关键字，等级为第二关键字排序。

然后用机器去匹配每一个任务。

排序之后，在时间上满足当前任务的机器，必定也在时间上满足后面的机器，所以我们每次把时间满足当前任务的机器放进候选项中，再在候选项里选出当前任务等级的前驱即可

（时间和等级最大的任务先处理，且尽可能的不浪费机器）

#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;

}