結果
| 問題 | No.2376 障害物競プロ |
| ユーザー |
 poyon
|
| 提出日時 | 2023-07-05 23:18:44 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 379 ms / 4,000 ms |
| コード長 | 22,316 bytes |
| コンパイル時間 | 3,420 ms |
| コンパイル使用メモリ | 227,088 KB |
| 実行使用メモリ | 5,376 KB |
| 最終ジャッジ日時 | 2024-07-19 17:47:56 |
| 合計ジャッジ時間 | 52,047 ms |
|
ジャッジサーバーID （参考情報） |
judge1 / judge3 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
5,248 KB |
| testcase_01 | AC | 2 ms
5,376 KB |
| testcase_02 | AC | 2 ms
5,376 KB |
| testcase_03 | AC | 2 ms
5,376 KB |
| testcase_04 | AC | 219 ms
5,376 KB |
| testcase_05 | AC | 287 ms
5,376 KB |
| testcase_06 | AC | 110 ms
5,376 KB |
| testcase_07 | AC | 325 ms
5,376 KB |
| testcase_08 | AC | 331 ms
5,376 KB |
| testcase_09 | AC | 311 ms
5,376 KB |
| testcase_10 | AC | 307 ms
5,376 KB |
| testcase_11 | AC | 250 ms
5,376 KB |
| testcase_12 | AC | 222 ms
5,376 KB |
| testcase_13 | AC | 327 ms
5,376 KB |
| testcase_14 | AC | 313 ms
5,376 KB |
| testcase_15 | AC | 293 ms
5,376 KB |
| testcase_16 | AC | 297 ms
5,376 KB |
| testcase_17 | AC | 241 ms
5,376 KB |
| testcase_18 | AC | 215 ms
5,376 KB |
| testcase_19 | AC | 313 ms
5,376 KB |
| testcase_20 | AC | 342 ms
5,376 KB |
| testcase_21 | AC | 326 ms
5,376 KB |
| testcase_22 | AC | 265 ms
5,376 KB |
| testcase_23 | AC | 167 ms
5,376 KB |
| testcase_24 | AC | 207 ms
5,376 KB |
| testcase_25 | AC | 105 ms
5,376 KB |
| testcase_26 | AC | 269 ms
5,376 KB |
| testcase_27 | AC | 208 ms
5,376 KB |
| testcase_28 | AC | 107 ms
5,376 KB |
| testcase_29 | AC | 101 ms
5,376 KB |
| testcase_30 | AC | 83 ms
5,376 KB |
| testcase_31 | AC | 116 ms
5,376 KB |
| testcase_32 | AC | 15 ms
5,376 KB |
| testcase_33 | AC | 39 ms
5,376 KB |
| testcase_34 | AC | 56 ms
5,376 KB |
| testcase_35 | AC | 41 ms
5,376 KB |
| testcase_36 | AC | 169 ms
5,376 KB |
| testcase_37 | AC | 243 ms
5,376 KB |
| testcase_38 | AC | 90 ms
5,376 KB |
| testcase_39 | AC | 226 ms
5,376 KB |
| testcase_40 | AC | 54 ms
5,376 KB |
| testcase_41 | AC | 88 ms
5,376 KB |
| testcase_42 | AC | 359 ms
5,376 KB |
| testcase_43 | AC | 379 ms
5,376 KB |
ソースコード
// A〜H を通しで解いて確認中
// clang-format off
#ifdef _LOCAL
#include <pch.hpp>
#else
#include <bits/stdc++.h>
#define cerr if (false) cerr
#define debug_bar
#define debug(...)
#define debug2(vv)
#define debug3(vvv)
#endif
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using P = pair<ll,ll>;
using VP = vector<P>;
using VVP = vector<VP>;
using VC = vector<char>;
using VS = vector<string>;
using VVS = vector<VS>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
using VLL = vector<ll>;
using VVLL = vector<VLL>;
using VVVLL = vector<VVLL>;
using VB = vector<bool>;
using VVB = vector<VB>;
using VVVB = vector<VVB>;
using VD = vector<double>;
using VVD = vector<VD>;
using VVVD = vector<VVD>;
#define FOR(i,l,r) for (ll i = (l); i < (r); ++i)
#define RFOR(i,l,r) for (ll i = (r)-1; (l) <= i; --i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define FORE(e,c) for (auto&& e : c)
#define ALL(c) (c).begin(), (c).end()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define MIN(c) *min_element(ALL(c))
#define MAX(c) *max_element(ALL(c))
#define COUNT(c,v) count(ALL(c),(v))
#define len(c) ((ll)(c).size())
#define BIT(b,i) (((b)>>(i)) & 1)
#define PCNT(b) ((ll)__builtin_popcountll(b))
#define LB(c,v) distance((c).begin(), lower_bound(ALL(c), (v)))
#define UB(c,v) distance((c).begin(), upper_bound(ALL(c), (v)))
#define UQ(c) do { SORT(c); (c).erase(unique(ALL(c)), (c).end()); (c).shrink_to_fit(); } while (0)
#define END(...) do { print(__VA_ARGS__); exit(0); } while (0)
constexpr ld EPS = 1e-10;
constexpr ld PI = acosl(-1.0);
constexpr int inf = (1 << 30) - (1 << 15); // 1,073,709,056
constexpr ll INF = (1LL << 62) - (1LL << 31); // 4,611,686,016,279,904,256
template<class... T> void input(T&... a) { (cin >> ... >> a); }
void print() { cout << '\n'; }
template<class T> void print(const T& a) { cout << a << '\n'; }
template<class P1, class P2> void print(const pair<P1, P2>& a) { cout << a.first << " " << a.second << '\n'; }
template<class T, class... Ts> void print(const T& a, const Ts&... b) { cout << a; (cout << ... << (cout << ' ', b)); cout << '\n'; }
template<class T> void cout_line(const vector<T>& ans, int l, int r) { for (int i = l; i < r; i++) { if (i != l) { cout << ' '; } cout << ans[i]; } cout << '\n'; }
template<class T> void print(const vector<T>& a) { cout_line(a, 0, a.size()); }
template<class S, class T> bool chmin(S& a, const T b) { if (b < a) { a = b; return 1; } return 0; }
template<class S, class T> bool chmax(S& a, const T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> T SUM(const vector<T>& A) { return accumulate(ALL(A), T(0)); }
template<class T> vector<T> cumsum(const vector<T>& A, bool offset = false) { int N = A.size(); vector<T> S(N+1, 0); for (int i = 0; i < N; i++) { S[i+1] = S[i] + A[i]; } if (not offset) { S.erase(S.begin()); } return S; }
template<class T> string to_binary(T x, int B = 0) { string s; while (x) { s += ('0' + (x & 1)); x >>= 1; } while ((int)s.size() < B) { s += '0'; } reverse(s.begin(), s.end()); return s; }
template<class F> ll binary_search(const F& is_ok, ll ok, ll ng) { while (abs(ok - ng) > 1) { ll m = (ok + ng) / 2; (is_ok(m) ? ok : ng) = m; } return ok; }
template<class F> double binary_search_real(const F& is_ok, double ok, double ng, int iter = 90) { for (int i = 0; i < iter; i++) { double m = (ok + ng) / 2; (is_ok(m) ? ok : ng) = m; } return ok; }
template<class T> using PQ_max = priority_queue<T>;
template<class T> using PQ_min = priority_queue<T, vector<T>, greater<T>>;
template<class T> T pick(stack<T>& s) { assert(not s.empty()); T x = s.top(); s.pop(); return x; }
template<class T> T pick(queue<T>& q) { assert(not q.empty()); T x = q.front(); q.pop(); return x; }
template<class T> T pick_front(deque<T>& dq) { assert(not dq.empty()); T x = dq.front(); dq.pop_front(); return x; }
template<class T> T pick_back(deque<T>& dq) { assert(not dq.empty()); T x = dq.back(); dq.pop_back(); return x; }
template<class T> T pick(PQ_min<T>& pq) { assert(not pq.empty()); T x = pq.top(); pq.pop(); return x; }
template<class T> T pick(PQ_max<T>& pq) { assert(not pq.empty()); T x = pq.top(); pq.pop(); return x; }
template<class T> T pick(vector<T>& v) { assert(not v.empty()); T x = v.back(); v.pop_back(); return x; }
int to_int(const char c) { if (islower(c)) { return (c - 'a'); } if (isupper(c)) { return (c - 'A'); } if (isdigit(c)) { return (c - '0'); } assert(false); }
char to_a(const int i) { assert(0 <= i && i < 26); return ('a' + i); }
char to_A(const int i) { assert(0 <= i && i < 26); return ('A' + i); }
char to_d(const int i) { assert(0 <= i && i <= 9); return ('0' + i); }
ll min(int a, ll b) { return min((ll)a, b); }
ll min(ll a, int b) { return min(a, (ll)b); }
ll max(int a, ll b) { return max((ll)a, b); }
ll max(ll a, int b) { return max(a, (ll)b); }
ll mod(ll x, ll m) { assert(m > 0); return (x % m + m) % m; }
ll ceil(ll a, ll b) { if (b < 0) { return ceil(-a, -b); } assert(b > 0); return (a < 0 ? a / b : (a + b - 1) / b); }
ll floor(ll a, ll b) { if (b < 0) { return floor(-a, -b); } assert(b > 0); return (a > 0 ? a / b : (a - b + 1) / b); }
ll powint(ll x, ll n) { assert(n >= 0); if (n == 0) { return 1; }; ll res = powint(x, n>>1); res *= res; if (n & 1) { res *= x; } return res; }
pair<ll,ll> divmod(ll a, ll b) { assert(b != 0); ll q = floor(a, b); return make_pair(q, a - q * b); }
ll bitlen(ll b) { if (b <= 0) { return 0; } return (64LL - __builtin_clzll(b)); }
ll digitlen(ll n) { assert(n >= 0); if (n == 0) { return 1; } ll sum = 0; while (n > 0) { sum++; n /= 10; } return sum; }
ll msb(ll b) { return (b <= 0 ? -1 : (63 - __builtin_clzll(b))); }
ll lsb(ll b) { return (b <= 0 ? -1 : __builtin_ctzll(b)); }
// --------------------------------------------------------
/** NOTE: 幾何ライブラリの整数版（使えるものだけ存在） **/
// References:
// 『プログラミングコンテスト攻略のためのアルゴリズムとデータ構造』
// <https://github.com/atcoder/live_library/blob/master/geom/vector.cpp>
// <https://ei1333.github.io/luzhiled/snippets/geometry/template.html>
// <https://github.com/E869120/kyopro_educational_90/blob/main/sol/041-03.cpp>
// 点 (ベクトル)
struct Point {
ll x, y;
Point(ll x = 0, ll y = 0): x(x), y(y) {}
Point& operator+=(const Point& v) noexcept { x += v.x; y += v.y; return *this; }
Point& operator-=(const Point& v) noexcept { x -= v.x; y -= v.y; return *this; }
// Point& operator*=(ll k) noexcept { x *= k; y *= k; return *this; }
// Point& operator/=(ll k) noexcept { x /= k; y /= k; return *this; }
Point operator+(const Point& v) const noexcept { return Point(*this) += v; }
Point operator-(const Point& v) const noexcept { return Point(*this) -= v; }
// Point operator*(ll k) const noexcept { return Point(*this) *= k; }
// Point operator/(ll k) const noexcept { return Point(*this) /= k; }
ll norm() const noexcept { return x*x + y*y; } // ベクトルの大きさ
// ll abs() const noexcept { return sqrt(norm()); } // 原点からの距離，ベクトルの長さ
// pair<x, y> の要領で大小比較（x昇順 --> y昇順）
bool operator < (const Point& p) const noexcept {
return x != p.x ? x < p.x : y < p.y;
}
bool operator == (const Point& p) const noexcept {
return (x == p.x) && (y == p.y);
}
};
// 直線
struct Line {
Point p1, p2;
Line(Point p1 = Point(), Point p2 = Point()): p1(p1), p2(p2) {}
};
// 線分
struct Segment {
Point p1, p2;
Segment(Point p1 = Point(), Point p2 = Point()): p1(p1), p2(p2) {}
};
// 円
struct Circle {
Point c; // 中心
ll r; // 半径
Circle(Point c = Point(), ll r = 0): c(c), r(r) {}
};
// 三角形
struct Triangle {
Point p1, p2, p3;
Triangle(Point p1 = Point(), Point p2 = Point(), Point p3 = Point()) : p1(p1), p2(p2), p3(p3) {}
};
using Points = vector<Point>;
using Polygon = vector<Point>; // 多角形
using Segments = vector<Segment>;
using Lines = vector<Line>;
using Circles = vector<Circle>;
using Triangles = vector<Triangle>;
ll norm(const Point& a) { return a.x*a.x + a.y*a.y; } // ベクトルの大きさ
// ll abs(const Point& a) { return sqrt(norm(a)); } // 原点からの距離，ベクトルの長さ
ll dot(const Point& a, const Point& b) { return a.x*b.x + a.y*b.y; } // 内積
ll cross(const Point& a, const Point& b) { return a.x*b.y - a.y*b.x; } // 外積
// 直交判定 (直線)
bool is_orthogonal(const Line& a, const Line& b) {
return (dot(a.p1 - a.p2, b.p1 - b.p2) == 0);
}
// 直交判定 (線分)
// ※ 線分の交差判定を先に行う必要あり --> is_intersected()
bool is_orthogonal(const Segment& a, const Segment& b) {
return (dot(a.p1 - a.p2, b.p1 - b.p2) == 0);
}
// 平行判定 (直線)
bool is_parallel(const Line& a, const Line& b) {
return (cross(a.p1 - a.p2, b.p1 - b.p2) == 0);
}
// 平行判定 (線分)
bool is_parallel(const Segment& a, const Segment& b) {
return (cross(a.p1 - a.p2, b.p1 - b.p2) == 0);
}
constexpr int COUNTER_CLOCKWISE = 1; // 反時計回り (左回り)
constexpr int CLOCKWISE = -1; // 時計回り (右回り)
constexpr int ONLINE_BACK = 2; // 線分後方
constexpr int ONLINE_FRONT = -2; // 線分前方
constexpr int ON_SEGMENT = 0; // 線分上
// 3点 p0,p1,p2 の位置関係を線分 p1 - p0 を基準にして求める
int ccw(const Point& p0, const Point& p1, const Point& p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > 0) return COUNTER_CLOCKWISE; // p0 -> p1, 反時計回りの方向に p2
if (cross(a, b) < 0) return CLOCKWISE; // p0 -> p1, 時計回りの方向に p2
if (dot(a, b) < 0) return ONLINE_BACK; // p2 -> p0 -> p1 の順で直線上に p2
if (a.norm() < b.norm()) return ONLINE_FRONT; // p0 -> p1 -> p2 の順で直線上に p2
return ON_SEGMENT; // p0 -> p2 -> p1 の順で線分上に p2
}
// 線分の交差判定
// 端点だけ重なる場合や平行に重なる場合も交差しているとみなす
bool is_intersected(const Point& p1, const Point& p2, const Point& p3, const Point& p4) {
return (ccw(p1,p2,p3) * ccw(p1,p2,p4) <= 0) && (ccw(p3,p4,p1) * ccw(p3,p4,p2) <= 0);
}
// 線分の交差判定
// 端点だけ重なる場合や平行に重なる場合も交差しているとみなす
bool is_intersected(const Segment& s1, const Segment& s2) {
return is_intersected(s1.p1, s1.p2, s2.p1, s2.p2);
}
// 直線と線分の交差判定
// 端点だけ重なる場合や平行に重なる場合も交差しているとみなす
bool is_intersected(const Line& l, const Segment& s) {
return (ccw(l.p1, l.p2, s.p1) * ccw(l.p1, l.p2, s.p2) <= 0);
}
// 線分上に点が存在するか判定
bool on_segment(const Segment& s, const Point& p) {
return ccw(s.p1, s.p2, p) == ON_SEGMENT;
}
// 円周上に点が存在するか判定
bool on_circle(const Circle& c, const Point& p) {
auto dx = c.c.x - p.x;
auto dy = c.c.y - p.y;
return dx * dx + dy * dy == c.r * c.r;
}
// 円内部に点が存在するか判定
// 円周上に点が存在する場合は false を返す
bool in_circle(const Circle& c, const Point& p) {
auto dx = c.c.x - p.x;
auto dy = c.c.y - p.y;
return dx * dx + dy * dy < c.r * c.r;
}
// 円における点の内包判定
// 0: 外側, 1: 円周上, 2: 内側
int point_containment(const Circle& c, const Point& p) {
if (in_circle(c, p)) { return 2; }
if (on_circle(c, p)) { return 1; }
return 0;
}
// 円の交差判定
// 2つの円の共通接線の数を計算する
// 4本: 離れている
// 3本: 外接
// 2本: 2点交差
// 1本: 内接
// 0本: 内包
int circle_intersection(const Circle& c1, const Circle& c2) {
auto dx = c1.c.x - c2.c.x;
auto dy = c1.c.y - c2.c.y;
ll d2 = dx * dx + dy * dy;
ll r2 = (c1.r - c2.r) * (c1.r - c2.r);
ll R2 = (c1.r + c2.r) * (c1.r + c2.r);
if (R2 < d2) { return 4; }
if (R2 == d2) { return 3; }
if (r2 < d2) { return 2; }
if (r2 == d2) { return 1; }
return 0;
}
// 円の交差判定
// 外接・2点交差・内接の場合に交差していると判定する
bool is_intersected(const Circle& c1, const Circle& c2) {
int n = circle_intersection(c1, c2);
return (n == 3 || n == 2 || n == 1);
}
// 三角形の (2 * 符号付き面積) を求める
// - 符号： 頂点列が反時計回りの場合は正、時計回りの場合は負
ll area_of_triangle(const Point& A, const Point& B, const Point& C) {
ll area = cross(B - A, C - A);
return area;
// return area / 2;
}
// 三角形の (2 * 符号付き面積) を求める
// - 符号： 頂点列が反時計回りの場合は正、時計回りの場合は負
ll area_of_triangle(const Triangle& t) {
return area_of_triangle(t.p1, t.p2, t.p3);
}
// 3 点が同一直線上にあるか判定する
bool are_on_same_line(const Point& p1, const Point& p2, const Point& p3) {
return abs(ccw(p1, p2, p3)) != 1;
}
// 多角形の (2 * 符号付き面積) を求める
// - 3 ≦ 頂点数
// - 符号： 頂点列が反時計回りの場合は正、時計回りの場合は負
// - 多角形が自己交差していないことを想定
// <https://ja.wikipedia.org/wiki/%E5%A4%9A%E8%A7%92%E5%BD%A2>
ll area_of_polygon(const Polygon& P) {
int N = P.size();
assert(3 <= N);
ll area = 0;
for (int i = 0; i < N; i++) {
area += cross(P[i], P[(i+1) % N]); // N番目の次は1番目
}
return area;
// return area / 2;
}
// 凸性判定 (多角形が凸多角形であるか判定)
// - 3 ≦ 頂点数
// - 頂点列が反時計回りであることを想定
// - 多角形が自己交差していないことを想定
bool is_convex(const Polygon& P) {
int N = P.size();
assert(3 <= N);
for (int i = 0; i < N; i++) {
if (ccw(P[(i-1+N) % N], P[i], P[(i+1+N) % N]) == CLOCKWISE) return false;
}
return true;
}
// 多角形における点の内包判定
// - 0: 外側, 1: 線分上, 2: 内側
int point_containment(const Polygon& g, const Point& p) {
int N = g.size();
bool x = false;
for (int i = 0; i < N; i++) {
Point a = g[i] - p;
Point b = g[(i+1) % N] - p; // N番目の次は1番目
if (cross(a, b) == 0 && dot(a, b) <= 0) return 1; // 線分上
if (a.y > b.y) swap(a, b);
if (a.y <= 0 && 0 < b.y && cross(a, b) > 0) x = !x; // 半直線との交差回数の偶奇
}
return (x ? 2 : 0);
}
// 凸包を求める (Andrew's Monotone Chain)
// - O(N log N)
// - 下記が満たされていることを想定
// - 3 ≦ 頂点数
// - 全点が一つの直線上に存在しない
// are_on_same_line(P[0],P[1],P[2..N-1]) を確認すれば判定可能
// - on_edge: 凸包の辺上の点を含めるか
// - 凸包の頂点の順序は最も左の頂点から反時計回り (左回り)
Polygon convex_hull(Polygon P, bool on_edge = true) {
int N = P.size();
assert(3 <= N);
sort(P.begin(), P.end()); // x昇順 --> y昇順
Polygon ch(2*N,{-1,-1});
int k = 0;
if (on_edge) {
// 上包 (upper hull)
for (int i = 0; i < N; ch[k++] = P[i++]) {
while (k >= 2 && ccw(ch[k-2], ch[k-1], P[i]) == COUNTER_CLOCKWISE) k--;
}
// 下包 (lower hull)
const int t = k + 1;
for (int i = N-2; 0 <= i; ch[k++] = P[i--]) {
while (k >= t && ccw(ch[k-2], ch[k-1], P[i]) == COUNTER_CLOCKWISE) k--;
}
} else {
// 上包 (upper hull)
for (int i = 0; i < N; ch[k++] = P[i++]) {
while (k >= 2 && ccw(ch[k-2], ch[k-1], P[i]) != CLOCKWISE) k--;
}
// 下包 (lower hull)
const int t = k + 1;
for (int i = N-2; 0 <= i; ch[k++] = P[i--]) {
while (k >= t && ccw(ch[k-2], ch[k-1], P[i]) != CLOCKWISE) k--;
}
}
ch.resize(k-1);
/** TODO: 最初から反時計回りで計算 **/
reverse(ch.begin() + 1, ch.end()); // 反時計回りに変換
return ch;
}
// 最近点対間距離 (の 2 乗) を求める
// - O(N log N)
ll closest_pair(Points P) {
int N = P.size();
assert(2 <= N);
sort(P.begin(), P.end());
auto compare_y = [](const Point& a, const Point& b) -> bool { return a.y < b.y; };
constexpr ll INF = numeric_limits<ll>::max();
Points B(N); // x座標を左右に分ける直線付近の点集合を保管用に使い回す配列
auto rec = [&](auto&& self, int l, int r) -> ll {
if (r - l <= 1) { return INF; }
int m = (l + r) / 2; // x座標を左右に分ける直線のインデックス
ll x_m = P[m].x; // x座標を左右に分ける直線のx座標
ll d = min(self(self, l, m), self(self, m, r)); // 最近点対間距離
inplace_merge(P.begin() + l, P.begin() + m, P.begin() + r, compare_y);
int k = 0;
for (int i = l; i < r; i++) {
if ((P[i].x - x_m) * (P[i].x - x_m) >= d) { continue; }
for (int j = k - 1; 0 <= j; j--) {
ll dx = P[i].x - B[j].x;
ll dy = P[i].y - B[j].y;
if (dy*dy >= d) { break; }
d = min(d, dx*dx + dy*dy);
}
B[k++] = P[i];
}
return d;
};
return rec(rec, 0, N);
}
// 多角形の頂点列が反時計回りか判定する
// - 符号付き面積の正負で判定する
bool is_counter_clockwise(const Polygon& P) {
return area_of_polygon(P) > 0;
}
// 三角形の頂点列が反時計回りか判定する
// - 符号付き面積の正負で判定する
bool is_counter_clockwise(const Triangle& t) {
return area_of_triangle(t) > 0;
}
// 三角形における点の内包判定
// - 0: 外側, 1: 線分上, 2: 内側
int point_containment(const Triangle& t, const Point& p) {
int c12 = ccw(t.p1, t.p2, p);
int c23 = ccw(t.p2, t.p3, p);
int c31 = ccw(t.p3, t.p1, p);
if (c12 == 0 || c23 == 0 || c31 == 0) { return 1; } // 辺上
if (c12 == +1 && c23 == +1 && c31 == +1) { return 2; } // 時計回り
if (c12 == -1 && c23 == -1 && c31 == -1) { return 2; } // 反時計回り
return 0;
}
// 多角形 P において三角形 (P[l],P[m],P[r]) が耳であるか判定する
bool is_ear(const Polygon& P, int l, int m, int r) {
Triangle t(P[l], P[m], P[r]);
// 明らかに ear でないケースを除外（この 3 点が mouth or 一直線）
if (ccw(t.p1, t.p2, t.p3) <= 0) { return false; }
int N = P.size();
for (int i = 0; i < N; i++) {
if (i == l || i == m || i == r) { continue; }
if (point_containment(t, P[i])) { continue; }
}
return true;
}
// 単純多角形を三角形分割する（耳分解）
// - 3 ≦ 頂点数
// - 頂点列が反時計回りであることを想定
// - O(N^2) : ear clipping method によるナイーブな実装
// - Reference: https://web.archive.org/web/20200222054711/http://www.prefiell.com/algorithm/geometry/triangulate.html
Triangles triangulation_of_polygon(const Polygon& P) {
int N = P.size();
assert(2 <= N);
vector<int> L(N), R(N); // 左隣・右隣
for (int i = 0; i < N; i++) {
L[i] = (i - 1 + N) % N;
R[i] = (i + 1 + N) % N;
}
Triangles ts;
int m = 0; // いま見ている３点の真ん中
while ((int)ts.size() < N-2) {
m = R[m];
while (is_ear(P, L[m], m, R[m])) {
ts.emplace_back(P[L[m]], P[m], P[R[m]]);
// 真ん中の m を闇に葬る
R[L[m]] = R[m];
L[R[m]] = L[m];
}
}
return ts;
}
// 線分上の格子点の個数を求める（端点を除く）
// - O(log ((x2 - x1) + (y2 - y1)))
ll lattice_point_of_segment(const Point& p1, const Point& p2) {
return gcd(p2.x - p1.x, p2.y - p1.y) - 1;
}
// 線分上の格子点の個数を求める（端点を除く）
// - O(log ((x2 - x1) + (y2 - y1)))
ll lattice_point_of_segment(const Segment& s) {
return lattice_point_of_segment(s.p1, s.p2);
}
// 格子点のみを頂点に持つ多角形の周上・内部の格子点の数をそれぞれ求める（ピックの定理）
// - 3 ≦ 頂点数
// - S = B/2 + I - 1
pair<ll,ll> lattice_points_of_polygon(const Polygon& P) {
int N = P.size();
ll S2 = abs(area_of_polygon(P));
ll B = N;
for (int i = 0; i < N; i++) {
B += lattice_point_of_segment(P[i], P[(i+1) % N]);
}
ll I = (S2 - B) / 2 + 1;
return make_pair(B, I);
}
void floyd_warshall(VVD& G) {
int N = G.size();
for (int k = 0; k < N; k++) {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
chmin(G[i][j], G[i][k] + G[k][j]);
}
}
}
}
// clang-format on
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
ll N, M;
input(N, M);
ll N2 = N * 2;
Points P(N2);
REP (i, N) {
ll a = 2 * i;
ll b = 2 * i + 1;
input(P[a].x, P[a].y, P[b].x, P[b].y);
}
VVD G(N2, VD(N2, INF));
REP (i, N2) { G[i][i] = 0; }
REP (a, N2) {
ll i = a / 2;
auto p1 = P[a];
FOR (b, a + 1, N2) {
ll j = b / 2;
auto p2 = P[b];
bool ok = [&]() -> bool {
REP (k, N) {
if (i == k || j == k) { continue; }
auto p3 = P[2 * k];
auto p4 = P[2 * k + 1];
if (is_intersected(p1, p2, p3, p4)) { return false; }
}
return true;
}();
if (ok) {
G[a][b] = G[b][a] = hypot(P[a].x - P[b].x, P[a].y - P[b].y);
}
}
}
floyd_warshall(G);
REP (_, M) {
ll a, b, c, d;
input(a, b, c, d);
a--;
b--;
c--;
d--;
ll s = 2 * a + b;
ll t = 2 * c + d;
auto ans = G[s][t];
print(ans);
}
return 0;
}