#include <algorithm> #include <array> #include <bitset> #include <cassert> #include <chrono> #include <cmath> #include <complex> #include <deque> #include <forward_list> #include <fstream> #include <functional> #include <iomanip> #include <ios> #include <iostream> #include <limits> #include <list> #include <map> #include <memory> #include <numeric> #include <optional> #include <queue> #include <random> #include <set> #include <sstream> #include <stack> #include <string> #include <tuple> #include <type_traits> #include <unordered_map> #include <unordered_set> #include <utility> #include <vector> using namespace std; using lint = long long; using pint = pair<int, int>; using plint = pair<lint, lint>; struct fast_ios { fast_ios(){ cin.tie(nullptr), ios::sync_with_stdio(false), cout << fixed << setprecision(20); }; } fast_ios_; #define ALL(x) (x).begin(), (x).end() #define FOR(i, begin, end) for(int i=(begin),i##_end_=(end);i<i##_end_;i++) #define IFOR(i, begin, end) for(int i=(end)-1,i##_begin_=(begin);i>=i##_begin_;i--) #define REP(i, n) FOR(i,0,n) #define IREP(i, n) IFOR(i,0,n) template <typename T> bool chmax(T &m, const T q) { return m < q ? (m = q, true) : false; } template <typename T> bool chmin(T &m, const T q) { return m > q ? (m = q, true) : false; } const std::vector<std::pair<int, int>> grid_dxs{{1, 0}, {-1, 0}, {0, 1}, {0, -1}}; int floor_lg(long long x) { return x <= 0 ? -1 : 63 - __builtin_clzll(x); } template <class T1, class T2> T1 floor_div(T1 num, T2 den) { return (num > 0 ? num / den : -((-num + den - 1) / den)); } template <class T1, class T2> std::pair<T1, T2> operator+(const std::pair<T1, T2> &l, const std::pair<T1, T2> &r) { return std::make_pair(l.first + r.first, l.second + r.second); } template <class T1, class T2> std::pair<T1, T2> operator-(const std::pair<T1, T2> &l, const std::pair<T1, T2> &r) { return std::make_pair(l.first - r.first, l.second - r.second); } template <class T> std::vector<T> sort_unique(std::vector<T> vec) { sort(vec.begin(), vec.end()), vec.erase(unique(vec.begin(), vec.end()), vec.end()); return vec; } template <class T> int arglb(const std::vector<T> &v, const T &x) { return std::distance(v.begin(), std::lower_bound(v.begin(), v.end(), x)); } template <class T> int argub(const std::vector<T> &v, const T &x) { return std::distance(v.begin(), std::upper_bound(v.begin(), v.end(), x)); } template <class IStream, class T> IStream &operator>>(IStream &is, std::vector<T> &vec) { for (auto &v : vec) is >> v; return is; } template <class OStream, class T> OStream &operator<<(OStream &os, const std::vector<T> &vec); template <class OStream, class T, size_t sz> OStream &operator<<(OStream &os, const std::array<T, sz> &arr); template <class OStream, class T, class TH> OStream &operator<<(OStream &os, const std::unordered_set<T, TH> &vec); template <class OStream, class T, class U> OStream &operator<<(OStream &os, const pair<T, U> &pa); template <class OStream, class T> OStream &operator<<(OStream &os, const std::deque<T> &vec); template <class OStream, class T> OStream &operator<<(OStream &os, const std::set<T> &vec); template <class OStream, class T> OStream &operator<<(OStream &os, const std::multiset<T> &vec); template <class OStream, class T> OStream &operator<<(OStream &os, const std::unordered_multiset<T> &vec); template <class OStream, class T, class U> OStream &operator<<(OStream &os, const std::pair<T, U> &pa); template <class OStream, class TK, class TV> OStream &operator<<(OStream &os, const std::map<TK, TV> &mp); template <class OStream, class TK, class TV, class TH> OStream &operator<<(OStream &os, const std::unordered_map<TK, TV, TH> &mp); template <class OStream, class... T> OStream &operator<<(OStream &os, const std::tuple<T...> &tpl); template <class OStream, class T> OStream &operator<<(OStream &os, const std::vector<T> &vec) { os << '['; for (auto v : vec) os << v << ','; os << ']'; return os; } template <class OStream, class T, size_t sz> OStream &operator<<(OStream &os, const std::array<T, sz> &arr) { os << '['; for (auto v : arr) os << v << ','; os << ']'; return os; } template <class... T> std::istream &operator>>(std::istream &is, std::tuple<T...> &tpl) { std::apply([&is](auto &&... args) { ((is >> args), ...);}, tpl); return is; } template <class OStream, class... T> OStream &operator<<(OStream &os, const std::tuple<T...> &tpl) { os << '('; std::apply([&os](auto &&... args) { ((os << args << ','), ...);}, tpl); return os << ')'; } template <class OStream, class T, class TH> OStream &operator<<(OStream &os, const std::unordered_set<T, TH> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; } template <class OStream, class T> OStream &operator<<(OStream &os, const std::deque<T> &vec) { os << "deq["; for (auto v : vec) os << v << ','; os << ']'; return os; } template <class OStream, class T> OStream &operator<<(OStream &os, const std::set<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; } template <class OStream, class T> OStream &operator<<(OStream &os, const std::multiset<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; } template <class OStream, class T> OStream &operator<<(OStream &os, const std::unordered_multiset<T> &vec) { os << '{'; for (auto v : vec) os << v << ','; os << '}'; return os; } template <class OStream, class T, class U> OStream &operator<<(OStream &os, const std::pair<T, U> &pa) { return os << '(' << pa.first << ',' << pa.second << ')'; } template <class OStream, class TK, class TV> OStream &operator<<(OStream &os, const std::map<TK, TV> &mp) { os << '{'; for (auto v : mp) os << v.first << "=>" << v.second << ','; os << '}'; return os; } template <class OStream, class TK, class TV, class TH> OStream &operator<<(OStream &os, const std::unordered_map<TK, TV, TH> &mp) { os << '{'; for (auto v : mp) os << v.first << "=>" << v.second << ','; os << '}'; return os; } #ifdef HITONANODE_LOCAL const string COLOR_RESET = "\033[0m", BRIGHT_GREEN = "\033[1;32m", BRIGHT_RED = "\033[1;31m", BRIGHT_CYAN = "\033[1;36m", NORMAL_CROSSED = "\033[0;9;37m", RED_BACKGROUND = "\033[1;41m", NORMAL_FAINT = "\033[0;2m"; #define dbg(x) std::cerr << BRIGHT_CYAN << #x << COLOR_RESET << " = " << (x) << NORMAL_FAINT << " (L" << __LINE__ << ") " << __FILE__ << COLOR_RESET << std::endl #define dbgif(cond, x) ((cond) ? std::cerr << BRIGHT_CYAN << #x << COLOR_RESET << " = " << (x) << NORMAL_FAINT << " (L" << __LINE__ << ") " << __FILE__ << COLOR_RESET << std::endl : std::cerr) #else #define dbg(x) ((void)0) #define dbgif(cond, x) ((void)0) #endif #include <cassert> #include <iostream> #include <vector> // Bipartite matching of undirected bipartite graph (Hopcroft-Karp) // https://ei1333.github.io/luzhiled/snippets/graph/hopcroft-karp.html // Comprexity: O((V + E)sqrtV) // int solve(): enumerate maximum number of matching / return -1 (if graph is not bipartite) struct BipartiteMatching { int V; std::vector<std::vector<int>> to; // Adjacency list std::vector<int> dist; // dist[i] = (Distance from i'th node) std::vector<int> match; // match[i] = (Partner of i'th node) or -1 (No parter) std::vector<int> used, vv; std::vector<int> color; // color of each node(checking bipartition): 0/1/-1(not determined) BipartiteMatching() = default; BipartiteMatching(int V_) : V(V_), to(V_), match(V_, -1), used(V_), color(V_, -1) {} void add_edge(int u, int v) { assert(u >= 0 and u < V and v >= 0 and v < V and u != v); to[u].push_back(v); to[v].push_back(u); } void _bfs() { dist.assign(V, -1); std::vector<int> q; int lq = 0; for (int i = 0; i < V; i++) { if (!color[i] and !used[i]) q.push_back(i), dist[i] = 0; } while (lq < int(q.size())) { int now = q[lq++]; for (auto nxt : to[now]) { int c = match[nxt]; if (c >= 0 and dist[c] == -1) q.push_back(c), dist[c] = dist[now] + 1; } } } bool _dfs(int now) { vv[now] = true; for (auto nxt : to[now]) { int c = match[nxt]; if (c < 0 or (!vv[c] and dist[c] == dist[now] + 1 and _dfs(c))) { match[nxt] = now, match[now] = nxt; used[now] = true; return true; } } return false; } bool _color_bfs(int root) { color[root] = 0; std::vector<int> q{root}; int lq = 0; while (lq < int(q.size())) { int now = q[lq++], c = color[now]; for (auto nxt : to[now]) { if (color[nxt] == -1) { color[nxt] = !c, q.push_back(nxt); } else if (color[nxt] == c) { return false; } } } return true; } int solve() { for (int i = 0; i < V; i++) { if (color[i] == -1 and !_color_bfs(i)) return -1; } int ret = 0; while (true) { _bfs(); vv.assign(V, false); int flow = 0; for (int i = 0; i < V; i++) { if (!color[i] and !used[i] and _dfs(i)) flow++; } if (!flow) break; ret += flow; } return ret; } template <class OStream> friend OStream &operator<<(OStream &os, const BipartiteMatching &bm) { os << "{N=" << bm.V << ':'; for (int i = 0; i < bm.V; i++) { if (bm.match[i] > i) os << '(' << i << '-' << bm.match[i] << "),"; } return os << '}'; } }; int main() { int N; cin >> N; vector<pint> xys(N); for (auto &[x, y] : xys) cin >> x >> y; sort(xys.begin(), xys.end()); vector<pint> dxdys{{2, -1}, {2, 1}, {1, 2}, {-1, 2}, {-2, 1}, {-2, -1}, {-1, -2}, {1, -2}}; int ret = N + 1; auto rec = [&](auto &&self, int rem_mask, vector<vector<int>> groups) -> void { if (!rem_mask) { if ((int)groups.size() >= ret) return; vector<vector<pint>> to; vector<pint> all_vs; for (const auto &is : groups) { vector<pint> targets; for (auto dxy : dxdys) { pint target = xys.at(is.at(0)) + dxy; if (binary_search(xys.begin(), xys.end(), target)) continue; targets.push_back(xys.at(is.at(0)) + dxy); } sort(targets.begin(), targets.end()); for (int i : is) { vector<pint> next_targets; for (auto dxy : dxdys) { pint target = xys.at(i) + dxy; if (binary_search(targets.begin(), targets.end(), target)) next_targets.push_back(target); } targets = move(next_targets); } to.push_back(targets); all_vs.insert(all_vs.end(), targets.begin(), targets.end()); } all_vs = sort_unique(all_vs); BipartiteMatching bm(groups.size() + all_vs.size()); REP(m, groups.size()) { for (const auto &v : to.at(m)) { const int j = arglb(all_vs, v); bm.add_edge(m, groups.size() + j); } } if (bm.solve() == (int)groups.size()) chmin(ret, (int)groups.size()); return; } const int i = __builtin_ctz(rem_mask); groups.push_back({i}); self(self, rem_mask - (1 << i), groups); for (int j = i + 1; j < N; ++j) { auto dxy = xys.at(j) - xys.at(i); if ((dxy.first == 0 and abs(dxy.second) == 2) or (dxy.second == 0 and abs(dxy.first) == 2)) { groups.back().push_back(j); self(self, rem_mask - (1 << i) - (1 << j), groups); groups.back().pop_back(); } } }; rec(rec, (1 << N) - 1, {}); cout << (ret <= N ? ret : -1) << '\n'; }