Submission #19437808


Source Code Expand

Copy
#pragma region Macros
// #pragma GCC target("avx2")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define ll long long
#define ld long double
#define rep2(i, a, b) for(ll i = a; i <= b; ++i)
#define rep(i, n) for(ll i = 0; i < n; ++i)
#define rep3(i, a, b) for(ll i = a; i >= b; --i)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pb push_back
#define eb emplace_back
#define vi vector<int>
#define vll vector<ll>
#define vpi vector<pii>
#define vpll vector<pll>
#define overload2(_1, _2, name, ...) name
#define vec(type, name, ...) vector<type> name(__VA_ARGS__)
#define VEC(type, name, size)                                                                                                                                  \
    vector<type> name(size);                                                                                                                                   \
    IN(name)
#define vv(type, name, h, ...) vector<vector<type>> name(h, vector<type>(__VA_ARGS__))
#define VV(type, name, h, w)                                                                                                                                   \
    vector<vector<type>> name(h, vector<type>(w));                                                                                                             \
    IN(name)
#define vvv(type, name, h, w, ...) vector<vector<vector<type>>> name(h, vector<vector<type>>(w, vector<type>(__VA_ARGS__)))
#define vvvv(type, name, a, b, c, ...)                                                                                                                         \
    vector<vector<vector<vector<type>>>> name(a, vector<vector<vector<type>>>(b, vector<vector<type>>(c, vector<type>(__VA_ARGS__))))
#define mt make_tuple

#define fi first
#define se second
#define all(c) begin(c), end(c)
#define lb(c, x) distance((c).begin(), lower_bound(all(c), (x)))
#define ub(c, x) distance((c).begin(), upper_bound(all(c), (x)))
using namespace std;
constexpr pii dx4[4] = {pii{1, 0}, pii{0, 1}, pii{-1, 0}, pii{0, -1}};
constexpr pii dx8[8] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
const string yesno[2] = {"no", "yes"};
void YES(bool t = 1) { cout << YESNO[t] << endl; }
void Yes(bool t = 1) { cout << YesNo[t] << endl; }
void yes(bool t = 1) { cout << yesno[t] << endl; }
template <class T> using vc = vector<T>;
template <class T> using vvc = vector<vc<T>>;
template <class T> using vvvc = vector<vvc<T>>;
template <class T> using vvvvc = vector<vvvc<T>>;
template <class T> using pq = priority_queue<T>;
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;
#define si(c) (int)(c).size()
#define INT(...)                                                                                                                                               \
    int __VA_ARGS__;                                                                                                                                           \
    IN(__VA_ARGS__)
#define LL(...)                                                                                                                                                \
    ll __VA_ARGS__;                                                                                                                                            \
    IN(__VA_ARGS__)
#define STR(...)                                                                                                                                               \
    string __VA_ARGS__;                                                                                                                                        \
    IN(__VA_ARGS__)
#define CHR(...)                                                                                                                                               \
    char __VA_ARGS__;                                                                                                                                          \
    IN(__VA_ARGS__)
#define DBL(...)                                                                                                                                               \
    double __VA_ARGS__;                                                                                                                                        \
    IN(__VA_ARGS__)
int scan() { return getchar(); }
void scan(int &a) { cin >> a; }
void scan(long long &a) { cin >> a; }
void scan(char &a) { cin >> a; }
void scan(double &a) { cin >> a; }
void scan(string &a) { cin >> a; }
template <class T, class S> void scan(pair<T, S> &p) { scan(p.first), scan(p.second); }
template <class T> void scan(vector<T> &);
template <class T> void scan(vector<T> &a) {
    for(auto &i : a) scan(i);
}
template <class T> void scan(T &a) { cin >> a; }
void IN() {}
template <class Head, class... Tail> void IN(Head &head, Tail &... tail) {
    scan(head);
    IN(tail...);
}
template <class T, class S> inline bool chmax(T &a, const S &b) { return (a < b ? a = b, 1 : 0); }
template <class T, class S> inline bool chmin(T &a, const S &b) { return (a > b ? a = b, 1 : 0); }
vi iota(int n) {
    vi a(n);
    iota(all(a), 0);
    return a;
}
template <typename T> vi iota(vector<T> &a, bool greater = false) {
    vi res(a.size());
    iota(all(res), 0);
    sort(all(res), [&](int i, int j) {
        if(greater) return a[i] > a[j];
        return a[i] < a[j];
    });
    return res;
}
#define UNIQUE(x) sort(all(x)), x.erase(unique(all(x)), x.end())
template <class T> T POW(T x, int n) {
    T res = 1;
    for(; n; n >>= 1, x *= x)
        if(n & 1) res *= x;
    return res;
}
vector<pll> factor(ll x) {
    vector<pll> ans;
    for(ll i = 2; i * i <= x; i++)
        if(x % i == 0) {
            ans.push_back({i, 1});
            while((x /= i) % i == 0) ans.back().second++;
        }
    if(x != 1) ans.push_back({x, 1});
    return ans;
}
template <class T> vector<T> divisor(T x) {
    vector<T> ans;
    for(T i = 1; i * i <= x; i++)
        if(x % i == 0) {
            ans.pb(i);
            if(i * i != x) ans.pb(x / i);
        }
    return ans;
}
template <typename T> void zip(vector<T> &x) {
    vector<T> y = x;
    sort(all(y));
    for(int i = 0; i < x.size(); ++i) { x[i] = lb(y, x[i]); }
}
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int lowbit(signed a) { return a == 0 ? 32 : __builtin_ctz(a); }
int lowbit(ll a) { return a == 0 ? 64 : __builtin_ctzll(a); }
// int allbit(int n) { return (1 << n) - 1; }
ll allbit(ll n) { return (1LL << n) - 1; }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }

int in() {
    int x;
    cin >> x;
    return x;
}
ll lin() {
    unsigned long long x;
    cin >> x;
    return x;
}

template <class T> pair<T, T> operator-(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.fi - y.fi, x.se - y.se); }
template <class T> pair<T, T> operator+(const pair<T, T> &x, const pair<T, T> &y) { return pair<T, T>(x.fi + y.fi, x.se + y.se); }
template <class T> ll operator*(const pair<T, T> &x, const pair<T, T> &y) { return (ll)x.fi * y.fi + (ll)x.se * y.se; }

template <typename T> struct edge {
    int from, to;
    T cost;
    int id;
    edge(int to, T cost) : from(-1), to(to), cost(cost) {}
    edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
    edge(int from, int to, T cost, int id) : from(from), to(to), cost(cost), id(id) {}
    edge &operator=(const int &x) {
        to = x;
        return *this;
    }
    operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;

using Tree = vector<vector<int>>;
using Graph = vector<vector<int>>;
template <class T> using Wgraph = vector<vector<edge<T>>>;
Graph getG(int n, int m = -1, bool directed = false, int margin = 1) {
    Tree res(n);
    if(m == -1) m = n - 1;
    while(m--) {
        int a, b;
        cin >> a >> b;
        a -= margin, b -= margin;
        res[a].emplace_back(b);
        if(!directed) res[b].emplace_back(a);
    }
    return move(res);
}
template <class T> Wgraph<T> getWg(int n, int m = -1, bool directed = false, int margin = 1) {
    Wgraph<T> res(n);
    if(m == -1) m = n - 1;
    while(m--) {
        int a, b;
        T c;
        cin >> a >> b >> c;
        a -= margin, b -= margin;
        res[a].emplace_back(b, c);
        if(!directed) res[b].emplace_back(a, c);
    }
    return move(res);
}

#define i128 __int128_t
#define ull unsigned long long int
#define TEST                                                                                                                                                   \
    INT(testcases);                                                                                                                                            \
    while(testcases--)
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
    for(auto it = begin(v); it != end(v); ++it) {
        if(it == begin(v))
            os << *it;
        else
            os << " " << *it;
    }
    return os;
}
template <class T, class S> ostream &operator<<(ostream &os, const pair<T, S> &p) {
    os << p.first << " " << p.second;
    return os;
}
template <class S, class T> string to_string(pair<S, T> p) { return "(" + to_string(p.first) + "," + to_string(p.second) + ")"; }
template <class A> string to_string(A v) {
    if(v.empty()) return "{}";
    string ret = "{";
    for(auto &x : v) ret += to_string(x) + ",";
    ret.back() = '}';
    return ret;
}
string to_string(string s) { return "\"" + s + "\""; }

void dump() { cerr << endl; }
template <class Head, class... Tail> void dump(Head head, Tail... tail) {
    cerr << to_string(head) << " ";
    dump(tail...);
}
#define endl '\n'
#ifdef _LOCAL
#undef endl
#define debug(x)                                                                                                                                               \
    cout << #x << ": ";                                                                                                                                        \
    dump(x)
#else
#define debug(x)
#endif

template <typename T> static constexpr T inf = numeric_limits<T>::max() / 2;
struct Setup_io {
    Setup_io() {
        ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
        cout << fixed << setprecision(15);
    }
} setup_io;
#define drop(s) cout << #s << endl, exit(0)
#pragma endregion

namespace modular {
constexpr ll MOD = 998244353;
const int MAXN = 1100000;
template <ll Modulus> class modint {
    using u64 = ll;

  public:
    u64 a;

    constexpr modint(const u64 x = 0) noexcept : a(((x % Modulus) + Modulus) % Modulus) {}
    constexpr u64 &value() noexcept { return a; }
    constexpr const u64 &value() const noexcept { return a; }
    constexpr modint operator+(const modint &rhs) const noexcept { return modint(*this) += rhs; }
    constexpr modint operator-(const modint &rhs) const noexcept { return modint(*this) -= rhs; }
    constexpr modint operator*(const modint &rhs) const noexcept { return modint(*this) *= rhs; }
    template <typename T> constexpr modint operator^(T rhs) const noexcept { return modint(*this) ^= rhs; }
    constexpr modint operator-() const noexcept { return modint() - *this; }
    constexpr modint &operator+=(const modint &rhs) noexcept {
        a += rhs.a;
        if(a >= Modulus) { a -= Modulus; }
        return *this;
    }
    constexpr modint &operator-=(const modint &rhs) noexcept {
        if(a < rhs.a) { a += Modulus; }
        a -= rhs.a;
        return *this;
    }
    constexpr modint &operator*=(const modint &rhs) noexcept {
        a = a * rhs.a % Modulus;
        return *this;
    }
    constexpr bool operator==(const modint &rhs) const noexcept { return a == rhs.a; }
    template <typename T> constexpr modint &operator^=(T n) noexcept {
        modint<Modulus> res = 1;
        modint<Modulus> x = a;
        while(n) {
            if(n & 1) res *= x;
            x *= x;
            n >>= 1;
        }
        a = res.a;
        return *this;
    }
    constexpr bool operator<(const modint &rhs) noexcept { return a < rhs.a; }
    constexpr bool operator<=(const modint &rhs) noexcept { return a < rhs.a; }
    constexpr bool operator>(const modint &rhs) noexcept { return a > rhs.a; }
    constexpr bool operator>=(const modint &rhs) noexcept { return a >= rhs.a; }
};
#define mint modint<MOD>
#define vmint vector<mint>
vmint Inv{0, 1}, Prd{1, 1}, Invprd{1, 1};
mint inv(int n) {
    if(n > MAXN) return mint(n) ^ (MOD - 2);
    if(Inv.size() > n)
        return Inv[n];
    else {
        for(int i = Inv.size(); i <= n; ++i) Inv.emplace_back(Inv[MOD % i] * (-MOD / i));
        return Inv[n];
    }
}
mint inv(mint x) { return inv(x.a); }
mint prd(int n) {
    if(Prd.size() > n)
        return Prd[n];
    else
        for(int i = Prd.size(); i <= n; ++i) Prd.emplace_back(Prd[i - 1] * i);
    return Prd[n];
}
mint invprd(int n) {
    if(Invprd.size() > n)
        return Invprd[n];
    else
        for(int i = Invprd.size(); i <= n; ++i) Invprd.emplace_back(Invprd[i - 1] * inv(i));
    return Invprd[n];
}
mint modpow(ll a, ll n) {
    mint x = a;
    return x ^= n;
}
mint operator/(mint l, mint r) { return l * inv(r); }
mint &operator/=(mint &l, mint r) { return l = l / r; }
mint C(int a, int b) {
    if(a < 0 || b < 0) return 0;
    if(a < b) return 0;
    return prd(a) * invprd(b) * invprd(a - b);
}
mint P(int a, int b) {
    if(a < 0 || b < 0) return 0;
    if(a < b) return 0;
    return prd(a) * invprd(a - b);
}
ostream &operator<<(ostream &os, mint a) {
    os << a.a;
    return os;
}
template <typename T> ostream &operator<<(ostream &os, const vmint &a) {
    for(auto &e : a) os << e << " ";
    return os;
}
mint operator*(ll x, mint y) { return y * x; }
istream &operator>>(istream &is, mint &a) {
    ll x;
    is >> x;
    a = x;
    return is;
}
mint proot = 3;

void FMT(vmint &f, const bool is_inv = false) {
    const int n = f.size();
    const mint root = is_inv ? inv(proot) : proot;
    vmint g(n);
    for(int b = n >> 1; b > 0; b >>= 1) {
        mint a = root ^ ((MOD - 1) / (n / b)), p = 1;
        for(int i = 0; i < n; i += b << 1) {
            rep(j, b) {
                f[i + j + b] *= p;
                g[(i >> 1) + j] = f[i + j] + f[i + b + j];
                g[(n >> 1) + (i >> 1) + j] = f[i + j] - f[i + b + j];
            }
            p *= a;
        }
        swap(f, g);
    }
    if(is_inv) rep(i, n) f[i] *= inv(n);
}

vmint mul(vmint x, const vmint &y) {
    int n = x.size() + y.size() - 1;
    int s = 1;
    while(s < n) s <<= 1;
    x.resize(s);
    FMT(x);
    vmint z(s);
    rep(i, y.size()) z[i] = y[i];
    FMT(z);
    rep(i, s) x[i] *= z[i];
    FMT(x, true);
    x.resize(n);
    return x;
}

using Poly = vmint;
Poly operator-(Poly f) {
    for(auto &&e : f) e = -e;
    return f;
}
Poly &operator+=(Poly &l, const Poly &r) {
    l.resize(max(l.size(), r.size()));
    rep(i, r.size()) l[i] += r[i];
    return l;
}
Poly operator+(Poly l, const Poly &r) { return l += r; }
Poly &operator-=(Poly &l, const Poly &r) {
    l.resize(max(l.size(), r.size()));
    rep(i, r.size()) l[i] -= r[i];
    return l;
}
Poly operator-(Poly l, const Poly &r) { return l -= r; }
Poly &operator<<=(Poly &f, size_t n) { return f.insert(f.begin(), n, 0), f; }
Poly operator<<(Poly f, size_t n) { return f <<= n; }
Poly &operator>>=(Poly &f, size_t n) { return f.erase(f.begin(), f.begin() + min(f.size(), n)), f; }
Poly operator>>(Poly f, size_t n) { return f >>= n; }
Poly operator*(const Poly &l, const Poly &r) { return mul(l, r); }
Poly &operator*=(Poly &l, const Poly &r) { return l = l * r; }
Poly inv(const Poly &f) {
    Poly g{1 / f[0]};
    while(g.size() < f.size()) {
        Poly x(f.begin(), f.begin() + min(f.size(), g.size() << 1)), y = g;
        x.resize(g.size() << 1), FMT(x);
        y.resize(g.size() << 1), FMT(y);
        rep(i, x.size()) x[i] *= y[i];
        FMT(x, true);
        x >>= g.size();
        x.resize(g.size() << 1), FMT(x);
        rep(i, x.size()) x[i] *= -y[i];
        FMT(x, true);
        g.insert(g.end(), x.begin(), x.begin() + g.size());
    }
    return Poly{begin(g), begin(g) + f.size()};
}
Poly integ(const Poly &f) {
    Poly res(f.size() + 1);
    for(int i = 1; i < (int)res.size(); ++i) res[i] = f[i - 1] / i;
    return res;
}
Poly deriv(const Poly &f) {
    if(f.size() == 0) return Poly();
    Poly res(f.size() - 1);
    rep(i, res.size()) res[i] = f[i + 1] * (i + 1);
    return res;
}
Poly log(const Poly &f) {
    Poly g = integ(inv(f) * deriv(f));
    return Poly{g.begin(), g.begin() + f.size()};
}
Poly exp(const Poly &f) {
    Poly g{1};
    while(g.size() < f.size()) {
        Poly x(f.begin(), f.begin() + min(f.size(), g.size() * 2));
        x[0] += 1;
        g.resize(2 * g.size());
        x -= log(g);
        x *= {g.begin(), g.begin() + g.size() / 2};
        rep2(i, g.size() / 2, min<int>(x.size(), g.size()) - 1) g[i] = x[i];
    }
    return {g.begin(), g.begin() + f.size()};
}
} // namespace modular
using namespace modular;

int main() {
    INT(n, m);
    map<pii, int> mp;
    vi a(m), b(m), c(m);
    vv(mint, v, n, 2);
    rep(i, n) v[i][0] = v[i][1] = modpow(2, min(i, n - 1 - i));
    rep(i, m) {
        cin >> a[i] >> b[i] >> c[i];
        a[i]--, b[i]--;
        mp[pii(a[i], b[i])] = c[i];
    }
    mint ans = modpow(2, (ll)n * n / 2 / 2 - (n - 1));
    rep(i, m) {
        if(abs(a[i] - b[i]) <= 1) continue;
        if(mp.count(pii(b[i], a[i]))) {
            int t = c[i], s = mp[pii(b[i], a[i])];
            if((a[i] + b[i]) & 1) {
                if(t != s)
                    drop(0);
                else if(a[i] < b[i])
                    ans /= 2;
            } else {
                if(a[i] < b[i]) {
                    int p = (a[i] + b[i]) / 2;
                    if(t != s)
                        v[p][1] /= 2, v[p][0] = 0;
                    else
                        v[p][1] = 0, v[p][0] /= 2;
                }
            }
        } else {
            if((a[i] + b[i]) & 1) {
                ans /= 2;
            } else
                rep(j, 2) v[(a[i] + b[i]) / 2][j] /= 2;
        }
    }
    vv(mint, dp, n, 2);
    if(mp.count(pii()))
        dp[0][mp[pii()]] = ans;
    else
        dp[0][0] = dp[0][1] = ans;
    rep(i, n - 1) {
        auto f = [&](int i, int j) {
            if(mp.count(pii(i, j)))
                return vi{mp[pii(i, j)]};
            else
                return vi{0, 1};
        };
        auto x = f(i + 1, i), y = f(i, i + 1), z = f(i + 1, i + 1);
        for(auto p : x)
            for(auto q : y)
                for(auto r : z) {
                    int t = p ^ q ^ r;
                    dp[i + 1][r] += dp[i][t] * v[i + 1][r];
                }
    }
    cout << dp[n - 1][0] + dp[n - 1][1] << endl;
}

Submission Info

Submission Time
Task F - Square
User noimi
Language C++ (GCC 9.2.1)
Score 900
Code Size 19708 Byte
Status AC
Exec Time 95 ms
Memory 18016 KB

Compile Error

./Main.cpp:1: warning: ignoring #pragma region Macros [-Wunknown-pragmas]
    1 | #pragma region Macros
      | 
./Main.cpp:253: warning: ignoring #pragma endregion  [-Wunknown-pragmas]
  253 | #pragma endregion
      | 
./Main.cpp: In function ‘Graph getG(int, int, bool, int)’:
./Main.cpp:186:16: warning: moving a local object in a return statement prevents copy elision [-Wpessimizing-move]
  186 |     return move(res);
      |            ~~~~^~~~~
./Main.cpp:186:16: note: remove ‘std::move’ call
./Main.cpp: In function ‘modular::modint<998244353> modular::inv(int)’:
./Main.cpp:308:19: warning: comparison of integer expressions of different signedness: ‘std::vector<modular::modint<998244353> >::size_type’ {aka ‘long unsigned int’} and ‘int’ [-Wsign-compare]
  308 |     if(Inv.size() > n)
      |        ~~~~~~~~~~~^~~
./Main.cpp: In function ‘modular::modint<998244353> modular::prd(int)’:
./Main.cpp:317:19: warning: comparison of integer expressions of different signedness: ‘std::vector<modular::modint<998244353> >::size_type’ {aka ‘long unsigned int’} and ‘int’ [-Wsign-compare]
  317 |     if(Prd.size() > n)
      |        ~~~~~~~~~~~^~~
./Main.cpp: In function ‘modular::modint<998244353> modular::invprd(int)’:
./Main.cpp:324:22: warning: comparison of integer expressions of different signedness: ‘std::vector<modular::modint<998244353> >::size_type’ {aka ‘long unsigned int’} and ‘int’ [-Wsign-compare]
  324 |     if(Invprd.size() > n)
      |        ~~~~~~~~~~~~~~^~~
./Main.cpp: In function ‘std::vector<modular::modint<998244353> > modular::mul(std::vector<modular::modint<998244353> >, const std::vector<modular::modint<998244353> >&)’:
./Main.cpp:9:35: warning: comparison of integer expressions of different signedness: ‘long long int’ and ‘std::vector<modular::modint<998244353> >::size_type’ {aka ‘long unsigned int’} [-Wsign-compare]
    9 | #define rep(i, n) for(ll i = 0; i < n; ++i)
......
  389 |     rep(i, y.size()) z[i] = y[i];
      | ...

Judge Result

Set Name Sample All
Score / Max Score 0 / 0 900 / 900
Status
AC × 5
AC × 93
Set Name Test Cases
Sample s1.txt, s2.txt, s3.txt, s4.txt, s5.txt
All 01.txt, 02.txt, 03.txt, 04.txt, 05.txt, 06.txt, 07.txt, 08.txt, 09.txt, 10.txt, 11.txt, 12.txt, 13.txt, 14.txt, 15.txt, 16.txt, 17.txt, 18.txt, 19.txt, 20.txt, 21.txt, 22.txt, 23.txt, 24.txt, 25.txt, 26.txt, 27.txt, 28.txt, 29.txt, 30.txt, 31.txt, 32.txt, 33.txt, 34.txt, 35.txt, 36.txt, 37.txt, 38.txt, 39.txt, 40.txt, 41.txt, 42.txt, 43.txt, 44.txt, 45.txt, 46.txt, 47.txt, 48.txt, 49.txt, 50.txt, 51.txt, 52.txt, 53.txt, 54.txt, 55.txt, 56.txt, 57.txt, 58.txt, 59.txt, 60.txt, 61.txt, 62.txt, 63.txt, 64.txt, 65.txt, 66.txt, 67.txt, 68.txt, 69.txt, 70.txt, 71.txt, 72.txt, 73.txt, 74.txt, 75.txt, 76.txt, 77.txt, 78.txt, 79.txt, 80.txt, 81.txt, 82.txt, 83.txt, 84.txt, 85.txt, 86.txt, 87.txt, 88.txt, s1.txt, s2.txt, s3.txt, s4.txt, s5.txt
Case Name Status Exec Time Memory
01.txt AC 56 ms 7804 KB
02.txt AC 51 ms 7872 KB
03.txt AC 55 ms 7848 KB
04.txt AC 53 ms 8048 KB
05.txt AC 59 ms 7988 KB
06.txt AC 53 ms 8000 KB
07.txt AC 54 ms 7856 KB
08.txt AC 52 ms 7996 KB
09.txt AC 55 ms 7868 KB
10.txt AC 52 ms 7904 KB
11.txt AC 52 ms 7916 KB
12.txt AC 56 ms 7800 KB
13.txt AC 51 ms 7968 KB
14.txt AC 54 ms 7852 KB
15.txt AC 54 ms 7856 KB
16.txt AC 53 ms 7920 KB
17.txt AC 54 ms 7980 KB
18.txt AC 53 ms 7868 KB
19.txt AC 92 ms 17896 KB
20.txt AC 90 ms 18016 KB
21.txt AC 88 ms 17988 KB
22.txt AC 94 ms 17964 KB
23.txt AC 93 ms 17904 KB
24.txt AC 89 ms 17780 KB
25.txt AC 48 ms 7252 KB
26.txt AC 38 ms 7316 KB
27.txt AC 37 ms 7324 KB
28.txt AC 31 ms 7324 KB
29.txt AC 93 ms 17960 KB
30.txt AC 95 ms 17944 KB
31.txt AC 61 ms 8724 KB
32.txt AC 59 ms 8700 KB
33.txt AC 60 ms 8720 KB
34.txt AC 60 ms 8736 KB
35.txt AC 63 ms 8592 KB
36.txt AC 58 ms 8588 KB
37.txt AC 94 ms 17892 KB
38.txt AC 91 ms 17884 KB
39.txt AC 55 ms 9828 KB
40.txt AC 57 ms 9780 KB
41.txt AC 54 ms 9668 KB
42.txt AC 56 ms 9764 KB
43.txt AC 55 ms 9804 KB
44.txt AC 57 ms 9712 KB
45.txt AC 55 ms 9708 KB
46.txt AC 54 ms 9644 KB
47.txt AC 56 ms 9800 KB
48.txt AC 53 ms 9780 KB
49.txt AC 55 ms 9768 KB
50.txt AC 52 ms 9716 KB
51.txt AC 87 ms 17944 KB
52.txt AC 85 ms 18016 KB
53.txt AC 88 ms 17768 KB
54.txt AC 82 ms 17976 KB
55.txt AC 66 ms 12292 KB
56.txt AC 67 ms 12240 KB
57.txt AC 75 ms 18016 KB
58.txt AC 76 ms 17784 KB
59.txt AC 79 ms 18000 KB
60.txt AC 75 ms 18012 KB
61.txt AC 79 ms 18016 KB
62.txt AC 75 ms 17832 KB
63.txt AC 79 ms 17780 KB
64.txt AC 78 ms 17944 KB
65.txt AC 81 ms 17832 KB
66.txt AC 83 ms 17952 KB
67.txt AC 84 ms 17976 KB
68.txt AC 79 ms 18016 KB
69.txt AC 81 ms 17984 KB
70.txt AC 82 ms 18012 KB
71.txt AC 88 ms 17880 KB
72.txt AC 93 ms 17884 KB
73.txt AC 78 ms 17828 KB
74.txt AC 74 ms 17852 KB
75.txt AC 92 ms 17780 KB
76.txt AC 91 ms 17840 KB
77.txt AC 2 ms 3600 KB
78.txt AC 2 ms 3632 KB
79.txt AC 2 ms 3648 KB
80.txt AC 2 ms 3600 KB
81.txt AC 2 ms 3520 KB
82.txt AC 2 ms 3576 KB
83.txt AC 2 ms 3604 KB
84.txt AC 2 ms 3524 KB
85.txt AC 38 ms 14156 KB
86.txt AC 43 ms 14152 KB
87.txt AC 2 ms 3648 KB
88.txt AC 2 ms 3692 KB
s1.txt AC 3 ms 3576 KB
s2.txt AC 2 ms 3604 KB
s3.txt AC 3 ms 3600 KB
s4.txt AC 2 ms 3596 KB
s5.txt AC 40 ms 14208 KB