QOJ.ac
QOJ
| ID | Problem | Submitter | Result | Time | Memory | Language | File size | Submit time | Judge time |
|---|---|---|---|---|---|---|---|---|---|
| #795101 | #9804. Guess the Polygon | ucup-team133# | RE | 5ms | 3736kb | C++23 | 24.3kb | 2024-11-30 17:53:30 | 2024-11-30 17:53:31 |
Judging History
answer
#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif
template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
for (auto& e : v) {
is >> e;
}
return is;
}
template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
for (std::string_view sep = ""; const auto& e : v) {
os << std::exchange(sep, " ") << e;
}
return os;
}
template <class T, class U = T> bool chmin(T& x, U&& y) {
return y < x and (x = std::forward<U>(y), true);
}
template <class T, class U = T> bool chmax(T& x, U&& y) {
return x < y and (x = std::forward<U>(y), true);
}
template <class T> void mkuni(std::vector<T>& v) {
std::ranges::sort(v);
auto result = std::ranges::unique(v);
v.erase(result.begin(), result.end());
}
template <class T> int lwb(const std::vector<T>& v, const T& x) {
return std::distance(v.begin(), std::ranges::lower_bound(v, x));
}
#include <type_traits>
#ifdef _MSC_VER
#include <intrin.h>
#endif
#ifdef _MSC_VER
#include <intrin.h>
#endif
namespace atcoder {
namespace internal {
// @param m `1 <= m`
// @return x mod m
constexpr long long safe_mod(long long x, long long m) {
x %= m;
if (x < 0) x += m;
return x;
}
// Fast modular multiplication by barrett reduction
// Reference: https://en.wikipedia.org/wiki/Barrett_reduction
// NOTE: reconsider after Ice Lake
struct barrett {
unsigned int _m;
unsigned long long im;
// @param m `1 <= m < 2^31`
explicit barrett(unsigned int m) : _m(m), im((unsigned long long)(-1) / m + 1) {}
// @return m
unsigned int umod() const { return _m; }
// @param a `0 <= a < m`
// @param b `0 <= b < m`
// @return `a * b % m`
unsigned int mul(unsigned int a, unsigned int b) const {
// [1] m = 1
// a = b = im = 0, so okay
// [2] m >= 2
// im = ceil(2^64 / m)
// -> im * m = 2^64 + r (0 <= r < m)
// let z = a*b = c*m + d (0 <= c, d < m)
// a*b * im = (c*m + d) * im = c*(im*m) + d*im = c*2^64 + c*r + d*im
// c*r + d*im < m * m + m * im < m * m + 2^64 + m <= 2^64 + m * (m + 1) < 2^64 * 2
// ((ab * im) >> 64) == c or c + 1
unsigned long long z = a;
z *= b;
#ifdef _MSC_VER
unsigned long long x;
_umul128(z, im, &x);
#else
unsigned long long x =
(unsigned long long)(((unsigned __int128)(z)*im) >> 64);
#endif
unsigned int v = (unsigned int)(z - x * _m);
if (_m <= v) v += _m;
return v;
}
};
// @param n `0 <= n`
// @param m `1 <= m`
// @return `(x ** n) % m`
constexpr long long pow_mod_constexpr(long long x, long long n, int m) {
if (m == 1) return 0;
unsigned int _m = (unsigned int)(m);
unsigned long long r = 1;
unsigned long long y = safe_mod(x, m);
while (n) {
if (n & 1) r = (r * y) % _m;
y = (y * y) % _m;
n >>= 1;
}
return r;
}
// Reference:
// M. Forisek and J. Jancina,
// Fast Primality Testing for Integers That Fit into a Machine Word
// @param n `0 <= n`
constexpr bool is_prime_constexpr(int n) {
if (n <= 1) return false;
if (n == 2 || n == 7 || n == 61) return true;
if (n % 2 == 0) return false;
long long d = n - 1;
while (d % 2 == 0) d /= 2;
constexpr long long bases[3] = {2, 7, 61};
for (long long a : bases) {
long long t = d;
long long y = pow_mod_constexpr(a, t, n);
while (t != n - 1 && y != 1 && y != n - 1) {
y = y * y % n;
t <<= 1;
}
if (y != n - 1 && t % 2 == 0) {
return false;
}
}
return true;
}
template <int n> constexpr bool is_prime = is_prime_constexpr(n);
// @param b `1 <= b`
// @return pair(g, x) s.t. g = gcd(a, b), xa = g (mod b), 0 <= x < b/g
constexpr std::pair<long long, long long> inv_gcd(long long a, long long b) {
a = safe_mod(a, b);
if (a == 0) return {b, 0};
// Contracts:
// [1] s - m0 * a = 0 (mod b)
// [2] t - m1 * a = 0 (mod b)
// [3] s * |m1| + t * |m0| <= b
long long s = b, t = a;
long long m0 = 0, m1 = 1;
while (t) {
long long u = s / t;
s -= t * u;
m0 -= m1 * u; // |m1 * u| <= |m1| * s <= b
// [3]:
// (s - t * u) * |m1| + t * |m0 - m1 * u|
// <= s * |m1| - t * u * |m1| + t * (|m0| + |m1| * u)
// = s * |m1| + t * |m0| <= b
auto tmp = s;
s = t;
t = tmp;
tmp = m0;
m0 = m1;
m1 = tmp;
}
// by [3]: |m0| <= b/g
// by g != b: |m0| < b/g
if (m0 < 0) m0 += b / s;
return {s, m0};
}
// Compile time primitive root
// @param m must be prime
// @return primitive root (and minimum in now)
constexpr int primitive_root_constexpr(int m) {
if (m == 2) return 1;
if (m == 167772161) return 3;
if (m == 469762049) return 3;
if (m == 754974721) return 11;
if (m == 998244353) return 3;
int divs[20] = {};
divs[0] = 2;
int cnt = 1;
int x = (m - 1) / 2;
while (x % 2 == 0) x /= 2;
for (int i = 3; (long long)(i)*i <= x; i += 2) {
if (x % i == 0) {
divs[cnt++] = i;
while (x % i == 0) {
x /= i;
}
}
}
if (x > 1) {
divs[cnt++] = x;
}
for (int g = 2;; g++) {
bool ok = true;
for (int i = 0; i < cnt; i++) {
if (pow_mod_constexpr(g, (m - 1) / divs[i], m) == 1) {
ok = false;
break;
}
}
if (ok) return g;
}
}
template <int m> constexpr int primitive_root = primitive_root_constexpr(m);
// @param n `n < 2^32`
// @param m `1 <= m < 2^32`
// @return sum_{i=0}^{n-1} floor((ai + b) / m) (mod 2^64)
unsigned long long floor_sum_unsigned(unsigned long long n,
unsigned long long m,
unsigned long long a,
unsigned long long b) {
unsigned long long ans = 0;
while (true) {
if (a >= m) {
ans += n * (n - 1) / 2 * (a / m);
a %= m;
}
if (b >= m) {
ans += n * (b / m);
b %= m;
}
unsigned long long y_max = a * n + b;
if (y_max < m) break;
// y_max < m * (n + 1)
// floor(y_max / m) <= n
n = (unsigned long long)(y_max / m);
b = (unsigned long long)(y_max % m);
std::swap(m, a);
}
return ans;
}
} // namespace internal
} // namespace atcoder
namespace atcoder {
namespace internal {
#ifndef _MSC_VER
template <class T>
using is_signed_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value ||
std::is_same<T, __int128>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_unsigned_int128 =
typename std::conditional<std::is_same<T, __uint128_t>::value ||
std::is_same<T, unsigned __int128>::value,
std::true_type,
std::false_type>::type;
template <class T>
using make_unsigned_int128 =
typename std::conditional<std::is_same<T, __int128_t>::value,
__uint128_t,
unsigned __int128>;
template <class T>
using is_integral = typename std::conditional<std::is_integral<T>::value ||
is_signed_int128<T>::value ||
is_unsigned_int128<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_signed_int = typename std::conditional<(is_integral<T>::value &&
std::is_signed<T>::value) ||
is_signed_int128<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<(is_integral<T>::value &&
std::is_unsigned<T>::value) ||
is_unsigned_int128<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<
is_signed_int128<T>::value,
make_unsigned_int128<T>,
typename std::conditional<std::is_signed<T>::value,
std::make_unsigned<T>,
std::common_type<T>>::type>::type;
#else
template <class T> using is_integral = typename std::is_integral<T>;
template <class T>
using is_signed_int =
typename std::conditional<is_integral<T>::value && std::is_signed<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using is_unsigned_int =
typename std::conditional<is_integral<T>::value &&
std::is_unsigned<T>::value,
std::true_type,
std::false_type>::type;
template <class T>
using to_unsigned = typename std::conditional<is_signed_int<T>::value,
std::make_unsigned<T>,
std::common_type<T>>::type;
#endif
template <class T>
using is_signed_int_t = std::enable_if_t<is_signed_int<T>::value>;
template <class T>
using is_unsigned_int_t = std::enable_if_t<is_unsigned_int<T>::value>;
template <class T> using to_unsigned_t = typename to_unsigned<T>::type;
} // namespace internal
} // namespace atcoder
namespace atcoder {
namespace internal {
struct modint_base {};
struct static_modint_base : modint_base {};
template <class T> using is_modint = std::is_base_of<modint_base, T>;
template <class T> using is_modint_t = std::enable_if_t<is_modint<T>::value>;
} // namespace internal
template <int m, std::enable_if_t<(1 <= m)>* = nullptr>
struct static_modint : internal::static_modint_base {
using mint = static_modint;
public:
static constexpr int mod() { return m; }
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
static_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T>* = nullptr>
static_modint(T v) {
long long x = (long long)(v % (long long)(umod()));
if (x < 0) x += umod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T>* = nullptr>
static_modint(T v) {
_v = (unsigned int)(v % umod());
}
unsigned int val() const { return _v; }
mint& operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
mint& operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint& operator+=(const mint& rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator-=(const mint& rhs) {
_v -= rhs._v;
if (_v >= umod()) _v += umod();
return *this;
}
mint& operator*=(const mint& rhs) {
unsigned long long z = _v;
z *= rhs._v;
_v = (unsigned int)(z % umod());
return *this;
}
mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
if (prime) {
assert(_v);
return pow(umod() - 2);
} else {
auto eg = internal::inv_gcd(_v, m);
assert(eg.first == 1);
return eg.second;
}
}
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint& lhs, const mint& rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint& lhs, const mint& rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static constexpr unsigned int umod() { return m; }
static constexpr bool prime = internal::is_prime<m>;
};
template <int id> struct dynamic_modint : internal::modint_base {
using mint = dynamic_modint;
public:
static int mod() { return (int)(bt.umod()); }
static void set_mod(int m) {
assert(1 <= m);
bt = internal::barrett(m);
}
static mint raw(int v) {
mint x;
x._v = v;
return x;
}
dynamic_modint() : _v(0) {}
template <class T, internal::is_signed_int_t<T>* = nullptr>
dynamic_modint(T v) {
long long x = (long long)(v % (long long)(mod()));
if (x < 0) x += mod();
_v = (unsigned int)(x);
}
template <class T, internal::is_unsigned_int_t<T>* = nullptr>
dynamic_modint(T v) {
_v = (unsigned int)(v % mod());
}
unsigned int val() const { return _v; }
mint& operator++() {
_v++;
if (_v == umod()) _v = 0;
return *this;
}
mint& operator--() {
if (_v == 0) _v = umod();
_v--;
return *this;
}
mint operator++(int) {
mint result = *this;
++*this;
return result;
}
mint operator--(int) {
mint result = *this;
--*this;
return result;
}
mint& operator+=(const mint& rhs) {
_v += rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator-=(const mint& rhs) {
_v += mod() - rhs._v;
if (_v >= umod()) _v -= umod();
return *this;
}
mint& operator*=(const mint& rhs) {
_v = bt.mul(_v, rhs._v);
return *this;
}
mint& operator/=(const mint& rhs) { return *this = *this * rhs.inv(); }
mint operator+() const { return *this; }
mint operator-() const { return mint() - *this; }
mint pow(long long n) const {
assert(0 <= n);
mint x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
mint inv() const {
auto eg = internal::inv_gcd(_v, mod());
assert(eg.first == 1);
return eg.second;
}
friend mint operator+(const mint& lhs, const mint& rhs) {
return mint(lhs) += rhs;
}
friend mint operator-(const mint& lhs, const mint& rhs) {
return mint(lhs) -= rhs;
}
friend mint operator*(const mint& lhs, const mint& rhs) {
return mint(lhs) *= rhs;
}
friend mint operator/(const mint& lhs, const mint& rhs) {
return mint(lhs) /= rhs;
}
friend bool operator==(const mint& lhs, const mint& rhs) {
return lhs._v == rhs._v;
}
friend bool operator!=(const mint& lhs, const mint& rhs) {
return lhs._v != rhs._v;
}
private:
unsigned int _v;
static internal::barrett bt;
static unsigned int umod() { return bt.umod(); }
};
template <int id> internal::barrett dynamic_modint<id>::bt(998244353);
using modint998244353 = static_modint<998244353>;
using modint1000000007 = static_modint<1000000007>;
using modint = dynamic_modint<-1>;
namespace internal {
template <class T>
using is_static_modint = std::is_base_of<internal::static_modint_base, T>;
template <class T>
using is_static_modint_t = std::enable_if_t<is_static_modint<T>::value>;
template <class> struct is_dynamic_modint : public std::false_type {};
template <int id>
struct is_dynamic_modint<dynamic_modint<id>> : public std::true_type {};
template <class T>
using is_dynamic_modint_t = std::enable_if_t<is_dynamic_modint<T>::value>;
} // namespace internal
} // namespace atcoder
template <typename T, bool Reduce = false> class Rational {
static T my_gcd(T x_, T y_) {
unsigned long long x = x_ < 0 ? -x_ : x_, y = y_ < 0 ? -y_ : y_;
if (!x or !y) return x + y;
int n = __builtin_ctzll(x), m = __builtin_ctzll(y);
x >>= n, y >>= m;
while (x != y) {
if (x > y)
x = (x - y) >> __builtin_ctzll(x - y);
else
y = (y - x) >> __builtin_ctzll(y - x);
}
return x << (n > m ? m : n);
}
void normalize() {
if (den < 0) num = -num, den = -den;
if (den == 0) num = (num > 0 ? 1 : num < 0 ? -1 : 0);
if constexpr (Reduce) {
T g = my_gcd(num, den);
if (g > 0) num /= g, den /= g;
}
}
public:
T num, den;
Rational() {}
Rational(T num) : num(num), den(T(1)) {}
Rational(T num, T den) : num(num), den(den) { normalize(); }
Rational operator+(const Rational& r) const { return Rational(num * r.den + den * r.num, den * r.den); }
Rational operator-(const Rational& r) const { return Rational(num * r.den - den * r.num, den * r.den); }
Rational operator*(const Rational& r) const { return Rational(num * r.num, den * r.den); }
Rational operator/(const Rational& r) const { return Rational(num * r.den, den * r.num); }
Rational& operator+=(const Rational& r) { return *this = *this + r; }
Rational& operator-=(const Rational& r) { return *this = *this - r; }
Rational& operator*=(const Rational& r) { return *this = *this * r; }
Rational& operator/=(const Rational& r) { return *this = *this / r; }
Rational operator+(const T& val) const { return *this + Rational(val); }
Rational operator-(const T& val) const { return *this - Rational(val); }
Rational operator*(const T& val) const { return *this * Rational(val); }
Rational operator/(const T& val) const { return *this / Rational(val); }
Rational& operator+=(const T& val) { return *this = *this + val; }
Rational& operator-=(const T& val) { return *this = *this - val; }
Rational& operator*=(const T& val) { return *this = *this * val; }
Rational& operator/=(const T& val) { return *this = *this / val; }
friend Rational operator+(const T& val, const Rational& r) { return r + val; }
friend Rational operator-(const T& val, const Rational& r) { return r - val; }
friend Rational operator*(const T& val, const Rational& r) { return r * val; }
friend Rational operator/(const T& val, const Rational& r) { return r / val; }
Rational operator-() const { return Rational(-num, den); }
Rational abs() const { return Rational(num < 0 ? -num : num, den); }
bool operator==(const Rational& r) const {
if (den == 0 and r.den == 0) return num == r.num;
if (den == 0 or r.den == 0) return false;
return num * r.den == den * r.num;
}
bool operator!=(const Rational& r) const { return !(*this == r); }
bool operator<(const Rational& r) const {
if (den == 0 and r.den == 0) return num < r.num;
if (den == 0) return num < 0;
if (r.den == 0) return r.num > 0;
return num * r.den < den * r.num;
}
bool operator<=(const Rational& r) const { return (*this == r) or (*this < r); }
bool operator>(const Rational& r) const { return r < *this; }
bool operator>=(const Rational& r) const { return (*this == r) or (*this > r); }
bool operator==(const T& val) const { return *this == Rational(val); }
bool operator!=(const T& val) const { return *this != Rational(val); }
bool operator<(const T& val) const { return *this < Rational(val); }
bool operator<=(const T& val) const { return *this <= Rational(val); }
bool operator>(const T& val) const { return *this > Rational(val); }
bool operator>=(const T& val) const { return *this >= Rational(val); }
friend bool operator==(const T& val, const Rational& r) { return r == val; }
friend bool operator!=(const T& val, const Rational& r) { return r != val; }
friend bool operator<(const T& val, const Rational& r) { return r > val; }
friend bool operator<=(const T& val, const Rational& r) { return r >= val; }
friend bool operator>(const T& val, const Rational& r) { return r < val; }
friend bool operator>=(const T& val, const Rational& r) { return r <= val; }
explicit operator double() const { return (double)num / (double)den; }
explicit operator long double() const { return (long double)num / (long double)den; }
friend std::ostream& operator<<(std::ostream& os, const Rational& r) { return os << r.num << '/' << r.den; }
};
using namespace std;
using ll = long long;
using R = Rational<ll, true>;
using mint = atcoder::modint998244353;
int rest;
R query(R val) {
assert(rest-- > 0);
cout << "? " << val.num << " " << val.den << endl;
ll r, s;
cin >> r >> s;
return R(r, s);
}
void answer(R ans) { cout << "! " << ans.num << " " << ans.den << endl; }
void solve() {
int n;
cin >> n;
rest = n - 2;
vector<int> x(n), y(n);
for (int i = 0; i < n; i++) cin >> x[i] >> y[i];
map<int, vector<int>> mp;
for (int i = 0; i < n; i++) mp[x[i]].emplace_back(y[i]);
vector<pair<int, vector<int>>> xs;
for (auto [key, val] : mp) xs.emplace_back(key, val);
int N = xs.size();
vector<R> ls(N, -1), rs(N, -1);
ls[0] = rs[N - 1] = 0;
vector<R> vals;
R ans = 0;
long double sum = 0;
for (int i = 0; i + 1 < N; i++) {
R lx = xs[i].first, rx = xs[i + 1].first;
vector<pair<R, R>> line;
{
// determine rs[i];
int len = xs[i].second.size();
if (i == 0) {
if (len == 1) {
line.emplace_back(lx, 0);
} else {
auto qx = lx + R(1, 3);
line.emplace_back(qx, query(qx));
}
} else {
if (len == 1) {
assert(ls[i] != -1);
line.emplace_back(lx, ls[i]);
} else {
auto qx = lx + R(1, 3);
line.emplace_back(qx, query(qx));
}
}
}
{
// determine ls[i + 1];
int len = xs[i + 1].second.size();
if (i + 1 == N - 1) {
if (len == 1) {
line.emplace_back(rx, 0);
} else {
auto qx = rx - R(1, 3);
line.emplace_back(qx, query(qx));
}
} else {
if (len == 1) {
assert(rs[i + 1] == -1);
line.emplace_back(rx, query(rx));
} else {
auto qx = rx - R(1, 3);
line.emplace_back(qx, query(qx));
}
}
}
{
assert(line.size() == 2);
auto d = (line[1].second - line[0].second) / (line[1].first - line[0].first);
rs[i] = line[0].second + d * (lx - line[0].first);
ls[i + 1] = line[0].second + d * (rx - line[0].first);
}
vals.emplace_back((rs[i] + ls[i + 1]) * (rx - lx));
{
auto s = rs[i] + ls[i + 1];
sum += (long double)(s.num * (xs[i + 1].first - xs[i].first)) / s.den;
}
}
// assert(ans.den == 1 or ans.den == 2);
ll p = roundl(sum);
ans = (p & 1 ? R(p, 2) : R(p / 2, 1));
auto check = [&](int x) -> bool {
mint prod = 1;
for (auto r : vals) prod *= r.den;
mint SUM = 0;
for (auto r : vals) SUM += prod * r.num / r.den;
return SUM == prod * x;
};
for (int i = p - 100; i <= p + 100; i++) {
if (check(i)) {
int p = i, q = 2, g = gcd(p, q);
p /= g, q /= g;
answer(R(p, q));
return;
}
}
assert(false);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
int T;
cin >> T;
for (; T--;) solve();
return 0;
}
Details
Tip: Click on the bar to expand more detailed information
Test #1:
score: 100
Accepted
time: 1ms
memory: 3608kb
input:
2 4 3 0 1 3 1 1 0 0 4 3 5 3 3 0 0 999 1000 1000 999 1999 1000
output:
? 2 3 ? 4 3 ! 3 1 ? 999 1 ! 1999 2
result:
ok correct! (2 test cases)
Test #2:
score: 0
Accepted
time: 1ms
memory: 3572kb
input:
9 4 1 1 1 3 3 0 0 0 2 1 5 6 4 0 0 1 3 1 1 3 0 2 3 5 2 4 0 0 3 0 1 2 1 1 2 3 5 6 4 0 0 3 0 1 2 1 1 4 3 5 6 4 0 0 3 0 1 1 1 2 2 3 5 3 3 1000 0 0 0 0 1000 2999 3 4 0 0 1000 0 1000 1000 0 1000 1000 1 1000 1 5 0 1 1000 1000 1000 0 0 1000 1 0 2998 3 1000 1 1000 1 9 4 1000 3 1 2 1000 3 1000 1 1 2 1 0 0 1 1...
output:
? 2 3 ? 4 3 ! 5 2 ? 2 3 ? 4 3 ! 7 2 ? 2 3 ? 4 3 ! 3 2 ? 2 3 ? 4 3 ! 2 1 ? 2 3 ? 4 3 ! 5 2 ? 1 3 ! 500000 1 ? 1 3 ? 2999 3 ! 1000000 1 ? 1 3 ? 1 1 ? 2999 3 ! 1999999 2 ? 2 3 ? 4 3 ? 5 3 ? 7 3 ? 8 3 ? 10 3 ? 11 3 ! 4003 2
result:
ok correct! (9 test cases)
Test #3:
score: 0
Accepted
time: 5ms
memory: 3736kb
input:
78 8 951 614 927 614 957 614 957 604 937 614 942 619 951 610 927 604 10 1 10 1 15 1 19 3 10 1 10 1 7 562 260 602 250 582 255 587 260 602 260 562 250 577 260 10 1 10 1 5 1 10 1 10 1 3 454 98 494 68 455 68 117 4 3 526 589 566 559 527 559 117 4 3 854 496 854 466 894 466 119 4 3 797 264 827 254 857 264 ...
output:
? 2782 3 ? 937 1 ? 942 1 ? 2852 3 ? 2854 3 ? 2870 3 ! 317 1 ? 1687 3 ? 577 1 ? 582 1 ? 587 1 ? 1805 3 ! 375 1 ? 455 1 ! 585 1 ? 527 1 ! 585 1 ? 2563 3 ! 600 1 ? 827 1 ! 300 1 ? 2158 3 ! 600 1 ? 162 1 ! 400 1 ? 2227 3 ? 2240 3 ? 2242 3 ? 2255 3 ? 2257 3 ? 2375 3 ! 275 1 ? 2797 3 ? 2810 3 ? 2812 3 ? 2...
result:
ok correct! (78 test cases)
Test #4:
score: -100
Runtime Error
input:
34 24 123 815 168 800 133 795 27 827 153 805 28 830 178 780 138 810 78 830 192 772 148 790 88 810 43 825 183 795 103 805 163 785 118 800 93 825 63 835 73 815 58 820 198 790 48 840 108 820 10 3 95 6 15 2 95 6 15 2 95 6 15 2 95 6 15 2 95 6 15 2 95 6 15 2 95 6 15 2 95 6 15 2 95 6 15 2 95 6 15 2 15 1 24...
output:
? 28 1 ? 43 1 ? 48 1 ? 58 1 ? 63 1 ? 73 1 ? 78 1 ? 88 1 ? 93 1 ? 103 1 ? 108 1 ? 118 1 ? 123 1 ? 133 1 ? 138 1 ? 148 1 ? 153 1 ? 163 1 ? 168 1 ? 178 1 ? 183 1 ? 192 1 ! 1925 1 ? 54 1 ? 69 1 ? 74 1 ? 84 1 ? 89 1 ? 99 1 ? 104 1 ? 114 1 ? 119 1 ? 129 1 ? 134 1 ? 144 1 ? 149 1 ? 159 1 ? 164 1 ? 174 1 ? ...