結果
問題 | No.3064 う し た ぷ に き あ く ん 笑 |
ユーザー | NULLCT |
提出日時 | 2021-04-06 21:57:13 |
言語 | C++17(clang) (17.0.6 + boost 1.83.0) |
結果 |
WA
|
実行時間 | - |
コード長 | 11,267 bytes |
コンパイル時間 | 1,880 ms |
コンパイル使用メモリ | 153,876 KB |
実行使用メモリ | 6,948 KB |
最終ジャッジ日時 | 2024-06-11 19:55:36 |
合計ジャッジ時間 | 2,906 ms |
ジャッジサーバーID (参考情報) |
judge3 / judge1 |
(要ログイン)
テストケース
テストケース表示入力 | 結果 | 実行時間 実行使用メモリ |
---|---|---|
testcase_00 | WA | - |
testcase_01 | WA | - |
testcase_02 | WA | - |
testcase_03 | WA | - |
testcase_04 | WA | - |
testcase_05 | WA | - |
testcase_06 | WA | - |
testcase_07 | WA | - |
testcase_08 | WA | - |
testcase_09 | WA | - |
testcase_10 | WA | - |
testcase_11 | WA | - |
testcase_12 | WA | - |
testcase_13 | WA | - |
testcase_14 | WA | - |
testcase_15 | WA | - |
testcase_16 | WA | - |
testcase_17 | WA | - |
testcase_18 | WA | - |
testcase_19 | WA | - |
testcase_20 | WA | - |
testcase_21 | WA | - |
testcase_22 | WA | - |
testcase_23 | WA | - |
testcase_24 | WA | - |
testcase_25 | WA | - |
testcase_26 | WA | - |
testcase_27 | WA | - |
testcase_28 | WA | - |
testcase_29 | WA | - |
testcase_30 | WA | - |
testcase_31 | WA | - |
testcase_32 | WA | - |
testcase_33 | WA | - |
testcase_34 | WA | - |
testcase_35 | WA | - |
testcase_36 | WA | - |
testcase_37 | WA | - |
testcase_38 | WA | - |
testcase_39 | WA | - |
testcase_40 | WA | - |
testcase_41 | WA | - |
testcase_42 | WA | - |
testcase_43 | WA | - |
testcase_44 | WA | - |
testcase_45 | WA | - |
testcase_46 | WA | - |
ソースコード
/* _ ____ */ /* U /"\ u U /"___| */ /* \/ _ \/ \| | u */ /* / ___ \ | |/__ */ /* /_/ \_\ \____| */ /* \\ >> _// \\ */ /* (__) (__)(__)(__) */ /* github.com/NULLCT/Compro */ /* Copyriλht (c) NULLCT */ #pragma GCC optimize("O3") #include <algorithm> #include <array> #include <bitset> #include <cassert> #include <cctype> #include <chrono> #include <cinttypes> #include <climits> #include <cmath> #include <complex> #include <cstdint> #include <cstdio> #include <cstdlib> #include <deque> #include <functional> #include <iomanip> #include <ios> #include <iostream> #include <iterator> #include <list> #include <map> #include <numeric> #include <ostream> #include <queue> #include <set> #include <stack> #include <string> #include <thread> #include <tuple> #include <unordered_map> #include <unordered_set> #include <utility> #include <vector> #define int int64_t #define ALL(var) ((var).begin()), ((var).end()) #define LEN(var) (static_cast<int>((var).size())) #ifdef DEBUG # define PRINT(var) cout << "(\e[34m" << #var << "\e[0m \e[2m@" << __LINE__ << "\e[0m): \e[36m\e[1m" << var << "\e[0m" << endl; #else # define PRINT(var) ; #endif using namespace std; template <typename T> ostream &operator<<(ostream &_ostr, const vector<T> &_v); template <typename T> ostream &operator<<(ostream &_ostr, const deque<T> &_v); template <typename T> ostream &operator<<(ostream &_ostr, const list<T> &_v); template <typename T, typename Y> ostream &operator<<(ostream &_ostr, const pair<T, Y> &_v); template <class... Ts> ostream &operator<<(ostream &_ostr, const tuple<Ts...> &t); template <typename T, typename Y> ostream &operator<<(ostream &_ostr, const map<T, Y> &_v); template <typename T> ostream &operator<<(ostream &_ostr, const set<T> &_v); template <typename T, typename Y> ostream &operator<<(ostream &_ostr, const unordered_map<T, Y> &_v); template <typename T> ostream &operator<<(ostream &_ostr, const unordered_set<T> &_v); template <typename T> void dumpFromRangeList(ostream &_ostr, const T &_v) { _ostr << _v.size() << "{"; for (auto itr = _v.begin(); itr != _v.end(); itr++) { _ostr << *itr; if (next(itr,1) != _v.end()) _ostr << ","; } _ostr << "}"; } template <typename T> ostream &operator<<(ostream &_ostr, const vector<T> &_v) { _ostr << "v"; dumpFromRangeList(_ostr, _v); return _ostr; } template <typename T> ostream &operator<<(ostream &_ostr, const deque<T> &_v) { _ostr << "d"; dumpFromRangeList(_ostr, _v); return _ostr; } template <typename T> ostream &operator<<(ostream &_ostr, const list<T> &_v) { _ostr << "l"; dumpFromRangeList(_ostr, _v); return _ostr; } template <typename T, typename Y> ostream &operator<<(ostream &_ostr, const pair<T, Y> &_v) { _ostr << "p{" << _v.first << "," << _v.second << "}"; return _ostr; } template <class... Ts> ostream &operator<<(ostream &_ostr, const tuple<Ts...> &_v) { _ostr << "t{"; bool first = true; apply([&_ostr, &first](auto &&... args) { auto print = [&](auto &&val) { if (!first) _ostr << ","; (_ostr << val); first = false; }; (print(args), ...); }, _v); _ostr << "}"; return _ostr; } template <typename T, typename Y> ostream &operator<<(ostream &_ostr, const map<T, Y> &_v) { _ostr << "m"; dumpFromRangeList(_ostr, _v); return _ostr; } template <typename T, typename Y> ostream &operator<<(ostream &_ostr, const unordered_map<T, Y> &_v) { _ostr << "um"; dumpFromRangeList(_ostr, _v); return _ostr; } template <typename T> ostream &operator<<(ostream &_ostr, const set<T> &_v) { _ostr << "s"; dumpFromRangeList(_ostr, _v); return _ostr; } template <typename T> ostream &operator<<(ostream &_ostr, const unordered_set<T> &_v) { _ostr << "us"; dumpFromRangeList(_ostr, _v); return _ostr; } template <typename T> istream &operator>>(istream &_istr, vector<T> &_v); template <typename T> istream &operator>>(istream &_istr, deque<T> &_v); template <typename T> istream &operator>>(istream &_istr, vector<T> &_v){ for (auto &i : _v) _istr >> i; return _istr; } template <typename T> istream &operator>>(istream &_istr, deque<T> &_v){ for (auto &i : _v) _istr >> i; return _istr; } template <int MOD> class ModNum { public: int num; constexpr ModNum(int v = 0) : num(v % MOD) { if (num < 0) num += MOD; } constexpr int getmod() { return MOD; } constexpr ModNum operator-() const { return num ? MOD - num : 0; } constexpr ModNum operator+(const ModNum &r) { return ModNum(*this) += r; } constexpr ModNum operator-(const ModNum &r) { return ModNum(*this) -= r; } constexpr ModNum operator*(const ModNum &r) { return ModNum(*this) *= r; } constexpr ModNum operator/(const ModNum &r) { return ModNum(*this) /= r; } constexpr ModNum &operator+=(const ModNum &r) { num += r.num; if (num >= MOD) num -= MOD; return *this; } constexpr ModNum &operator-=(const ModNum &r) { num -= r.num; if (num < 0) num += MOD; return *this; } constexpr ModNum &operator*=(const ModNum &r) { num = num * r.num % MOD; return *this; } constexpr ModNum &operator/=(const ModNum &r) { int a = r.num, b = MOD, u = 1, v = 0; while (b) { int t = a / b; a -= t * b; swap(a, b); u -= t * v; swap(u, v); } num = num * u % MOD; if (num < 0) num += MOD; return *this; } constexpr bool operator==(const ModNum &r) { return this->num == r.num; } constexpr bool operator!=(const ModNum &r) { return this->num != r.val; } constexpr ModNum<MOD> modpow(const ModNum<MOD> &a, int n) { if (n == 0) return 1; auto t = modpow(a, n / 2); t = t * t; if (n & 1) t = t * a; return t; } friend constexpr ostream &operator<<(ostream &os, const ModNum<MOD> &x) { return os << x.num; } }; template <typename Monoid> class SegmentTree { public: using F = function<Monoid(Monoid, Monoid)>; int sz; vector<Monoid> seg; const F f; const Monoid M1; SegmentTree(int n, const F f, const Monoid &M1) : f(f), M1(M1) { sz = 1; while (sz < n) sz <<= 1; seg.assign(2 * sz, M1); } void set(int k, const Monoid &x) { seg[k + sz] = x; } void build() { for (int k = sz - 1; k > 0; k--) seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]); } void update(int k, const Monoid &x) { k += sz; seg[k] = x; while (k >>= 1) seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]); } Monoid query(int a, int b) { Monoid L = M1, R = M1; for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) { if (a & 1) L = f(L, seg[a++]); if (b & 1) R = f(seg[--b], R); } return f(L, R); } Monoid operator[](const int &k) const { return seg[k + sz]; } template <typename C> int find_subtree(int a, const C &check, Monoid &M, bool type) { while (a < sz) { Monoid nxt = type ? f(seg[2 * a + type], M) : f(M, seg[2 * a + type]); if (check(nxt)) a = 2 * a + type; else M = nxt, a = 2 * a + 1 - type; } return a - sz; } template <typename C> int find_first(int a, const C &check) { Monoid L = M1; if (a <= 0) { if (check(f(L, seg[1]))) return find_subtree(1, check, L, false); return -1; } int b = sz; for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) { if (a & 1) { Monoid nxt = f(L, seg[a]); if (check(nxt)) return find_subtree(a, check, L, false); L = nxt; ++a; } } return -1; } template <typename C> int find_last(int b, const C &check) { Monoid R = M1; if (b >= sz) { if (check(f(seg[1], R))) return find_subtree(1, check, R, true); return -1; } int a = sz; for (b += sz; a < b; a >>= 1, b >>= 1) { if (b & 1) { Monoid nxt = f(seg[--b], R); if (check(nxt)) return find_subtree(b, check, R, true); R = nxt; } } return -1; } }; class Graph { private: struct Edge { int to, cost; }; public: int V; vector<vector<Edge>> G; vector<int> d; Graph(int n) { init(n); } void init(int n) { V = n; G.resize(V); d.resize(V); for (int i = 0; i < V; i++) { d[i] = INT_MAX; } } void add_edge(int s, int t, int cost) { Edge e; e.to = t, e.cost = cost; G[s].push_back(e); } void dijkstra(int s) { for (int i = 0; i < V; i++) { d[i] = INT_MAX; } d[s] = 0; priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> que; que.push(make_pair(0, s)); while (!que.empty()) { pair<int, int> p = que.top(); que.pop(); int v = p.second; if (d[v] < p.first) continue; for (auto e : G[v]) { if (d[e.to] > d[v] + e.cost) { d[e.to] = d[v] + e.cost; que.push(make_pair(d[e.to], e.to)); } } } } }; class UnionFind { public: int n; vector<int> par; UnionFind() : n(0) {} UnionFind(int _n) : n(_n), par(_n, -1) {} int merge(int a, int b) { int x = root(a), y = root(b); if (x == y) return x; if (-par[x] < -par[y]) swap(x, y); par[x] += par[y]; par[y] = x; return x; } bool isSame(int a, int b) { return root(a) == root(b); } int root(int a) { if (par[a] < 0) return a; return par[a] = root(par[a]); } int size(int a) { return -par[root(a)]; } vector<vector<int>> groups() { vector<int> leader_buf(n), group_size(n); for (int i = 0; i < n; i++) { leader_buf[i] = root(i); group_size[leader_buf[i]]++; } vector<vector<int>> result(n); for (int i = 0; i < n; i++) result[i].reserve(group_size[i]); for (int i = 0; i < n; i++) result[leader_buf[i]].push_back(i); result.erase(remove_if(result.begin(), result.end(), [&](const vector<int> &v) { return v.empty(); }), result.end()); return result; } }; class Range { private: struct Cnt { int num; int operator*() { return num; } bool operator!=(const Cnt &_num) { return num < _num.num; } void operator++() { num++; } }; Cnt st, ed; public: Range(const int _end) : st({0}), ed({_end}) {} Range(const int _start, const int _end) : st({_start}), ed({_end}) {} Cnt &begin() { return st; } Cnt &end() { return ed; } }; vector<int> divisor(const int _n) { vector<int> head, tail; for (int i = 1; i * i <= _n; i++) { if (_n % i == 0) { head.push_back(i); if (i * i != _n) tail.push_back(_n / i); } } head.insert(head.end(), tail.rbegin(), tail.rend()); return head; } int dichotomy(int ng, int ok, function<bool(int)> discriminant) { while (ok - ng > 1) { int mid = (ng + ok) / 2; (discriminant(mid) ? ok : ng) = mid; } return ok; } void execution(); signed main() { cin.tie(nullptr); cout.tie(nullptr); ios::sync_with_stdio(false); cout << fixed << setprecision(10); execution(); } //-------------------------------------------------------------- inline void execution() { string s;cin>>s; cout<<s; }