Old legos

#include <algorithm>
#include <iostream>
#include <limits>
#include <set>
#include <utility>
#include <vector>

/**
Uolevi and Maija are visiting their parents. While the blueberry pie is cooking
in the oven, they go explore the attic. They find their old legos and decide to
build castles from them. There are n legos in a box numbered 1,2,\dots,n, the
i-th of which has u_i nostalgic value to Uolevi and m_i to Maija. The siblings
then take turns in picking legos from the box and placing them to their castles.
Naturally, both try to maximize the value difference between their own castle
and their opponents castle. Formally, the legos will be divided into two sets U
and M at the end of the process. Uolevi's castle has value x = \sum_{i \in
U}{u_i} and Maija's castle has value y = \sum_{i \in M}{m_i}. Maija tries to
minimize x-y while Uolevi tries to maximize it. Calculate x-y if Uolevi gets to
pick the first lego and both pick the legos optimally.

Input
First line contain a single integer n.
The 𝑖-th of the next n lines contains two integers u_i and m_𝑖.

Output
Output a single integer x-y.
Constraints

1 \leq n \leq 10^5
1 \leq u_i, m_i \leq 10^9

Example 1
Input:
5
3 1
9 3
6 3
2 10
1 7

Output:
1

Explanation:
The sequence of picks would be:
Uolevi picks lego 2
Maija picks lego 4
Uolevi picks lego 3
Maija picks lego 5
Uolevi picks lego 1
Example 2
Input:
2
10 2
1 1000

Output:
-1
 */

using namespace std;

const int INF = numeric_limits<int>::max();
const int NEGINF = numeric_limits<int>::lowest();

template <typename T>
std::ostream &operator<<(std::ostream &os, const vector<T> &obj) {
    bool first = true;
    for (const auto &o : obj) {
        if (first) {
            cout << o;
            first = false;
        } else {
            cout << ' ' << o;
        }
    }
    cout << endl;
    return os;
}

std::ostream &operator<<(std::ostream &os, const vector<pair<int, int>> &obj) {
    for (const auto &o : obj) {
        cout << o.first << ' ' << o.second << endl;
    }
    cout << endl;
    return os;
}

vector<pair<int, int>> UM;

int u(set<pair<int, int>> &left);

int m(set<pair<int, int>> left) {
    if (left.empty())
        return 0;
    if (left.size() == 1)
        return -left.begin()->second;

    int best = INF;

    auto scratch{left};
    for (auto &elem : left) {
        scratch.erase(elem);
        int u_ = u(scratch);
        if (-elem.second + u_ < best)
            best = -elem.second + u_;
        scratch.insert(elem);
    }
    return best;
}

int u(set<pair<int, int>> &left) {
    if (left.empty())
        return 0;
    if (left.size() == 1)
        return left.begin()->first;

    int best = NEGINF;

    auto scratch{left};
    for (auto &elem : left) {
        scratch.erase(elem);
        int m_ = m(scratch);
        if (elem.first + m_ > best)
            best = elem.first + m_;
        scratch.insert(elem);
    }
    return best;
}

int main(int argc, char **argv) {
    int n;
    cin >> n;

    UM = vector<pair<int, int>>(n);

    for (int i = 0; i < n; ++i) {
        cin >> UM[i].first;
        cin >> UM[i].second;
    }
    set<pair<int, int>> left{UM.begin(), UM.end()};

    cout << u(left);

    // sort(UM.begin(), UM.end(), [](pair<int, int> a, pair<int, int> b) {
    //     return abs(a.first - a.second) > abs(b.first - b.second);
    // });
    //
    // cout << endl;
    // cout << "UM: " << endl << UM << endl;
    // char turn{'U'};
    // int x_y = 0;
    // for (int i = 0; i < UM.size(); ++i) {
    //     if (turn == 'U') {
    //         x_y += UM[i].first;
    //         turn = 'M';
    //     } else {
    //         x_y -= UM[i].second;
    //         turn = 'U';
    //     }
    // }
    // cout << x_y << endl;
}

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: ACCEPTED

Test 7

Verdict: ACCEPTED

Test 8

Verdict: ACCEPTED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: ACCEPTED

Test 14

Verdict: ACCEPTED

Test 15

Verdict: ACCEPTED

Test 16

Verdict: ACCEPTED

Test 17

Verdict: ACCEPTED

Test 18

Verdict: ACCEPTED

Test 19

Verdict: ACCEPTED

Test 20

Verdict: WRONG ANSWER

Test 21

Verdict: ACCEPTED

Test 22

Verdict: TIME LIMIT EXCEEDED

Test 23

Verdict: WRONG ANSWER

Test 24

Verdict: ACCEPTED

Test 25

Verdict: TIME LIMIT EXCEEDED

Test 26

Verdict: ACCEPTED

Test 27

Verdict: TIME LIMIT EXCEEDED

Test 28

Verdict: ACCEPTED

Test 29

Verdict: TIME LIMIT EXCEEDED

Test 30

Verdict: TIME LIMIT EXCEEDED

Test 31

Verdict: TIME LIMIT EXCEEDED

Test 32

Verdict: TIME LIMIT EXCEEDED

Test 33

Verdict: TIME LIMIT EXCEEDED

Test 34

Verdict: TIME LIMIT EXCEEDED

Test 35

Verdict: TIME LIMIT EXCEEDED

Test 36

Verdict: TIME LIMIT EXCEEDED

Test 37

Verdict: TIME LIMIT EXCEEDED

Test 38

Verdict: TIME LIMIT EXCEEDED

Test 39

Verdict: TIME LIMIT EXCEEDED

Test 40

Verdict: TIME LIMIT EXCEEDED

Test 41

Verdict: TIME LIMIT EXCEEDED

Test 42

Verdict: TIME LIMIT EXCEEDED

Test 43

Verdict: TIME LIMIT EXCEEDED

Test 44

Verdict: TIME LIMIT EXCEEDED

Test 45

Verdict: TIME LIMIT EXCEEDED

Test 46

Verdict: TIME LIMIT EXCEEDED

Test 47

Verdict: TIME LIMIT EXCEEDED

Test 48

Verdict: TIME LIMIT EXCEEDED

Test 49

Verdict: TIME LIMIT EXCEEDED

Test 50

Verdict: TIME LIMIT EXCEEDED

Test 51

Verdict: TIME LIMIT EXCEEDED

Test 52

Verdict: TIME LIMIT EXCEEDED

Test 53

Verdict: TIME LIMIT EXCEEDED

Test 54

Verdict: TIME LIMIT EXCEEDED

Test 55

Verdict: TIME LIMIT EXCEEDED

Test 56

Verdict: TIME LIMIT EXCEEDED

Test 57

Verdict: TIME LIMIT EXCEEDED

Test 58

Verdict: TIME LIMIT EXCEEDED

Test 59

Verdict: TIME LIMIT EXCEEDED

Test 60

Verdict: RUNTIME ERROR

Test 61

Verdict: RUNTIME ERROR

Test 62

Verdict: RUNTIME ERROR

Test 63

Verdict: RUNTIME ERROR

Test 64

Verdict: RUNTIME ERROR

Test 65

Verdict: RUNTIME ERROR

Test 66

Verdict: RUNTIME ERROR

Test 67

Verdict: RUNTIME ERROR

Test 68

Verdict: RUNTIME ERROR

Test 69

Verdict: RUNTIME ERROR