claoj/cpp/prevoi19_robots.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <set>
using namespace std;

typedef long long ll;

struct Point {
    ll x, y;
};

ll manhattan(const Point &a, const Point &b) {
    return abs(a.x - b.x) + abs(a.y - b.y);
}

bool isPossible(ll D, const vector<Point> &chargers, const Point &start, ll N) {
    if (D == 0) return true;

    ll u0 = start.x + start.y;
    ll v0 = start.x - start.y;
    ll min_u = u0 - N;
    ll max_u = u0 + N;
    ll min_v = v0 - N;
    ll max_v = v0 + N;

    set<pair<ll, ll> > candidates;

    vector<pair<ll, ll> > base_points = {
        {min_u, min_v}, {min_u, max_v}, {max_u, min_v}, {max_u, max_v},
        {u0, v0}, {min_u, v0}, {max_u, v0}, {u0, min_v}, {u0, max_v}
    };

    for (auto [u, v]: base_points) {
        candidates.insert({u, v});
    }

    for (const Point &c: chargers) {
        ll cu = c.x + c.y;
        ll cv = c.x - c.y;

        vector<pair<ll, ll> > charger_points = {
            {cu - D, cv}, {cu + D, cv}, {cu, cv - D}, {cu, cv + D},
            {cu - D, cv - D}, {cu - D, cv + D}, {cu + D, cv - D}, {cu + D, cv + D}
        };

        for (auto [u, v]: charger_points) {
            u = max(min_u, min(max_u, u));
            v = max(min_v, min(max_v, v));
            candidates.insert({u, v});
        }
    }

    for (auto [u, v]: candidates) {
        for (ll du = -1; du <= 1; du++) {
            for (ll dv = -1; dv <= 1; dv++) {
                ll test_u = u + du;
                ll test_v = v + dv;

                if (test_u < min_u || test_u > max_u || test_v < min_v || test_v > max_v) {
                    continue;
                }

                if ((test_u + test_v) % 2 != 0) continue;

                ll x = (test_u + test_v) / 2;
                ll y = (test_u - test_v) / 2;
                Point p = {x, y};

                if (manhattan(p, start) > N) continue;

                bool valid = true;
                for (const Point &c: chargers) {
                    if (manhattan(p, c) < D) {
                        valid = false;
                        break;
                    }
                }
                if (valid) return true;
            }
        }
    }

    return false;
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);

    int U;
    ll N;
    cin >> U >> N;

    vector<Point> chargers(U);
    for (int i = 0; i < U; i++) {
        cin >> chargers[i].x >> chargers[i].y;
    }

    Point start;
    cin >> start.x >> start.y;

    ll max_dist = 0;
    for (const Point &c: chargers) {
        max_dist = max(max_dist, manhattan(start, c));
    }
    ll upper_bound = max_dist + N + 1;

    ll left = 0;
    ll right = upper_bound;

    while (left <= right) {
        ll mid = left + (right - left) / 2;
        if (isPossible(mid, chargers, start, N)) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    cout << right << endl;

    return 0;
}