From 47459ea02382f6e956b61b10fb58c388404fc0df Mon Sep 17 00:00:00 2001 From: subcrip Date: Tue, 2 Jul 2024 22:52:00 +0800 Subject: [PATCH] backup --- src/bin/a.out | Bin 121448 -> 0 bytes src/bin/abc-334f.cc | 550 +++++++++++++++++++++++++++++++++++++++++++ src/bin/abc-338f.cc | 41 +++- src/bin/ctext_out.cc | 96 +++----- src/bin/std.in | 6 + src/bin/template.cc | 24 +- 6 files changed, 643 insertions(+), 74 deletions(-) delete mode 100755 src/bin/a.out create mode 100644 src/bin/abc-334f.cc diff --git a/src/bin/a.out b/src/bin/a.out deleted file mode 100755 index 204c4cda54689c95ff9aa6f8ee8016b8f35f1c15..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 121448 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 KCLT!KdjB6>=baq@ diff --git a/src/bin/abc-334f.cc b/src/bin/abc-334f.cc new file mode 100644 index 0000000..0ba95fb --- /dev/null +++ b/src/bin/abc-334f.cc @@ -0,0 +1,550 @@ +#pragma GCC diagnostic ignored "-Wunused-const-variable" +#pragma GCC diagnostic ignored "-Wreorder" +#pragma GCC diagnostic ignored "-Wunknown-pragmas" +#pragma GCC diagnostic ignored "-Wshift-op-parentheses" +#pragma GCC optimize("Ofast") +/************* This code requires C++17. ***************/ + +#include +using namespace std; + +/* macro helpers */ +#define __NARGS(...) std::tuple_size::value +#define __DECOMPOSE_S(a, x) auto x = a; +#define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; +constexpr void __() {} +#define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() +#define __as_typeof(container) remove_reference::type + +/* type aliases */ +#if LONG_LONG_MAX != INT64_MAX +using ll = int64_t; +using ull = uint64_t; +#else +using ll = long long; +using ull = unsigned long long; +#endif +using int128 = __int128_t; +using uint128 = __uint128_t; +using ld = long double; +using pii = pair; using pil = pair; using pid = pair; +using pli = pair; using pll = pair; using pld = pair; +using pdi = pair; using pdl = pair; using pdd = pair; +using tiii = tuple; using tiil = tuple; using tiid = tuple; +using tili = tuple; using till = tuple; using tild = tuple; +using tidi = tuple; using tidl = tuple; using tidd = tuple; +using tlii = tuple; using tlil = tuple; using tlid = tuple; +using tlli = tuple; using tlll = tuple; using tlld = tuple; +using tldi = tuple; using tldl = tuple; using tldd = tuple; +using tdii = tuple; using tdil = tuple; using tdid = tuple; +using tdli = tuple; using tdll = tuple; using tdld = tuple; +using tddi = tuple; using tddl = tuple; using tddd = tuple; +template using max_heap = priority_queue; +template using min_heap = priority_queue, greater<>>; +template using oi = ostream_iterator; +template using ii = istream_iterator; + +/* constants */ +constexpr int INF = 0x3f3f3f3f; +constexpr ll INFLL = 0x3f3f3f3f3f3f3f3fLL; +constexpr ll MDL = 1e9 + 7; +constexpr ll PRIME = 998'244'353; +constexpr ll MDL1 = 8784491; +constexpr ll MDL2 = PRIME; +constexpr int128 INT128_MAX = numeric_limits::max(); +constexpr uint128 UINT128_MAX = numeric_limits::max(); +constexpr int128 INT128_MIN = numeric_limits::min(); +constexpr uint128 UINT128_MIN = numeric_limits::min(); + +/* random */ + +mt19937 rd(chrono::duration_cast(chrono::system_clock::now().time_since_epoch()).count()); + +/* bit-wise operations */ +#define lowbit(x) ((x) & -(x)) +#define popcount(x) (__builtin_popcountll(ll(x))) +#define parity(x) (__builtin_parityll(ll(x))) +#define msp(x) (63LL - __builtin_clzll(ll(x))) +#define lsp(x) (__builtin_ctzll(ll(x))) + +/* arithmetic operations */ +#define mod(x, y) ((((x) % (y)) + (y)) % (y)) + +/* fast pairs */ +#define upair ull +#define umake(x, y) (ull(x) << 32 | (ull(y) & ((1ULL << 32) - 1))) +#define u1(p) ((p) >> 32) +#define u2(p) ((p) & ((1ULL << 32) - 1)) +#define ult std::less +#define ugt std::greater + +#define ipair ull +#define imake(x, y) (umake(x, y)) +#define i1(p) (int(u1(ll(p)))) +#define i2(p) (ll(u2(p) << 32) >> 32) +struct ilt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) < i2(b); + else return i1(a) < i1(b); + } +}; +struct igt { + bool operator()(const ipair& a, const ipair& b) const { + if (i1(a) == i1(b)) return i2(a) > i2(b); + else return i1(a) > i1(b); + } +}; + +/* conditions */ +#define loop while (1) +#define if_or(var, val) if (!(var == val)) var = val; else +#define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) +#define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) + +/* hash */ +struct safe_hash { + // https://codeforces.com/blog/entry/62393 + static uint64_t splitmix64(uint64_t x) { + // http://xorshift.di.unimi.it/splitmix64.c + x += 0x9e3779b97f4a7c15; + x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; + x = (x ^ (x >> 27)) * 0x94d049bb133111eb; + return x ^ (x >> 31); + } + + size_t operator()(uint64_t x) const { + static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count(); + return splitmix64(x + FIXED_RANDOM); + } +}; + +struct pair_hash { + template + size_t operator()(const pair& a) const { + auto hash1 = safe_hash()(a.first); + auto hash2 = safe_hash()(a.second); + if (hash1 != hash2) { + return hash1 ^ hash2; + } + return hash1; + } +}; + +uniform_int_distribution dist(PRIME); +const size_t __array_hash_b = 31, __array_hash_mdl1 = dist(rd), __array_hash_mdl2 = dist(rd); +struct array_hash { + template + size_t operator()(const Sequence& arr) const { + size_t pw1 = 1, pw2 = 1; + size_t res1 = 0, res2 = 0; + for (auto&& x : arr) { + res1 = (res1 + x * pw1) % __array_hash_mdl1; + res2 = (res2 + x * pw2) % __array_hash_mdl2; + pw1 = (pw1 * __array_hash_b) % __array_hash_mdl1; + pw2 = (pw2 * __array_hash_b) % __array_hash_mdl2; + } + return res1 + res2; + } +}; + +/* build data structures */ +#define faster(um) __AS_PROCEDURE((um).reserve(1024); (um).max_load_factor(0.25);) +#define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t, safe_hash> to; for (auto&& x : from) ++to[x];) +#define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) +#define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) +#define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) +#define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) +#define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) +#define edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w), ch[v].emplace_back(u, w);) +#define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) +#define Edgew(ch, u, v, w) __AS_PROCEDURE(ch[u].emplace_back(v, w);) +template pair> discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} +template pair> unordered_discretize(Iterator __first, Iterator __last) { + set st(__first, __last); + size_t N = 0; + unordered_map mp; + for (auto&& x : st) mp[x] = ++N; + return {N, mp}; +} + +/* io */ +#define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) +template istream& operator>>(istream& in, pair& p) { + return in >> p.first >> p.second; +} +template ostream& operator<<(ostream& out, const pair& p) { + out << "{" << p.first << ", " << p.second << "}"; + return out; +} +template +void print_tuple_impl(std::basic_ostream& os, const Tuple& t, std::index_sequence) { + using swallow = int[]; // guaranties left to right order + (void)swallow { 0, (void(os << (Index == 0 ? "" : ", ") << std::get(t)), 0)... }; +} +template +decltype(auto) operator<<(std::basic_ostream& os, const std::tuple& t) { + os << "{"; + print_tuple_impl(os, t, std::index_sequence_for{}); + return os << "}"; +} +template ostream& operator<<(ostream& out, const vector& vec) { + for (auto&& i : vec) out << i << ' '; + return out; +} +std::ostream& operator<<(std::ostream& dest, const int128& value) { + // https://stackoverflow.com/a/25115163/23881100 + std::ostream::sentry s( dest ); + if ( s ) { + uint128 tmp = value < 0 ? -value : value; + char buffer[ 128 ]; + char* d = std::end( buffer ); + do { + -- d; + *d = "0123456789"[ tmp % 10 ]; + tmp /= 10; + } while ( tmp != 0 ); + if ( value < 0 ) { + -- d; + *d = '-'; + } + int len = std::end( buffer ) - d; + if ( dest.rdbuf()->sputn( d, len ) != len ) { + dest.setstate( std::ios_base::badbit ); + } + } + return dest; +} +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(cin), (n), a.begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) + +/* pops */ +#define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) +#define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) +#define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) + +/* math */ +template +return_t qpow(ll b, ll p) { + if (b == 0 and p != 0) return 0; + if (p == 0) return 1; + return_t half = qpow(b, p / 2); + if (p % 2 == 1) return half * half * b; + else return half * half; +} + +#define comb(n, k) ((n) < 0 or (k) < 0 or (n) < (k) ? 0 : fact[n] / fact[k] / fact[(n) - (k)]) + +constexpr inline int lg2(ll x) { return x == 0 ? -1 : sizeof(ll) * 8 - 1 - __builtin_clzll(x); } + +void __exgcd(ll a, ll b, ll& x, ll& y) { + if (b == 0) { + x = 1, y = 0; + return; + } + __exgcd(b, a % b, y, x); + y -= a / b * x; +} + +ll inverse(ll a, ll b) { + ll x, y; + __exgcd(a, b, x, y); + return mod(x, b); +} + +vector> decompose(ll x) { + // return (factor, count, factor ** count) + vector> res; + for (int i = 2; i * i <= x; i++) { + if (x % i == 0) { + int cnt = 0; + ll pw = 1; + while (x % i == 0) ++cnt, x /= i, pw *= i; + res.emplace_back(i, cnt, pw); + } + } + if (x != 1) { + res.emplace_back(x, 1, x); + } + return res; +} + +vector decompose_prime(int N) { + // return (factor, count) + vector result; + for (int i = 2; i * i <= N; i++) { + if (N % i == 0) { + int cnt = 0; + while (N % i == 0) N /= i, ++cnt; + result.emplace_back(i, cnt); + } + } + if (N != 1) { + result.emplace_back(N, 1); + } + return result; +} + +/* string algorithms */ +vector calc_next(string t) { // pi function of t + int n = (int)t.length(); + vector pi(n); + for (int i = 1; i < n; i++) { + int j = pi[i - 1]; + while (j > 0 && t[i] != t[j]) j = pi[j - 1]; + if (t[i] == t[j]) j++; + pi[i] = j; + } + return pi; +} +vector calc_z(string t) { // z function of t + int m = t.length(); + vector z; + z.push_back(m); + pair prev = {1, -1}; + for (int i = 1; i < m; ++i) { + if (z[i - prev.first] + i <= prev.second) { + z.push_back(z[i - prev.first]); + } else { + int j = max(i, prev.second + 1); + while (j < m && t[j] == t[j - i]) ++j; + z.push_back(j - i); + prev = {i, j - 1}; + } + } + return z; +} +vector kmp(string s, string t) { // find all t in s + string cur = t + '#' + s; + int sz1 = s.size(), sz2 = t.size(); + vector v; + vector lps = calc_next(cur); + for (int i = sz2 + 1; i <= sz1 + sz2; i++) { + if (lps[i] == sz2) v.push_back(i - 2 * sz2); + } + return v; +} +int period(string s) { // find the length of shortest recurring period + int n = s.length(); + auto z = calc_z(s); + for (int i = 1; i <= n / 2; ++i) { + if (n % i == 0 && z[i] == n - i) { + return i; + } + } + return n; +} + +/* modular arithmetic */ +template struct MLL { + ll val; + MLL(ll v = 0) : val(mod(v, mdl)) {} + MLL(const MLL& other) : val(other.val) {} + friend MLL operator+(const MLL& lhs, const MLL& rhs) { return mod(lhs.val + rhs.val, mdl); } + friend MLL operator-(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - rhs.val, mdl); } + friend MLL operator*(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * rhs.val, mdl); } + friend MLL operator/(const MLL& lhs, const MLL& rhs) { return mod(lhs.val * mod(inverse(rhs.val, mdl), mdl), mdl); } + friend MLL operator%(const MLL& lhs, const MLL& rhs) { return mod(lhs.val - (lhs / rhs).val, mdl); } + friend bool operator==(const MLL& lhs, const MLL& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLL& lhs, const MLL& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLL& rhs) { val = (*this + rhs).val; } + void operator-=(const MLL& rhs) { val = (*this - rhs).val; } + void operator*=(const MLL& rhs) { val = (*this * rhs).val; } + void operator/=(const MLL& rhs) { val = (*this / rhs).val; } + void operator%=(const MLL& rhs) { val = (*this % rhs).val; } +}; +struct MLLd { + ll val, mdl; + MLLd(ll mdl, ll v = 0) : mdl(mdl), val(mod(v, mdl)) {} + MLLd(const MLLd& other) : mdl(other.mdl), val(other.val) {} + friend MLLd operator+(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val + rhs.val, lhs.mdl)); } + friend MLLd operator-(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - rhs.val, lhs.mdl)); } + friend MLLd operator*(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * rhs.val, lhs.mdl)); } + friend MLLd operator/(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val * mod(inverse(rhs.val, lhs.mdl), lhs.mdl), lhs.mdl)); } + friend MLLd operator%(const MLLd& lhs, const MLLd& rhs) { return MLLd(lhs.mdl, mod(lhs.val - (lhs / rhs).val, lhs.mdl)); } + friend bool operator==(const MLLd& lhs, const MLLd& rhs) { return lhs.val == rhs.val; } + friend bool operator!=(const MLLd& lhs, const MLLd& rhs) { return lhs.val != rhs.val; } + void operator+=(const MLLd& rhs) { val = (*this + rhs).val; } + void operator-=(const MLLd& rhs) { val = (*this - rhs).val; } + void operator*=(const MLLd& rhs) { val = (*this * rhs).val; } + void operator/=(const MLLd& rhs) { val = (*this / rhs).val; } + void operator%=(const MLLd& rhs) { val = (*this % rhs).val; } +}; + +template +ostream& operator<<(ostream& out, const MLL& num) { + return out << num.val; +} + +ostream& operator<<(ostream& out, const MLLd& num) { + return out << num.val; +} + +template +istream& operator>>(istream& in, MLL& num) { + return in >> num.val; +} + +istream& operator>>(istream& in, MLLd& num) { + return in >> num.val; +} + +// miscancellous +template +bool chmax(T& lhs, const U& rhs) { + bool ret = lhs < rhs; + if (ret) { + lhs = rhs; + } + return ret; +} +template +bool chmin(T& lhs, const U& rhs) { + bool ret = lhs > rhs; + if (ret) { + lhs = rhs; + } + return ret; +} + +#define functor(func) [&](auto&&... val) \ +noexcept(noexcept(func(std::forward(val)...))) -> decltype(auto) \ +{return func(std::forward(val)...);} +template void sort_by_key(RandomIt first, RandomIt last, Func extractor) { + std::sort(first, last, [&] (auto&& a, auto&& b) { return std::less<>()(extractor(a), extractor(b)); }); +} +template void sort_by_key(RandomIt first, RandomIt last, Func extractor, Compare comp) { + std::sort(first, last, [&] (auto&& a, auto&& b) { return comp(extractor(a), extractor(b)); }); +} +template +vector> zip(Iterator_T a_first, Iterator_T a_last, Iterator_U b_first, Iterator_U b_last) { + vector> res; + auto a_it = a_first; + auto b_it = b_first; + for (; not (a_it == a_last) and not (b_it == b_last); ++a_it, ++b_it) { + res.emplace_back(*a_it, *b_it); + } + return res; +} +template +vector> zip_n(Iterator_T a_first, Iterator_U b_first, size_t n) { + vector> res; + if (n > 0) { + res.emplace_back(*a_first, *b_first); + for (size_t i = 1; i != n; ++i) { + res.emplace_back(*++a_first, *++b_first); + } + } + return res; +} +template +class ArithmeticIterator : bidirectional_iterator_tag { +public: + using difference_type = ptrdiff_t; + using value_type = T; +private: + value_type value; +public: + ArithmeticIterator(const T& value) : value(value) {} + value_type operator*() const { return value; } + ArithmeticIterator& operator++() { ++value; return *this; } + ArithmeticIterator& operator--() { --value; return *this; } + bool operator==(const ArithmeticIterator& rhs) const { return value == rhs.value; } +}; +template vector> enumerate(const vector& container) { + return zip(ArithmeticIterator(0), ArithmeticIterator(INT_MAX), container.begin(), container.end()); +} +#define initarray(init, N) (__initarray::type, (N)>(init)) +template +array __initarray(const T& init) { + array res; + for (size_t i = 0; i < N; ++i) { + res[i] = init; + } + return res; +} +/*******************************************************/ + +#define SINGLE_TEST_CASE +// #define DUMP_TEST_CASE 7219 +// #define TOT_TEST_CASE 10000 + +void dump() {} + +void dump_ignore() {} + +void prep() { +} + +ld distance(const pii& p1, const pii& p2) { + auto [x1, y1] = p1; + auto [x2, y2] = p2; + return sqrt(ld(1) * (x2 - x1) * (x2 - x1) + ld(1) * (y2 - y1) * (y2 - y1)); +} + +void solve() { + read(int, n, k); + read(pii, s); + vector a(n); + read(pii, prev); + ld tot = distance(s, prev); + for (int i = 1; i < n; ++i) { + read(pii, curr); + tot += distance(prev, curr); + a[i] = distance(s, prev) + distance(s, curr) - distance(prev, curr); + prev = curr; + } + tot += distance(s, prev); + + min_heap pq; + pq.emplace(0, 0); + for (int i = 1; i < n; ++i) { + pq.emplace(pq.top().first + a[i], i); + while (pq.size() and pq.top().second < i + 1 - k) { + pq.pop(); + } + } + + cout << setprecision(50) << tot + pq.top().first << endl; +} + +int main() { +#if __cplusplus < 201402L or defined(_MSC_VER) and not defined(__clang__) + assert(false && "incompatible compiler variant detected."); +#endif + untie; + prep(); +#ifdef SINGLE_TEST_CASE + solve(); +#else + read(int, t); + for (int i = 0; i < t; ++i) { +#ifdef DUMP_TEST_CASE + if (t != (TOT_TEST_CASE)) { + solve(); + } else if (i + 1 == (DUMP_TEST_CASE)) { + dump(); + } else { + dump_ignore(); + } +#else + solve(); +#endif + } +#endif +} diff --git a/src/bin/abc-338f.cc b/src/bin/abc-338f.cc index c12e5e6..f5155f9 100644 --- a/src/bin/abc-338f.cc +++ b/src/bin/abc-338f.cc @@ -480,7 +480,7 @@ array __initarray(const T& init) { } /*******************************************************/ -// #define SINGLE_TEST_CASE +#define SINGLE_TEST_CASE // #define DUMP_TEST_CASE 7219 // #define TOT_TEST_CASE 10000 @@ -492,6 +492,45 @@ void prep() { } void solve() { + read(int, n, m); + vector dp(1 << n + 5, INF); + vector> e(n + 1); + while (m--) { + read(int, u, v, w); + --u, --v; + Edgew(e, u, v, w); + } + + auto dfs = [&] (auto dfs, int state) -> void { + int v = state & ((1 << 5) - 1); + int mask = state >> 5; + for (auto&& [u, w] : e[v]) { + int new_state = (mask | 1 << u) << 5 | u; + if (dp[new_state] <= w + dp[state]) { + ;; + } else { + dp[new_state] = w + dp[state]; + dfs(dfs, new_state); + } + } + }; + + for (int i = 0; i < n; ++i) { + Edgew(e, n, i, 0); + } + dp[n] = 0; + dfs(dfs, n); + + int res = INF; + for (int i = 0; i < n; ++i) { + chmin(res, dp[((1 << n) - 1) << 5 | i]); + } + // debug(dp); + if (res == INF) { + cout << "No\n"; + } else { + cout << res << '\n'; + } } int main() { diff --git a/src/bin/ctext_out.cc b/src/bin/ctext_out.cc index 74df92d..0ba95fb 100644 --- a/src/bin/ctext_out.cc +++ b/src/bin/ctext_out.cc @@ -175,18 +175,6 @@ template pair void __read(T& x) { cin >> x; } -template void __read(T& x, U&... args) { cin >> x; __read(args...); } -#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) -#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) -#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(cin), (n), a.begin() + 1);) -#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) -#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) -#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) -#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) -#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) -#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) -#define deb(...) debug(make_tuple(__VA_ARGS__)) template istream& operator>>(istream& in, pair& p) { return in >> p.first >> p.second; } @@ -232,6 +220,18 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { } return dest; } +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(cin), (n), a.begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) /* pops */ #define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) @@ -491,62 +491,36 @@ void dump_ignore() {} void prep() { } +ld distance(const pii& p1, const pii& p2) { + auto [x1, y1] = p1; + auto [x2, y2] = p2; + return sqrt(ld(1) * (x2 - x1) * (x2 - x1) + ld(1) * (y2 - y1) * (y2 - y1)); +} + void solve() { - read(int, n, m, w); - vector a(n, vector(m)); - for (int i = 0; i < n; ++i) { - for (int j = 0; j < m; ++j) { - cin >> a[i][j]; - } + read(int, n, k); + read(pii, s); + vector a(n); + read(pii, prev); + ld tot = distance(s, prev); + for (int i = 1; i < n; ++i) { + read(pii, curr); + tot += distance(prev, curr); + a[i] = distance(s, prev) + distance(s, curr) - distance(prev, curr); + prev = curr; } - vector ch(n * m + 1, pair>()); - auto add_edge = [&] (int v, int u, int w) { - int pos = ch[v].first++; - ch[v].second[pos] = {u, w}; - }; - #define ser(i, j) ((i) * m + (j)) - int cnt = 0; - for (int i = 0; i < n; ++i) { - for (int j = 0; j < m; ++j) { - if (a[i][j] == -1) continue; - if (j + 1 < m and a[i][j + 1] != -1) { - add_edge(ser(i, j), ser(i, j + 1), w); - cnt += 1; - } - if (i + 1 < n and a[i + 1][j] != -1) { - add_edge(ser(i, j), ser(i + 1, j), w); - cnt += 1; - } + tot += distance(s, prev); - if (a[i][j] != 0) { - add_edge(ser(i, j), n * m, a[i][j]); - cnt += 1; - } - } - } - - min_heap pq; - vector dis(n * m + 1, INFLL); - vector vis(n * m + 1); + min_heap pq; pq.emplace(0, 0); - dis[0] = 0; - int mxs = 0; - while (pq.size()) { - chmax(mxs, pq.size()); - poptop(pq, d, v); - continue_or(vis[v], 1); - for (int i = 0; i < ch[v].first; ++i) { - auto&& [u, w] = ch[v].second[i]; - if (d + w < dis[u]) { - dis[u] = d + w; - pq.emplace(d + w, u); - } + for (int i = 1; i < n; ++i) { + pq.emplace(pq.top().first + a[i], i); + while (pq.size() and pq.top().second < i + 1 - k) { + pq.pop(); } } - debug(mxs); - - cout << (dis[n * m - 1] == INFLL ? -1 : dis[n * m - 1]) << endl; + cout << setprecision(50) << tot + pq.top().first << endl; } int main() { diff --git a/src/bin/std.in b/src/bin/std.in index e69de29..9a315ae 100644 --- a/src/bin/std.in +++ b/src/bin/std.in @@ -0,0 +1,6 @@ +3 2 +1 1 +3 1 +1 2 +3 2 + diff --git a/src/bin/template.cc b/src/bin/template.cc index c12e5e6..05f118b 100644 --- a/src/bin/template.cc +++ b/src/bin/template.cc @@ -175,18 +175,6 @@ template pair void __read(T& x) { cin >> x; } -template void __read(T& x, U&... args) { cin >> x; __read(args...); } -#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) -#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) -#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(cin), (n), a.begin() + 1);) -#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) -#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) -#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) -#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) -#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) -#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) -#define deb(...) debug(make_tuple(__VA_ARGS__)) template istream& operator>>(istream& in, pair& p) { return in >> p.first >> p.second; } @@ -232,6 +220,18 @@ std::ostream& operator<<(std::ostream& dest, const int128& value) { } return dest; } +template void __read(T& x) { cin >> x; } +template void __read(T& x, U&... args) { cin >> x; __read(args...); } +#define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) +#define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (auto& x : a) cin >> x;) +#define readvec1(type, a, n) __AS_PROCEDURE(vector a((n) + 1); copy_n(ii(cin), (n), a.begin() + 1);) +#define putvec(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec1(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, " ")); cout << endl;) +#define putvec_eol(a) __AS_PROCEDURE(copy(a.begin(), a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define putvec1_eol(a) __AS_PROCEDURE(copy(a.begin() + 1, a.end(), oi<__as_typeof(a)::value_type>(cout, "\n"));) +#define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) +#define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) +#define deb(...) debug(make_tuple(__VA_ARGS__)) /* pops */ #define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();)