hdu 4864 Task

　　题目链接：hdu 4864

　　其实就是个贪心，只是当初我想的有偏差，贪心的思路不对，应该是这样子的：

　　因为 xi 的权值更重，所以优先按照 x 来排序，而这样的排序方式决定了在满足任务（即 xi >= xj && yi >= yj）的所有机器中（设为 S）优先选择更贴近 yj 的 yi（因为我们肯定是选择最贴近任务 x,y 值的机器，要么是 xi 最贴近，要么是 yi 最贴近），这样子可以使得浪费最小——因为在后续的任务中，xj 只会越来越小，S 中的任何一台机器的 xi 值都能满足要求，但 yj 就不一定了，因为一开始是按照 x 来排序的，所以 yj 有可能会比之前的更大，因此我们为当前任务选择机器时 yi 能小则小，把 yi 更大的机器留给后续有可能满足的任务，这样子就可以使得当前的浪费最小。

　　用个数组来作标记，整个程序就是近乎 O(n) 的复杂度了：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 typedef long long ll;
 const int N = ;

 struct node {
     int x,y;
     node() {}
     node(int x, int y): x(x), y(y) {}
     bool operator < (const node &n2) const {
         if(x == n2.x)   return y > n2.y;
         return x > n2.x;
     }
     void read()  {   scanf("%d %d",&x,&y);   }
 } mach[N], task[N];

 int c[];

 int main() {
     int n,m;
     while(~scanf("%d %d",&n,&m)) {
         for(int i = ; i < n; ++i)
             mach[i].read();
         for(int i = ; i < m; ++i)
             task[i].read();
         sort(mach, mach + n);
         sort(task, task + m);
         memset(c, , sizeof c);
         int num = ;
         ll ans = ;
         for(int i = , j = ; j < m; ++j) {
             while(i < n && mach[i].x >= task[j].x) {
                 c[mach[i].y]++;
                 ++i;
             }
             for(int k = task[j].y; k <= ; ++k) {
                 if(c[k]) {
                     ++num;
                     ans +=  * task[j].x +  * task[j].y;
                     --c[k];
                     break;
                 }
             }
         }
         printf("%d %I64d\n",num,ans);
     }
     return ;
 }