CF 725F 贪心

F. Family Photos
time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
Alice and Bonnie are sisters, but they don’t like each other very much. So when some old family photos were found in the attic, they started to argue about who should receive which photos. In the end, they decided that they would take turns picking photos. Alice goes first.

There are n stacks of photos. Each stack contains exactly two photos. In each turn, a player may take only a photo from the top of one of the stacks.

Each photo is described by two non-negative integers a and b, indicating that it is worth a units of happiness to Alice and b units of happiness to Bonnie. Values of a and b might differ for different photos.

It’s allowed to pass instead of taking a photo. The game ends when all photos are taken or both players pass consecutively.

The players don’t act to maximize their own happiness. Instead, each player acts to maximize the amount by which her happiness exceeds her sister’s. Assuming both players play optimal, find the difference between Alice’s and Bonnie’s happiness. That is, if there’s a perfectly-played game such that Alice has x happiness and Bonnie has y happiness at the end, you should print x - y.

Input
The first line of input contains a single integer n (1 ≤ n ≤ 100 000) — the number of two-photo stacks. Then follow n lines, each describing one of the stacks. A stack is described by four space-separated non-negative integers a1, b1, a2 and b2, each not exceeding 109. a1 and b1 describe the top photo in the stack, while a2 and b2 describe the bottom photo in the stack.

Output
Output a single integer: the difference between Alice’s and Bonnie’s happiness if both play optimally.

Examples
input
2
12 3 4 7
1 15 9 1
output
1
input
2
5 4 8 8
4 12 14 0
output
4
input
1
0 10 0 10
output
-10

题意：给了n个四元组x,y,xx,yy,A和B参与博弈。两人轮流选择,拿掉第i个的第一层或者在第一层拿掉的情况下拿第二层，A拿获利x(xx)，B拿同理，可以选择pass。在拿完或两人连续pass时结束。

做法：xjb贪。
首先，若$x<=yy$且 $y<=xx$该堆显然后手得利，相当于没用，pass。
其次，若不满足上一种条件，但是$x+y<xx+yy$，则先手会相对“吃亏“，但是因为不满足上一条，必然存在$x>yy$与$y>xx$两者之一，就是说必然有一方有“净利润”，有净利润者即使相对“吃亏”也会先取第一层，所以$ans+=x-yy(xx-y)$。
最后，其余情况，一堆的价值等于x+y的和，维护一个大顶堆，按价值从高到低取，取到第一层后把第二层置入堆，依次操作即可。
比赛的时候想到是贪心，但没考虑周全，wa了，赛后感觉确实没有什么大的trick。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

int n;
struct node{
    int x, y, xx, yy;
    int tag;
};

bool operator<(const node& a, const node& b){
    return a.x+a.y<b.x+b.y;
}

int main()
{
    priority_queue<node> pq;
    ll ans=0;
    scanf("%d", &n);
    int x, y, xx, yy;
    for(int i=1;i<=n;i++){
        scanf("%d%d%d%d", &x, &y, &xx, &yy);
        if(x<=yy&&y<=xx)continue;
        else if(x+y<xx+yy){
            if(x>yy)ans+=x-yy;
            else ans+=xx-y;
        }
        else{
            node tmp;
            tmp.x=x, tmp.y=y, tmp.xx=xx, tmp.yy=yy;
            tmp.tag=1;
            pq.push(tmp);
        }
    }
    int cnt=0;
    while(!pq.empty()){
        cnt++;
        node tmp=pq.top();
        pq.pop();
        //printf("%d %d\n", tmp.x, tmp.y);
        if(cnt%2){
            ans+=tmp.x;
        }
        else ans-=tmp.y;
        if(tmp.tag==1){
            tmp.tag=2;
            tmp.x=tmp.xx;
            tmp.y=tmp.yy;
            tmp.xx=0;
            tmp.yy=0;
            pq.push(tmp);
        }
    }
    printf("%lld\n", ans);
}