From 1ef40d76da7a47835c8b37fdd023832e3445fe32 Mon Sep 17 00:00:00 2001
From: tiennm99 <tiennm99@outlook.com>
Date: Sat, 29 Nov 2025 01:33:39 +0700
Subject: [PATCH] Update prevoi19_robots.cpp

---
 cpp/prevoi19_robots.cpp | 85 ++++++++++++++++++++++++++---------------
 1 file changed, 54 insertions(+), 31 deletions(-)

diff --git a/cpp/prevoi19_robots.cpp b/cpp/prevoi19_robots.cpp
index cbf945d..521d939 100644
--- a/cpp/prevoi19_robots.cpp
+++ b/cpp/prevoi19_robots.cpp
@@ -16,6 +16,8 @@ ll manhattan(const Point &a, const Point &b) {
 }
 
 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;
@@ -23,48 +25,63 @@ bool isPossible(ll D, const vector<Point> &chargers, const Point &start, ll N) {
     ll min_v = v0 - N;
     ll max_v = v0 + N;
 
-    set<pair<ll, ll> > test_points;
+    set<pair<ll, ll> > candidates;
 
-    test_points.insert({min_u, min_v});
-    test_points.insert({min_u, max_v});
-    test_points.insert({max_u, min_v});
-    test_points.insert({max_u, max_v});
+    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> > corners = {
-            {cu - D, cv - D}, {cu - D, cv + D},
-            {cu + D, cv - D}, {cu + D, cv + D}
+        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]: corners) {
-            ll u_clamped = max(min_u, min(max_u, u));
-            ll v_clamped = max(min_v, min(max_v, v));
-            test_points.insert({u_clamped, v_clamped});
+        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]: test_points) {
-        if (u < min_u || u > max_u || v < min_v || v > max_v) continue;
-        if ((u + v) % 2 != 0) continue;
+    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;
 
-        ll x = (u + v) / 2;
-        ll y = (u - v) / 2;
-        Point p = {x, y};
+                if (test_u < min_u || test_u > max_u || test_v < min_v || test_v > max_v) {
+                    continue;
+                }
 
-        if (manhattan(p, start) > N) continue;
+                if ((test_u + test_v) % 2 != 0) continue;
 
-        bool valid = true;
-        for (const Point &c: chargers) {
-            if (manhattan(p, c) < D) {
-                valid = false;
-                break;
+                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;
             }
         }
-        if (valid) return true;
     }
+
     return false;
 }
 
@@ -84,19 +101,25 @@ int main() {
     Point start;
     cin >> start.x >> start.y;
 
-    ll left = 0;
-    ll right = 4e9;
+    ll max_dist = 0;
+    for (const Point &c: chargers) {
+        max_dist = max(max_dist, manhattan(start, c));
+    }
+    ll upper_bound = max_dist + N + 1;
 
-    while (left < right) {
-        ll mid = left + (right - left + 1) / 2;
+    ll left = 0;
+    ll right = upper_bound;
+
+    while (left <= right) {
+        ll mid = left + (right - left) / 2;
         if (isPossible(mid, chargers, start, N)) {
-            left = mid;
+            left = mid + 1;
         } else {
             right = mid - 1;
         }
     }
 
-    cout << left << endl;
+    cout << right << endl;
 
     return 0;
 }