結果

問題 No.2354 Poor Sight in Winter
ユーザー nu50218nu50218
提出日時 2023-06-16 22:46:37
言語 C++17(gcc12)
(gcc 12.3.0 + boost 1.87.0)
結果
WA  
実行時間 -
コード長 6,938 bytes
コンパイル時間 22,018 ms
コンパイル使用メモリ 329,376 KB
最終ジャッジ日時 2025-02-14 21:06:29
ジャッジサーバーID
(参考情報)
judge5 / judge4
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
sample AC * 3
other AC * 23 WA * 3
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#line 1 "main.cpp"
#ifdef LOCAL
#include <local.hpp>
#else
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,popcnt,lzcnt,abm,bmi,bmi2")
#include <bits/stdc++.h>
#define debug(...) ((void)0)
#define postprocess(...) ((void)0)
#endif
// https://hitonanode.github.io/cplib-cpp/graph/manhattan_mst.hpp
// CUT begin
// Manhattan MST: minimum spanning tree O(N)
// Complexity: O(N log N)
// output: [(weight_uv, u, v), ...]
// Verified: https://judge.yosupo.jp/problem/manhattanmst, https://www.codechef.com/problems/HKRMAN
// Reference:
// [1] H. Zhou, N. Shenoy, W. Nicholls,
// "Efficient minimum spanning tree construction without Delaunay triangulation,"
// Information Processing Letters, 81(5), 271-276, 2002.
template <typename T>
std::vector<std::tuple<T, int, int>> manhattan_mst(std::vector<T> xs, std::vector<T> ys) {
const int n = xs.size();
std::vector<int> idx(n);
std::iota(idx.begin(), idx.end(), 0);
std::vector<std::tuple<T, int, int>> ret;
for (int s = 0; s < 2; s++) {
for (int t = 0; t < 2; t++) {
auto cmp = [&](int i, int j) { return xs[i] + ys[i] < xs[j] + ys[j]; };
std::sort(idx.begin(), idx.end(), cmp);
std::map<T, int> sweep;
for (int i : idx) {
for (auto it = sweep.lower_bound(-ys[i]); it != sweep.end(); it = sweep.erase(it)) {
int j = it->second;
if (xs[i] - xs[j] < ys[i] - ys[j]) break;
ret.emplace_back(std::abs(xs[i] - xs[j]) + std::abs(ys[i] - ys[j]), i, j);
}
sweep[-ys[i]] = i;
}
std::swap(xs, ys);
}
for (auto& x : xs) x = -x;
}
std::sort(ret.begin(), ret.end());
return ret;
}
#line 1 "library/graph/shortest_path.hpp"
#include <algorithm>
#include <cassert>
#include <limits>
#include <queue>
#include <vector>
template <typename weight>
struct shortest_path {
const weight unreachable = std::numeric_limits<weight>::max();
shortest_path() : _computed(false) {}
shortest_path(const int& n, const int& m = 0) : _n(n), _computed(false) {
if (m) _edges.reserve(m);
}
void set_number(const int& n, const int& m = 0) {
_n = n;
if (m) _edges.reserve(m);
}
void add_edge(const int& i, const int& j, const weight& w) {
assert(0 <= i && i < _n);
assert(0 <= j && j < _n);
_edges.emplace_back(i, j, w);
}
void compute(const int& s) {
_s = s;
_computed = true;
_adj.resize(_n);
for (auto&& e : _edges) {
auto [u, v, w] = e;
_adj[u].emplace_back(v, w);
}
_dist.resize(_n);
std::fill(_dist.begin(), _dist.end(), unreachable);
_par.resize(_n);
std::fill(_par.begin(), _par.end(), -1);
// select best algorithm
if (!std::is_integral<weight>::value) {
_dijkstra(s);
return;
}
for (auto&& [_, __, cost] : _edges) {
if (cost >= 2) {
_dijkstra(s);
return;
}
}
for (auto&& [_, __, cost] : _edges) {
if (cost == 0) {
_bfs01(s);
return;
}
}
_bfs(s);
}
int s() {
assert(_computed);
return _s;
}
std::vector<weight> dist() {
assert(_computed);
return _dist;
}
weight dist(const int& t) {
assert(_computed);
return _dist[t];
}
std::vector<int> path(int t) {
assert(_computed);
assert(0 <= t && t < _n);
assert(_dist[t] != unreachable);
std::vector<int> ret;
while (t != _s) {
ret.push_back(t);
t = _par[t];
}
ret.push_back(_s);
std::reverse(ret.begin(), ret.end());
return ret;
}
private:
// input values
int _n;
int _s;
std::vector<std::tuple<int, int, weight>> _edges;
// computed values
bool _computed;
std::vector<std::vector<std::pair<int, weight>>> _adj;
std::vector<weight> _dist;
std::vector<int> _par;
void _bfs(const int& s) {
std::queue<int> que;
que.emplace(s);
_dist[s] = 0;
while (!que.empty()) {
auto v = que.front();
que.pop();
for (auto&& [to, _] : _adj[v]) {
if (_dist[to] == unreachable) {
_dist[to] = _dist[v] + 1;
_par[to] = v;
que.emplace(to);
}
}
}
}
void _bfs01(const int& s) {
std::deque<int> que;
_dist[s] = 0;
que.emplace_back(s);
while (!que.empty()) {
auto v = que.front();
que.pop_front();
for (auto&& [to, cost] : _adj[v]) {
weight d = _dist[v] + cost;
if (d < _dist[to]) {
_dist[to] = d;
_par[to] = v;
if (cost) {
que.emplace_back(to);
} else {
que.emplace_front(to);
}
}
}
}
}
void _dijkstra(const int& s) {
using que_class = std::pair<weight, int>;
std::priority_queue<que_class, std::vector<que_class>, std::greater<que_class>> que;
_dist[s] = 0;
que.emplace(0, s);
while (!que.empty()) {
auto [d, v] = que.top();
que.pop();
if (_dist[v] != d) continue;
for (auto&& [to, cost] : _adj[v]) {
if (_dist[to] <= d + cost) continue;
_dist[to] = d + cost;
_par[to] = v;
que.emplace(_dist[to], to);
}
}
}
};
#line 49 "main.cpp"
using namespace std;
using ll = long long;
using ld = long double;
void solve([[maybe_unused]] int test) {
ll N, K;
cin >> N >> K;
const int s = 0;
const int g = 1;
vector<ll> x(N + 2), y(N + 2);
for (int i = 0; i < N + 2; i++) {
cin >> x[i] >> y[i];
}
ll imin = 0;
ll imax = 3e5;
while (imax - imin > 1) {
ll imid = (imin + imax) / 2;
shortest_path<ll> sp(N + 2);
for (auto&& [w, i, j] : manhattan_mst(x, y)) {
sp.add_edge(i, j, (w - 1) / imid);
sp.add_edge(j, i, (w - 1) / imid);
}
sp.compute(s);
(sp.dist(g) != sp.unreachable && sp.dist(g) <= K ? imax : imin) = imid;
}
cout << imax << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
// cin >> t;
for (int i = 1; i <= t; i++) {
solve(i);
}
postprocess();
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0