#define PROBLEM "https://judge.yosupo.jp/problem/aplusb"
#include "../../template/template.hpp"
//
#include "../../marathon/sa-manager.hpp"
//
using namespace Nyaan;
int N;
int x[110], y[110];
// 状態を持つ型
using state_t = V<i128>;
// スコアを持つ型
using score_t = double;
using pair_t = pair<state_t, score_t>;
// 焼きなましの初期解を入れる関数
pair_t get_init_state() {
state_t ans;
score_t score;
// ans, score に初期解を入れる。
// 多点焼きなましを行う場合は初期解に多様性が生まれるようにする。
ans.resize(3, 0);
rep(i, N) {
if (rng() & 1) {
ans[0] |= i128(1) << i, ans[1] += x[i], ans[2] += y[i];
}
}
score = hypot<double, double>(ans[1], ans[2]);
return {ans, score};
}
// 状態を更新する関数
void update_state(state_t& ans, score_t& score, double th) {
// 遷移を作る
// 基本的には以下のように値を複製して遷移先を作っていい
// (差分更新したい場合は適宜頑張る)
state_t nxt{ans};
score_t nxt_score{score};
int d = rng() % 2 + 1;
rep(t, d) {
int i = rng() % N;
if ((nxt[0] >> i) & 1) {
nxt[1] -= x[i], nxt[2] -= y[i];
} else {
nxt[1] += x[i], nxt[2] += y[i];
}
nxt[0] ^= i128(1) << i;
}
nxt_score = hypot<double, double>(nxt[1], nxt[2]);
// スコアの伸びを変数 diff に格納して値を元に遷移を採用するか決める。
double diff = nxt_score - score;
if (diff > th) {
// 遷移を採用して ans, score を更新 or 差分更新する。
ans = nxt, score = nxt_score;
} else {
// (必要があれば)元に戻す。
}
}
int sa_size = 1;
int endt = 1900;
pair_t sa(Timer& t) {
SA_manager<state_t, score_t> sa(t, 2000, -2000, endt, sa_size);
return sa.run<get_init_state, update_state>();
}
int N_circle = 90;
int x_circle[] = {0, 63926, 127540, 190533, 252597, 313431, 372738,
430229, 485624, 538653, 589058, 636593, 681026, 722142,
759739, 793635, 823665, 849681, 871559, 889190, 902489,
911391, 915853, 915853, 911391, 902489, 889190, 871559,
849681, 823665, 793635, 759739, 722142, 681026, 636593,
589058, 538653, 485624, 430229, 372738, 313431, 252597,
190533, 127540, 63926, 0, -63926, -127540, -190533,
-252597, -313431, -372738, -430229, -485624, -538653, -589058,
-636593, -681026, -722142, -759739, -793635, -823665, -849681,
-871559, -889190, -902489, -911391, -915853, -915853, -911391,
-902489, -889190, -871559, -849681, -823665, -793635, -759739,
-722142, -681026, -636593, -589058, -538653, -485624, -430229,
-372738, -313431, -252597, -190533, -127540, -63926};
int y_circle[] = {916411, 914179, 907493, 896385, 880911, 861145, 837183,
809143, 777161, 741392, 702012, 659211, 613199, 564199,
512451, 458205, 401728, 343294, 283187, 221700, 159133,
95791, 31982, -31982, -95791, -159133, -221700, -283187,
-343294, -401728, -458206, -512451, -564199, -613199, -659211,
-702012, -741392, -777161, -809143, -837183, -861145, -880911,
-896385, -907493, -914179, -916411, -914179, -907493, -896385,
-880911, -861145, -837183, -809143, -777161, -741392, -702012,
-659211, -613199, -564199, -512451, -458205, -401728, -343294,
-283187, -221700, -159133, -95791, -31982, 31982, 95791,
159133, 221700, 283187, 343294, 401728, 458206, 512451,
564199, 613199, 659211, 702012, 741392, 777161, 809143,
837183, 861145, 880911, 896385, 907493, 914179};
double ans_circle = 26258581.001626496877294216848735127029515732503186465405;
template <int LOOP_TIME>
void test() {
Timer timer;
N = N_circle;
rep(i, N) {
x[i] = x_circle[i];
y[i] = y_circle[i];
}
vp kekka;
for (auto s : vi{10}) {
sa_size = 10;
endt = 1900;
int cnt = 0;
rep(t, LOOP_TIME) {
double score = 0;
timer.reset();
auto [_, cur] = sa(timer);
amax(score, cur);
cerr << "output : " << score << endl;
cerr << "answer : " << ans_circle << endl;
cerr << "judge : ";
if (abs(score - ans_circle) / ans_circle < 1e-10) {
cerr << "AC" << endl;
} else {
cerr << "WA" << endl;
}
}
kekka.emplace_back(s, cnt);
}
}
void q() {
test<1>();
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
void Nyaan::solve() {
int T = 1;
// in(T);
while (T--) q();
}
#line 1 "verify/verify-unit-test/sa-manager.test.cpp"
#define PROBLEM "https://judge.yosupo.jp/problem/aplusb"
#line 2 "template/template.hpp"
using namespace std;
// intrinstic
#include <immintrin.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// utility
#line 1 "template/util.hpp"
namespace Nyaan {
using ll = long long;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<vector<T>>;
using vi = vector<int>;
using vl = vector<long long>;
using vd = V<double>;
using vs = V<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
template <typename T>
using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T, typename U>
struct P : pair<T, U> {
template <typename... Args>
P(Args... args) : pair<T, U>(args...) {}
using pair<T, U>::first;
using pair<T, U>::second;
P &operator+=(const P &r) {
first += r.first;
second += r.second;
return *this;
}
P &operator-=(const P &r) {
first -= r.first;
second -= r.second;
return *this;
}
P &operator*=(const P &r) {
first *= r.first;
second *= r.second;
return *this;
}
template <typename S>
P &operator*=(const S &r) {
first *= r, second *= r;
return *this;
}
P operator+(const P &r) const { return P(*this) += r; }
P operator-(const P &r) const { return P(*this) -= r; }
P operator*(const P &r) const { return P(*this) *= r; }
template <typename S>
P operator*(const S &r) const {
return P(*this) *= r;
}
P operator-() const { return P{-first, -second}; }
};
using pl = P<ll, ll>;
using pi = P<int, int>;
using vp = V<pl>;
constexpr int inf = 1001001001;
constexpr long long infLL = 4004004004004004004LL;
template <typename T>
int sz(const T &t) {
return t.size();
}
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T>
inline T Max(const vector<T> &v) {
return *max_element(begin(v), end(v));
}
template <typename T>
inline T Min(const vector<T> &v) {
return *min_element(begin(v), end(v));
}
template <typename T>
inline long long Sum(const vector<T> &v) {
return accumulate(begin(v), end(v), 0LL);
}
template <typename T>
int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T>
int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
for (; n; x *= x, n >>= 1) ret *= (n & 1 ? x : 1);
return ret;
}
template <typename T, typename U>
pair<T, U> mkp(const T &t, const U &u) {
return make_pair(t, u);
}
template <typename T>
vector<T> mkrui(const vector<T> &v, bool rev = false) {
vector<T> ret(v.size() + 1);
if (rev) {
for (int i = int(v.size()) - 1; i >= 0; i--) ret[i] = v[i] + ret[i + 1];
} else {
for (int i = 0; i < int(v.size()); i++) ret[i + 1] = ret[i] + v[i];
}
return ret;
};
template <typename T>
vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F>
vector<int> mkord(int N, F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T>
vector<int> mkinv(vector<T> &v) {
int max_val = *max_element(begin(v), end(v));
vector<int> inv(max_val + 1, -1);
for (int i = 0; i < (int)v.size(); i++) inv[v[i]] = i;
return inv;
}
vector<int> mkiota(int n) {
vector<int> ret(n);
iota(begin(ret), end(ret), 0);
return ret;
}
template <typename T>
T mkrev(const T &v) {
T w{v};
reverse(begin(w), end(w));
return w;
}
template <typename T>
bool nxp(vector<T> &v) {
return next_permutation(begin(v), end(v));
}
// 返り値の型は入力の T に依存
// i 要素目 : [0, a[i])
template <typename T>
vector<vector<T>> product(const vector<T> &a) {
vector<vector<T>> ret;
vector<T> v;
auto dfs = [&](auto rc, int i) -> void {
if (i == (int)a.size()) {
ret.push_back(v);
return;
}
for (int j = 0; j < a[i]; j++) v.push_back(j), rc(rc, i + 1), v.pop_back();
};
dfs(dfs, 0);
return ret;
}
// F : function(void(T&)), mod を取る操作
// T : 整数型のときはオーバーフローに注意する
template <typename T>
T Power(T a, long long n, const T &I, const function<void(T &)> &f) {
T res = I;
for (; n; f(a = a * a), n >>= 1) {
if (n & 1) f(res = res * a);
}
return res;
}
// T : 整数型のときはオーバーフローに注意する
template <typename T>
T Power(T a, long long n, const T &I) {
return Power(a, n, I, function<void(T &)>{[](T &) -> void {}});
}
} // namespace Nyaan
#line 58 "template/template.hpp"
// bit operation
#line 1 "template/bitop.hpp"
namespace Nyaan {
__attribute__((target("popcnt"))) inline int popcnt(const u64 &a) {
return _mm_popcnt_u64(a);
}
inline int lsb(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int ctz(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int msb(const u64 &a) { return a ? 63 - __builtin_clzll(a) : -1; }
template <typename T>
inline int gbit(const T &a, int i) {
return (a >> i) & 1;
}
template <typename T>
inline void sbit(T &a, int i, bool b) {
if (gbit(a, i) != b) a ^= T(1) << i;
}
constexpr long long PW(int n) { return 1LL << n; }
constexpr long long MSK(int n) { return (1LL << n) - 1; }
} // namespace Nyaan
#line 61 "template/template.hpp"
// inout
#line 1 "template/inout.hpp"
namespace Nyaan {
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
istream &operator>>(istream &is, __int128_t &x) {
string S;
is >> S;
x = 0;
int flag = 0;
for (auto &c : S) {
if (c == '-') {
flag = true;
continue;
}
x *= 10;
x += c - '0';
}
if (flag) x = -x;
return is;
}
istream &operator>>(istream &is, __uint128_t &x) {
string S;
is >> S;
x = 0;
for (auto &c : S) {
x *= 10;
x += c - '0';
}
return is;
}
ostream &operator<<(ostream &os, __int128_t x) {
if (x == 0) return os << 0;
if (x < 0) os << '-', x = -x;
string S;
while (x) S.push_back('0' + x % 10), x /= 10;
reverse(begin(S), end(S));
return os << S;
}
ostream &operator<<(ostream &os, __uint128_t x) {
if (x == 0) return os << 0;
string S;
while (x) S.push_back('0' + x % 10), x /= 10;
reverse(begin(S), end(S));
return os << S;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &...u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U, char sep = ' '>
void out(const T &t, const U &...u) {
cout << t;
if (sizeof...(u)) cout << sep;
out(u...);
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
} // namespace Nyaan
#line 64 "template/template.hpp"
// debug
#line 1 "template/debug.hpp"
namespace DebugImpl {
template <typename U, typename = void>
struct is_specialize : false_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, typename U::iterator, void>::type>
: true_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, decltype(U::first), void>::type>
: true_type {};
template <typename U>
struct is_specialize<U, enable_if_t<is_integral<U>::value, void>> : true_type {
};
void dump(const char& t) { cerr << t; }
void dump(const string& t) { cerr << t; }
void dump(const bool& t) { cerr << (t ? "true" : "false"); }
void dump(__int128_t t) {
if (t == 0) cerr << 0;
if (t < 0) cerr << '-', t = -t;
string S;
while (t) S.push_back('0' + t % 10), t /= 10;
reverse(begin(S), end(S));
cerr << S;
}
void dump(__uint128_t t) {
if (t == 0) cerr << 0;
string S;
while (t) S.push_back('0' + t % 10), t /= 10;
reverse(begin(S), end(S));
cerr << S;
}
template <typename U,
enable_if_t<!is_specialize<U>::value, nullptr_t> = nullptr>
void dump(const U& t) {
cerr << t;
}
template <typename T>
void dump(const T& t, enable_if_t<is_integral<T>::value>* = nullptr) {
string res;
if (t == Nyaan::inf) res = "inf";
if constexpr (is_signed<T>::value) {
if (t == -Nyaan::inf) res = "-inf";
}
if constexpr (sizeof(T) == 8) {
if (t == Nyaan::infLL) res = "inf";
if constexpr (is_signed<T>::value) {
if (t == -Nyaan::infLL) res = "-inf";
}
}
if (res.empty()) res = to_string(t);
cerr << res;
}
template <typename T, typename U>
void dump(const pair<T, U>&);
template <typename T>
void dump(const pair<T*, int>&);
template <typename T>
void dump(const T& t,
enable_if_t<!is_void<typename T::iterator>::value>* = nullptr) {
cerr << "[ ";
for (auto it = t.begin(); it != t.end();) {
dump(*it);
cerr << (++it == t.end() ? "" : ", ");
}
cerr << " ]";
}
template <typename T, typename U>
void dump(const pair<T, U>& t) {
cerr << "( ";
dump(t.first);
cerr << ", ";
dump(t.second);
cerr << " )";
}
template <typename T>
void dump(const pair<T*, int>& t) {
cerr << "[ ";
for (int i = 0; i < t.second; i++) {
dump(t.first[i]);
cerr << (i == t.second - 1 ? "" : ", ");
}
cerr << " ]";
}
void trace() { cerr << endl; }
template <typename Head, typename... Tail>
void trace(Head&& head, Tail&&... tail) {
cerr << " ";
dump(head);
if (sizeof...(tail) != 0) cerr << ",";
trace(forward<Tail>(tail)...);
}
} // namespace DebugImpl
#ifdef NyaanDebug
#define trc(...) \
do { \
cerr << "## " << #__VA_ARGS__ << " = "; \
DebugImpl::trace(__VA_ARGS__); \
} while (0)
#else
#define trc(...) (void(0))
#endif
#ifdef NyaanLocal
#define trc2(...) \
do { \
cerr << "## " << #__VA_ARGS__ << " = "; \
DebugImpl::trace(__VA_ARGS__); \
} while (0)
#else
#define trc2(...) (void(0))
#endif
#line 67 "template/template.hpp"
// macro
#line 1 "template/macro.hpp"
#define each(x, v) for (auto&& x : v)
#define each2(x, y, v) for (auto&& [x, y] : v)
#define all(v) (v).begin(), (v).end()
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define regr(i, a, b) for (long long i = (b)-1; i >= (a); i--)
#define fi first
#define se second
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define die(...) \
do { \
Nyaan::out(__VA_ARGS__); \
return; \
} while (0)
#line 70 "template/template.hpp"
namespace Nyaan {
void solve();
}
int main() { Nyaan::solve(); }
#line 4 "verify/verify-unit-test/sa-manager.test.cpp"
//
#line 2 "marathon/sa-manager.hpp"
#line 6 "marathon/sa-manager.hpp"
using namespace std;
#line 2 "misc/rng.hpp"
#line 2 "internal/internal-seed.hpp"
#line 4 "internal/internal-seed.hpp"
using namespace std;
namespace internal {
unsigned long long non_deterministic_seed() {
unsigned long long m =
chrono::duration_cast<chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count();
m ^= 9845834732710364265uLL;
m ^= m << 24, m ^= m >> 31, m ^= m << 35;
return m;
}
unsigned long long deterministic_seed() { return 88172645463325252UL; }
// 64 bit の seed 値を生成 (手元では seed 固定)
// 連続で呼び出すと同じ値が何度も返ってくるので注意
// #define RANDOMIZED_SEED するとシードがランダムになる
unsigned long long seed() {
#if defined(NyaanLocal) && !defined(RANDOMIZED_SEED)
return deterministic_seed();
#else
return non_deterministic_seed();
#endif
}
} // namespace internal
#line 4 "misc/rng.hpp"
namespace my_rand {
using i64 = long long;
using u64 = unsigned long long;
// [0, 2^64 - 1)
u64 rng() {
static u64 _x = internal::seed();
return _x ^= _x << 7, _x ^= _x >> 9;
}
// [l, r]
i64 rng(i64 l, i64 r) {
assert(l <= r);
return l + rng() % u64(r - l + 1);
}
// [l, r)
i64 randint(i64 l, i64 r) {
assert(l < r);
return l + rng() % u64(r - l);
}
// choose n numbers from [l, r) without overlapping
vector<i64> randset(i64 l, i64 r, i64 n) {
assert(l <= r && n <= r - l);
unordered_set<i64> s;
for (i64 i = n; i; --i) {
i64 m = randint(l, r + 1 - i);
if (s.find(m) != s.end()) m = r - i;
s.insert(m);
}
vector<i64> ret;
for (auto& x : s) ret.push_back(x);
return ret;
}
// [0.0, 1.0)
double rnd() { return rng() * 5.42101086242752217004e-20; }
// [l, r)
double rnd(double l, double r) {
assert(l < r);
return l + rnd() * (r - l);
}
template <typename T>
void randshf(vector<T>& v) {
int n = v.size();
for (int i = 1; i < n; i++) swap(v[i], v[randint(0, i + 1)]);
}
} // namespace my_rand
using my_rand::randint;
using my_rand::randset;
using my_rand::randshf;
using my_rand::rnd;
using my_rand::rng;
#line 2 "misc/timer.hpp"
#line 4 "misc/timer.hpp"
using namespace std;
struct Timer {
chrono::high_resolution_clock::time_point st;
Timer() { reset(); }
void reset() { st = chrono::high_resolution_clock::now(); }
long long elapsed() {
auto ed = chrono::high_resolution_clock::now();
return chrono::duration_cast<chrono::milliseconds>(ed - st).count();
}
long long operator()() { return elapsed(); }
};
#line 2 "marathon/log_table.hpp"
struct log_table {
static constexpr int M = 65536;
static constexpr int mask = M - 1;
double l[M];
log_table() : l() {
unsigned long long x = 88172645463325252ULL;
double log_u64max = log(2) * 64;
for (int i = 0; i < M; i++) {
x = x ^ (x << 7);
x = x ^ (x >> 9);
l[i] = log(double(x)) - log_u64max;
}
}
double operator()(int i) const { return l[i & mask]; }
};
#line 11 "marathon/sa-manager.hpp"
template <typename state_t, typename score_t>
struct SA_manager {
private:
log_table rand_log;
Timer timer;
double start_time, end_time, inv_time, cur_time;
double start_temp, diff_temp, cur_temp;
int state_max, state_size;
// 時間をセットする関数
void set_time() { cur_time = timer.elapsed(); }
// 時間を色々初期化する関数
void init_time() {
set_time();
start_time = cur_time;
inv_time = 1. / (end_time - start_time);
}
// 気温を設定して cur_temp に代入する関数
void set_temp() {
double passed_time = max(0., cur_time - start_time);
cur_temp = max(0., start_temp - passed_time * inv_time * diff_temp);
}
// 焼きなましで持つ状態の個数の max を代入する関数
void set_state_size() {
double passed_time = max(0., cur_time - start_time);
double n = 1.0 - max(0.0, passed_time * inv_time * 1.05 - 0.05);
state_size = int(max(1., state_max * n) + 0.5);
}
// update すべきかどうかのしきい値を計算する
double get_thresfold() { return cur_temp * rand_log(iter); }
public:
using pair_t = pair<state_t, score_t>;
long long iter = 0, loop_count = 0;
vector<pair_t> states;
#ifdef NyaanLocal
#define debug true
#else
#define debug false
#endif
void dump() {
// 重いので適宜コメントアウトする
/**/
if constexpr (debug) {
if ((loop_count & 0x3FFF) == 0) {
if (loop_count == 0) {
cerr << " iter | ";
cerr << " loops | ";
cerr << " time | ";
cerr << " cur temp | ";
cerr << "size | ";
cerr << " cur score | ";
cerr << endl;
}
cerr << setprecision(3);
cerr << setw(9) << iter << " | ";
cerr << setw(9) << loop_count << " | ";
cerr << setw(7) << int(cur_time) << " | ";
cerr << setw(10) << cur_temp << " | ";
cerr << setw(4) << states.size() << " | ";
auto comp_pair = [](const pair_t& lhs, const pair_t& rhs) {
return lhs.second > rhs.second;
};
sort(begin(states), end(states), comp_pair);
for (int i = 0; i < min<int>(states.size(), 5); i++) {
cerr << " " << setw(14) << states[i].second << " | ";
}
cerr << endl;
}
}
//*/
}
template <pair_t (*get_init_state)(),
void (*update_state)(state_t&, score_t&, double)>
pair_t run() {
auto comp_pair = [](const pair_t& lhs, const pair_t& rhs) {
return lhs.second > rhs.second;
};
// states の初期化
set_time();
if constexpr (debug) cerr << "init start : " << int(cur_time) << endl;
states.clear();
for (int i = 0; i < state_max; i++) states.push_back(get_init_state());
sort(begin(states), end(states), comp_pair);
// 時間・温度の初期化
init_time(), set_temp();
if constexpr (debug) cerr << "SA start : " << int(cur_time) << endl;
if (end_time <= cur_time) return states[0];
iter = loop_count = 0;
state_size = state_max; // 現在の states のサイズ
constexpr int L = 256;
while (state_size != 1) {
if ((loop_count & (L - 1)) == 0) {
set_time();
if (cur_time >= end_time) break;
set_temp();
}
dump();
loop_count++;
for (auto& state : states) {
iter++;
double thresfold = get_thresfold();
update_state(state.first, state.second, thresfold);
}
set_state_size();
while (state_size < (int)states.size()) {
sort(begin(states), end(states), comp_pair);
states.pop_back();
}
}
loop_count &= ~(L - 1);
while (true) {
set_time();
if (cur_time >= end_time) break;
set_temp();
dump();
for (int t = 0; t < L; t++) {
double thresfold = get_thresfold();
update_state(states[0].first, states[0].second, thresfold);
}
loop_count += L, iter += L;
}
sort(begin(states), end(states), comp_pair);
if constexpr (debug) {
cerr << "SA end : " << int(cur_time) << endl;
cerr << "iteration : " << iter << endl;
cerr << "loops : " << loop_count << endl;
cerr << "score : " << states[0].second << endl;
cerr << string(50, '*') << endl;
}
return states[0];
}
SA_manager(Timer& _timer, double _start_temp, double _end_temp,
double _end_time, int _state_max = 1)
: timer(_timer),
start_time(0.),
end_time(_end_time),
inv_time(1. / _end_time),
cur_time(0.),
start_temp(_start_temp),
diff_temp(_start_temp - _end_temp),
cur_temp(_start_temp),
state_max(_state_max),
state_size(_state_max) {
assert(_start_temp >= _end_temp);
assert(_state_max > 0);
}
};
#undef debug
/**
* @brief Multipoint Simulated Annealing
* @docs docs/marathon/sa-manager.md
*/
#line 6 "verify/verify-unit-test/sa-manager.test.cpp"
//
using namespace Nyaan;
int N;
int x[110], y[110];
// 状態を持つ型
using state_t = V<i128>;
// スコアを持つ型
using score_t = double;
using pair_t = pair<state_t, score_t>;
// 焼きなましの初期解を入れる関数
pair_t get_init_state() {
state_t ans;
score_t score;
// ans, score に初期解を入れる。
// 多点焼きなましを行う場合は初期解に多様性が生まれるようにする。
ans.resize(3, 0);
rep(i, N) {
if (rng() & 1) {
ans[0] |= i128(1) << i, ans[1] += x[i], ans[2] += y[i];
}
}
score = hypot<double, double>(ans[1], ans[2]);
return {ans, score};
}
// 状態を更新する関数
void update_state(state_t& ans, score_t& score, double th) {
// 遷移を作る
// 基本的には以下のように値を複製して遷移先を作っていい
// (差分更新したい場合は適宜頑張る)
state_t nxt{ans};
score_t nxt_score{score};
int d = rng() % 2 + 1;
rep(t, d) {
int i = rng() % N;
if ((nxt[0] >> i) & 1) {
nxt[1] -= x[i], nxt[2] -= y[i];
} else {
nxt[1] += x[i], nxt[2] += y[i];
}
nxt[0] ^= i128(1) << i;
}
nxt_score = hypot<double, double>(nxt[1], nxt[2]);
// スコアの伸びを変数 diff に格納して値を元に遷移を採用するか決める。
double diff = nxt_score - score;
if (diff > th) {
// 遷移を採用して ans, score を更新 or 差分更新する。
ans = nxt, score = nxt_score;
} else {
// (必要があれば)元に戻す。
}
}
int sa_size = 1;
int endt = 1900;
pair_t sa(Timer& t) {
SA_manager<state_t, score_t> sa(t, 2000, -2000, endt, sa_size);
return sa.run<get_init_state, update_state>();
}
int N_circle = 90;
int x_circle[] = {0, 63926, 127540, 190533, 252597, 313431, 372738,
430229, 485624, 538653, 589058, 636593, 681026, 722142,
759739, 793635, 823665, 849681, 871559, 889190, 902489,
911391, 915853, 915853, 911391, 902489, 889190, 871559,
849681, 823665, 793635, 759739, 722142, 681026, 636593,
589058, 538653, 485624, 430229, 372738, 313431, 252597,
190533, 127540, 63926, 0, -63926, -127540, -190533,
-252597, -313431, -372738, -430229, -485624, -538653, -589058,
-636593, -681026, -722142, -759739, -793635, -823665, -849681,
-871559, -889190, -902489, -911391, -915853, -915853, -911391,
-902489, -889190, -871559, -849681, -823665, -793635, -759739,
-722142, -681026, -636593, -589058, -538653, -485624, -430229,
-372738, -313431, -252597, -190533, -127540, -63926};
int y_circle[] = {916411, 914179, 907493, 896385, 880911, 861145, 837183,
809143, 777161, 741392, 702012, 659211, 613199, 564199,
512451, 458205, 401728, 343294, 283187, 221700, 159133,
95791, 31982, -31982, -95791, -159133, -221700, -283187,
-343294, -401728, -458206, -512451, -564199, -613199, -659211,
-702012, -741392, -777161, -809143, -837183, -861145, -880911,
-896385, -907493, -914179, -916411, -914179, -907493, -896385,
-880911, -861145, -837183, -809143, -777161, -741392, -702012,
-659211, -613199, -564199, -512451, -458205, -401728, -343294,
-283187, -221700, -159133, -95791, -31982, 31982, 95791,
159133, 221700, 283187, 343294, 401728, 458206, 512451,
564199, 613199, 659211, 702012, 741392, 777161, 809143,
837183, 861145, 880911, 896385, 907493, 914179};
double ans_circle = 26258581.001626496877294216848735127029515732503186465405;
template <int LOOP_TIME>
void test() {
Timer timer;
N = N_circle;
rep(i, N) {
x[i] = x_circle[i];
y[i] = y_circle[i];
}
vp kekka;
for (auto s : vi{10}) {
sa_size = 10;
endt = 1900;
int cnt = 0;
rep(t, LOOP_TIME) {
double score = 0;
timer.reset();
auto [_, cur] = sa(timer);
amax(score, cur);
cerr << "output : " << score << endl;
cerr << "answer : " << ans_circle << endl;
cerr << "judge : ";
if (abs(score - ans_circle) / ans_circle < 1e-10) {
cerr << "AC" << endl;
} else {
cerr << "WA" << endl;
}
}
kekka.emplace_back(s, cnt);
}
}
void q() {
test<1>();
int a, b;
cin >> a >> b;
cout << a + b << endl;
}
void Nyaan::solve() {
int T = 1;
// in(T);
while (T--) q();
}
verify/verify-unit-test/sa-manager.test.cpp