claoj/cpp/prevoi19_robots.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
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) {
    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;

    vector<pair<ll, ll> > test_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 (const Point &c: chargers) {
        ll cu = c.x + c.y;
        ll cv = c.x - c.y;

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

        for (auto [u, v]: boundary_points) {
            u = max(min_u, min(max_u, u));
            v = max(min_v, min(max_v, v));
            test_points.push_back({u, v});
        }
    }

    for (auto [u, v]: test_points) {
        if (u < min_u || u > max_u || v < min_v || v > max_v) continue;
        if ((u + v) % 2 != 0) continue;

        ll x = (u + v) / 2;
        ll y = (u - 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 left = 0;
    ll right = 4e9;

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