problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
using namespace std;
int div2count(int x) {
int coun = 0;
while (!(x % 2)) {
x /= 2;
coun++;
}
return coun;
}
long long gcd(long long x, long long y) {
if (x < y) {
int temp = x;
x = y;
y = temp;
}
if (x % y) {
return gcd(y, x % y);
}
return y;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<int> div2(n);
cin >> a[0];
div2[0] = div2count(a[0]);
a[0] /= 2;
for (int i = 1; i < n; i++) {
cin >> a[i];
div2[i] = div2count(a[i]);
a[i] /= 2;
if (div2[i - 1] != div2[i]) {
cout << 0 << endl;
return 0;
}
}
long long lcm = a[0];
for (int i = 1; i < n; i++) {
lcm = lcm * a[i] / gcd(lcm, a[i]);
}
cout << (m / lcm + 1) / 2 << endl;
return 0;
}
| #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
using namespace std;
int div2count(int x) {
int coun = 0;
while (!(x % 2)) {
x /= 2;
coun++;
}
return coun;
}
long long gcd(long long x, long long y) {
if (x < y) {
int temp = x;
x = y;
y = temp;
}
if (x % y) {
return gcd(y, x % y);
}
return y;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
vector<int> div2(n);
cin >> a[0];
div2[0] = div2count(a[0]);
a[0] /= 2;
for (int i = 1; i < n; i++) {
cin >> a[i];
div2[i] = div2count(a[i]);
a[i] /= 2;
if (div2[i - 1] != div2[i]) {
cout << 0 << endl;
return 0;
}
}
long long lcm = a[0];
for (int i = 1; i < n; i++) {
lcm = lcm * a[i] / gcd(lcm, a[i]);
if (lcm > m) {
cout << 0 << endl;
return 0;
}
}
cout << (m / lcm + 1) / 2 << endl;
return 0;
}
| insert | 53 | 53 | 53 | 57 | TLE | |
p02814 | C++ | Time Limit Exceeded | /*
URL https://
SCORE 0
AC false
WA false
TLE false
MLE false
TASK_TYPE
FAILURE_TYPE
NOTES
*/
#include <algorithm>
#include <cstdint>
#include <experimental/optional>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
/* import STL */
// stream
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::flush;
// basic types
using std::nullptr_t;
using std::pair;
using std::string;
using std::tuple;
using std::experimental::optional;
// function for basic types
using std::get;
using std::make_pair;
using std::make_tuple;
using std::experimental::make_optional;
/* TODO remove them */
using std::queue;
using std::stack;
using std::vector;
// algorithms
using std::accumulate;
using std::lower_bound;
using std::max_element;
using std::min_element;
using std::nth_element;
using std::upper_bound;
/* macros */
// loops
#define REP(i, n) for (i64 i = 0; i < static_cast<decltype(i)>(n); ++i)
#define REPR(i, n) for (i64 i = (n)-1; i >= static_cast<decltype(i)>(0); --i)
#define FOR(i, n, m) for (i64 i = (n); i < static_cast<decltype(i)>(m); ++i)
#define FORR(i, n, m) for (i64 i = (m)-1; i >= static_cast<decltype(i)>(n); --i)
#define EACH(x, xs) for (auto &x : (xs))
#define EACH_V(x, xs) for (auto x : (xs))
// helpers
#define CTR(x) (x).begin(), (x).end()
/* utils for std::tuple */
namespace internal {
namespace tuple_utils { // TODO rename to "internal::tuple"
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Tuple, size_t... Is>
void read(std::istream &stream, Tuple &t, seq<Is...>) {
static_cast<void>((int[]){0, (void(stream >> get<Is>(t)), 0)...});
}
template <class Tuple, size_t... Is>
void print(std::ostream &stream, Tuple const &t, seq<Is...>) {
static_cast<void>(
(int[]){0, (void(stream << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...});
}
template <size_t I, class F, class A, class... Elems> struct ForEach {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
void operator()(A &arg, tuple<Elems...> &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
};
template <class F, class A, class... Elems> struct ForEach<0, F, A, Elems...> {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<0>(t));
}
void operator()(A &arg, tuple<Elems...> &t) const { F()(arg, get<0>(t)); }
};
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> const &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
} // namespace tuple_utils
} // namespace internal
/* utils for Matrix (definition of Matrix) */
namespace internal {
namespace matrix {
template <typename V, int N> struct matrix_t {
using type = std::vector<typename matrix_t<V, N - 1>::type>;
};
template <typename V> struct matrix_t<V, 0> {
using type = V;
};
template <typename V, int N> using Matrix = typename matrix_t<V, N>::type;
template <typename V, typename It, int N> struct matrix_helper {
static Matrix<V, N> create(const It &begin, const It &end,
const V &default_value) {
return Matrix<V, N>(*begin, matrix_helper<V, It, N - 1>::create(
begin + 1, end, default_value));
}
};
template <typename V, typename It> struct matrix_helper<V, It, 0> {
static Matrix<V, 0> create(const It &begin __attribute__((unused)),
const It &end __attribute__((unused)),
const V &default_value) {
return default_value;
}
};
} // namespace matrix
} // namespace internal
/* Primitive types */
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using usize = size_t;
/* Data structure type */
template <typename T> using Vector = std::vector<T>;
template <typename V> using OrderedSet = std::set<V>;
template <typename V> using HashSet = std::unordered_set<V>;
template <typename K, typename V> using OrderedMap = std::map<K, V>;
template <typename K, typename V> using HashMap = std::unordered_map<K, V>;
template <typename T, int N> using Matrix = internal::matrix::Matrix<T, N>;
template <typename T, typename Compare = std::less<T>,
typename Container = std::vector<T>>
using PriorityQueue = std::priority_queue<T, Container, Compare>;
/* utils for Vector */
template <typename V> Vector<V> make_pre_allocated_vector(size_t N) {
Vector<V> retval;
retval.reserve(N);
return retval;
}
/* utils for Matrix */
template <class V, int N>
Matrix<V, N> make_matrix(const std::array<size_t, N> &shape,
V default_value = V()) {
return internal::matrix::matrix_helper<V, decltype(shape.begin()), N>::create(
shape.begin(), shape.end(), default_value);
}
/* utils for STL iterators */
namespace internal {
template <typename Iterator, typename F> struct MappedIterator {
MappedIterator(const Iterator &it, const F &function)
: it(it), function(function) {}
auto operator*() const { return this->function(this->it); }
void operator++() { ++this->it; }
void operator+=(size_t n) { this->it += n; }
auto operator+(size_t n) const {
return MappedIterator<Iterator, F>(this->it + n, this->function);
}
bool operator==(const MappedIterator<Iterator, F> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const MappedIterator<Iterator, F> &rhs) const {
return !(*this == rhs);
}
private:
Iterator it;
F function;
};
template <typename Iterator, typename P> struct FilteredIterator {
FilteredIterator(const Iterator &it, const Iterator &end, const P &predicate)
: it(it), end(end), predicate(predicate) {
if (this->it != end) {
if (!predicate(this->it)) {
this->increment();
}
}
}
decltype(auto) operator*() const { return *this->it; }
auto operator->() const { return this->it; }
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool operator==(const FilteredIterator<Iterator, P> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const FilteredIterator<Iterator, P> &rhs) const {
return !(*this == rhs);
}
private:
void increment() {
if (this->it == this->end) {
return;
}
++this->it;
while (this->it != this->end && !this->predicate(this->it)) {
++this->it;
}
}
Iterator it;
Iterator end;
P predicate;
};
template <typename Iterator, typename ElementIterator>
struct FlattenedIterator {
FlattenedIterator(const Iterator &it, const Iterator &end)
: it(make_pair(it, ElementIterator())), end(end) {
if (this->it.first != this->end) {
this->it.second = it->begin();
}
this->find_valid();
}
decltype(auto) operator*() const { return this->it; }
const pair<Iterator, ElementIterator> *operator->() const {
return &this->it;
}
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool
operator==(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
if (this->it.first != rhs.it.first) {
return false;
}
if (this->it.first == this->end || rhs.it.first == rhs.end) {
if (this->end == rhs.end) {
return true;
} else {
return false;
}
} else {
return this->it.second == rhs.it.second;
}
}
bool
operator!=(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
return !(*this == rhs);
}
private:
bool is_end() const { return this->it.first == this->end; }
bool is_valid() const {
if (this->is_end())
return false;
if (this->it.second == this->it.first->end())
return false;
return true;
}
void _increment() {
if (this->it.second == this->it.first->end()) {
++this->it.first;
if (this->it.first != this->end) {
this->it.second = this->it.first->begin();
}
} else {
++this->it.second;
}
}
void find_valid() {
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
void increment() {
this->_increment();
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
pair<Iterator, ElementIterator> it;
Iterator end;
};
} // namespace internal
template <class Iterator> struct Container {
Container(const Iterator &begin, const Iterator &end)
: m_begin(begin), m_end(end) {}
const Iterator &begin() const { return this->m_begin; }
const Iterator &end() const { return this->m_end; }
Iterator m_begin;
Iterator m_end;
};
template <typename C, typename F> auto iterator_map(const C &c, F function) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::MappedIterator<Iterator, F>>(
internal::MappedIterator<Iterator, F>(c.begin(), function),
internal::MappedIterator<Iterator, F>(c.end(), function));
}
template <typename C, typename P>
auto iterator_filter(const C &c, P predicate) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::FilteredIterator<Iterator, P>>(
internal::FilteredIterator<Iterator, P>(c.begin(), c.end(), predicate),
internal::FilteredIterator<Iterator, P>(c.end(), c.end(), predicate));
}
template <typename C> auto iterator_flatten(const C &c) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
using ElementIterator = std::remove_const_t<
std::remove_reference_t<decltype(c.begin()->begin())>>;
return Container<internal::FlattenedIterator<Iterator, ElementIterator>>(
internal::FlattenedIterator<Iterator, ElementIterator>(c.begin(),
c.end()),
internal::FlattenedIterator<Iterator, ElementIterator>(c.end(), c.end()));
}
/* input */
template <class F, class S>
std::istream &operator>>(std::istream &stream, pair<F, S> &pair) {
stream >> pair.first;
stream >> pair.second;
return stream;
}
template <class... Args>
std::istream &operator>>(std::istream &stream, tuple<Args...> &tuple) {
internal::tuple_utils::read(
stream, tuple, internal::tuple_utils::gen_seq<sizeof...(Args)>());
return stream;
}
template <class T> T read() {
T t;
cin >> t;
return t;
}
template <class F, class S> pair<F, S> read() {
pair<F, S> p;
cin >> p;
return p;
}
template <class T1, class T2, class T3, class... Args>
tuple<T1, T2, T3, Args...> read() {
tuple<T1, T2, T3, Args...> t;
cin >> t;
return t;
}
template <typename T, typename F = std::function<T()>>
Vector<T> read(const usize length, F r) {
auto retval = make_pre_allocated_vector<T>(length);
REP(i, length) { retval.emplace_back(r()); }
return retval;
}
template <class T> Vector<T> read(const usize length) {
return read<T>(length, [] { return read<T>(); });
}
template <class F, class S> Vector<pair<F, S>> read(const usize length) {
return read<pair<F, S>>(length);
}
template <class T1, class T2, class T3, class... Args>
Vector<tuple<T1, T2, T3, Args...>> read(const usize length) {
return read<tuple<T1, T2, T3, Args...>>(length);
}
namespace internal {
template <typename T> struct oneline {
std::string operator()(const T &t) const {
std::ostringstream oss;
oss << t;
return oss.str();
}
};
template <typename F, typename S> struct oneline<pair<F, S>> {
std::string operator()(const pair<F, S> &p) const {
std::ostringstream oss;
oss << "{" << oneline<F>()(p.first) << ", " << oneline<S>()(p.second)
<< "}";
return oss.str();
}
};
template <typename... Args> struct oneline<tuple<Args...>> {
struct oneline_tuple {
template <class V>
void operator()(Vector<std::string> &strs, const V &v) const {
strs.emplace_back(oneline<V>()(v));
}
};
std::string operator()(const tuple<Args...> &t) const {
std::ostringstream oss;
Vector<std::string> strs;
internal::tuple_utils::for_each<oneline_tuple, Vector<std::string>,
Args...>(strs, t);
oss << "{";
REPR(i, strs.size()) {
oss << strs[i];
if (i != 0) {
oss << ", ";
}
}
oss << "}";
return oss.str();
}
};
template <> struct oneline<bool> {
std::string operator()(const bool b) const { return b ? "true" : "false"; }
};
template <typename X> struct oneline<Vector<X>> {
std::string operator()(const Vector<X> &vec) const {
std::string retval = "[";
auto f = oneline<X>();
REP(i, vec.size()) {
retval += f(vec[i]);
if (i != static_cast<i64>(vec.size() - 1)) {
retval += ", ";
}
}
retval += "]";
return retval;
}
};
template <typename X> struct oneline<OrderedSet<X>> {
std::string operator()(const OrderedSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename X> struct oneline<HashSet<X>> {
std::string operator()(const HashSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<OrderedMap<K, V>> {
std::string operator()(const OrderedMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<HashMap<K, V>> {
std::string operator()(const HashMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename V> struct keys { /* no implementation */
};
template <typename X> struct keys<std::vector<X>> {
Vector<size_t> operator()(const Vector<X> &v) const {
Vector<size_t> keys;
REP(i, v.size()) { keys.emplace_back(i); }
return keys;
}
};
template <typename K, typename V> struct keys<OrderedMap<K, V>> {
Vector<K> operator()(const OrderedMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
template <typename K, typename V> struct keys<HashMap<K, V>> {
Vector<K> operator()(const HashMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
} // namespace internal
template <typename T> void dump(const T &t) {
using namespace internal;
std::cerr << oneline<T>()(t) << std::endl;
}
template <typename V1, typename V2, typename... Args>
void dump(const V1 &v1, const V2 &v2, const Args &...args) {
using namespace internal;
using F = typename oneline<tuple<V1, V2, Args...>>::oneline_tuple;
auto x = std::make_tuple(v1, v2, args...);
Vector<std::string> strs;
internal::tuple_utils::for_each<F, Vector<std::string>, V1, V2, Args...>(strs,
x);
REPR(i, strs.size()) {
std::cerr << strs[i];
if (i != 0) {
std::cerr << ", ";
}
}
std::cerr << std::endl;
}
template <typename C> std::string as_set(const C &ctr) {
Vector<std::string> values;
using namespace internal;
EACH(x, ctr) { values.emplace_back(oneline<decltype(x)>()(x)); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_map(const C &ctr) {
using namespace internal;
auto ks = keys<C>()(ctr);
Vector<std::string> keys;
Vector<std::string> values;
EACH(key, ks) {
keys.emplace_back(oneline<decltype(key)>()(key));
values.emplace_back(oneline<decltype(ctr.at(key))>()(ctr.at(key)));
}
size_t l = 0;
EACH(key, keys) { l = std::max(l, key.size()); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += keys[i];
REP(j, l - keys[i].size()) { retval += " "; }
retval += ": ";
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_table(const C &ctr) {
using namespace internal;
auto rkeys = keys<C>()(ctr);
auto ckeys = OrderedSet<std::string>();
auto values =
Vector<pair<std::string, OrderedMap<std::string, std::string>>>();
/* Stringify all data */
EACH(rkey, rkeys) {
auto rkey_str = oneline<decltype(rkey)>()(rkey);
values.emplace_back(rkey_str, OrderedMap<std::string, std::string>());
auto row = ctr.at(rkey);
auto ks = keys<decltype(row)>()(row);
EACH(ckey, ks) {
auto ckey_str = oneline<decltype(ckey)>()(ckey);
ckeys.emplace(ckey_str);
values.back().second.emplace(
ckey_str, oneline<decltype(row.at(ckey))>()(row.at(ckey)));
}
}
/* Calculate string length */
size_t max_row_key_length = 0;
EACH(value, values) {
max_row_key_length = std::max(max_row_key_length, value.first.size());
}
OrderedMap<std::string, size_t> max_col_length;
EACH(ckey, ckeys) { max_col_length.emplace(ckey, ckey.size()); }
EACH(value, values) {
EACH(elem, value.second) {
auto ckey = elem.first;
auto value = elem.second;
max_col_length[ckey] = std::max(max_col_length[ckey], value.size());
}
}
std::string retval = "---\n";
/* Header */
REP(i, max_row_key_length) { retval += " "; }
retval += " ";
size_t cnt = 0;
EACH(ckey, ckeys) {
retval += ckey;
REP(j, max_col_length[ckey] - ckey.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n------\n";
/* Values */
EACH(value, values) {
retval += value.first;
REP(i, max_row_key_length - value.first.size()) { retval += " "; }
retval += "| ";
size_t cnt = 0;
EACH(ckey, ckeys) {
auto v = std::string("");
if (value.second.find(ckey) != value.second.end()) {
v = value.second.at(ckey);
}
retval += v;
REP(j, max_col_length[ckey] - v.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n";
}
retval += "---";
return retval;
}
// Hash
namespace std {
template <class F, class S> struct hash<pair<F, S>> {
size_t operator()(const pair<F, S> &p) const {
return hash<F>()(p.first) ^ hash<S>()(p.second);
}
};
template <class... Args> struct hash<tuple<Args...>> {
struct hash_for_element {
template <class V> void operator()(size_t &size, const V &v) const {
size ^= std::hash<V>()(v);
}
};
size_t operator()(const tuple<Args...> &t) const {
size_t retval = 0;
internal::tuple_utils::for_each<hash_for_element, size_t, Args...>(retval,
t);
return retval;
}
};
} // namespace std
#define MAIN
void body();
// main function (DO NOT EDIT)
int main(int argc, char **argv) {
cin.tie(0);
std::ios_base::sync_with_stdio(false);
cout << std::fixed;
body();
return 0;
}
#ifndef MAIN
#include "common.cc"
#endif
static i64 mod(i64 a, i64 m) { return (a % m + m) % m; }
/*
* n^r
*/
template <class V> static V pow(V n, i64 r) {
if (r == 0) {
return 1;
}
auto r2 = r / 2;
auto x2 = pow(n, r2);
return x2 * x2 * ((r % 2 == 0) ? 1 : n);
}
static i64 gcd(i64 a, i64 b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class Iterator>
static i64 gcd_ctr(const Iterator &begin, const Iterator &end) {
if (begin == end) {
return -1;
} else {
auto ans = *begin;
auto it = begin;
++it;
for (; it != end; ++it) {
auto x = *it;
ans = gcd(ans, x);
}
return ans;
}
}
static i64 gcd_ctr(const Vector<i64> &xs) {
return gcd_ctr(xs.begin(), xs.end());
}
/*
* a * get<0>(r) + b * get<1>(r) = get<2>(r), get<2>(r) = gcd(a, b)
*/
static tuple<i64, i64, i64> ext_gcd(i64 a, i64 b) {
auto ext_gcd_ = [](i64 a, i64 b, i64 &p, i64 &q, auto f) -> i64 {
if (b == 0) {
p = 1;
q = 0;
return a;
}
i64 d = f(b, a % b, q, p, f);
q -= a / b * p;
return d;
};
i64 p = 0, q = 0;
auto d = ext_gcd_(a, b, p, q, ext_gcd_);
return make_tuple(p, q, d);
}
static i64 lcm(i64 a, i64 b) {
auto x = gcd(a, b);
return a / x * b;
}
template <class Iterator>
static i64 lcm_ctr(const Iterator &begin, const Iterator &end) {
if (begin == end) {
return -1;
} else {
auto ans = *begin;
auto it = begin;
++it;
for (; it != end; ++it) {
auto x = *it;
ans = lcm(ans, x);
}
return ans;
}
}
static i64 lcm_ctr(const Vector<i64> &xs) {
return lcm_ctr(xs.begin(), xs.end());
}
template <class V> static V combination(V n, i64 r) {
if (r == 0) {
return 1;
}
V x = 1;
FOR(d, 1, r + 1) {
x *= n;
n -= 1;
x /= d;
}
return x;
}
static bool is_prime(i64 n) {
if (n <= 1)
return false;
for (i64 i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
static Vector<i64> divisor(i64 n) {
Vector<i64> res;
for (i64 i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i)
res.push_back(n / i);
}
}
return res;
}
static HashMap<i64, size_t> prime_factor(i64 n) {
HashMap<i64, size_t> res;
for (i64 i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i] += 1;
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
static pair<Vector<i64>, Vector<bool>> sieve(i64 n) {
Vector<i64> prime;
Vector<bool> is_prime_(n + 1, true);
is_prime_[0] = is_prime_[1] = false;
FOR(i, 2, n + 1) {
if (is_prime_[i]) {
prime.push_back(i);
for (i64 j = 2 * i; j <= n; j += i) {
is_prime_[j] = false;
}
}
}
return {prime, is_prime_};
}
/*
* x = b1 (mod m1)
* x = b2 (mod m2)
* => x = r.first (mod r.second) (r is a return value)
*/
static std::experimental::optional<pair<i64, i64>> chinese_rem(i64 b1, i64 m1,
i64 b2, i64 m2) {
auto elem = ext_gcd(m1, m2);
auto p = get<0>(elem);
auto d = get<2>(elem);
if ((b2 - b1) % d != 0)
return {};
i64 m = m1 * (m2 / d); //< lcm(m1, m2)
i64 r = mod(b1 + m1 * ((b2 - b1) / d * p % (m2 / d)), m);
return make_optional(std::make_pair(r, m));
}
template <typename Iterator1, typename Iterator2>
static std::experimental::optional<pair<i64, i64>>
chinese_rem_ctr(Iterator1 b_begin, Iterator1 b_end, Iterator2 m_begin,
Iterator2 m_end) {
i64 r = 0, M = 1;
auto b = b_begin;
auto m = m_begin;
for (; b != b_end && m != m_end; ++b, ++m) {
auto elem = ext_gcd(M, *m);
auto p = get<0>(elem);
auto d = get<2>(elem);
if ((*b - r) % d != 0)
return {};
r += M * ((*b - r) / d * p % (*m / d));
M *= *m / d;
}
return make_optional(std::make_pair(mod(r, M), M));
}
static std::experimental::optional<pair<i64, i64>>
chinese_rem_ctr(const Vector<i64> &b, const Vector<i64> &m) {
return chinese_rem_ctr<decltype(b.begin()), decltype(m.begin())>(CTR(b),
CTR(m));
}
void body() {
auto N = read<i64>();
auto M = read<i64>();
auto as = read<i64>(N);
auto As = Vector<i64>();
EACH(a, as) {
a /= 2;
As.push_back(a);
}
auto Y = lcm_ctr(CTR(As));
i64 p = -1;
EACH(A, As) {
auto i = prime_factor(A)[2];
if (p < 0) {
p = i;
}
if (p != i) {
cout << 0 << endl;
return;
}
}
if (M < Y) {
cout << 0 << endl;
return;
}
auto ans = (M / Y + 1) / 2;
cout << ans << endl;
}
| /*
URL https://
SCORE 0
AC false
WA false
TLE false
MLE false
TASK_TYPE
FAILURE_TYPE
NOTES
*/
#include <algorithm>
#include <cstdint>
#include <experimental/optional>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
/* import STL */
// stream
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::flush;
// basic types
using std::nullptr_t;
using std::pair;
using std::string;
using std::tuple;
using std::experimental::optional;
// function for basic types
using std::get;
using std::make_pair;
using std::make_tuple;
using std::experimental::make_optional;
/* TODO remove them */
using std::queue;
using std::stack;
using std::vector;
// algorithms
using std::accumulate;
using std::lower_bound;
using std::max_element;
using std::min_element;
using std::nth_element;
using std::upper_bound;
/* macros */
// loops
#define REP(i, n) for (i64 i = 0; i < static_cast<decltype(i)>(n); ++i)
#define REPR(i, n) for (i64 i = (n)-1; i >= static_cast<decltype(i)>(0); --i)
#define FOR(i, n, m) for (i64 i = (n); i < static_cast<decltype(i)>(m); ++i)
#define FORR(i, n, m) for (i64 i = (m)-1; i >= static_cast<decltype(i)>(n); --i)
#define EACH(x, xs) for (auto &x : (xs))
#define EACH_V(x, xs) for (auto x : (xs))
// helpers
#define CTR(x) (x).begin(), (x).end()
/* utils for std::tuple */
namespace internal {
namespace tuple_utils { // TODO rename to "internal::tuple"
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Tuple, size_t... Is>
void read(std::istream &stream, Tuple &t, seq<Is...>) {
static_cast<void>((int[]){0, (void(stream >> get<Is>(t)), 0)...});
}
template <class Tuple, size_t... Is>
void print(std::ostream &stream, Tuple const &t, seq<Is...>) {
static_cast<void>(
(int[]){0, (void(stream << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...});
}
template <size_t I, class F, class A, class... Elems> struct ForEach {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
void operator()(A &arg, tuple<Elems...> &t) const {
F()(arg, get<I>(t));
ForEach<I - 1, F, A, Elems...>()(arg, t);
}
};
template <class F, class A, class... Elems> struct ForEach<0, F, A, Elems...> {
void operator()(A &arg, tuple<Elems...> const &t) const {
F()(arg, get<0>(t));
}
void operator()(A &arg, tuple<Elems...> &t) const { F()(arg, get<0>(t)); }
};
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> const &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
template <class F, class A, class... Elems>
void for_each(A &arg, tuple<Elems...> &t) {
ForEach<std::tuple_size<tuple<Elems...>>::value - 1, F, A, Elems...>()(arg,
t);
}
} // namespace tuple_utils
} // namespace internal
/* utils for Matrix (definition of Matrix) */
namespace internal {
namespace matrix {
template <typename V, int N> struct matrix_t {
using type = std::vector<typename matrix_t<V, N - 1>::type>;
};
template <typename V> struct matrix_t<V, 0> {
using type = V;
};
template <typename V, int N> using Matrix = typename matrix_t<V, N>::type;
template <typename V, typename It, int N> struct matrix_helper {
static Matrix<V, N> create(const It &begin, const It &end,
const V &default_value) {
return Matrix<V, N>(*begin, matrix_helper<V, It, N - 1>::create(
begin + 1, end, default_value));
}
};
template <typename V, typename It> struct matrix_helper<V, It, 0> {
static Matrix<V, 0> create(const It &begin __attribute__((unused)),
const It &end __attribute__((unused)),
const V &default_value) {
return default_value;
}
};
} // namespace matrix
} // namespace internal
/* Primitive types */
using i8 = int8_t;
using u8 = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using usize = size_t;
/* Data structure type */
template <typename T> using Vector = std::vector<T>;
template <typename V> using OrderedSet = std::set<V>;
template <typename V> using HashSet = std::unordered_set<V>;
template <typename K, typename V> using OrderedMap = std::map<K, V>;
template <typename K, typename V> using HashMap = std::unordered_map<K, V>;
template <typename T, int N> using Matrix = internal::matrix::Matrix<T, N>;
template <typename T, typename Compare = std::less<T>,
typename Container = std::vector<T>>
using PriorityQueue = std::priority_queue<T, Container, Compare>;
/* utils for Vector */
template <typename V> Vector<V> make_pre_allocated_vector(size_t N) {
Vector<V> retval;
retval.reserve(N);
return retval;
}
/* utils for Matrix */
template <class V, int N>
Matrix<V, N> make_matrix(const std::array<size_t, N> &shape,
V default_value = V()) {
return internal::matrix::matrix_helper<V, decltype(shape.begin()), N>::create(
shape.begin(), shape.end(), default_value);
}
/* utils for STL iterators */
namespace internal {
template <typename Iterator, typename F> struct MappedIterator {
MappedIterator(const Iterator &it, const F &function)
: it(it), function(function) {}
auto operator*() const { return this->function(this->it); }
void operator++() { ++this->it; }
void operator+=(size_t n) { this->it += n; }
auto operator+(size_t n) const {
return MappedIterator<Iterator, F>(this->it + n, this->function);
}
bool operator==(const MappedIterator<Iterator, F> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const MappedIterator<Iterator, F> &rhs) const {
return !(*this == rhs);
}
private:
Iterator it;
F function;
};
template <typename Iterator, typename P> struct FilteredIterator {
FilteredIterator(const Iterator &it, const Iterator &end, const P &predicate)
: it(it), end(end), predicate(predicate) {
if (this->it != end) {
if (!predicate(this->it)) {
this->increment();
}
}
}
decltype(auto) operator*() const { return *this->it; }
auto operator->() const { return this->it; }
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool operator==(const FilteredIterator<Iterator, P> &rhs) const {
return this->it == rhs.it;
}
bool operator!=(const FilteredIterator<Iterator, P> &rhs) const {
return !(*this == rhs);
}
private:
void increment() {
if (this->it == this->end) {
return;
}
++this->it;
while (this->it != this->end && !this->predicate(this->it)) {
++this->it;
}
}
Iterator it;
Iterator end;
P predicate;
};
template <typename Iterator, typename ElementIterator>
struct FlattenedIterator {
FlattenedIterator(const Iterator &it, const Iterator &end)
: it(make_pair(it, ElementIterator())), end(end) {
if (this->it.first != this->end) {
this->it.second = it->begin();
}
this->find_valid();
}
decltype(auto) operator*() const { return this->it; }
const pair<Iterator, ElementIterator> *operator->() const {
return &this->it;
}
void operator++() { this->increment(); }
void operator+=(size_t n) {
REP(i, n) { this->increment(); }
}
auto operator+(size_t n) const {
auto retval = *this;
retval += n;
return retval;
}
bool
operator==(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
if (this->it.first != rhs.it.first) {
return false;
}
if (this->it.first == this->end || rhs.it.first == rhs.end) {
if (this->end == rhs.end) {
return true;
} else {
return false;
}
} else {
return this->it.second == rhs.it.second;
}
}
bool
operator!=(const FlattenedIterator<Iterator, ElementIterator> &rhs) const {
return !(*this == rhs);
}
private:
bool is_end() const { return this->it.first == this->end; }
bool is_valid() const {
if (this->is_end())
return false;
if (this->it.second == this->it.first->end())
return false;
return true;
}
void _increment() {
if (this->it.second == this->it.first->end()) {
++this->it.first;
if (this->it.first != this->end) {
this->it.second = this->it.first->begin();
}
} else {
++this->it.second;
}
}
void find_valid() {
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
void increment() {
this->_increment();
while (!this->is_end() && !this->is_valid()) {
this->_increment();
}
}
pair<Iterator, ElementIterator> it;
Iterator end;
};
} // namespace internal
template <class Iterator> struct Container {
Container(const Iterator &begin, const Iterator &end)
: m_begin(begin), m_end(end) {}
const Iterator &begin() const { return this->m_begin; }
const Iterator &end() const { return this->m_end; }
Iterator m_begin;
Iterator m_end;
};
template <typename C, typename F> auto iterator_map(const C &c, F function) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::MappedIterator<Iterator, F>>(
internal::MappedIterator<Iterator, F>(c.begin(), function),
internal::MappedIterator<Iterator, F>(c.end(), function));
}
template <typename C, typename P>
auto iterator_filter(const C &c, P predicate) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
return Container<internal::FilteredIterator<Iterator, P>>(
internal::FilteredIterator<Iterator, P>(c.begin(), c.end(), predicate),
internal::FilteredIterator<Iterator, P>(c.end(), c.end(), predicate));
}
template <typename C> auto iterator_flatten(const C &c) {
using Iterator =
std::remove_const_t<std::remove_reference_t<decltype(c.begin())>>;
using ElementIterator = std::remove_const_t<
std::remove_reference_t<decltype(c.begin()->begin())>>;
return Container<internal::FlattenedIterator<Iterator, ElementIterator>>(
internal::FlattenedIterator<Iterator, ElementIterator>(c.begin(),
c.end()),
internal::FlattenedIterator<Iterator, ElementIterator>(c.end(), c.end()));
}
/* input */
template <class F, class S>
std::istream &operator>>(std::istream &stream, pair<F, S> &pair) {
stream >> pair.first;
stream >> pair.second;
return stream;
}
template <class... Args>
std::istream &operator>>(std::istream &stream, tuple<Args...> &tuple) {
internal::tuple_utils::read(
stream, tuple, internal::tuple_utils::gen_seq<sizeof...(Args)>());
return stream;
}
template <class T> T read() {
T t;
cin >> t;
return t;
}
template <class F, class S> pair<F, S> read() {
pair<F, S> p;
cin >> p;
return p;
}
template <class T1, class T2, class T3, class... Args>
tuple<T1, T2, T3, Args...> read() {
tuple<T1, T2, T3, Args...> t;
cin >> t;
return t;
}
template <typename T, typename F = std::function<T()>>
Vector<T> read(const usize length, F r) {
auto retval = make_pre_allocated_vector<T>(length);
REP(i, length) { retval.emplace_back(r()); }
return retval;
}
template <class T> Vector<T> read(const usize length) {
return read<T>(length, [] { return read<T>(); });
}
template <class F, class S> Vector<pair<F, S>> read(const usize length) {
return read<pair<F, S>>(length);
}
template <class T1, class T2, class T3, class... Args>
Vector<tuple<T1, T2, T3, Args...>> read(const usize length) {
return read<tuple<T1, T2, T3, Args...>>(length);
}
namespace internal {
template <typename T> struct oneline {
std::string operator()(const T &t) const {
std::ostringstream oss;
oss << t;
return oss.str();
}
};
template <typename F, typename S> struct oneline<pair<F, S>> {
std::string operator()(const pair<F, S> &p) const {
std::ostringstream oss;
oss << "{" << oneline<F>()(p.first) << ", " << oneline<S>()(p.second)
<< "}";
return oss.str();
}
};
template <typename... Args> struct oneline<tuple<Args...>> {
struct oneline_tuple {
template <class V>
void operator()(Vector<std::string> &strs, const V &v) const {
strs.emplace_back(oneline<V>()(v));
}
};
std::string operator()(const tuple<Args...> &t) const {
std::ostringstream oss;
Vector<std::string> strs;
internal::tuple_utils::for_each<oneline_tuple, Vector<std::string>,
Args...>(strs, t);
oss << "{";
REPR(i, strs.size()) {
oss << strs[i];
if (i != 0) {
oss << ", ";
}
}
oss << "}";
return oss.str();
}
};
template <> struct oneline<bool> {
std::string operator()(const bool b) const { return b ? "true" : "false"; }
};
template <typename X> struct oneline<Vector<X>> {
std::string operator()(const Vector<X> &vec) const {
std::string retval = "[";
auto f = oneline<X>();
REP(i, vec.size()) {
retval += f(vec[i]);
if (i != static_cast<i64>(vec.size() - 1)) {
retval += ", ";
}
}
retval += "]";
return retval;
}
};
template <typename X> struct oneline<OrderedSet<X>> {
std::string operator()(const OrderedSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename X> struct oneline<HashSet<X>> {
std::string operator()(const HashSet<X> &s) const {
std::string retval = "{";
auto f = oneline<X>();
size_t ctr = 0;
EACH(x, s) {
retval += f(x);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<OrderedMap<K, V>> {
std::string operator()(const OrderedMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename K, typename V> struct oneline<HashMap<K, V>> {
std::string operator()(const HashMap<K, V> &s) const {
std::string retval = "{";
auto f1 = oneline<K>();
auto f2 = oneline<V>();
size_t ctr = 0;
EACH(x, s) {
retval += f1(x.first);
retval += ": ";
retval += f2(x.second);
ctr += 1;
if (ctr != s.size()) {
retval += ", ";
}
}
retval += "}";
return retval;
}
};
template <typename V> struct keys { /* no implementation */
};
template <typename X> struct keys<std::vector<X>> {
Vector<size_t> operator()(const Vector<X> &v) const {
Vector<size_t> keys;
REP(i, v.size()) { keys.emplace_back(i); }
return keys;
}
};
template <typename K, typename V> struct keys<OrderedMap<K, V>> {
Vector<K> operator()(const OrderedMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
template <typename K, typename V> struct keys<HashMap<K, V>> {
Vector<K> operator()(const HashMap<K, V> &c) const {
Vector<K> keys;
EACH(elem, c) { keys.emplace_back(elem.first); }
return keys;
}
};
} // namespace internal
template <typename T> void dump(const T &t) {
using namespace internal;
std::cerr << oneline<T>()(t) << std::endl;
}
template <typename V1, typename V2, typename... Args>
void dump(const V1 &v1, const V2 &v2, const Args &...args) {
using namespace internal;
using F = typename oneline<tuple<V1, V2, Args...>>::oneline_tuple;
auto x = std::make_tuple(v1, v2, args...);
Vector<std::string> strs;
internal::tuple_utils::for_each<F, Vector<std::string>, V1, V2, Args...>(strs,
x);
REPR(i, strs.size()) {
std::cerr << strs[i];
if (i != 0) {
std::cerr << ", ";
}
}
std::cerr << std::endl;
}
template <typename C> std::string as_set(const C &ctr) {
Vector<std::string> values;
using namespace internal;
EACH(x, ctr) { values.emplace_back(oneline<decltype(x)>()(x)); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_map(const C &ctr) {
using namespace internal;
auto ks = keys<C>()(ctr);
Vector<std::string> keys;
Vector<std::string> values;
EACH(key, ks) {
keys.emplace_back(oneline<decltype(key)>()(key));
values.emplace_back(oneline<decltype(ctr.at(key))>()(ctr.at(key)));
}
size_t l = 0;
EACH(key, keys) { l = std::max(l, key.size()); }
std::string retval = "---\n";
REP(i, values.size()) {
retval += keys[i];
REP(j, l - keys[i].size()) { retval += " "; }
retval += ": ";
retval += values[i];
retval += "\n";
}
retval += "---";
return retval;
}
template <typename C> std::string as_table(const C &ctr) {
using namespace internal;
auto rkeys = keys<C>()(ctr);
auto ckeys = OrderedSet<std::string>();
auto values =
Vector<pair<std::string, OrderedMap<std::string, std::string>>>();
/* Stringify all data */
EACH(rkey, rkeys) {
auto rkey_str = oneline<decltype(rkey)>()(rkey);
values.emplace_back(rkey_str, OrderedMap<std::string, std::string>());
auto row = ctr.at(rkey);
auto ks = keys<decltype(row)>()(row);
EACH(ckey, ks) {
auto ckey_str = oneline<decltype(ckey)>()(ckey);
ckeys.emplace(ckey_str);
values.back().second.emplace(
ckey_str, oneline<decltype(row.at(ckey))>()(row.at(ckey)));
}
}
/* Calculate string length */
size_t max_row_key_length = 0;
EACH(value, values) {
max_row_key_length = std::max(max_row_key_length, value.first.size());
}
OrderedMap<std::string, size_t> max_col_length;
EACH(ckey, ckeys) { max_col_length.emplace(ckey, ckey.size()); }
EACH(value, values) {
EACH(elem, value.second) {
auto ckey = elem.first;
auto value = elem.second;
max_col_length[ckey] = std::max(max_col_length[ckey], value.size());
}
}
std::string retval = "---\n";
/* Header */
REP(i, max_row_key_length) { retval += " "; }
retval += " ";
size_t cnt = 0;
EACH(ckey, ckeys) {
retval += ckey;
REP(j, max_col_length[ckey] - ckey.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n------\n";
/* Values */
EACH(value, values) {
retval += value.first;
REP(i, max_row_key_length - value.first.size()) { retval += " "; }
retval += "| ";
size_t cnt = 0;
EACH(ckey, ckeys) {
auto v = std::string("");
if (value.second.find(ckey) != value.second.end()) {
v = value.second.at(ckey);
}
retval += v;
REP(j, max_col_length[ckey] - v.size()) { retval += " "; }
cnt += 1;
if (cnt != ckeys.size()) {
retval += ", ";
}
}
retval += "\n";
}
retval += "---";
return retval;
}
// Hash
namespace std {
template <class F, class S> struct hash<pair<F, S>> {
size_t operator()(const pair<F, S> &p) const {
return hash<F>()(p.first) ^ hash<S>()(p.second);
}
};
template <class... Args> struct hash<tuple<Args...>> {
struct hash_for_element {
template <class V> void operator()(size_t &size, const V &v) const {
size ^= std::hash<V>()(v);
}
};
size_t operator()(const tuple<Args...> &t) const {
size_t retval = 0;
internal::tuple_utils::for_each<hash_for_element, size_t, Args...>(retval,
t);
return retval;
}
};
} // namespace std
#define MAIN
void body();
// main function (DO NOT EDIT)
int main(int argc, char **argv) {
cin.tie(0);
std::ios_base::sync_with_stdio(false);
cout << std::fixed;
body();
return 0;
}
#ifndef MAIN
#include "common.cc"
#endif
static i64 mod(i64 a, i64 m) { return (a % m + m) % m; }
/*
* n^r
*/
template <class V> static V pow(V n, i64 r) {
if (r == 0) {
return 1;
}
auto r2 = r / 2;
auto x2 = pow(n, r2);
return x2 * x2 * ((r % 2 == 0) ? 1 : n);
}
static i64 gcd(i64 a, i64 b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class Iterator>
static i64 gcd_ctr(const Iterator &begin, const Iterator &end) {
if (begin == end) {
return -1;
} else {
auto ans = *begin;
auto it = begin;
++it;
for (; it != end; ++it) {
auto x = *it;
ans = gcd(ans, x);
}
return ans;
}
}
static i64 gcd_ctr(const Vector<i64> &xs) {
return gcd_ctr(xs.begin(), xs.end());
}
/*
* a * get<0>(r) + b * get<1>(r) = get<2>(r), get<2>(r) = gcd(a, b)
*/
static tuple<i64, i64, i64> ext_gcd(i64 a, i64 b) {
auto ext_gcd_ = [](i64 a, i64 b, i64 &p, i64 &q, auto f) -> i64 {
if (b == 0) {
p = 1;
q = 0;
return a;
}
i64 d = f(b, a % b, q, p, f);
q -= a / b * p;
return d;
};
i64 p = 0, q = 0;
auto d = ext_gcd_(a, b, p, q, ext_gcd_);
return make_tuple(p, q, d);
}
static i64 lcm(i64 a, i64 b) {
auto x = gcd(a, b);
return a / x * b;
}
template <class Iterator>
static i64 lcm_ctr(const Iterator &begin, const Iterator &end) {
if (begin == end) {
return -1;
} else {
auto ans = *begin;
auto it = begin;
++it;
for (; it != end; ++it) {
auto x = *it;
ans = lcm(ans, x);
}
return ans;
}
}
static i64 lcm_ctr(const Vector<i64> &xs) {
return lcm_ctr(xs.begin(), xs.end());
}
template <class V> static V combination(V n, i64 r) {
if (r == 0) {
return 1;
}
V x = 1;
FOR(d, 1, r + 1) {
x *= n;
n -= 1;
x /= d;
}
return x;
}
static bool is_prime(i64 n) {
if (n <= 1)
return false;
for (i64 i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
static Vector<i64> divisor(i64 n) {
Vector<i64> res;
for (i64 i = 2; i * i <= n; i++) {
if (n % i == 0) {
res.push_back(i);
if (i != n / i)
res.push_back(n / i);
}
}
return res;
}
static HashMap<i64, size_t> prime_factor(i64 n) {
HashMap<i64, size_t> res;
for (i64 i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i] += 1;
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
static pair<Vector<i64>, Vector<bool>> sieve(i64 n) {
Vector<i64> prime;
Vector<bool> is_prime_(n + 1, true);
is_prime_[0] = is_prime_[1] = false;
FOR(i, 2, n + 1) {
if (is_prime_[i]) {
prime.push_back(i);
for (i64 j = 2 * i; j <= n; j += i) {
is_prime_[j] = false;
}
}
}
return {prime, is_prime_};
}
/*
* x = b1 (mod m1)
* x = b2 (mod m2)
* => x = r.first (mod r.second) (r is a return value)
*/
static std::experimental::optional<pair<i64, i64>> chinese_rem(i64 b1, i64 m1,
i64 b2, i64 m2) {
auto elem = ext_gcd(m1, m2);
auto p = get<0>(elem);
auto d = get<2>(elem);
if ((b2 - b1) % d != 0)
return {};
i64 m = m1 * (m2 / d); //< lcm(m1, m2)
i64 r = mod(b1 + m1 * ((b2 - b1) / d * p % (m2 / d)), m);
return make_optional(std::make_pair(r, m));
}
template <typename Iterator1, typename Iterator2>
static std::experimental::optional<pair<i64, i64>>
chinese_rem_ctr(Iterator1 b_begin, Iterator1 b_end, Iterator2 m_begin,
Iterator2 m_end) {
i64 r = 0, M = 1;
auto b = b_begin;
auto m = m_begin;
for (; b != b_end && m != m_end; ++b, ++m) {
auto elem = ext_gcd(M, *m);
auto p = get<0>(elem);
auto d = get<2>(elem);
if ((*b - r) % d != 0)
return {};
r += M * ((*b - r) / d * p % (*m / d));
M *= *m / d;
}
return make_optional(std::make_pair(mod(r, M), M));
}
static std::experimental::optional<pair<i64, i64>>
chinese_rem_ctr(const Vector<i64> &b, const Vector<i64> &m) {
return chinese_rem_ctr<decltype(b.begin()), decltype(m.begin())>(CTR(b),
CTR(m));
}
void body() {
auto N = read<i64>();
auto M = read<i64>();
auto as = read<i64>(N);
auto As = Vector<i64>();
EACH(a, as) {
a /= 2;
As.push_back(a);
}
auto Y = lcm_ctr(CTR(As));
i64 p = -1;
EACH(A, As) {
i64 i = 0;
while (A % 2 == 0) {
A /= 2;
i += 1;
}
if (p < 0) {
p = i;
}
if (p != i) {
cout << 0 << endl;
return;
}
}
if (M < Y) {
cout << 0 << endl;
return;
}
auto ans = (M / Y + 1) / 2;
cout << ans << endl;
}
| replace | 966 | 967 | 966 | 971 | TLE | |
p02814 | C++ | Runtime Error | #include <stdio.h>
typedef long long ll;
ll a[111111];
ll gcd(ll x, ll y) { return !y ? x : gcd(y, x % y); }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int main(void) {
ll n, m, i, LCM = 1;
scanf("%lld %lld", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
a[i] /= 2;
LCM = lcm(LCM, a[i]);
if (LCM > m) {
puts("0");
return 0;
}
}
for (i = 0; i < n; i++)
if (!(LCM / a[i] % 2)) {
puts("0");
return 0;
}
printf("%lld", m / LCM % 2 == 0 ? m / LCM / 2 : m / LCM / 2 + 1);
return 0;
} | #include <stdio.h>
typedef long long ll;
ll a[111111];
ll gcd(ll x, ll y) { return !y ? x : gcd(y, x % y); }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int main(void) {
ll n, m, i, LCM = 1;
scanf("%lld %lld", &n, &m);
for (i = 0; i < n; i++) {
scanf("%lld", &a[i]);
a[i] /= 2;
LCM = lcm(LCM, a[i]);
if (LCM > m) {
puts("0");
return 0;
}
}
for (i = 0; i < n; i++)
if (!(LCM / a[i] % 2)) {
puts("0");
return 0;
}
printf("%lld", m / LCM % 2 == 0 ? m / LCM / 2 : m / LCM / 2 + 1);
return 0;
} | replace | 13 | 14 | 13 | 14 | -8 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
#define range(i, l, r) for (long long int(i) = (l); (i) < (r); (i)++)
#define reversed_range(i, l, r) for (long long int(i) = (r)-1; (i) >= l; (i)--)
using namespace std;
template <typename T> using vec = vector<T>;
using lint = long long;
using ulint = unsigned long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
template <typename S, typename T>
ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(";
os << p.first << ", " << p.second;
return os << ")";
}
template <typename T> ostream &operator<<(ostream &os, vec<T> v) {
os << "[";
if (v.size() == 0)
return os << "]";
for (int i = 0; i < v.size() - 1; i++) {
os << v.at(i) << ", ";
}
return os << v.at(v.size() - 1) << "]";
}
template <typename T> ostream &operator<<(ostream &os, set<T> &s) {
os << "{";
if (s.begin() == s.end())
return os << "}";
auto it_first_item = s.begin();
os << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
os << ", " << *it;
}
return os << "}";
}
template <typename T> ostream &operator<<(ostream &os, unordered_set<T> &s) {
os << "{";
if (s.begin() == s.end())
return os << "}";
auto it_first_item = s.begin();
os << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
os << ", " << *it;
}
return os << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, map<K, V> m) {
os << "{";
if (m.begin() == m.end())
return os << "}";
auto it_first_item = m.begin();
os << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
os << ", " << it->first << ": " << it->second;
}
return os << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
os << "{";
if (m.begin() == m.end())
return os << "}";
auto it_first_item = m.begin();
os << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
os << ", " << it->first << ": " << it->second;
}
return os << "}";
}
lint pow(lint num, lint e, lint MOD) {
lint res = 1;
lint cur_num = num;
while (e) {
if (e & 1) {
res *= cur_num;
res %= MOD;
}
cur_num *= cur_num;
cur_num %= MOD;
e >>= 1;
}
return res;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
lint N, M;
cin >> N >> M;
vec<lint> a_list(N);
range(i, 0, N) cin >> a_list.at(i);
auto num_twos = [](lint a) {
lint ans = 0;
while (a % 2 == 0) {
ans += 1;
a /= 2;
}
return ans;
};
lint n_twos = num_twos(a_list.at(0));
range(i, 1, N) {
if (num_twos(a_list.at(i)) != n_twos) {
cout << 0 << "\n";
return 0;
}
}
lint base = 1LL << n_twos;
range(i, 0, N) a_list.at(i) /= base;
lint lcm = a_list.at(0) * a_list.at(1) / __gcd(a_list.at(0), a_list.at(1));
range(i, 2, N) { lcm = lcm * a_list.at(i) / __gcd(lcm, a_list.at(i)); }
lcm *= base / 2;
cout << (M + lcm) / (2 * lcm) << '\n';
} | #include <bits/stdc++.h>
#define range(i, l, r) for (long long int(i) = (l); (i) < (r); (i)++)
#define reversed_range(i, l, r) for (long long int(i) = (r)-1; (i) >= l; (i)--)
using namespace std;
template <typename T> using vec = vector<T>;
using lint = long long;
using ulint = unsigned long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
template <typename S, typename T>
ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(";
os << p.first << ", " << p.second;
return os << ")";
}
template <typename T> ostream &operator<<(ostream &os, vec<T> v) {
os << "[";
if (v.size() == 0)
return os << "]";
for (int i = 0; i < v.size() - 1; i++) {
os << v.at(i) << ", ";
}
return os << v.at(v.size() - 1) << "]";
}
template <typename T> ostream &operator<<(ostream &os, set<T> &s) {
os << "{";
if (s.begin() == s.end())
return os << "}";
auto it_first_item = s.begin();
os << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
os << ", " << *it;
}
return os << "}";
}
template <typename T> ostream &operator<<(ostream &os, unordered_set<T> &s) {
os << "{";
if (s.begin() == s.end())
return os << "}";
auto it_first_item = s.begin();
os << *it_first_item;
for (auto it = ++it_first_item; it != s.end(); it++) {
os << ", " << *it;
}
return os << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, map<K, V> m) {
os << "{";
if (m.begin() == m.end())
return os << "}";
auto it_first_item = m.begin();
os << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
os << ", " << it->first << ": " << it->second;
}
return os << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &os, unordered_map<K, V> m) {
os << "{";
if (m.begin() == m.end())
return os << "}";
auto it_first_item = m.begin();
os << it_first_item->first << ": " << it_first_item->second;
for (auto it = ++it_first_item; it != m.end(); it++) {
os << ", " << it->first << ": " << it->second;
}
return os << "}";
}
lint pow(lint num, lint e, lint MOD) {
lint res = 1;
lint cur_num = num;
while (e) {
if (e & 1) {
res *= cur_num;
res %= MOD;
}
cur_num *= cur_num;
cur_num %= MOD;
e >>= 1;
}
return res;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
lint N, M;
cin >> N >> M;
vec<lint> a_list(N);
range(i, 0, N) cin >> a_list.at(i);
auto num_twos = [](lint a) {
lint ans = 0;
while (a % 2 == 0) {
ans += 1;
a /= 2;
}
return ans;
};
lint n_twos = num_twos(a_list.at(0));
range(i, 1, N) {
if (num_twos(a_list.at(i)) != n_twos) {
cout << 0 << "\n";
return 0;
}
}
lint base = 1LL << n_twos;
range(i, 0, N) a_list.at(i) /= base;
lint lcm = a_list.at(0);
range(i, 1, N) { lcm = lcm * a_list.at(i) / __gcd(lcm, a_list.at(i)); }
lcm *= base / 2;
cout << (M + lcm) / (2 * lcm) << '\n';
} | replace | 118 | 120 | 118 | 120 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
ll gcd(ll a, ll b) {
if (a < b) {
ll x;
x = a;
a = b;
b = x;
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
template <typename T> T lcm(T x, T y) {
return x / gcd(max(x, y), min(x, y)) * y;
}
int main() {
ll n, m, i, j, k;
cin >> n >> m;
vector<ll> a(n);
ll l = 1;
for (auto &x : a) {
cin >> x;
l = lcm(l, x / 2);
}
ll ret = 0;
// cout << l << endl;
for (auto &x : a) {
if (l % x == 0) {
cout << 0 << endl;
return 0;
}
}
cout << (m / l + 1) / 2 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x * y / gcd(x, y); }
int main() {
ll n, m, i, j, k;
cin >> n >> m;
vector<ll> a(n);
ll l = 1;
for (auto &x : a) {
cin >> x;
l = lcm(l, x / 2);
}
ll ret = 0;
// cout << l << endl;
for (auto &x : a) {
if (l % x == 0) {
cout << 0 << endl;
return 0;
}
}
cout << (m / l + 1) / 2 << endl;
return 0;
}
| replace | 8 | 23 | 8 | 11 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define fi first
#define se second
typedef pair<ll, ll> P;
using VP = vector<P>;
using VVP = vector<VP>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
const int inf = 1e9 + 7;
const ll INF = 1LL << 61;
const ll mod = 1e9 + 7;
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return gcd(a % b, b);
}
int main() {
int i, j;
int n, m;
cin >> n >> m;
ll a[n];
ll aa[n];
VI v(n, 0);
bool ng = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
aa[i] = a[i] / 2;
while (a[i] % 2 == 0) {
a[i] /= 2;
v[i]++;
}
}
for (i = 0; i < n; i++) {
if (v[0] != v[i]) {
cout << 0 << endl;
return 0;
}
}
if (v[0] == 0) {
cout << 0 << endl;
return 0;
}
ll l = aa[0];
for (i = 1; i < n; i++) {
l = l * aa[i] / gcd(l, aa[i]);
}
cout << m / l - m / (l * 2) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
#define fi first
#define se second
typedef pair<ll, ll> P;
using VP = vector<P>;
using VVP = vector<VP>;
using VI = vector<int>;
using VVI = vector<VI>;
using VVVI = vector<VVI>;
const int inf = 1e9 + 7;
const ll INF = 1LL << 61;
const ll mod = 1e9 + 7;
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return gcd(a % b, b);
}
int main() {
int i, j;
int n, m;
cin >> n >> m;
ll a[n];
ll aa[n];
VI v(n, 0);
bool ng = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
aa[i] = a[i] / 2;
while (a[i] % 2 == 0) {
a[i] /= 2;
v[i]++;
}
}
for (i = 0; i < n; i++) {
if (v[0] != v[i]) {
cout << 0 << endl;
return 0;
}
}
if (v[0] == 0) {
cout << 0 << endl;
return 0;
}
ll l = aa[0];
for (i = 1; i < n; i++) {
l = (l / gcd(l, aa[i])) * aa[i];
if (l > m) {
cout << 0 << endl;
return 0;
}
}
cout << m / l - m / (l * 2) << endl;
return 0;
}
| replace | 55 | 56 | 55 | 60 | TLE | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
int n, m;
cin >> n >> m;
VL a(n);
cin >> a;
set<int> c;
FOR(i, 0, n) FOR(j, 0, 40) if (a[i] & (1LL << j)) {
c.insert(j);
break;
}
if (c.size() != 1) {
cout << "0\n";
return 0;
}
ll x = 1;
FOR(i, 0, n) x = max(lcm(x, a[i]), 0LL);
if (x % 2 == 1) {
cout << "0\n";
return 0;
}
ll ans = (m + x / 2) / x;
cout << ans << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
int n, m;
cin >> n >> m;
VL a(n);
cin >> a;
set<int> c;
FOR(i, 0, n) FOR(j, 0, 40) if (a[i] & (1LL << j)) {
c.insert(j);
break;
}
if (c.size() != 1) {
cout << "0\n";
return 0;
}
ll x = 1;
FOR(i, 0, n) x = lcm(x, a[i]);
if (x % 2 == 1) {
cout << "0\n";
return 0;
}
ll ans = (m + x / 2) / x;
cout << ans << "\n";
}
| replace | 92 | 93 | 92 | 93 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define int long long
int gcd(int a, int b) {
if (a > b) {
swap(a, b);
}
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
int ord2(int n) {
int ret = 0;
while (n % 2 == 0) {
n /= 2;
ret++;
}
return ret;
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m, ans = 0, L = 1, ord, d;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ord = ord2(a[0]);
d = (1 << ord);
for (int i = 0; i < n; i++) {
if ((a[i] / d) % 2 == 0) {
cout << 0 << endl;
return 0;
}
a[i] /= d;
L = (L / gcd(L, a[i])) * a[i];
}
L *= d / 2;
if ((L > m) || (L <= 0)) {
cout << 0;
return 0;
}
cout << (m + L) / (2 * L) << endl;
return 0;
}
| #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#define int long long
int gcd(int a, int b) {
if (a > b) {
swap(a, b);
}
if (a == 0) {
return b;
} else {
return gcd(b % a, a);
}
}
int ord2(int n) {
int ret = 0;
while (n % 2 == 0) {
n /= 2;
ret++;
}
return ret;
}
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m, ans = 0, L = 1, ord, d;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
ord = ord2(a[0]);
d = (1 << ord);
for (int i = 0; i < n; i++) {
if ((a[i] / d) % 2 == 0) {
cout << 0 << endl;
return 0;
}
a[i] /= d;
int tmp = (L / gcd(L, a[i])) * a[i];
if (tmp < 0 || L > tmp) {
cout << 0 << endl;
return 0;
} else {
L = tmp;
}
}
L *= d / 2;
if ((L > m) || (L <= 0)) {
cout << 0;
return 0;
}
cout << (m + L) / (2 * L) << endl;
return 0;
}
| replace | 40 | 41 | 40 | 47 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define loop(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) loop(i, 0, n)
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define vi vector<int>
#define vl vector<ll>
#define pll pair<ll, ll>
#define vpll vector<pll>
ll int gcd(ll a, ll b) {
auto r = a % b;
a = b;
b = r;
while (0 != b) {
r = a % b;
a = b;
b = r;
}
return a;
}
ll int lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
ll int n, m;
cin >> n >> m;
ll int a[n];
rep(i, n) {
ll int tmp;
cin >> tmp;
a[i] = tmp / 2;
}
int mn = 1;
rep(i, n) { mn = lcm(mn, a[i]); }
ll int ans = 0;
ll int i = 1;
rep(i, n) {
if (mn / (a[i] / 2) % 2 == 0) {
printf("0");
return 0;
}
}
if (m / mn == 0) {
cout << ans << endl;
} else {
cout << (m / mn + 1) / 2 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define loop(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) loop(i, 0, n)
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define vi vector<int>
#define vl vector<ll>
#define pll pair<ll, ll>
#define vpll vector<pll>
ll int gcd(ll a, ll b) {
auto r = a % b;
a = b;
b = r;
while (0 != b) {
r = a % b;
a = b;
b = r;
}
return a;
}
ll int lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
ll int n, m;
cin >> n >> m;
ll int a[n];
rep(i, n) {
ll int tmp;
cin >> tmp;
a[i] = tmp / 2;
}
int mn = 1;
rep(i, n) { mn = lcm(mn, a[i]); }
ll int ans = 0;
ll int i = 1;
rep(i, n) {
if (mn / a[i] % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
if (m / mn == 0) {
cout << ans << endl;
} else {
cout << (m / mn + 1) / 2 << endl;
}
} | replace | 39 | 41 | 39 | 41 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v);
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p);
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v) {
for (auto &i : v) {
stream >> i;
}
return stream;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p) {
stream >> p.first >> p.second;
return stream;
}
template <typename T> T gcd(const T x, const T y) {
if (x == 0) {
return y;
} else if (y == 0) {
return x;
} else if (x < y) {
return gcd(x, y % x);
} else if (y < x) {
return gcd(y, x % y);
} else {
return x;
}
}
template <typename T> T lcm(const T x, const T y) {
if (x == 0 || y == 0) {
return 0;
} else {
return x / gcd(x, y) * y;
}
}
int main() {
int64_t n, m;
std::cin >> n >> m;
std::vector<int64_t> a(n);
std::cin >> a;
std::sort(a.begin(), a.end());
std::set<int64_t> s;
for (int64_t i = 0; i < n; i++) {
a[i] /= 2;
s.insert(a[i]);
}
if (s.size() == 1) {
if (m < a[0]) {
std::cout << 0 << std::endl;
} else {
m -= a[0];
std::cout << 1 + m / (2 * a[0]) << std::endl;
}
} else {
std::vector<int64_t> b(a.cbegin(), a.cend());
auto g = gcd(b[0], b[1]);
auto l = lcm(b[0], b[1]);
for (int64_t i = 2; i < b.size(); i++) {
l = lcm(l, b[i]);
g = gcd(g, b[i]);
}
for (const auto j : b) {
if ((j / g) % 2 == 0) {
std::cout << 0 << std::endl;
return 0;
}
}
if (m < l) {
std::cout << 0 << std::endl;
} else {
m -= l;
std::cout << 1 + m / (2 * l) << std::endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
template <typename InputIterator>
typename InputIterator::value_type summation(InputIterator first,
InputIterator last) {
return std::accumulate(first, last, typename InputIterator::value_type());
}
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v);
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p);
template <typename T>
std::istream &operator>>(std::istream &stream, std::vector<T> &v) {
for (auto &i : v) {
stream >> i;
}
return stream;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &stream, std::pair<T1, T2> &p) {
stream >> p.first >> p.second;
return stream;
}
template <typename T> T gcd(const T x, const T y) {
if (x == 0) {
return y;
} else if (y == 0) {
return x;
} else if (x < y) {
return gcd(x, y % x);
} else if (y < x) {
return gcd(y, x % y);
} else {
return x;
}
}
template <typename T> T lcm(const T x, const T y) {
if (x == 0 || y == 0) {
return 0;
} else {
return x / gcd(x, y) * y;
}
}
int main() {
int64_t n, m;
std::cin >> n >> m;
std::vector<int64_t> a(n);
std::cin >> a;
std::sort(a.begin(), a.end());
std::set<int64_t> s;
for (int64_t i = 0; i < n; i++) {
a[i] /= 2;
s.insert(a[i]);
}
if (s.size() == 1) {
if (m < a[0]) {
std::cout << 0 << std::endl;
} else {
m -= a[0];
std::cout << 1 + m / (2 * a[0]) << std::endl;
}
} else {
std::vector<int64_t> b(a.cbegin(), a.cend());
auto g = gcd(b[0], b[1]);
auto l = lcm(b[0], b[1]);
for (int64_t i = 2; i < b.size(); i++) {
l = lcm(l, b[i]);
g = gcd(g, b[i]);
if (m < l) {
std::cout << 0 << std::endl;
return 0;
}
}
for (const auto j : b) {
if ((j / g) % 2 == 0) {
std::cout << 0 << std::endl;
return 0;
}
}
if (m < l) {
std::cout << 0 << std::endl;
} else {
m -= l;
std::cout << 1 + m / (2 * l) << std::endl;
}
}
return 0;
}
| insert | 73 | 73 | 73 | 77 | TLE | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec)
ndarray(v, args...);
}
template <typename T> bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T> bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
#define dbg(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
int gcd(int a, int b) { return (b > 0) ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main() {
lint n, m;
cin >> n >> m;
vector<lint> a(n);
cin >> a;
REP(i, n) a[i] >>= 1;
lint l = a[0];
REP(i, n) l = lcm(l, a[i]);
REP(i, n) {
if ((l / a[i]) % 2 == 0) {
cout << 0;
return 0;
}
}
cout << m / l - m / (l >> 1);
}
| #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec)
ndarray(v, args...);
}
template <typename T> bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T> bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
#define dbg(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
int gcd(int a, int b) { return (b > 0) ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main() {
lint n, m;
cin >> n >> m;
vector<lint> a(n);
cin >> a;
REP(i, n) a[i] >>= 1;
lint l = a[0];
REP(i, n) l = lcm(l, a[i]);
REP(i, n) {
if ((l / a[i]) % 2 == 0) {
cout << 0;
return 0;
}
}
cout << m / l - m / (l << 1);
}
| replace | 140 | 141 | 140 | 141 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using ll = long long;
using pll = pair<ll, ll>;
constexpr ll INF = (1LL << 60);
constexpr ll MOD = (1e9 + 7);
// constexpr ll MOD = (998244353);
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#if loc || debg || local || debug
void dump() { cerr << endl; }
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {
cerr << h << ", ";
dump(forward<Ts>(t)...);
}
#else
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {}
#endif
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
for (auto const &vi : v)
os << vi << " ";
return os;
}
template <class T> vector<T> vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T> vector<T> _vec(size_t a, T v) { return vector<T>(a, v); }
template <class T, class... Ts> auto _vec(size_t a, Ts... ts) {
return vector<decltype(_vec<T>(ts...))>(a, _vec<T>(ts...));
}
template <typename T> T gcd(T a, T b) {
while (1) {
swap(a, b);
if (a == 0)
return b;
if (b == 0)
return a;
a %= b;
}
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
cin >> a;
rep(i, n) assert(a[i] % 2 == 0);
vector<ll> b = a;
rep(i, n) b[i] /= 2;
ll tb = 1;
rep(i, n) tb = lcm(tb, b[i]);
ll ta = 1;
rep(i, n) ta = lcm(ta, a[i]);
dump(ta, tb);
bool ok = true;
rep(i, n) if ((tb / b[i]) % 2 == 0) ok = false;
if (ok)
cout << (m / tb - m / ta) << endl;
else
cout << 0 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using ll = long long;
using pll = pair<ll, ll>;
constexpr ll INF = (1LL << 60);
constexpr ll MOD = (1e9 + 7);
// constexpr ll MOD = (998244353);
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#if loc || debg || local || debug
void dump() { cerr << endl; }
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {
cerr << h << ", ";
dump(forward<Ts>(t)...);
}
#else
template <class T, class... Ts> void dump(T &&h, Ts &&...t) {}
#endif
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
for (auto const &vi : v)
os << vi << " ";
return os;
}
template <class T> vector<T> vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T> vector<T> _vec(size_t a, T v) { return vector<T>(a, v); }
template <class T, class... Ts> auto _vec(size_t a, Ts... ts) {
return vector<decltype(_vec<T>(ts...))>(a, _vec<T>(ts...));
}
template <typename T> T gcd(T a, T b) {
while (1) {
swap(a, b);
if (a == 0)
return b;
if (b == 0)
return a;
a %= b;
}
}
template <class T> inline T lcm(T a, T b) { return a / gcd(a, b) * b; }
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
cin >> a;
vector<ll> b = a;
rep(i, n) b[i] /= 2;
ll tb = 1;
rep(i, n) tb = lcm(tb, b[i]);
ll ta = 1;
rep(i, n) ta = lcm(ta, a[i]);
dump(ta, tb);
bool ok = true;
rep(i, n) if ((tb / b[i]) % 2 == 0) ok = false;
if (ok)
cout << (m / tb - m / ta) << endl;
else
cout << 0 << endl;
}
| delete | 74 | 76 | 74 | 74 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5;
ll a[maxn];
ll lcm(int n, int m) { return n / __gcd(n, m) * m; }
ll nlcm(ll *a, int n) {
if (n == 1)
return *a;
return lcm(a[n - 1], nlcm(a, n - 1));
}
int main() {
int n;
ll m;
scanf("%d%lld", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
a[i] = a[i] / 2;
}
ll c = nlcm(a, n);
cout << c << endl;
for (auto g : a) {
if ((c / g) % 2)
continue;
puts("0");
return 0;
}
printf("%lld\n", (m / c + 1) / 2);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 5;
ll a[maxn];
ll lcm(int n, int m) { return n / __gcd(n, m) * m; }
ll nlcm(ll *a, int n) {
if (n == 1)
return *a;
return lcm(a[n - 1], nlcm(a, n - 1));
}
int main() {
int n;
ll m;
scanf("%d%lld", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
a[i] = a[i] / 2;
}
ll c = nlcm(a, n);
for (int i = 0; i < n; i++) {
ll g = a[i];
if ((c / g) % 2)
continue;
puts("0");
return 0;
}
printf("%lld\n", (m / c + 1) / 2);
return 0;
}
| replace | 20 | 22 | 20 | 22 | -8 | |
p02814 | C++ | Time Limit Exceeded | #define rep(i, a, b) for (int i = a; i < (int)(b); i++)
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
template <class T> inline void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
const long long INF = 1LL << 60;
const long long MOD = (ll)1e9 + 7;
// const long long MOD = (ll)1e6+3;
const long long MAX = (ll)1e5 + 10;
// GCD, LCM
long long GCD(long long C, long long D) {
while (1) {
if (C == 0 || D == 0)
break;
if (D > C)
D -= (D / C) * C;
else
C -= (C / D) * D;
}
return max(C, D);
}
long long LCM(long long C, long long D) { return C / GCD(C, D) * D; }
int main(void) {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, 0, N) cin >> A[i];
sort(A.begin(), A.end());
ll now = 1;
rep(i, 0, N) { now = LCM(now, (ll)(A[i] / 2)); }
// cout<<now<<endl;
rep(i, 0, N) {
if ((now * 2 / A[i]) % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
ll ans = M / now;
ans = (ans + 1) / 2;
cout << ans << endl;
return 0;
} | #define rep(i, a, b) for (int i = a; i < (int)(b); i++)
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
template <class T> inline void chmax(T &a, const T &b) {
if (a < b)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (a > b)
a = b;
}
const long long INF = 1LL << 60;
const long long MOD = (ll)1e9 + 7;
// const long long MOD = (ll)1e6+3;
const long long MAX = (ll)1e5 + 10;
// GCD, LCM
long long GCD(long long C, long long D) {
while (1) {
if (C == 0 || D == 0)
break;
if (D > C)
D -= (D / C) * C;
else
C -= (C / D) * D;
}
return max(C, D);
}
long long LCM(long long C, long long D) { return C / GCD(C, D) * D; }
int main(void) {
ll N, M;
cin >> N >> M;
vector<ll> A(N);
rep(i, 0, N) cin >> A[i];
sort(A.begin(), A.end());
ll now = 1;
rep(i, 0, N) {
now = LCM(now, (ll)(A[i] / 2));
if (now > M) {
cout << 0 << endl;
return 0;
}
}
// cout<<now<<endl;
rep(i, 0, N) {
if ((now * 2 / A[i]) % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
ll ans = M / now;
ans = (ans + 1) / 2;
cout << ans << endl;
return 0;
} | replace | 40 | 41 | 40 | 47 | TLE | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long long int LL;
typedef unsigned long long int ULL;
using namespace std;
// 插入此處
namespace Number {
typedef long long int LL;
// 求取 a, b 的最大公因數
LL gcd(LL a, LL b) {
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
// 求取 a, b 的最大公因數 gcd
// 以及 x, y 使得 a*x + b*y = gcd
LL gcd_extend(LL a, LL b, LL *x, LL *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
LL x1, y1; // To store results of recursive call
LL gcd = gcd_extend(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
// 求 a_inv 使得 (a * a_inv) % m = gcd(a, m)
// 若 a, m 互質，即求 a 在 mod m 群的反元素 a_inv
LL mod_inv(LL a, LL m) {
LL x, y;
LL g = gcd_extend(a, m, &x, &y);
// 處理 x 爲負的情形
LL a_inv = (x % m + m) % m;
return a_inv;
}
// 求 x^n % m
LL mod_pow(LL x, LL n, LL m) {
if (n == 0) {
return 1;
} else if (n & 1) {
LL half = mod_pow(x, n / 2, m);
return (half * half % m) * x % m;
} else {
LL half = mod_pow(x, n / 2, m);
return half * half % m;
}
}
// 連乘
LL mul(LL from, LL to, LL m) {
LL ret = 1;
for (LL i = from; i <= to; i++) {
ret *= i;
ret %= m;
}
return ret;
}
// 求 (C n 取 k) % m
LL mod_comb(LL n, LL k, LL m) {
LL mi = k < n - k ? k : n - k;
LL up = mul(n - mi + 1, n, m);
LL down = mul(1, mi, m);
return (up * mod_inv(down, m)) % m;
}
} // namespace Number
LL a[100005];
int main() {
LL n, m;
cin >> n >> m;
LL lcm = 1;
bool ok = true;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
LL mul = (lcm / Number::gcd(a[i], lcm));
if ((m + 1) < a[i] * mul) {
ok = false;
break;
}
lcm = a[i] * mul;
}
for (int i = 0; i < n; i++) {
if ((lcm / a[i]) % 2 == 0) {
ok = false;
}
}
if (!ok) {
cout << 0 << endl;
} else {
cout << (m / lcm + 1) / 2 << endl;
}
}
| #include <bits/stdc++.h>
typedef long long int LL;
typedef unsigned long long int ULL;
using namespace std;
// 插入此處
namespace Number {
typedef long long int LL;
// 求取 a, b 的最大公因數
LL gcd(LL a, LL b) {
if (a % b == 0) {
return b;
}
return gcd(b, a % b);
}
// 求取 a, b 的最大公因數 gcd
// 以及 x, y 使得 a*x + b*y = gcd
LL gcd_extend(LL a, LL b, LL *x, LL *y) {
if (a == 0) {
*x = 0, *y = 1;
return b;
}
LL x1, y1; // To store results of recursive call
LL gcd = gcd_extend(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
// 求 a_inv 使得 (a * a_inv) % m = gcd(a, m)
// 若 a, m 互質，即求 a 在 mod m 群的反元素 a_inv
LL mod_inv(LL a, LL m) {
LL x, y;
LL g = gcd_extend(a, m, &x, &y);
// 處理 x 爲負的情形
LL a_inv = (x % m + m) % m;
return a_inv;
}
// 求 x^n % m
LL mod_pow(LL x, LL n, LL m) {
if (n == 0) {
return 1;
} else if (n & 1) {
LL half = mod_pow(x, n / 2, m);
return (half * half % m) * x % m;
} else {
LL half = mod_pow(x, n / 2, m);
return half * half % m;
}
}
// 連乘
LL mul(LL from, LL to, LL m) {
LL ret = 1;
for (LL i = from; i <= to; i++) {
ret *= i;
ret %= m;
}
return ret;
}
// 求 (C n 取 k) % m
LL mod_comb(LL n, LL k, LL m) {
LL mi = k < n - k ? k : n - k;
LL up = mul(n - mi + 1, n, m);
LL down = mul(1, mi, m);
return (up * mod_inv(down, m)) % m;
}
} // namespace Number
LL a[100005];
int main() {
LL n, m;
cin >> n >> m;
LL lcm = 1;
bool ok = true;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
LL mul = (lcm / Number::gcd(a[i], lcm));
if ((m + 1) < a[i] * mul) {
ok = false;
break;
}
lcm = a[i] * mul;
}
for (int i = 0; i < n && ok; i++) {
if ((lcm / a[i]) % 2 == 0) {
ok = false;
}
}
if (!ok) {
cout << 0 << endl;
} else {
cout << (m / lcm + 1) / 2 << endl;
}
}
| replace | 87 | 88 | 87 | 88 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define repk(i, k, n) for (ll i = k; i < (ll)(n); ++i)
#define MAX 50000001
#define MOD 1000000007
typedef long long ll;
using namespace std;
ll ans, cnt;
ll l;
// 最大公約数のll版
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
return b == 0 ? a : gcd(b, a % b);
}
// 最小公倍数のll版
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
ll abc150func(ll l, ll M) {
ll i = 1;
ll res = 0;
while (true) {
if (l * i > M)
return res;
else {
res++;
i += 2;
}
}
}
int main() {
ll N, M;
cin >> N >> M;
vector<ll> a(N);
ll temp = 0;
rep(i, N) {
cin >> a[i];
a[i] /= 2;
}
l = a[0];
rep(i, N) l = lcm(l, a[i]);
rep(i, N) {
if (l / a[i] % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
// cout << abc150func(l, M) << endl;
cout << M / l - M / (l << 1);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define repk(i, k, n) for (ll i = k; i < (ll)(n); ++i)
#define MAX 50000001
#define MOD 1000000007
typedef long long ll;
using namespace std;
ll ans, cnt;
ll l;
int gcd(int a, int b) { return (b > 0) ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
ll abc150func(ll l, ll M) {
ll i = 1;
ll res = 0;
while (true) {
if (l * i > M)
return res;
else {
res++;
i += 2;
}
}
}
int main() {
ll N, M;
cin >> N >> M;
vector<ll> a(N);
ll temp = 0;
rep(i, N) {
cin >> a[i];
a[i] /= 2;
}
l = a[0];
rep(i, N) l = lcm(l, a[i]);
rep(i, N) {
if (l / a[i] % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
// cout << abc150func(l, M) << endl;
cout << M / l - M / (l << 1);
return 0;
} | replace | 12 | 21 | 12 | 14 | TLE | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
int gcd(int a, int b) {
if (a < b)
swap(a, b);
int c = -1;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main() {
int N, M;
cin >> N >> M;
vi a(N);
rep(i, N) { cin >> a[i]; }
int n2 = -1;
rep(i, N) {
int k = 0;
int d = 2;
while (a[i] % d == 0) {
d <<= 1;
k++;
}
if (n2 < 0) {
n2 = k;
} else if (n2 != k) {
cout << 0 << endl;
return 0;
}
}
n2--;
rep(i, N) { a[i] /= 2; }
rep(i, n2) {
M /= 2;
rep(j, N) { a[i] /= 2; }
}
ll l = a[0];
rep(i, N) {
l = lcm(l, a[i]);
if (l > M) {
cout << 0 << endl;
return 0;
}
}
ll s = M / l;
ll ans = (s + 1) / 2;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(), a.end()
#define sz(x) (int)(x).size()
#define uni(x) x.erase(unique(rng(x)), x.end())
#define show(x) cout << #x << " = " << x << endl;
#define PQ(T) priority_queue<T, v(T), greater<T>>
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef set<int> S;
typedef queue<int> Q;
typedef queue<P> QP;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
const int MOD = 1000000007;
int gcd(int a, int b) {
if (a < b)
swap(a, b);
int c = -1;
while (c != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
int main() {
int N, M;
cin >> N >> M;
vi a(N);
rep(i, N) { cin >> a[i]; }
int n2 = -1;
rep(i, N) {
int k = 0;
int d = 2;
while (a[i] % d == 0) {
d <<= 1;
k++;
}
if (n2 < 0) {
n2 = k;
} else if (n2 != k) {
cout << 0 << endl;
return 0;
}
}
n2--;
rep(i, N) { a[i] /= 2; }
rep(i, n2) {
M /= 2;
rep(j, N) { a[j] /= 2; }
}
ll l = a[0];
rep(i, N) {
l = lcm(l, a[i]);
if (l > M) {
cout << 0 << endl;
return 0;
}
}
ll s = M / l;
ll ans = (s + 1) / 2;
cout << ans << endl;
return 0;
} | replace | 66 | 67 | 66 | 67 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
ll gcd(ll a, ll b) {
if (a < b) {
ll x;
x = a;
a = b;
b = x;
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
template <typename T> T lcm(T x, T y) {
return x / gcd(max(x, y), min(x, y)) * y;
}
int main() {
ll n, m, i, j, k;
cin >> n >> m;
vector<ll> a(n);
ll l = 1;
for (auto &x : a) {
cin >> x;
l = lcm(l, x / 2);
}
ll ret = 0;
// cout << l << endl;
for (auto &x : a) {
if (l % x == 0) {
cout << 0 << endl;
return 0;
}
}
cout << (m / l + 1) / 2 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
ll gcd(ll a, ll b) {
if (a < b) {
ll x;
x = a;
a = b;
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
template <typename T> T lcm(T x, T y) {
return x / gcd(max(x, y), min(x, y)) * y;
}
int main() {
ll n, m, i, j, k;
cin >> n >> m;
vector<ll> a(n);
ll l = 1;
for (auto &x : a) {
cin >> x;
l = lcm(l, x / 2);
}
ll ret = 0;
// cout << l << endl;
for (auto &x : a) {
if (l % x == 0) {
cout << 0 << endl;
return 0;
}
}
cout << (m / l + 1) / 2 << endl;
return 0;
}
| delete | 13 | 14 | 13 | 13 | TLE | |
p02814 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int f(int x) {
int res = 0;
while (x % 2 == 0) {
x /= 2;
res++;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
REP(i, n) cin >> a[i];
// a -> a'にしている
REP(i, n) {
if (a[i] % 2 == 1) {
cout << 0 << endl;
return 0;
}
a[i] /= 2;
}
/* a' -> a''、つまり上記で言う所の2^tで割ってる
これをやると一々a'の最大に最小公倍数を
合わせるとか考えることがなくなるので楽
*/
int t = f(a[0]);
REP(i, n) {
if (f(a[i] != t)) {
cout << 0 << endl;
return 0;
}
a[i] >>= t; // a[i] /= 2^t
}
m >>= t;
ll l = 1;
REP(i, n) {
l = lcm(l, a[i]);
if (l > m) {
cout << 0 << endl;
return 0;
}
}
// m -> m'
m /= l;
/*
これはm'以下の奇数の数、つまり
mを最小公倍数で割った時の奇数倍を表す
(奇数倍の数=倍数中の奇数の数を求めれば良い)
*/
ll ans = (m + 1) / 2;
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int f(int x) {
int res = 0;
while (x % 2 == 0) {
x /= 2;
res++;
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n);
REP(i, n) cin >> a[i];
// a -> a'にしている
REP(i, n) {
if (a[i] % 2 == 1) {
cout << 0 << endl;
return 0;
}
a[i] /= 2;
}
/* a' -> a''、つまり上記で言う所の2^tで割ってる
これをやると一々a'の最大に最小公倍数を
合わせるとか考えることがなくなるので楽
*/
int t = f(a[0]);
REP(i, n) {
if (f(a[i]) != t) {
cout << 0 << endl;
return 0;
}
a[i] >>= t; // a[i] /= 2^t
}
m >>= t;
ll l = 1;
REP(i, n) {
l = lcm(l, a[i]);
if (l > m) {
cout << 0 << endl;
return 0;
}
}
// m -> m'
m /= l;
/*
これはm'以下の奇数の数、つまり
mを最小公倍数で割った時の奇数倍を表す
(奇数倍の数=倍数中の奇数の数を求めれば良い)
*/
ll ans = (m + 1) / 2;
cout << ans << endl;
return 0;
}
| replace | 39 | 40 | 39 | 40 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
constexpr lint INF = 1'010'000'000'000'000'017LL;
constexpr lint MOD = 1'000'000'007LL;
constexpr double EPS = 1e-12;
constexpr double PI = 3.14159265358979323846;
#define FOR(i, start, end) for (lint i = (start); i < end; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
lint mod(lint val, lint m) {
lint res = val % m;
if (res < 0)
res += m;
return res;
}
lint modinv(lint a, lint m) {
lint b = m, u = 1, v = 0;
while (b) {
lint t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
lint modpow(lint a, lint n, lint mod) {
lint res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// lint gcd(lint a, lint b){ if(a < b) swap(a, b); if(b == 0) return a; return
// gcd(b, a%b);} lint lcm(lint a, lint b){ return a * b / gcd(a, b);}
//---------------------------------------------------------------
/*lint gcd(lint x, lint y){
if(x>y) swap(x, y);
while(1){
y %= x;
swap(x, y);
if(x==0) return y;
}
}
*/
lint gcd(lint x, lint y) {
if (x > y)
swap(x, y);
if (x == 0)
return y;
return gcd(y % x, x);
}
void Main() {
lint N, M, ans;
cin >> N >> M;
vector<lint> a(N);
REP(i, N) {
cin >> a[i];
a[i] /= 2;
}
lint T;
T = a[0];
FOR(i, 1, N) { T = T * a[i] / gcd(T, a[i]); }
int f = 0;
REP(i, N) {
if ((T / a[i]) % 2 == 0)
f = 1;
}
if (!f) {
ans = (1 + M / T) / 2;
} else {
ans = 0;
}
cout << ans << endl;
}
//---------------------------------------------------------------
int main() {
cout << fixed << setprecision(15);
Main();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using lint = long long;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
constexpr lint INF = 1'010'000'000'000'000'017LL;
constexpr lint MOD = 1'000'000'007LL;
constexpr double EPS = 1e-12;
constexpr double PI = 3.14159265358979323846;
#define FOR(i, start, end) for (lint i = (start); i < end; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
lint mod(lint val, lint m) {
lint res = val % m;
if (res < 0)
res += m;
return res;
}
lint modinv(lint a, lint m) {
lint b = m, u = 1, v = 0;
while (b) {
lint t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
lint modpow(lint a, lint n, lint mod) {
lint res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// lint gcd(lint a, lint b){ if(a < b) swap(a, b); if(b == 0) return a; return
// gcd(b, a%b);} lint lcm(lint a, lint b){ return a * b / gcd(a, b);}
//---------------------------------------------------------------
/*lint gcd(lint x, lint y){
if(x>y) swap(x, y);
while(1){
y %= x;
swap(x, y);
if(x==0) return y;
}
}
*/
// lint gcd(lint x, lint y){
// if(x>y) swap(x,y);
// if(x==0) return y;
// return gcd(y%x, x);
// }
lint gcd(lint a, lint b) { return b ? gcd(b, a % b) : a; }
void Main() {
lint N, M, ans;
cin >> N >> M;
vector<lint> a(N);
REP(i, N) {
cin >> a[i];
a[i] /= 2;
}
lint T;
T = a[0];
FOR(i, 1, N) { T = T * a[i] / gcd(T, a[i]); }
int f = 0;
REP(i, N) {
if ((T / a[i]) % 2 == 0)
f = 1;
}
if (!f) {
ans = (1 + M / T) / 2;
} else {
ans = 0;
}
cout << ans << endl;
}
//---------------------------------------------------------------
int main() {
cout << fixed << setprecision(15);
Main();
return 0;
} | replace | 72 | 79 | 72 | 79 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <string.h>
#include <vector>
#define ll long long int
#define ld long double
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep1(i, n) for (ll i = 1; i < n; i++)
#define co(x) cout << x << endl
#define cosp(x) cout << x << " "
#define all(x) x.begin(), x.end()
#define allr(x) x.begin(), x.end(), greater<ll>()
#define P pair<ll, ll>
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define INF 1ll << 60
#define PI 3.14159265359
using namespace std;
ll gcd(ll a, ll b) {
if (a * b == 0)
return max(a, b);
if (a < b) {
ll tmp = a;
a = b;
b = tmp;
}
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
}
ll odd, even;
ll even_count = 0;
while (true) {
odd = 0;
even = 0;
for (ll i = 0; i < n; i++) {
if (a[i] % 2 == 0)
even++;
else
odd++;
}
if (even * odd != 0) {
cout << 0 << endl;
return 0;
}
if (even == 0) {
break;
}
even_count++;
for (ll i = 0; i < n; i++)
a[i] /= 2;
}
ll lcm_all = lcm(pow(2, even_count), a[0]);
for (ll i = 1; i < n; i++) {
lcm_all = lcm(lcm_all, a[i]);
}
cout << (m / lcm_all + 1) / 2 << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <string.h>
#include <vector>
#define ll long long int
#define ld long double
#define rep(i, n) for (ll i = 0; i < n; i++)
#define rep1(i, n) for (ll i = 1; i < n; i++)
#define co(x) cout << x << endl
#define cosp(x) cout << x << " "
#define all(x) x.begin(), x.end()
#define allr(x) x.begin(), x.end(), greater<ll>()
#define P pair<ll, ll>
#define pb push_back
#define mp make_pair
#define MOD 1000000007
#define INF 1ll << 60
#define PI 3.14159265359
using namespace std;
ll gcd(ll a, ll b) {
if (a * b == 0)
return max(a, b);
if (a < b) {
ll tmp = a;
a = b;
b = tmp;
}
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
}
ll odd, even;
ll even_count = 0;
while (true) {
odd = 0;
even = 0;
for (ll i = 0; i < n; i++) {
if (a[i] % 2 == 0)
even++;
else
odd++;
}
if (even * odd != 0) {
cout << 0 << endl;
return 0;
}
if (even == 0) {
break;
}
even_count++;
for (ll i = 0; i < n; i++)
a[i] /= 2;
}
ll lcm_all = lcm(pow(2, even_count), a[0]);
for (ll i = 1; i < n; i++) {
lcm_all = lcm(lcm_all, a[i]);
if (lcm_all > m) {
cout << 0 << endl;
return 0;
}
}
cout << (m / lcm_all + 1) / 2 << endl;
return 0;
}
| insert | 88 | 88 | 88 | 92 | TLE | |
p02814 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int f(int x) {
int res = 0;
while (x % 2 == 0) {
x /= 2;
res++;
}
return res;
}
int main(void) {
// Your code here!
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 1) {
cout << 0 << endl;
return 0;
}
a[i] /= 2;
}
int t = f(a[0]);
for (int i = 0; i < n; i++) {
if (f(a[i] != t)) {
cout << 0 << endl;
return 0;
}
a[i] = a[i] >> t;
}
m = m >> t;
long long l = 1;
for (int i = 0; i < n; i++) {
l = lcm(l, a[i]);
if (l > m) {
cout << 0 << endl;
return 0;
}
}
m /= l;
int ans = (m + 1) / 2;
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int f(int x) {
int res = 0;
while (x % 2 == 0) {
x /= 2;
res++;
}
return res;
}
int main(void) {
// Your code here!
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 1) {
cout << 0 << endl;
return 0;
}
a[i] /= 2;
}
int t = f(a[0]);
for (int i = 0; i < n; i++) {
if (f(a[i]) != t) {
cout << 0 << endl;
return 0;
}
a[i] = a[i] >> t;
}
m = m >> t;
long long l = 1;
for (int i = 0; i < n; i++) {
l = lcm(l, a[i]);
if (l > m) {
cout << 0 << endl;
return 0;
}
}
m /= l;
int ans = (m + 1) / 2;
cout << ans << endl;
return 0;
}
| replace | 43 | 44 | 43 | 44 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> iint;
typedef pair<ll, ll> llll;
#define ALL(x) (x).begin(), (x).end()
const ll zero = 0;
const ll INF = 3000000000000000000; // 10^18
const int inINF = 1000000000; // 10^9
const ll MOD = 1000000007; // 10^9+7
const ll MOD2 = 998244353;
void Yes() { printf("Yes\n"); }
void No() { printf("No\n"); }
void YES() { printf("YES\n"); }
void NO() { printf("NO\n"); }
ll lcm(ll a, ll b) { return a / __gcd(a, b) * b; }
int main() {
ll N, M;
cin >> N >> M;
vector<ll> b(N);
for (ll i = 0; i < N; i++) {
cin >> b[i];
b[i] = b[i] / 2;
}
ll L = lcm(b[0], b[1]);
for (ll i = 2; i < N; i++) {
L = lcm(L, b[i]);
if (L > M) {
printf("0\n");
return 0;
}
}
ll C = M / L;
ll D = M / (2 * L);
for (ll i = 0; i < N; i++) {
if ((L / b[i]) % 2 == 0) {
D = C;
}
}
printf("%lld\n", C - D);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> iint;
typedef pair<ll, ll> llll;
#define ALL(x) (x).begin(), (x).end()
const ll zero = 0;
const ll INF = 3000000000000000000; // 10^18
const int inINF = 1000000000; // 10^9
const ll MOD = 1000000007; // 10^9+7
const ll MOD2 = 998244353;
void Yes() { printf("Yes\n"); }
void No() { printf("No\n"); }
void YES() { printf("YES\n"); }
void NO() { printf("NO\n"); }
ll lcm(ll a, ll b) { return a / __gcd(a, b) * b; }
int main() {
ll N, M;
cin >> N >> M;
vector<ll> b(N);
for (ll i = 0; i < N; i++) {
cin >> b[i];
b[i] = b[i] / 2;
}
if (N == 1) {
printf("%lld\n", M / b[0] - M / (2 * b[0]));
return 0;
}
ll L = lcm(b[0], b[1]);
for (ll i = 2; i < N; i++) {
L = lcm(L, b[i]);
if (L > M) {
printf("0\n");
return 0;
}
}
ll C = M / L;
ll D = M / (2 * L);
for (ll i = 0; i < N; i++) {
if ((L / b[i]) % 2 == 0) {
D = C;
}
}
printf("%lld\n", C - D);
} | insert | 28 | 28 | 28 | 33 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (a < b)
return gcd(b, a);
if (b == 0)
return a;
ll x = a % b;
if (b / 2 < x)
return gcd(b, b - x);
return gcd(b, x);
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
ll x = a[0];
ll y = 0;
while (x % 2 == 0) {
x /= 2;
y++;
}
ll shift = 1ll << y;
for (ll i = 0; i < n; i++) {
if (a[i] % shift != 0 || a[i] % (shift << 1) == 0) {
cout << 0 << endl;
return 0;
}
}
for (ll i = 0; i < n; i++) {
a[i] >>= 1;
}
vector<ll> ruiseki(n);
ruiseki[0] = a[0];
for (ll i = 1; i < n; i++) {
ruiseki[i] = ruiseki[i - 1] / gcd(ruiseki[i - 1], a[i]) * a[i];
// if(ruiseki[i] > m) {
// cout << 0 << endl;
// return 0;
// }
}
printf("%lld\n", ll(ceil(m / ruiseki[n - 1] / 2.0)));
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (a < b)
return gcd(b, a);
if (b == 0)
return a;
ll x = a % b;
if (b / 2 < x)
return gcd(b, b - x);
return gcd(b, x);
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
ll x = a[0];
ll y = 0;
while (x % 2 == 0) {
x /= 2;
y++;
}
ll shift = 1ll << y;
for (ll i = 0; i < n; i++) {
if (a[i] % shift != 0 || a[i] % (shift << 1) == 0) {
cout << 0 << endl;
return 0;
}
}
for (ll i = 0; i < n; i++) {
a[i] >>= 1;
}
vector<ll> ruiseki(n);
ruiseki[0] = a[0];
for (ll i = 1; i < n; i++) {
ruiseki[i] = ruiseki[i - 1] / gcd(ruiseki[i - 1], a[i]) * a[i];
if (ruiseki[i] > m) {
cout << 0 << endl;
return 0;
}
}
printf("%lld\n", ll(ceil(m / ruiseki[n - 1] / 2.0)));
}
| replace | 51 | 55 | 51 | 55 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (a < b)
return gcd(b, a);
if (b == 0)
return a;
ll x = a % b;
if (b / 2 < x)
return gcd(b, b - x);
return gcd(b, x);
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
ll x = a[0];
ll y = 0;
while (x % 2 == 0) {
x /= 2;
y++;
}
ll shift = 1ll << y;
for (ll i = 0; i < n; i++) {
if (a[i] % shift != 0 || a[i] % (shift << 1) == 0) {
cout << 0 << endl;
return 0;
}
}
for (ll i = 0; i < n; i++) {
a[i] >>= 1;
}
vector<ll> ruiseki(n);
ruiseki[0] = a[0];
for (ll i = 1; i < n; i++) {
ruiseki[i] = ruiseki[i - 1] * a[i] / gcd(ruiseki[i - 1], a[i]);
}
printf("%lld\n", ll(ceil(m / ruiseki[n - 1] / 2.0)));
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (a < b)
return gcd(b, a);
if (b == 0)
return a;
ll x = a % b;
if (b / 2 < x)
return gcd(b, b - x);
return gcd(b, x);
}
int main() {
ll n, m;
cin >> n >> m;
vector<ll> a(n);
for (ll i = 0; i < n; i++) {
cin >> a[i];
}
ll x = a[0];
ll y = 0;
while (x % 2 == 0) {
x /= 2;
y++;
}
ll shift = 1ll << y;
for (ll i = 0; i < n; i++) {
if (a[i] % shift != 0 || a[i] % (shift << 1) == 0) {
cout << 0 << endl;
return 0;
}
}
for (ll i = 0; i < n; i++) {
a[i] >>= 1;
}
vector<ll> ruiseki(n);
ruiseki[0] = a[0];
for (ll i = 1; i < n; i++) {
ruiseki[i] = ruiseki[i - 1] * a[i] / gcd(ruiseki[i - 1], a[i]);
if (ruiseki[i] > m) {
cout << 0 << endl;
return 0;
}
}
printf("%lld\n", ll(ceil(m / ruiseki[n - 1] / 2.0)));
}
| insert | 51 | 51 | 51 | 55 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm> // for next_permutation
#include <bits/stl_numeric.h>
#include <fstream>
#include <iostream>
#include <queue>
#include <vector>
#define DEBUG 0
#define REP(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
static const ll MOD = 1000000007;
static const ll INF = 1000000000000000000LL;
unsigned gcd(unsigned a, unsigned b) {
if (a < b)
return gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<ll> a(N);
ll amax = 0;
REP(i, N) {
cin >> a[i];
amax = max(amax, a[i]);
}
ll wa = a[0];
int wa2 = 0;
for (int i = 1; i < N; ++i) {
wa = lcm(wa, a[i]);
if (wa >= MOD * 2) {
cout << 0 << endl;
return 0;
}
}
// lcmの2が複数含まれてたらおわり
// それぞれの2の個数が一致していないといけない
int cnt1 = 0;
while (a[0] % 2 == 0) {
++cnt1;
a[0] /= 2;
}
for (int i = 1; i < N; ++i) {
int cnt2 = 0;
while (a[i] % 2 == 0) {
++cnt2;
a[i] %= 2;
}
if (cnt1 != cnt2) {
cout << 0 << endl;
return 0;
}
}
ll res;
M += (wa / 2);
res = M / wa;
cout << res << endl;
return 0;
}
| #include <algorithm> // for next_permutation
#include <bits/stl_numeric.h>
#include <fstream>
#include <iostream>
#include <queue>
#include <vector>
#define DEBUG 0
#define REP(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
static const ll MOD = 1000000007;
static const ll INF = 1000000000000000000LL;
unsigned gcd(unsigned a, unsigned b) {
if (a < b)
return gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
vector<ll> a(N);
ll amax = 0;
REP(i, N) {
cin >> a[i];
amax = max(amax, a[i]);
}
ll wa = a[0];
int wa2 = 0;
for (int i = 1; i < N; ++i) {
wa = lcm(wa, a[i]);
if (wa >= MOD * 2) {
cout << 0 << endl;
return 0;
}
}
// lcmの2が複数含まれてたらおわり
// それぞれの2の個数が一致していないといけない
int cnt1 = 0;
while (a[0] % 2 == 0) {
++cnt1;
a[0] /= 2;
}
for (int i = 1; i < N; ++i) {
int cnt2 = 0;
while (a[i] % 2 == 0) {
++cnt2;
a[i] /= 2;
}
if (cnt1 != cnt2) {
cout << 0 << endl;
return 0;
}
}
ll res;
M += (wa / 2);
res = M / wa;
cout << res << endl;
return 0;
}
| replace | 65 | 66 | 65 | 66 | TLE | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int MOD = 1000000007;
const int INF = 1e15;
using Graph = vector<vector<int>>;
int gcd(int a, int b) {
if (!a)
return b;
return gcd(b % a, a);
}
int lcm(int x, int y) {
if (x == 0 || y == 0)
return 0;
return x / gcd(x, y) * y;
}
signed main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
A[i] /= 2;
}
int cnt = 0;
int B = A[0];
while (B % 2 == 0) {
B /= 2;
cnt++;
}
for (int i = 1; i < N; i++) {
B = A[i];
int now = 0;
while (B % 2 == 0) {
B /= 2;
now++;
}
// 2で割れる回数が異なったら
if (cnt != now) {
cout << 0 << endl;
return 0;
}
}
int LCM = lcm(A[0], A[1]);
for (int i = 2; i < N; i++) {
LCM = lcm(LCM, A[i]);
if (LCM > M) {
cout << 0 << endl;
return 0;
}
}
cout << (M / LCM + 1) / 2 << endl;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
const int MOD = 1000000007;
const int INF = 1e15;
using Graph = vector<vector<int>>;
int gcd(int a, int b) {
if (!a)
return b;
return gcd(b % a, a);
}
int lcm(int x, int y) {
if (x == 0 || y == 0)
return 0;
return x / gcd(x, y) * y;
}
signed main() {
int N, M;
cin >> N >> M;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
A[i] /= 2;
}
int cnt = 0;
int B = A[0];
while (B % 2 == 0) {
B /= 2;
cnt++;
}
for (int i = 1; i < N; i++) {
B = A[i];
int now = 0;
while (B % 2 == 0) {
B /= 2;
now++;
}
// 2で割れる回数が異なったら
if (cnt != now) {
cout << 0 << endl;
return 0;
}
}
int LCM;
if (N >= 2)
LCM = lcm(A[0], A[1]);
else
LCM = A[0];
for (int i = 2; i < N; i++) {
LCM = lcm(LCM, A[i]);
if (LCM > M) {
cout << 0 << endl;
return 0;
}
}
cout << (M / LCM + 1) / 2 << endl;
}
| replace | 49 | 50 | 49 | 55 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #include <boost/multiprecision/cpp_int.hpp>
// typedef boost::multiprecision::cpp_int ll;
typedef long double dd;
#define i_7 (ll)(1E9 + 7)
// #define i_7 998244353
#define i_5 i_7 - 2
ll mod(ll a) {
ll c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
typedef pair<ll, ll> l_l;
ll inf = (ll)1E16;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define pb push_back
ll max(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll min(ll a, ll b) {
if (a > b)
return b;
else
return a;
}
void Max(ll &pos, ll val) { pos = max(pos, val); } // Max(dp[n],dp[n-1]);
void Min(ll &pos, ll val) { pos = min(pos, val); }
void Add(ll &pos, ll val) { pos = mod(pos + val); }
dd EPS = 1E-9;
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
////////////////////////////
ll gcd(ll x, ll y) {
if (x < y)
return gcd(y, x);
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
ll b[n];
ll g = 1;
int bol = 0;
rep(i, 0, n - 1) {
cin >> a[i];
b[i] = a[i] / 2;
if (i == 0) {
bol = b[i] % 2;
} else {
if (bol != b[i] % 2) {
cout << 0 << endl;
return 0;
}
}
g = (g * b[i]) / gcd(g, b[i]);
}
if (bol == 1) {
ll ans = (m + g) / (2 * g);
cout << ans << endl;
} else {
rep(i, 0, n - 1) {
if ((g / b[i]) % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
ll ans = (m + g) / (2 * g);
cout << ans << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// #include <boost/multiprecision/cpp_int.hpp>
// typedef boost::multiprecision::cpp_int ll;
typedef long double dd;
#define i_7 (ll)(1E9 + 7)
// #define i_7 998244353
#define i_5 i_7 - 2
ll mod(ll a) {
ll c = a % i_7;
if (c >= 0)
return c;
return c + i_7;
}
typedef pair<ll, ll> l_l;
ll inf = (ll)1E16;
#define rep(i, l, r) for (ll i = l; i <= r; i++)
#define pb push_back
ll max(ll a, ll b) {
if (a < b)
return b;
else
return a;
}
ll min(ll a, ll b) {
if (a > b)
return b;
else
return a;
}
void Max(ll &pos, ll val) { pos = max(pos, val); } // Max(dp[n],dp[n-1]);
void Min(ll &pos, ll val) { pos = min(pos, val); }
void Add(ll &pos, ll val) { pos = mod(pos + val); }
dd EPS = 1E-9;
#define fastio \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0);
////////////////////////////
ll gcd(ll x, ll y) {
if (x < y)
return gcd(y, x);
if (y == 0)
return x;
return gcd(y, x % y);
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
ll b[n];
ll g = 1;
int bol = 0;
rep(i, 0, n - 1) {
cin >> a[i];
b[i] = a[i] / 2;
if (i == 0) {
bol = b[i] % 2;
} else {
if (bol != b[i] % 2) {
cout << 0 << endl;
return 0;
}
}
if (g <= 10 * m) {
g = (g * b[i]) / gcd(g, b[i]);
} else {
cout << 0 << endl;
return 0;
}
}
if (bol == 1) {
ll ans = (m + g) / (2 * g);
cout << ans << endl;
} else {
rep(i, 0, n - 1) {
if ((g / b[i]) % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
ll ans = (m + g) / (2 * g);
cout << ans << endl;
}
return 0;
}
| replace | 67 | 68 | 67 | 73 | TLE | |
p02814 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef long long ll;
const char sp = ' ';
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * (b / gcd(a, b)) * gcd(a, b); }
using namespace std;
int main(void) {
ll N, M, amax = 1;
cin >> N >> M;
ll a[100005], d = 1;
rep(i, N) {
cin >> a[i];
// amax=max(amax, a[i]);
if (i == 0) {
while (true) {
if (a[i] % 2 != 0)
break;
a[i] /= 2;
d *= 2;
}
} else {
if (a[i] % d != 0) {
cout << 0 << endl;
return 0;
}
a[i] /= d;
if (a[i] % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
}
d /= 2;
rep(i, N) { a[i] *= d; }
ll LCM = 1;
rep(i, N) { LCM = lcm(LCM, a[i]); }
// cout<<lcm<<endl;
ll ans = (ll)((M / LCM) + 1) / 2;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <cstring>
#include <iostream>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define MEMSET(v, h) memset((v), h, sizeof(v))
typedef unsigned long long ll;
const char sp = ' ';
ll gcd(ll a, ll b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * (b / gcd(a, b)) * gcd(a, b); }
using namespace std;
int main(void) {
ll N, M, amax = 1;
cin >> N >> M;
ll a[100005], d = 1;
rep(i, N) {
cin >> a[i];
// amax=max(amax, a[i]);
if (i == 0) {
while (true) {
if (a[i] % 2 != 0)
break;
a[i] /= 2;
d *= 2;
}
} else {
if (a[i] % d != 0) {
cout << 0 << endl;
return 0;
}
a[i] /= d;
if (a[i] % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
}
d /= 2;
rep(i, N) { a[i] *= d; }
ll LCM = 1;
rep(i, N) { LCM = lcm(LCM, a[i]); }
// cout<<lcm<<endl;
ll ans = (ll)((M / LCM) + 1) / 2;
cout << ans << endl;
return 0;
}
| replace | 15 | 16 | 15 | 16 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long long maxn = 10;
long long n, m;
long long a[maxn];
long long b[maxn];
long long ans;
void in();
void solve();
void out();
int main() {
in();
solve();
out();
}
void in() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
}
}
void solve() {
long long chek = __builtin_ctz(a[0]);
long long lcm = a[0];
for (long long i = 0; i < n; i++) {
lcm = lcm * a[i] / __gcd(lcm, a[i]);
if (__builtin_ctzll(a[i]) != chek || lcm > m)
return;
}
ans = (m / lcm + 1) / 2;
}
void out() { cout << ans; }
| #include <bits/stdc++.h>
using namespace std;
const long long maxn = 1e5 + 10;
long long n, m;
long long a[maxn];
long long b[maxn];
long long ans;
void in();
void solve();
void out();
int main() {
in();
solve();
out();
}
void in() {
ios::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
cin >> n >> m;
for (long long i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
}
}
void solve() {
long long chek = __builtin_ctz(a[0]);
long long lcm = a[0];
for (long long i = 0; i < n; i++) {
lcm = lcm * a[i] / __gcd(lcm, a[i]);
if (__builtin_ctzll(a[i]) != chek || lcm > m)
return;
}
ans = (m / lcm + 1) / 2;
}
void out() { cout << ans; }
| replace | 3 | 4 | 3 | 4 | 0 | |
p02814 | C++ | Runtime Error | #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template <class T> bool chmax(T &a, const T &b) {
if (b > a) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
#pragma endregion
long long gcd(long long a, long long b) {
if (a < b)
std::swap(a, b);
if (b == 0)
return a;
while (a % b > 0) {
long long buf = b;
b = a % b;
a = buf;
}
return b;
}
void solve() {
int n;
ll m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
int cnt2 = 0;
for (int i = 0; i < n; i++) {
int tmp = 0;
while (a.at(i) % 2 == 0) {
a.at(i) /= 2;
tmp++;
}
if (i == 0)
cnt2 = tmp;
else {
if (cnt2 != tmp) {
cout << 0 << "\n";
return;
}
}
}
ll odd = 1;
for (int i = 0; i < n; i++) {
odd = odd * a.at(i) / gcd(odd, a.at(i));
}
odd *= (1ll << (cnt2 - 1));
cout << (m / odd) / 2 + (m / odd) % 2 << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
| #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template <class T> bool chmax(T &a, const T &b) {
if (b > a) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
#pragma endregion
long long gcd(long long a, long long b) {
if (a < b)
std::swap(a, b);
if (b == 0)
return a;
while (a % b > 0) {
long long buf = b;
b = a % b;
a = buf;
}
return b;
}
void solve() {
int n;
ll m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a.at(i);
}
int cnt2 = 0;
for (int i = 0; i < n; i++) {
int tmp = 0;
while (a.at(i) % 2 == 0) {
a.at(i) /= 2;
tmp++;
}
if (i == 0)
cnt2 = tmp;
else {
if (cnt2 != tmp) {
cout << 0 << "\n";
return;
}
}
}
ll odd = 1;
for (int i = 0; i < n; i++) {
odd = odd * a.at(i) / gcd(odd, a.at(i));
}
if (cnt2 >= 2)
odd *= pow(2, cnt2 - 1);
cout << (m / odd) / 2 + (m / odd) % 2 << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
| replace | 70 | 71 | 70 | 72 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0, i##_max = (N); i < i##_max; ++i)
#define repp(i, l, r) for (int i = (l), i##_max = (r); i < i##_max; ++i)
#define per(i, N) for (int i = (N)-1; i >= 0; --i)
#define perr(i, l, r) for (int i = r - 1, i##_min(l); i >= i##_min; --i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP \
cin.tie(0); \
ios::sync_with_stdio(false);
#define MAX_I INT_MAX // 1e9
#define MIN_I INT_MIN //-1e9
#define MAX_UI UINT_MAX // 1e9
#define MAX_LL LLONG_MAX // 1e18
#define MIN_LL LLONG_MIN //-1e18
#define MAX_ULL ULLONG_MAX // 1e19
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<char, char> PCC;
typedef pair<ll, ll> PLL;
typedef pair<char, int> PCI;
typedef pair<int, char> PIC;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, char> PLC;
typedef pair<char, ll> PCL;
inline void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
inline void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
inline void Yay(bool b) { cout << (b ? "Yay!" : ":(") << endl; }
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
return gcd(b, a % b);
}
int fac2(ll x) {
int count = 0;
while (x % 2 == 0) {
x <<= 1;
++count;
}
return count;
}
int main(void) {
SPEEDUP
cout << setprecision(15);
int N;
ll M;
cin >> N >> M;
vector<ll> v(N);
rep(i, N) cin >> v[i], v[i] = v[i] / 2;
int fac20 = fac2(v[N - 1]);
rep(i, N - 1) {
if (fac2(v[i]) != fac20) {
cout << 0 << endl;
return 0;
}
}
ll LCM = 1ll;
rep(i, N) {
ll GCD = gcd(LCM, v[i]);
LCM = LCM / GCD * v[i];
if (LCM > M) {
cout << 0 << endl;
return 0;
}
}
ll num = M / LCM;
cout << (num + 1ll) / 2ll << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0, i##_max = (N); i < i##_max; ++i)
#define repp(i, l, r) for (int i = (l), i##_max = (r); i < i##_max; ++i)
#define per(i, N) for (int i = (N)-1; i >= 0; --i)
#define perr(i, l, r) for (int i = r - 1, i##_min(l); i >= i##_min; --i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP \
cin.tie(0); \
ios::sync_with_stdio(false);
#define MAX_I INT_MAX // 1e9
#define MIN_I INT_MIN //-1e9
#define MAX_UI UINT_MAX // 1e9
#define MAX_LL LLONG_MAX // 1e18
#define MIN_LL LLONG_MIN //-1e18
#define MAX_ULL ULLONG_MAX // 1e19
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<char, char> PCC;
typedef pair<ll, ll> PLL;
typedef pair<char, int> PCI;
typedef pair<int, char> PIC;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, char> PLC;
typedef pair<char, ll> PCL;
inline void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
inline void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
inline void Yay(bool b) { cout << (b ? "Yay!" : ":(") << endl; }
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
return gcd(b, a % b);
}
int fac2(ll x) {
int count = 0;
while (x % 2 == 0) {
x >>= 1;
++count;
}
return count;
}
int main(void) {
SPEEDUP
cout << setprecision(15);
int N;
ll M;
cin >> N >> M;
vector<ll> v(N);
rep(i, N) cin >> v[i], v[i] = v[i] / 2;
int fac20 = fac2(v[N - 1]);
rep(i, N - 1) {
if (fac2(v[i]) != fac20) {
cout << 0 << endl;
return 0;
}
}
ll LCM = 1ll;
rep(i, N) {
ll GCD = gcd(LCM, v[i]);
LCM = LCM / GCD * v[i];
if (LCM > M) {
cout << 0 << endl;
return 0;
}
}
ll num = M / LCM;
cout << (num + 1ll) / 2ll << endl;
return 0;
}
| replace | 44 | 45 | 44 | 45 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define RREP(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define rrep(i, n) RREP(i, (n)-1, 0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const ll mod2 = 998244353;
const ld eps = 1e-10;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
ll gcd(ll x, ll y) {
if (x > y)
return gcd(y, x);
else if (x == 0)
return y;
else
return gcd(y % x, x);
}
ll lcm(ll x, ll y) {
ll g = gcd(x, y);
return g * (x / g) * (y / g);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll m;
cin >> n >> m;
vector<ll> A(n);
rep(i, n) cin >> A[i];
auto count = [&](ll n) {
int ret = 0;
while (n % 2 == 0) {
ret++;
n /= 2;
}
return ret;
};
int cnt = count(A[0]);
rep(i, n) {
if (count(A[i]) != cnt) {
cout << 0 << endk;
return 0;
}
}
ll l = A[0];
rep(i, n) l = lcm(A[i], l);
cout << (m < l / 2 ? 0 : (m - l / 2) / l + 1) << endk;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define RREP(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define rrep(i, n) RREP(i, (n)-1, 0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
const ll mod2 = 998244353;
const ld eps = 1e-10;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
ll gcd(ll x, ll y) {
if (x > y)
return gcd(y, x);
else if (x == 0)
return y;
else
return gcd(y % x, x);
}
ll lcm(ll x, ll y) {
ll g = gcd(x, y);
return g * (x / g) * (y / g);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll m;
cin >> n >> m;
vector<ll> A(n);
rep(i, n) cin >> A[i];
auto count = [&](ll n) {
int ret = 0;
while (n % 2 == 0) {
ret++;
n /= 2;
}
return ret;
};
int cnt = count(A[0]);
rep(i, n) {
if (count(A[i]) != cnt) {
cout << 0 << endk;
return 0;
}
}
ll l = A[0];
rep(i, n) {
l = lcm(A[i], l);
if (l / 2 > m) {
cout << 0 << endk;
return 0;
}
}
cout << (m - l / 2) / l + 1 << endk;
return 0;
}
| replace | 60 | 62 | 60 | 68 | TLE | |
p02814 | Python | Runtime Error | # from fractions import gcd
from math import gcd
from functools import reduce
N, M = map(int, input().split())
nums = set([num // 2 for num in list(map(int, input().split()))])
# 1<=X<=Mの範囲で、半公倍数の数を求める。
# 但し、Xは、num*(p+0.5)でなければならない
# Mが10**9なので、全部やるのは無理。
# n.5倍なので、numsのあたいは全て偶数になっている。
# nums一つ一つ、答えになりうるXの配列を作って、重複したものを残せばそれが答えになる。
# Nが10**5なので、どうだろう
def half_multiple(x, y):
return (x * y) // gcd(x, y)
def run():
half_multiple_num = reduce(half_multiple, nums, 1)
# print(half_multiple_num)
for num in nums:
if (half_multiple_num // num) % 2 == 0:
print(0)
return
pmax = M // half_multiple_num
pmax = pmax - 1 if pmax % 2 == 0 else pmax
print((pmax + 1) // 2)
run()
| from fractions import gcd
# from math import gcd
from functools import reduce
N, M = map(int, input().split())
nums = set([num // 2 for num in list(map(int, input().split()))])
# 1<=X<=Mの範囲で、半公倍数の数を求める。
# 但し、Xは、num*(p+0.5)でなければならない
# Mが10**9なので、全部やるのは無理。
# n.5倍なので、numsのあたいは全て偶数になっている。
# nums一つ一つ、答えになりうるXの配列を作って、重複したものを残せばそれが答えになる。
# Nが10**5なので、どうだろう
def half_multiple(x, y):
return (x * y) // gcd(x, y)
def run():
half_multiple_num = reduce(half_multiple, nums, 1)
# print(half_multiple_num)
for num in nums:
if (half_multiple_num // num) % 2 == 0:
print(0)
return
pmax = M // half_multiple_num
pmax = pmax - 1 if pmax % 2 == 0 else pmax
print((pmax + 1) // 2)
run()
| replace | 0 | 2 | 0 | 3 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3,Ofast,no-stack-protector,unroll-loops,fast-math")
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
int main() {
long long n, m;
cin >> n >> m;
long long a[n];
long long ans = 1;
long long ok = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
ok = ans * a[i];
ans = __gcd(ans, a[i]);
ans = ok / ans;
}
// cout<<ans<<endl;
long long ammat = m / ans;
for (int i = 0; i < n; i++) {
if ((ans / (a[i] / 2)) % 2 == 0) {
cout << 0;
return 0;
}
}
if (ammat % 2) {
cout << ammat / 2 + 1;
} else {
cout << ammat / 2;
}
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3,Ofast,no-stack-protector,unroll-loops,fast-math")
#define IOS ios::sync_with_stdio(0), cin.tie(0), cout.tie(0)
int main() {
long long n, m;
cin >> n >> m;
long long a[n];
long long ans = 1;
long long ok = 1;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 2;
ok = ans * a[i];
ans = __gcd(ans, a[i]);
ans = ok / ans;
}
// cout<<ans<<endl;
long long ammat = m / ans;
for (int i = 0; i < n; i++) {
if ((ans / (a[i])) % 2 == 0) {
cout << 0;
return 0;
}
}
if (ammat % 2) {
cout << ammat / 2 + 1;
} else {
cout << ammat / 2;
}
}
| replace | 20 | 21 | 20 | 21 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
#define int long long
int gcd(int a, int b) {
if (b > a)
return gcd(b, a);
else if (b == 0)
return a;
else
return gcd(b, a % b);
}
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
int a[100010];
rep(i, N) cin >> a[i];
int k = 0;
while (((a[0] >> k) << k) == a[0])
k++;
rep(i, N) {
int tmp = 0;
while (((a[i] >> tmp) << tmp) == a[i])
tmp++;
if (k != tmp) {
cout << 0 << endl;
return 0;
}
}
int L = a[0];
rep(i, N) { L = L * a[i] / gcd(L, a[i]); }
cout << (M + L / 2) / L << endl;
return 0;
}
| #include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ll long long int
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = n; i >= 0; i--)
#define REP(i, s, t) for (int i = s; i <= t; i++)
#define RREP(i, s, t) for (int i = s; i >= t; i--)
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
#define int long long
int gcd(int a, int b) {
if (b > a)
return gcd(b, a);
else if (b == 0)
return a;
else
return gcd(b, a % b);
}
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
int a[100010];
rep(i, N) cin >> a[i];
int k = 0;
while (((a[0] >> k) << k) == a[0])
k++;
rep(i, N) {
int tmp = 0;
while (((a[i] >> tmp) << tmp) == a[i])
tmp++;
if (k != tmp) {
cout << 0 << endl;
return 0;
}
}
int L = a[0];
rep(i, N) {
L = L * a[i] / gcd(L, a[i]);
if ((M + L / 2) / L == 0) {
cout << 0 << endl;
return 0;
}
}
cout << (M + L / 2) / L << endl;
return 0;
}
| replace | 55 | 56 | 55 | 62 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define all_map(itr, mp) for (auto itr = mp.begin(); itr != mp.end(); itr++)
#define ALL(a) (a).begin(), (a).end()
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
ll g = 1;
rep(i, n) g = (g * a[i]) / gcd(g, a[i]);
g /= 2;
rep(i, n) if (g % a[i] == 0) {
cout << 0;
return 0;
}
ll ans = m / g + 1;
cout << ans / 2 << endl;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
using ll = long long;
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define all_map(itr, mp) for (auto itr = mp.begin(); itr != mp.end(); itr++)
#define ALL(a) (a).begin(), (a).end()
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return (b);
else
return (gcd(b, a % b));
}
int main() {
ll n, m;
cin >> n >> m;
ll a[n];
rep(i, n) cin >> a[i];
ll g = 1;
rep(i, n) {
g = (g * a[i]) / gcd(g, a[i]);
if (g / 2 > m) {
cout << 0;
return 0;
}
}
g /= 2;
rep(i, n) if (g % a[i] == 0) {
cout << 0;
return 0;
}
ll ans = m / g + 1;
cout << ans / 2 << endl;
} | replace | 33 | 34 | 33 | 40 | TLE | |
p02814 | C++ | Time Limit Exceeded |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
if (a < b)
return gcd(b, a);
return gcd(b, a % b);
}
ll lcm(ll x, ll y) { return (x * y) / gcd(x, y); }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool ok = true;
for (int i = 1; i < n; i++) {
int cntX = 0, cntY = 0;
int x = a[i];
int y = a[i - 1];
while (x % 2 == 0) {
x /= 2;
cntX++;
}
while (y % 2 == 0) {
y /= 2;
cntY++;
}
if (cntX != cntY) {
ok = false;
break;
}
}
ll vlcm = a[0] / 2;
for (int i = 1; i < n; i++) {
a[i] /= 2;
vlcm = lcm(a[i], vlcm);
}
ll ans = 0;
if (ok) {
ll mul = 1;
while (vlcm * mul <= m) {
ans++;
mul += 2;
}
cout << ans << endl;
} else {
cout << 0 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
if (a < b)
return gcd(b, a);
return gcd(b, a % b);
}
ll lcm(ll x, ll y) { return (x * y) / gcd(x, y); }
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
bool ok = true;
for (int i = 1; i < n; i++) {
int cntX = 0, cntY = 0;
int x = a[i];
int y = a[i - 1];
while (x % 2 == 0) {
x /= 2;
cntX++;
}
while (y % 2 == 0) {
y /= 2;
cntY++;
}
if (cntX != cntY) {
ok = false;
break;
}
}
ll vlcm = a[0] / 2;
for (int i = 1; i < n; i++) {
a[i] /= 2;
vlcm = lcm(a[i], vlcm);
if (vlcm > m) {
ok = false;
break;
}
}
ll ans = 0;
if (ok) {
ll mul = 1;
while (vlcm * mul <= m) {
ans++;
mul += 2;
}
cout << ans << endl;
} else {
cout << 0 << endl;
}
return 0;
}
| insert | 55 | 55 | 55 | 59 | TLE | |
p02814 | Python | Runtime Error | def main():
from functools import reduce
from math import gcd
def lcm(a, b):
return (a // gcd(a, b)) * b
N, M = map(int, input().split())
(*a,) = map(int, input().split())
p = -1
b = []
for x in a:
cnt = 0
while x % 2 == 0:
x //= 2
cnt += 1
if ~p and p != cnt:
print(0)
return
p = cnt
b.append(x)
if p == 0:
print(0)
return
t = pow(2, p - 1) * reduce(lcm, b)
ans = (M // t) - (M // (t * 2))
print(ans)
if __name__ == "__main__":
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| def main():
from functools import reduce
def gcd(a, b):
return a if b == 0 else gcd(b, a % b)
def lcm(a, b):
return (a // gcd(a, b)) * b
N, M = map(int, input().split())
(*a,) = map(int, input().split())
p = -1
b = []
for x in a:
cnt = 0
while x % 2 == 0:
x //= 2
cnt += 1
if ~p and p != cnt:
print(0)
return
p = cnt
b.append(x)
if p == 0:
print(0)
return
t = pow(2, p - 1) * reduce(lcm, b)
ans = (M // t) - (M // (t * 2))
print(ans)
if __name__ == "__main__":
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
| replace | 2 | 3 | 2 | 5 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i, s, n) for (int i = s; i < n; i++)
#define MOD 1000000007
#define NUM 2520
#define INF (1LL << 50)
#define DEBUG 0
#define mp(a, b) make_pair(a, b)
#define SORT(V) sort(V.begin(), V.end())
#define PI (3.141592653589794)
lli gcd(lli x, lli y) {
if (x < y)
swap(x, y);
if (y == 0) {
return x;
} else {
return gcd(y, x % y);
}
}
lli lcm(lli a, lli b) { return a * b / gcd(a, b); }
void func(long long N, long long M, std::vector<long long> a) {
sort(a.begin(), a.end());
REP(i, 0, N) a[i] /= 2;
lli GCD = a[0];
REP(i, 1, N) GCD = lcm(GCD, a[i]);
REP(i, 0, N) {
if ((GCD / a[i]) % 2 == 0) {
cout << 0 << endl;
return;
}
}
cout << (M + GCD) / (2 * GCD) << endl;
}
int main() {
// cout << fixed << setprecision(5);
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
std::vector<long long> a(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &a[i]);
}
func(N, M, std::move(a));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define REP(i, s, n) for (int i = s; i < n; i++)
#define MOD 1000000007
#define NUM 2520
#define INF (1LL << 50)
#define DEBUG 0
#define mp(a, b) make_pair(a, b)
#define SORT(V) sort(V.begin(), V.end())
#define PI (3.141592653589794)
lli gcd(lli x, lli y) {
if (x < y)
swap(x, y);
if (y == 0) {
return x;
} else {
return gcd(y, x % y);
}
}
lli lcm(lli a, lli b) { return a * b / gcd(a, b); }
void func(long long N, long long M, std::vector<long long> a) {
sort(a.begin(), a.end());
REP(i, 0, N) a[i] /= 2;
lli GCD = a[0];
REP(i, 1, N) {
GCD = lcm(GCD, a[i]);
if (GCD > M) {
cout << 0 << endl;
return;
}
}
REP(i, 0, N) {
if ((GCD / a[i]) % 2 == 0) {
cout << 0 << endl;
return;
}
}
cout << (M + GCD) / (2 * GCD) << endl;
}
int main() {
// cout << fixed << setprecision(5);
long long N;
scanf("%lld", &N);
long long M;
scanf("%lld", &M);
std::vector<long long> a(N);
for (int i = 0; i < N; i++) {
scanf("%lld", &a[i]);
}
func(N, M, std::move(a));
return 0;
}
| replace | 29 | 30 | 29 | 36 | TLE | |
p02814 | Python | Runtime Error | def main():
from math import gcd, ceil
n, m, *a = map(int, open(0).read().split())
b = [0 for _ in range(n)]
a.sort()
for i, j in enumerate(a):
c = 0
while j % 2 == 0:
c += 1
j = j // 2
a[i] = j
b[i] = c
if len(set(b)) > 1:
print(0)
exit()
lcm = 1
for i in a:
lcm = (lcm * i) // gcd(lcm, i)
k = b[0] - 1
ans = ceil(m // 2**k // lcm / 2)
print(ans)
if __name__ == "__main__":
main()
| def main():
from fractions import gcd
from math import ceil
n, m, *a = map(int, open(0).read().split())
b = [0 for _ in range(n)]
a.sort()
for i, j in enumerate(a):
c = 0
while j % 2 == 0:
c += 1
j = j // 2
a[i] = j
b[i] = c
if len(set(b)) > 1:
print(0)
exit()
lcm = 1
for i in a:
lcm = (lcm * i) // gcd(lcm, i)
k = b[0] - 1
ans = ceil(m // 2**k // lcm / 2)
print(ans)
if __name__ == "__main__":
main()
| replace | 1 | 2 | 1 | 3 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
int n, m;
cin >> n >> m;
VL a(n);
cin >> a;
set<int> c;
FOR(i, 0, n) FOR(j, 0, 40) if (a[i] & (1LL << j)) {
c.insert(j);
break;
}
if (c.size() != 1) {
cout << "0\n";
return 0;
}
ll x = 1;
FOR(i, 0, n) x = max(lcm(x, a[i]), 0LL);
if (x % 2 == 1) {
cout << "0\n";
return 0;
}
ll ans = (m - x / 2 + x) / x;
cout << ans << "\n";
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<int>;
using VL = vector<ll>;
template <class T> using PQ = priority_queue<T, vector<T>, greater<T>>;
#define FOR(i, a, n) for (int(i) = (a); (i) < (n); ++(i))
#define eFOR(i, a, n) for (int(i) = (a); (i) <= (n); ++(i))
#define rFOR(i, a, n) for (int(i) = (n)-1; (i) >= (a); --(i))
#define erFOR(i, a, n) for (int(i) = (n); (i) >= (a); --(i))
#define each(i, a) for (auto &i : a)
#define SORT(i) sort((i).begin(), (i).end())
#define rSORT(i, a) sort((i).begin(), (i).end(), (a))
#define all(i) (i).begin(), (i).end()
#define out(y, x) ((y) < 0 || h <= (y) || (x) < 0 || w <= (x))
#define line cout << "------------------------\n"
#define ENDL(i, n) ((i) == (n)-1 ? "\n" : " ")
#define stop system("pause") // comment out this on AOJ.
constexpr ll INF = 1000000000;
constexpr ll LLINF = 1LL << 60;
constexpr ll mod = 1000000007;
constexpr ll MOD = 998244353;
constexpr ld eps = 1e-10; // 1e-9?
constexpr ld pi = 3.1415926535897932;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
inline void init() {
cin.tie(nullptr);
cout.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
}
template <class T> inline istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U>
inline istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> inline vector<T> vec(size_t a) { return vector<T>(a); }
template <class T> inline vector<T> defvec(T def, size_t a) {
return vector<T>(a, def);
}
template <class T, class... Ts> inline auto vec(size_t a, Ts... ts) {
return vector<decltype(vec<T>(ts...))>(a, vec<T>(ts...));
}
template <class T, class... Ts> inline auto defvec(T def, size_t a, Ts... ts) {
return vector<decltype(defvec<T>(def, ts...))>(a, defvec<T>(def, ts...));
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
init();
int n, m;
cin >> n >> m;
VL a(n);
cin >> a;
set<int> c;
FOR(i, 0, n) FOR(j, 0, 40) if (a[i] & (1LL << j)) {
c.insert(j);
break;
}
if (c.size() != 1) {
cout << "0\n";
return 0;
}
ll x = 1;
FOR(i, 0, n) x = max(lcm(x, a[i]), 0LL);
if (x % 2 == 1 || x == 0) {
cout << "0\n";
return 0;
}
ll ans = (m - x / 2 + x) / x;
cout << ans << "\n";
}
| replace | 93 | 94 | 93 | 94 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR_LT(i, beg, end) for (int i = beg; i < end; i++)
#define FOR_LE(i, beg, end) for (int i = beg; i <= end; i++)
#define FOR_DW(i, beg, end) for (int i = beg; end <= i; i--)
using namespace std;
int64_t gcd(int64_t a, int64_t b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
int64_t lcm(int64_t a, int64_t b) { return a * b / gcd(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(20);
int64_t n, m;
cin >> n >> m;
vector<int64_t> as(n);
for (auto &a : as) {
cin >> a;
}
int64_t lcm_v = 1;
FOR_LT(i, 0, n) { lcm_v = lcm(lcm_v, as[i]); }
FOR_LT(i, 0, n) {
if (((lcm_v / as[i]) & 1) == 0) {
cout << 0 << endl;
return 0;
}
}
int64_t fv = lcm_v / 2;
if (m < fv) {
cout << 0 << endl;
} else {
cout << 1 + (m - fv) / (2 * fv) << endl;
}
return 0;
} | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR_LT(i, beg, end) for (int i = beg; i < end; i++)
#define FOR_LE(i, beg, end) for (int i = beg; i <= end; i++)
#define FOR_DW(i, beg, end) for (int i = beg; end <= i; i--)
using namespace std;
int64_t gcd(int64_t a, int64_t b) {
if (a < b)
swap(a, b);
if (a % b == 0)
return b;
return gcd(b, a % b);
}
int64_t lcm(int64_t a, int64_t b) { return a * b / gcd(a, b); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(20);
int64_t n, m;
cin >> n >> m;
vector<int64_t> as(n);
for (auto &a : as) {
cin >> a;
}
int64_t lcm_v = 1;
FOR_LT(i, 0, n) {
lcm_v = lcm(lcm_v, as[i]);
if (m < lcm_v / 2) {
cout << 0 << endl;
return 0;
}
}
FOR_LT(i, 0, n) {
if (((lcm_v / as[i]) & 1) == 0) {
cout << 0 << endl;
return 0;
}
}
int64_t fv = lcm_v / 2;
if (m < fv) {
cout << 0 << endl;
} else {
cout << 1 + (m - fv) / (2 * fv) << endl;
}
return 0;
} | replace | 54 | 55 | 54 | 61 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define testcase() \
int t; \
cin >> t; \
while (t--)
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define vll vector<ll>
#define vi vector<int>
#define all(v) v.begin(), v.end()
ll M = 1e9 + 7;
double pi = acos(-1.0);
ll powerm(ll x, ll y) {
ll res = 1;
while (y) {
if (y & 1)
res = (res * x) % M;
y = y >> 1;
x = (x * x) % M;
}
return res % M;
}
ll power(ll x, ll y) {
ll res = 1;
while (y) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
ll gcd(ll a, ll b) {
if (b > a)
return gcd(b, a);
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
// ifstream cin("input.txt");
// ofstream cout("output.txt");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
ll m;
cin >> n >> m;
ll g = 1;
vll a(n);
bool ok = 1;
forn(i, n) {
cin >> a[i];
if (a[i] & 1)
ok = 0;
ll h = a[i] / 2;
g = (g * h) / gcd(g, h);
}
if (!ok) {
cout << 0;
return 0;
}
forn(i, n) {
ll h = g / (a[i] / 2);
if (~h & 1) {
ok = 0;
break;
}
}
if (!ok)
cout << 0;
else {
ll f = m / g;
cout << (f + 1) / 2;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define ff first
#define ss second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define testcase() \
int t; \
cin >> t; \
while (t--)
#define forn(i, n) for (int i = 0; i < n; i++)
#define forn1(i, n) for (int i = 1; i <= n; i++)
#define vll vector<ll>
#define vi vector<int>
#define all(v) v.begin(), v.end()
ll M = 1e9 + 7;
double pi = acos(-1.0);
ll powerm(ll x, ll y) {
ll res = 1;
while (y) {
if (y & 1)
res = (res * x) % M;
y = y >> 1;
x = (x * x) % M;
}
return res % M;
}
ll power(ll x, ll y) {
ll res = 1;
while (y) {
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
ll gcd(ll a, ll b) {
if (b > a)
return gcd(b, a);
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
// ifstream cin("input.txt");
// ofstream cout("output.txt");
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
ll m;
cin >> n >> m;
ll g = 1;
vll a(n);
bool ok = 1;
forn(i, n) {
cin >> a[i];
if (a[i] & 1)
ok = 0;
ll h = a[i] / 2;
if (g < 0) {
cout << 0;
return 0;
}
g = (g * h) / gcd(g, h);
}
if (!ok) {
cout << 0;
return 0;
}
forn(i, n) {
ll h = g / (a[i] / 2);
if (~h & 1) {
ok = 0;
break;
}
}
if (!ok)
cout << 0;
else {
ll f = m / g;
cout << (f + 1) / 2;
}
return 0;
}
| insert | 68 | 68 | 68 | 72 | TLE | |
p02814 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef uint64_t u64;
typedef int64_t s64;
typedef uint32_t u32;
typedef int32_t s32;
typedef vector<s32> vs32;
typedef vector<u32> vu32;
typedef vector<s64> vs64;
typedef vector<u64> vu64;
const double PI = 3.14159265358979323846;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
#define rep(i, N) for (int i = 0; i < N; ++i)
#define CEIL(x, y) (((x) + (y)-1) / (y))
#define MOD 1000000007ULL
s64 gcd(s64 x, s64 y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
s64 cmul(s64 x, s64 y) {
s64 g = gcd(x, y);
return x * y / g;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
s64 N, M;
cin >> N >> M;
vs64 A(N);
s64 g = 0;
rep(i, N) {
cin >> A[i];
A[i] /= 2;
g = gcd(A[i], g);
}
sort(A.begin(), A.end());
A.erase(unique(A.begin(), A.end()), A.end());
s64 d = 1;
rep(i, A.size()) {
d = cmul(d, A[i]);
if ((A[i] / g) % (s64)2 == 0) {
d = M + 1;
break;
}
}
s64 ans = (M + d) / ((s64)2 * d);
cout << ans << "\n";
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef uint64_t u64;
typedef int64_t s64;
typedef uint32_t u32;
typedef int32_t s32;
typedef vector<s32> vs32;
typedef vector<u32> vu32;
typedef vector<s64> vs64;
typedef vector<u64> vu64;
const double PI = 3.14159265358979323846;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
#define rep(i, N) for (int i = 0; i < N; ++i)
#define CEIL(x, y) (((x) + (y)-1) / (y))
#define MOD 1000000007ULL
s64 gcd(s64 x, s64 y) {
if (x < y)
swap(x, y);
if (y == 0)
return x;
return gcd(y, x % y);
}
s64 cmul(s64 x, s64 y) {
s64 g = gcd(x, y);
return x * y / g;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
s64 N, M;
cin >> N >> M;
vs64 A(N);
s64 g = 0;
rep(i, N) {
cin >> A[i];
A[i] /= 2;
g = gcd(A[i], g);
}
sort(A.begin(), A.end());
A.erase(unique(A.begin(), A.end()), A.end());
s64 d = 1;
rep(i, A.size()) {
d = cmul(d, A[i]);
if (d > M)
break;
if ((A[i] / g) % (s64)2 == 0) {
d = M + 1;
break;
}
}
s64 ans = (M + d) / ((s64)2 * d);
cout << ans << "\n";
return 0;
}
| insert | 69 | 69 | 69 | 71 | TLE | |
p02814 | C++ | Runtime Error | // In The Name Of Allah
#include <bits/stdc++.h>
#define ss second
#define ff first
#define use_fast ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define ret(n) return cout << n, 0
#define se(n) cout << setprecision(n) << fixed
#define pb push_back
#define ll long long
#define ld long double
using namespace std;
const int N = 2e5 + 1000, OO = 1e9 + 100, M = 1e9 + 7, P = 6151, SQ = 120,
lg = 100;
typedef pair<int, int> pii;
int a[N];
int32_t main() {
use_fast;
int n, m;
cin >> n >> m;
vector<int> v;
for (int i = 1; i <= n; i++) {
cin >> a[i];
int x = a[i];
int k = 0;
x /= 2;
while (x % 2 == 0) {
x /= 2;
k++;
}
v.pb(k);
}
sort(v.begin(), v.end());
if (v[(int)v.size() - 1] != v[0])
return cout << 0, 0;
int lc = 1;
for (int i = 1; i <= n; i++) {
a[i] /= 2;
int h = __gcd(a[i], lc);
lc = (lc * a[i]) / h;
}
m /= lc;
cout << (m + 1) / 2 << endl;
return 0;
}
/*
be carefull :
1- if not solve after 20 min, read again twice
2- after submit read the code again
3- fun with contest
4- ...
*/ | // In The Name Of Allah
#include <bits/stdc++.h>
#define ss second
#define ff first
#define use_fast ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define ret(n) return cout << n, 0
#define se(n) cout << setprecision(n) << fixed
#define pb push_back
#define int long long
#define ld long double
using namespace std;
const int N = 2e5 + 1000, OO = 1e9 + 100, M = 1e9 + 7, P = 6151, SQ = 120,
lg = 100;
typedef pair<int, int> pii;
int a[N];
int32_t main() {
use_fast;
int n, m;
cin >> n >> m;
vector<int> v;
for (int i = 1; i <= n; i++) {
cin >> a[i];
int x = a[i];
int k = 0;
x /= 2;
while (x % 2 == 0) {
x /= 2;
k++;
}
v.pb(k);
}
sort(v.begin(), v.end());
if (v[(int)v.size() - 1] != v[0])
return cout << 0, 0;
int lc = 1;
for (int i = 1; i <= n; i++) {
a[i] /= 2;
int h = __gcd(a[i], lc);
lc = (lc * a[i]) / h;
}
m /= lc;
cout << (m + 1) / 2 << endl;
return 0;
}
/*
be carefull :
1- if not solve after 20 min, read again twice
2- after submit read the code again
3- fun with contest
4- ...
*/ | replace | 8 | 9 | 8 | 9 | 0 | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int f(int x) {
int res = 0;
while (x % 2 == 0) {
x /= 2;
res++;
}
return res;
}
int main() {
ll N, M;
cin >> N >> M;
vector<int> a(N);
rep(i, N) cin >> a[i];
rep(i, N) {
if (a[i] % 2 == 1) {
cout << 0 << endl;
return 0;
}
a[i] /= 2;
}
int t = f(a[0]);
rep(i, N) {
if (f(a[i] != t)) {
cout << 0 << endl;
return 0;
}
a[i] >>= t; // 2でt回割る
}
M >>= t;
ll l = 1;
rep(i, N) {
l = lcm(l, a[i]);
if (l > M) {
cout << 0 << endl;
return 0;
}
}
M /= l;
int ans = (M + 1) / 2;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int f(int x) {
int res = 0;
while (x % 2 == 0) {
x /= 2;
res++;
}
return res;
}
int main() {
ll N, M;
cin >> N >> M;
vector<int> a(N);
rep(i, N) cin >> a[i];
rep(i, N) {
if (a[i] % 2 == 1) {
cout << 0 << endl;
return 0;
}
a[i] /= 2;
}
int t = f(a[0]);
rep(i, N) {
if (f(a[i]) != t) {
cout << 0 << endl;
return 0;
}
a[i] >>= t; // 2でt回割る
}
M >>= t;
ll l = 1;
rep(i, N) {
l = lcm(l, a[i]);
if (l > M) {
cout << 0 << endl;
return 0;
}
}
M /= l;
int ans = (M + 1) / 2;
cout << ans << endl;
return 0;
}
| replace | 37 | 38 | 37 | 38 | 0 | |
p02814 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int Max = 1000000;
long gcd(long a, long b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
long lcm(int c, int d) { return c * d / gcd(c, d); }
int main() {
long N;
long M;
cin >> N >> M;
long a;
long b[N];
for (long i = 0; i < N; i++) {
cin >> a;
b[i] = a / 2;
}
long r = 1;
while (b[0] % 2 == 0) {
r *= 2;
b[0] /= 2;
}
for (long i = 1; i < N; i++) {
if ((b[i] % r) != 0) {
cout << 0 << endl;
return 0;
}
b[i] /= r;
if (b[i] % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
long l = b[0];
for (long i = 1; i < N; i++) {
l = lcm(l, b[i]);
}
cout << (M / (l * r) + 1) / 2 << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int Max = 1000000;
long gcd(long a, long b) {
if (a == 0)
return b;
else
return gcd(b % a, a);
}
long lcm(long c, long d) { return c * d / gcd(c, d); }
int main() {
long N;
long M;
cin >> N >> M;
long a;
long b[N];
for (long i = 0; i < N; i++) {
cin >> a;
b[i] = a / 2;
}
long r = 1;
while (b[0] % 2 == 0) {
r *= 2;
b[0] /= 2;
}
for (long i = 1; i < N; i++) {
if ((b[i] % r) != 0) {
cout << 0 << endl;
return 0;
}
b[i] /= r;
if (b[i] % 2 == 0) {
cout << 0 << endl;
return 0;
}
}
long l = b[0];
for (long i = 1; i < N; i++) {
l = lcm(l, b[i]);
}
cout << (M / (l * r) + 1) / 2 << endl;
return 0;
}
| replace | 16 | 17 | 16 | 17 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
typedef long long ll;
typedef pair<int, int> pii;
#define mp make_pair
#define fst first
#define snd second
#define fr(i, a, b) for (int i = a; i < b; i++)
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int ok(V<ll> &d, ll t) {
for (int i = 0; i < d.size(); i++) {
if ((t - d[i] / 2) % d[i])
return 0;
}
return 1;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
ll t = 1;
ll ma = 0;
V<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
t = (t * a[i]) / gcd(t, a[i]);
ma = max(ma, a[i]);
}
ll s = ma / 2;
while (!ok(a, s)) {
s++;
if (s > m)
break;
}
if (s > m)
cout << 0 << endl;
else {
cout << 1 + (m - s) / t << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
typedef long long ll;
typedef pair<int, int> pii;
#define mp make_pair
#define fst first
#define snd second
#define fr(i, a, b) for (int i = a; i < b; i++)
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int ok(V<ll> &d, ll t) {
for (int i = 0; i < d.size(); i++) {
if ((t - d[i] / 2) % d[i])
return 0;
}
return 1;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
ll t = 1;
ll ma = 0;
V<ll> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
t = (t * a[i]) / gcd(t, a[i]);
ma = max(ma, a[i]);
}
ll s = ma / 2;
while (!ok(a, s)) {
s += ma;
if (s > m)
break;
}
if (s > m)
cout << 0 << endl;
else {
cout << 1 + (m - s) / t << endl;
}
}
| replace | 112 | 113 | 112 | 113 | TLE | |
p02814 | Python | Time Limit Exceeded | from sys import stdin
import fractions
N, M = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) // 2 for x in stdin.readline().rstrip().split()]
ans = 0
g = 1
for i in range(len(A)):
g = g * A[i] // fractions.gcd(g % A[i], A[i])
for i in range(len(A)):
if (g // A[i]) % 2 == 0:
print(0)
exit()
ans = M // g
if ans % 2 == 0:
print(ans // 2)
else:
print((ans + 1) // 2)
| from sys import stdin
import fractions
N, M = [int(x) for x in stdin.readline().rstrip().split()]
A = [int(x) // 2 for x in stdin.readline().rstrip().split()]
ans = 0
g = 1
for i in range(len(A)):
g = g * A[i] // fractions.gcd(g % A[i], A[i])
if g > M:
print(0)
exit()
for i in range(len(A)):
if (g // A[i]) % 2 == 0:
print(0)
exit()
ans = M // g
if ans % 2 == 0:
print(ans // 2)
else:
print((ans + 1) // 2)
| insert | 10 | 10 | 10 | 13 | TLE | |
p02814 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define repm(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define pb(n) push_back(n)
#define mp make_pair
#define MOD 1000000007
#define INF LONG_LONG_MAX
int n, m, a[100000], x = 1, M;
signed main() {
cin >> n >> m;
rep(i, n) {
cin >> a[i];
M = max(M, a[i]);
x = a[i] * x / __gcd(a[i], x);
if (x > 3000000000)
x = 0;
}
if (x % 2) {
cout << 0 << endl;
return 0;
}
x /= 2;
cout << (m / x + 1) / 2 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define rep11(i, n) for (int i = 1; i < (int)(n); ++i)
#define repo(i, o, n) for (int i = o; i < (int)(n); ++i)
#define repm(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define pb(n) push_back(n)
#define mp make_pair
#define MOD 1000000007
#define INF LONG_LONG_MAX
int n, m, a[100000], x = 1, M;
signed main() {
cin >> n >> m;
rep(i, n) {
cin >> a[i];
M = max(M, a[i]);
x = a[i] * x / __gcd(a[i], x);
if (x > 3000000000)
x = 0;
}
if (x % 2) {
cout << 0 << endl;
return 0;
}
x /= 2;
bool f = true;
rep(i, n) {
if ((double)x / a[i] - (int)(x / a[i]) != 0.5)
f = false;
}
if (f)
cout << (m / x + 1) / 2 << endl;
else
cout << 0 << endl;
}
| replace | 34 | 35 | 34 | 43 | 0 | |
p02814 | Python | Runtime Error | import sys
from math import gcd
from functools import reduce
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
def lcm(x, y):
return x * y // gcd(x, y)
def main():
N, M, *A = map(int, read().split())
A = [a // 2 for a in A]
semi_lcm = reduce(lcm, A)
for a in A[1:]:
semi_lcm = lcm(semi_lcm, a)
if semi_lcm > M or semi_lcm // a % 2 == 0:
print(0)
return
print((M // semi_lcm + 1) // 2)
return
if __name__ == "__main__":
main()
| import sys
from fractions import gcd
from functools import reduce
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
def lcm(x, y):
return x * y // gcd(x, y)
def main():
N, M, *A = map(int, read().split())
A = [a // 2 for a in A]
semi_lcm = reduce(lcm, A)
for a in A[1:]:
semi_lcm = lcm(semi_lcm, a)
if semi_lcm > M or semi_lcm // a % 2 == 0:
print(0)
return
print((M // semi_lcm + 1) // 2)
return
if __name__ == "__main__":
main()
| replace | 1 | 2 | 1 | 2 | 0 | |
p02814 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL << 60;
const long long int Mod = 1000000007;
using ll = long long int;
using ci = const int;
using vi = vector<int>;
using Vi = vector<long long int>;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define all(x) (x).begin(), (x).end()
#define rep(i, N) for (ll i = 0; i < (ll)N; i++)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
template <class T> bool chmax(T &former, const T &b) {
if (former < b) {
former = b;
return true;
}
return false;
}
template <class T> bool chmin(T &former, const T &b) {
if (b < former) {
former = b;
return true;
}
return false;
}
template <class T> T sqar(T x) { return x * x; } // sqrt(x)は平方根;
#define Sort(v) \
std::sort(v.begin(), v.end(), \
std::greater<decltype(v[0])>()) // 降順でVをソート
template <class T> inline void princ(T x) { cout << x << " "; };
template <class T> inline void print(T x) { cout << x << "\n"; };
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
///////////////////////////////////////////////////////////////////////////////////
ll n, m;
Vi aa;
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// std::cout<<std::fixed<<std::setprecision(30);
cin >> n >> m;
// rep(i,10000)rep(j,10000)dp[i][j]=0;
// memset(dp,0,sizeof(dp));
aa.resize(n);
rep(i, n) cin >> aa[i];
ll tmp = 1;
bool flg = true;
rep(i, n) {
tmp = lcm(tmp, aa[i] / 2);
if ((tmp * 2 / aa[i]) % 2 == 0) {
flg = false;
break;
}
}
ll ans = m / tmp;
if (!flg) {
print(0);
} else if (ans % 2 == 1) {
print((ans - 1) / 2 + 1);
} else {
print(ans / 2);
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
///////////////////////////////////////////
const long long int INF = 1LL << 60;
const long long int Mod = 1000000007;
using ll = long long int;
using ci = const int;
using vi = vector<int>;
using Vi = vector<long long int>;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;
#define pb(x) push_back(x)
#define mp(x, y) make_pair(x, y)
#define all(x) (x).begin(), (x).end()
#define rep(i, N) for (ll i = 0; i < (ll)N; i++)
#define repi(i, a, b) for (ll i = ll(a); i < ll(b); ++i)
template <class T> bool chmax(T &former, const T &b) {
if (former < b) {
former = b;
return true;
}
return false;
}
template <class T> bool chmin(T &former, const T &b) {
if (b < former) {
former = b;
return true;
}
return false;
}
template <class T> T sqar(T x) { return x * x; } // sqrt(x)は平方根;
#define Sort(v) \
std::sort(v.begin(), v.end(), \
std::greater<decltype(v[0])>()) // 降順でVをソート
template <class T> inline void princ(T x) { cout << x << " "; };
template <class T> inline void print(T x) { cout << x << "\n"; };
template <class T> inline void Yes(T condition) {
if (condition)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
template <class T> inline void YES(T condition) {
if (condition)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
///////////////////////////////////////////////////////////////////////////////////
ll n, m;
Vi aa;
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
return b ? gcd(b, a % b) : a;
}
ll lcm(ll a, ll b) { return a * b / __gcd(a, b); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// std::cout<<std::fixed<<std::setprecision(30);
cin >> n >> m;
// rep(i,10000)rep(j,10000)dp[i][j]=0;
// memset(dp,0,sizeof(dp));
aa.resize(n);
rep(i, n) cin >> aa[i];
ll tmp = 1;
bool flg = true;
rep(i, n) {
tmp = lcm(tmp, aa[i] / 2);
if ((tmp * 2 / aa[i]) % 2 == 0) {
flg = false;
break;
}
}
ll ans = m / tmp;
if (!flg) {
print(0);
} else if (ans % 2 == 1) {
print((ans - 1) / 2 + 1);
} else {
print(ans / 2);
}
return 0;
} | replace | 59 | 60 | 59 | 60 | TLE | |
p02815 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; i++)
#define Rep(i, m, n) for (long long i = m; i < n; i++)
#define REP(i, m, n, p) for (long long i = m; i < n; i += p)
#define all(v) v.begin(), v.end()
#define pq priority_queue
#define bcnt(n) __builtin_popcountll(n)
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
using vvvi = vector<vvi>;
using ll = long long; // long longをllだけにした
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using mii = map<int, int>;
using pqll = priority_queue<long long>;
using pqllg = priority_queue<long long, vector<long long>, greater<long long>>;
using mll = map<long long, long long>;
using pll = pair<long long, long long>;
using sll = set<long long>;
using vpll = vector<pair<long long, long long>>;
using mlv = map<long long, vector<long long>>;
long long divup(long long a, long long b);
long long kaijou(long long i);
long long P(long long n, long long k);
long long C(long long n, long long k);
long long GCD(long long a, long long b);
long long LCM(long long a, long long b);
bool prime(long long N);
double distance(vector<long long> p, vector<long long> q, long long n);
void press(vector<long long> &v);
void ranking(vector<long long> &v);
void erase(vector<long long> &v, long long i);
void unique(vector<long long> &v);
void printv(vector<long long> v);
vector<ll> keta(ll x);
long long modpow(long long a, long long n, long long mod);
long long modinv(long long a, long long mod);
// 20200416
vector<long long> inputv(long long n);
// 20200417
vector<long long> yakusuu(int n);
map<long long, long long> soinsuu(long long n);
vector<vector<long long>> maze(long long i, long long j, vector<string> &s);
// 20200423
vector<long long> eratos(long long n);
set<long long> eraset(long long n);
//////////////////////////////////////////////////////
// 端数繰りあがり割り算(検証済)
// a÷bの端数繰り上げ
// b!=0のデバグはしてないので分母に0を入れないように
// 負数対応
long long divup(long long a, long long b) {
long long x = abs(a);
long long y = abs(b);
long long z = (x + y - 1) / y;
if ((a < 0 && b > 0) || (a > 0 && b < 0))
return -z;
else if (a == 0)
return 0;
else
return z;
}
// 階乗
// 検証済み
long long kaijou(long long i) {
if (i == 0)
return 1;
long long j = 1;
for (long long k = 1; k <= i; k++) {
j *= k;
}
return j;
}
// 順列nPk(完成)
// n個の異なる要素から、取り出す順序を区別してk個取り出す場合の数
// n<kなら0を返す
// 敢えて負数時のデバグはしてない
long long P(long long n, long long k) {
if (n < k)
return 0;
long long y = 1;
for (long long i = 0; i < k; i++) {
y *= (n - i);
}
return y;
}
// 組み合わせnCk(検証済み)
// P,kaijouと併用
long long C(long long n, long long k) {
if (n < k)
return 0;
return P(n, k) / kaijou(k);
}
// nHk
// 区別しないn個の要素を、区別するk個のグループに分ける
// 0個のグループがあっ
// て良い
// C必須
// 最大公約数GCD,最小公倍数LCM
// LCMを使うときはGCDをセットで
// 検証済み
long long GCD(long long a, long long b) {
if (a < b)
swap(a, b);
long long d = a % b;
if (d == 0) {
return b;
}
return GCD(b, d);
}
long long LCM(long long a, long long b) { return (a / GCD(a, b)) * b; }
// 素数判定
// 素数ならばtrue、素数以外の整数にはfalse
// 負数は全てfalse
// 検証済み
bool prime(long long N) {
if (N == 1) {
return false;
}
if (N < 0)
return false;
long long p = sqrt(N);
for (long long i = 2; i <= p; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
// ユークリッド距離
// 検証済み
// 位置ベクトル1,位置ベクトル2,ベクトルの次元(2または3が一般的)
double distance(vector<long long> p, vector<long long> q, long long n) {
double x = 0;
for (long long i = 0; i < n; i++) {
x += pow((p.at(i) - q.at(i)), 2);
}
return sqrt(x);
}
// 配列圧縮(検証済)
//{1,36,1,3,8,-2,-92}を
//{2, 5,2,3,4, 1, 0}にする
void press(vector<long long> &v) {
long long n = v.size();
vector<long long> w(n);
map<long long, long long> m;
for (auto &p : v) {
m[p] = 0;
}
long long i = 0;
for (auto &p : m) {
p.second = i;
i++;
}
for (long long i = 0; i < n; i++) {
w.at(i) = m[v.at(i)];
}
v = w;
return;
}
// 配列のi番目の要素がj番目に小さいとき、j番目の数がiであるベクトルを返す関数
// 配列の要素が全て異なるときにしか正常に動作しない
// 配列の要素に同じものが含まれても見かけ上動作はするが意味のない値を戻し、
// エラーも起きないので注意
// 検証済
//{2,4,1,6,0,3,8,9,5}を
//{4,2,0,5,1,8,3,6,7}にして返す
//"rank"という名前にするとSTLの関数(配列の次元を返す関数)になるので注意
void ranking(vector<long long> &v) {
long long n = v.size();
map<long long, long long> m;
long long i;
for (i = 0; i < n; i++) {
m[v.at(i)] = i;
}
vector<long long> w(n);
i = 0;
for (auto &p : m) {
v.at(i) = p.second;
i++;
}
return;
}
// 部分削除(未検証)
// ベクトルのi番目(i=0,1,2,...,n-1)の要素を削除し、
// 以降の要素を全て前に1ずらして参照返し
// ベクトル長は1小さくなって返る
// i>n-1の時は変化しない
void erase(vector<long long> &v, long long i) {
long long n = v.size();
if (i > n - 1)
return;
for (long long j = i; j < n - 1; j++) {
v.at(j) = v.at(j + 1);
}
v.pop_back();
return;
}
// 重複削除(未完成)
// 引数ベクトルに同一要素が複数あるとき、先頭を残し他は削除
// 参照返し
// ベクトル長も変化する
// O(logn)くらい
void unique(vector<long long> &v) {
long long n = v.size();
set<long long> s;
long long i = 0;
while (i < n) {
if (s.count(v.at(i))) {
erase(v, i);
n--;
} else {
s.insert(v.at(i));
i++;
}
}
return;
}
// ベクトルの出力(検証済)
// debug用にvectorの中身を出力する
void printv(vector<long long> v) {
cout << "{ ";
for (auto &p : v) {
cout << p << ",";
}
cout << "}" << endl;
}
// 10進法でn桁の整数xに対して、大きい方の位から、その位の1桁の数字を
// 収納した長さnのベクトルを返す
// 0に対しては{0}を返す
// 検証済み
vector<ll> keta(ll x) {
if (x == 0)
return {0};
ll n = log10(x) + 1; // xの桁数
vll w(n, 0);
for (ll i = 0; i < n; i++) {
ll p;
p = x % 10;
x = x / 10;
w[n - 1 - i] = p;
}
return w;
}
// 20200415
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// a^{-1} mod を計算する
// modとaが互いに素のときのみ有効(数学的に逆元が一意に定まるのがそのときのみ)
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
// 整数n個の入力を受け取ってベクトルに突っ込んで返す
// チェック済み
vector<long long> inputv(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
vector<long long> yakusuu(long long n) // nの約数を列挙
{
vector<long long> ret;
for (long long i = 1; i <= sqrt(n); ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
sort(ret.begin(), ret.end());
return ret;
}
map<long long, long long> soinsuu(long long n) {
map<long long, long long> m;
long long p = sqrt(n);
while (n % 2 == 0) {
n /= 2;
if (m.count(2)) {
m[2]++;
} else {
m[2] = 1;
}
}
for (long long i = 3; i * i <= n; i += 2) {
while (n % i == 0) {
n /= i;
if (m.count(i)) {
m[i]++;
} else {
m[i] = 1;
}
}
}
if (n != 1)
m[n] = 1;
return m;
}
// スタートが(i,j)の迷路の全ての地点までの距離を幅優先探索で解く
// スタートから何マス離れているか(辿り着けない場合は-1)を入れたベクトルを返す
// 壁からスタートしても正常に動作するので注意(この関数の外で処理が必要)
// 検証済み 一応O(地図の広さ)くらい
vector<vector<long long>> maze(ll i, ll j, vector<string> &s) {
ll h = s.size();
ll w = s[0].size();
queue<vector<long long>> q;
vector<vector<long long>> dis(h, vll(w, -1));
q.push({i, j});
dis[i][j] = 0;
while (!q.empty()) {
auto v = q.front();
q.pop();
if (v[0] > 0 && s[v[0] - 1][v[1]] == '.' && dis[v[0] - 1][v[1]] == -1) {
dis[v[0] - 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] - 1, v[1]});
}
if (v[1] > 0 && s[v[0]][v[1] - 1] == '.' && dis[v[0]][v[1] - 1] == -1) {
dis[v[0]][v[1] - 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] - 1});
}
if (v[0] < h - 1 && s[v[0] + 1][v[1]] == '.' && dis[v[0] + 1][v[1]] == -1) {
dis[v[0] + 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] + 1, v[1]});
}
if (v[1] < w - 1 && s[v[0]][v[1] + 1] == '.' && dis[v[0]][v[1] + 1] == -1) {
dis[v[0]][v[1] + 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] + 1});
}
}
return dis; // スタートから何マス離れているか(辿り着けない場合は-1)
}
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
// vector<long long> eratos(long long n){
// }
// 二項係数の剰余を求める
// 引数は剰余の形ではなくもとの数そのものである
// 未検証(検証サンプルがない)
long long modC(long long n, long long k, long long mod) {
if (n < k)
return 0;
long long p = 1, q = 1;
for (long long i = 0; i < k; i++) {
p = p * (n - i) % mod;
q = q * (i + 1) % mod;
}
return p * modinv(q, mod) % mod;
}
// 20200418
// 整数のとき限定の普通のPOW関数
// 標準機能のpow(a,n)は整数だとバグるのでこちらを使う
long long POW(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a;
a = a * a;
n >>= 1;
}
return res;
}
// 20200423
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
vector<long long> eratos(long long n) {
if (n < 2)
return {};
vll v(n - 1);
rep(i, n - 1) {
v[i] = i + 2; // 2からnまで
}
ll i = 0;
while (i < n - 1) {
ll p = v[i];
for (ll j = i + 1; j < n - 1; j++) {
if (v[j] % p == 0) {
v.erase(v.begin() + j);
n--;
}
}
i++;
}
v.resize(n - 1);
return v;
}
// n以下の素数を全て詰めたset
set<long long> eraset(long long n) {
set<long long> s;
vll v = eratos(n);
for (auto &t : v) {
s.insert(t);
}
return s;
}
// 20200428
//(x1,y1),(x2,y2)を通る直線をax+by+c=0としたとき
//{a,b,c}を返す
vll line(ll x1, ll y1, ll x2, ll y2) {
vector<ll> v(3);
v[0] = y1 - y2;
v[1] = x2 - x1;
v[2] = -x1 * (y1 - y2) + y1 * (x1 - x2);
return v;
}
//(x,y)とv[0]x+v[1]y+v[2]=0との距離
double dis(vll v, ll x, ll y) {
double s = sqrt(v[0] * v[0] + v[1] * v[1]);
return (double)abs(v[0] * x + v[1] * y + v[2]) / s;
}
// 20200502
void maxin(ll &a, ll b) {
a = max(a, b);
return;
}
void minin(ll &a, ll b) {
a = min(a, b);
return;
}
// 20200506
map<long long, long long> countv(vll v) {
map<long long, long long> m;
for (auto &g : v) {
if (m.count(g))
m[g]++;
else
m[g] = 1;
}
return m;
}
// nCk modを求める
const ll MAX = 510000;
const ll MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void cominit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long commod(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// 順列計算
long long pmod(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[n - k] % MOD;
}
/* next combination */
// 次の組み合わせをbitで返す
// 全探索のloopに使える
long long next_combination(long long sub) {
long long x = sub & -sub, y = sub + x;
return (((sub & ~y) / x) >> 1) | y;
}
//////////////////////////////////////////
struct UF { // サイズが測れるUF
vector<long long> par, size; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
// sizeはiを根とする木のサイズ
UF(long long N) : par(N), size(N) { // 最初は全てが根であるとして初期化
for (long long i = 0; i < N; i++) {
par[i] = i;
size[i] = 1;
}
}
long long root(
long long x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(long long x, long long y) { // xとyの木を併合
long long rx = root(x); // xの根をrx
long long ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
size[ry] += size[rx];
size[rx] = 0; // サイズの処理 根じゃなくなったらサイズは0になる
}
bool same(long long x,
long long y) { // 2つのデータx, yが属する木が同じならtrueを返す
long long rx = root(x);
long long ry = root(y);
return rx == ry;
}
};
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// int mod=17;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
void debug(ll &a) { cout << a << endl; }
void debug(vll &a) {
cout << "debug vector" << endl;
cout << "{ ";
for (auto t : a) {
cout << t << ",";
}
cout << " }" << endl;
cout << "debug finished" << endl;
}
void debug(set<long long> &a) {
cout << "debug set" << endl;
for (auto t : a) {
cout << t << endl;
}
cout << "debug finished" << endl;
}
void debug(map<long long, long long> a) {
cout << "debug map" << endl;
for (auto t : a) {
cout << t.first << " " << t.second << endl;
}
cout << "debug finished" << endl;
}
void debug(queue<long long> a) {
cout << "debug queue" << endl;
while (!a.empty()) {
ll t = a.front();
a.pop();
cout << t << endl;
}
cout << "debug finished" << endl;
}
//////////////////////////////////////////////
// ll const mod=1e9+7;
ll const dekai = 99999999977; // 1e11-23.素数.
ll dx[4] = {-1, 0, 1, 0};
ll dy[4] = {0, -1, 0, 1};
ll ddx[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
ll ddy[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
// cout<<fixed<<setprecision(10);
#define ednl endl
#define endk endl
//////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
auto c = inputv(n);
sort(all(c));
cominit();
ll ans = (0);
rep(i, n) {
ll k = (0);
Rep(j, 1, n - i + 1) {
k += commod(n - 1 - i, j - 1) * j % mod * modpow(2, i, mod) % mod;
k %= mod;
}
ans += k * c[i] % mod;
ans %= mod;
}
// ans -= 4535;
ans *= modpow(2, n, mod);
ans %= mod;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < n; i++)
#define Rep(i, m, n) for (long long i = m; i < n; i++)
#define REP(i, m, n, p) for (long long i = m; i < n; i += p)
#define all(v) v.begin(), v.end()
#define pq priority_queue
#define bcnt(n) __builtin_popcountll(n)
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける
using vvvi = vector<vvi>;
using ll = long long; // long longをllだけにした
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vb = vector<bool>;
using vvb = vector<vb>;
using mii = map<int, int>;
using pqll = priority_queue<long long>;
using pqllg = priority_queue<long long, vector<long long>, greater<long long>>;
using mll = map<long long, long long>;
using pll = pair<long long, long long>;
using sll = set<long long>;
using vpll = vector<pair<long long, long long>>;
using mlv = map<long long, vector<long long>>;
long long divup(long long a, long long b);
long long kaijou(long long i);
long long P(long long n, long long k);
long long C(long long n, long long k);
long long GCD(long long a, long long b);
long long LCM(long long a, long long b);
bool prime(long long N);
double distance(vector<long long> p, vector<long long> q, long long n);
void press(vector<long long> &v);
void ranking(vector<long long> &v);
void erase(vector<long long> &v, long long i);
void unique(vector<long long> &v);
void printv(vector<long long> v);
vector<ll> keta(ll x);
long long modpow(long long a, long long n, long long mod);
long long modinv(long long a, long long mod);
// 20200416
vector<long long> inputv(long long n);
// 20200417
vector<long long> yakusuu(int n);
map<long long, long long> soinsuu(long long n);
vector<vector<long long>> maze(long long i, long long j, vector<string> &s);
// 20200423
vector<long long> eratos(long long n);
set<long long> eraset(long long n);
//////////////////////////////////////////////////////
// 端数繰りあがり割り算(検証済)
// a÷bの端数繰り上げ
// b!=0のデバグはしてないので分母に0を入れないように
// 負数対応
long long divup(long long a, long long b) {
long long x = abs(a);
long long y = abs(b);
long long z = (x + y - 1) / y;
if ((a < 0 && b > 0) || (a > 0 && b < 0))
return -z;
else if (a == 0)
return 0;
else
return z;
}
// 階乗
// 検証済み
long long kaijou(long long i) {
if (i == 0)
return 1;
long long j = 1;
for (long long k = 1; k <= i; k++) {
j *= k;
}
return j;
}
// 順列nPk(完成)
// n個の異なる要素から、取り出す順序を区別してk個取り出す場合の数
// n<kなら0を返す
// 敢えて負数時のデバグはしてない
long long P(long long n, long long k) {
if (n < k)
return 0;
long long y = 1;
for (long long i = 0; i < k; i++) {
y *= (n - i);
}
return y;
}
// 組み合わせnCk(検証済み)
// P,kaijouと併用
long long C(long long n, long long k) {
if (n < k)
return 0;
return P(n, k) / kaijou(k);
}
// nHk
// 区別しないn個の要素を、区別するk個のグループに分ける
// 0個のグループがあっ
// て良い
// C必須
// 最大公約数GCD,最小公倍数LCM
// LCMを使うときはGCDをセットで
// 検証済み
long long GCD(long long a, long long b) {
if (a < b)
swap(a, b);
long long d = a % b;
if (d == 0) {
return b;
}
return GCD(b, d);
}
long long LCM(long long a, long long b) { return (a / GCD(a, b)) * b; }
// 素数判定
// 素数ならばtrue、素数以外の整数にはfalse
// 負数は全てfalse
// 検証済み
bool prime(long long N) {
if (N == 1) {
return false;
}
if (N < 0)
return false;
long long p = sqrt(N);
for (long long i = 2; i <= p; i++) {
if (N % i == 0) {
return false;
}
}
return true;
}
// ユークリッド距離
// 検証済み
// 位置ベクトル1,位置ベクトル2,ベクトルの次元(2または3が一般的)
double distance(vector<long long> p, vector<long long> q, long long n) {
double x = 0;
for (long long i = 0; i < n; i++) {
x += pow((p.at(i) - q.at(i)), 2);
}
return sqrt(x);
}
// 配列圧縮(検証済)
//{1,36,1,3,8,-2,-92}を
//{2, 5,2,3,4, 1, 0}にする
void press(vector<long long> &v) {
long long n = v.size();
vector<long long> w(n);
map<long long, long long> m;
for (auto &p : v) {
m[p] = 0;
}
long long i = 0;
for (auto &p : m) {
p.second = i;
i++;
}
for (long long i = 0; i < n; i++) {
w.at(i) = m[v.at(i)];
}
v = w;
return;
}
// 配列のi番目の要素がj番目に小さいとき、j番目の数がiであるベクトルを返す関数
// 配列の要素が全て異なるときにしか正常に動作しない
// 配列の要素に同じものが含まれても見かけ上動作はするが意味のない値を戻し、
// エラーも起きないので注意
// 検証済
//{2,4,1,6,0,3,8,9,5}を
//{4,2,0,5,1,8,3,6,7}にして返す
//"rank"という名前にするとSTLの関数(配列の次元を返す関数)になるので注意
void ranking(vector<long long> &v) {
long long n = v.size();
map<long long, long long> m;
long long i;
for (i = 0; i < n; i++) {
m[v.at(i)] = i;
}
vector<long long> w(n);
i = 0;
for (auto &p : m) {
v.at(i) = p.second;
i++;
}
return;
}
// 部分削除(未検証)
// ベクトルのi番目(i=0,1,2,...,n-1)の要素を削除し、
// 以降の要素を全て前に1ずらして参照返し
// ベクトル長は1小さくなって返る
// i>n-1の時は変化しない
void erase(vector<long long> &v, long long i) {
long long n = v.size();
if (i > n - 1)
return;
for (long long j = i; j < n - 1; j++) {
v.at(j) = v.at(j + 1);
}
v.pop_back();
return;
}
// 重複削除(未完成)
// 引数ベクトルに同一要素が複数あるとき、先頭を残し他は削除
// 参照返し
// ベクトル長も変化する
// O(logn)くらい
void unique(vector<long long> &v) {
long long n = v.size();
set<long long> s;
long long i = 0;
while (i < n) {
if (s.count(v.at(i))) {
erase(v, i);
n--;
} else {
s.insert(v.at(i));
i++;
}
}
return;
}
// ベクトルの出力(検証済)
// debug用にvectorの中身を出力する
void printv(vector<long long> v) {
cout << "{ ";
for (auto &p : v) {
cout << p << ",";
}
cout << "}" << endl;
}
// 10進法でn桁の整数xに対して、大きい方の位から、その位の1桁の数字を
// 収納した長さnのベクトルを返す
// 0に対しては{0}を返す
// 検証済み
vector<ll> keta(ll x) {
if (x == 0)
return {0};
ll n = log10(x) + 1; // xの桁数
vll w(n, 0);
for (ll i = 0; i < n; i++) {
ll p;
p = x % 10;
x = x / 10;
w[n - 1 - i] = p;
}
return w;
}
// 20200415
// a^n mod を計算する
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
// a^{-1} mod を計算する
// modとaが互いに素のときのみ有効(数学的に逆元が一意に定まるのがそのときのみ)
long long modinv(long long a, long long mod) { return modpow(a, mod - 2, mod); }
// 整数n個の入力を受け取ってベクトルに突っ込んで返す
// チェック済み
vector<long long> inputv(long long n) {
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
return v;
}
vector<long long> yakusuu(long long n) // nの約数を列挙
{
vector<long long> ret;
for (long long i = 1; i <= sqrt(n); ++i) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) {
ret.push_back(n / i);
}
}
}
sort(ret.begin(), ret.end());
return ret;
}
map<long long, long long> soinsuu(long long n) {
map<long long, long long> m;
long long p = sqrt(n);
while (n % 2 == 0) {
n /= 2;
if (m.count(2)) {
m[2]++;
} else {
m[2] = 1;
}
}
for (long long i = 3; i * i <= n; i += 2) {
while (n % i == 0) {
n /= i;
if (m.count(i)) {
m[i]++;
} else {
m[i] = 1;
}
}
}
if (n != 1)
m[n] = 1;
return m;
}
// スタートが(i,j)の迷路の全ての地点までの距離を幅優先探索で解く
// スタートから何マス離れているか(辿り着けない場合は-1)を入れたベクトルを返す
// 壁からスタートしても正常に動作するので注意(この関数の外で処理が必要)
// 検証済み 一応O(地図の広さ)くらい
vector<vector<long long>> maze(ll i, ll j, vector<string> &s) {
ll h = s.size();
ll w = s[0].size();
queue<vector<long long>> q;
vector<vector<long long>> dis(h, vll(w, -1));
q.push({i, j});
dis[i][j] = 0;
while (!q.empty()) {
auto v = q.front();
q.pop();
if (v[0] > 0 && s[v[0] - 1][v[1]] == '.' && dis[v[0] - 1][v[1]] == -1) {
dis[v[0] - 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] - 1, v[1]});
}
if (v[1] > 0 && s[v[0]][v[1] - 1] == '.' && dis[v[0]][v[1] - 1] == -1) {
dis[v[0]][v[1] - 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] - 1});
}
if (v[0] < h - 1 && s[v[0] + 1][v[1]] == '.' && dis[v[0] + 1][v[1]] == -1) {
dis[v[0] + 1][v[1]] = dis[v[0]][v[1]] + 1;
q.push({v[0] + 1, v[1]});
}
if (v[1] < w - 1 && s[v[0]][v[1] + 1] == '.' && dis[v[0]][v[1] + 1] == -1) {
dis[v[0]][v[1] + 1] = dis[v[0]][v[1]] + 1;
q.push({v[0], v[1] + 1});
}
}
return dis; // スタートから何マス離れているか(辿り着けない場合は-1)
}
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
// vector<long long> eratos(long long n){
// }
// 二項係数の剰余を求める
// 引数は剰余の形ではなくもとの数そのものである
// 未検証(検証サンプルがない)
long long modC(long long n, long long k, long long mod) {
if (n < k)
return 0;
long long p = 1, q = 1;
for (long long i = 0; i < k; i++) {
p = p * (n - i) % mod;
q = q * (i + 1) % mod;
}
return p * modinv(q, mod) % mod;
}
// 20200418
// 整数のとき限定の普通のPOW関数
// 標準機能のpow(a,n)は整数だとバグるのでこちらを使う
long long POW(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a;
a = a * a;
n >>= 1;
}
return res;
}
// 20200423
// エラトステネスのふるいによりn以下の素数を全てベクトルに入れて返す
vector<long long> eratos(long long n) {
if (n < 2)
return {};
vll v(n - 1);
rep(i, n - 1) {
v[i] = i + 2; // 2からnまで
}
ll i = 0;
while (i < n - 1) {
ll p = v[i];
for (ll j = i + 1; j < n - 1; j++) {
if (v[j] % p == 0) {
v.erase(v.begin() + j);
n--;
}
}
i++;
}
v.resize(n - 1);
return v;
}
// n以下の素数を全て詰めたset
set<long long> eraset(long long n) {
set<long long> s;
vll v = eratos(n);
for (auto &t : v) {
s.insert(t);
}
return s;
}
// 20200428
//(x1,y1),(x2,y2)を通る直線をax+by+c=0としたとき
//{a,b,c}を返す
vll line(ll x1, ll y1, ll x2, ll y2) {
vector<ll> v(3);
v[0] = y1 - y2;
v[1] = x2 - x1;
v[2] = -x1 * (y1 - y2) + y1 * (x1 - x2);
return v;
}
//(x,y)とv[0]x+v[1]y+v[2]=0との距離
double dis(vll v, ll x, ll y) {
double s = sqrt(v[0] * v[0] + v[1] * v[1]);
return (double)abs(v[0] * x + v[1] * y + v[2]) / s;
}
// 20200502
void maxin(ll &a, ll b) {
a = max(a, b);
return;
}
void minin(ll &a, ll b) {
a = min(a, b);
return;
}
// 20200506
map<long long, long long> countv(vll v) {
map<long long, long long> m;
for (auto &g : v) {
if (m.count(g))
m[g]++;
else
m[g] = 1;
}
return m;
}
// nCk modを求める
const ll MAX = 510000;
const ll MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void cominit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
long long commod(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
// 順列計算
long long pmod(ll n, ll k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * finv[n - k] % MOD;
}
/* next combination */
// 次の組み合わせをbitで返す
// 全探索のloopに使える
long long next_combination(long long sub) {
long long x = sub & -sub, y = sub + x;
return (((sub & ~y) / x) >> 1) | y;
}
//////////////////////////////////////////
struct UF { // サイズが測れるUF
vector<long long> par, size; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
// sizeはiを根とする木のサイズ
UF(long long N) : par(N), size(N) { // 最初は全てが根であるとして初期化
for (long long i = 0; i < N; i++) {
par[i] = i;
size[i] = 1;
}
}
long long root(
long long x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
void unite(long long x, long long y) { // xとyの木を併合
long long rx = root(x); // xの根をrx
long long ry = root(y); // yの根をry
if (rx == ry)
return; // xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] =
ry; // xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
size[ry] += size[rx];
size[rx] = 0; // サイズの処理 根じゃなくなったらサイズは0になる
}
bool same(long long x,
long long y) { // 2つのデータx, yが属する木が同じならtrueを返す
long long rx = root(x);
long long ry = root(y);
return rx == ry;
}
};
// auto mod int
// https://youtu.be/L8grWxBlIZ4?t=9858
// https://youtu.be/ERZuLAxZffQ?t=4807 : optimize
// https://youtu.be/8uowVvQ_-Mo?t=1329 : division
const int mod = 1000000007;
// int mod=17;
// const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint &operator-=(const mint a) {
if ((x += mod - a.x) >= mod)
x -= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
void debug(ll &a) { cout << a << endl; }
void debug(vll &a) {
cout << "debug vector" << endl;
cout << "{ ";
for (auto t : a) {
cout << t << ",";
}
cout << " }" << endl;
cout << "debug finished" << endl;
}
void debug(set<long long> &a) {
cout << "debug set" << endl;
for (auto t : a) {
cout << t << endl;
}
cout << "debug finished" << endl;
}
void debug(map<long long, long long> a) {
cout << "debug map" << endl;
for (auto t : a) {
cout << t.first << " " << t.second << endl;
}
cout << "debug finished" << endl;
}
void debug(queue<long long> a) {
cout << "debug queue" << endl;
while (!a.empty()) {
ll t = a.front();
a.pop();
cout << t << endl;
}
cout << "debug finished" << endl;
}
//////////////////////////////////////////////
// ll const mod=1e9+7;
ll const dekai = 99999999977; // 1e11-23.素数.
ll dx[4] = {-1, 0, 1, 0};
ll dy[4] = {0, -1, 0, 1};
ll ddx[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
ll ddy[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
// cout<<fixed<<setprecision(10);
#define ednl endl
#define endk endl
//////////////////////////////////////////////////
int main() {
ll n;
cin >> n;
auto c = inputv(n);
sort(all(c));
cominit();
ll ans = (0);
rep(i, n) {
ll k = (0);
// Rep(j, 1, n - i + 1) {
// // k += commod(n - 1 - i, j - 1) * j % mod;
// k %= mod;
// }
k = modpow(2, n - i - 1, mod) +
(n - i - 1) * modpow(2, n - i - 2, mod) % mod;
k %= mod;
ans += k * c[i] % mod * modpow(2, i, mod) % mod;
ans %= mod;
}
// ans -= 4535;
ans *= modpow(2, n, mod);
ans %= mod;
cout << ans << endl;
}
| replace | 651 | 656 | 651 | 660 | TLE | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
constexpr int64_t mod = 1'000'000'007; //'
template <uint32_t mod> class modint {
uint64_t value;
public:
constexpr modint(const int64_t x = 0) noexcept
: value(x % mod + (x < 0 ? mod : 0)) {}
constexpr explicit operator uint64_t() const noexcept { return value; }
constexpr modint inverse() const noexcept { return pow(*this, mod - 2); }
constexpr bool operator==(const modint &rhs) const noexcept {
return value == rhs.value;
}
constexpr bool operator!=(const modint &rhs) const noexcept {
return value != rhs.value;
}
constexpr modint operator+() const noexcept { return modint(*this); }
constexpr modint operator-() const noexcept { return modint(mod - value); }
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;
}
constexpr modint operator/(const modint &rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint &rhs) noexcept {
if ((value += rhs.value) >= mod)
value -= mod;
return *this;
}
constexpr modint &operator-=(const modint &rhs) noexcept {
return *this += mod - rhs.value;
}
constexpr modint &operator*=(const modint &rhs) noexcept {
if ((value *= rhs.value) >= mod)
value %= mod;
return *this;
}
constexpr modint &operator/=(const modint &rhs) noexcept {
return *this *= rhs.inverse();
}
constexpr modint operator++(int) noexcept {
modint ret(*this);
if ((++value) >= mod)
value -= mod;
return ret;
}
constexpr modint operator--(int) noexcept {
modint ret(*this);
if ((value += mod - 1) >= mod)
value -= mod;
return ret;
}
constexpr modint &operator++() noexcept { return *this += 1; }
constexpr modint &operator--() noexcept { return *this -= 1; }
friend std::ostream &operator<<(std::ostream &os, const modint<mod> &x) {
return os << x.value;
}
friend std::istream &operator>>(std::istream &is, modint<mod> &x) {
int64_t i;
is >> i;
x = modint<mod>(i);
return is;
}
friend constexpr modint<mod> pow(const modint<mod> &x, uint64_t y) {
modint<mod> ret{1}, m{x};
while (y > 0) {
if (y & 1)
ret *= m;
m *= m;
y >>= 1;
}
return ret;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
modint<mod> c[100000];
for (int i = 0; i < n; ++i)
cin >> c[i];
sort(c, c + n, [](auto x, auto y) { return (uint64_t)x < (uint64_t)y; });
modint<mod> ans = 0, two = 2;
for (int i = 0; i < n; ++i) {
modint<mod> pw = n - i - 2 >= 0 ? pow(two, n - i - 2) : modint<mod>{0};
ans += c[i] * pow(two * 2, i) * 2 * pow(two, n - i - 1) *
(pow(two, n - i - 1) + pw * (n - i - 1));
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
constexpr int64_t mod = 1'000'000'007; //'
template <uint32_t mod> class modint {
uint64_t value;
public:
constexpr modint(const int64_t x = 0) noexcept
: value(x % mod + (x < 0 ? mod : 0)) {}
constexpr explicit operator uint64_t() const noexcept { return value; }
constexpr modint inverse() const noexcept { return pow(*this, mod - 2); }
constexpr bool operator==(const modint &rhs) const noexcept {
return value == rhs.value;
}
constexpr bool operator!=(const modint &rhs) const noexcept {
return value != rhs.value;
}
constexpr modint operator+() const noexcept { return modint(*this); }
constexpr modint operator-() const noexcept { return modint(mod - value); }
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;
}
constexpr modint operator/(const modint &rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint &rhs) noexcept {
if ((value += rhs.value) >= mod)
value -= mod;
return *this;
}
constexpr modint &operator-=(const modint &rhs) noexcept {
return *this += mod - rhs.value;
}
constexpr modint &operator*=(const modint &rhs) noexcept {
if ((value *= rhs.value) >= mod)
value %= mod;
return *this;
}
constexpr modint &operator/=(const modint &rhs) noexcept {
return *this *= rhs.inverse();
}
constexpr modint operator++(int) noexcept {
modint ret(*this);
if ((++value) >= mod)
value -= mod;
return ret;
}
constexpr modint operator--(int) noexcept {
modint ret(*this);
if ((value += mod - 1) >= mod)
value -= mod;
return ret;
}
constexpr modint &operator++() noexcept { return *this += 1; }
constexpr modint &operator--() noexcept { return *this -= 1; }
friend std::ostream &operator<<(std::ostream &os, const modint<mod> &x) {
return os << x.value;
}
friend std::istream &operator>>(std::istream &is, modint<mod> &x) {
int64_t i;
is >> i;
x = modint<mod>(i);
return is;
}
friend constexpr modint<mod> pow(const modint<mod> &x, uint64_t y) {
modint<mod> ret{1}, m{x};
while (y > 0) {
if (y & 1)
ret *= m;
m *= m;
y >>= 1;
}
return ret;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n;
cin >> n;
modint<mod> c[200000];
for (int i = 0; i < n; ++i)
cin >> c[i];
sort(c, c + n, [](auto x, auto y) { return (uint64_t)x < (uint64_t)y; });
modint<mod> ans = 0, two = 2;
for (int i = 0; i < n; ++i) {
modint<mod> pw = n - i - 2 >= 0 ? pow(two, n - i - 2) : modint<mod>{0};
ans += c[i] * pow(two * 2, i) * 2 * pow(two, n - i - 1) *
(pow(two, n - i - 1) + pw * (n - i - 1));
}
cout << ans << endl;
return 0;
} | replace | 89 | 90 | 89 | 90 | 0 | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
#define F first
#define S second
#define P pair
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define V vector
#define RE return
#define ALL(a) a.begin(), a.end()
#define MP make_pair
#define PB push_back
#define PF push_front
#define FILL(a, b) memset(a, b, sizeof(a))
using namespace std;
int a[100005], mod = 1e9 + 7;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
FOR(i, 1, n) cin >> a[i];
int ans = 0;
sort(a + 1, a + n + 1, greater<int>());
FOR(i, 1, n) ans = ans + a[i] * (i + 1), ans = ans % mod;
FOR(i, 1, 2 * n - 2) { ans = ans * 2 % mod; }
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define int long long
#define F first
#define S second
#define P pair
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define V vector
#define RE return
#define ALL(a) a.begin(), a.end()
#define MP make_pair
#define PB push_back
#define PF push_front
#define FILL(a, b) memset(a, b, sizeof(a))
using namespace std;
int a[200005], mod = 1e9 + 7;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
FOR(i, 1, n) cin >> a[i];
int ans = 0;
sort(a + 1, a + n + 1, greater<int>());
FOR(i, 1, n) ans = ans + a[i] * (i + 1), ans = ans % mod;
FOR(i, 1, 2 * n - 2) { ans = ans * 2 % mod; }
cout << ans;
return 0;
}
| replace | 14 | 15 | 14 | 15 | 0 | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN = 100010, P = 1e9 + 7;
int n, qp, ans, c[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
sort(c + 1, c + n + 1);
qp = 1;
for (int i = 1; i <= 2 * n - 2; i++) {
qp = (qp + qp) % P;
}
for (int i = 1; i <= n; i++) {
ans = (ans + (1ll * c[i] * (((1ll * (n - i + 1) * qp) % P + qp) % P)) % P) %
P;
}
printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int MAXN = 200010, P = 1e9 + 7;
int n, qp, ans, c[MAXN];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &c[i]);
}
sort(c + 1, c + n + 1);
qp = 1;
for (int i = 1; i <= 2 * n - 2; i++) {
qp = (qp + qp) % P;
}
for (int i = 1; i <= n; i++) {
ans = (ans + (1ll * c[i] * (((1ll * (n - i + 1) * qp) % P + qp) % P)) % P) %
P;
}
printf("%d\n", ans);
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02815 | Python | Runtime Error | import sys
readline = sys.stdin.readline
MOD = 10**9 + 7
INF = float("INF")
sys.setrecursionlimit(10**5)
def main():
n0 = int(input())
c0 = list(map(int, readline().split()))
c0.sort(reverse=True)
ans = 0
mul = pow(2, n0 - 1, MOD)
add = pow(2, n0 - 2, MOD)
for i, cc in enumerate(c0, 1):
ans += cc * mul
ans %= MOD
mul += add
mul %= MOD
ans *= pow(2, n0, MOD)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.readline
MOD = 10**9 + 7
INF = float("INF")
sys.setrecursionlimit(10**5)
def main():
n0 = int(input())
c0 = list(map(int, readline().split()))
c0.sort(reverse=True)
ans = 0
mul = pow(2, n0 - 1, MOD)
add = pow(2, max(0, n0 - 2), MOD)
for i, cc in enumerate(c0, 1):
ans += cc * mul
ans %= MOD
mul += add
mul %= MOD
ans *= pow(2, n0, MOD)
ans %= MOD
print(ans)
if __name__ == "__main__":
main()
| replace | 15 | 16 | 15 | 16 | 0 | |
p02815 | Python | Time Limit Exceeded | n = int(input())
c = sorted([int(_) for _ in input().split()])
mod = 10**9 + 7
ans = 0
for i in range(n):
ans += c[i] * 2 ** (2 * n - 2) * (n - i + 1)
ans %= mod
print(ans)
| n = int(input())
c = sorted([int(_) for _ in input().split()])
mod = 10**9 + 7
ans = 0
for i in range(n):
ans += c[i] * pow(2, 2 * n - 2, mod) * (n - i + 1)
ans %= mod
print(ans)
| replace | 5 | 6 | 5 | 6 | TLE | |
p02815 | C++ | Runtime Error |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
typedef long long ll;
// const ll MOD = 1000000007;
long long inv(int a, int p) {
return a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p;
}
static const int MODVAL = 1000000007;
struct mint {
int val;
mint() : val(0) {}
mint(int x) : val(x % MODVAL) {}
mint(size_t x) : val(x % MODVAL) {}
mint(long long x) : val(x % MODVAL) {}
mint &operator+=(mint y) {
val += y.val;
if (val >= MODVAL)
val -= MODVAL;
return *this;
}
mint &operator-=(mint y) {
val -= y.val;
if (val < 0)
val += MODVAL;
return *this;
}
mint &operator*=(mint y) {
val = (val * (long long)y.val) % MODVAL;
return *this;
}
mint &operator/=(mint y) {
val = (val * inv(y.val, MODVAL)) % MODVAL;
return *this;
}
};
inline mint operator+(mint x, mint y) { return x += y; }
inline mint operator-(mint x, mint y) { return x -= y; }
inline mint operator*(mint x, mint y) { return x *= y; }
inline mint operator/(mint x, mint y) { return x /= y; }
mint POW(mint x, long long n) {
mint r(1);
for (; n; x *= x, n >>= 1)
if (n & 1)
r *= x;
return r;
}
mint FAC(int n) {
static vector<mint> FAC_(1, 1);
while (int(FAC_.size()) <= n)
FAC_.push_back(FAC_.back() * FAC_.size());
return FAC_[n];
}
inline mint CMB(int n, int k) {
return k < 0 || n < k ? 0 : FAC(n) / (FAC(k) * FAC(n - k));
}
inline ostream &operator<<(ostream &os, mint a) { return os << a.val; }
int n;
ll cs[100000 + 10];
int main(void) {
scanf("%d", &n);
REP(i, n) { scanf("%lld", &cs[i]); }
sort(cs, cs + n);
reverse(cs, cs + n);
mint res = 0;
mint g = 1;
REP(i, n) {
// cerr << "> " << g << endl;
res += mint(cs[i]) * POW(2, n - i - 1) * g;
g = g * 2 + POW(2, i);
}
res *= POW(2, n);
cout << res << endl;
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
typedef long long ll;
// const ll MOD = 1000000007;
long long inv(int a, int p) {
return a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p;
}
static const int MODVAL = 1000000007;
struct mint {
int val;
mint() : val(0) {}
mint(int x) : val(x % MODVAL) {}
mint(size_t x) : val(x % MODVAL) {}
mint(long long x) : val(x % MODVAL) {}
mint &operator+=(mint y) {
val += y.val;
if (val >= MODVAL)
val -= MODVAL;
return *this;
}
mint &operator-=(mint y) {
val -= y.val;
if (val < 0)
val += MODVAL;
return *this;
}
mint &operator*=(mint y) {
val = (val * (long long)y.val) % MODVAL;
return *this;
}
mint &operator/=(mint y) {
val = (val * inv(y.val, MODVAL)) % MODVAL;
return *this;
}
};
inline mint operator+(mint x, mint y) { return x += y; }
inline mint operator-(mint x, mint y) { return x -= y; }
inline mint operator*(mint x, mint y) { return x *= y; }
inline mint operator/(mint x, mint y) { return x /= y; }
mint POW(mint x, long long n) {
mint r(1);
for (; n; x *= x, n >>= 1)
if (n & 1)
r *= x;
return r;
}
mint FAC(int n) {
static vector<mint> FAC_(1, 1);
while (int(FAC_.size()) <= n)
FAC_.push_back(FAC_.back() * FAC_.size());
return FAC_[n];
}
inline mint CMB(int n, int k) {
return k < 0 || n < k ? 0 : FAC(n) / (FAC(k) * FAC(n - k));
}
inline ostream &operator<<(ostream &os, mint a) { return os << a.val; }
int n;
ll cs[200000 + 10];
int main(void) {
scanf("%d", &n);
REP(i, n) { scanf("%lld", &cs[i]); }
sort(cs, cs + n);
reverse(cs, cs + n);
mint res = 0;
mint g = 1;
REP(i, n) {
// cerr << "> " << g << endl;
res += mint(cs[i]) * POW(2, n - i - 1) * g;
g = g * 2 + POW(2, i);
}
res *= POW(2, n);
cout << res << endl;
return 0;
}
| replace | 71 | 72 | 71 | 72 | 0 | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define vi vector<int>
#define vll vector<ll>
#define pll pair<ll, ll>
#define pii pair<int, int>
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define SIZE 200005
#define M 1000000007
ll power(ll a, ll b) {
if (b == 0)
return 1;
ll p = power(a, b / 2);
p = (p * p) % M;
if (b % 2 == 0) {
return p;
} else {
return (p * a) % M;
}
}
ll arr[SIZE];
ll presum[SIZE];
// ll binomial[SIZE];
// ll binomialCoeff(ll n, ll k)
// {
// if(n==0)
// return 1;
// ll res = 1;
// // Since C(n, k) = C(n, n-k)
// if ( k > n - k )
// k = n - k;
// // Calculate value of
// // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
// for (ll i = 0; i < k; ++i)
// {
// res *= (n - i);
// res /= (i + 1);
// }
// return res;
// }
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N;
cin >> N;
for (ll i = 1; i <= N; ++i) {
cin >> arr[i];
}
sort(arr + 1, arr + N + 1, greater<ll>());
ll ans = 0, ans2 = 0;
presum[0] = 1;
for (ll i = 1; i <= N; ++i) {
// ll temp=0;
// for(ll j=0;j<i;++j){
// temp+=(j+1)*binomialCoeff(i-1,j);
// }
// ans2=(ans2+((power(2,i)*temp)%M*(arr[i]*power(2,2*(N-i)))%M)%M)%M;
ans = (ans + (((power(2, i) * presum[i - 1]) % M) *
((arr[i] * power(2, 2 * (N - i))) % M) % M)) %
M;
presum[i] = ((2 * presum[i - 1]) % M + power(2, i - 1)) % M;
// cout<<arr[i]<<" "<<ans<<" "<<presum[i-1]<<":"<<ans2<<" "<<temp<<endl;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define vi vector<int>
#define vll vector<ll>
#define pll pair<ll, ll>
#define pii pair<int, int>
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define SIZE 200005
#define M 1000000007
ll power(ll a, ll b) {
if (b == 0)
return 1;
ll p = power(a, b / 2);
p = (p * p) % M;
if (b % 2 == 0) {
return p;
} else {
return (p * a) % M;
}
}
ll arr[SIZE];
ll presum[SIZE];
// ll binomial[SIZE];
// ll binomialCoeff(ll n, ll k)
// {
// if(n==0)
// return 1;
// ll res = 1;
// // Since C(n, k) = C(n, n-k)
// if ( k > n - k )
// k = n - k;
// // Calculate value of
// // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
// for (ll i = 0; i < k; ++i)
// {
// res *= (n - i);
// res /= (i + 1);
// }
// return res;
// }
int main() {
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N;
cin >> N;
for (ll i = 1; i <= N; ++i) {
cin >> arr[i];
}
sort(arr + 1, arr + N + 1, greater<ll>());
ll ans = 0, ans2 = 0;
presum[0] = 1;
for (ll i = 1; i <= N; ++i) {
// ll temp=0;
// for(ll j=0;j<i;++j){
// temp+=(j+1)*binomialCoeff(i-1,j);
// }
// ans2=(ans2+((power(2,i)*temp)%M*(arr[i]*power(2,2*(N-i)))%M)%M)%M;
ans = (ans + (((power(2, i) * presum[i - 1]) % M) *
((arr[i] * power(2, 2 * (N - i))) % M) % M)) %
M;
presum[i] = ((2 * presum[i - 1]) % M + power(2, i - 1)) % M;
// cout<<arr[i]<<" "<<ans<<" "<<presum[i-1]<<":"<<ans2<<" "<<temp<<endl;
}
cout << ans << endl;
} | replace | 49 | 53 | 49 | 53 | TLE | |
p02815 | C++ | Time Limit Exceeded | /*temp*/
//
//
//
//
// #undef _DEBUG
// #pragma GCC optimize("Ofast")
// 不動小数点の計算高速化
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #include <boost/multiprecision/cpp_int.hpp>
#ifdef _DEBUG
#include "template.h"
#else
#if __cplusplus >= 201703L
/*Atcoderでしか使えない(c++17 && このテンプレートが使えるならAtcoder)*/
#include <boost/sort/pdqsort/pdqsort.hpp>
#define fast_sort boost::sort::pdqsort
#endif
#endif
#ifndef _DEBUG
#ifndef UNTITLED15_TEMPLATE_H
#define UNTITLED15_TEMPLATE_H
#ifdef _DEBUG
#include "bits_stdc++.h"
#else
#include <bits/stdc++.h>
#endif
#ifndef fast_sort
#define fast_sort sort
#endif
// #define use_pq
#define use_for
#define use_for_each
#define use_sort
#define use_fill
#define use_rand
#define use_mgr
#define use_rui
#define use_compress
//
//
//
//
//
//
#define use_pbds
#ifdef use_pbds
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <class T, class U, class W, class X>
auto count(__gnu_pbds::gp_hash_table<T, U, W> &a, X k) {
return a.find(k) != a.end();
}
#endif
using namespace std;
using namespace std::chrono;
/*@formatter:off*/
#define ll long long
using sig_dou = double;
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define mt make_tuple
#define pb pop_back
#define pf push_front
#define eb emplace_back
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
template <class T, class U> auto max(T a, U b) { return a > b ? a : b; }
template <class T, class U> auto min(T a, U b) { return a < b ? a : b; }
// optional<T>について下でオーバーロード(nullopt_tを左辺右辺について単位元として扱う)
template <class T, class U> bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// メタ系 meta
// vector<T>でTを返す
#define decl_t(A) decltype(A)::value_type
// vector<vector<.....T>>でTを返す
template <class T> struct decl2 {
typedef T type;
};
template <class T> struct decl2<vector<T>> {
typedef typename decl2<T>::type type;
};
// #define decl_max(a, b) decltype(max(MAX<decltype(a)>(), MAX<decltype(b)>()))
#define is_same2(T, U) is_same<T, U>::value
template <class T> struct is_vector : std::false_type {};
template <class T> struct is_vector<std::vector<T>> : std::true_type {};
// 大きい型を返す max_type<int, char>::type
// todo mintがlong long より小さいと判定されるためバグる
template <class T1, class T2, bool t1_bigger = (sizeof(T1) > sizeof(T2))>
struct max_type {
typedef T1 type;
};
template <class T1, class T2> struct max_type<T1, T2, false> {
typedef T2 type;
};
template <typename T, typename U = typename T::value_type>
std::true_type value_type_tester(signed);
template <typename T> std::false_type value_type_tester(long);
template <typename T>
struct has_value_type : decltype(value_type_tester<T>(0)) {};
template <class T> struct vec_rank : integral_constant<int, 0> {};
template <class T>
struct vec_rank<vector<T>> : integral_constant<int, vec_rank<T>{} + 1> {};
// N個のTを並べたtupleを返す
// tuple_n<3, int>::type tuple<int, int, int>
template <size_t N, class T, class... Arg> struct tuple_n {
typedef typename tuple_n<N - 1, T, T, Arg...>::type type;
};
template <class T, class... Arg> struct tuple_n<0, T, Arg...> {
typedef tuple<Arg...> type;
};
struct dummy_t1 {};
struct dummy_t2 {};
struct dummy_t3 {};
struct dummy_t4 {};
struct dummy_t5 {};
struct dummy_t6 {};
// template<class T, require(is_integral<T>::value)>など
#define require_t(bo) enable_if_t<bo> * = nullptr
// 複数でオーバーロードする場合、引数が同じだとうまくいかないため
// require_arg(bool, dummy_t1)
// require_arg(bool, dummy_t2)等とする
#define require_arg1(bo) enable_if_t<bo> * = nullptr
#define require_arg2(bo, dummy_type) enable_if_t<bo, dummy_type> * = nullptr
#define require_arg(...) \
over2(__VA_ARGS__, require_arg2, require_arg1)(__VA_ARGS__)
//->//enable_if_tのtを書き忘れそうだから
#define require_ret(bo, ret_type) enable_if_t<bo, ret_type>
#define int long long // todo 消したら動かない intの代わりにsignedを使う
auto start_time = system_clock::now();
auto past_time = system_clock::now();
#define debugName(VariableName) #VariableName
// 最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
void assert2(bool b, const string &s = "") {
if (!b) {
cerr << s << endl;
exit(1); /*assert(0);*/
}
}
// my_nulloptをあらゆる操作の単位元的な物として扱う
// vectorの参照外時に返したり、右辺値として渡されたときに何もしないなど
struct my_nullopt_t {
} my_nullopt;
#define nullopt_t my_nullopt_t
#define nullopt my_nullopt
/*@formatter:off*/
// 値が無いときは、setを使わない限り代入できない
//=を使っても無視される
template <class T> struct my_optional {
private:
bool is_null;
T v;
public:
typedef T value_type;
my_optional() : is_null(true) {}
my_optional(const nullopt_t &) : is_null(true) {}
my_optional(const T &v) : v(v), is_null(false) {}
bool has_value() const { return !is_null; }
T &value() {
static string mes = "optional has no value";
assert2(!is_null, mes);
return v;
}
const T &value() const {
static string mes = "optional has no value";
assert2(!is_null, mes);
return v;
}
void set(const T &nv) {
is_null = false;
v = nv;
}
template <class U> void operator=(const U &v) {
if (has_value())
value() = v;
else
return;
}
template <class U> void operator=(const my_optional<U> &v) {
if (has_value() && v.has_value())
(*this) = v;
else
return;
}
void reset() { is_null = true; }
void operator=(const nullopt_t &) { reset(); }
template <require_t(!is_same2(T, bool))> explicit operator bool() {
return !is_null;
}
// nullの時はエラー
operator T &() { return value(); }
operator const T &() const { return value(); }
my_optional<T> operator++() {
if (this->has_value()) {
this->value()++;
return *this;
} else {
return *this;
}
}
my_optional<T> operator++(signed) {
if (this->has_value()) {
auto tem = *this;
this->value()++;
return tem;
} else {
return *this;
}
}
my_optional<T> operator--() {
if (this->has_value()) {
this->value()--;
return *this;
} else {
return *this;
}
}
my_optional<T> operator--(signed) {
if (this->has_value()) {
auto tem = *this;
this->value()--;
return tem;
} else {
return *this;
}
}
};
template <class T> istream &operator>>(istream &iss, my_optional<T> &v) {
T val;
iss >> val;
v.set(val);
return iss;
}
#define optional my_optional
template <class T> using opt = my_optional<T>;
// template<class T, class A = std::allocator<T>> struct debtor : std::vector<T,
// A> {
template <class Key, class T, class Compare = less<Key>,
class Allocator = allocator<pair<const Key, T>>>
struct o_map : std::map<Key, optional<T>, Compare, Allocator> {
optional<T> emp;
o_map() : std::map<Key, optional<T>, Compare, Allocator>() {}
auto operator()(const nullopt_t &) { return nullopt; }
optional<T> &operator()(const optional<Key> &k) {
if (k.has_value()) {
return std::map<Key, optional<T>, Compare, Allocator>::operator[](
k.value());
} else {
emp.reset();
return emp;
}
}
optional<T> &operator()(const Key &k) {
auto &v = std::map<Key, optional<T>, Compare, Allocator>::operator[](k);
if (v.has_value())
return v;
else {
v.set(0);
return v;
}
}
template <class U> void operator[](U) {
static string mes = "s_map cant []";
assert2(0, mes);
}
};
// 以下、空のoptionalをnulloptと書く
// ov[-1(参照外)] でnulloptを返す
// ov[nullopt] で nulloptをかえす
template <class T> struct ov {
optional<T> emp;
vector<optional<T>> v;
ov(int i = 0, T val = 0) : v(i, val) {}
template <class U> ov(const U &rhs) {
v.resize(sz(rhs));
for (int i = 0; i < sz(rhs); i++)
v[i].set(rhs[i]);
}
optional<T> &operator()(int i) {
if (i < 0 || sz(v) <= i) {
emp.reset();
return emp;
} else {
return v[i];
}
}
optional<T> &operator()(const nullopt_t &) { return operator()(-1); }
optional<T> &operator()(const optional<T> &i) {
if (i.has_value())
return operator()(i.value());
else {
return operator()(-1);
}
}
/*@formatter:off*/
};
template <class T> string deb_tos(const ov<T> &v) { return deb_tos(v.v); }
// vectorに対しての処理は.vを呼ぶ
template <class T> class ovv {
optional<T> emp;
public:
vector<vector<optional<T>>> v;
ovv(int i = 0, int j = 0, T val = 0) : v(i, vector<optional<T>>(j, val)) {}
optional<T> &operator()(int i, int j) {
if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) {
return emp;
} else {
return v[i][j];
}
}
// 再帰ver 遅いと思う
// optional<T>& gets(optional<T>& v){return v;}
// template<class V, class H, class... U> optional<T>& gets(V& v, H i, U...
// tail){ if constexpr(is_same2(H, nullopt_t))return
// operator()(-1,-1); else if constexpr(is_same2(H, optional<int>)){
// if(i.has_value())return gets(v[(int)i], tail...); else return
// operator()(-1,-1); }else if constexpr(is_integral<H>::value){
// return gets(v[(int)i], tail...); }else{ assert(0);
// return emp; } }
#if __cplusplus >= 201703L
// if constexprバージョン 上が遅かったらこれで
template <class U, class V>
optional<T> &operator()(const U &i, const V &j) { /*駄目な場合を除外*/
if constexpr (is_same2(U, nullopt_t) || is_same2(U, nullopt_t)) {
return operator()(-1, -1); /* o, o*/
} else if constexpr (is_same2(U, optional<int>) &&
is_same2(V, optional<int>)) {
return operator()(i.has_value() ? (int)i : -1,
j.has_value() ? (int)j : -1); /* o, x*/
} else if constexpr (is_same2(U, optional<int>)) {
return operator()(i.has_value() ? (int)i : -1, (int)j); /* x, o*/
} else if constexpr (is_same2(V, optional<int>)) {
return operator()((int)i, j.has_value() ? (int)j : -1); /* x, x*/
} else {
return operator()((int)i, (int)j);
}
}
#endif
operator const vector<vector<optional<T>>> &() { return v; }
};
template <class T> istream &operator>>(istream &iss, ovv<T> &a) {
for (int h = 0; h < sz(a); h++) {
for (int w = 0; w < sz(a[h]); w++) {
iss >> a.v[h][w];
}
}
return iss;
}
template <class T> string deb_tos(const ovv<T> &v) { return deb_tos(v.v); }
template <class T> struct ov3 {
optional<T> emp;
vector<vector<vector<optional<T>>>> v;
ov3(int i, int j, int k, T val = 0)
: v(i, vector<vector<optional<T>>>(j, vector<optional<T>>(k, val))) {}
optional<T> &operator()(int i, int j, int k) {
if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) {
if (k < 0 || sz(v[i][j]) <= k) {
emp.reset();
return emp;
}
}
return v[i][j][k];
}
private:
#if __cplusplus >= 201703L
// 再帰ver 遅いと思う
template <class V, class H> optional<T> &gets(V &nowv, H i) {
if constexpr (is_same2(H, nullopt_t)) {
return emp;
} else if constexpr (is_same2(H, optional<int>)) {
if (i.has_value()) {
return nowv[(int)i];
} else {
return emp;
}
} else if constexpr (is_integral<H>::value) {
return nowv[(int)i];
} else {
static string mes = "ov3 error not index";
assert2(0, mes);
return emp;
}
}
// todo const &消した
template <class V, class H, class... U>
optional<T> &gets(V &nowv, H i, U... tail) {
if constexpr (is_same2(H, nullopt_t)) {
return emp;
} else if constexpr (is_same2(H, optional<int>)) {
if (i.has_value()) {
return gets(nowv[(int)i], tail...);
} else {
return emp;
}
} else if constexpr (is_integral<H>::value) {
return gets(nowv[(int)i], tail...);
} else {
static string mes = "ov3 error not index";
assert2(0, mes);
return emp;
}
}
#endif
public:
template <class U, class V, class W> optional<T> &operator()(U i, V j, W k) {
return gets(v, i, j, k);
}
/*@formatter:off*/
};
template <class T> string deb_tos(const ov3<T> &v) { return deb_tos(v.v); }
// nullopt_t
// 優先順位
// null, [opt, tem]
// + と += は違う意味を持つ
// val+=null : val
// val+null : null
//
//+は途中計算
//+=は最終的に格納したい値にだけ持たせる
//+=がvoidを返すのは、途中計算で使うのを抑制するため
// nulloptを考慮する際、計算途中では+を使ってnulloptを作り
// 格納する際は+=で無効にする必要がある
// 演算子==
// optional<int>(10) == 10
// 全ての型に対応させ、value_typeが等しいかを見るようにするのもありかも
// null同士を比較する状況はおかしいのではないか
bool operator==(const nullopt_t &, const nullopt_t &) {
assert2(0, "nul == null cant hikaku");
return false;
}
template <class T> bool operator==(const nullopt_t &, const T &) {
return false;
}
template <class T> bool operator!=(const nullopt_t &, const T &) {
return true;
}
template <class T> bool operator==(const T &, const nullopt_t &) {
return false;
}
template <class T> bool operator!=(const T &, const nullopt_t &) {
return true;
}
// nullを
nullopt_t &operator+(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator-(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator*(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator/(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator+=(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator-=(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator*=(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator/=(const nullopt_t &, const nullopt_t &) { return nullopt; }
template <class ANY> nullopt_t operator+(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator-(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator*(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator/(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator+(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> nullopt_t operator-(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> nullopt_t operator*(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> nullopt_t operator/(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> void operator+=(nullopt_t &, const ANY &) {}
template <class ANY> void operator-=(nullopt_t &, const ANY &) {}
template <class ANY> void operator*=(nullopt_t &, const ANY &) {}
template <class ANY> void operator/=(nullopt_t &, const ANY &) {}
template <class ANY> void operator+=(ANY &, const nullopt_t &) {}
template <class ANY> void operator-=(ANY &, const nullopt_t &) {}
template <class ANY> void operator*=(ANY &, const nullopt_t &) {}
template <class ANY> void operator/=(ANY &, const nullopt_t &) {}
template <class T> struct is_optional : false_type {};
template <class T> struct is_optional<optional<T>> : true_type {};
template <class T, class U>
true_type both_optional(optional<T> t, optional<U> u);
false_type both_optional(...);
template <class T, class U>
class opt_check : public decltype(both_optional(declval<T>(), declval<U>())) {};
// optionalは同じ型同士しか足せない
//(o, t), (t, o), (o, o)
#define opt_tem(op) \
template <class O, class O_ret = decltype(declval<O>() op declval<O>())> \
optional<O_ret> operator op(const optional<O> &opt1, \
const optional<O> &opt2) { \
if (!opt1.has_value() || !opt2.has_value()) { \
return optional<O_ret>(); \
} else { \
return optional<O_ret>(opt1.value() op opt2.value()); \
} \
} \
template <class O, class T, \
class O_ret = decltype(declval<O>() op declval<O>())> \
auto operator op(const optional<O> &opt, const T &tem) \
->require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { \
if (!opt.has_value()) { \
return optional<O_ret>(); \
} else { \
return optional<O_ret>(opt.value() op tem); \
} \
} \
template <class O, class T, \
class O_ret = decltype(declval<O>() op declval<O>())> \
auto operator op(const T &tem, const optional<O> &opt) \
->require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { \
if (!opt.has_value()) { \
return optional<O_ret>(); \
} else { \
return optional<O_ret>(opt.value() op tem); \
} \
}
/*@formatter:off*/
opt_tem(+) opt_tem(-) opt_tem(*) opt_tem(/)
// 比較はoptional<bool>を返す
opt_tem(<) opt_tem(>) opt_tem(<=) opt_tem(>=)
/*@formatter:on*/ /*@formatter:off*/
template <class O, class T>
bool operator==(const optional<O> &opt, const T &tem) {
if (opt.has_value()) {
return opt.value() == tem;
} else
return nullopt == tem;
}
template <class O, class T>
bool operator!=(const optional<O> &opt, const T &tem) {
if (opt.has_value()) {
return opt.value() != tem;
} else
return nullopt != tem;
}
template <class O, class T>
bool operator==(const T &tem, const optional<O> &opt) {
if (opt.has_value()) {
return opt.value() == tem;
} else
return nullopt == tem;
}
template <class O, class T>
bool operator!=(const T &tem, const optional<O> &opt) {
if (opt.has_value()) {
return opt.value() != tem;
} else
return nullopt != tem;
}
template <class O>
bool operator==(const optional<O> &opt1, const optional<O> &opt2) {
if (opt1.has_value() != opt2.has_value()) {
return false;
} else if (opt1.has_value()) {
return opt1.value() == opt2.value();
} else {
return nullopt == nullopt;
}
}
template <class O>
bool operator!=(const optional<O> &opt1, const optional<O> &opt2) {
return !(opt1 == opt2);
}
//(a+=null) != (a=a+null)
// a null
template <class T, class O> void operator+=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem += opt.value();
}
}
template <class T, class O> void operator-=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem -= opt.value();
}
}
template <class T, class O> void operator*=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem *= opt.value();
}
}
template <class T, class O> void operator/=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem /= opt.value();
}
}
template <class T, class O> void operator+=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() += tem;
}
}
template <class T, class O> void operator-=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() -= tem;
}
}
template <class T, class O> void operator*=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() *= tem;
}
}
template <class T, class O> void operator/=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() /= tem;
}
}
//
template <class Ol, class Or>
void operator+=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl += opr.value();
}
}
template <class Ol, class Or>
void operator-=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl -= opr.value();
}
}
template <class Ol, class Or>
void operator*=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl *= opr.value();
}
}
template <class Ol, class Or>
void operator/=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl /= opr.value();
}
}
/*@formatter:off*/
template <class U> auto max(const nullopt_t &, const U &val) { return val; }
template <class U> auto max(const U &val, const nullopt_t &) { return val; }
template <class U> auto min(const nullopt_t &, const U &val) { return val; }
template <class U> auto min(const U &val, const nullopt_t &) { return val; }
template <class T, class U> auto max(const optional<T> &opt, const U &val) {
if (opt.has_value())
return max(opt.value(), val);
else
return val;
}
template <class T, class U> auto max(const U &val, const optional<T> &opt) {
if (opt.has_value())
return max(opt.value(), val);
else
return val;
}
template <class T, class U> auto min(const optional<T> &opt, const U &val) {
if (opt.has_value())
return min(opt.value(), val);
else
return val;
}
template <class T, class U> auto min(const U &val, const optional<T> &opt) {
if (opt.has_value())
return min(opt.value(), val);
else
return val;
}
// null , optional, T
bool chma(nullopt_t &, const nullopt_t &) { return false; }
template <class T> bool chma(T &opt, const nullopt_t &) { return false; }
template <class T> bool chma(nullopt_t &, const T &opt) { return false; }
template <class T> bool chma(optional<T> &olv, const optional<T> &orv) {
if (orv.has_value()) {
return chma(olv, orv.value());
} else
return false;
}
template <class T, class U> bool chma(optional<T> &opt, const U &rhs) {
if (opt.has_value()) {
return chma(opt.value(), rhs);
} else
return false;
}
template <class T, class U> bool chma(T &lhs, const optional<U> &opt) {
if (opt.has_value()) {
return chma(lhs, opt.value());
} else
return false;
}
bool chmi(nullopt_t &, const nullopt_t &) { return false; }
template <class T> bool chmi(T &opt, const nullopt_t &) { return false; }
template <class T> bool chmi(nullopt_t &, const T &opt) { return false; }
template <class T> bool chmi(optional<T> &olv, const optional<T> &orv) {
if (orv.has_value()) {
return chmi(olv, orv.value());
} else
return false;
}
template <class T, class U> bool chmi(optional<T> &opt, const U &rhs) {
if (opt.has_value()) {
return chmi(opt.value(), rhs);
} else
return false;
}
template <class T, class U> bool chmi(T &lhs, const optional<U> &opt) {
if (opt.has_value()) {
return chmi(lhs, opt.value());
} else
return false;
}
template <class T> ostream &operator<<(ostream &os, optional<T> p) {
if (p.has_value())
os << p.value();
else
os << "e";
return os;
}
struct xorshift {
/*@formatter:on*/
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
/*@formatter:off*/
size_t operator()(const uint64_t &x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
size_t operator()(const std::pair<ll, ll> &x) const {
ll v = ((x.first) << 32) | x.second;
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(v + FIXED_RANDOM);
}
template <class T, class U>
size_t operator()(const std::pair<T, U> &x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
uint64_t hasx = splitmix64(x.first);
uint64_t hasy = splitmix64(x.second + FIXED_RANDOM);
return hasx ^ hasy;
}
template <class T> size_t operator()(const vector<T> &x) const {
uint64_t has = 0;
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
uint64_t rv = splitmix64(FIXED_RANDOM);
for (int i = 0; i < sz(x); i++) {
uint64_t v = splitmix64(x[i] + rv);
has ^= v;
rv = splitmix64(rv);
}
return has;
}
};
#ifdef _DEBUG
string message;
string res_mes;
// #define use_debtor
// template<class T, class U, class X> auto count(unordered_map<T, U> &a, X k) {
// return a.find(k) != a.end(); }
#ifdef use_debtor
// https://marycore.jp/prog/cpp/class-extension-methods/ 違うかも
template <class T, class A = std::allocator<T>>
struct debtor : std::vector<T, A> {
using std::vector<T, A>::vector;
template <class U> int deb_v(U a, int v) { return v; }
template <class U> int deb_v(debtor<U> &a, int v = 0) {
cerr << a.size() << " ";
return deb_v(a.at(0), v + 1);
}
template <class U> void deb_o(U a) { cerr << a << " "; }
template <class U> void deb_o(debtor<U> &a) {
for (int i = 0; i < min((int)a.size(), 15ll); i++) {
deb_o(a[i]);
}
if ((int)a.size() > 15) {
cerr << "...";
}
cerr << endl;
}
typename std::vector<T>::reference my_at(typename std::vector<T>::size_type n,
vector<int> &ind) {
if (n < 0 || n >= (int)this->size()) {
int siz = (int)this->size();
cerr << "vector size = ";
int dim = deb_v((*this));
cerr << endl;
ind.push_back(n);
cerr << "out index at ";
for (auto &&i : ind) {
cerr << i << " ";
}
cerr << endl;
cerr << endl;
if (dim <= 2) {
deb_o((*this));
}
exit(0);
}
return this->at(n);
}
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
if (n < 0 || n >= (int)this->size()) {
int siz = (int)this->size();
cerr << "vector size = ";
int dim = deb_v((*this));
cerr << endl;
cerr << "out index at " << n << endl;
cerr << endl;
if (dim <= 2) {
deb_o((*this));
}
exit(0);
}
return this->at(n);
}
};
#define vector debtor
#endif
#ifdef use_pbds
template <class T> struct my_pbds_tree {
set<T> s;
auto begin() { return s.begin(); }
auto end() { return s.end(); }
auto rbegin() { return s.rbegin(); }
auto rend() { return s.rend(); }
auto empty() { return s.empty(); }
auto size() { return s.size(); }
void clear() { s.clear(); }
template <class U> void insert(U v) { s.insert(v); }
template <class U> void operator+=(U v) { insert(v); }
template <class F> auto erase(F v) { return s.erase(v); }
template <class U> auto find(U v) { return s.find(v); }
template <class U> auto lower_bound(U v) { return s.lower_bound(v); }
template <class U> auto upper_bound(U v) { return s.upper_bound(v); }
auto find_by_order(ll k) {
auto it = s.begin();
for (ll i = 0; i < k; i++)
it++;
return it;
}
auto order_of_key(ll v) {
auto it = s.begin();
ll i = 0;
for (; it != s.end() && *it < v; i++)
it++;
return i;
}
};
#define pbds(T) my_pbds_tree<T>
#endif
// 区間削除は出来ない
// gp_hash_tableでcountを使えないようにするため
template <class T, class U> struct my_unordered_map {
unordered_map<T, U> m;
my_unordered_map(){};
auto begin() { return m.begin(); }
auto end() { return m.end(); }
auto cbegin() { return m.cbegin(); }
auto cend() { return m.cend(); }
template <class V> auto erase(V v) { return m.erase(v); }
void clear() {
m.clear();
} /*countは gp_hash_tableに存在しない*/ /*!= m.end()*/
template <class V> auto find(V v) { return m.find(v); }
template <class V> auto &operator[](V n) { return m[n]; }
};
template <class K, class V> using umap_f = my_unordered_map<K, V>;
#else
#define endl '\n'
// umapはunorderd_mapになる
// umapiはgp_hash_table
// find_by_order(k) k番目のイテレーター
// order_of_key(k) k以上が前から何番目か
#define pbds(U) \
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag, \
__gnu_pbds::tree_order_statistics_node_update>
template <class K, class V>
using umap_f = __gnu_pbds::gp_hash_table<K, V, xorshift>;
#endif
#define umapi unordered_map<ll, ll>
#define umapp unordered_map<P, ll>
#define umappp unordered_map<P, P>
#define umapu unordered_map<uint64_t, ll>
#define umapip unordered_map<ll, P>
template <class T, class U, class X> auto count(unordered_map<T, U> &a, X k) {
return a.find(k) != a.end();
}
/*@formatter:off*/
#ifdef use_pbds
template <class U, class L>
void operator+=(
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update> &s,
L v) {
s.insert(v);
}
#endif
// 衝突対策
#define ws ws_
// todo 要らないと思う
template <class A, class B, class C> struct T2 {
A f;
B s;
C t;
T2() { f = 0, s = 0, t = 0; }
T2(A f, B s, C t) : f(f), s(s), t(t) {}
bool operator<(const T2 &r) const {
return f != r.f ? f < r.f
: s != r.s ? s < r.s
: t < r.t; /*return f != r.f ? f > r.f : s != r.s ?n s >
r.s : t > r.t; 大きい順 */
}
bool operator>(const T2 &r) const {
return f != r.f ? f > r.f
: s != r.s ? s > r.s
: t > r.t; /*return f != r.f ? f > r.f : s != r.s ? s >
r.s : t > r.t; 小さい順 */
}
bool operator==(const T2 &r) const {
return f == r.f && s == r.s && t == r.t;
}
bool operator!=(const T2 &r) const {
return f != r.f || s != r.s || t != r.t;
}
};
template <class A, class B, class C, class D> struct F2 {
A a;
B b;
C c;
D d;
F2() { a = 0, b = 0, c = 0, d = 0; }
F2(A a, B b, C c, D d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F2 &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d; /* return a != r.a ? a > r.a : b != r.b ? b
> r.b : c != r.c ? c > r.c : d > r.d;*/
}
bool operator>(const F2 &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d; /* return a != r.a ? a < r.a : b != r.b
? b < r.b : c != r.c ? c < r.c : d < r.d;*/
}
bool operator==(const F2 &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F2 &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
ll operator[](ll i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
typedef T2<ll, ll, ll> T;
typedef F2<ll, ll, ll, ll> F;
// T mt(ll a, ll b, ll c) { return T(a, b, c); }
// F mf(ll a, ll b, ll c, ll d) { return F(a, b, c, d); }
// 関数内をまとめる
// 初期値l=-1, r=-1
void set_lr12(int &l, int &r, int n) { /*r==-1*/
if (r == -1) {
if (l == -1) {
l = 0;
r = n;
} else {
r = l;
l = 0;
}
}
}
//@マクロ省略系 型,構造
// using で元のdoubleを同時に使えるはず
#define double_big
#ifdef double_big
#define double long double
// #define pow powl
#endif
using dou = double;
/*@formatter:off*/
template <class T> T MAX() { return numeric_limits<T>::max(); }
template <class T> T MIN() { return numeric_limits<T>::min(); }
constexpr ll inf = (ll)1e9 + 100;
constexpr ll linf = (ll)1e18 + 100;
constexpr dou dinf = (dou)linf * linf;
constexpr char infc = '{';
const string infs = "{";
template <class T> T INF() { return MAX<T>() / 2; }
template <> signed INF() { return inf; }
template <> ll INF() { return linf; }
template <> double INF() { return dinf; }
template <> char INF() { return infc; }
template <> string INF() { return infs; }
const double eps = 1e-9;
// #define use_epsdou
#ifdef use_epsdou
// 基本コメントアウト
struct epsdou {
double v;
epsdou(double v = 0) : v(v) {}
template <class T> epsdou &operator+=(T b) {
v += (double)b;
return (*this);
}
template <class T> epsdou &operator-=(T b) {
v -= (double)b;
return (*this);
}
template <class T> epsdou &operator*=(T b) {
v *= (double)b;
return (*this);
}
template <class T> epsdou &operator/=(T b) {
v /= (double)b;
return (*this);
}
epsdou operator+(epsdou b) { return v + (double)b; }
epsdou operator-(epsdou b) { return v - (double)b; }
epsdou operator*(epsdou b) { return v * (double)b; }
epsdou operator/(epsdou b) { return v / (double)b; }
epsdou operator-() const { return epsdou(-v); }
template <class T> bool operator<(T b) { return v < (double)b; }
template <class T> bool operator>(T b) {
auto r = (double)b;
return v > (double)b;
}
template <class T> bool operator==(T b) { return fabs(v - (double)b) <= eps; }
template <class T> bool operator<=(T b) {
return v < (double)b || fabs(v - b) <= eps;
}
template <class T> bool operator>=(T b) {
return v > (double)b || fabs(v - b) <= eps;
}
operator double() { return v; }
};
template <> epsdou MAX() { return MAX<double>(); }
template <> epsdou MIN() { return MIN<double>(); }
// priqrity_queue等で使うのに必要
bool operator<(const epsdou &a, const epsdou &b) { return a.v < b.v; }
bool operator>(const epsdou &a, const epsdou &b) { return a.v > b.v; }
istream &operator>>(istream &iss, epsdou &a) {
iss >> a.v;
return iss;
}
ostream &operator<<(ostream &os, epsdou &a) {
os << a.v;
return os;
}
#define eps_conr_t(o) \
template <class T> epsdou operator o(T a, epsdou b) { return (dou)a o b.v; }
#define eps_conl_t(o) \
template <class T> epsdou operator o(epsdou a, T b) { return a.v o(dou) b; }
eps_conl_t(+) eps_conl_t(-) eps_conl_t(*) eps_conl_t(/) eps_conr_t(+)
eps_conr_t(-) eps_conr_t(*) eps_conr_t(/)
// template<class U> epsdou max(epsdou a, U b){return a.v>b ? a.v: b;}
// template<class U> epsdou max(U a, epsdou b){return a>b.v ? a: b.v;}
// template<class U> epsdou min(epsdou a, U b){return a.v<b ? a.v: b;}
// template<class U> epsdou min(U a, epsdou b){return a<b.v ? a: b.v;}
#undef double
#define double epsdou
#undef dou
#define dou epsdou
#endif
template <class T = int, class A, class B = int>
auto my_pow(A a, B b = 2) {
#if __cplusplus >= 201703L
if constexpr (is_floating_point<T>::value) {
return pow((T)a, (T)b);
} else if constexpr (is_floating_point<A>::value) {
assert2(
0,
"pow <not dou>(dou, )"); /*return
0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/
} else if constexpr (is_floating_point<B>::value) {
assert2(
0,
"pow <not dou>(, dou)"); /*return
0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/
} else {
#endif
T ret = 1;
T bek = a;
while (b) {
if (b & 1)
ret *= bek;
bek *= bek;
b >>= 1;
}
return ret;
#if __cplusplus >= 201703L
}
#endif
}
#define pow my_pow
#define ull unsigned long long
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
#define fi first
#define se second
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define el else
#define elf else if
#define upd update
#define sstream stringstream
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
#define lam1(ret) [&](auto &&v) { return ret; }
#define lam2(v, ret) [&](auto &&v) { return ret; }
#define lam(...) over2(__VA_ARGS__, lam2, lam1)(__VA_ARGS__)
#define lamr(right) [&](auto &&p) { return p right; }
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
// マクロ省略系 コンテナ
using vi = vector<ll>;
using vb = vector<bool>;
using vs = vector<string>;
using vd = vector<double>;
using vc = vector<char>;
using vp = vector<P>;
using vt = vector<T>;
// #define V vector
#define vvt0(t) vector<vector<t>>
#define vvt1(t, a) vector<vector<t>> a
#define vvt2(t, a, b) vector<vector<t>> a(b)
#define vvt3(t, a, b, c) vector<vector<t>> a(b, vector<t>(c))
#define vvt4(t, a, b, c, d) vector<vector<t>> a(b, vector<t>(c, d))
#define vvi(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(ll, __VA_ARGS__)
#define vvb(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(bool, __VA_ARGS__)
#define vvs(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(string, __VA_ARGS__)
#define vvd(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(double, __VA_ARGS__)
#define vvc(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(char, __VA_ARGS__)
#define vvp(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(P, __VA_ARGS__)
#define vvt(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(T, __VA_ARGS__)
#define vv(type, ...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(type, __VA_ARGS__)
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<ll>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define vn(type, name, ...) auto name = make_v<type>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<ll, ll>;
using mapp = map<P, ll>;
using mapd = map<dou, ll>;
using mapc = map<char, ll>;
using maps = map<str, ll>;
using seti = set<ll>;
using setp = set<P>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define uset unordered_set
#define useti unordered_set<ll, xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
// 任意のマクロサポート用 使う度に初期化する
int index_, v1_, v2_, v3_;
/*@formatter:off*/
string to_string(char c) {
string ret = "";
ret += c;
return ret;
}
template <class T> class pq_min_max {
vector<T> d;
void make_heap() {
for (int i = d.size(); i--;) {
if (i & 1 && d[i - 1] < d[i])
swap(d[i - 1], d[i]);
int k = down(i);
up(k, i);
}
}
inline int parent(int k) const { return ((k >> 1) - 1) & ~1; }
int down(int k) {
int n = d.size();
if (k & 1) { /* min heap*/
while (2 * k + 1 < n) {
int c = 2 * k + 3;
if (n <= c || d[c - 2] < d[c])
c -= 2;
if (c < n && d[c] < d[k]) {
swap(d[k], d[c]);
k = c;
} else
break;
}
} else { /* max heap*/
while (2 * k + 2 < n) {
int c = 2 * k + 4;
if (n <= c || d[c] < d[c - 2])
c -= 2;
if (c < n && d[k] < d[c]) {
swap(d[k], d[c]);
k = c;
} else
break;
}
}
return k;
}
int up(int k, int root = 1) {
if ((k | 1) < (int)d.size() && d[k & ~1] < d[k | 1]) {
swap(d[k & ~1], d[k | 1]);
k ^= 1;
}
int p;
while (root < k && d[p = parent(k)] < d[k]) { /*max heap*/
swap(d[p], d[k]);
k = p;
}
while (root < k && d[k] < d[p = parent(k) | 1]) { /* min heap*/
swap(d[p], d[k]);
k = p;
}
return k;
}
public:
pq_min_max() {}
pq_min_max(const vector<T> &d_) : d(d_) { make_heap(); }
template <class Iter> pq_min_max(Iter first, Iter last) : d(first, last) {
make_heap();
}
void operator+=(const T &x) {
int k = d.size();
d.push_back(x);
up(k);
}
void pop_min() {
if (d.size() < 3u) {
d.pop_back();
} else {
swap(d[1], d.back());
d.pop_back();
int k = down(1);
up(k);
}
}
void pop_max() {
if (d.size() < 2u) {
d.pop_back();
} else {
swap(d[0], d.back());
d.pop_back();
int k = down(0);
up(k);
}
}
const T &get_min() const { return d.size() < 2u ? d[0] : d[1]; }
const T &get_max() const { return d[0]; }
int size() const { return d.size(); }
bool empty() const { return d.empty(); }
};
// 小さいほうからM個取得するpq
template <class T> struct helper_pq_size {
pq_min_max<T> q;
T su = 0;
int max_size = 0;
helper_pq_size() {}
helper_pq_size(int max_size) : max_size(max_size) {}
void clear() {
q = pq_min_max<T>();
su = 0;
}
void operator+=(T v) {
su += v;
q += (v);
if (sz(q) > max_size) {
su -= q.get_max();
q.pop_max();
}
}
T sum() { return su; }
T top() { return q.get_min(); }
void pop() {
su -= q.get_min();
q.pop_min();
}
T poll() {
T ret = q.get_min();
su -= ret;
q.pop_min();
return ret;
}
ll size() { return q.size(); }
};
// 大きいほうからM個取得するpq
template <class T> struct helper_pqg_size {
pq_min_max<T> q;
T su = 0;
int max_size = 0;
helper_pqg_size() {}
helper_pqg_size(int max_size) : max_size(max_size) {}
void clear() {
q = pq_min_max<T>();
su = 0;
}
void operator+=(T v) {
su += v;
q += (v);
if (sz(q) > max_size) {
su -= q.get_min();
q.pop_min();
}
}
T sum() { return su; }
T top() { return q.get_max(); }
void pop() {
su -= q.get_max();
q.pop_max();
}
T poll() {
T ret = q.get_max();
su -= ret;
q.pop_min();
return ret;
}
ll size() { return q.size(); }
};
;
template <class T, class Container = vector<T>,
class Compare = std::less<typename Container::value_type>>
struct helper_pqg {
priority_queue<T, Container, Compare> q; /*小さい順*/
T su = 0;
helper_pqg() {}
void clear() {
q = priority_queue<T, vector<T>, greater<T>>();
su = 0;
}
void operator+=(T v) {
su += v;
q.push(v);
}
T sum() { return su; }
T top() { return q.top(); }
void pop() {
su -= q.top();
q.pop();
}
T poll() {
T ret = q.top();
su -= ret;
q.pop();
return ret;
}
ll size() { return q.size(); }
};
template <class T> using helper_pq = helper_pqg<T, vector<T>, greater<T>>;
#if __cplusplus >= 201703L
// 小さいほうからsize個残る
// Tがoptionalなら空の時nullを返す
template <class T> struct pq {
helper_pq<T> a_q; /*大きい順*/
helper_pq_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pq(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pq_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
// optionalなら空の時nullを返す
T top() {
if constexpr (is_optional<T>::value) {
if (aquery) {
if (sz(a_q) == 0)
return T();
return a_q.top();
} else {
if (sz(b_q) == 0)
return T();
return b_q.top();
}
} else {
if (aquery)
return a_q.top();
else
return b_q.top();
}
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
// optionalなら空の時何もしない
void pop() {
if constexpr (is_optional<T>::value) {
if (aquery) {
if (sz(a_q))
a_q.pop();
} else {
if (sz(b_q))
b_q.pop();
}
} else {
if (aquery)
a_q.pop();
else
b_q.pop();
}
} /*T*/
T poll() {
if constexpr (is_optional<T>::value) {
if (aquery) {
if (sz(a_q) == 0)
return T();
return a_q.poll();
} else {
if (sz(b_q) == 0)
return T();
return b_q.poll();
}
} else {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
/*@formatter:off*/
};
template <class T> struct pqg {
helper_pqg<T> a_q; /*大きい順*/
helper_pqg_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pqg(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pqg_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
T top() {
if (aquery)
return a_q.top();
else
return b_q.top();
}
void pop() {
if (aquery)
a_q.pop();
else
b_q.pop();
}
T poll() {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
};
#else
// 小さいほうからsize個残る
template <class T> struct pq {
helper_pq<T> a_q; /*大きい順*/
helper_pq_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pq(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pq_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
T top() {
if (aquery)
return a_q.top();
else
return b_q.top();
}
void pop() {
if (aquery)
a_q.pop();
else
b_q.pop();
}
T poll() {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
};
// 大きいほうからsize個残る
template <class T> struct pqg {
helper_pqg<T> a_q; /*大きい順*/
helper_pqg_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pqg(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pqg_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
T top() {
if (aquery)
return a_q.top();
else
return b_q.top();
}
void pop() {
if (aquery)
a_q.pop();
else
b_q.pop();
}
T poll() {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
};
#endif
#define pqi pq<ll>
#define pqgi pqg<ll>
template <class T> string deb_tos(pq<T> &q) {
vector<T> res;
auto temq = q;
while (sz(temq))
res.push_back(temq.top()), temq.pop();
stringstream ss;
ss << res;
return ss.str();
}
template <class T> string deb_tos(pqg<T> &q) {
vector<T> res;
auto temq = q;
while (sz(temq))
res.push_back(temq.top()), temq.pop();
stringstream ss;
ss << res;
return ss.str();
}
/*@formatter:off*/
// マクロ 繰り返し
// ↓@オーバーロード隔離
// todo 使わないもの非表示
#define rep1(n) for (ll rep1i = 0, rep1lim = n; rep1i < rep1lim; ++rep1i)
#define rep2(i, n) for (ll i = 0, rep2lim = n; i < rep2lim; ++i)
#define rep3(i, m, n) for (ll i = m, rep3lim = n; i < rep3lim; ++i)
#define rep4(i, m, n, ad) for (ll i = m, rep4lim = n; i < rep4lim; i += ad)
// 逆順 閉区間
#define rer2(i, n) for (ll i = n; i >= 0; i--)
#define rer3(i, m, n) for (ll i = m, rer3lim = n; i >= rer3lim; i--)
#define rer4(i, m, n, dec) for (ll i = m, rer4lim = n; i >= rer4lim; i -= dec)
#ifdef use_for
// ループを一つにまとめないとフォーマットで汚くなるため
#define nex_ind1(i) i++
#define nex_ind2(i, j, J) \
i = (j + 1 == J) ? i + 1 : i, j = (j + 1 == J ? 0 : j + 1)
#define nex_ind3(i, j, k, J, K) \
i = (j + 1 == J && k + 1 == K) ? i + 1 : i, \
j = (k + 1 == K) ? (j + 1 == J ? 0 : j + 1) : j, \
k = (k + 1 == K ? 0 : k + 1)
#define nex_ind4(i, j, k, l, J, K, L) \
i = (j + 1 == J && k + 1 == K && l + 1 == L) ? i + 1 : i, \
j = (k + 1 == K && l + 1 == L) ? (j + 1 == J ? 0 : j + 1) : j, \
k = (l + 1 == L ? (k + 1 == K ? 0 : k + 1) : k), l = l + 1 == L ? 0 : l + 1
#define nex_ind5(i, j, k, l, m, J, K, L, M) \
i = (j + 1 == J && k + 1 == K && l + 1 == L && m + 1 == M) ? i + 1 : i, \
j = (k + 1 == K && l + 1 == L && m + 1 == M) ? (j + 1 == J ? 0 : j + 1) : j, \
k = (l + 1 == L && m + 1 == M ? (k + 1 == K ? 0 : k + 1) : k), \
l = m + 1 == M ? l + 1 == L ? 0 : l + 1 : l, m = m + 1 == M ? 0 : m + 1
#define repss2(i, I) for (int i = 0; i < I; i++)
#define repss4(i, j, I, J) \
for (int i = (J ? 0 : I), j = 0; i < I; nex_ind2(i, j, J))
#define repss6(i, j, k, I, J, K) \
for (int i = (J && K ? 0 : I), j = 0, k = 0; i < I; nex_ind3(i, j, k, J, K))
#define repss8(i, j, k, l, I, J, K, L) \
for (int i = (J && K && L ? 0 : I), j = 0, k = 0, l = 0; i < I; \
nex_ind4(i, j, k, l, J, K, L))
#define repss10(i, j, k, l, m, I, J, K, L, M) \
for (int i = (J && K && L && M ? 0 : I), j = 0, k = 0, l = 0, m = 0; i < I; \
nex_ind5(i, j, k, l, m, J, K, L, M))
// i,j,k...をnまで見る
#define reps2(i, n) repss2(i, n)
#define reps3(i, j, n) repss4(i, j, n, n)
#define reps4(i, j, k, n) repss6(i, j, k, n, n, n)
#define reps5(i, j, k, l, n) repss8(i, j, k, l, n, n, n, n)
template <class T>
void nex_repv2(int &i, int &j, int &I, int &J, vector<vector<T>> &s) {
while (1) {
j++;
if (j >= J) {
j = 0;
i++;
if (i < I) {
J = (int)s[i].size();
}
}
if (i >= I || J)
return;
}
}
template <class T>
void nex_repv3(int &i, int &j, int &k, int &I, int &J, int &K,
vector<vector<vector<T>>> &s) {
while (1) {
k++;
if (k >= K) {
k = 0;
j++;
if (j >= J) {
j = 0;
i++;
if (i >= I)
return;
}
}
J = (int)s[i].size();
K = (int)s[i][j].size();
if (J && K)
return;
}
}
#define repv_2(i, a) repss2(i, sz(a))
// 正方形である必要はない
// 直前を持つのとどっちが早いか
#define repv_3(i, j, a) \
for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), i = 0, j = 0; \
i < repvI; nex_repv2(i, j, repvI, repvJ, a))
// 箱状になっている事が要求される つまり[i] 次元目の要素数は一定
#define repv_4(i, j, k, a) \
for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), \
repvK = (int)a[0][0].size(), i = 0, j = 0, k = 0; \
i < repvI; nex_repv3(i, j, k, repvI, repvJ, repvK, a))
#define repv_5(i, j, k, l, a) \
repss8(i, j, k, l, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]))
#define repv_6(i, j, k, l, m, a) \
repss10(i, j, k, l, m, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]), \
sz(a[0][0][0][0]))
#endif
template <typename T> struct has_rbegin_rend {
private:
template <typename U>
static auto check(U &&obj)
-> decltype(std::rbegin(obj), std::rend(obj), std::true_type{});
static std::false_type check(...);
public:
static constexpr bool value = decltype(check(std::declval<T>()))::value;
};
template <typename T>
constexpr bool has_rbegin_rend_v = has_rbegin_rend<T>::value;
template <typename Iterator> class Range {
public:
Range(Iterator &&begin, Iterator &&end) noexcept
: m_begin(std::forward<Iterator>(begin)),
m_end(std::forward<Iterator>(end)) {}
Iterator begin() const noexcept { return m_begin; }
Iterator end() const noexcept { return m_end; }
private:
const Iterator m_begin;
const Iterator m_end;
};
template <typename Iterator>
static inline Range<Iterator> makeRange(Iterator &&begin,
Iterator &&end) noexcept {
return Range<Iterator>{std::forward<Iterator>(begin),
std::forward<Iterator>(end)};
}
template <typename T>
static inline decltype(auto)
makeReversedRange(const std::initializer_list<T> &iniList) noexcept {
return makeRange(std::rbegin(iniList), std::rend(iniList));
}
template <typename T, typename std::enable_if_t<has_rbegin_rend_v<T>,
std::nullptr_t> = nullptr>
static inline decltype(auto) makeReversedRange(T &&c) noexcept {
return makeRange(std::rbegin(c), std::rend(c));
} /* rbegin(),
rend()を持たないものはこっちに分岐させて，エラーメッセージを少なくする*/
template <typename T, typename std::enable_if<!has_rbegin_rend<T>::value,
std::nullptr_t>::type = nullptr>
static inline void makeReversedRange(T &&) noexcept {
static_assert(has_rbegin_rend<T>::value,
"Specified argument doesn't have reverse iterator.");
}
// #define use_for
#define form1(st) \
for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form3(k, v, st) \
for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form4(k, v, st, r) \
for (auto &&form_it = st.begin(); form_it != st.end() && (*form_it).fi < r; \
++form_it)
#define form5(k, v, st, l, r) \
for (auto &&form_it = st.lower_bound(l); \
form_it != st.end() && (*form_it).fi < r; ++form_it)
#define forrm1(st) \
for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
#define forrm3(k, v, st) \
for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
// 向こう側で
// ++itか it = st.erase(it)とする
#define fors1(st) for (auto &&it = st.begin(); it != st.end();)
#define fors2(v, st) for (auto &&it = st.begin(); it != st.end();)
#define fors3(v, st, r) \
for (auto &&it = st.begin(); it != st.end() && (*it) < r;)
#define fors4(v, st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r;)
#ifdef use_for
#define forslr3(st, a, b) \
for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr4(v, st, a, b) \
for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr5(v, st, r, a, b) \
for (auto &&forslr_it = st.begin(); \
forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define forslr6(v, st, l, r, a, b) \
for (auto &&forslr_it = st.lower_bound(l); \
forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define fora_f_init_2(a, A) ;
#define fora_f_init_3(fora_f_i, a, A) auto &&a = A[fora_f_i];
#define fora_f_init_4(a, b, A, B) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i];
#define fora_f_init_5(fora_f_i, a, b, A, B) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i];
#define fora_f_init_6(a, b, c, A, B, C) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i];
#define fora_f_init_7(fora_f_i, a, b, c, A, B, C) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i];
#define fora_f_init_8(a, b, c, d, A, B, C, D) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i]; \
auto &&d = D[fora_f_i];
#define fora_f_init_9(fora_f_i, a, b, c, d, A, B, C, D) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i]; \
auto &&d = D[fora_f_i];
#define fora_f_init(...) \
over9(__VA_ARGS__, fora_f_init_9, fora_f_init_8, fora_f_init_7, \
fora_f_init_6, fora_f_init_5, fora_f_init_4, fora_f_init_3, \
fora_f_init_2)(__VA_ARGS__)
#define forr_init_2(a, A) auto &&a = A[forr_i];
#define forr_init_3(forr_i, a, A) auto &&a = A[forr_i];
#define forr_init_4(a, b, A, B) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i];
#define forr_init_5(forr_i, a, b, A, B) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i];
#define forr_init_6(a, b, c, A, B, C) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i];
#define forr_init_7(forr_i, a, b, c, A, B, C) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i];
#define forr_init_8(a, b, c, d, A, B, C, D) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i]; \
auto &&d = D[forr_i];
#define forr_init_9(forr_i, a, b, c, d, A, B, C, D) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i]; \
auto &&d = D[forr_i];
#define forr_init(...) \
over9(__VA_ARGS__, forr_init_9, forr_init_8, forr_init_7, forr_init_6, \
forr_init_5, forr_init_4, forr_init_3, forr_init_2)(__VA_ARGS__)
#define forp_init3(k, v, S) \
auto &&k = S[forp_i].first; \
auto &&v = S[forp_i].second;
#define forp_init4(forp_i, k, v, S) \
auto &&k = S[forp_i].first; \
auto &&v = S[forp_i].second;
#define forp_init(...) \
over4(__VA_ARGS__, forp_init4, forp_init3, forp_init2, \
forp_init1)(__VA_ARGS__)
#define form_init(k, v, ...) \
auto &&k = (*form_it).fi; \
auto &&v = (*form_it).se;
#define forrm_init(k, v, ...) \
auto &&k = (*forrm_it).fi; \
auto &&v = (*forrm_it).se;
#define fors_init(v, ...) auto &&v = (*it);
#define forlr_init(a, A, ngl, ngr) \
auto a = A[forlr_i]; \
auto prev = forlr_i ? A[forlr_i - 1] : ngl; \
auto next = forlr_i + 1 < rep2lim ? A[forlr_i + 1] : ngr;
#define forslr_init4(a, A, ngl, ngr) \
auto a = (*forslr_it); \
auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl; \
auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init5(a, A, r, ngl, ngr) \
auto a = (*forslr_it); \
auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl; \
auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init6(a, A, l, r, ngl, ngr) \
auto a = (*forslr_it); \
auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl; \
auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init(...) \
over6(__VA_ARGS__, forslr_init6, forslr_init5, forslr_init4)(__VA_ARGS__);
// こうしないとmapがおかしくなる
#define fora_f_2(a, A) for (auto &&a : A)
#define fora_f_3(fora_f_i, a, A) rep(fora_f_i, sz(A))
#define fora_f_4(a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_5(fora_f_i, a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_6(a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_7(fora_f_i, a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_8(a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define fora_f_9(fora_f_i, a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define forr_2(a, A) rer(forr_i, sz(A) - 1)
#define forr_3(forr_i, a, A) rer(forr_i, sz(A) - 1)
#define forr_4(a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_5(forr_i, a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_6(a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_7(forr_i, a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_8(a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)
#define forr_9(forr_i, a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)
#endif
// ↑@オーバーロード隔離
// rep系はインデックス、for系は中身
#define rep(...) over4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rer(...) over4(__VA_ARGS__, rer4, rer3, rer2, )(__VA_ARGS__)
// 自分込みで残りがREM以上の間ループを回す
#define rem(i, N, REM) for (int i = 0; i < N - REM + 1; i++)
// char用のrep
#define repc(i, m, n) for (char i = m, repc3lim = n; i < repc3lim; ++i)
// i,j,k...をnまで見る
#define reps(...) over5(__VA_ARGS__, reps5, reps4, reps3, reps2, )(__VA_ARGS__)
#define repss(...) \
over10(__VA_ARGS__, repss10, a, repss8, a, repss6, a, repss4, a, \
repss2)(__VA_ARGS__)
// vectorのindexを走査する
// repv(i,j,vvi)
#define repv(...) \
over6(__VA_ARGS__, repv_6, repv_5, repv_4, repv_3, repv_2, )(__VA_ARGS__)
#define rerv(i, A) for (int i = sz(A) - 1; i >= 0; i--)
// repvn(dp) nは次元
#define repv1(a) repv(i, a)
#define repv2(a) repv(i, j, a)
#define repv3(a) repv(i, j, k, a)
#define repv4(a) repv(i, j, k, l, a)
#ifdef use_for
#define fora_f(...) \
over9(__VA_ARGS__, fora_f_9, fora_f_8, fora_f_7, fora_f_6, fora_f_5, \
fora_f_4, fora_f_3, fora_f_2)(__VA_ARGS__)
#endif
#define forr(...) \
over9(__VA_ARGS__, forr_9, forr_8, forr_7, forr_6, forr_5, forr_4, forr_3, \
forr_2)(__VA_ARGS__)
// 0~N-2まで見る
#define forar_init(v, rv, A) \
auto &&v = A[forar_i]; \
auto &&rv = A[forar_i + 1];
#define forar(v, rv, A) rep(forar_i, sz(A) - 1)
#if __cplusplus >= 201703L
template <size_t M_SZ, bool indexed, class Iterator, class T, class U = T,
class V = T, class W = T>
class ite_vec_merge : public Iterator {
std::size_t i = 0;
vector<T> &A;
vector<U> &B;
vector<V> &C;
vector<W> &D;
public:
ite_vec_merge(Iterator ita, vector<T> &A)
: Iterator(ita), A(A), B(A), C(A), D(A) {}
ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B)
: Iterator(ita), A(A), B(B), C(A), D(A) {}
ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C)
: Iterator(ita), A(A), B(B), C(C), D(A) {}
ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C,
vector<W> &D)
: Iterator(ita), A(A), B(B), C(C), D(D) {}
auto &operator++() {
++i;
this->Iterator::operator++();
return *this;
}
auto operator*() const noexcept {
if constexpr (!indexed && M_SZ == 1) {
return tuple<T &>(A[i]);
} else if constexpr (!indexed && M_SZ == 2) {
return tuple<T &, U &>(A[i], B[i]);
} else if constexpr (!indexed && M_SZ == 3) {
return tuple<T &, U &, V &>(A[i], B[i], C[i]);
} else if constexpr (!indexed && M_SZ == 4) {
return tuple<T &, U &, V &, W &>(A[i], B[i], C[i], D[i]);
} else if constexpr (indexed && M_SZ == 1) {
return tuple<int, T &>(i, A[i]);
} else if constexpr (indexed && M_SZ == 2) {
return tuple<int, T &, U &>(i, A[i], B[i]);
} else if constexpr (indexed && M_SZ == 3) {
return tuple<int, T &, U &, V &>(i, A[i], B[i], C[i]);
} else if constexpr (indexed && M_SZ == 4) {
return tuple<int, T &, U &, V &, W &>(i, A[i], B[i], C[i], D[i]);
} else {
assert(0);
return tuple<int>(i);
}
}
};
template <size_t M_SZ, bool indexed, class T, class U = T, class V = T,
class W = T>
class vec_merge {
vector<T> &a;
vector<U> &b;
vector<V> &c;
vector<W> &d;
public:
vec_merge(vector<T> &a) : a(a), b(a), c(a), d(a) {}
vec_merge(vector<T> &a, vector<U> &b) : a(a), b(b), c(a), d(a) {}
vec_merge(vector<T> &a, vector<U> &b, vector<V> &c)
: a(a), b(b), c(c), d(a) {}
vec_merge(vector<T> &a, vector<U> &b, vector<V> &c, vector<W> &d)
: a(a), b(b), c(c), d(d) {}
auto begin() const {
if constexpr (M_SZ == 1) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a};
} else if constexpr (M_SZ == 2) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a, b};
} else if constexpr (M_SZ == 3) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a, b, c};
} else if constexpr (M_SZ == 4) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a, b, c, d};
} else {
assert(0);
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a};
}
}
auto end() const {
if constexpr (M_SZ == 1) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a};
} else if constexpr (M_SZ == 2) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a, b};
} else if constexpr (M_SZ == 3) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a, b, c};
} else if constexpr (M_SZ == 4) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a, b, c, d};
} else {
assert(0);
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a};
}
}
};
#endif
#define fora_2(a, A) for (auto &&a : A)
#if __cplusplus >= 201703L
#define fora_3(i, a, A) for (auto [i, a] : vec_merge<1, true, decl_t(A)>(A))
#define fora_4(a, b, A, B) \
for (auto [a, b] : vec_merge<2, false, decl_t(A), decl_t(B)>(A, B))
#define fora_5(i, a, b, A, B) \
for (auto [i, a, b] : vec_merge<2, true, decl_t(A), decl_t(B)>(A, B))
#define fora_6(a, b, c, A, B, C) \
for (auto [a, b, c] : \
vec_merge<3, false, decl_t(A), decl_t(B), decl_t(C)>(A, B, C))
#define fora_7(i, a, b, c, A, B, C) \
for (auto [i, a, b, c] : \
vec_merge<3, true, decl_t(A), decl_t(B), decl_t(C)>(A, B, C))
#define fora_8(a, b, c, d, A, B, C, D) \
for (auto [a, b, c, d] : \
vec_merge<4, false, decl_t(A), decl_t(B), decl_t(C), decl_t(D)>(A, B, \
C, D))
#define fora_9(i, a, b, c, d, A, B, C, D) \
for (auto [i, a, b, c, d] : \
vec_merge<4, true, decl_t(A), decl_t(B), decl_t(C), decl_t(D)>(A, B, C, \
D))
#endif
// 構造化束縛ver
// 1e5要素で40ms程度
// 遅いときはfora_fを使う
#define fora(...) \
over9(__VA_ARGS__, fora_9, fora_8, fora_7, fora_6, fora_5, fora_4, fora_3, \
fora_2)(__VA_ARGS__)
// #define forr(v, a) for(auto&& v : makeReversedRange(a))
// 参照を取らない
/*@formatter:off*/
#ifdef use_for
template <class U> vector<U> to1d(vector<U> &a) { return a; }
template <class U> auto to1d(vector<vector<U>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
res.push_back(a2);
return res;
}
template <class U> vector<U> to1d(vector<vector<vector<U>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
res.push_back(a3);
return res;
}
template <class U> vector<U> to1d(vector<vector<vector<vector<U>>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
for (auto &&a4 : a3)
res.push_back(a4);
return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<U>>>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
for (auto &&a4 : a3)
for (auto &&a5 : a4)
res.push_back(a5);
return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<vector<U>>>>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
for (auto &&a4 : a3)
for (auto &&a5 : a4)
for (auto &&a6 : a5)
res.push_back(a6);
return res;
}
#define forv(a, b) for (auto a : to1d(b))
// インデックスを前後含めて走査
#define ring(i, s, len) \
for (int i = s, prev = (s == 0) ? len - 1 : s - 1, \
next = (s == len - 1) ? 0 : s + 1, cou = 0; \
cou < len; \
cou++, prev = i, i = next, next = (next == len - 1) ? 0 : next + 1)
// 値と前後を見る
#define ringv(v, d) \
index_ = 0; \
for (auto prev = d[sz(d) - 1], next = (int)d.size() > 1 ? d[1] : d[0], \
v = d[0]; \
index_ < sz(d); index_++, prev = v, v = next, \
next = (index_ >= sz(d) - 1 ? d[0] : d[index_ + 1]))
// 左右をnext prevで見る 0の左と nの右
#define forlr(v, d, banpei_l, banpei_r) rep(forlr_i, sz(d))
#endif
#define form(...) \
over5(__VA_ARGS__, form5, form4, form3, form2, form1)(__VA_ARGS__)
#define forrm(...) \
over5(__VA_ARGS__, forrm5, forrm4, forrm3, forrm2, forrm1)(__VA_ARGS__)
#define fors(...) over4(__VA_ARGS__, fors4, fors3, fors2, fors1)(__VA_ARGS__)
#define forslr(...) \
over6(__VA_ARGS__, forslr6, forslr5, forslr4, forslr3)(__VA_ARGS__)
#define forp3(k, v, st) rep(forp_i, sz(st))
#define forp4(forp_i, k, v, st) rep(forp_i, sz(st))
#define forp(...) over4(__VA_ARGS__, forp4, forp3)(__VA_ARGS__)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const double PI = 3.1415926535897932384626433832795029L;
constexpr bool ev(ll a) { return !(a & 1); }
constexpr bool od(ll a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public
: /*大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断*/
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
} // namespace std
// stream まとめ
/*@formatter:off*/
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec_) {
for (T &x : vec_)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec_) {
for (ll i = 0; i < vec_.size(); ++i)
os << vec_[i] << (i + 1 == vec_.size() ? "" : " ");
return os;
}
template <typename T>
ostream &operator<<(ostream &os, vector<vector<T>> &vec_) {
for (ll i = 0; i < vec_.size(); ++i) {
for (ll j = 0; j < vec_[i].size(); ++j) {
os << vec_[i][j] << " ";
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
os << endl;
for (auto &&v : m)
os << v << endl;
return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> s) {
fora(v, s) { os << v << " "; }
return os;
}
template <class T> ostream &operator<<(ostream &os, mset<T> s) {
fora(v, s) { os << v << " "; }
return os;
}
template <class T> ostream &operator<<(ostream &os, deque<T> a) {
fora(v, a) { os << v << " "; }
return os;
}
ostream &operator<<(ostream &os, vector<vector<char>> &vec_) {
rep(h, sz(vec_)) {
rep(w, sz(vec_[0])) { os << vec_[h][w]; }
os << endl;
}
return os;
}
/*@formatter:off*/
// template<class T,class U>ostream &operator<<(ostream &os, vector<pair<T,U>>&
// a) {fora_f(v,a)os<<v<<endl;return os;}
template <typename W, typename H> void resize(W &vec_, const H head) {
vec_.resize(head);
}
template <typename W, typename H, typename... T>
void resize(W &vec_, const H &head, const T... tail) {
vec_.resize(head);
for (auto &v : vec_)
resize(v, tail...);
}
// #define use_for_each //_each _all_of _any_of _none_of _find_if _rfind_if
// _contains _count_if _erase_if _entry_if
#ifdef use_for_each
// todo Atcoderの過去問がc++17に対応したら
#if __cplusplus >= 201703L
// for_each以外はconst & (呼び出し側のラムダも)
template <typename T, typename F> bool all_of2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : v) {
if (!all_of2(v_, f))
return false;
}
return true;
} else {
return f(v);
}
}
template <typename T, typename F> bool any_of2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : v) {
if (!any_of2(v_, f))
return true;
}
return false;
} else {
return f(v);
}
}
template <typename T, typename F> bool none_of2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : v) {
if (none_of2(v_, f))
return false;
}
return true;
} else {
return f(v);
}
}
// 存在しない場合
// 1次元 Nを返す
// 多次元-1を返す
template <typename T, typename F> ll find_if2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (f(v[i]))
return i;
}
return sz(v);
}
template <typename T, typename F>
tuple<int, int> find_if2(const vector<vector<T>> &v, F f) {
rep(i, sz(v)) {
rep(j, sz(v[i])) {
if (f(v[i][j])) {
return tuple<int, int>(i, j);
}
}
}
return tuple<int, int>(-1, -1);
}
template <typename T, typename F>
auto find_if2(const vector<vector<vector<T>>> &v, F f) {
rep(i, sz(v)) {
if (auto ret = find_if2(v[i], f); get<0>(ret) != -1) {
return tuple_cat(tuple<int>(i), ret);
}
}
auto bad = tuple_cat(tuple<int>(-1), find_if2(v[0], f));
return bad;
}
// 存在しない場合
// 1次元 -1を返す
// 多次元-1を返す
template <typename T, typename F> ll rfind_if2(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (f(v[i]))
return i;
}
return -1;
}
template <typename T, typename F>
tuple<int, int> rfind_if2(const vector<vector<T>> &v, F f) {
rer(i, sz(v) - 1) {
rer(j, sz(v[i]) - 1) {
if (f(v[i][j])) {
return tuple<int, int>(i, j);
}
}
}
return tuple<int, int>(-1, -1);
}
template <typename T, typename F>
auto rfind_if2(const vector<vector<vector<T>>> &v, F f) {
rer(i, sz(v) - 1) {
if (auto ret = rfind_if2(v[i], f); get<0>(ret) != -1) {
return tuple_cat(tuple<int>(i), ret);
}
}
auto bad = tuple_cat(tuple<int>(-1), rfind_if2(v[0], f));
return bad;
}
// todo まとめられそう string,vector全般
template <class T> bool contains(const string &s, const T &v) {
return s.find(v) != string::npos;
}
template <typename T> bool contains(const vector<T> &v, const T &val) {
return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(const vector<T> &v, F f) {
return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
ll ret = 0;
for (auto &&v_ : v) {
ret += count_if2(v_, f);
}
return ret;
} else {
return f(v);
}
}
template <typename T, typename F> void for_each2(T &a, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : a)
for_each2(v_, f);
} else {
f(a);
}
}
#else
template <typename T, typename F> bool all_of2(const T &v, F f) { return f(v); }
template <typename T, typename F> bool all_of2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (!all_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool any_of2(const T &v, F f) { return f(v); }
template <typename T, typename F> bool any_of2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (any_of2(v[i], f))
return true;
}
return false;
}
template <typename T, typename F> bool none_of2(const T &v, F f) {
return f(v);
}
template <typename T, typename F> bool none_of2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (none_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool find_if2(const T &v, F f) {
return f(v);
}
template <typename T, typename F> ll find_if2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (find_if2(v[i], f))
return i;
}
return sz(v);
}
template <typename T, typename F> bool rfind_if2(const T &v, F f) {
return f(v);
}
template <typename T, typename F> ll rfind_if2(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (rfind_if2(v[i], f))
return i;
}
return -1;
}
template <class T> bool contains(const string &s, const T &v) {
return s.find(v) != string::npos;
}
template <typename T> bool contains(const vector<T> &v, const T &val) {
return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(const vector<T> &v, F f) {
return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(const T &v, F f) { return f(v); }
template <typename T, typename F> ll count_if2(const vector<T> &vec_, F f) {
ll ret = 0;
fora(v, vec_) { ret += count_if2(v, f); }
return ret;
}
template <typename T, typename F> void for_each2(T &a, F f) { f(a); }
template <typename T, typename F> void for_each2(vector<T> &a, F f) {
for (auto &&v_ : a)
for_each2(v_, f);
}
#endif
template <typename W> ll count_od(const vector<W> &a) {
return count_if2(a, [](ll v) { return v & 1; });
}
template <typename W> ll count_ev(const vector<W> &a) {
return count_if2(a, [](ll v) { return !(v & 1); });
}
// 削除した後のvectorを返す
template <typename T, typename F> vector<T> erase_if2(const vector<T> &v, F f) {
vector<T> nv;
rep(i, sz(v)) {
if (!f(v[i])) {
nv.push_back(v[i]);
}
}
return nv;
}
template <typename T, typename F>
vector<vector<T>> erase_if2(const vector<vector<T>> &v, F f) {
vector<vector<T>> res;
rep(i, sz(v)) { res[i] = erase_if2(v[i], f); }
return res;
}
template <typename T, typename F> vector<T> entry_if2(const vector<T> &v, F f) {
vector<T> nv;
rep(i, sz(v)) {
if (f(v[i])) {
nv.push_back(v[i]);
}
}
return nv;
}
template <typename T, typename F>
vector<vector<T>> entry_if2(const vector<vector<T>> &v, F f) {
vector<vector<T>> res;
rep(i, sz(v)) { res[i] = entry_if2(v[i], f); }
return res;
}
template <typename T, typename F> ll l_rfind_if(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (f(v[i]))
return i;
}
return -1;
}
template <typename T, typename F> bool l_contains_if(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (f(v[i]))
return true;
}
return false;
}
template <class A, class B, class C> auto t_all_of(A a, B b, C c) {
return std::all_of(a, b, c);
}
template <class A, class B, class C> auto t_any_of(A a, B b, C c) {
return std::any_of(a, b, c);
}
template <class A, class B, class C> auto t_none_of(A a, B b, C c) {
return std::none_of(a, b, c);
}
template <class A, class B, class C> auto t_find_if(A a, B b, C c) {
return std::find_if(a, b, c);
}
template <class A, class B, class C> auto t_count_if(A a, B b, C c) {
return std::count_if(a, b, c);
}
#define all_of_s__2(a, right) (t_all_of(ALL(a), lamr(right)))
#define all_of_s__3(a, v, siki) (t_all_of(ALL(a), [&](auto v) { return siki; }))
#define all_of_s(...) over3(__VA_ARGS__, all_of_s__3, all_of_s__2)(__VA_ARGS__)
// all_of(A, %2);
// all_of(A, a, a%2);
#define all_of__2(a, right) all_of2(a, lamr(right))
#define all_of__3(a, v, siki) all_of2(a, [&](auto v) { return siki; })
#define all_of(...) over3(__VA_ARGS__, all_of__3, all_of__2)(__VA_ARGS__)
#define all_of_f(a, f) all_of2(a, f)
#define any_of_s__2(a, right) (t_any_of(ALL(a), lamr(right)))
#define any_of_s__3(a, v, siki) (t_any_of(ALL(a), [&](auto v) { return siki; }))
#define any_of_s(...) over3(__VA_ARGS__, any_of_s__3, any_of_s__2)(__VA_ARGS__)
#define any_of__2(a, right) any_of2(a, lamr(right))
#define any_of__3(a, v, siki) any_of2(a, [&](auto v) { return siki; })
#define any_of(...) over3(__VA_ARGS__, any_of__3, any_of__2)(__VA_ARGS__)
#define any_of_f(a, f) any_of2(a, f)
#define none_of_s__2(a, right) (t_none_of(ALL(a), lamr(right)))
#define none_of_s__3(a, v, siki) \
(t_none_of(ALL(a), [&](auto v) { return siki; }))
#define none_of_s(...) \
over3(__VA_ARGS__, none_of_s__3, none_of_s__2)(__VA_ARGS__)
#define none_of__2(a, right) none_of2(a, lamr(right))
#define none_of__3(a, v, siki) none_of2(a, [&](auto v) { return siki; })
#define none_of(...) over3(__VA_ARGS__, none_of__3, none_of__2)(__VA_ARGS__)
#define none_of_f(a, f) none_of2(a, f)
#define find_if_s__2(a, right) (t_find_if(ALL(a), lamr(right)) - a.begin())
#define find_if_s__3(a, v, siki) \
(t_find_if(ALL(a), [&](auto v) { return siki; }) - a.begin())
#define find_if_s(...) \
over3(__VA_ARGS__, find_if_s__3, find_if_s__2)(__VA_ARGS__)
#define find_if__2(a, right) find_if2(a, lamr(right))
#define find_if__3(a, v, siki) find_if2(a, [&](auto v) { return siki; })
#define find_if(...) over3(__VA_ARGS__, find_if__3, find_if__2)(__VA_ARGS__)
#define find_if_f(a, f) find_if2(a, f)
#define rfind_if_s__2(a, right) l_rfind_if(a, lamr(right))
#define rfind_if_s__3(a, v, siki) l_rfind_if(a, [&](auto v) { return siki; })
#define rfind_if_s(...) \
over3(__VA_ARGS__, rfind_if_s__3, rfind_if_s__2)(__VA_ARGS__)
#define rfind_if__2(a, right) rfind_if2(a, lamr(right))
#define rfind_if__3(a, v, siki) rfind_if2(a, [&](auto v) { return siki; })
#define rfind_if(...) over3(__VA_ARGS__, rfind_if__3, rfind_if__2)(__VA_ARGS__)
#define rfind_if_f(a, f) rfind_if2(a, f)
#define contains_if_s__2(a, right) l_contains_if(a, lamr(right))
#define contains_if_s__3(a, v, siki) \
l_contains_if(a, [&](auto v) { return siki; })
#define contains_if_s(...) \
over3(__VA_ARGS__, contains_if_s__3, contains_if_s__2)(__VA_ARGS__)
#define contains_if__2(a, right) contains_if2(a, lamr(right))
#define contains_if__3(a, v, siki) contains_if2(a, [&](auto v) { return siki; })
#define contains_if(...) \
over3(__VA_ARGS__, contains_if__3, contains_if__2)(__VA_ARGS__)
#define contains_if_f(a, f) contains_if2(a, f)
#define count_if_s__2(a, right) (t_count_if(ALL(a), lamr(right)))
#define count_if_s__3(a, v, siki) \
(t_count_if(ALL(a), [&](auto v) { return siki; }))
#define count_if_s(...) \
over3(__VA_ARGS__, count_if_s__3, count_if_s__2)(__VA_ARGS__)
#define count_if__2(a, right) count_if2(a, lamr(right))
#define count_if__3(a, v, siki) count_if2(a, [&](auto v) { return siki; })
#define count_if(...) over3(__VA_ARGS__, count_if__3, count_if__2)(__VA_ARGS__)
#define count_if_f(a, f) count_if2(a, f)
// vector<vi>で、viに対して操作
#define for_each_s__2(a, right) \
do { \
fora(v, a) { v right; } \
} while (0)
#define for_each_s__3(a, v, shori) \
do { \
fora(v, a) { shori; } \
} while (0)
#define for_each_s(...) \
over3(__VA_ARGS__, for_each_s__3, for_each_s__2)(__VA_ARGS__)
// vector<vi>で、intに対して操作
#define for_each__2(a, right) for_each2(a, lamr(right))
#define for_each__3(a, v, shori) for_each2(a, [&](auto &v) { shori; })
#define for_each(...) over3(__VA_ARGS__, for_each__3, for_each__2)(__VA_ARGS__)
#define for_each_f(a, f) for_each2(a, f);
template <class T, class F> vector<T> help_for_eached(const vector<T> &A, F f) {
vector<T> ret = A;
for_each(ret, v, f(v));
return ret;
}
#define for_eached__2(a, right) help_for_eached(a, lamr(right))
#define for_eached__3(a, v, shori) help_for_eached(a, lam(v, shori))
#define for_eached(...) \
over3(__VA_ARGS__, for_eached__3, for_eached__2)(__VA_ARGS__)
#define for_eached_f(a, f) for_eached2(a, f);
#define each for_each
#define eached for_eached
// #define erase_if_s__2(a, right) l_erase_if2(a,lamr(right))
// #define erase_if_s__3(a, v, siki) l_erase_if2(a,[&](auto v){return siki;})
// #define erase_if_s(...)
// over3(__VA_ARGS__,erase_if_s__3,erase_if_s__2)(__VA_ARGS__)
#define erase_if__2(a, right) erase_if2(a, lamr(right))
#define erase_if__3(a, v, siki) erase_if2(a, [&](auto v) { return siki; })
#define erase_if(...) over3(__VA_ARGS__, erase_if__3, erase_if__2)(__VA_ARGS__)
#define erase_if_f(a, f) erase_if2(a, f)
// #define entry_if_s__2(a, right) l_entry_if2(a,lamr(right))
// #define entry_if_s__3(a, v, siki) l_entry_if2(a,[&](auto v){return siki;})
// #define entry_if_s(...)
// over3(__VA_ARGS__,entry_if_s__3,entry_if_s__2)(__VA_ARGS__)
#define entry_if__2(a, right) entry_if2(a, lamr(right))
#define entry_if__3(a, v, siki) entry_if2(a, [&](auto v) { return siki; })
#define entry_if(...) over3(__VA_ARGS__, entry_if__3, entry_if__2)(__VA_ARGS__)
#define entry_if_f(a, f) entry_if2(a, f)
#endif
/*@formatter:off*/
template <class T, class U, class W> void replace(vector<W> &a, T key, U v) {
rep(i, sz(a)) if (a[i] == key) a[i] = v;
}
template <class T, class U, class W>
void replace(vector<vector<W>> &A, T key, U v) {
rep(i, sz(A)) replace(A[i], key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(ALL(a), key), a.end());
}
void replace(str &a, char key, char v) { replace(ALL(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
void replace(str &a) {
int dec = 0;
if ('a' <= a[0] && a[0] <= 'z')
dec = 'a';
if ('A' <= a[0] && a[0] <= 'Z')
dec = 'A';
fora(v, a) { v -= dec; }
}
void replace(str &a, str key, str v) {
stringstream t;
ll kn = sz(key);
std::string::size_type Pos(a.find(key));
ll l = 0;
while (Pos != std::string::npos) {
t << a.substr(l, Pos - l);
t << v;
l = Pos + kn;
Pos = a.find(key, Pos + kn);
}
t << a.substr(l, sz(a) - l);
a = t.str();
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(ALL(a), ALL(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(ALL(a));
}
vi iota(ll s, ll len) {
vi ve(len);
iota(ALL(ve), s);
return ve;
}
template <class A, class B> auto vtop(vector<A> &a, vector<B> &b) {
assert(sz(a) == sz(b)); /*stringを0で初期化できない */
vector<pair<A, B>> res;
rep(i, sz(a)) res.eb(a[i], b[i]);
return res;
}
template <class A, class B>
void ptov(vector<pair<A, B>> &p, vector<A> &a, vector<B> &b) {
a.resize(sz(p)), b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <class A, class B, class C>
auto vtot(vector<A> &a, vector<B> &b, vector<C> &c) {
assert(sz(a) == sz(b) && sz(b) == sz(c));
vector<T2<A, B, C>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i]);
return res;
}
template <class A, class B, class C, class D>
auto vtof(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
assert(sz(a) == sz(b) && sz(b) == sz(c) && sz(c) == sz(d));
vector<F2<A, B, C, D>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i], d[i]);
return res;
}
/*@formatter:off*/
template <class T> void sort(vector<T> &a, int l = -1, int r = -1) {
set_lr12(l, r, sz(a));
fast_sort(a.begin() + l, a.begin() + r);
}
template <class T> void rsort(vector<T> &a, int l = -1, int r = -1) {
set_lr12(l, r, sz(a));
fast_sort(a.begin() + l, a.begin() + r, greater<T>());
};
template <class A, class B> void sortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
sort(c);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B> void rsortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
rsort(c);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
sort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
rsort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class... T, class U> auto sorted(U head, T... a) {
sort(head, a...);
return head;
}
template <class... T, class U> auto rsorted(U head, T... a) {
rsort(head, a...);
return head;
}
// sortindex 元のvectorはソートしない
template <class T> vi sorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind);
return ind;
}
// #define use_sort
#ifdef use_sort
enum pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
enum tcomparator {
fisiti,
fisitd,
fisdti,
fisdtd,
fdsiti,
fdsitd,
fdsdti,
fdsdtd,
fitisi,
fitisd,
fitdsi,
fitdsd,
fdtisi,
fdtisd,
fdtdsi,
fdtdsd,
sifiti,
sifitd,
sifdti,
sifdtd,
sdfiti,
sdfitd,
sdfdti,
sdfdtd,
sitifi,
sitifd,
sitdfi,
sitdfd,
sdtifi,
sdtifd,
sdtdfi,
sdfdfd,
tifisi,
tifisd,
tifdsi,
tifdsd,
tdfisi,
tdfisd,
tdfdsi,
tdfdsd,
tisifi,
tisifd,
tisdfi,
tisdfd,
tdsifi,
tdsifd,
tdsdfi,
tdsdfd
};
template <class A, class B> void sort(vector<pair<A, B>> &a, pcomparator type) {
typedef pair<A, B> U;
if (type == fisi)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
else if (type == fisd)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
else if (type == fdsi)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
else if (type == fdsd)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
else if (type == sifi)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
else if (type == sifd)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
else if (type == sdfi)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
else if (type == sdfd)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
};
template <class U> void sort(vector<U> &a, pcomparator type) {
if (type == fisi)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
else if (type == fisd)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
else if (type == fdsi)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
else if (type == fdsd)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
else if (type == sifi)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
else if (type == sifd)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
else if (type == sdfi)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
else if (type == sdfd)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
};
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, pcomparator type) {
typedef F2<A, B, C, D> U;
if (type == fisi)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b < r.b; });
else if (type == fisd)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b > r.b; });
else if (type == fdsi)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b < r.b; });
else if (type == fdsd)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b > r.b; });
else if (type == sifi)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a < r.a; });
else if (type == sifd)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a > r.a; });
else if (type == sdfi)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a < r.a; });
else if (type == sdfd)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a > r.a; });
};
template <class U> void sort(vector<U> &a, tcomparator type) {
if (type == 0)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 1)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 2)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 3)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 4)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 5)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 6)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 7)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 8)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 9)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 10)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 11)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 12)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 13)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 14)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 15)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 16)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 17)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 18)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 19)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 20)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 21)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 22)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 23)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 24)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 25)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 26)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 27)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 28)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 29)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 30)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 31)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 32)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 33)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 34)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 35)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 36)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 37)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 38)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 39)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 40)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 41)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 42)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 43)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
else if (type == 44)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 45)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 46)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 47)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
}
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, tcomparator type) {
typedef F2<A, B, C, D> U;
if (type == 0)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 1)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 2)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 3)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 4)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 5)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 6)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 7)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 8)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 9)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 10)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 11)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 12)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 13)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 14)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 15)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 16)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 17)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 18)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 19)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 20)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 21)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 22)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 23)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 24)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 25)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 26)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 27)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 28)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 29)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 30)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 31)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 32)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 33)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 34)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 35)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 36)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 37)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 38)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 39)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 40)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 41)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 42)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 43)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
else if (type == 44)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 45)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 46)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 47)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
}
/*@formatter:off*/
void sort(string &a) { sort(ALL(a)); }
void rsort(string &a) { sort(RALL(a)); }
void sort(int &a, int &b) {
if (a > b)
swap(a, b);
}
void sort(int &a, int &b, int &c) {
sort(a, b);
sort(a, c);
sort(b, c);
}
void rsort(int &a, int &b) {
if (a < b)
swap(a, b);
}
void rsort(int &a, int &b, int &c) {
rsort(a, b);
rsort(a, c);
rsort(b, c);
}
// P l, P rで f(P) の形で渡す
template <class U, class F> void sort(vector<U> &a, F f) {
sort(ALL(a), [&](U l, U r) { return f(l) < f(r); });
};
template <class U, class F> void rsort(vector<U> &a, F f) {
sort(ALL(a), [&](U l, U r) { return f(l) > f(r); });
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class A, class B, class F>
void sortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
sort(c, f);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B, class F>
void rsortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
rsort(c, f);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C, class F>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
sort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
rsort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class D>
void sortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
sort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
template <class A, class B, class C, class D>
void rsortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
rsort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
/*indexの分で型が変わるためpcomparatorが必要*/
template <class T> vi sorti(vector<T> &a, pcomparator f) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind, f);
return ind;
}
template <class T, class F> vi sorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(a[x]) < f(a[y]); });
return ind;
}
template <class T> vi rsorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
rsortp(b, ind);
return ind;
}
template <class T, class F> vi rsorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(a[x]) > f(a[y]); });
return ind;
}
template <class A, class B, class F>
vi sortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(c[x]) < f(c[y]); });
return ind;
}
template <class A, class B>
vi sortpi(vector<A> &a, vector<B> &b, pcomparator f) {
vi ind = iota(0, sz(a));
auto c = a;
auto d = b;
sortt(c, d, ind, f);
return ind;
}
template <class A, class B> vi sortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fisi);
};
template <class A, class B, class F>
vi rsortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(c[x]) > f(c[y]); });
return ind;
}
template <class A, class B> vi rsortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fdsd);
};
template <class A, class B, class C, class F>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(d[x]) < f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, pcomparator f) {
vi ind = iota(0, sz(a));
auto d = vtof(a, b, c, ind);
sort(d, f);
rep(i, sz(a)) ind[i] = d[i].d;
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] < c[y];
else
return b[x] < b[y];
} else {
return a[x] < a[y];
}
});
return ind;
}
template <class A, class B, class C, class F>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(d[x]) > f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] > c[y];
else
return b[x] > b[y];
} else {
return a[x] > a[y];
}
});
return ind;
}
template <class T> void sort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
rsort(a[i]);
}
#endif
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(c);
sort(d);
return includes(ALL(c), ALL(d));
}
template <class T> bool distinct(const vector<T> &A) {
if ((int)(A).size() == 1)
return true;
if ((int)(A).size() == 2)
return A[0] != A[1];
if ((int)(A).size() == 3)
return (A[0] != A[1] && A[1] != A[2] && A[0] != A[2]);
auto B = A;
sort(B);
int N = (B.size());
unique(B);
return N == (int)(B.size());
}
template <class H, class... T> bool distinct(const H &a, const T &...b) {
return distinct(vector<H>{a, b...});
}
/*@formatter:off*/
template <typename W, typename T> void fill(W &xx, const T vall) { xx = vall; }
template <typename W, typename T> void fill(vector<W> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
template <typename W, typename T> void fill(vector<W> &xx, const T v, ll len) {
rep(i, len) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<W> &xx, const T v, int s, ll t) {
rep(i, s, t) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<vector<W>> &xx, T v, int sh, int th, int sw, int tw) {
rep(h, sh, th) rep(w, sw, tw) xx[h][w] = v;
}
// #define use_fill //_sum _array _max _min
#ifdef use_fill
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, const vi &ind, U val) {
fora(v, ind) { a[v] = val; }
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
template <typename A, size_t N> A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
#endif
/*@formatter:off*/
template <class T, class U> void inc(pair<T, U> &a, U v = 1) {
a.first += v, a.second += v;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U = int> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U = int> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class U> void dec(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, W v = 1) {
for (auto &u : a)
dec(u, v);
for (auto &u : b)
dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, vector<W> &c) {
for (auto &u : a)
dec(u, 1);
for (auto &u : b)
dec(u, 1);
for (auto &u : c)
dec(u, 1);
}
bool ins(ll h, ll w, ll H, ll W) { return h >= 0 && w >= 0 && h < H && w < W; }
bool san(ll l, ll v, ll r) { return l <= v && v < r; }
template <class T> bool ins(vector<T> &a, ll i, ll j = 0) {
return san(0, i, sz(a)) && san(0, j, sz(a));
}
#define inside ins
ll u0(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u0(vector<T> &a) {
vector<T> ret = a;
fora(v, ret) { v = u(v); }
return ret;
}
// todo 名前
bool d_(int a, int b) {
if (b == 0)
return false;
return (a % b) == 0;
}
// エラー
void ole() {
#ifdef _DEBUG
cerr << "ole" << endl;
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re(string s = "") {
cerr << s << endl;
assert(0 == 1);
exit(0);
}
void tle() {
while (inf)
cout << inf << endl;
}
//@汎用便利関数 入力
ll in() {
ll ret;
cin >> ret;
return ret;
}
template <class T> T in() {
T ret;
cin >> ret;
return ret;
}
string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> void in(T &head) { cin >> head; }
template <class T, class... U> void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
// value_typeを持つ場合呼べる
// len回要素を追加する
template <class Iterable, class T = typename Iterable::value_type>
Iterable tin(int len) {
Iterable ret;
T tem;
while (len--) {
cin >> tem;
ret += tem;
}
return ret;
}
template <class T> T tin() {
T ret;
cin >> ret;
return ret;
}
template <class T> T tind(int len = 0) {
auto ret = tin<T>(len);
dec(ret, 1);
return ret;
}
#define din_t2(type, a) \
type a; \
cin >> a
#define din_t3(type, a, b) \
type a, b; \
cin >> a >> b
#define din_t4(type, a, b, c) \
type a, b, c; \
cin >> a >> b >> c
#define din_t5(type, a, b, c, d) \
type a, b, c, d; \
cin >> a >> b >> c >> d
#define din_t6(type, a, b, c, d, e) \
type a, b, c, d, e; \
cin >> a >> b >> c >> d >> e
#define din_t7(type, a, b, c, d, e, f) \
type a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f
#define din_t(...) \
over7(__VA_ARGS__, din_t7, din_t6, din_t5, din_t4, din_t3, \
din_t2)(__VA_ARGS__)
#define din(...) din_t(int, __VA_ARGS__)
#define d_in
#define dsig(...) din_t(signed, __VA_ARGS__)
#define dst(...) din_t(string, __VA_ARGS__)
#define dstr dst
#define d_str dst
#define dcha(...) din_t(char, __VA_ARGS__)
#define dchar dcha
#define ddou(...) din_t(double, __VA_ARGS__)
#define din1d(a) \
din_t2(int, a); \
a--
#define din2d(a, b) \
din_t3(int, a, b); \
a--, b--
#define din3d(a, b, c) \
din_t4(int, a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din_t5(int, a, b, c, d); \
a--, b--, c--, d--
#define dind(...) over4(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
/*@formatter:off*/
#ifdef _DEBUG
template <class T> void err2(T &&head) { cerr << head; }
template <class T, class... U> void err2(T &&head, U &&...tail) {
cerr << head << " ";
err2(tail...);
}
template <class T, class... U> void err(T &&head, U &&...tail) {
cerr << head << " ";
err2(tail...);
cerr << "" << endl;
}
template <class T> void err(T &&head) { cerr << head << endl; }
void err() { cerr << "" << endl; }
// debで出力する最大長
constexpr int DEB_LEN = 20;
constexpr int DEB_LEN_H = 12;
string deb_tos(const int &v) {
if (abs(v) == inf || abs(v) == linf)
return "e";
else
return to_string(v);
}
template <class T> string deb_tos(const T &a) {
stringstream ss;
ss << a;
return ss.str();
}
#ifdef use_epsdou
string deb_tos(const epsdou &a) { return deb_tos(a.v); }
#endif
template <class T> string deb_tos(const optional<T> &a) {
if (a.has_value()) {
return deb_tos(a.value());
} else
return "e";
}
template <class T> string deb_tos(const vector<T> &a, ll W = inf) {
stringstream ss;
if (W == inf)
W = min(sz(a), DEB_LEN);
if (sz(a) == 0)
return ss.str();
rep(i, W) {
ss << deb_tos(a[i]);
if (typeid(a[i]) == typeid(P)) {
ss << endl;
} else {
ss << " ";
}
}
return ss.str();
}
template <class T>
string deb_tos(const vector<vector<T>> &a, vi H, vi W, int key = -1) {
stringstream ss;
ss << endl;
vi lens(sz(W));
fora(h, H) {
rep(wi, sz(W)) {
lens[wi] = max(lens[wi], sz(deb_tos(a[h][W[wi]])) + 1);
lens[wi] = max(lens[wi], sz(deb_tos(W[wi])) + 1);
}
}
if (key == -1)
ss << " *|";
else
ss << " " << key << "|";
int wi = 0;
fora(w, W) {
ss << std::right << std::setw(lens[wi]) << w;
wi++;
}
ss << "" << endl;
rep(i, sz(W)) rep(lens[i]) ss << "_";
rep(i, 3) ss << "_";
ss << "" << endl;
fora(h, H) {
ss << std::right << std::setw(2) << h << "|";
int wi = 0;
fora(w, W) {
ss << std::right << std::setw(lens[wi]) << deb_tos(a[h][w]);
wi++;
}
ss << "" << endl;
}
return ss.str();
}
template <class T>
string deb_tos(const vector<vector<T>> &a, ll H = inf, ll W = inf,
int key = -1) {
H = (H != inf) ? H : min({H, sz(a), DEB_LEN_H});
W = min({W, sz(a[0]), DEB_LEN_H});
vi hs, ws;
rep(h, H) { hs.push_back(h); }
rep(w, W) { ws.push_back(w); }
return deb_tos(a, hs, ws, key);
}
template <class T>
string deb_tos(const vector<vector<vector<T>>> &a, ll H = inf) {
stringstream ss;
if (H == inf)
H = DEB_LEN_H;
H = min(H, sz(a));
rep(i, H) {
ss << endl;
ss << deb_tos(a[i], inf, inf, i);
}
return ss.str();
}
template <class T>
string deb_tos(vector<set<T>> &a, ll H = inf, ll W = inf, int key = -1) {
vector<vector<T>> b(sz(a));
rep(i, sz(a)) {
fora(v, a[i]) { b[i].push_back(v); }
}
return deb_tos(b, H, W, key);
}
template <class T, size_t A> string deb_tos(T (&a)[A]) {
return deb_tos(vector<T>(begin(a), end(a)));
}
template <class T, size_t A, size_t B> string deb_tos(T (&a)[A][B]) {
return deb_tos(vector<vector<T>>(begin(a), end(a)));
}
template <class T, size_t A, size_t B, size_t C>
string deb_tos(T (&a)[A][B][C]) {
return deb_tos(vector<vector<vector<T>>>(begin(a), end(a)));
}
/*@formatter:off*/
template <class T> void out2(T head) {
cout << head;
res_mes += deb_tos(head);
}
template <class T, class... U> void out2(T head, U... tail) {
cout << head << " ";
res_mes += deb_tos(head) + " ";
out2(tail...);
}
template <class T, class... U> void out(T head, U... tail) {
cout << head << " ";
res_mes += deb_tos(head) + " ";
out2(tail...);
cout << "" << endl;
res_mes += "\n";
}
template <class T> void out(T head) {
cout << head << endl;
res_mes += deb_tos(head) + "\n";
}
void out() { cout << "" << endl; }
#else
#define err(...) ;
template <class T> void out2(T &&head) { cout << head; }
template <class T, class... U> void out2(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
}
template <class T, class... U> void out(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
cout << "" << endl;
}
template <class T> void out(T &&head) { cout << head << endl; }
void out() { cout << "" << endl; }
#endif
template <class T> void outl(const vector<T> &a, int n = inf) {
rep(i, min(n, sz(a))) cout << a[i] << endl;
}
// テーブルをスペースなしで出力
template <class T> void outt(vector<vector<T>> &a) {
rep(i, sz(a)) {
rep(j, sz(a[i])) { cout << a[i][j]; }
cout << endl;
}
}
// int型をbit表記で出力
void outb(int a) { cout << bitset<20>(a) << endl; }
/*@formatter:off*/
template <class T> void na(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i];
}
template <class T> void na(set<T> &a, ll n) { rep(i, n) a.insert(in()); }
#define dna(a, n) \
vi a; \
na(a, n); /*nを複数使うと n==in()の時バグる事に注意*/
#define dnad(a, n) \
vi a; \
nad(a, n);
template <class T> void nao(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1];
}
template <class T> void naod(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1], a[i + 1]--;
}
template <class T> void nad(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i], a[i]--;
}
template <class T> void nad(set<T> &a, ll n) { rep(i, n) a.insert(in() - 1); }
template <class T, class U> void na2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i];
}
template <class T, class U> void na2(set<T> &a, set<U> &b, ll n) {
rep(i, n) {
a.insert(in());
b.insert(in());
}
}
#define dna2(a, b, n) \
vi a, b; \
na2(a, b, n);
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n + 1);
b.resize(n + 1);
a[0] = b[0] = 0;
rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i], a[i]--, b[i]--;
}
#define dna2d(a, b, n) \
vi a, b; \
na2d(a, b, n);
template <class T, class U, class W>
void na3(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
}
#define dna3(a, b, c, n) \
vi a, b, c; \
na3(a, b, c, n);
template <class T, class U, class W>
void na3d(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i], a[i]--, b[i]--, c[i]--;
}
#define dna3d(a, b, c, n) \
vi a, b, c; \
na3d(a, b, c, n);
template <class T, class U, class W, class X>
void na4(vector<T> &a, vector<U> &b, vector<W> &c, vector<X> &d, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
d.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
}
#define dna4(a, b, c, d, n) \
vi a, b, c, d; \
na4(a, b, c, d, n);
#define dna4d(a, b, c, d, n) \
vi a, b, c, d; \
na4d(a, b, c, d, n);
#define nt(a, h, w) \
resize(a, h, w); \
rep(nthi, h) rep(ntwi, w) cin >> a[nthi][ntwi];
#define ntd(a, h, w) \
resize(a, h, w); \
rep(ntdhi, h) rep(ntdwi, w) cin >> a[ntdhi][ntdwi], a[ntdhi][ntdwi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(ntphi, 1, h + 1) rep(ntpwi, 1, w + 1) cin >> a[ntphi][ntpwi];
#define dnt(S, h, w) \
vvi(S, h, w); \
nt(S, h, w);
#define dntc(S, h, w) \
vvc(S, h, w); \
nt(S, h, w);
#define dnts(S, h, w) \
vvs(S, h, w); \
nt(S, h, w);
// デバッグ
#define sp << " " <<
/*@formatter:off*/
#define deb1(x) debugName(x) << " = " << deb_tos(x)
#define deb_2(x, ...) deb1(x) << ", " << deb1(__VA_ARGS__)
#define deb_3(x, ...) deb1(x) << ", " << deb_2(__VA_ARGS__)
#define deb_4(x, ...) deb1(x) << ", " << deb_3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) << ", " << deb_4(__VA_ARGS__)
#define deb6(x, ...) deb1(x) << ", " << deb5(__VA_ARGS__)
// #define deb7(x, ...) deb1(x) <<", "<< deb6(__VA_ARGS__)
// #define deb8(x, ...) deb1(x) <<", "<< deb7(__VA_ARGS__)
// #define deb9(x, ...) deb1(x) <<", "<< deb8(__VA_ARGS__)
// #define deb10(x, ...) deb1(x) <<", "<< deb9(__VA_ARGS__)
/*@formatter:off*/
#ifdef _DEBUG
bool was_deb = false;
#define deb(...) \
do { \
was_deb = true; \
cerr << over10(__VA_ARGS__, deb10, deb9, deb8, deb7, deb6, deb5, deb_4, \
deb_3, deb_2, deb1)(__VA_ARGS__) \
<< endl; \
} while (0)
#define base_keta 8
void print_n_base(int x, int base) { cerr << bitset<base_keta>(x) << endl; }
template <class T> void print_n_base(vector<T> X, int base) {
cerr << endl;
for (auto &&x : X) {
print_n_base(x, base);
}
cerr << endl;
}
// n進数
#define deb2(x) \
was_deb = true; \
cerr << debugName(x) << " = "; \
print_n_base(x, 2);
#define deb3(x) \
was_deb = true; \
cerr << debugName(x) << " = "; \
print_n_base(x, 3);
#define deb4(x) \
was_deb = true; \
cerr << debugName(x) << " = "; \
print_n_base(x, 4);
#define deb_ex_deb(x, len) debugName(x) << " = " << deb_tos(x, len)
#define call_deb_ex_deb(x, len) deb_ex_deb(x, len)
// 要素が存在する行だけ出力(vvt)
#define deb_ex(v) \
do { \
int N = sz(v); \
int s = N; \
int t = 0; \
rep(i, N) { \
if (sz(v[i])) { \
chmi(s, i); \
chma(t, i); \
} \
} \
auto ex_v = sub(v, s, N); \
str S = deb_tos(ex_v, sz(ex_v)); \
debugName(v); \
cerr << " = " << endl; \
cerr << S << endl; \
} while (0);
#define debi(A) \
{ \
int len = min(sz(A), 20); \
was_deb = true; \
cerr << debugName(A) << " = " << endl; \
rep(i, len) cerr << std::right \
<< std::setw((int)(sz(tos(A[i])) + (i ? 1 : 0))) \
<< (i % 10); \
cerr << endl; \
rep(i, len) cerr << std::right \
<< std::setw((int)(sz(tos(A[i])) + (i ? 1 : 0))) << A[i]; \
cerr << endl; \
}
template <class T, class F>
string deb_tos_f(vector<vector<T>> &a, F f, int key = -1) {
vi hs, ws_;
int H = sz(a), W = sz(a[0]);
vi exh(H), exw(W);
rep(h, H) {
rep(w, W) {
if (f(a[h][w])) {
exh[h] = true;
exw[w] = true;
}
}
}
rep(h, H) if (exh[h]) hs.push_back(h);
rep(w, W) if (exw[w]) ws_.push_back(w);
return deb_tos(a, hs, ws_, key);
}
template <class T, class F>
string deb_tos_f(vector<vector<vector<T>>> &a, F f) {
stringstream ss;
int H = sz(a);
if (sz(a) == 0)
return ss.str();
rep(i, H) { ss << deb_tos_f(a[i], f, i); }
ss << "" << endl;
return ss.str();
}
#define debf_normal(tab, f) \
do { \
cerr << debugName(tab) << " = " << endl; \
cerr << deb_tos_f(tab, f) << endl; \
} while (0);
#define debf2(tab, siki_r) debf_normal(tab, lamr(siki_r))
#define debf3(tab, v, siki) debf_normal(tab, lam(siki))
// S, sikir
// S, v, siki
#define debf(...) over3(__VA_ARGS__, debf3, debf2, debf1)(__VA_ARGS__)
#else
#define deb(...) ;
#define deb2(...) ;
#define deb3(...) ;
#define deb4(...) ;
#define deb_ex(...) ;
#define debf(...) ;
#define debi(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
/*@formatter:off*/
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;
using bint = __int128;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t 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 = '-';
}
ll len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 to_bint(string &s) {
__int128 ret = 0;
for (ll i = 0; i < (ll)s.length(); ++i)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
void operator>>(istream &iss, bint &v) {
string S;
iss >> S;
v = 0;
rep(i, sz(S)) {
v *= 10;
v += S[i] - '0';
}
}
// 便利関数
/*@formatter:off*/
// テスト用
#define rand xor128_
unsigned long xor128_(void) {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
char ranc() { return (char)('a' + rand() % 26); }
ll rand(ll min, ll max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
if (rand() % 2) {
return rand(0, max);
} else {
return -rand(0, -min);
}
}
}
ll rand(ll max) { return rand(0, max); }
template <class T> T rand(vector<T> &A) { return A[rand(sz(A) - 1)]; }
// 重複することがある
template <class T> vector<T> ranv(vector<T> &A, int N) {
vector<T> ret(N);
rep(i, N) { ret[i] = rand(A); }
return ret;
}
template <class T> vector<T> ranv_unique(vector<T> &A, int N) {
vector<T> ret(N);
umapi was;
rep(j, N) {
int i;
while (1) {
i = rand(sz(A) - 1);
if (was.find(i) == was.end())
break;
}
ret[j] = A[i];
was[i] = 1;
}
return ret;
}
vi ranv(ll n, ll min, ll max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
/*@formatter:off*/
#ifdef _DEBUG
bool timeup(int time) {
static bool never = true;
if (never)
message += "may timeup, because slow";
never = false;
auto end_time = system_clock::now();
auto part = duration_cast<milliseconds>(end_time - start_time);
auto lim = milliseconds(time);
return part >= lim;
}
#else
bool timeup(int time) {
auto end_time = system_clock::now();
auto part = duration_cast<milliseconds>(end_time - start_time);
auto lim = milliseconds(time);
return part >= lim;
}
#endif
void set_time() { past_time = system_clock::now(); }
// MS型(millisecqnds)で返る
// set_timeをしてからの時間
auto calc_time_milli() {
auto now = system_clock::now();
auto part = duration_cast<milliseconds>(now - past_time);
return part;
}
auto calc_time_micro() {
auto now = system_clock::now();
auto part = duration_cast<microseconds>(now - past_time);
return part;
}
auto calc_time_nano() {
auto now = system_clock::now();
auto part = duration_cast<nanoseconds>(now - past_time);
return part;
}
bool calc_time(int zikan) { return calc_time_micro() >= microseconds(zikan); }
using MS = std::chrono::microseconds;
int div(microseconds a, microseconds b) { return a / b; }
int div(nanoseconds a, nanoseconds b) {
if (b < nanoseconds(1)) {
return a / nanoseconds(1);
}
int v = a / b;
return v;
}
// set_time();
// rep(i,lim)shori
// lim*=time_nanbai();
// rep(i,lim)shoriと使う
// 全体でmilliかかっていいときにlimを何倍してもう一回できるかを返す
int time_nanbai(int milli) {
auto dec = duration_cast<nanoseconds>(past_time - start_time);
auto part = calc_time_nano();
auto can_time = nanoseconds(milli * 1000 * 1000);
can_time -= part;
can_time -= dec;
return div(can_time, part);
}
/*@formatter:off*/
// #define use_rand
#ifdef use_rand
str ransu(ll n) {
str s;
rep(i, n) s += (char)rand('A', 'Z');
return s;
}
str ransl(ll n) {
str s;
rep(i, n) s += (char)rand('a', 'z');
return s;
}
// 単調増加
vi ranvinc(ll n, ll min, ll max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
// 便利 汎用
#endif
void ranvlr(ll n, ll min, ll max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
template <class Iterable, class T = typename Iterable::value_type>
vector<pair<T, int>> run_length(const Iterable &a) {
vector<pair<T, int>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
/*@formatter:off*/
// #define use_mgr //_goldd _goldt
#ifdef use_mgr
//->[i, f(i)]
template <class T, class U, class F>
auto mgr(T ok, U ng, const F &f,
require_arg(is_integral<T>::value &&is_integral<U>::value)) {
auto mid = (ok + ng);
if (ok < ng)
while (ng - ok > 1) {
mid = (ok + ng) >> 1;
if (f(mid))
ok = mid;
else
ng = mid;
}
else
while (ok - ng > 1) {
mid = (ok + ng) >> 1;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
//[l, r)の中で,f(i)がtrueとなる範囲を返す okはそこに含まれる
template <class F> P mgr_range(int l, int r, F f, int ok) {
if (f(ok) == 0) {
out("f(ok) must true");
re();
}
return mp(mgr(ok, l - 1, f), mgr(ok, r, f) + 1);
}
template <class F> auto mgrd(dou ok, dou ng, F f, int kai = 100) {
if (ok < ng)
rep(i, kai) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
else
rep(i, kai) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
template <class F> dou mgrd_time(dou ok, dou ng, F f, int time = 1980) {
bool han = true;
if (ok < ng)
while (1) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid, han = true;
else
ng = mid, han = false;
deb(mid, han);
if (timeup(time)) {
break;
}
}
else
while (1) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid, han = true;
else
ng = mid, han = false;
deb(mid, han);
if (timeup(time)) {
break;
}
}
return ok;
}
// todo 減らす
template <class F> auto goldd_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX<ll>();
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return make_tuple(resIndex, calc(resIndex));
}
template <class F> auto goldt_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN<ll>();
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return make_tuple(resIndex, calc(resIndex));
}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template <class F> auto goldd_d(dou left, dou right, F calc, ll loop = 200) {
dou GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm); /*200にすればおそらく大丈夫*/ /*余裕なら300に*/
ll k = 141;
loop++;
while (--loop) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return make_tuple(left, calc(left));
}
template <class F> auto goldt_d(dou left, dou right, F calc, ll loop = 200) {
double GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm);
loop++;
while (--loop) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return make_tuple(left, calc(left));
}
// l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template <class F> auto goldd_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll mini = 0, minv = MAX<ll>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldd_l(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(mini, calc(mini));
}
template <class F> auto goldt_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll maxi = 0, maxv = MIN<ll>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldt_l(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(maxi, calc(maxi));
}
template <class F>
auto goldd_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を持つ*/
auto lim = milliseconds(time - 20);
dou mini = 0, minv = MAX<dou>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldd_d(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(mini, calc(mini));
}
template <class F>
auto goldt_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を残している*/
auto lim = milliseconds(time - 20);
dou maxi = 0, maxv = MIN<dou>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldt_d(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(maxi, calc(maxi));
}
#endif
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else if (a < b)
return b;
else
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) > sz(b)) {
return b;
} else if (sz(a) < sz(b)) {
return a;
} else if (a > b)
return b;
else
return a;
}
// エラー-1
template <typename W, typename T> ll find(vector<W> &a, int l, const T key) {
rep(i, l, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename W, typename T> ll find(vector<W> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename W, typename T> P find(vector<vector<W>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
// getid(find())を返す 1次元にする
template <typename W, typename T> int findi(vector<vector<W>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return i * sz(a[0]) + j;
return -1;
}
template <typename W, typename U>
tuple<int, int, int> find(vector<vector<vector<W>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] ==
key) return tuple<int, int, int>(i, j, k);
return tuple<int, int, int>(-1, -1, -1);
}
// 無ければ-1
int find(string &s, const string key) {
int klen = sz(key);
rep(i, sz(s) - klen + 1) {
if (s[i] != key[0])
continue;
if (s.substr(i, klen) == key) {
return i;
}
}
return -1;
}
int find(string &s, int l, const string key) {
int klen = sz(key);
rep(i, l, sz(s) - klen + 1) {
if (s[i] != key[0])
continue;
if (s.substr(i, klen) == key) {
return i;
}
}
return -1;
}
int find(string &s, const char key) {
rep(i, sz(s)) {
if (s[i] == key)
return i;
}
return -1;
}
int find(string &s, int l, const char key) {
rep(i, l, sz(s)) {
if (s[i] == key)
return i;
}
return -1;
}
// N箇所について右のkeyの場所を返す
template <typename W, typename T> vi finds(const W &a, const T &key) {
int n = sz(a);
vi rpos(n, -1);
rer(i, n - 1) {
if (i < n - 1) {
rpos[i] = rpos[i + 1];
}
if (a[i] == key)
rpos[i] = i;
}
return rpos;
}
template <typename W, typename T> vi rfinds(const W &a, const T &key) {
int n = sz(a);
vi lpos(n, -1);
rep(i, n) {
if (i > 0) {
lpos[i] = lpos[i - 1];
}
if (a[i] == key)
lpos[i] = i;
}
return lpos;
}
// todoz
#if __cplusplus >= 201703L
template <typename W, typename T, class Iterable = typename W::value_type>
ll count(const W &a, const T &k) {
return count_if(a, == k);
}
/*@formatter:on*/
template <typename W, class Iterable = typename W::value_type>
vi count(const W &a) {
vi res;
for_each(a, v, if (sz(res) <= (int)v) res.resize((int)v + 1); res[v]++;);
return res;
}
#endif
/*@formatter:off*/
ll count(const str &a, const str &k) {
ll ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ++ret;
return ret;
}
/*@formatter:off*/
//'a' = 'A' = 0 として集計 既に-'a'されていても動く
vi count(str &a, int l, int r) {
vi cou(26);
char c = 'a';
if ('A' <= a[l] && a[l] <= 'Z')
c = 'A';
if ('a' <= a[l] && a[l] <= 'z')
c = 'a';
else
c = 0;
rep(i, l, r)++ cou[a[i] - c];
return cou;
}
#define couif count_if
// algorythm
ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> auto rev(const vector<T> &a) {
auto b = a;
reverse(ALL(b));
return b;
}
/* ＼反転 */ template <class U> auto rev(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[h][w];
return b;
}
/* ｜反転 */ template <class U> auto revw(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a), vector<U>(sz(a[0])));
int W = sz(a[0]);
rep(h, sz(a)) rep(w, sz(a[0])) { b[h][W - 1 - w] = a[h][w]; }
return b;
}
/* ー反転 */ template <class U> auto revh(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a), vector<U>(sz(a[0])));
int H = sz(a);
rep(h, sz(a)) rep(w, sz(a[0])) { b[H - 1 - h][w] = a[h][w]; }
return b;
}
/* ／反転 */ template <class U> auto revr(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
int H = sz(a);
int W = sz(a[0]);
rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[H - 1 - h][W - 1 - w];
return b;
}
auto rev(const string &a) {
string b = a;
reverse(ALL(b));
return b;
}
template <class T> auto rev(const T &v, int i) { return v[sz(v) - 1 - i]; }
int rev(int N, int i) { return N - 1 - i; }
constexpr ll p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
// 0は0桁
ll keta(ll v, int if_zero_res) {
if (!v)
return if_zero_res;
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1]) {
if (v < p10[0])
return 0;
else
return 1;
} else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else
return 15;
} else {
if (v < p10[17]) {
if (v < p10[16])
return 16;
else
return 17;
} else {
if (v < p10[18])
return 18;
else
return 19;
}
}
}
}
}
#if __cplusplus >= 201703L
ll getr(ll a, ll keta) { return (a / pow<ll>(10, keta)) % 10; }
#else
ll getr(ll a, ll keta) { return (a / (int)pow(10, keta)) % 10; }
#endif
// 上から何桁目か
ll getl(ll a, ll ket) {
int sketa = keta(a, 1);
return getr(a, sketa - 1 - ket);
}
ll dsum(ll v, ll sin = 10) {
ll ret = 0;
for (; v; v /= sin)
ret += v % sin;
return ret;
}
ll mask10(ll v) { return p10[v] - 1; }
// 変換系
template <class T, class U>
auto to_v1(vector<reference_wrapper<U>> &ret, vector<T> &A) {
rep(i, sz(A)) ret.push_back(A[i]);
return ret;
}
template <class T, class U>
auto to_v1(vector<reference_wrapper<U>> &ret, vector<vector<T>> &A) {
rep(i, sz(A)) to_v1(ret, A[i]);
return ret;
}
// 参照付きで1次元に起こす
template <class T> auto to_v1(vector<vector<T>> &A) {
vector<reference_wrapper<typename decl2<decltype(A)>::type>> ret;
rep(i, sz(A)) to_v1(ret, A[i]);
return ret;
}
//[v] := iとなるようなvectorを返す
// 存在しない物は-1
// 空でも動く(なぜか)
template <class T> auto keys(const T &a) {
vector<decltype((a.begin())->fi)> res;
for (auto &&k : a)
res.push_back(k.fi);
return res;
}
template <class T> auto values(const T &a) {
vector<decltype((a.begin())->se)> res;
for (auto &&k : a)
res.push_back(k.se);
return res;
}
// todo 可変長で
template <class T> constexpr T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> constexpr T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class V, class T = typename V::value_type>
T min(V &a, ll s = -1, ll n = -1) {
set_lr12(s, n, sz(a));
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class V, class T = typename V::value_type>
T max(V &a, ll s = -1, ll n = -1) {
set_lr12(s, n, sz(a));
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> int mini(const vector<T> &a) {
return min_element(ALL(a)) - a.begin();
}
template <class T> int maxi(const vector<T> &a) {
return max_element(ALL(a)) - a.begin();
}
template <class T> T sum(const vector<T> &A, int l = -1, int r = -1) {
T s = 0;
set_lr12(l, r, sz(A));
rep(i, l, r) s += A[i];
return s;
}
template <class T> auto sum(const vector<vector<T>> &A) {
decl2<decltype(A)> s = 0;
rep(i, sz(A)) s += sum(A[i]);
return s;
}
template <class T> T min(const vector<T> &A, int l = -1, int r = -1) {
T s = MAX<T>();
set_lr12(l, r, sz(A));
rep(i, l, r) s = min(s, A[i]);
return s;
}
template <class T> auto min(const vector<vector<T>> &A) {
using S = decl2<decltype(A)>;
S s = MAX<S>();
rep(i, sz(A)) s = min(s, A[i]);
return s;
}
template <class T> T max(const vector<T> &A, int l = -1, int r = -1) {
T s = MIN<T>();
set_lr12(l, r, sz(A));
rep(i, l, r);
rep(i, l, r) s = max(s, A[i]);
return s;
}
template <class T> auto max(const vector<vector<T>> &A) {
using S = decl2<decltype(A)>;
S s = MIN<S>();
rep(i, sz(A)) s = max(s, A[i]);
return s;
}
template <class T> T mul(vector<T> &v, ll t = inf) {
T ret = v[0];
rep(i, 1, min(t, sz(v))) ret *= v[i];
return ret;
}
// template<class T, class U, class... W> auto sumn(vector<T> &v, U head, W...
// tail) { auto ret = sum(v[0], tail...); rep(i, 1, min(sz(v), head))ret
// += sum(v[i], tail...); return ret;} indexを持つvectorを返す
vi inds_(vi &a) {
int n = max(a) + 1;
vi ret(n, -1);
rep(i, sz(a)) {
assert(ret[a[i]] == -1);
ret[a[i]] = i;
}
return ret;
}
void clear(PQ &q) { q = PQ(); }
void clear(priority_queue<int> &q) { q = priority_queue<int>(); }
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
// template<class T> T *negarr(ll size) { T *body = (T *) malloc((size * 2 +
// 1) * sizeof(T)); return body + size;} template<class T> T *negarr2(ll h,
// ll w) { double **dummy1 = new double *[2 * h + 1]; double *dummy2 = new
// double[(2 * h + 1) * (2 * w + 1)]; dummy1[0] = dummy2 + w; for (ll i =
// 1; i <= 2 * h + 1; ++i) { dummy1[i] = dummy1[i - 1] + 2 * w + 1; } double
// **a = dummy1 + h; return a;}
template <class T> struct ruiC {
vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
/*先頭0*/
ruiC() : rui(1, 0) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruic ";
deb(l, r);
assert(0);
}
return rui[r] - rui[l];
}
T operator()(int r = inf) { return operator()(0, min(r, sz(rui) - 1)); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
T operator[](ll i) { return rui[i]; }
/*0から順に追加される必要がある*/
void operator+=(T v) { rui.push_back(rui.back() + v); }
void add(int i, T v) {
if (sz(rui) - 1 != i)
ole();
operator+=(v);
}
T back() { return rui.back(); }
ll size() { return rui.size(); }
auto begin() { return rui.begin(); }
auto end() { return rui.end(); }
};
template <class T> string deb_tos(const ruiC<T> &a) { return deb_tos(a.rui); }
template <class T> ostream &operator<<(ostream &os, ruiC<T> a) {
fora(v, a.rui) { os << v << " "; }
return os;
}
template <class T> vector<T> ruiv(const vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> ruiC<T> ruic(const vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
template <class T> ruiC<T> ruic() { return ruiC<T>(); }
// imoは0-indexed
// ruiは1-indexed
template <class T> vector<T> imo(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// #define use_rui //_imo _ruic _ruiv
#ifdef use_rui
// kと同じものの数
template <class T, class U> vi imo(const vector<T> &a, U k) {
vi equ(sz(a));
rep(i, sz(a)) { equ[i] = a[i] == k; }
return imo(equ);
}
template <class T> vector<T> imox(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> vector<T> imi(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> vector<T> ima(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chma(ret[i + 1], ret[i]);
return ret;
}
template <class T> vector<T> rimi(const vector<T> &v) {
vector<T> ret = v;
rer(i, sz(ret) - 1, 1) chmi(ret[i - 1], ret[i]);
return ret;
}
template <class T> vector<T> rima(const vector<T> &v) {
vector<T> ret = v;
rer(i, sz(ret) - 1, 1) chma(ret[i - 1], ret[i]);
return ret;
}
template <class T> struct ruimax {
template <typename Monoid> struct SegmentTree { /*pairで処理*/
int sz;
vector<Monoid> seg;
const Monoid M1 = mp(MIN<T>(), -1);
Monoid f(Monoid a, Monoid b) { return max(a, b); }
void build(vector<T> &a) {
int n = sz(a);
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
rep(i, n) { seg[i + sz] = mp(a[i], i); }
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[k << 1], seg[(k << 1) | 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]; }
};
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
public:
int n;
ruimax(vector<T> &a) : ve(a), n(sz(a)) {
int index = -1;
T ma = MIN<T>();
rv.resize(n + 1);
ri.resize(n + 1);
rv[0] = -INF<T>;
ri[0] = -1;
rep(i, n) {
if (chma(ma, a[i])) {
index = i;
}
rv[i + 1] = ma;
ri[i + 1] = index;
}
}
T operator()(int l, int r) {
if (!(l <= r && 0 <= l && r <= n)) {
deb(l, r, n);
assert(0);
}
if (l == 0) {
return rv[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).first;
}
}
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) {
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return ri[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).second;
}
}
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template <class T> struct ruimin {
template <typename Monoid> struct SegmentTree { /*pairで処理*/
int sz;
vector<Monoid> seg;
const Monoid M1 = mp(MAX<T>(), -1);
Monoid f(Monoid a, Monoid b) { return min(a, b); }
void build(vector<T> &a) {
int n = sz(a);
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
rep(i, n) { seg[i + sz] = mp(a[i], i); }
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[k << 1], seg[(k << 1) | 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]; }
};
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
int n;
public:
ruimin(vector<T> &a) : ve(a), n(sz(a)) {
int index = -1;
T mi = MAX<T>();
rv.resize(n + 1);
ri.resize(n + 1);
rv[0] = INF<T>;
ri[0] = -1;
rep(i, n) {
if (chmi(mi, a[i])) {
index = i;
}
rv[i + 1] = mi;
ri[i + 1] = index;
}
}
T operator()(int l, int r) {
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return rv[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).first;
}
}
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) {
{
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return ri[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).second;
}
}
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return ri[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).second;
}
}
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
}; /*@formatter:off*/
vvi() ruib(vi &a) {
vvi(res, 61, sz(a) + 1);
rep(k, 61) {
rep(i, sz(a)) { res[k][i + 1] = res[k][i] + ((a[i] >> k) & 1); }
}
return res;
}
vector<ruiC<int>> ruibc(vi &a) {
vector<ruiC<int>> ret(61);
vvi(res, 61, sz(a));
rep(k, 61) {
rep(i, sz(a)) { res[k][i] = (a[i] >> k) & 1; }
ret[k] = ruic(res[k]);
}
return ret;
}
// kと同じものの数
template <class T, class U> vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> ruiC<ll> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<ll>(ret);
}
template <class T> struct ruiC2 {
int H;
vector<ruiC<T>> rui;
ruiC<T> dummy; // 変なのをよばれたときはこれを返す//todo
ruiC2(const vector<vector<T>> &ru) : rui(sz(ru)), H(sz(ru)) {
for (int h = 0; h < H; h++) {
if (sz(ru[h]) == 0)
continue;
if (sz(dummy) == 1)
dummy = ruic(vector<T>(sz(ru[h])));
rui[h] = ruic(ru[h]);
}
}
// WについてHを返す
vector<T> operator()(ll l, ll r) {
if (l > r) {
cerr << "ruic ";
deb(l, r);
assert(0);
}
vector<T> res(H);
for (int h = 0; h < H; h++)
res[h] = rui[h](l, r);
return res;
}
// HについてWを返す
ruiC<T> &operator[](ll h) {
#ifdef _DEBUG
if (h >= H) {
message += "warning ruiC h >= H";
}
#endif
if (h >= H || sz(rui[h]) == 1)
return dummy;
else
return rui[h];
}
/*@formatter:off*/
// vector<T> operator()(int r) { return operator()(0, r); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
/*0から順に追加される必要がある*/
// T back() { return rui.back(); }
// ll size() { return rui.size(); }
// auto begin(){return rui.begin();}
// auto end(){return rui.end();}
};
template <class T, class U> ruiC<ll> ruicou(vector<T> &a, U b) {
vi cou(sz(a));
rep(i, sz(a)) { cou[i] = a[i] == b; }
return ruic(cou);
}
// メモリは形式によらず(26*N)
// rui(l,r)でvector(26文字について, l~rのcの個数)
// rui[h] ruic()を返す
// 添え字は'a', 'A'のまま扱う
// (予め-='a','A'されているものが渡されたらそれに従う)
template <typename Iterable, class is_Iterable = typename Iterable::value_type>
ruiC2<ll> ruicou(const Iterable &a) {
int H = max(a) + 1;
vvi(cou, H);
rep(i, sz(a)) {
if (sz(cou[a[i]]) == 0)
cou[a[i]].resize(sz(a));
cou[a[i]][i] = 1;
}
return ruiC2<ll>(cou);
}
/*@formatter:off*/
// h query
template <class T> vector<T> imoh(vector<vector<T>> &v, int w) {
vector<T> ret(sz(v));
rep(h, sz(ret)) { ret[h] = v[h][w]; }
rep(i, sz(ret) - 1) { ret[i + 1] += ret[i]; }
return ret;
}
template <class T> vector<T> ruih(vector<vector<T>> &v, int w) {
vector<T> ret(sz(v) + 1);
rep(h, sz(v)) { ret[h + 1] = v[h][w]; }
rep(i, sz(v)) { ret[i + 1] += ret[i]; }
return ret;
}
template <class T> ruiC<T> ruihc(vector<vector<T>> &a, int w) {
vector<T> ret = ruih(a, w);
return ruiC<T>(ret);
}
// xor
template <class T> struct ruixC {
vector<T> rui;
ruixC(vector<T> &ru) : rui(ru) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruiXc ";
deb(l, r);
assert(0);
}
return rui[r] ^ rui[l];
}
T operator[](ll i) { return rui[i]; }
T back() { return rui.back(); }
ll size() { return rui.size(); }
};
template <class T> vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> ruixC<ll> ruixc(vector<T> &a) {
vi ret = ruix(a);
return ruixC<ll>(ret);
}
// 差分を返す(累積を取ると元に戻る)
// 101なら
// 1111を返す
// 元の配列で[l, r)へのxorは
//[l]と[r]へのxorになる https://atcoder.jp/contests/abc155/tasks/abc155_f
vi ruix_diff(vi &A) {
int N = sz(A);
assert(N);
vi res(N + 1);
res[0] = A[0];
rep(i, 1, N) { res[i] = A[i - 1] ^ A[i]; }
res[N] = A[N - 1];
return res;
}
template <class T> vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> vector<T> ruimi(vector<T> &a) {
ll n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> struct rruiC {
vector<T> rui;
int n;
rruiC(vector<T> &a) : n(sz(a)) {
rui.resize(n + 1);
rer(i, n - 1) { rui[i] = rui[i + 1] + a[i]; }
}
/*[r l)*/
T operator()(int r, int l) {
r++;
l++;
assert(l <= r && l >= 0 && r <= n);
return rui[l] - rui[r];
}
T operator()(int l) { return operator()(n - 1, l); }
T operator[](int i) { return operator()(i); }
};
template <class T> ostream &operator<<(ostream &os, rruiC<T> a) {
fora(v, a.rui) { os << v << " "; }
return os;
}
template <class T> string deb_tos(rruiC<T> &a) { return deb_tos(a.rui); }
#define rrui rruic
template <class T> rruiC<T> rruic(vector<T> &a) { return rruiC<T>(a); }
// 掛け算
template <class T> struct ruimulC {
vector<T> rv;
int n;
ruimulC(vector<T> &a) : rv(a), n(sz(a)) {
rv.resize(n + 1);
rv[0] = 1;
rep(i, n) { rv[i + 1] = a[i] * rv[i]; }
}
ruimulC() : n(0) {
rv.resize(n + 1);
rv[0] = 1;
}
void operator+=(T v) {
rv.push_back(rv.back() * v);
n++;
}
T operator()(int l, int r) {
assert(l <= r && 0 <= l && r <= n);
return rv[r] / rv[l];
}
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template <class T> ruimulC<T> ruimul(vector<T> &a) { return ruimulC<T>(a); }
template <class T> ruimulC<T> ruimul() {
vector<T> a;
return ruimulC<T>(a);
}
template <class T> T *rruim(vector<T> &a) {
ll len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U, class W> T lowerBound(ruiC<T> &a, U v, W banpei) {
return lowerBound(a.rui, v, banpei);
}
template <class T, class U, class W> T upperBound(ruiC<T> &a, U v, W banpei) {
return upperBound(a.rui, v, banpei);
}
template <class T, class U, class W> T rlowerBound(ruiC<T> &a, U v, W banpei) {
return rlowerBound(a.rui, v, banpei);
}
template <class T, class U, class W> T rupperBound(ruiC<T> &a, U v, W banpei) {
return rupperBound(a.rui, v, banpei);
}
#endif
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
assert(keta <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (m >> keta) & 1;
}
// bget(n)次元
// NならN-1まで
vector<vi> bget2(vi &a, int keta_size) {
vvi(res, keta_size, sz(a));
rep(k, keta_size) {
rep(i, sz(a)) { res[k][i] = bget(a[i], k); }
}
return res;
}
vi bget1(vi &a, int keta) {
vi res(sz(a));
rep(i, sz(a)) { res[i] = bget(a[i], keta); }
return res;
}
#if __cplusplus >= 201703L
ll bget(ll m, ll keta, ll sinsuu) {
m /= pow<ll>(sinsuu, keta);
return m % sinsuu;
}
#else
ll bget(ll m, ll keta, ll sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
#endif
constexpr ll bit(ll n) {
#ifdef _DEBUG
assert(n <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (1LL << (n));
}
#if __cplusplus >= 201703L
ll bit(ll n, ll sinsuu) { return pow<ll>(sinsuu, n); }
#else
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
#endif
ll mask(ll n) { return (1ll << n) - 1; }
// aをbitに置きなおす
//{0, 2} -> 101
ll bit(const vi &a) {
int m = 0;
for (auto &&v : a)
m |= bit(v);
return m;
}
//{1, 1, 0} -> 011
// bitsetに置き換える感覚 i が立っていたら i bit目を立てる
ll bit_bool(vi &a) {
int m = 0;
rep(i, sz(a)) if (a[i]) m |= bit(i);
return m;
}
#define bcou __builtin_popcountll
// 最下位ビット
ll lbit(ll n) {
assert(n);
return n & -n;
}
ll lbiti(ll n) {
assert(n);
return log2(n & -n);
}
// 最上位ビット
ll hbit(ll n) {
assert(n);
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
ll hbiti(ll n) {
assert(n);
return log2(hbit(n));
}
// ll hbitk(ll n) { ll k = 0; rer(i, 5) { ll a = k + (1ll << i); ll
// b = 1ll << a; if (b <= n)k += 1ll << i; } return k;}
// 初期化は0を渡す
ll nextComb(ll &mask, ll n, ll r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; /*最下位の1*/
ll y = mask + x; /*連続した下の1を繰り上がらせる*/
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vi bitCombList(ll n, ll r) {
vi res;
ll m = 0;
while (nextComb(m, n, r)) {
res.push_back(m);
}
return res;
}
/*over*/ #define forbit1_2(i, mas) \
for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, \
i = !mas ? 0 : log2(forbitj); \
forbitm; forbitm = forbitm ^ forbitj, \
forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
/*over*/ #define forbit1_3(i, N, mas) \
for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, \
i = !mas ? 0 : log2(forbitj); \
forbitm && i < N; forbitm = forbitm ^ forbitj, \
forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
// masの立ってるindexを見る
// i, [N], mas
#define forbit1(...) over3(__VA_ARGS__, forbit1_3, forbit1_2)(__VA_ARGS__)
// masが立っていないindexを見る
// i, N, mas
#define forbit0(i, N, mas) forbit1(i, mask(N) & (~(mas)))
// forsubをスニペットして使う
// Mの部分集合(0,M含む)を見る 3^sz(S)個ある
#define forsub_all(m, M) for (int m = M; m != -1; m = m == 0 ? -1 : (m - 1) & M)
// BASE進数
template <size_t BASE> class base_num {
int v;
public:
base_num(int v = 0) : v(v){};
int operator[](int i) { return bget(v, i, BASE); }
void operator++() { v++; }
void operator++(signed) { v++; }
operator int() { return v; }
};
#define base3(mas, lim, BASE) for (base_num<BASE> mas; mas < lim; mas++)
#define base2(mas, lim) base3(mas, lim, 2)
#define base(...) over3(__VA_ARGS__, base3, base2, base1)(__VA_ARGS__)
// aにある物をtrueとする
vb bool_(vi a, int n) {
vb ret(max(max(a) + 1, n));
rep(i, sz(a)) ret[a[i]] = true;
return ret;
}
char itoal(ll i) { return 'a' + i; }
char itoaL(ll i) { return 'A' + i; }
ll altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
ll ctoi(char c) { return c - '0'; }
char itoc(ll i) { return i + '0'; }
ll vtoi(vi &v) {
ll res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(ll i) {
vi res;
while (i) {
res.push_back(i % 10);
i /= 10;
}
res = rev(res);
return res;
}
vi stov(string &a) {
ll n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
ll n = sz(a);
vi ret(n);
rep(i, n) ret[i] = a[i] == one;
return ret;
}
vector<vector<ll>> ctoi(vector<vector<char>> s, char c) {
ll n = sz(s), m = sz(s[0]);
vector<vector<ll>> res(n, vector<ll>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
// #define use_compress
//[i] := vを返す
// aは0~n-1で置き換えられる
vi compress(vi &a) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
#ifdef use_compress
// ind[i] := i番目に小さい数
// map[v] := vは何番目に小さいか
vi compress(vi &a, umapi &map) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
ll v = a[i];
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
map[v] = a[i];
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r) {
vi b;
ll len = a.size();
fora(v, a) { b.push_back(v); }
fora(v, r) { b.push_back(v); }
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(ALL(b), r[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r, vi &s) {
vi b;
ll len = a.size();
fora(v, a) { b.push_back(v); }
fora(v, r) { b.push_back(v); }
fora(v, s) { b.push_back(v); }
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(ALL(b), r[i]) - b.begin();
for (ll i = 0; i < sz(s); ++i)
r[i] = lower_bound(ALL(b), s[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vi> &a) {
vi b;
fora(vv, a) {
fora(v, vv) { b.push_back(v); }
}
sort(b);
unique(b);
fora(vv, a) {
fora(v, vv) { v = lower_bound(ALL(b), v) - b.begin(); }
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vector<vi>> &a) {
vi b;
fora(vvv, a) {
fora(vv, vvv) {
fora(v, vv) { b.push_back(v); }
}
}
sort(b);
unique(b);
fora(vvv, a) {
fora(vv, vvv) {
fora(v, vv) { v = lower_bound(ALL(b), v) - b.begin(); }
}
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
void compress(ll a[], ll len) {
vi b;
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
}
}
#endif
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(ALL(a), v))
#define lowerIndex(a, v) (lower_bound(ALL(a), v) - a.begin())
#define upperIndex(a, v) (upper_bound(ALL(a), v) - a.begin())
#define rlowerIndex(a, v) (upper_bound(ALL(a), v) - a.begin() - 1)
#define rupperIndex(a, v) (lower_bound(ALL(a), v) - a.begin() - 1)
template <class T, class U, class W> T lowerBound(vector<T> &a, U v, W banpei) {
auto it = lower_bound(a.begin(), a.end(), v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T upperBound(vector<T> &a, U v, W banpei) {
auto it = upper_bound(a.begin(), a.end(), v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W>
T rlowerBound(vector<T> &a, U v, W banpei) {
auto it = upper_bound(a.begin(), a.end(), v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W>
T rupperBound(vector<T> &a, U v, W banpei) {
auto it = lower_bound(a.begin(), a.end(), v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
// todo 消せないか
template <class T, class U, class W> T lowerBound(set<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T upperBound(set<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T rlowerBound(set<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W> T rupperBound(set<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W> T lowerBound(mset<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T upperBound(mset<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T rlowerBound(mset<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W> T rupperBound(mset<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
#define next2(a) next(next(a))
#define prev2(a) prev(prev(a))
// 狭義の単調増加列 長さを返す
template <class T> int lis(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX<T>());
rep(i, n) {
int id = lowerIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX<T>());
}
template <class T> int lis_eq(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX<T>());
rep(i, n) {
int id = upperIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX<T>());
}
// iteratorを返す
// valueが1以上の物を返す 0は見つけ次第削除
// vを減らす場合 (*it).se--でいい
template <class T, class U, class V> auto lower_map(map<T, U> &m, V k) {
auto ret = m.lower_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
template <class T, class U, class V> auto upper_map(map<T, U> &m, V k) {
auto ret = m.upper_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
// 存在しなければエラー
template <class T, class U, class V> auto rlower_map(map<T, U> &m, V k) {
auto ret = upper_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class T, class U, class V> auto rupper_map(map<T, U> &m, V k) {
auto ret = lower_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class... T> void fin(T... s) {
out(s...);
exit(0);
}
// 便利 数学 math
// sub ⊂ top
bool subset(int sub, int top) { return (sub & top) == sub; }
//-180 ~ 180 degree
double atand(double h, double w) { return atan2(h, w) / PI * 180; }
//% -mの場合、最小の正の数を返す
ll mod(ll a, ll m) {
if (m < 0)
m *= -1;
return (a % m + m) % m;
}
// ll pow(ll a) { return a * a; };
template <class T> T fact(int v) {
static vector<T> fact(2, 1);
if (sz(fact) <= v) {
rep(i, sz(fact), v + 1) { fact.emplace_back(fact.back() * i); }
}
return fact[v];
}
ll comi(ll n, ll r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
// 二項係数の偶奇を返す
int com_mod2(int n, int r) { return n == (r | (n - r)); }
double comd2(ll n, ll r) {
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
double comd(int n, int r) {
if (r < 0 || r > n)
return 0;
if (n < 2020)
return comd2(n, r);
static vd fact(2, 1);
if (sz(fact) <= n) {
rep(i, sz(fact), n + 1) { fact.push_back(fact.back() * i); }
}
return fact[n] / fact[n - r] / fact[r];
}
#define gcd my_gcd
ll gcd(ll a, ll b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
ll gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
#define lcm my_lcm
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
ll res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
#define hypot my_hypot
double hypot(double dx, double dy) { return std::sqrt(dx * dx + dy * dy); }
ll sig0(int t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
bint sig0(bint t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
// ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
ll sig(ll s, ll t) {
if (s > t)
swap(s, t);
return sig0(t - s) + s * (t - s + 1);
}
#define tousa_i tosa_i
#define lower_tousa_i lower_tosa_i
#define upper_tousa upper_tosa
#define upper_tousa_i upper_tosa_i
ll tosa_i(ll st, ll ad, ll v) {
assert(((v - st) % ad) == 0);
return (v - st) / ad;
}
ll tosa_s(ll st, ll ad, ll len) { return st * len + sig0(len - 1) * ad; }
// ax + r (x は非負整数) で表せる整数のうち、v 以上となる最小の整数
ll lower_tosa(ll st, ll ad, ll v) {
if (st >= v)
return st;
return (v - st + ad - 1) / ad * ad + st;
}
// 第何項か
ll lower_tosa_i(ll st, ll ad, ll v) {
if (st >= v)
return 0;
return (v - st + ad - 1) / ad;
}
ll upper_tosa(ll st, ll ad, ll v) { return lower_tosa(st, ad, v + 1); }
ll upper_tosa_i(ll st, ll ad, ll v) { return lower_tosa_i(st, ad, v + 1); }
// b * res <= aを満たす [l, r)を返す div
P drange_ika(int a, int b) {
P null_p = mp(linf, linf);
if (b == 0) {
if (a >= 0) {
return mp(-linf, linf + 1) /*全て*/;
} else {
return null_p /*無い*/;
}
} else {
if (a >= 0) {
if (b > 0) {
return mp(-linf, a / b + 1);
} else {
return mp(-(a / -b), linf + 1);
}
} else {
if (b > 0) {
return mp(-linf, -ceil(-a, b) + 1);
} else {
return mp(ceil(-a, -b), linf + 1);
}
}
}
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
++res;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
/*@formatter:off*/
// 機能拡張
#define dtie(a, b) \
int a, b; \
tie(a, b)
template <class T, class U> string to_string(T a, U b) {
string res = "";
res += a;
res += b;
return res;
}
template <class T, class U, class V> string to_string(T a, U b, V c) {
string res = "";
res += a;
res += b;
res += c;
return res;
}
template <class T, class U, class V, class W>
string to_string(T a, U b, V c, W d) {
string res = "";
res += a;
res += b;
res += c;
res += d;
return res;
}
template <class T, class U, class V, class W, class X>
string to_string(T a, U b, V c, W d, X e) {
string res = "";
res += a;
res += b;
res += c;
res += d;
res += e;
return res;
}
template <class T> vector<T> sub(const vector<T> &A, int l, int r) {
assert(0 <= l && l <= r && r <= sz(A));
vector<T> ret(r - l);
std::copy(A.begin() + l, A.begin() + r, ret.begin());
return ret;
}
template <class T> vector<T> sub(const vector<T> &A, int r) {
return sub(A, 0, r);
}
template <class T> vector<T> subn(const vector<T> &A, int l, int len) {
return sub(A, l, l + len);
}
string sub(string &A, int l, int r) {
assert(0 <= l && l <= r && r <= sz(A));
return A.substr(l, r - l);
}
template <class T, class F>
// sub2で呼ぶ
vector<T> sub(const vector<vector<T>> &A, int h, int w, int ah, int aw, F f) {
vector<T> res;
while (0 <= h && h < sz(A) && 0 <= w && w < sz(A[h]) && f(A[h][w])) {
res.emplace_back(A[h][w]);
h += ah;
w += aw;
}
return res;
}
template <class T>
vector<T> sub(const vector<vector<T>> &A, int h, int w, int ah, int aw) {
return sub(A, h, w, ah, aw, [&](T v) { return true; });
}
#define sub25(A, h, w, ah, aw) sub(A, h, w, ah, aw)
#define sub26(A, h, w, ah, aw, siki_r) \
sub(A, h, w, ah, aw, [&](auto v) { return v siki_r; })
#define sub27(A, h, w, ah, aw, v, siki) \
sub(A, h, w, ah, aw, [&](auto v) { return siki; })
#define sub2(...) over7(__VA_ARGS__, sub27, sub26, sub25)(__VA_ARGS__)
constexpr int bsetlen = k5 * 2;
// constexpr int bsetlen = 5050;
#define bset bitset<bsetlen>
bool operator<(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] < b[i])
return true;
if (a[i] > b[i])
return false;
}
return false;
}
bool operator>(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] > b[i])
return true;
if (a[i] < b[i])
return false;
}
return false;
}
bool operator<=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] < b[i])
return true;
if (a[i] > b[i])
return false;
}
return true;
}
bool operator>=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] > b[i])
return true;
if (a[i] < b[i])
return false;
}
return true;
}
string operator~(string &a) {
string res = a;
for (auto &&c : res) {
if (c == '0')
c = '1';
else if (c == '1')
c = '0';
else {
cerr << "cant ~" << a << "must bit" << endl;
exit(0);
}
}
return res;
}
ostream &operator<<(ostream &os, bset &a) {
bitset<10> b;
vi list;
rep(i, bsetlen) {
if (a[i])
list.push_back(i), b[i] = 1;
}
os << b << ", " << list;
return os;
}
int hbiti(bset &a) {
rer(i, bsetlen) {
if (a[i])
return i;
}
return -1;
}
#define hk(a, b, c) (a <= b && b < c)
// O(N/64)
bset nap(bset &a, int v) {
bset r = a | a << v;
return r;
}
bset nap(bset &a, bset &v) {
bset r = a;
rep(i, bsetlen) {
if (v[i])
r |= a << i;
}
return r;
}
template <class T> int count(set<T> &S, T l, T r) {
assert(l < r);
auto it = S.lower_bound(l);
return it != S.end() && (*it) < r;
}
// template<class T> void seth(vector<vector<T>> &S, int w, vector<T> &v)
// {assert(sz(S) == sz(v));assert(w < sz(S[0]));rep(h, sz(S)) { S[h][w] = v[h];
// }}
template <class T> vector<T> geth(vector<vector<T>> &S, int w) {
assert(w < sz(S[0]));
vector<T> ret(sz(S));
rep(h, sz(S)) { ret[h] = S[h][w]; }
return ret;
}
// vector<bool>[i]は参照を返さないため、こうしないとvb[i] |=
// trueがコンパイルエラー
vb::reference operator|=(vb::reference a, bool b) { return a = a | b; }
vb::reference operator&=(vb::reference a, bool b) { return a = a & b; }
template <class T, class U> void operator+=(pair<T, U> &a, pair<T, U> &b) {
a.fi += b.fi;
a.se += b.se;
}
template <class T, class U>
pair<T, U> operator+(const pair<T, U> &a, const pair<T, U> &b) {
return pair<T, U>(a.fi + b.fi, a.se + b.se);
}
template <class T, class U>
pair<T, U> operator-(const pair<T, U> &a, const pair<T, U> &b) {
return pair<T, U>(a.fi - b.fi, a.se - b.se);
}
template <class T, class U> pair<T, U> operator-(const pair<T, U> &a) {
return pair<T, U>(-a.first, -a.second);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
#ifdef _DEBUG
static bool was = false;
if (!was)
message += "str += 65 is 'A' not \"65\" ";
was = true;
#endif
return lhs + (char)rv;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
lhs = lhs + rv;
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
const int rv2 = rv;
return lhs + rv2;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
const int v = rv;
lhs += v;
}
template <typename CharT, typename Traits, typename Alloc>
void operator*=(basic_string<CharT, Traits, Alloc> &s, int num) {
auto bek = s;
s = "";
for (; num; num >>= 1) {
if (num & 1) {
s += bek;
}
bek += bek;
}
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<T> &v) {
fora(d, v) { a.push(d); }
return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T> set<T> &operator+=(set<T> &a, vector<T> v) {
fora(d, v) { a.insert(d); }
return a;
}
template <class T, class U> auto operator+=(set<T> &a, U v) {
return a.insert(v);
}
template <class T, class U> auto operator-=(set<T> &a, U v) {
return a.erase(v);
}
template <class T, class U> auto operator+=(mset<T> &a, U v) {
return a.insert(v);
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.push_back(v);
return a;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(const vector<T> &a, const vector<T> &b) {
vector<T> ret;
ret = a;
fora(v, b) { ret += v; }
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, const vector<T> &b) {
rep(i, sz(b)) { /*こうしないとa+=aで両辺が増え続けてバグる*/
a.push_back(b[i]);
}
return a;
}
template <class T, class U> map<T, U> &operator+=(map<T, U> &a, map<T, U> &b) {
for (auto &&bv : b) {
a[bv.first] += bv.second;
}
return a;
}
template <class T, class U>
vector<T> operator+(const vector<T> &a, const U &v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> auto operator+=(uset<T> &a, U v) {
return a.insert(v);
}
template <class T> vector<T> operator%(vector<T> &a, int v) {
vi ret(sz(a));
rep(i, sz(a)) { ret[i] = a[i] % v; }
return ret;
}
template <class T> vector<T> operator%=(vector<T> &a, int v) {
rep(i, sz(a)) { a[i] %= v; }
return a;
}
vi operator&(vi &a, vi &b) {
assert(sz(a) == sz(b));
vi ret(sz(a));
rep(i, sz(a)) { ret[i] = min(a[i], b[i]); }
return ret;
}
template <class T> void operator+=(mset<T> &a, vector<T> &v) {
for (auto &&u : v)
a.insert(u);
}
template <class T> void operator+=(set<T> &a, vector<T> &v) {
for (auto &&u : v)
a.insert(u);
}
template <class T> void operator+=(vector<T> &a, set<T> &v) {
for (auto &&u : v)
a.emplace_back(u);
}
template <class T> void operator+=(vector<T> &a, mset<T> &v) {
for (auto &&u : v)
a.emplace_back(u);
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
exit(0);
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
// template<class T, class U> void operator*=(vector<T> &a, U b) { vector<T>
// ta = a; rep(b-1){ a+=ta; }}
template <typename T> void erase(vector<T> &v, unsigned ll i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned ll s, unsigned ll e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T> void pop_front(vector<T> &v) { erase(v, 0); }
template <typename T> void entry(vector<T> &v, unsigned ll s, unsigned ll e) {
erase(v, e, sz(v));
erase(v, 0, s);
}
template <class T, class U> void erase(map<T, U> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T> void erasen(vector<T> &v, unsigned ll s, unsigned ll n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
vector<string> split(const string &a, const char deli) {
string b = a + deli;
ll l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string &a, const string deli) {
vector<string> res;
ll kn = sz(deli);
std::string::size_type Pos(a.find(deli));
ll l = 0;
while (Pos != std::string::npos) {
if (Pos - l)
res.push_back(a.substr(l, Pos - l));
l = Pos + kn;
Pos = a.find(deli, Pos + kn);
}
if (sz(a) - l)
res.push_back(a.substr(l, sz(a) - l));
return res;
}
ll stoi(string &s) { return stol(s); }
#define assert_yn(yn_v, v) \
; \
assert(yn_v == 0 || yn_v == v); \
yn_v = v;
// 不完全な対策、現状はautohotkeyで対応
int yn_v = 0;
void yn(bool a) {
assert_yn(yn_v, 1);
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void fyn(bool a) {
assert_yn(yn_v, 1);
yn(a);
exit(0);
}
void Yn(bool a) {
assert_yn(yn_v, 2);
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void fYn(bool a) {
assert_yn(yn_v, 2);
Yn(a);
exit(0);
}
void YN(bool a) {
assert_yn(yn_v, 3);
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fYN(bool a) {
assert_yn(yn_v, 3);
YN(a);
exit(0);
}
int ab_v = 0;
void fAb(bool a) {
assert_yn(ab_v, 1);
if (a)
cout << "Alice" << endl;
else
cout << "Bob";
}
void fAB(bool a) {
assert_yn(yn_v, 2);
if (a)
cout << "ALICE" << endl;
else
cout << "BOB";
}
int pos_v = 0;
void Possible(bool a) {
assert_yn(pos_v, 1);
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
assert_yn(pos_v, 2);
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
void fPossible(bool a) {
assert_yn(pos_v, 1) Possible(a);
exit(0);
}
void fPOSSIBLE(bool a) {
assert_yn(pos_v, 2) POSSIBLE(a);
exit(0);
}
template <typename T> class fixed_point : T {
public:
explicit constexpr fixed_point(T &&t) noexcept : T(std::forward<T>(t)) {}
template <typename... Args>
constexpr decltype(auto) operator()(Args &&...args) const {
return T::operator()(*this, std::forward<Args>(args)...);
}
};
template <typename T>
static inline constexpr decltype(auto) fix(T &&t) noexcept {
return fixed_point<T>{std::forward<T>(t)};
}
// 未分類
// 0,2,1 1番目と2番目の次元を入れ替える
template <class T>
auto irekae(vector<vector<vector<T>>> &A, int x, int y, int z) {
#define irekae_resize_loop(a, b, c) \
resize(res, a, b, c); \
rep(i, a) rep(j, b) rep(k, c)
vector<vector<vector<T>>> res;
if (x == 0 && y == 1 && z == 2) {
res = A;
} else if (x == 0 && y == 2 && z == 1) {
irekae_resize_loop(sz(A), sz(A[0][0]), sz(A[0])) {
res[i][j][k] = A[i][k][j];
}
} else if (x == 1 && y == 0 && z == 2) {
irekae_resize_loop(sz(A[0]), sz(A), sz(A[0][0])) {
res[i][j][k] = A[j][i][k];
}
} else if (x == 1 && y == 2 && z == 0) {
irekae_resize_loop(sz(A[0]), sz(A[0][0]), sz(A)) {
res[i][j][k] = A[k][i][j];
}
} else if (x == 2 && y == 0 && z == 1) {
irekae_resize_loop(sz(A[0][0]), sz(A), sz(A[0])) {
res[i][j][k] = A[j][k][i];
}
} else if (x == 2 && y == 1 && z == 0) {
irekae_resize_loop(sz(A[0][0]), sz(A[0]), sz(A)) {
res[i][j][k] = A[k][j][i];
}
}
return res;
#undef irekae_resize_loop
}
template <class T> auto irekae(vector<vector<T>> &A, int i = 1, int j = 0) {
vvt(res, sz(A[0]), sz(A));
rep(i, sz(A)) {
rep(j, sz(A[0])) { res[j][i] = A[i][j]; }
}
return res;
}
// tou分割する
template <typename Iterable>
vector<Iterable> table(const Iterable &a, int tou = 2) {
int N = sz(a);
vector<Iterable> res(tou);
int hab = N / tou;
vi lens(tou, hab);
rep(i, N % tou) { lens[tou - 1 - i]++; }
int l = 0;
rep(i, tou) {
int len = lens[i];
int r = l + len;
res[i].resize(len);
std::copy(a.begin() + l, a.begin() + r, res[i].begin());
l = r;
}
return res;
}
// 長さn毎に分割する
template <typename Iterable>
vector<Iterable> table_n(const Iterable &a, int len) {
int N = sz(a);
vector<Iterable> res(ceil(N, len));
vi lens(N / len, len);
if (N % len)
lens.push_back(N % len);
int l = 0;
rep(i, sz(lens)) {
int len = lens[i];
int r = l + len;
res[i].resize(len);
std::copy(a.begin() + l, a.begin() + r, res[i].begin());
l = r;
}
return res;
}
// 縦を返す
vi &geth(vvi() & a, int w) {
static vi ret;
ret.resize(sz(a));
rep(i, sz(a)) { ret[i] = a[i][w]; }
return ret;
}
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} initonv;
// #define pre prev
// #define nex next
// gra mll pr
// 上下左右
const string udlr = "udlr";
string UDLR = "UDLR"; // x4と連動 UDLR.find('U') := x4[0]
vc atoz = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
vc AtoZ = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
// 右、上が正
constexpr ll h4[] = {1, -1, 0, 0};
constexpr ll w4[] = {0, 0, -1, 1};
constexpr ll h8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll w8[] = {1, 0, -1, 0, 1, -1, 1, -1};
int mei_inc(int h, int w, int H, int W, int i) {
while (++i < 4) {
if (inside(h + h4[i], w + w4[i], H, W))
return i;
}
return i;
}
#define mei(nh, nw, h, w) \
for (int i = mei_inc(h, w, H, W, -1), nh = i < 4 ? h + h4[i] : 0, \
nw = i < 4 ? w + w4[i] : 0; \
i < 4; i = mei_inc(h, w, H, W, i), nh = h + h4[i], nw = w + w4[i])
int mei_inc8(int h, int w, int H, int W, int i) {
while (++i < 8) {
if (inside(h + h8[i], w + w8[i], H, W))
return i;
}
return i;
}
#define mei8(nh, nw, h, w) \
for (int i = mei_inc8(h, w, H, W, -1), nh = i < 8 ? h + h8[i] : 0, \
nw = i < 8 ? w + w8[i] : 0; \
i < 8; i = mei_inc8(h, w, H, W, i), nh = h + h8[i], nw = w + w8[i])
int mei_incv(int h, int w, int H, int W, int i, vp &p) {
while (++i < sz(p)) {
if (inside(h + p[i].fi, w + p[i].se, H, W))
return i;
}
return i;
}
#define meiv(nh, nw, h, w, p) \
for (int i = mei_incv(h, w, H, W, -1, p), nh = i < sz(p) ? h + p[i].fi : 0, \
nw = i < sz(p) ? w + p[i].se : 0; \
i < sz(p); \
i = mei_incv(h, w, H, W, i, p), nh = h + p[i].fi, nw = w + p[i].se)
// H*Wのグリッドを斜めに分割する
// 右上
vector<vp> naname_list_ne(int H, int W) {
vector<vp> res(H + W - 1);
rep(sh, H) {
int sw = 0;
res[sh] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh--;
nw++;
if (0 <= nh && nw < W) {
res[sh] += mp(nh, nw);
} else {
break;
}
}
}
rep(sw, 1, W) {
int sh = H - 1;
res[H + sw - 1] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh--;
nw++;
if (0 <= nh && nw < W) {
res[H + sw - 1] += mp(nh, nw);
} else {
break;
}
}
}
return res;
}
// 右下
vector<vp> naname_list_se(int H, int W) {
vector<vp> res(H + W - 1);
rep(sh, H) {
int sw = 0;
res[sh] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh++;
nw++;
if (0 <= nh && nh < H && nw < W) {
res[sh] += mp(nh, nw);
} else {
break;
}
}
}
rep(sw, 1, W) {
int sh = 0;
res[H + sw - 1] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh++;
nw++;
if (0 <= nh && nh < H && nw < W) {
res[H + sw - 1] += mp(nh, nw);
} else {
break;
}
}
}
return res;
}
// グラフ内で #undef getid
// #define getidとしているため、ここを書き直したらgraphも書き直す
#define getid_2(h, w) ((h) * (W) + (w))
#define getid_1(p) ((p).first * W + (p).second)
#define getid(...) over2(__VA_ARGS__, getid_2, getid_1)(__VA_ARGS__)
#define getp(id) mp(id / W, id % W)
// #define set_shuffle() std::random_device seed_gen;std::mt19937
// engine(seed_gen()) #define shuffle(a) std::shuffle((a).begin(), (a).end(),
// engine); 1980 開始からtime ms経っていたらtrue
vb bit_bool(int v, int len) {
assert(bit(len) > v);
vb ret(len);
rep(i, len) { ret[i] = bget(v, i); }
return ret;
}
vi range(int l, int r) {
vi ret;
ret.resize(r - l);
rep(v, l, r) { ret[v - l] = v; }
return ret;
}
vi range(int r) { return range(0, r); }
vi tov(vb &a) {
vi ret;
rep(i, sz(a)) {
if (a[i])
ret.push_back(i);
}
return ret;
}
bool kaibun(const str &S) { return S == rev(S); }
template <class T> vector<T> repeat(const vector<T> &A, int kaisu) {
vector<T> ret;
while (kaisu--) {
ret += A;
}
return ret;
}
#define rge range
#define upd update
// S[{s, t, d}]
#define strs slice_str
struct slice_str {
string S;
slice_str() {}
slice_str(const string &S) : S(S) {}
slice_str(int len, char c) : S(len, c) {}
auto size() { return S.size(); }
char &operator[](int p) { return S[p]; }
string operator[](initializer_list<int> p) {
if (sz(p) == 1) {
return S.substr(0, *(p.begin()));
} else if (sz(p) == 2) {
int l = *(p.begin());
int r = *(next(p.begin()));
return S.substr(l, r - l);
} else {
auto it = p.begin();
int s = *(it++);
int t = *(it++);
int d = *(it);
if (d == -1) {
int s_ = sz(S) - s - 1;
int t_ = sz(S) - t - 1;
return rev(S).substr(s_, t_ - s_);
} else if (d < 0) {
t = max(-1ll, t);
string ret;
while (s > t) {
ret += S[s];
s += d;
}
return ret;
} else {
t = min(sz(S), t);
string ret;
while (s < t) {
ret += S[s];
s += d;
}
return ret;
}
}
}
operator string &() { return S; }
template <class T> void operator+=(const T &a) { S += a; }
bool operator==(const slice_str &rhs) { return S == rhs.S; }
};
ostream &operator<<(ostream &os, const slice_str &a) {
os << a.S;
return os;
}
istream &operator>>(istream &iss, const slice_str &a) {
iss >> a.S;
return iss;
}
template <class T> bool can(const T &v, int i) { return 0 <= i && i < sz(v); }
#if __cplusplus >= 201703L
// template<class T> auto sum(int a, T v...) {return (v + ... + 0);}
#endif
#define VEC vector
#endif /*UNTITLED15_TEMPLATE_H*/
#endif
// † ←template終了
/*@formatter:on*/
// vectorで取れる要素数
// bool=> 1e9 * 8.32
// int => 1e8 * 2.6
// ll => 1e8 * 1.3
// 3次元以上取るとメモリがヤバい
// static配列を使う
vvc(ba);
ll N, M, H, W;
vi A, B, C;
#ifndef MINT
#define MINT
/*@formatter:off*/
template <typename T> T minv(T a, T m);
template <typename T> T minv(T a);
template <typename T> class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U> Modular(const U &x) { value = normalize(x); }
template <typename U> static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0)
v += mod();
return v;
}
const Type &operator()() const { return value; }
template <typename U> explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
if ((value += other.value) >= mod())
value -= mod();
return *this;
}
Modular &operator-=(const Modular &other) {
if ((value -= other.value) < 0)
value += mod();
return *this;
}
template <typename U> Modular &operator+=(const U &other) {
return *this += Modular(other);
}
template <typename U> Modular &operator-=(const U &other) {
return *this -= Modular(other);
}
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(signed) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(signed) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, signed>::value,
Modular>::type &
operator*=(const Modular &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type &
operator*=(const Modular &rhs) {
int64_t q =
static_cast<int64_t>(static_cast<double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) {
return *this *= Modular(minv(other.value));
}
template <typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
operator int() { return value; }
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator%(const Modular<T> &lhs, U rhs) {
cerr << "can't mint % int" << endl;
assert(0);
exit(0);
return 0;
}
constexpr signed MOD =
// 998244353;
1e9 + 7; // MOD
using mint = Modular<std::integral_constant<decay<decltype(MOD)>::type, MOD>>;
#ifdef optional
template <class T>
optional<mint> operator+(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv + opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator-(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator*(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator/(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv / opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator+(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv + opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator-(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator*(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator/(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv / opt.value();
else
return optional<mint>();
}
template <class T> void operator+=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv += opt.value();
}
template <class T> void operator-=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv -= opt.value();
}
template <class T> void operator*=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv *= opt.value();
}
template <class T> void operator/=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv /= opt.value();
}
template <class T> void operator+=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value += mv;
}
template <class T> void operator-=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value -= mv;
}
template <class T> void operator*=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value *= mv;
}
template <class T> void operator/=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value /= mv;
}
#endif
// constexpr int mint_len = std::min(1400001, MOD);
vi fac, finv, inv;
vi p2;
void setmod_resize(int mint_len) {
// p2.resize(mint_len);p2[0] = 1; for (int i = 1; i < mint_len; ++i) p2[i]
// = p2[i - 1] * 2 % MOD;
int tn = sz(fac);
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = tn; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = tn; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
// 4e6 >= n なら O(r)で計算する
mint com_big(int n, int r) {
int fa = finv[r];
rep(i, r) fa *= n - i, fa %= MOD;
return mint(fa);
}
mint com(int n, int r) {
if (r < 0 || r > n)
return 0; /*nが大きくてrが小さい場合、nを上からr個掛ける*/
if (n >= sz(fac)) {
if (n <= 4e6)
setmod_resize(n + 1000);
else
return com_big(n, r);
}
return mint(finv[r] * fac[n] % MOD * finv[n - r]);
}
mint pom(int n, int r) { /* if (!sz(fac)) com(0, -1);*/
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
mint npr(int n, int r) { /* if (!sz(fac)) com(0, -1);*/
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
mint com_grid(int n, int r) {
assert(r);
return com(n + r - 2, n - 1);
}
int nprin(int n, int r) { /* if (!sz(fac)) com(0, -1);*/
if (r < 0 || r > n)
return 0;
return fac[n] * finv[n - r] % MOD;
}
int icom(int n, int r) {
const int NUM_ = 1400001;
static ll fac[NUM_ + 1], finv[NUM_ + 1], inv[NUM_ + 1];
if (fac[0] == 0) {
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
if (r < 0 || r > n)
return 0;
return ((finv[r] * fac[n] % MOD) * finv[n - r]) % MOD;
}
#define ncr com
#define ncri icom
// n種類でr個選ぶ
// n個の場所にr個の物を置く
// 負が渡された場合もcomが処理出来る
mint nhr(int n, int r) {
if (n == 0 && r == 0)
return 1;
else
return com(n + r - 1, r);
}
// n種類でそれぞれ少なくとも1つは選び、r個揃える
mint nhr1(int n, int r) { return nhr(n, r - n); }
mint hom(int n, int r) {
if (n == 0 && r == 0)
return 1;
else
return com(n + r - 1, r);
}
int nhri(int n, int r) {
if (n == 0 && r == 0)
return 1;
else
return icom(n + r - 1, r);
}
// グリッドで0-indexedの最短経路 pascal
mint pas(int h, int w) { return com(h + w, w); }
template <typename T> T minv(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T> T minv(T a) {
if (a < sz(fac))
return inv[a];
T u = 0, v = 1;
T m = MOD;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
// int型 mod m
template <typename T, typename U, typename V>
int mpow(const T a, const U b, const V m) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T, typename U>
Modular<T> mpow(const Modular<T> &a, const U &b) {
assert(b >= 0);
int x = a(), res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
//-k乗出来る
/*@formatter:on*/
template <typename T, typename U>
mint mpow(const T a, const U b) { /* assert(b >= 0);*/
if (b < 0) {
return minv(mpow(a, -b));
}
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
/*@formatter:off*/
template <class T> mint mpow(bint a, const T b) { return mpow((mint)a, b); }
template <typename T, typename U, typename V>
int mpowi(const T &a, const U &b, const V &m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T> string to_string(const Modular<T> &number) {
return to_string(number());
}
#ifdef _DEBUG
void yuri(const mint &a) {
stringstream st;
rep(i, 300) {
rep(j, 300) {
if ((mint)i / j == a) {
st << i << " / " << j;
i = 2000;
break;
}
}
}
string val = st.str();
if (val != "") {
deb(val);
return;
}
rep(i, 1000) {
rep(j, 1000) {
if ((mint)i / j == a) {
st << i << " / " << j;
i = 2000;
break;
}
}
}
val = st.str();
deb(val);
}
#else
#define yuri(...) ;
#endif
template <typename T>
std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
stream << number();
#ifdef _DEBUG
// stream << " -> " << yuri(number);
#endif
return stream;
}
//@formatter:off
template <typename T>
std::istream &operator>>(std::istream &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
using PM = pair<mint, mint>;
using vm = vector<mint>;
using mapm = map<int, mint>;
using umapm = umap<int, mint>;
#define vvm(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(mint, __VA_ARGS__)
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
string out_m2(mint a) {
stringstream st;
st << (int)a;
rep(i, 300) {
rep(j, 2, 300) {
if ((i % j) && (mint)i / j == a) {
st << "(" << i << "/" << j << ")";
i = 2000;
break;
}
}
}
return st.str();
}
// nhr n個の場所にr個の物を分ける
mint m1 = (mint)1;
mint half = (mint)1 / 2;
struct setmod {
// comで長さが足りない場合はsetmod_resizeでリサイズする
int mint_len = 1.4 * 1e6;
setmod() {
// p2を使う場合setmod_resizeも変える
// p2.resize(mint_len);p2[0] = 1; for (int i = 1; i < mint_len; ++i)
// p2[i] = p2[i - 1] * 2 % MOD;
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
} setmodv;
template <signed S>
using mint_ = Modular<std::integral_constant<decay<signed>::type, S>>;
#endif
/*@formatter:on*/
void solve() {
in(N);
na(A, N);
rsort(A);
mint res = 0;
rep(i, N) { res += (pow<mint>(2, i - 1) + pow<mint>(2, i)) * A[i]; }
res *= mpow(2, N); // Tの選び方
out(res);
}
auto my(ll n, vi &a) { return 0; }
auto sister(ll n, vi &a) {
ll ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (ll i = 0, ok = 1; i < k5 && ok; ++i) {
ll n = rand(1, 8);
vi a = ranv(n, 1, 10);
auto myres = my(arg);
auto res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "AC : " << res << endl;
cerr << "MY : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// solveを書き直す
// solveを呼び出す
}
if (was_deb && sz(res_mes)) {
cerr << "result = " << endl << res_mes << endl;
}
if (sz(message)) {
cerr << "****************************" << endl;
cerr << "Note." << endl;
cerr << message << endl;
cerr << "****************************" << endl;
}
#endif
return 0;
};
| /*temp*/
//
//
//
//
// #undef _DEBUG
// #pragma GCC optimize("Ofast")
// 不動小数点の計算高速化
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
// #include <boost/multiprecision/cpp_int.hpp>
#ifdef _DEBUG
#include "template.h"
#else
#if __cplusplus >= 201703L
/*Atcoderでしか使えない(c++17 && このテンプレートが使えるならAtcoder)*/
#include <boost/sort/pdqsort/pdqsort.hpp>
#define fast_sort boost::sort::pdqsort
#endif
#endif
#ifndef _DEBUG
#ifndef UNTITLED15_TEMPLATE_H
#define UNTITLED15_TEMPLATE_H
#ifdef _DEBUG
#include "bits_stdc++.h"
#else
#include <bits/stdc++.h>
#endif
#ifndef fast_sort
#define fast_sort sort
#endif
// #define use_pq
#define use_for
#define use_for_each
#define use_sort
#define use_fill
#define use_rand
#define use_mgr
#define use_rui
#define use_compress
//
//
//
//
//
//
#define use_pbds
#ifdef use_pbds
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
template <class T, class U, class W, class X>
auto count(__gnu_pbds::gp_hash_table<T, U, W> &a, X k) {
return a.find(k) != a.end();
}
#endif
using namespace std;
using namespace std::chrono;
/*@formatter:off*/
#define ll long long
using sig_dou = double;
// マクロ省略形 関数等
#define arsz(a) (sizeof(a) / sizeof(a[0]))
#define sz(a) ((ll)(a).size())
#define mp make_pair
#define mt make_tuple
#define pb pop_back
#define pf push_front
#define eb emplace_back
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
template <class T, class U> auto max(T a, U b) { return a > b ? a : b; }
template <class T, class U> auto min(T a, U b) { return a < b ? a : b; }
// optional<T>について下でオーバーロード(nullopt_tを左辺右辺について単位元として扱う)
template <class T, class U> bool chma(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T, class U> bool chmi(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// メタ系 meta
// vector<T>でTを返す
#define decl_t(A) decltype(A)::value_type
// vector<vector<.....T>>でTを返す
template <class T> struct decl2 {
typedef T type;
};
template <class T> struct decl2<vector<T>> {
typedef typename decl2<T>::type type;
};
// #define decl_max(a, b) decltype(max(MAX<decltype(a)>(), MAX<decltype(b)>()))
#define is_same2(T, U) is_same<T, U>::value
template <class T> struct is_vector : std::false_type {};
template <class T> struct is_vector<std::vector<T>> : std::true_type {};
// 大きい型を返す max_type<int, char>::type
// todo mintがlong long より小さいと判定されるためバグる
template <class T1, class T2, bool t1_bigger = (sizeof(T1) > sizeof(T2))>
struct max_type {
typedef T1 type;
};
template <class T1, class T2> struct max_type<T1, T2, false> {
typedef T2 type;
};
template <typename T, typename U = typename T::value_type>
std::true_type value_type_tester(signed);
template <typename T> std::false_type value_type_tester(long);
template <typename T>
struct has_value_type : decltype(value_type_tester<T>(0)) {};
template <class T> struct vec_rank : integral_constant<int, 0> {};
template <class T>
struct vec_rank<vector<T>> : integral_constant<int, vec_rank<T>{} + 1> {};
// N個のTを並べたtupleを返す
// tuple_n<3, int>::type tuple<int, int, int>
template <size_t N, class T, class... Arg> struct tuple_n {
typedef typename tuple_n<N - 1, T, T, Arg...>::type type;
};
template <class T, class... Arg> struct tuple_n<0, T, Arg...> {
typedef tuple<Arg...> type;
};
struct dummy_t1 {};
struct dummy_t2 {};
struct dummy_t3 {};
struct dummy_t4 {};
struct dummy_t5 {};
struct dummy_t6 {};
// template<class T, require(is_integral<T>::value)>など
#define require_t(bo) enable_if_t<bo> * = nullptr
// 複数でオーバーロードする場合、引数が同じだとうまくいかないため
// require_arg(bool, dummy_t1)
// require_arg(bool, dummy_t2)等とする
#define require_arg1(bo) enable_if_t<bo> * = nullptr
#define require_arg2(bo, dummy_type) enable_if_t<bo, dummy_type> * = nullptr
#define require_arg(...) \
over2(__VA_ARGS__, require_arg2, require_arg1)(__VA_ARGS__)
//->//enable_if_tのtを書き忘れそうだから
#define require_ret(bo, ret_type) enable_if_t<bo, ret_type>
#define int long long // todo 消したら動かない intの代わりにsignedを使う
auto start_time = system_clock::now();
auto past_time = system_clock::now();
#define debugName(VariableName) #VariableName
// 最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
void assert2(bool b, const string &s = "") {
if (!b) {
cerr << s << endl;
exit(1); /*assert(0);*/
}
}
// my_nulloptをあらゆる操作の単位元的な物として扱う
// vectorの参照外時に返したり、右辺値として渡されたときに何もしないなど
struct my_nullopt_t {
} my_nullopt;
#define nullopt_t my_nullopt_t
#define nullopt my_nullopt
/*@formatter:off*/
// 値が無いときは、setを使わない限り代入できない
//=を使っても無視される
template <class T> struct my_optional {
private:
bool is_null;
T v;
public:
typedef T value_type;
my_optional() : is_null(true) {}
my_optional(const nullopt_t &) : is_null(true) {}
my_optional(const T &v) : v(v), is_null(false) {}
bool has_value() const { return !is_null; }
T &value() {
static string mes = "optional has no value";
assert2(!is_null, mes);
return v;
}
const T &value() const {
static string mes = "optional has no value";
assert2(!is_null, mes);
return v;
}
void set(const T &nv) {
is_null = false;
v = nv;
}
template <class U> void operator=(const U &v) {
if (has_value())
value() = v;
else
return;
}
template <class U> void operator=(const my_optional<U> &v) {
if (has_value() && v.has_value())
(*this) = v;
else
return;
}
void reset() { is_null = true; }
void operator=(const nullopt_t &) { reset(); }
template <require_t(!is_same2(T, bool))> explicit operator bool() {
return !is_null;
}
// nullの時はエラー
operator T &() { return value(); }
operator const T &() const { return value(); }
my_optional<T> operator++() {
if (this->has_value()) {
this->value()++;
return *this;
} else {
return *this;
}
}
my_optional<T> operator++(signed) {
if (this->has_value()) {
auto tem = *this;
this->value()++;
return tem;
} else {
return *this;
}
}
my_optional<T> operator--() {
if (this->has_value()) {
this->value()--;
return *this;
} else {
return *this;
}
}
my_optional<T> operator--(signed) {
if (this->has_value()) {
auto tem = *this;
this->value()--;
return tem;
} else {
return *this;
}
}
};
template <class T> istream &operator>>(istream &iss, my_optional<T> &v) {
T val;
iss >> val;
v.set(val);
return iss;
}
#define optional my_optional
template <class T> using opt = my_optional<T>;
// template<class T, class A = std::allocator<T>> struct debtor : std::vector<T,
// A> {
template <class Key, class T, class Compare = less<Key>,
class Allocator = allocator<pair<const Key, T>>>
struct o_map : std::map<Key, optional<T>, Compare, Allocator> {
optional<T> emp;
o_map() : std::map<Key, optional<T>, Compare, Allocator>() {}
auto operator()(const nullopt_t &) { return nullopt; }
optional<T> &operator()(const optional<Key> &k) {
if (k.has_value()) {
return std::map<Key, optional<T>, Compare, Allocator>::operator[](
k.value());
} else {
emp.reset();
return emp;
}
}
optional<T> &operator()(const Key &k) {
auto &v = std::map<Key, optional<T>, Compare, Allocator>::operator[](k);
if (v.has_value())
return v;
else {
v.set(0);
return v;
}
}
template <class U> void operator[](U) {
static string mes = "s_map cant []";
assert2(0, mes);
}
};
// 以下、空のoptionalをnulloptと書く
// ov[-1(参照外)] でnulloptを返す
// ov[nullopt] で nulloptをかえす
template <class T> struct ov {
optional<T> emp;
vector<optional<T>> v;
ov(int i = 0, T val = 0) : v(i, val) {}
template <class U> ov(const U &rhs) {
v.resize(sz(rhs));
for (int i = 0; i < sz(rhs); i++)
v[i].set(rhs[i]);
}
optional<T> &operator()(int i) {
if (i < 0 || sz(v) <= i) {
emp.reset();
return emp;
} else {
return v[i];
}
}
optional<T> &operator()(const nullopt_t &) { return operator()(-1); }
optional<T> &operator()(const optional<T> &i) {
if (i.has_value())
return operator()(i.value());
else {
return operator()(-1);
}
}
/*@formatter:off*/
};
template <class T> string deb_tos(const ov<T> &v) { return deb_tos(v.v); }
// vectorに対しての処理は.vを呼ぶ
template <class T> class ovv {
optional<T> emp;
public:
vector<vector<optional<T>>> v;
ovv(int i = 0, int j = 0, T val = 0) : v(i, vector<optional<T>>(j, val)) {}
optional<T> &operator()(int i, int j) {
if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) {
return emp;
} else {
return v[i][j];
}
}
// 再帰ver 遅いと思う
// optional<T>& gets(optional<T>& v){return v;}
// template<class V, class H, class... U> optional<T>& gets(V& v, H i, U...
// tail){ if constexpr(is_same2(H, nullopt_t))return
// operator()(-1,-1); else if constexpr(is_same2(H, optional<int>)){
// if(i.has_value())return gets(v[(int)i], tail...); else return
// operator()(-1,-1); }else if constexpr(is_integral<H>::value){
// return gets(v[(int)i], tail...); }else{ assert(0);
// return emp; } }
#if __cplusplus >= 201703L
// if constexprバージョン 上が遅かったらこれで
template <class U, class V>
optional<T> &operator()(const U &i, const V &j) { /*駄目な場合を除外*/
if constexpr (is_same2(U, nullopt_t) || is_same2(U, nullopt_t)) {
return operator()(-1, -1); /* o, o*/
} else if constexpr (is_same2(U, optional<int>) &&
is_same2(V, optional<int>)) {
return operator()(i.has_value() ? (int)i : -1,
j.has_value() ? (int)j : -1); /* o, x*/
} else if constexpr (is_same2(U, optional<int>)) {
return operator()(i.has_value() ? (int)i : -1, (int)j); /* x, o*/
} else if constexpr (is_same2(V, optional<int>)) {
return operator()((int)i, j.has_value() ? (int)j : -1); /* x, x*/
} else {
return operator()((int)i, (int)j);
}
}
#endif
operator const vector<vector<optional<T>>> &() { return v; }
};
template <class T> istream &operator>>(istream &iss, ovv<T> &a) {
for (int h = 0; h < sz(a); h++) {
for (int w = 0; w < sz(a[h]); w++) {
iss >> a.v[h][w];
}
}
return iss;
}
template <class T> string deb_tos(const ovv<T> &v) { return deb_tos(v.v); }
template <class T> struct ov3 {
optional<T> emp;
vector<vector<vector<optional<T>>>> v;
ov3(int i, int j, int k, T val = 0)
: v(i, vector<vector<optional<T>>>(j, vector<optional<T>>(k, val))) {}
optional<T> &operator()(int i, int j, int k) {
if (i < 0 || j < 0 || sz(v) <= i || sz(v[i]) <= j) {
if (k < 0 || sz(v[i][j]) <= k) {
emp.reset();
return emp;
}
}
return v[i][j][k];
}
private:
#if __cplusplus >= 201703L
// 再帰ver 遅いと思う
template <class V, class H> optional<T> &gets(V &nowv, H i) {
if constexpr (is_same2(H, nullopt_t)) {
return emp;
} else if constexpr (is_same2(H, optional<int>)) {
if (i.has_value()) {
return nowv[(int)i];
} else {
return emp;
}
} else if constexpr (is_integral<H>::value) {
return nowv[(int)i];
} else {
static string mes = "ov3 error not index";
assert2(0, mes);
return emp;
}
}
// todo const &消した
template <class V, class H, class... U>
optional<T> &gets(V &nowv, H i, U... tail) {
if constexpr (is_same2(H, nullopt_t)) {
return emp;
} else if constexpr (is_same2(H, optional<int>)) {
if (i.has_value()) {
return gets(nowv[(int)i], tail...);
} else {
return emp;
}
} else if constexpr (is_integral<H>::value) {
return gets(nowv[(int)i], tail...);
} else {
static string mes = "ov3 error not index";
assert2(0, mes);
return emp;
}
}
#endif
public:
template <class U, class V, class W> optional<T> &operator()(U i, V j, W k) {
return gets(v, i, j, k);
}
/*@formatter:off*/
};
template <class T> string deb_tos(const ov3<T> &v) { return deb_tos(v.v); }
// nullopt_t
// 優先順位
// null, [opt, tem]
// + と += は違う意味を持つ
// val+=null : val
// val+null : null
//
//+は途中計算
//+=は最終的に格納したい値にだけ持たせる
//+=がvoidを返すのは、途中計算で使うのを抑制するため
// nulloptを考慮する際、計算途中では+を使ってnulloptを作り
// 格納する際は+=で無効にする必要がある
// 演算子==
// optional<int>(10) == 10
// 全ての型に対応させ、value_typeが等しいかを見るようにするのもありかも
// null同士を比較する状況はおかしいのではないか
bool operator==(const nullopt_t &, const nullopt_t &) {
assert2(0, "nul == null cant hikaku");
return false;
}
template <class T> bool operator==(const nullopt_t &, const T &) {
return false;
}
template <class T> bool operator!=(const nullopt_t &, const T &) {
return true;
}
template <class T> bool operator==(const T &, const nullopt_t &) {
return false;
}
template <class T> bool operator!=(const T &, const nullopt_t &) {
return true;
}
// nullを
nullopt_t &operator+(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator-(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator*(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator/(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator+=(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator-=(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator*=(const nullopt_t &, const nullopt_t &) { return nullopt; }
nullopt_t &operator/=(const nullopt_t &, const nullopt_t &) { return nullopt; }
template <class ANY> nullopt_t operator+(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator-(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator*(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator/(const nullopt_t &, const ANY &) {
return nullopt;
}
template <class ANY> nullopt_t operator+(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> nullopt_t operator-(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> nullopt_t operator*(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> nullopt_t operator/(const ANY &, const nullopt_t &) {
return nullopt;
}
template <class ANY> void operator+=(nullopt_t &, const ANY &) {}
template <class ANY> void operator-=(nullopt_t &, const ANY &) {}
template <class ANY> void operator*=(nullopt_t &, const ANY &) {}
template <class ANY> void operator/=(nullopt_t &, const ANY &) {}
template <class ANY> void operator+=(ANY &, const nullopt_t &) {}
template <class ANY> void operator-=(ANY &, const nullopt_t &) {}
template <class ANY> void operator*=(ANY &, const nullopt_t &) {}
template <class ANY> void operator/=(ANY &, const nullopt_t &) {}
template <class T> struct is_optional : false_type {};
template <class T> struct is_optional<optional<T>> : true_type {};
template <class T, class U>
true_type both_optional(optional<T> t, optional<U> u);
false_type both_optional(...);
template <class T, class U>
class opt_check : public decltype(both_optional(declval<T>(), declval<U>())) {};
// optionalは同じ型同士しか足せない
//(o, t), (t, o), (o, o)
#define opt_tem(op) \
template <class O, class O_ret = decltype(declval<O>() op declval<O>())> \
optional<O_ret> operator op(const optional<O> &opt1, \
const optional<O> &opt2) { \
if (!opt1.has_value() || !opt2.has_value()) { \
return optional<O_ret>(); \
} else { \
return optional<O_ret>(opt1.value() op opt2.value()); \
} \
} \
template <class O, class T, \
class O_ret = decltype(declval<O>() op declval<O>())> \
auto operator op(const optional<O> &opt, const T &tem) \
->require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { \
if (!opt.has_value()) { \
return optional<O_ret>(); \
} else { \
return optional<O_ret>(opt.value() op tem); \
} \
} \
template <class O, class T, \
class O_ret = decltype(declval<O>() op declval<O>())> \
auto operator op(const T &tem, const optional<O> &opt) \
->require_ret(!(opt_check<optional<O>, T>::value), optional<O_ret>) { \
if (!opt.has_value()) { \
return optional<O_ret>(); \
} else { \
return optional<O_ret>(opt.value() op tem); \
} \
}
/*@formatter:off*/
opt_tem(+) opt_tem(-) opt_tem(*) opt_tem(/)
// 比較はoptional<bool>を返す
opt_tem(<) opt_tem(>) opt_tem(<=) opt_tem(>=)
/*@formatter:on*/ /*@formatter:off*/
template <class O, class T>
bool operator==(const optional<O> &opt, const T &tem) {
if (opt.has_value()) {
return opt.value() == tem;
} else
return nullopt == tem;
}
template <class O, class T>
bool operator!=(const optional<O> &opt, const T &tem) {
if (opt.has_value()) {
return opt.value() != tem;
} else
return nullopt != tem;
}
template <class O, class T>
bool operator==(const T &tem, const optional<O> &opt) {
if (opt.has_value()) {
return opt.value() == tem;
} else
return nullopt == tem;
}
template <class O, class T>
bool operator!=(const T &tem, const optional<O> &opt) {
if (opt.has_value()) {
return opt.value() != tem;
} else
return nullopt != tem;
}
template <class O>
bool operator==(const optional<O> &opt1, const optional<O> &opt2) {
if (opt1.has_value() != opt2.has_value()) {
return false;
} else if (opt1.has_value()) {
return opt1.value() == opt2.value();
} else {
return nullopt == nullopt;
}
}
template <class O>
bool operator!=(const optional<O> &opt1, const optional<O> &opt2) {
return !(opt1 == opt2);
}
//(a+=null) != (a=a+null)
// a null
template <class T, class O> void operator+=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem += opt.value();
}
}
template <class T, class O> void operator-=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem -= opt.value();
}
}
template <class T, class O> void operator*=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem *= opt.value();
}
}
template <class T, class O> void operator/=(T &tem, const optional<O> &opt) {
if (opt.has_value()) {
tem /= opt.value();
}
}
template <class T, class O> void operator+=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() += tem;
}
}
template <class T, class O> void operator-=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() -= tem;
}
}
template <class T, class O> void operator*=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() *= tem;
}
}
template <class T, class O> void operator/=(optional<O> &opt, const T &tem) {
if (opt.has_value()) {
opt.value() /= tem;
}
}
//
template <class Ol, class Or>
void operator+=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl += opr.value();
}
}
template <class Ol, class Or>
void operator-=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl -= opr.value();
}
}
template <class Ol, class Or>
void operator*=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl *= opr.value();
}
}
template <class Ol, class Or>
void operator/=(optional<Ol> &opl, const optional<Or> &opr) {
if (opr.has_value()) {
return opl /= opr.value();
}
}
/*@formatter:off*/
template <class U> auto max(const nullopt_t &, const U &val) { return val; }
template <class U> auto max(const U &val, const nullopt_t &) { return val; }
template <class U> auto min(const nullopt_t &, const U &val) { return val; }
template <class U> auto min(const U &val, const nullopt_t &) { return val; }
template <class T, class U> auto max(const optional<T> &opt, const U &val) {
if (opt.has_value())
return max(opt.value(), val);
else
return val;
}
template <class T, class U> auto max(const U &val, const optional<T> &opt) {
if (opt.has_value())
return max(opt.value(), val);
else
return val;
}
template <class T, class U> auto min(const optional<T> &opt, const U &val) {
if (opt.has_value())
return min(opt.value(), val);
else
return val;
}
template <class T, class U> auto min(const U &val, const optional<T> &opt) {
if (opt.has_value())
return min(opt.value(), val);
else
return val;
}
// null , optional, T
bool chma(nullopt_t &, const nullopt_t &) { return false; }
template <class T> bool chma(T &opt, const nullopt_t &) { return false; }
template <class T> bool chma(nullopt_t &, const T &opt) { return false; }
template <class T> bool chma(optional<T> &olv, const optional<T> &orv) {
if (orv.has_value()) {
return chma(olv, orv.value());
} else
return false;
}
template <class T, class U> bool chma(optional<T> &opt, const U &rhs) {
if (opt.has_value()) {
return chma(opt.value(), rhs);
} else
return false;
}
template <class T, class U> bool chma(T &lhs, const optional<U> &opt) {
if (opt.has_value()) {
return chma(lhs, opt.value());
} else
return false;
}
bool chmi(nullopt_t &, const nullopt_t &) { return false; }
template <class T> bool chmi(T &opt, const nullopt_t &) { return false; }
template <class T> bool chmi(nullopt_t &, const T &opt) { return false; }
template <class T> bool chmi(optional<T> &olv, const optional<T> &orv) {
if (orv.has_value()) {
return chmi(olv, orv.value());
} else
return false;
}
template <class T, class U> bool chmi(optional<T> &opt, const U &rhs) {
if (opt.has_value()) {
return chmi(opt.value(), rhs);
} else
return false;
}
template <class T, class U> bool chmi(T &lhs, const optional<U> &opt) {
if (opt.has_value()) {
return chmi(lhs, opt.value());
} else
return false;
}
template <class T> ostream &operator<<(ostream &os, optional<T> p) {
if (p.has_value())
os << p.value();
else
os << "e";
return os;
}
struct xorshift {
/*@formatter:on*/
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
/*@formatter:off*/
size_t operator()(const uint64_t &x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
size_t operator()(const std::pair<ll, ll> &x) const {
ll v = ((x.first) << 32) | x.second;
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(v + FIXED_RANDOM);
}
template <class T, class U>
size_t operator()(const std::pair<T, U> &x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
uint64_t hasx = splitmix64(x.first);
uint64_t hasy = splitmix64(x.second + FIXED_RANDOM);
return hasx ^ hasy;
}
template <class T> size_t operator()(const vector<T> &x) const {
uint64_t has = 0;
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
uint64_t rv = splitmix64(FIXED_RANDOM);
for (int i = 0; i < sz(x); i++) {
uint64_t v = splitmix64(x[i] + rv);
has ^= v;
rv = splitmix64(rv);
}
return has;
}
};
#ifdef _DEBUG
string message;
string res_mes;
// #define use_debtor
// template<class T, class U, class X> auto count(unordered_map<T, U> &a, X k) {
// return a.find(k) != a.end(); }
#ifdef use_debtor
// https://marycore.jp/prog/cpp/class-extension-methods/ 違うかも
template <class T, class A = std::allocator<T>>
struct debtor : std::vector<T, A> {
using std::vector<T, A>::vector;
template <class U> int deb_v(U a, int v) { return v; }
template <class U> int deb_v(debtor<U> &a, int v = 0) {
cerr << a.size() << " ";
return deb_v(a.at(0), v + 1);
}
template <class U> void deb_o(U a) { cerr << a << " "; }
template <class U> void deb_o(debtor<U> &a) {
for (int i = 0; i < min((int)a.size(), 15ll); i++) {
deb_o(a[i]);
}
if ((int)a.size() > 15) {
cerr << "...";
}
cerr << endl;
}
typename std::vector<T>::reference my_at(typename std::vector<T>::size_type n,
vector<int> &ind) {
if (n < 0 || n >= (int)this->size()) {
int siz = (int)this->size();
cerr << "vector size = ";
int dim = deb_v((*this));
cerr << endl;
ind.push_back(n);
cerr << "out index at ";
for (auto &&i : ind) {
cerr << i << " ";
}
cerr << endl;
cerr << endl;
if (dim <= 2) {
deb_o((*this));
}
exit(0);
}
return this->at(n);
}
typename std::vector<T>::reference
operator[](typename std::vector<T>::size_type n) {
if (n < 0 || n >= (int)this->size()) {
int siz = (int)this->size();
cerr << "vector size = ";
int dim = deb_v((*this));
cerr << endl;
cerr << "out index at " << n << endl;
cerr << endl;
if (dim <= 2) {
deb_o((*this));
}
exit(0);
}
return this->at(n);
}
};
#define vector debtor
#endif
#ifdef use_pbds
template <class T> struct my_pbds_tree {
set<T> s;
auto begin() { return s.begin(); }
auto end() { return s.end(); }
auto rbegin() { return s.rbegin(); }
auto rend() { return s.rend(); }
auto empty() { return s.empty(); }
auto size() { return s.size(); }
void clear() { s.clear(); }
template <class U> void insert(U v) { s.insert(v); }
template <class U> void operator+=(U v) { insert(v); }
template <class F> auto erase(F v) { return s.erase(v); }
template <class U> auto find(U v) { return s.find(v); }
template <class U> auto lower_bound(U v) { return s.lower_bound(v); }
template <class U> auto upper_bound(U v) { return s.upper_bound(v); }
auto find_by_order(ll k) {
auto it = s.begin();
for (ll i = 0; i < k; i++)
it++;
return it;
}
auto order_of_key(ll v) {
auto it = s.begin();
ll i = 0;
for (; it != s.end() && *it < v; i++)
it++;
return i;
}
};
#define pbds(T) my_pbds_tree<T>
#endif
// 区間削除は出来ない
// gp_hash_tableでcountを使えないようにするため
template <class T, class U> struct my_unordered_map {
unordered_map<T, U> m;
my_unordered_map(){};
auto begin() { return m.begin(); }
auto end() { return m.end(); }
auto cbegin() { return m.cbegin(); }
auto cend() { return m.cend(); }
template <class V> auto erase(V v) { return m.erase(v); }
void clear() {
m.clear();
} /*countは gp_hash_tableに存在しない*/ /*!= m.end()*/
template <class V> auto find(V v) { return m.find(v); }
template <class V> auto &operator[](V n) { return m[n]; }
};
template <class K, class V> using umap_f = my_unordered_map<K, V>;
#else
#define endl '\n'
// umapはunorderd_mapになる
// umapiはgp_hash_table
// find_by_order(k) k番目のイテレーター
// order_of_key(k) k以上が前から何番目か
#define pbds(U) \
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag, \
__gnu_pbds::tree_order_statistics_node_update>
template <class K, class V>
using umap_f = __gnu_pbds::gp_hash_table<K, V, xorshift>;
#endif
#define umapi unordered_map<ll, ll>
#define umapp unordered_map<P, ll>
#define umappp unordered_map<P, P>
#define umapu unordered_map<uint64_t, ll>
#define umapip unordered_map<ll, P>
template <class T, class U, class X> auto count(unordered_map<T, U> &a, X k) {
return a.find(k) != a.end();
}
/*@formatter:off*/
#ifdef use_pbds
template <class U, class L>
void operator+=(
__gnu_pbds::tree<U, __gnu_pbds::null_type, less<U>, __gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update> &s,
L v) {
s.insert(v);
}
#endif
// 衝突対策
#define ws ws_
// todo 要らないと思う
template <class A, class B, class C> struct T2 {
A f;
B s;
C t;
T2() { f = 0, s = 0, t = 0; }
T2(A f, B s, C t) : f(f), s(s), t(t) {}
bool operator<(const T2 &r) const {
return f != r.f ? f < r.f
: s != r.s ? s < r.s
: t < r.t; /*return f != r.f ? f > r.f : s != r.s ?n s >
r.s : t > r.t; 大きい順 */
}
bool operator>(const T2 &r) const {
return f != r.f ? f > r.f
: s != r.s ? s > r.s
: t > r.t; /*return f != r.f ? f > r.f : s != r.s ? s >
r.s : t > r.t; 小さい順 */
}
bool operator==(const T2 &r) const {
return f == r.f && s == r.s && t == r.t;
}
bool operator!=(const T2 &r) const {
return f != r.f || s != r.s || t != r.t;
}
};
template <class A, class B, class C, class D> struct F2 {
A a;
B b;
C c;
D d;
F2() { a = 0, b = 0, c = 0, d = 0; }
F2(A a, B b, C c, D d) : a(a), b(b), c(c), d(d) {}
bool operator<(const F2 &r) const {
return a != r.a ? a < r.a
: b != r.b ? b < r.b
: c != r.c ? c < r.c
: d < r.d; /* return a != r.a ? a > r.a : b != r.b ? b
> r.b : c != r.c ? c > r.c : d > r.d;*/
}
bool operator>(const F2 &r) const {
return a != r.a ? a > r.a
: b != r.b ? b > r.b
: c != r.c ? c > r.c
: d > r.d; /* return a != r.a ? a < r.a : b != r.b
? b < r.b : c != r.c ? c < r.c : d < r.d;*/
}
bool operator==(const F2 &r) const {
return a == r.a && b == r.b && c == r.c && d == r.d;
}
bool operator!=(const F2 &r) const {
return a != r.a || b != r.b || c != r.c || d != r.d;
}
ll operator[](ll i) {
assert(i < 4);
return i == 0 ? a : i == 1 ? b : i == 2 ? c : d;
}
};
typedef T2<ll, ll, ll> T;
typedef F2<ll, ll, ll, ll> F;
// T mt(ll a, ll b, ll c) { return T(a, b, c); }
// F mf(ll a, ll b, ll c, ll d) { return F(a, b, c, d); }
// 関数内をまとめる
// 初期値l=-1, r=-1
void set_lr12(int &l, int &r, int n) { /*r==-1*/
if (r == -1) {
if (l == -1) {
l = 0;
r = n;
} else {
r = l;
l = 0;
}
}
}
//@マクロ省略系 型,構造
// using で元のdoubleを同時に使えるはず
#define double_big
#ifdef double_big
#define double long double
// #define pow powl
#endif
using dou = double;
/*@formatter:off*/
template <class T> T MAX() { return numeric_limits<T>::max(); }
template <class T> T MIN() { return numeric_limits<T>::min(); }
constexpr ll inf = (ll)1e9 + 100;
constexpr ll linf = (ll)1e18 + 100;
constexpr dou dinf = (dou)linf * linf;
constexpr char infc = '{';
const string infs = "{";
template <class T> T INF() { return MAX<T>() / 2; }
template <> signed INF() { return inf; }
template <> ll INF() { return linf; }
template <> double INF() { return dinf; }
template <> char INF() { return infc; }
template <> string INF() { return infs; }
const double eps = 1e-9;
// #define use_epsdou
#ifdef use_epsdou
// 基本コメントアウト
struct epsdou {
double v;
epsdou(double v = 0) : v(v) {}
template <class T> epsdou &operator+=(T b) {
v += (double)b;
return (*this);
}
template <class T> epsdou &operator-=(T b) {
v -= (double)b;
return (*this);
}
template <class T> epsdou &operator*=(T b) {
v *= (double)b;
return (*this);
}
template <class T> epsdou &operator/=(T b) {
v /= (double)b;
return (*this);
}
epsdou operator+(epsdou b) { return v + (double)b; }
epsdou operator-(epsdou b) { return v - (double)b; }
epsdou operator*(epsdou b) { return v * (double)b; }
epsdou operator/(epsdou b) { return v / (double)b; }
epsdou operator-() const { return epsdou(-v); }
template <class T> bool operator<(T b) { return v < (double)b; }
template <class T> bool operator>(T b) {
auto r = (double)b;
return v > (double)b;
}
template <class T> bool operator==(T b) { return fabs(v - (double)b) <= eps; }
template <class T> bool operator<=(T b) {
return v < (double)b || fabs(v - b) <= eps;
}
template <class T> bool operator>=(T b) {
return v > (double)b || fabs(v - b) <= eps;
}
operator double() { return v; }
};
template <> epsdou MAX() { return MAX<double>(); }
template <> epsdou MIN() { return MIN<double>(); }
// priqrity_queue等で使うのに必要
bool operator<(const epsdou &a, const epsdou &b) { return a.v < b.v; }
bool operator>(const epsdou &a, const epsdou &b) { return a.v > b.v; }
istream &operator>>(istream &iss, epsdou &a) {
iss >> a.v;
return iss;
}
ostream &operator<<(ostream &os, epsdou &a) {
os << a.v;
return os;
}
#define eps_conr_t(o) \
template <class T> epsdou operator o(T a, epsdou b) { return (dou)a o b.v; }
#define eps_conl_t(o) \
template <class T> epsdou operator o(epsdou a, T b) { return a.v o(dou) b; }
eps_conl_t(+) eps_conl_t(-) eps_conl_t(*) eps_conl_t(/) eps_conr_t(+)
eps_conr_t(-) eps_conr_t(*) eps_conr_t(/)
// template<class U> epsdou max(epsdou a, U b){return a.v>b ? a.v: b;}
// template<class U> epsdou max(U a, epsdou b){return a>b.v ? a: b.v;}
// template<class U> epsdou min(epsdou a, U b){return a.v<b ? a.v: b;}
// template<class U> epsdou min(U a, epsdou b){return a<b.v ? a: b.v;}
#undef double
#define double epsdou
#undef dou
#define dou epsdou
#endif
template <class T = int, class A, class B = int>
auto my_pow(A a, B b = 2) {
#if __cplusplus >= 201703L
if constexpr (is_floating_point<T>::value) {
return pow((T)a, (T)b);
} else if constexpr (is_floating_point<A>::value) {
assert2(
0,
"pow <not dou>(dou, )"); /*return
0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/
} else if constexpr (is_floating_point<B>::value) {
assert2(
0,
"pow <not dou>(, dou)"); /*return
0;しない方がコンパイル前に(voidを受け取るので)エラーが出ていいかも*/
} else {
#endif
T ret = 1;
T bek = a;
while (b) {
if (b & 1)
ret *= bek;
bek *= bek;
b >>= 1;
}
return ret;
#if __cplusplus >= 201703L
}
#endif
}
#define pow my_pow
#define ull unsigned long long
using itn = int;
using str = string;
using bo = bool;
#define au auto
using P = pair<ll, ll>;
#define fi first
#define se second
#define beg begin
#define rbeg rbegin
#define con continue
#define bre break
#define brk break
#define is ==
#define el else
#define elf else if
#define upd update
#define sstream stringstream
#define maxq 1
#define minq -1
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
#define MALLOC(type, len) (type *)malloc((len) * sizeof(type))
#define lam1(ret) [&](auto &&v) { return ret; }
#define lam2(v, ret) [&](auto &&v) { return ret; }
#define lam(...) over2(__VA_ARGS__, lam2, lam1)(__VA_ARGS__)
#define lamr(right) [&](auto &&p) { return p right; }
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
// マクロ省略系 コンテナ
using vi = vector<ll>;
using vb = vector<bool>;
using vs = vector<string>;
using vd = vector<double>;
using vc = vector<char>;
using vp = vector<P>;
using vt = vector<T>;
// #define V vector
#define vvt0(t) vector<vector<t>>
#define vvt1(t, a) vector<vector<t>> a
#define vvt2(t, a, b) vector<vector<t>> a(b)
#define vvt3(t, a, b, c) vector<vector<t>> a(b, vector<t>(c))
#define vvt4(t, a, b, c, d) vector<vector<t>> a(b, vector<t>(c, d))
#define vvi(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(ll, __VA_ARGS__)
#define vvb(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(bool, __VA_ARGS__)
#define vvs(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(string, __VA_ARGS__)
#define vvd(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(double, __VA_ARGS__)
#define vvc(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(char, __VA_ARGS__)
#define vvp(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(P, __VA_ARGS__)
#define vvt(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(T, __VA_ARGS__)
#define vv(type, ...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(type, __VA_ARGS__)
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
#define vni(name, ...) auto name = make_v<ll>(__VA_ARGS__)
#define vnb(name, ...) auto name = make_v<bool>(__VA_ARGS__)
#define vns(name, ...) auto name = make_v<string>(__VA_ARGS__)
#define vnd(name, ...) auto name = make_v<double>(__VA_ARGS__)
#define vnc(name, ...) auto name = make_v<char>(__VA_ARGS__)
#define vnp(name, ...) auto name = make_v<P>(__VA_ARGS__)
#define vn(type, name, ...) auto name = make_v<type>(__VA_ARGS__)
#define PQ priority_queue<ll, vector<ll>, greater<ll>>
#define tos to_string
using mapi = map<ll, ll>;
using mapp = map<P, ll>;
using mapd = map<dou, ll>;
using mapc = map<char, ll>;
using maps = map<str, ll>;
using seti = set<ll>;
using setp = set<P>;
using setd = set<dou>;
using setc = set<char>;
using sets = set<str>;
using qui = queue<ll>;
#define uset unordered_set
#define useti unordered_set<ll, xorshift>
#define mset multiset
#define mseti multiset<ll>
#define umap unordered_map
#define mmap multimap
// 任意のマクロサポート用 使う度に初期化する
int index_, v1_, v2_, v3_;
/*@formatter:off*/
string to_string(char c) {
string ret = "";
ret += c;
return ret;
}
template <class T> class pq_min_max {
vector<T> d;
void make_heap() {
for (int i = d.size(); i--;) {
if (i & 1 && d[i - 1] < d[i])
swap(d[i - 1], d[i]);
int k = down(i);
up(k, i);
}
}
inline int parent(int k) const { return ((k >> 1) - 1) & ~1; }
int down(int k) {
int n = d.size();
if (k & 1) { /* min heap*/
while (2 * k + 1 < n) {
int c = 2 * k + 3;
if (n <= c || d[c - 2] < d[c])
c -= 2;
if (c < n && d[c] < d[k]) {
swap(d[k], d[c]);
k = c;
} else
break;
}
} else { /* max heap*/
while (2 * k + 2 < n) {
int c = 2 * k + 4;
if (n <= c || d[c] < d[c - 2])
c -= 2;
if (c < n && d[k] < d[c]) {
swap(d[k], d[c]);
k = c;
} else
break;
}
}
return k;
}
int up(int k, int root = 1) {
if ((k | 1) < (int)d.size() && d[k & ~1] < d[k | 1]) {
swap(d[k & ~1], d[k | 1]);
k ^= 1;
}
int p;
while (root < k && d[p = parent(k)] < d[k]) { /*max heap*/
swap(d[p], d[k]);
k = p;
}
while (root < k && d[k] < d[p = parent(k) | 1]) { /* min heap*/
swap(d[p], d[k]);
k = p;
}
return k;
}
public:
pq_min_max() {}
pq_min_max(const vector<T> &d_) : d(d_) { make_heap(); }
template <class Iter> pq_min_max(Iter first, Iter last) : d(first, last) {
make_heap();
}
void operator+=(const T &x) {
int k = d.size();
d.push_back(x);
up(k);
}
void pop_min() {
if (d.size() < 3u) {
d.pop_back();
} else {
swap(d[1], d.back());
d.pop_back();
int k = down(1);
up(k);
}
}
void pop_max() {
if (d.size() < 2u) {
d.pop_back();
} else {
swap(d[0], d.back());
d.pop_back();
int k = down(0);
up(k);
}
}
const T &get_min() const { return d.size() < 2u ? d[0] : d[1]; }
const T &get_max() const { return d[0]; }
int size() const { return d.size(); }
bool empty() const { return d.empty(); }
};
// 小さいほうからM個取得するpq
template <class T> struct helper_pq_size {
pq_min_max<T> q;
T su = 0;
int max_size = 0;
helper_pq_size() {}
helper_pq_size(int max_size) : max_size(max_size) {}
void clear() {
q = pq_min_max<T>();
su = 0;
}
void operator+=(T v) {
su += v;
q += (v);
if (sz(q) > max_size) {
su -= q.get_max();
q.pop_max();
}
}
T sum() { return su; }
T top() { return q.get_min(); }
void pop() {
su -= q.get_min();
q.pop_min();
}
T poll() {
T ret = q.get_min();
su -= ret;
q.pop_min();
return ret;
}
ll size() { return q.size(); }
};
// 大きいほうからM個取得するpq
template <class T> struct helper_pqg_size {
pq_min_max<T> q;
T su = 0;
int max_size = 0;
helper_pqg_size() {}
helper_pqg_size(int max_size) : max_size(max_size) {}
void clear() {
q = pq_min_max<T>();
su = 0;
}
void operator+=(T v) {
su += v;
q += (v);
if (sz(q) > max_size) {
su -= q.get_min();
q.pop_min();
}
}
T sum() { return su; }
T top() { return q.get_max(); }
void pop() {
su -= q.get_max();
q.pop_max();
}
T poll() {
T ret = q.get_max();
su -= ret;
q.pop_min();
return ret;
}
ll size() { return q.size(); }
};
;
template <class T, class Container = vector<T>,
class Compare = std::less<typename Container::value_type>>
struct helper_pqg {
priority_queue<T, Container, Compare> q; /*小さい順*/
T su = 0;
helper_pqg() {}
void clear() {
q = priority_queue<T, vector<T>, greater<T>>();
su = 0;
}
void operator+=(T v) {
su += v;
q.push(v);
}
T sum() { return su; }
T top() { return q.top(); }
void pop() {
su -= q.top();
q.pop();
}
T poll() {
T ret = q.top();
su -= ret;
q.pop();
return ret;
}
ll size() { return q.size(); }
};
template <class T> using helper_pq = helper_pqg<T, vector<T>, greater<T>>;
#if __cplusplus >= 201703L
// 小さいほうからsize個残る
// Tがoptionalなら空の時nullを返す
template <class T> struct pq {
helper_pq<T> a_q; /*大きい順*/
helper_pq_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pq(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pq_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
// optionalなら空の時nullを返す
T top() {
if constexpr (is_optional<T>::value) {
if (aquery) {
if (sz(a_q) == 0)
return T();
return a_q.top();
} else {
if (sz(b_q) == 0)
return T();
return b_q.top();
}
} else {
if (aquery)
return a_q.top();
else
return b_q.top();
}
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
// optionalなら空の時何もしない
void pop() {
if constexpr (is_optional<T>::value) {
if (aquery) {
if (sz(a_q))
a_q.pop();
} else {
if (sz(b_q))
b_q.pop();
}
} else {
if (aquery)
a_q.pop();
else
b_q.pop();
}
} /*T*/
T poll() {
if constexpr (is_optional<T>::value) {
if (aquery) {
if (sz(a_q) == 0)
return T();
return a_q.poll();
} else {
if (sz(b_q) == 0)
return T();
return b_q.poll();
}
} else {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
/*@formatter:off*/
};
template <class T> struct pqg {
helper_pqg<T> a_q; /*大きい順*/
helper_pqg_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pqg(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pqg_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
T top() {
if (aquery)
return a_q.top();
else
return b_q.top();
}
void pop() {
if (aquery)
a_q.pop();
else
b_q.pop();
}
T poll() {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
};
#else
// 小さいほうからsize個残る
template <class T> struct pq {
helper_pq<T> a_q; /*大きい順*/
helper_pq_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pq(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pq_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
T top() {
if (aquery)
return a_q.top();
else
return b_q.top();
}
void pop() {
if (aquery)
a_q.pop();
else
b_q.pop();
}
T poll() {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
};
// 大きいほうからsize個残る
template <class T> struct pqg {
helper_pqg<T> a_q; /*大きい順*/
helper_pqg_size<T> b_q; /*大きい順*/
bool aquery;
T su = 0;
pqg(int size = inf) {
aquery = size == inf;
if (!aquery) {
b_q = helper_pqg_size<T>(size);
}
}
void clear() {
if (aquery)
a_q.clear();
else
b_q.clear();
}
void operator+=(T v) {
if (aquery)
a_q += v;
else
b_q += v;
}
T sum() {
if (aquery)
return a_q.sum();
else
return b_q.sum();
}
T top() {
if (aquery)
return a_q.top();
else
return b_q.top();
}
void pop() {
if (aquery)
a_q.pop();
else
b_q.pop();
}
T poll() {
if (aquery)
return a_q.poll();
else
return b_q.poll();
}
ll size() {
if (aquery)
return a_q.size();
else
return b_q.size();
}
};
#endif
#define pqi pq<ll>
#define pqgi pqg<ll>
template <class T> string deb_tos(pq<T> &q) {
vector<T> res;
auto temq = q;
while (sz(temq))
res.push_back(temq.top()), temq.pop();
stringstream ss;
ss << res;
return ss.str();
}
template <class T> string deb_tos(pqg<T> &q) {
vector<T> res;
auto temq = q;
while (sz(temq))
res.push_back(temq.top()), temq.pop();
stringstream ss;
ss << res;
return ss.str();
}
/*@formatter:off*/
// マクロ 繰り返し
// ↓@オーバーロード隔離
// todo 使わないもの非表示
#define rep1(n) for (ll rep1i = 0, rep1lim = n; rep1i < rep1lim; ++rep1i)
#define rep2(i, n) for (ll i = 0, rep2lim = n; i < rep2lim; ++i)
#define rep3(i, m, n) for (ll i = m, rep3lim = n; i < rep3lim; ++i)
#define rep4(i, m, n, ad) for (ll i = m, rep4lim = n; i < rep4lim; i += ad)
// 逆順 閉区間
#define rer2(i, n) for (ll i = n; i >= 0; i--)
#define rer3(i, m, n) for (ll i = m, rer3lim = n; i >= rer3lim; i--)
#define rer4(i, m, n, dec) for (ll i = m, rer4lim = n; i >= rer4lim; i -= dec)
#ifdef use_for
// ループを一つにまとめないとフォーマットで汚くなるため
#define nex_ind1(i) i++
#define nex_ind2(i, j, J) \
i = (j + 1 == J) ? i + 1 : i, j = (j + 1 == J ? 0 : j + 1)
#define nex_ind3(i, j, k, J, K) \
i = (j + 1 == J && k + 1 == K) ? i + 1 : i, \
j = (k + 1 == K) ? (j + 1 == J ? 0 : j + 1) : j, \
k = (k + 1 == K ? 0 : k + 1)
#define nex_ind4(i, j, k, l, J, K, L) \
i = (j + 1 == J && k + 1 == K && l + 1 == L) ? i + 1 : i, \
j = (k + 1 == K && l + 1 == L) ? (j + 1 == J ? 0 : j + 1) : j, \
k = (l + 1 == L ? (k + 1 == K ? 0 : k + 1) : k), l = l + 1 == L ? 0 : l + 1
#define nex_ind5(i, j, k, l, m, J, K, L, M) \
i = (j + 1 == J && k + 1 == K && l + 1 == L && m + 1 == M) ? i + 1 : i, \
j = (k + 1 == K && l + 1 == L && m + 1 == M) ? (j + 1 == J ? 0 : j + 1) : j, \
k = (l + 1 == L && m + 1 == M ? (k + 1 == K ? 0 : k + 1) : k), \
l = m + 1 == M ? l + 1 == L ? 0 : l + 1 : l, m = m + 1 == M ? 0 : m + 1
#define repss2(i, I) for (int i = 0; i < I; i++)
#define repss4(i, j, I, J) \
for (int i = (J ? 0 : I), j = 0; i < I; nex_ind2(i, j, J))
#define repss6(i, j, k, I, J, K) \
for (int i = (J && K ? 0 : I), j = 0, k = 0; i < I; nex_ind3(i, j, k, J, K))
#define repss8(i, j, k, l, I, J, K, L) \
for (int i = (J && K && L ? 0 : I), j = 0, k = 0, l = 0; i < I; \
nex_ind4(i, j, k, l, J, K, L))
#define repss10(i, j, k, l, m, I, J, K, L, M) \
for (int i = (J && K && L && M ? 0 : I), j = 0, k = 0, l = 0, m = 0; i < I; \
nex_ind5(i, j, k, l, m, J, K, L, M))
// i,j,k...をnまで見る
#define reps2(i, n) repss2(i, n)
#define reps3(i, j, n) repss4(i, j, n, n)
#define reps4(i, j, k, n) repss6(i, j, k, n, n, n)
#define reps5(i, j, k, l, n) repss8(i, j, k, l, n, n, n, n)
template <class T>
void nex_repv2(int &i, int &j, int &I, int &J, vector<vector<T>> &s) {
while (1) {
j++;
if (j >= J) {
j = 0;
i++;
if (i < I) {
J = (int)s[i].size();
}
}
if (i >= I || J)
return;
}
}
template <class T>
void nex_repv3(int &i, int &j, int &k, int &I, int &J, int &K,
vector<vector<vector<T>>> &s) {
while (1) {
k++;
if (k >= K) {
k = 0;
j++;
if (j >= J) {
j = 0;
i++;
if (i >= I)
return;
}
}
J = (int)s[i].size();
K = (int)s[i][j].size();
if (J && K)
return;
}
}
#define repv_2(i, a) repss2(i, sz(a))
// 正方形である必要はない
// 直前を持つのとどっちが早いか
#define repv_3(i, j, a) \
for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), i = 0, j = 0; \
i < repvI; nex_repv2(i, j, repvI, repvJ, a))
// 箱状になっている事が要求される つまり[i] 次元目の要素数は一定
#define repv_4(i, j, k, a) \
for (int repvI = (int)a.size(), repvJ = (int)a[0].size(), \
repvK = (int)a[0][0].size(), i = 0, j = 0, k = 0; \
i < repvI; nex_repv3(i, j, k, repvI, repvJ, repvK, a))
#define repv_5(i, j, k, l, a) \
repss8(i, j, k, l, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]))
#define repv_6(i, j, k, l, m, a) \
repss10(i, j, k, l, m, sz(a), sz(a[0]), sz(a[0][0]), sz(a[0][0][0]), \
sz(a[0][0][0][0]))
#endif
template <typename T> struct has_rbegin_rend {
private:
template <typename U>
static auto check(U &&obj)
-> decltype(std::rbegin(obj), std::rend(obj), std::true_type{});
static std::false_type check(...);
public:
static constexpr bool value = decltype(check(std::declval<T>()))::value;
};
template <typename T>
constexpr bool has_rbegin_rend_v = has_rbegin_rend<T>::value;
template <typename Iterator> class Range {
public:
Range(Iterator &&begin, Iterator &&end) noexcept
: m_begin(std::forward<Iterator>(begin)),
m_end(std::forward<Iterator>(end)) {}
Iterator begin() const noexcept { return m_begin; }
Iterator end() const noexcept { return m_end; }
private:
const Iterator m_begin;
const Iterator m_end;
};
template <typename Iterator>
static inline Range<Iterator> makeRange(Iterator &&begin,
Iterator &&end) noexcept {
return Range<Iterator>{std::forward<Iterator>(begin),
std::forward<Iterator>(end)};
}
template <typename T>
static inline decltype(auto)
makeReversedRange(const std::initializer_list<T> &iniList) noexcept {
return makeRange(std::rbegin(iniList), std::rend(iniList));
}
template <typename T, typename std::enable_if_t<has_rbegin_rend_v<T>,
std::nullptr_t> = nullptr>
static inline decltype(auto) makeReversedRange(T &&c) noexcept {
return makeRange(std::rbegin(c), std::rend(c));
} /* rbegin(),
rend()を持たないものはこっちに分岐させて，エラーメッセージを少なくする*/
template <typename T, typename std::enable_if<!has_rbegin_rend<T>::value,
std::nullptr_t>::type = nullptr>
static inline void makeReversedRange(T &&) noexcept {
static_assert(has_rbegin_rend<T>::value,
"Specified argument doesn't have reverse iterator.");
}
// #define use_for
#define form1(st) \
for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form3(k, v, st) \
for (auto &&form_it = st.begin(); form_it != st.end(); ++form_it)
#define form4(k, v, st, r) \
for (auto &&form_it = st.begin(); form_it != st.end() && (*form_it).fi < r; \
++form_it)
#define form5(k, v, st, l, r) \
for (auto &&form_it = st.lower_bound(l); \
form_it != st.end() && (*form_it).fi < r; ++form_it)
#define forrm1(st) \
for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
#define forrm3(k, v, st) \
for (auto &&forrm_it = st.rbegin(); forrm_it != st.rend(); ++forrm_it)
// 向こう側で
// ++itか it = st.erase(it)とする
#define fors1(st) for (auto &&it = st.begin(); it != st.end();)
#define fors2(v, st) for (auto &&it = st.begin(); it != st.end();)
#define fors3(v, st, r) \
for (auto &&it = st.begin(); it != st.end() && (*it) < r;)
#define fors4(v, st, l, r) \
for (auto &&it = st.lower_bound(l); it != st.end() && (*it) < r;)
#ifdef use_for
#define forslr3(st, a, b) \
for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr4(v, st, a, b) \
for (auto &&forslr_it = st.begin(); forslr_it != st.end(); ++forslr_it)
#define forslr5(v, st, r, a, b) \
for (auto &&forslr_it = st.begin(); \
forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define forslr6(v, st, l, r, a, b) \
for (auto &&forslr_it = st.lower_bound(l); \
forslr_it != st.end() && (*forslr_it) < r; ++forslr_it)
#define fora_f_init_2(a, A) ;
#define fora_f_init_3(fora_f_i, a, A) auto &&a = A[fora_f_i];
#define fora_f_init_4(a, b, A, B) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i];
#define fora_f_init_5(fora_f_i, a, b, A, B) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i];
#define fora_f_init_6(a, b, c, A, B, C) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i];
#define fora_f_init_7(fora_f_i, a, b, c, A, B, C) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i];
#define fora_f_init_8(a, b, c, d, A, B, C, D) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i]; \
auto &&d = D[fora_f_i];
#define fora_f_init_9(fora_f_i, a, b, c, d, A, B, C, D) \
auto &&a = A[fora_f_i]; \
auto &&b = B[fora_f_i]; \
auto &&c = C[fora_f_i]; \
auto &&d = D[fora_f_i];
#define fora_f_init(...) \
over9(__VA_ARGS__, fora_f_init_9, fora_f_init_8, fora_f_init_7, \
fora_f_init_6, fora_f_init_5, fora_f_init_4, fora_f_init_3, \
fora_f_init_2)(__VA_ARGS__)
#define forr_init_2(a, A) auto &&a = A[forr_i];
#define forr_init_3(forr_i, a, A) auto &&a = A[forr_i];
#define forr_init_4(a, b, A, B) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i];
#define forr_init_5(forr_i, a, b, A, B) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i];
#define forr_init_6(a, b, c, A, B, C) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i];
#define forr_init_7(forr_i, a, b, c, A, B, C) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i];
#define forr_init_8(a, b, c, d, A, B, C, D) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i]; \
auto &&d = D[forr_i];
#define forr_init_9(forr_i, a, b, c, d, A, B, C, D) \
auto &&a = A[forr_i]; \
auto &&b = B[forr_i]; \
auto &&c = C[forr_i]; \
auto &&d = D[forr_i];
#define forr_init(...) \
over9(__VA_ARGS__, forr_init_9, forr_init_8, forr_init_7, forr_init_6, \
forr_init_5, forr_init_4, forr_init_3, forr_init_2)(__VA_ARGS__)
#define forp_init3(k, v, S) \
auto &&k = S[forp_i].first; \
auto &&v = S[forp_i].second;
#define forp_init4(forp_i, k, v, S) \
auto &&k = S[forp_i].first; \
auto &&v = S[forp_i].second;
#define forp_init(...) \
over4(__VA_ARGS__, forp_init4, forp_init3, forp_init2, \
forp_init1)(__VA_ARGS__)
#define form_init(k, v, ...) \
auto &&k = (*form_it).fi; \
auto &&v = (*form_it).se;
#define forrm_init(k, v, ...) \
auto &&k = (*forrm_it).fi; \
auto &&v = (*forrm_it).se;
#define fors_init(v, ...) auto &&v = (*it);
#define forlr_init(a, A, ngl, ngr) \
auto a = A[forlr_i]; \
auto prev = forlr_i ? A[forlr_i - 1] : ngl; \
auto next = forlr_i + 1 < rep2lim ? A[forlr_i + 1] : ngr;
#define forslr_init4(a, A, ngl, ngr) \
auto a = (*forslr_it); \
auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl; \
auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init5(a, A, r, ngl, ngr) \
auto a = (*forslr_it); \
auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl; \
auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init6(a, A, l, r, ngl, ngr) \
auto a = (*forslr_it); \
auto prev = (forslr_it != A.begin()) ? (*std::prev(forslr_it)) : ngl; \
auto next = (forslr_it != std::prev(A.end())) ? (*std::next(forslr_it)) : ngr;
#define forslr_init(...) \
over6(__VA_ARGS__, forslr_init6, forslr_init5, forslr_init4)(__VA_ARGS__);
// こうしないとmapがおかしくなる
#define fora_f_2(a, A) for (auto &&a : A)
#define fora_f_3(fora_f_i, a, A) rep(fora_f_i, sz(A))
#define fora_f_4(a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_5(fora_f_i, a, b, A, B) rep(fora_f_i, sz(A))
#define fora_f_6(a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_7(fora_f_i, a, b, c, A, B, C) rep(fora_f_i, sz(A))
#define fora_f_8(a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define fora_f_9(fora_f_i, a, b, c, d, A, B, C, D) rep(fora_f_i, sz(A))
#define forr_2(a, A) rer(forr_i, sz(A) - 1)
#define forr_3(forr_i, a, A) rer(forr_i, sz(A) - 1)
#define forr_4(a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_5(forr_i, a, b, A, B) rer(forr_i, sz(A) - 1)
#define forr_6(a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_7(forr_i, a, b, c, A, B, C) rer(forr_i, sz(A) - 1)
#define forr_8(a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)
#define forr_9(forr_i, a, b, c, d, A, B, C, D) rer(forr_i, sz(A) - 1)
#endif
// ↑@オーバーロード隔離
// rep系はインデックス、for系は中身
#define rep(...) over4(__VA_ARGS__, rep4, rep3, rep2, rep1)(__VA_ARGS__)
#define rer(...) over4(__VA_ARGS__, rer4, rer3, rer2, )(__VA_ARGS__)
// 自分込みで残りがREM以上の間ループを回す
#define rem(i, N, REM) for (int i = 0; i < N - REM + 1; i++)
// char用のrep
#define repc(i, m, n) for (char i = m, repc3lim = n; i < repc3lim; ++i)
// i,j,k...をnまで見る
#define reps(...) over5(__VA_ARGS__, reps5, reps4, reps3, reps2, )(__VA_ARGS__)
#define repss(...) \
over10(__VA_ARGS__, repss10, a, repss8, a, repss6, a, repss4, a, \
repss2)(__VA_ARGS__)
// vectorのindexを走査する
// repv(i,j,vvi)
#define repv(...) \
over6(__VA_ARGS__, repv_6, repv_5, repv_4, repv_3, repv_2, )(__VA_ARGS__)
#define rerv(i, A) for (int i = sz(A) - 1; i >= 0; i--)
// repvn(dp) nは次元
#define repv1(a) repv(i, a)
#define repv2(a) repv(i, j, a)
#define repv3(a) repv(i, j, k, a)
#define repv4(a) repv(i, j, k, l, a)
#ifdef use_for
#define fora_f(...) \
over9(__VA_ARGS__, fora_f_9, fora_f_8, fora_f_7, fora_f_6, fora_f_5, \
fora_f_4, fora_f_3, fora_f_2)(__VA_ARGS__)
#endif
#define forr(...) \
over9(__VA_ARGS__, forr_9, forr_8, forr_7, forr_6, forr_5, forr_4, forr_3, \
forr_2)(__VA_ARGS__)
// 0~N-2まで見る
#define forar_init(v, rv, A) \
auto &&v = A[forar_i]; \
auto &&rv = A[forar_i + 1];
#define forar(v, rv, A) rep(forar_i, sz(A) - 1)
#if __cplusplus >= 201703L
template <size_t M_SZ, bool indexed, class Iterator, class T, class U = T,
class V = T, class W = T>
class ite_vec_merge : public Iterator {
std::size_t i = 0;
vector<T> &A;
vector<U> &B;
vector<V> &C;
vector<W> &D;
public:
ite_vec_merge(Iterator ita, vector<T> &A)
: Iterator(ita), A(A), B(A), C(A), D(A) {}
ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B)
: Iterator(ita), A(A), B(B), C(A), D(A) {}
ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C)
: Iterator(ita), A(A), B(B), C(C), D(A) {}
ite_vec_merge(Iterator ita, vector<T> &A, vector<U> &B, vector<V> &C,
vector<W> &D)
: Iterator(ita), A(A), B(B), C(C), D(D) {}
auto &operator++() {
++i;
this->Iterator::operator++();
return *this;
}
auto operator*() const noexcept {
if constexpr (!indexed && M_SZ == 1) {
return tuple<T &>(A[i]);
} else if constexpr (!indexed && M_SZ == 2) {
return tuple<T &, U &>(A[i], B[i]);
} else if constexpr (!indexed && M_SZ == 3) {
return tuple<T &, U &, V &>(A[i], B[i], C[i]);
} else if constexpr (!indexed && M_SZ == 4) {
return tuple<T &, U &, V &, W &>(A[i], B[i], C[i], D[i]);
} else if constexpr (indexed && M_SZ == 1) {
return tuple<int, T &>(i, A[i]);
} else if constexpr (indexed && M_SZ == 2) {
return tuple<int, T &, U &>(i, A[i], B[i]);
} else if constexpr (indexed && M_SZ == 3) {
return tuple<int, T &, U &, V &>(i, A[i], B[i], C[i]);
} else if constexpr (indexed && M_SZ == 4) {
return tuple<int, T &, U &, V &, W &>(i, A[i], B[i], C[i], D[i]);
} else {
assert(0);
return tuple<int>(i);
}
}
};
template <size_t M_SZ, bool indexed, class T, class U = T, class V = T,
class W = T>
class vec_merge {
vector<T> &a;
vector<U> &b;
vector<V> &c;
vector<W> &d;
public:
vec_merge(vector<T> &a) : a(a), b(a), c(a), d(a) {}
vec_merge(vector<T> &a, vector<U> &b) : a(a), b(b), c(a), d(a) {}
vec_merge(vector<T> &a, vector<U> &b, vector<V> &c)
: a(a), b(b), c(c), d(a) {}
vec_merge(vector<T> &a, vector<U> &b, vector<V> &c, vector<W> &d)
: a(a), b(b), c(c), d(d) {}
auto begin() const {
if constexpr (M_SZ == 1) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a};
} else if constexpr (M_SZ == 2) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a, b};
} else if constexpr (M_SZ == 3) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a, b, c};
} else if constexpr (M_SZ == 4) {
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a, b, c, d};
} else {
assert(0);
return ite_vec_merge<M_SZ, indexed, decltype(std::begin(a)), T, U, V, W>{
std::begin(a), a};
}
}
auto end() const {
if constexpr (M_SZ == 1) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a};
} else if constexpr (M_SZ == 2) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a, b};
} else if constexpr (M_SZ == 3) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a, b, c};
} else if constexpr (M_SZ == 4) {
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a, b, c, d};
} else {
assert(0);
return ite_vec_merge<M_SZ, indexed, decltype(std::end(a)), T, U, V, W>{
std::end(a), a};
}
}
};
#endif
#define fora_2(a, A) for (auto &&a : A)
#if __cplusplus >= 201703L
#define fora_3(i, a, A) for (auto [i, a] : vec_merge<1, true, decl_t(A)>(A))
#define fora_4(a, b, A, B) \
for (auto [a, b] : vec_merge<2, false, decl_t(A), decl_t(B)>(A, B))
#define fora_5(i, a, b, A, B) \
for (auto [i, a, b] : vec_merge<2, true, decl_t(A), decl_t(B)>(A, B))
#define fora_6(a, b, c, A, B, C) \
for (auto [a, b, c] : \
vec_merge<3, false, decl_t(A), decl_t(B), decl_t(C)>(A, B, C))
#define fora_7(i, a, b, c, A, B, C) \
for (auto [i, a, b, c] : \
vec_merge<3, true, decl_t(A), decl_t(B), decl_t(C)>(A, B, C))
#define fora_8(a, b, c, d, A, B, C, D) \
for (auto [a, b, c, d] : \
vec_merge<4, false, decl_t(A), decl_t(B), decl_t(C), decl_t(D)>(A, B, \
C, D))
#define fora_9(i, a, b, c, d, A, B, C, D) \
for (auto [i, a, b, c, d] : \
vec_merge<4, true, decl_t(A), decl_t(B), decl_t(C), decl_t(D)>(A, B, C, \
D))
#endif
// 構造化束縛ver
// 1e5要素で40ms程度
// 遅いときはfora_fを使う
#define fora(...) \
over9(__VA_ARGS__, fora_9, fora_8, fora_7, fora_6, fora_5, fora_4, fora_3, \
fora_2)(__VA_ARGS__)
// #define forr(v, a) for(auto&& v : makeReversedRange(a))
// 参照を取らない
/*@formatter:off*/
#ifdef use_for
template <class U> vector<U> to1d(vector<U> &a) { return a; }
template <class U> auto to1d(vector<vector<U>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
res.push_back(a2);
return res;
}
template <class U> vector<U> to1d(vector<vector<vector<U>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
res.push_back(a3);
return res;
}
template <class U> vector<U> to1d(vector<vector<vector<vector<U>>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
for (auto &&a4 : a3)
res.push_back(a4);
return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<U>>>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
for (auto &&a4 : a3)
for (auto &&a5 : a4)
res.push_back(a5);
return res;
}
template <class U>
vector<U> to1d(vector<vector<vector<vector<vector<vector<U>>>>>> &a) {
vector<U> res;
for (auto &&a1 : a)
for (auto &&a2 : a1)
for (auto &&a3 : a2)
for (auto &&a4 : a3)
for (auto &&a5 : a4)
for (auto &&a6 : a5)
res.push_back(a6);
return res;
}
#define forv(a, b) for (auto a : to1d(b))
// インデックスを前後含めて走査
#define ring(i, s, len) \
for (int i = s, prev = (s == 0) ? len - 1 : s - 1, \
next = (s == len - 1) ? 0 : s + 1, cou = 0; \
cou < len; \
cou++, prev = i, i = next, next = (next == len - 1) ? 0 : next + 1)
// 値と前後を見る
#define ringv(v, d) \
index_ = 0; \
for (auto prev = d[sz(d) - 1], next = (int)d.size() > 1 ? d[1] : d[0], \
v = d[0]; \
index_ < sz(d); index_++, prev = v, v = next, \
next = (index_ >= sz(d) - 1 ? d[0] : d[index_ + 1]))
// 左右をnext prevで見る 0の左と nの右
#define forlr(v, d, banpei_l, banpei_r) rep(forlr_i, sz(d))
#endif
#define form(...) \
over5(__VA_ARGS__, form5, form4, form3, form2, form1)(__VA_ARGS__)
#define forrm(...) \
over5(__VA_ARGS__, forrm5, forrm4, forrm3, forrm2, forrm1)(__VA_ARGS__)
#define fors(...) over4(__VA_ARGS__, fors4, fors3, fors2, fors1)(__VA_ARGS__)
#define forslr(...) \
over6(__VA_ARGS__, forslr6, forslr5, forslr4, forslr3)(__VA_ARGS__)
#define forp3(k, v, st) rep(forp_i, sz(st))
#define forp4(forp_i, k, v, st) rep(forp_i, sz(st))
#define forp(...) over4(__VA_ARGS__, forp4, forp3)(__VA_ARGS__)
// マクロ 定数
#define k3 1010
#define k4 10101
#define k5 101010
#define k6 1010101
#define k7 10101010
const double PI = 3.1415926535897932384626433832795029L;
constexpr bool ev(ll a) { return !(a & 1); }
constexpr bool od(ll a) { return (a & 1); }
//@拡張系 こう出来るべきというもの
// 埋め込み 存在を意識せずに機能を増やされているもの
namespace std {
template <> class hash<std::pair<signed, signed>> {
public:
size_t operator()(const std::pair<signed, signed> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
template <> class hash<std::pair<ll, ll>> {
public
: /*大きいllが渡されると、<<32でオーバーフローするがとりあえず問題ないと判断*/
size_t operator()(const std::pair<ll, ll> &x) const {
return hash<ll>()(((ll)x.first << 32) | x.second);
}
};
} // namespace std
// stream まとめ
/*@formatter:off*/
istream &operator>>(istream &iss, P &a) {
iss >> a.first >> a.second;
return iss;
}
template <typename T> istream &operator>>(istream &iss, vector<T> &vec_) {
for (T &x : vec_)
iss >> x;
return iss;
}
template <class T, class U> ostream &operator<<(ostream &os, pair<T, U> p) {
os << p.fi << " " << p.se;
return os;
}
ostream &operator<<(ostream &os, T p) {
os << p.f << " " << p.s << " " << p.t;
return os;
}
ostream &operator<<(ostream &os, F p) {
os << p.a << " " << p.b << " " << p.c << " " << p.d;
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> &vec_) {
for (ll i = 0; i < vec_.size(); ++i)
os << vec_[i] << (i + 1 == vec_.size() ? "" : " ");
return os;
}
template <typename T>
ostream &operator<<(ostream &os, vector<vector<T>> &vec_) {
for (ll i = 0; i < vec_.size(); ++i) {
for (ll j = 0; j < vec_[i].size(); ++j) {
os << vec_[i][j] << " ";
}
os << endl;
}
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &m) {
os << endl;
for (auto &&v : m)
os << v << endl;
return os;
}
template <class T> ostream &operator<<(ostream &os, set<T> s) {
fora(v, s) { os << v << " "; }
return os;
}
template <class T> ostream &operator<<(ostream &os, mset<T> s) {
fora(v, s) { os << v << " "; }
return os;
}
template <class T> ostream &operator<<(ostream &os, deque<T> a) {
fora(v, a) { os << v << " "; }
return os;
}
ostream &operator<<(ostream &os, vector<vector<char>> &vec_) {
rep(h, sz(vec_)) {
rep(w, sz(vec_[0])) { os << vec_[h][w]; }
os << endl;
}
return os;
}
/*@formatter:off*/
// template<class T,class U>ostream &operator<<(ostream &os, vector<pair<T,U>>&
// a) {fora_f(v,a)os<<v<<endl;return os;}
template <typename W, typename H> void resize(W &vec_, const H head) {
vec_.resize(head);
}
template <typename W, typename H, typename... T>
void resize(W &vec_, const H &head, const T... tail) {
vec_.resize(head);
for (auto &v : vec_)
resize(v, tail...);
}
// #define use_for_each //_each _all_of _any_of _none_of _find_if _rfind_if
// _contains _count_if _erase_if _entry_if
#ifdef use_for_each
// todo Atcoderの過去問がc++17に対応したら
#if __cplusplus >= 201703L
// for_each以外はconst & (呼び出し側のラムダも)
template <typename T, typename F> bool all_of2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : v) {
if (!all_of2(v_, f))
return false;
}
return true;
} else {
return f(v);
}
}
template <typename T, typename F> bool any_of2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : v) {
if (!any_of2(v_, f))
return true;
}
return false;
} else {
return f(v);
}
}
template <typename T, typename F> bool none_of2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : v) {
if (none_of2(v_, f))
return false;
}
return true;
} else {
return f(v);
}
}
// 存在しない場合
// 1次元 Nを返す
// 多次元-1を返す
template <typename T, typename F> ll find_if2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (f(v[i]))
return i;
}
return sz(v);
}
template <typename T, typename F>
tuple<int, int> find_if2(const vector<vector<T>> &v, F f) {
rep(i, sz(v)) {
rep(j, sz(v[i])) {
if (f(v[i][j])) {
return tuple<int, int>(i, j);
}
}
}
return tuple<int, int>(-1, -1);
}
template <typename T, typename F>
auto find_if2(const vector<vector<vector<T>>> &v, F f) {
rep(i, sz(v)) {
if (auto ret = find_if2(v[i], f); get<0>(ret) != -1) {
return tuple_cat(tuple<int>(i), ret);
}
}
auto bad = tuple_cat(tuple<int>(-1), find_if2(v[0], f));
return bad;
}
// 存在しない場合
// 1次元 -1を返す
// 多次元-1を返す
template <typename T, typename F> ll rfind_if2(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (f(v[i]))
return i;
}
return -1;
}
template <typename T, typename F>
tuple<int, int> rfind_if2(const vector<vector<T>> &v, F f) {
rer(i, sz(v) - 1) {
rer(j, sz(v[i]) - 1) {
if (f(v[i][j])) {
return tuple<int, int>(i, j);
}
}
}
return tuple<int, int>(-1, -1);
}
template <typename T, typename F>
auto rfind_if2(const vector<vector<vector<T>>> &v, F f) {
rer(i, sz(v) - 1) {
if (auto ret = rfind_if2(v[i], f); get<0>(ret) != -1) {
return tuple_cat(tuple<int>(i), ret);
}
}
auto bad = tuple_cat(tuple<int>(-1), rfind_if2(v[0], f));
return bad;
}
// todo まとめられそう string,vector全般
template <class T> bool contains(const string &s, const T &v) {
return s.find(v) != string::npos;
}
template <typename T> bool contains(const vector<T> &v, const T &val) {
return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(const vector<T> &v, F f) {
return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(const T &v, F f) {
if constexpr (has_value_type<T>::value) {
ll ret = 0;
for (auto &&v_ : v) {
ret += count_if2(v_, f);
}
return ret;
} else {
return f(v);
}
}
template <typename T, typename F> void for_each2(T &a, F f) {
if constexpr (has_value_type<T>::value) {
for (auto &&v_ : a)
for_each2(v_, f);
} else {
f(a);
}
}
#else
template <typename T, typename F> bool all_of2(const T &v, F f) { return f(v); }
template <typename T, typename F> bool all_of2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (!all_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool any_of2(const T &v, F f) { return f(v); }
template <typename T, typename F> bool any_of2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (any_of2(v[i], f))
return true;
}
return false;
}
template <typename T, typename F> bool none_of2(const T &v, F f) {
return f(v);
}
template <typename T, typename F> bool none_of2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (none_of2(v[i], f))
return false;
}
return true;
}
template <typename T, typename F> bool find_if2(const T &v, F f) {
return f(v);
}
template <typename T, typename F> ll find_if2(const vector<T> &v, F f) {
rep(i, sz(v)) {
if (find_if2(v[i], f))
return i;
}
return sz(v);
}
template <typename T, typename F> bool rfind_if2(const T &v, F f) {
return f(v);
}
template <typename T, typename F> ll rfind_if2(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (rfind_if2(v[i], f))
return i;
}
return -1;
}
template <class T> bool contains(const string &s, const T &v) {
return s.find(v) != string::npos;
}
template <typename T> bool contains(const vector<T> &v, const T &val) {
return std::find(v.begin(), v.end(), val) != v.end();
}
template <typename T, typename F> bool contains_if2(const vector<T> &v, F f) {
return find_if(v.begin(), v.end(), f) != v.end();
}
template <typename T, typename F> ll count_if2(const T &v, F f) { return f(v); }
template <typename T, typename F> ll count_if2(const vector<T> &vec_, F f) {
ll ret = 0;
fora(v, vec_) { ret += count_if2(v, f); }
return ret;
}
template <typename T, typename F> void for_each2(T &a, F f) { f(a); }
template <typename T, typename F> void for_each2(vector<T> &a, F f) {
for (auto &&v_ : a)
for_each2(v_, f);
}
#endif
template <typename W> ll count_od(const vector<W> &a) {
return count_if2(a, [](ll v) { return v & 1; });
}
template <typename W> ll count_ev(const vector<W> &a) {
return count_if2(a, [](ll v) { return !(v & 1); });
}
// 削除した後のvectorを返す
template <typename T, typename F> vector<T> erase_if2(const vector<T> &v, F f) {
vector<T> nv;
rep(i, sz(v)) {
if (!f(v[i])) {
nv.push_back(v[i]);
}
}
return nv;
}
template <typename T, typename F>
vector<vector<T>> erase_if2(const vector<vector<T>> &v, F f) {
vector<vector<T>> res;
rep(i, sz(v)) { res[i] = erase_if2(v[i], f); }
return res;
}
template <typename T, typename F> vector<T> entry_if2(const vector<T> &v, F f) {
vector<T> nv;
rep(i, sz(v)) {
if (f(v[i])) {
nv.push_back(v[i]);
}
}
return nv;
}
template <typename T, typename F>
vector<vector<T>> entry_if2(const vector<vector<T>> &v, F f) {
vector<vector<T>> res;
rep(i, sz(v)) { res[i] = entry_if2(v[i], f); }
return res;
}
template <typename T, typename F> ll l_rfind_if(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (f(v[i]))
return i;
}
return -1;
}
template <typename T, typename F> bool l_contains_if(const vector<T> &v, F f) {
rer(i, sz(v) - 1) {
if (f(v[i]))
return true;
}
return false;
}
template <class A, class B, class C> auto t_all_of(A a, B b, C c) {
return std::all_of(a, b, c);
}
template <class A, class B, class C> auto t_any_of(A a, B b, C c) {
return std::any_of(a, b, c);
}
template <class A, class B, class C> auto t_none_of(A a, B b, C c) {
return std::none_of(a, b, c);
}
template <class A, class B, class C> auto t_find_if(A a, B b, C c) {
return std::find_if(a, b, c);
}
template <class A, class B, class C> auto t_count_if(A a, B b, C c) {
return std::count_if(a, b, c);
}
#define all_of_s__2(a, right) (t_all_of(ALL(a), lamr(right)))
#define all_of_s__3(a, v, siki) (t_all_of(ALL(a), [&](auto v) { return siki; }))
#define all_of_s(...) over3(__VA_ARGS__, all_of_s__3, all_of_s__2)(__VA_ARGS__)
// all_of(A, %2);
// all_of(A, a, a%2);
#define all_of__2(a, right) all_of2(a, lamr(right))
#define all_of__3(a, v, siki) all_of2(a, [&](auto v) { return siki; })
#define all_of(...) over3(__VA_ARGS__, all_of__3, all_of__2)(__VA_ARGS__)
#define all_of_f(a, f) all_of2(a, f)
#define any_of_s__2(a, right) (t_any_of(ALL(a), lamr(right)))
#define any_of_s__3(a, v, siki) (t_any_of(ALL(a), [&](auto v) { return siki; }))
#define any_of_s(...) over3(__VA_ARGS__, any_of_s__3, any_of_s__2)(__VA_ARGS__)
#define any_of__2(a, right) any_of2(a, lamr(right))
#define any_of__3(a, v, siki) any_of2(a, [&](auto v) { return siki; })
#define any_of(...) over3(__VA_ARGS__, any_of__3, any_of__2)(__VA_ARGS__)
#define any_of_f(a, f) any_of2(a, f)
#define none_of_s__2(a, right) (t_none_of(ALL(a), lamr(right)))
#define none_of_s__3(a, v, siki) \
(t_none_of(ALL(a), [&](auto v) { return siki; }))
#define none_of_s(...) \
over3(__VA_ARGS__, none_of_s__3, none_of_s__2)(__VA_ARGS__)
#define none_of__2(a, right) none_of2(a, lamr(right))
#define none_of__3(a, v, siki) none_of2(a, [&](auto v) { return siki; })
#define none_of(...) over3(__VA_ARGS__, none_of__3, none_of__2)(__VA_ARGS__)
#define none_of_f(a, f) none_of2(a, f)
#define find_if_s__2(a, right) (t_find_if(ALL(a), lamr(right)) - a.begin())
#define find_if_s__3(a, v, siki) \
(t_find_if(ALL(a), [&](auto v) { return siki; }) - a.begin())
#define find_if_s(...) \
over3(__VA_ARGS__, find_if_s__3, find_if_s__2)(__VA_ARGS__)
#define find_if__2(a, right) find_if2(a, lamr(right))
#define find_if__3(a, v, siki) find_if2(a, [&](auto v) { return siki; })
#define find_if(...) over3(__VA_ARGS__, find_if__3, find_if__2)(__VA_ARGS__)
#define find_if_f(a, f) find_if2(a, f)
#define rfind_if_s__2(a, right) l_rfind_if(a, lamr(right))
#define rfind_if_s__3(a, v, siki) l_rfind_if(a, [&](auto v) { return siki; })
#define rfind_if_s(...) \
over3(__VA_ARGS__, rfind_if_s__3, rfind_if_s__2)(__VA_ARGS__)
#define rfind_if__2(a, right) rfind_if2(a, lamr(right))
#define rfind_if__3(a, v, siki) rfind_if2(a, [&](auto v) { return siki; })
#define rfind_if(...) over3(__VA_ARGS__, rfind_if__3, rfind_if__2)(__VA_ARGS__)
#define rfind_if_f(a, f) rfind_if2(a, f)
#define contains_if_s__2(a, right) l_contains_if(a, lamr(right))
#define contains_if_s__3(a, v, siki) \
l_contains_if(a, [&](auto v) { return siki; })
#define contains_if_s(...) \
over3(__VA_ARGS__, contains_if_s__3, contains_if_s__2)(__VA_ARGS__)
#define contains_if__2(a, right) contains_if2(a, lamr(right))
#define contains_if__3(a, v, siki) contains_if2(a, [&](auto v) { return siki; })
#define contains_if(...) \
over3(__VA_ARGS__, contains_if__3, contains_if__2)(__VA_ARGS__)
#define contains_if_f(a, f) contains_if2(a, f)
#define count_if_s__2(a, right) (t_count_if(ALL(a), lamr(right)))
#define count_if_s__3(a, v, siki) \
(t_count_if(ALL(a), [&](auto v) { return siki; }))
#define count_if_s(...) \
over3(__VA_ARGS__, count_if_s__3, count_if_s__2)(__VA_ARGS__)
#define count_if__2(a, right) count_if2(a, lamr(right))
#define count_if__3(a, v, siki) count_if2(a, [&](auto v) { return siki; })
#define count_if(...) over3(__VA_ARGS__, count_if__3, count_if__2)(__VA_ARGS__)
#define count_if_f(a, f) count_if2(a, f)
// vector<vi>で、viに対して操作
#define for_each_s__2(a, right) \
do { \
fora(v, a) { v right; } \
} while (0)
#define for_each_s__3(a, v, shori) \
do { \
fora(v, a) { shori; } \
} while (0)
#define for_each_s(...) \
over3(__VA_ARGS__, for_each_s__3, for_each_s__2)(__VA_ARGS__)
// vector<vi>で、intに対して操作
#define for_each__2(a, right) for_each2(a, lamr(right))
#define for_each__3(a, v, shori) for_each2(a, [&](auto &v) { shori; })
#define for_each(...) over3(__VA_ARGS__, for_each__3, for_each__2)(__VA_ARGS__)
#define for_each_f(a, f) for_each2(a, f);
template <class T, class F> vector<T> help_for_eached(const vector<T> &A, F f) {
vector<T> ret = A;
for_each(ret, v, f(v));
return ret;
}
#define for_eached__2(a, right) help_for_eached(a, lamr(right))
#define for_eached__3(a, v, shori) help_for_eached(a, lam(v, shori))
#define for_eached(...) \
over3(__VA_ARGS__, for_eached__3, for_eached__2)(__VA_ARGS__)
#define for_eached_f(a, f) for_eached2(a, f);
#define each for_each
#define eached for_eached
// #define erase_if_s__2(a, right) l_erase_if2(a,lamr(right))
// #define erase_if_s__3(a, v, siki) l_erase_if2(a,[&](auto v){return siki;})
// #define erase_if_s(...)
// over3(__VA_ARGS__,erase_if_s__3,erase_if_s__2)(__VA_ARGS__)
#define erase_if__2(a, right) erase_if2(a, lamr(right))
#define erase_if__3(a, v, siki) erase_if2(a, [&](auto v) { return siki; })
#define erase_if(...) over3(__VA_ARGS__, erase_if__3, erase_if__2)(__VA_ARGS__)
#define erase_if_f(a, f) erase_if2(a, f)
// #define entry_if_s__2(a, right) l_entry_if2(a,lamr(right))
// #define entry_if_s__3(a, v, siki) l_entry_if2(a,[&](auto v){return siki;})
// #define entry_if_s(...)
// over3(__VA_ARGS__,entry_if_s__3,entry_if_s__2)(__VA_ARGS__)
#define entry_if__2(a, right) entry_if2(a, lamr(right))
#define entry_if__3(a, v, siki) entry_if2(a, [&](auto v) { return siki; })
#define entry_if(...) over3(__VA_ARGS__, entry_if__3, entry_if__2)(__VA_ARGS__)
#define entry_if_f(a, f) entry_if2(a, f)
#endif
/*@formatter:off*/
template <class T, class U, class W> void replace(vector<W> &a, T key, U v) {
rep(i, sz(a)) if (a[i] == key) a[i] = v;
}
template <class T, class U, class W>
void replace(vector<vector<W>> &A, T key, U v) {
rep(i, sz(A)) replace(A[i], key, v);
}
void replace(str &a, char key, str v) {
if (v == "")
a.erase(remove(ALL(a), key), a.end());
}
void replace(str &a, char key, char v) { replace(ALL(a), key, v); }
// keyと同じかどうか01で置き換える
template <class T, class U> void replace(vector<T> &a, U k) {
rep(i, sz(a)) a[i] = a[i] == k;
}
template <class T, class U> void replace(vector<vector<T>> &a, U k) {
rep(i, sz(a)) rep(j, sz(a[0])) a[i][j] = a[i][j] == k;
}
void replace(str &a) {
int dec = 0;
if ('a' <= a[0] && a[0] <= 'z')
dec = 'a';
if ('A' <= a[0] && a[0] <= 'Z')
dec = 'A';
fora(v, a) { v -= dec; }
}
void replace(str &a, str key, str v) {
stringstream t;
ll kn = sz(key);
std::string::size_type Pos(a.find(key));
ll l = 0;
while (Pos != std::string::npos) {
t << a.substr(l, Pos - l);
t << v;
l = Pos + kn;
Pos = a.find(key, Pos + kn);
}
t << a.substr(l, sz(a) - l);
a = t.str();
}
template <class T> bool is_permutation(vector<T> &a, vector<T> &b) {
return is_permutation(ALL(a), ALL(b));
}
template <class T> bool next_permutation(vector<T> &a) {
return next_permutation(ALL(a));
}
vi iota(ll s, ll len) {
vi ve(len);
iota(ALL(ve), s);
return ve;
}
template <class A, class B> auto vtop(vector<A> &a, vector<B> &b) {
assert(sz(a) == sz(b)); /*stringを0で初期化できない */
vector<pair<A, B>> res;
rep(i, sz(a)) res.eb(a[i], b[i]);
return res;
}
template <class A, class B>
void ptov(vector<pair<A, B>> &p, vector<A> &a, vector<B> &b) {
a.resize(sz(p)), b.resize(sz(p));
rep(i, sz(p)) a[i] = p[i].fi, b[i] = p[i].se;
}
template <class A, class B, class C>
auto vtot(vector<A> &a, vector<B> &b, vector<C> &c) {
assert(sz(a) == sz(b) && sz(b) == sz(c));
vector<T2<A, B, C>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i]);
return res;
}
template <class A, class B, class C, class D>
auto vtof(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
assert(sz(a) == sz(b) && sz(b) == sz(c) && sz(c) == sz(d));
vector<F2<A, B, C, D>> res;
rep(i, sz(a)) res.eb(a[i], b[i], c[i], d[i]);
return res;
}
/*@formatter:off*/
template <class T> void sort(vector<T> &a, int l = -1, int r = -1) {
set_lr12(l, r, sz(a));
fast_sort(a.begin() + l, a.begin() + r);
}
template <class T> void rsort(vector<T> &a, int l = -1, int r = -1) {
set_lr12(l, r, sz(a));
fast_sort(a.begin() + l, a.begin() + r, greater<T>());
};
template <class A, class B> void sortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
sort(c);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B> void rsortp(vector<A> &a, vector<B> &b) {
auto c = vtop(a, b);
rsort(c);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
sort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c) {
auto d = vtot(a, b, c);
rsort(d);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class... T, class U> auto sorted(U head, T... a) {
sort(head, a...);
return head;
}
template <class... T, class U> auto rsorted(U head, T... a) {
rsort(head, a...);
return head;
}
// sortindex 元のvectorはソートしない
template <class T> vi sorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind);
return ind;
}
// #define use_sort
#ifdef use_sort
enum pcomparator { fisi, fisd, fdsi, fdsd, sifi, sifd, sdfi, sdfd };
enum tcomparator {
fisiti,
fisitd,
fisdti,
fisdtd,
fdsiti,
fdsitd,
fdsdti,
fdsdtd,
fitisi,
fitisd,
fitdsi,
fitdsd,
fdtisi,
fdtisd,
fdtdsi,
fdtdsd,
sifiti,
sifitd,
sifdti,
sifdtd,
sdfiti,
sdfitd,
sdfdti,
sdfdtd,
sitifi,
sitifd,
sitdfi,
sitdfd,
sdtifi,
sdtifd,
sdtdfi,
sdfdfd,
tifisi,
tifisd,
tifdsi,
tifdsd,
tdfisi,
tdfisd,
tdfdsi,
tdfdsd,
tisifi,
tisifd,
tisdfi,
tisdfd,
tdsifi,
tdsifd,
tdsdfi,
tdsdfd
};
template <class A, class B> void sort(vector<pair<A, B>> &a, pcomparator type) {
typedef pair<A, B> U;
if (type == fisi)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se < r.se; });
else if (type == fisd)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi < r.fi : l.se > r.se; });
else if (type == fdsi)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se < r.se; });
else if (type == fdsd)
sort(ALL(a),
[&](U l, U r) { return l.fi != r.fi ? l.fi > r.fi : l.se > r.se; });
else if (type == sifi)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi < r.fi; });
else if (type == sifd)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se < r.se : l.fi > r.fi; });
else if (type == sdfi)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi < r.fi; });
else if (type == sdfd)
sort(ALL(a),
[&](U l, U r) { return l.se != r.se ? l.se > r.se : l.fi > r.fi; });
};
template <class U> void sort(vector<U> &a, pcomparator type) {
if (type == fisi)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s < r.s; });
else if (type == fisd)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f < r.f : l.s > r.s; });
else if (type == fdsi)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s < r.s; });
else if (type == fdsd)
sort(ALL(a), [&](U l, U r) { return l.f != r.f ? l.f > r.f : l.s > r.s; });
else if (type == sifi)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f < r.f; });
else if (type == sifd)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s < r.s : l.f > r.f; });
else if (type == sdfi)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f < r.f; });
else if (type == sdfd)
sort(ALL(a), [&](U l, U r) { return l.s != r.s ? l.s > r.s : l.f > r.f; });
};
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, pcomparator type) {
typedef F2<A, B, C, D> U;
if (type == fisi)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b < r.b; });
else if (type == fisd)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a < r.a : l.b > r.b; });
else if (type == fdsi)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b < r.b; });
else if (type == fdsd)
sort(ALL(a), [&](U l, U r) { return l.a != r.a ? l.a > r.a : l.b > r.b; });
else if (type == sifi)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a < r.a; });
else if (type == sifd)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b < r.b : l.a > r.a; });
else if (type == sdfi)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a < r.a; });
else if (type == sdfd)
sort(ALL(a), [&](U l, U r) { return l.b != r.b ? l.b > r.b : l.a > r.a; });
};
template <class U> void sort(vector<U> &a, tcomparator type) {
if (type == 0)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 1)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 2)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 3)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 4)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t < r.t;
});
else if (type == 5)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s < r.s : l.t > r.t;
});
else if (type == 6)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t < r.t;
});
else if (type == 7)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.s != r.s ? l.s > r.s : l.t > r.t;
});
else if (type == 8)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 9)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 10)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 11)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f < r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 12)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s < r.s;
});
else if (type == 13)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t < r.t : l.s > r.s;
});
else if (type == 14)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s < r.s;
});
else if (type == 15)
sort(ALL(a), [&](U l, U r) {
return l.f != r.f ? l.f > r.f : l.t != r.t ? l.t > r.t : l.s > r.s;
});
else if (type == 16)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 17)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 18)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 19)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 20)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t < r.t;
});
else if (type == 21)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f < r.f : l.t > r.t;
});
else if (type == 22)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t < r.t;
});
else if (type == 23)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.f != r.f ? l.f > r.f : l.t > r.t;
});
else if (type == 24)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 25)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 26)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 27)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s < r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 28)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f < r.f;
});
else if (type == 29)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t < r.t : l.f > r.f;
});
else if (type == 30)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f < r.f;
});
else if (type == 31)
sort(ALL(a), [&](U l, U r) {
return l.s != r.s ? l.s > r.s : l.t != r.t ? l.t > r.t : l.f > r.f;
});
else if (type == 32)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 33)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 34)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 35)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 36)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s < r.s;
});
else if (type == 37)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f < r.f : l.s > r.s;
});
else if (type == 38)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s < r.s;
});
else if (type == 39)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.f != r.f ? l.f > r.f : l.s > r.s;
});
else if (type == 40)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 41)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 42)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 43)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t < r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
else if (type == 44)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f < r.f;
});
else if (type == 45)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s < r.s : l.f > r.f;
});
else if (type == 46)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f < r.f;
});
else if (type == 47)
sort(ALL(a), [&](U l, U r) {
return l.t != r.t ? l.t > r.t : l.s != r.s ? l.s > r.s : l.f > r.f;
});
}
template <class A, class B, class C, class D>
void sort(vector<F2<A, B, C, D>> &a, tcomparator type) {
typedef F2<A, B, C, D> U;
if (type == 0)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 1)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 2)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 3)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 4)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c < r.c;
});
else if (type == 5)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b < r.b : l.c > r.c;
});
else if (type == 6)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c < r.c;
});
else if (type == 7)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.b != r.b ? l.b > r.b : l.c > r.c;
});
else if (type == 8)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 9)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 10)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 11)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a < r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 12)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b < r.b;
});
else if (type == 13)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c < r.c : l.b > r.b;
});
else if (type == 14)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b < r.b;
});
else if (type == 15)
sort(ALL(a), [&](U l, U r) {
return l.a != r.a ? l.a > r.a : l.c != r.c ? l.c > r.c : l.b > r.b;
});
else if (type == 16)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 17)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 18)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 19)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 20)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c < r.c;
});
else if (type == 21)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a < r.a : l.c > r.c;
});
else if (type == 22)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c < r.c;
});
else if (type == 23)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.a != r.a ? l.a > r.a : l.c > r.c;
});
else if (type == 24)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 25)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 26)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 27)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b < r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 28)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a < r.a;
});
else if (type == 29)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c < r.c : l.a > r.a;
});
else if (type == 30)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a < r.a;
});
else if (type == 31)
sort(ALL(a), [&](U l, U r) {
return l.b != r.b ? l.b > r.b : l.c != r.c ? l.c > r.c : l.a > r.a;
});
else if (type == 32)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 33)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 34)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 35)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 36)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b < r.b;
});
else if (type == 37)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a < r.a : l.b > r.b;
});
else if (type == 38)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b < r.b;
});
else if (type == 39)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.a != r.a ? l.a > r.a : l.b > r.b;
});
else if (type == 40)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 41)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 42)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 43)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c < r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
else if (type == 44)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a < r.a;
});
else if (type == 45)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b < r.b : l.a > r.a;
});
else if (type == 46)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a < r.a;
});
else if (type == 47)
sort(ALL(a), [&](U l, U r) {
return l.c != r.c ? l.c > r.c : l.b != r.b ? l.b > r.b : l.a > r.a;
});
}
/*@formatter:off*/
void sort(string &a) { sort(ALL(a)); }
void rsort(string &a) { sort(RALL(a)); }
void sort(int &a, int &b) {
if (a > b)
swap(a, b);
}
void sort(int &a, int &b, int &c) {
sort(a, b);
sort(a, c);
sort(b, c);
}
void rsort(int &a, int &b) {
if (a < b)
swap(a, b);
}
void rsort(int &a, int &b, int &c) {
rsort(a, b);
rsort(a, c);
rsort(b, c);
}
// P l, P rで f(P) の形で渡す
template <class U, class F> void sort(vector<U> &a, F f) {
sort(ALL(a), [&](U l, U r) { return f(l) < f(r); });
};
template <class U, class F> void rsort(vector<U> &a, F f) {
sort(ALL(a), [&](U l, U r) { return f(l) > f(r); });
};
// F = T<T>
// 例えばreturn p.fi + p.se;
template <class A, class B, class F>
void sortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
sort(c, f);
rep(i, sz(a)) a[i] = c[i].fi, b[i] = c[i].se;
}
template <class A, class B, class F>
void rsortp(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
rsort(c, f);
rep(i, sz(a)) a[i] = c[i].first, b[i] = c[i].second;
}
template <class A, class B, class C, class F>
void sortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
sort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class F>
void rsortt(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
rsort(d, f);
rep(i, sz(a)) a[i] = d[i].f, b[i] = d[i].s, c[i] = d[i].t;
}
template <class A, class B, class C, class D>
void sortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
sort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
template <class A, class B, class C, class D>
void rsortf(vector<A> &a, vector<B> &b, vector<C> &c, vector<D> &d) {
auto e = vtof(a, b, c, d);
rsort(e);
rep(i, sz(a)) a[i] = e[i].a, b[i] = e[i].b, c[i] = e[i].c, d[i] = e[i].d;
}
/*indexの分で型が変わるためpcomparatorが必要*/
template <class T> vi sorti(vector<T> &a, pcomparator f) {
auto b = a;
vi ind = iota(0, sz(a));
sortp(b, ind, f);
return ind;
}
template <class T, class F> vi sorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(a[x]) < f(a[y]); });
return ind;
}
template <class T> vi rsorti(vector<T> &a) {
auto b = a;
vi ind = iota(0, sz(a));
rsortp(b, ind);
return ind;
}
template <class T, class F> vi rsorti(vector<T> &a, F f) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(a[x]) > f(a[y]); });
return ind;
}
template <class A, class B, class F>
vi sortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(c[x]) < f(c[y]); });
return ind;
}
template <class A, class B>
vi sortpi(vector<A> &a, vector<B> &b, pcomparator f) {
vi ind = iota(0, sz(a));
auto c = a;
auto d = b;
sortt(c, d, ind, f);
return ind;
}
template <class A, class B> vi sortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fisi);
};
template <class A, class B, class F>
vi rsortpi(vector<A> &a, vector<B> &b, F f) {
auto c = vtop(a, b);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(c[x]) > f(c[y]); });
return ind;
}
template <class A, class B> vi rsortpi(vector<A> &a, vector<B> &b) {
return sortpi(a, b, fdsd);
};
template <class A, class B, class C, class F>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(d[x]) < f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c, pcomparator f) {
vi ind = iota(0, sz(a));
auto d = vtof(a, b, c, ind);
sort(d, f);
rep(i, sz(a)) ind[i] = d[i].d;
return ind;
}
template <class A, class B, class C>
vi sortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] < c[y];
else
return b[x] < b[y];
} else {
return a[x] < a[y];
}
});
return ind;
}
template <class A, class B, class C, class F>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c, F f) {
auto d = vtot(a, b, c);
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) { return f(d[x]) > f(d[y]); });
return ind;
}
template <class A, class B, class C>
vi rsortti(vector<A> &a, vector<B> &b, vector<C> &c) {
vi ind = iota(0, sz(a));
sort(ALL(ind), [&](ll x, ll y) {
if (a[x] == a[y]) {
if (b[x] == b[y])
return c[x] > c[y];
else
return b[x] > b[y];
} else {
return a[x] > a[y];
}
});
return ind;
}
template <class T> void sort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
sort(a[i]);
}
template <class T> void rsort2(vector<vector<T>> &a) {
for (ll i = 0, n = a.size(); i < n; ++i)
rsort(a[i]);
}
#endif
template <class T> bool includes(vector<T> &a, vector<T> &b) {
vi c = a;
vi d = b;
sort(c);
sort(d);
return includes(ALL(c), ALL(d));
}
template <class T> bool distinct(const vector<T> &A) {
if ((int)(A).size() == 1)
return true;
if ((int)(A).size() == 2)
return A[0] != A[1];
if ((int)(A).size() == 3)
return (A[0] != A[1] && A[1] != A[2] && A[0] != A[2]);
auto B = A;
sort(B);
int N = (B.size());
unique(B);
return N == (int)(B.size());
}
template <class H, class... T> bool distinct(const H &a, const T &...b) {
return distinct(vector<H>{a, b...});
}
/*@formatter:off*/
template <typename W, typename T> void fill(W &xx, const T vall) { xx = vall; }
template <typename W, typename T> void fill(vector<W> &vecc, const T vall) {
for (auto &&vx : vecc)
fill(vx, vall);
}
template <typename W, typename T> void fill(vector<W> &xx, const T v, ll len) {
rep(i, len) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<W> &xx, const T v, int s, ll t) {
rep(i, s, t) xx[i] = v;
}
template <typename W, typename T>
void fill(vector<vector<W>> &xx, T v, int sh, int th, int sw, int tw) {
rep(h, sh, th) rep(w, sw, tw) xx[h][w] = v;
}
// #define use_fill //_sum _array _max _min
#ifdef use_fill
template <typename A, size_t N, typename T> void fill(A (&a)[N], const T &v) {
rep(i, N) a[i] = v;
}
template <typename A, size_t N, size_t O, typename T>
void fill(A (&a)[N][O], const T &v) {
rep(i, N) rep(j, O) a[i][j] = v;
}
template <typename A, size_t N, size_t O, size_t P, typename T>
void fill(A (&a)[N][O][P], const T &v) {
rep(i, N) rep(j, O) rep(k, P) a[i][j][k] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, typename T>
void fill(A (&a)[N][O][P][Q], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) a[i][j][k][l] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
typename T>
void fill(A (&a)[N][O][P][Q][R], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) a[i][j][k][l][m] = v;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S, typename T>
void fill(A (&a)[N][O][P][Q][R][S], const T &v) {
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S)
a[i][j][k][l][m][n] = v;
}
template <class T, class U> void fill(vector<T> &a, const vi &ind, U val) {
fora(v, ind) { a[v] = val; }
}
template <typename A, size_t N> A sum(A (&a)[N]) {
A res = 0;
rep(i, N) res += a[i];
return res;
}
template <typename A, size_t N, size_t O> A sum(A (&a)[N][O]) {
A res = 0;
rep(i, N) rep(j, O) res += a[i][j];
return res;
}
template <typename A, size_t N, size_t O, size_t P> A sum(A (&a)[N][O][P]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) res += a[i][j][k];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A sum(A (&a)[N][O][P][Q]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) res += a[i][j][k][l];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A sum(A (&a)[N][O][P][Q][R]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) res += a[i][j][k][l][m];
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A sum(A (&a)[N][O][P][Q][R][S]) {
A res = 0;
rep(i, N) rep(j, O) rep(k, P) rep(l, Q) rep(m, R) rep(n, S) res +=
a[i][j][k][l][m][n];
return res;
}
template <typename A, size_t N> A max(A (&a)[N]) {
A res = a[0];
rep(i, N) res = max(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A max(A (&a)[N][O]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A max(A (&a)[N][O][P]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A max(A (&a)[N][O][P][Q], const T &v) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A max(A (&a)[N][O][P][Q][R]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A max(A (&a)[N][O][P][Q][R][S]) {
A res = max(a[0]);
rep(i, N) res = max(res, max(a[i]));
return res;
}
template <typename A, size_t N> A min(A (&a)[N]) {
A res = a[0];
rep(i, N) res = min(res, a[i]);
return res;
}
template <typename A, size_t N, size_t O> A min(A (&a)[N][O]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P> A min(A (&a)[N][O][P]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q>
A min(A (&a)[N][O][P][Q], const T &v) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R>
A min(A (&a)[N][O][P][Q][R]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
template <typename A, size_t N, size_t O, size_t P, size_t Q, size_t R,
size_t S>
A min(A (&a)[N][O][P][Q][R][S]) {
A res = min(a[0]);
rep(i, N) res = min(res, min(a[i]));
return res;
}
#endif
/*@formatter:off*/
template <class T, class U> void inc(pair<T, U> &a, U v = 1) {
a.first += v, a.second += v;
}
template <class T, class U> void inc(T &a, U v = 1) { a += v; }
template <class T, class U = int> void inc(vector<T> &a, U v = 1) {
for (auto &u : a)
inc(u, v);
}
template <class T, class U> void dec(T &a, U v = 1) { a -= v; }
template <class T, class U = int> void dec(vector<T> &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class U> void dec(string &a, U v = 1) {
for (auto &u : a)
dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, W v = 1) {
for (auto &u : a)
dec(u, v);
for (auto &u : b)
dec(u, v);
}
template <class T, class U, class W>
void dec(vector<T> &a, vector<U> &b, vector<W> &c) {
for (auto &u : a)
dec(u, 1);
for (auto &u : b)
dec(u, 1);
for (auto &u : c)
dec(u, 1);
}
bool ins(ll h, ll w, ll H, ll W) { return h >= 0 && w >= 0 && h < H && w < W; }
bool san(ll l, ll v, ll r) { return l <= v && v < r; }
template <class T> bool ins(vector<T> &a, ll i, ll j = 0) {
return san(0, i, sz(a)) && san(0, j, sz(a));
}
#define inside ins
ll u0(ll a) { return a < 0 ? 0 : a; }
template <class T> vector<T> u0(vector<T> &a) {
vector<T> ret = a;
fora(v, ret) { v = u(v); }
return ret;
}
// todo 名前
bool d_(int a, int b) {
if (b == 0)
return false;
return (a % b) == 0;
}
// エラー
void ole() {
#ifdef _DEBUG
cerr << "ole" << endl;
exit(0);
#endif
string a = "a";
rep(i, 30) a += a;
rep(i, 1 << 17) cout << a << endl;
cout << "OLE 出力長制限超過" << endl;
exit(0);
}
void re(string s = "") {
cerr << s << endl;
assert(0 == 1);
exit(0);
}
void tle() {
while (inf)
cout << inf << endl;
}
//@汎用便利関数 入力
ll in() {
ll ret;
cin >> ret;
return ret;
}
template <class T> T in() {
T ret;
cin >> ret;
return ret;
}
string sin() {
string ret;
cin >> ret;
return ret;
}
template <class T> void in(T &head) { cin >> head; }
template <class T, class... U> void in(T &head, U &...tail) {
cin >> head;
in(tail...);
}
// value_typeを持つ場合呼べる
// len回要素を追加する
template <class Iterable, class T = typename Iterable::value_type>
Iterable tin(int len) {
Iterable ret;
T tem;
while (len--) {
cin >> tem;
ret += tem;
}
return ret;
}
template <class T> T tin() {
T ret;
cin >> ret;
return ret;
}
template <class T> T tind(int len = 0) {
auto ret = tin<T>(len);
dec(ret, 1);
return ret;
}
#define din_t2(type, a) \
type a; \
cin >> a
#define din_t3(type, a, b) \
type a, b; \
cin >> a >> b
#define din_t4(type, a, b, c) \
type a, b, c; \
cin >> a >> b >> c
#define din_t5(type, a, b, c, d) \
type a, b, c, d; \
cin >> a >> b >> c >> d
#define din_t6(type, a, b, c, d, e) \
type a, b, c, d, e; \
cin >> a >> b >> c >> d >> e
#define din_t7(type, a, b, c, d, e, f) \
type a, b, c, d, e, f; \
cin >> a >> b >> c >> d >> e >> f
#define din_t(...) \
over7(__VA_ARGS__, din_t7, din_t6, din_t5, din_t4, din_t3, \
din_t2)(__VA_ARGS__)
#define din(...) din_t(int, __VA_ARGS__)
#define d_in
#define dsig(...) din_t(signed, __VA_ARGS__)
#define dst(...) din_t(string, __VA_ARGS__)
#define dstr dst
#define d_str dst
#define dcha(...) din_t(char, __VA_ARGS__)
#define dchar dcha
#define ddou(...) din_t(double, __VA_ARGS__)
#define din1d(a) \
din_t2(int, a); \
a--
#define din2d(a, b) \
din_t3(int, a, b); \
a--, b--
#define din3d(a, b, c) \
din_t4(int, a, b, c); \
a--, b--, c--
#define din4d(a, b, c, d) \
din_t5(int, a, b, c, d); \
a--, b--, c--, d--
#define dind(...) over4(__VA_ARGS__, din4d, din3d, din2d, din1d)(__VA_ARGS__)
/*@formatter:off*/
#ifdef _DEBUG
template <class T> void err2(T &&head) { cerr << head; }
template <class T, class... U> void err2(T &&head, U &&...tail) {
cerr << head << " ";
err2(tail...);
}
template <class T, class... U> void err(T &&head, U &&...tail) {
cerr << head << " ";
err2(tail...);
cerr << "" << endl;
}
template <class T> void err(T &&head) { cerr << head << endl; }
void err() { cerr << "" << endl; }
// debで出力する最大長
constexpr int DEB_LEN = 20;
constexpr int DEB_LEN_H = 12;
string deb_tos(const int &v) {
if (abs(v) == inf || abs(v) == linf)
return "e";
else
return to_string(v);
}
template <class T> string deb_tos(const T &a) {
stringstream ss;
ss << a;
return ss.str();
}
#ifdef use_epsdou
string deb_tos(const epsdou &a) { return deb_tos(a.v); }
#endif
template <class T> string deb_tos(const optional<T> &a) {
if (a.has_value()) {
return deb_tos(a.value());
} else
return "e";
}
template <class T> string deb_tos(const vector<T> &a, ll W = inf) {
stringstream ss;
if (W == inf)
W = min(sz(a), DEB_LEN);
if (sz(a) == 0)
return ss.str();
rep(i, W) {
ss << deb_tos(a[i]);
if (typeid(a[i]) == typeid(P)) {
ss << endl;
} else {
ss << " ";
}
}
return ss.str();
}
template <class T>
string deb_tos(const vector<vector<T>> &a, vi H, vi W, int key = -1) {
stringstream ss;
ss << endl;
vi lens(sz(W));
fora(h, H) {
rep(wi, sz(W)) {
lens[wi] = max(lens[wi], sz(deb_tos(a[h][W[wi]])) + 1);
lens[wi] = max(lens[wi], sz(deb_tos(W[wi])) + 1);
}
}
if (key == -1)
ss << " *|";
else
ss << " " << key << "|";
int wi = 0;
fora(w, W) {
ss << std::right << std::setw(lens[wi]) << w;
wi++;
}
ss << "" << endl;
rep(i, sz(W)) rep(lens[i]) ss << "_";
rep(i, 3) ss << "_";
ss << "" << endl;
fora(h, H) {
ss << std::right << std::setw(2) << h << "|";
int wi = 0;
fora(w, W) {
ss << std::right << std::setw(lens[wi]) << deb_tos(a[h][w]);
wi++;
}
ss << "" << endl;
}
return ss.str();
}
template <class T>
string deb_tos(const vector<vector<T>> &a, ll H = inf, ll W = inf,
int key = -1) {
H = (H != inf) ? H : min({H, sz(a), DEB_LEN_H});
W = min({W, sz(a[0]), DEB_LEN_H});
vi hs, ws;
rep(h, H) { hs.push_back(h); }
rep(w, W) { ws.push_back(w); }
return deb_tos(a, hs, ws, key);
}
template <class T>
string deb_tos(const vector<vector<vector<T>>> &a, ll H = inf) {
stringstream ss;
if (H == inf)
H = DEB_LEN_H;
H = min(H, sz(a));
rep(i, H) {
ss << endl;
ss << deb_tos(a[i], inf, inf, i);
}
return ss.str();
}
template <class T>
string deb_tos(vector<set<T>> &a, ll H = inf, ll W = inf, int key = -1) {
vector<vector<T>> b(sz(a));
rep(i, sz(a)) {
fora(v, a[i]) { b[i].push_back(v); }
}
return deb_tos(b, H, W, key);
}
template <class T, size_t A> string deb_tos(T (&a)[A]) {
return deb_tos(vector<T>(begin(a), end(a)));
}
template <class T, size_t A, size_t B> string deb_tos(T (&a)[A][B]) {
return deb_tos(vector<vector<T>>(begin(a), end(a)));
}
template <class T, size_t A, size_t B, size_t C>
string deb_tos(T (&a)[A][B][C]) {
return deb_tos(vector<vector<vector<T>>>(begin(a), end(a)));
}
/*@formatter:off*/
template <class T> void out2(T head) {
cout << head;
res_mes += deb_tos(head);
}
template <class T, class... U> void out2(T head, U... tail) {
cout << head << " ";
res_mes += deb_tos(head) + " ";
out2(tail...);
}
template <class T, class... U> void out(T head, U... tail) {
cout << head << " ";
res_mes += deb_tos(head) + " ";
out2(tail...);
cout << "" << endl;
res_mes += "\n";
}
template <class T> void out(T head) {
cout << head << endl;
res_mes += deb_tos(head) + "\n";
}
void out() { cout << "" << endl; }
#else
#define err(...) ;
template <class T> void out2(T &&head) { cout << head; }
template <class T, class... U> void out2(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
}
template <class T, class... U> void out(T &&head, U &&...tail) {
cout << head << " ";
out2(tail...);
cout << "" << endl;
}
template <class T> void out(T &&head) { cout << head << endl; }
void out() { cout << "" << endl; }
#endif
template <class T> void outl(const vector<T> &a, int n = inf) {
rep(i, min(n, sz(a))) cout << a[i] << endl;
}
// テーブルをスペースなしで出力
template <class T> void outt(vector<vector<T>> &a) {
rep(i, sz(a)) {
rep(j, sz(a[i])) { cout << a[i][j]; }
cout << endl;
}
}
// int型をbit表記で出力
void outb(int a) { cout << bitset<20>(a) << endl; }
/*@formatter:off*/
template <class T> void na(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i];
}
template <class T> void na(set<T> &a, ll n) { rep(i, n) a.insert(in()); }
#define dna(a, n) \
vi a; \
na(a, n); /*nを複数使うと n==in()の時バグる事に注意*/
#define dnad(a, n) \
vi a; \
nad(a, n);
template <class T> void nao(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1];
}
template <class T> void naod(vector<T> &a, ll n) {
a.resize(n + 1);
a[0] = 0;
rep(i, n) cin >> a[i + 1], a[i + 1]--;
}
template <class T> void nad(vector<T> &a, ll n) {
a.resize(n);
rep(i, n) cin >> a[i], a[i]--;
}
template <class T> void nad(set<T> &a, ll n) { rep(i, n) a.insert(in() - 1); }
template <class T, class U> void na2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i];
}
template <class T, class U> void na2(set<T> &a, set<U> &b, ll n) {
rep(i, n) {
a.insert(in());
b.insert(in());
}
}
#define dna2(a, b, n) \
vi a, b; \
na2(a, b, n);
template <class T, class U> void nao2(vector<T> &a, vector<U> &b, ll n) {
a.resize(n + 1);
b.resize(n + 1);
a[0] = b[0] = 0;
rep(i, n) cin >> a[i + 1] >> b[i + 1];
}
template <class T, class U> void na2d(vector<T> &a, vector<U> &b, ll n) {
a.resize(n);
b.resize(n);
rep(i, n) cin >> a[i] >> b[i], a[i]--, b[i]--;
}
#define dna2d(a, b, n) \
vi a, b; \
na2d(a, b, n);
template <class T, class U, class W>
void na3(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i];
}
#define dna3(a, b, c, n) \
vi a, b, c; \
na3(a, b, c, n);
template <class T, class U, class W>
void na3d(vector<T> &a, vector<U> &b, vector<W> &c, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i], a[i]--, b[i]--, c[i]--;
}
#define dna3d(a, b, c, n) \
vi a, b, c; \
na3d(a, b, c, n);
template <class T, class U, class W, class X>
void na4(vector<T> &a, vector<U> &b, vector<W> &c, vector<X> &d, ll n) {
a.resize(n);
b.resize(n);
c.resize(n);
d.resize(n);
rep(i, n) cin >> a[i] >> b[i] >> c[i] >> d[i];
}
#define dna4(a, b, c, d, n) \
vi a, b, c, d; \
na4(a, b, c, d, n);
#define dna4d(a, b, c, d, n) \
vi a, b, c, d; \
na4d(a, b, c, d, n);
#define nt(a, h, w) \
resize(a, h, w); \
rep(nthi, h) rep(ntwi, w) cin >> a[nthi][ntwi];
#define ntd(a, h, w) \
resize(a, h, w); \
rep(ntdhi, h) rep(ntdwi, w) cin >> a[ntdhi][ntdwi], a[ntdhi][ntdwi]--;
#define ntp(a, h, w) \
resize(a, h + 2, w + 2); \
fill(a, '#'); \
rep(ntphi, 1, h + 1) rep(ntpwi, 1, w + 1) cin >> a[ntphi][ntpwi];
#define dnt(S, h, w) \
vvi(S, h, w); \
nt(S, h, w);
#define dntc(S, h, w) \
vvc(S, h, w); \
nt(S, h, w);
#define dnts(S, h, w) \
vvs(S, h, w); \
nt(S, h, w);
// デバッグ
#define sp << " " <<
/*@formatter:off*/
#define deb1(x) debugName(x) << " = " << deb_tos(x)
#define deb_2(x, ...) deb1(x) << ", " << deb1(__VA_ARGS__)
#define deb_3(x, ...) deb1(x) << ", " << deb_2(__VA_ARGS__)
#define deb_4(x, ...) deb1(x) << ", " << deb_3(__VA_ARGS__)
#define deb5(x, ...) deb1(x) << ", " << deb_4(__VA_ARGS__)
#define deb6(x, ...) deb1(x) << ", " << deb5(__VA_ARGS__)
// #define deb7(x, ...) deb1(x) <<", "<< deb6(__VA_ARGS__)
// #define deb8(x, ...) deb1(x) <<", "<< deb7(__VA_ARGS__)
// #define deb9(x, ...) deb1(x) <<", "<< deb8(__VA_ARGS__)
// #define deb10(x, ...) deb1(x) <<", "<< deb9(__VA_ARGS__)
/*@formatter:off*/
#ifdef _DEBUG
bool was_deb = false;
#define deb(...) \
do { \
was_deb = true; \
cerr << over10(__VA_ARGS__, deb10, deb9, deb8, deb7, deb6, deb5, deb_4, \
deb_3, deb_2, deb1)(__VA_ARGS__) \
<< endl; \
} while (0)
#define base_keta 8
void print_n_base(int x, int base) { cerr << bitset<base_keta>(x) << endl; }
template <class T> void print_n_base(vector<T> X, int base) {
cerr << endl;
for (auto &&x : X) {
print_n_base(x, base);
}
cerr << endl;
}
// n進数
#define deb2(x) \
was_deb = true; \
cerr << debugName(x) << " = "; \
print_n_base(x, 2);
#define deb3(x) \
was_deb = true; \
cerr << debugName(x) << " = "; \
print_n_base(x, 3);
#define deb4(x) \
was_deb = true; \
cerr << debugName(x) << " = "; \
print_n_base(x, 4);
#define deb_ex_deb(x, len) debugName(x) << " = " << deb_tos(x, len)
#define call_deb_ex_deb(x, len) deb_ex_deb(x, len)
// 要素が存在する行だけ出力(vvt)
#define deb_ex(v) \
do { \
int N = sz(v); \
int s = N; \
int t = 0; \
rep(i, N) { \
if (sz(v[i])) { \
chmi(s, i); \
chma(t, i); \
} \
} \
auto ex_v = sub(v, s, N); \
str S = deb_tos(ex_v, sz(ex_v)); \
debugName(v); \
cerr << " = " << endl; \
cerr << S << endl; \
} while (0);
#define debi(A) \
{ \
int len = min(sz(A), 20); \
was_deb = true; \
cerr << debugName(A) << " = " << endl; \
rep(i, len) cerr << std::right \
<< std::setw((int)(sz(tos(A[i])) + (i ? 1 : 0))) \
<< (i % 10); \
cerr << endl; \
rep(i, len) cerr << std::right \
<< std::setw((int)(sz(tos(A[i])) + (i ? 1 : 0))) << A[i]; \
cerr << endl; \
}
template <class T, class F>
string deb_tos_f(vector<vector<T>> &a, F f, int key = -1) {
vi hs, ws_;
int H = sz(a), W = sz(a[0]);
vi exh(H), exw(W);
rep(h, H) {
rep(w, W) {
if (f(a[h][w])) {
exh[h] = true;
exw[w] = true;
}
}
}
rep(h, H) if (exh[h]) hs.push_back(h);
rep(w, W) if (exw[w]) ws_.push_back(w);
return deb_tos(a, hs, ws_, key);
}
template <class T, class F>
string deb_tos_f(vector<vector<vector<T>>> &a, F f) {
stringstream ss;
int H = sz(a);
if (sz(a) == 0)
return ss.str();
rep(i, H) { ss << deb_tos_f(a[i], f, i); }
ss << "" << endl;
return ss.str();
}
#define debf_normal(tab, f) \
do { \
cerr << debugName(tab) << " = " << endl; \
cerr << deb_tos_f(tab, f) << endl; \
} while (0);
#define debf2(tab, siki_r) debf_normal(tab, lamr(siki_r))
#define debf3(tab, v, siki) debf_normal(tab, lam(siki))
// S, sikir
// S, v, siki
#define debf(...) over3(__VA_ARGS__, debf3, debf2, debf1)(__VA_ARGS__)
#else
#define deb(...) ;
#define deb2(...) ;
#define deb3(...) ;
#define deb4(...) ;
#define deb_ex(...) ;
#define debf(...) ;
#define debi(...) ;
#endif
#define debugline(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n'
/*@formatter:off*/
using u32 = unsigned;
using u64 = unsigned long long;
using u128 = __uint128_t;
using bint = __int128;
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
std::ostream::sentry s(dest);
if (s) {
__uint128_t 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 = '-';
}
ll len = std::end(buffer) - d;
if (dest.rdbuf()->sputn(d, len) != len) {
dest.setstate(std::ios_base::badbit);
}
}
return dest;
}
__int128 to_bint(string &s) {
__int128 ret = 0;
for (ll i = 0; i < (ll)s.length(); ++i)
if ('0' <= s[i] && s[i] <= '9')
ret = 10 * ret + s[i] - '0';
return ret;
}
void operator>>(istream &iss, bint &v) {
string S;
iss >> S;
v = 0;
rep(i, sz(S)) {
v *= 10;
v += S[i] - '0';
}
}
// 便利関数
/*@formatter:off*/
// テスト用
#define rand xor128_
unsigned long xor128_(void) {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
char ranc() { return (char)('a' + rand() % 26); }
ll rand(ll min, ll max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
if (rand() % 2) {
return rand(0, max);
} else {
return -rand(0, -min);
}
}
}
ll rand(ll max) { return rand(0, max); }
template <class T> T rand(vector<T> &A) { return A[rand(sz(A) - 1)]; }
// 重複することがある
template <class T> vector<T> ranv(vector<T> &A, int N) {
vector<T> ret(N);
rep(i, N) { ret[i] = rand(A); }
return ret;
}
template <class T> vector<T> ranv_unique(vector<T> &A, int N) {
vector<T> ret(N);
umapi was;
rep(j, N) {
int i;
while (1) {
i = rand(sz(A) - 1);
if (was.find(i) == was.end())
break;
}
ret[j] = A[i];
was[i] = 1;
}
return ret;
}
vi ranv(ll n, ll min, ll max) {
vi v(n);
rep(i, n) v[i] = rand(min, max);
return v;
}
/*@formatter:off*/
#ifdef _DEBUG
bool timeup(int time) {
static bool never = true;
if (never)
message += "may timeup, because slow";
never = false;
auto end_time = system_clock::now();
auto part = duration_cast<milliseconds>(end_time - start_time);
auto lim = milliseconds(time);
return part >= lim;
}
#else
bool timeup(int time) {
auto end_time = system_clock::now();
auto part = duration_cast<milliseconds>(end_time - start_time);
auto lim = milliseconds(time);
return part >= lim;
}
#endif
void set_time() { past_time = system_clock::now(); }
// MS型(millisecqnds)で返る
// set_timeをしてからの時間
auto calc_time_milli() {
auto now = system_clock::now();
auto part = duration_cast<milliseconds>(now - past_time);
return part;
}
auto calc_time_micro() {
auto now = system_clock::now();
auto part = duration_cast<microseconds>(now - past_time);
return part;
}
auto calc_time_nano() {
auto now = system_clock::now();
auto part = duration_cast<nanoseconds>(now - past_time);
return part;
}
bool calc_time(int zikan) { return calc_time_micro() >= microseconds(zikan); }
using MS = std::chrono::microseconds;
int div(microseconds a, microseconds b) { return a / b; }
int div(nanoseconds a, nanoseconds b) {
if (b < nanoseconds(1)) {
return a / nanoseconds(1);
}
int v = a / b;
return v;
}
// set_time();
// rep(i,lim)shori
// lim*=time_nanbai();
// rep(i,lim)shoriと使う
// 全体でmilliかかっていいときにlimを何倍してもう一回できるかを返す
int time_nanbai(int milli) {
auto dec = duration_cast<nanoseconds>(past_time - start_time);
auto part = calc_time_nano();
auto can_time = nanoseconds(milli * 1000 * 1000);
can_time -= part;
can_time -= dec;
return div(can_time, part);
}
/*@formatter:off*/
// #define use_rand
#ifdef use_rand
str ransu(ll n) {
str s;
rep(i, n) s += (char)rand('A', 'Z');
return s;
}
str ransl(ll n) {
str s;
rep(i, n) s += (char)rand('a', 'z');
return s;
}
// 単調増加
vi ranvinc(ll n, ll min, ll max) {
vi v(n);
bool bad = 1;
while (bad) {
bad = 0;
v.resize(n);
rep(i, n) {
if (i && min > max - v[i - 1]) {
bad = 1;
break;
}
if (i)
v[i] = v[i - 1] + rand(min, max - v[i - 1]);
else
v[i] = rand(min, max);
}
}
return v;
}
// 便利 汎用
#endif
void ranvlr(ll n, ll min, ll max, vi &l, vi &r) {
l.resize(n);
r.resize(n);
rep(i, n) {
l[i] = rand(min, max);
r[i] = l[i] + rand(0, max - l[i]);
}
}
template <class Iterable, class T = typename Iterable::value_type>
vector<pair<T, int>> run_length(const Iterable &a) {
vector<pair<T, int>> ret;
ret.eb(a[0], 1);
rep(i, 1, sz(a)) {
if (ret.back().fi == a[i]) {
ret.back().se++;
} else {
ret.eb(a[i], 1);
}
}
return ret;
}
/*@formatter:off*/
// #define use_mgr //_goldd _goldt
#ifdef use_mgr
//->[i, f(i)]
template <class T, class U, class F>
auto mgr(T ok, U ng, const F &f,
require_arg(is_integral<T>::value &&is_integral<U>::value)) {
auto mid = (ok + ng);
if (ok < ng)
while (ng - ok > 1) {
mid = (ok + ng) >> 1;
if (f(mid))
ok = mid;
else
ng = mid;
}
else
while (ok - ng > 1) {
mid = (ok + ng) >> 1;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
//[l, r)の中で,f(i)がtrueとなる範囲を返す okはそこに含まれる
template <class F> P mgr_range(int l, int r, F f, int ok) {
if (f(ok) == 0) {
out("f(ok) must true");
re();
}
return mp(mgr(ok, l - 1, f), mgr(ok, r, f) + 1);
}
template <class F> auto mgrd(dou ok, dou ng, F f, int kai = 100) {
if (ok < ng)
rep(i, kai) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
else
rep(i, kai) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
template <class F> dou mgrd_time(dou ok, dou ng, F f, int time = 1980) {
bool han = true;
if (ok < ng)
while (1) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid, han = true;
else
ng = mid, han = false;
deb(mid, han);
if (timeup(time)) {
break;
}
}
else
while (1) {
dou mid = (ok + ng) / 2;
if (f(mid))
ok = mid, han = true;
else
ng = mid, han = false;
deb(mid, han);
if (timeup(time)) {
break;
}
}
return ok;
}
// todo 減らす
template <class F> auto goldd_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
ll minScore = MAX<ll>();
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (minScore > score) {
minScore = score;
resIndex = i;
}
}
return make_tuple(resIndex, calc(resIndex));
}
template <class F> auto goldt_l(ll left, ll right, F calc) {
double GRATIO = 1.6180339887498948482045868343656;
ll lm = left + (ll)((right - left) / (GRATIO + 1.0));
ll rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
ll fl = calc(lm);
ll fr = calc(rm);
while (right - left > 10) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + (ll)((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + (ll)((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
if (left > right) {
ll l = left;
left = right;
right = l;
}
ll maxScore = MIN<ll>();
ll resIndex = left;
for (ll i = left; i < right + 1; ++i) {
ll score = calc(i);
if (maxScore < score) {
maxScore = score;
resIndex = i;
}
}
return make_tuple(resIndex, calc(resIndex));
}
/*loopは200にすればおそらく大丈夫 余裕なら300に*/
template <class F> auto goldd_d(dou left, dou right, F calc, ll loop = 200) {
dou GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm); /*200にすればおそらく大丈夫*/ /*余裕なら300に*/
ll k = 141;
loop++;
while (--loop) {
if (fl < fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return make_tuple(left, calc(left));
}
template <class F> auto goldt_d(dou left, dou right, F calc, ll loop = 200) {
double GRATIO = 1.6180339887498948482045868343656;
dou lm = left + ((right - left) / (GRATIO + 1.0));
dou rm = lm + ((right - lm) / (GRATIO + 1.0));
dou fl = calc(lm);
dou fr = calc(rm);
loop++;
while (--loop) {
if (fl > fr) {
right = rm;
rm = lm;
fr = fl;
lm = left + ((right - left) / (GRATIO + 1.0));
fl = calc(lm);
} else {
left = lm;
lm = rm;
fl = fr;
rm = lm + ((right - lm) / (GRATIO + 1.0));
fr = calc(rm);
}
}
return make_tuple(left, calc(left));
}
// l ~ rを複数の区間に分割し、極致を与えるiを返す time-20 msまで探索
template <class F> auto goldd_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll mini = 0, minv = MAX<ll>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldd_l(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(mini, calc(mini));
}
template <class F> auto goldt_ls(ll l, ll r, F calc, ll time = 2000) {
auto lim = milliseconds(time - 20);
ll maxi = 0, maxv = MIN<ll>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
ll haba = (r - l + k) / k; /*((r-l+1) + k-1) /k*/
ll nl = l;
ll nr = l + haba;
rep(i, k) {
ll ni = goldt_l(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(maxi, calc(maxi));
}
template <class F>
auto goldd_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を持つ*/
auto lim = milliseconds(time - 20);
dou mini = 0, minv = MAX<dou>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldd_d(nl, nr, calc);
if (chmi(minv, calc(ni)))
mini = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(mini, calc(mini));
}
template <class F>
auto goldt_d_s(dou l, dou r, F calc, ll time = 2000) { /*20ms余裕を残している*/
auto lim = milliseconds(time - 20);
dou maxi = 0, maxv = MIN<dou>(); /*区間をk分割する*/
rep(k, 1, inf) {
auto s = system_clock::now();
dou haba = (r - l) / k;
dou nl = l;
dou nr = l + haba;
rep(i, k) {
dou ni = goldt_d(nl, nr, calc);
if (chma(maxv, calc(ni)))
maxi = ni;
nl = nr;
nr = nl + haba;
}
auto end = system_clock::now();
auto part = duration_cast<milliseconds>(end - s);
auto elapsed = duration_cast<milliseconds>(end - start_time);
if (elapsed + part * 2 >= lim) {
break;
}
}
return make_tuple(maxi, calc(maxi));
}
#endif
// strを整数として比較
string smax(str &a, str b) {
if (sz(a) < sz(b)) {
return b;
} else if (sz(a) > sz(b)) {
return a;
} else if (a < b)
return b;
else
return a;
}
// strを整数として比較
string smin(str &a, str b) {
if (sz(a) > sz(b)) {
return b;
} else if (sz(a) < sz(b)) {
return a;
} else if (a > b)
return b;
else
return a;
}
// エラー-1
template <typename W, typename T> ll find(vector<W> &a, int l, const T key) {
rep(i, l, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename W, typename T> ll find(vector<W> &a, const T key) {
rep(i, sz(a)) if (a[i] == key) return i;
return -1;
}
template <typename W, typename T> P find(vector<vector<W>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return mp(i, j);
return mp(-1, -1);
}
// getid(find())を返す 1次元にする
template <typename W, typename T> int findi(vector<vector<W>> &a, const T key) {
rep(i, sz(a)) rep(j, sz(a[0])) if (a[i][j] == key) return i * sz(a[0]) + j;
return -1;
}
template <typename W, typename U>
tuple<int, int, int> find(vector<vector<vector<W>>> &a, const U key) {
rep(i, sz(a)) rep(j, sz(a[0]))
rep(k, sz(a[0][0])) if (a[i][j][k] ==
key) return tuple<int, int, int>(i, j, k);
return tuple<int, int, int>(-1, -1, -1);
}
// 無ければ-1
int find(string &s, const string key) {
int klen = sz(key);
rep(i, sz(s) - klen + 1) {
if (s[i] != key[0])
continue;
if (s.substr(i, klen) == key) {
return i;
}
}
return -1;
}
int find(string &s, int l, const string key) {
int klen = sz(key);
rep(i, l, sz(s) - klen + 1) {
if (s[i] != key[0])
continue;
if (s.substr(i, klen) == key) {
return i;
}
}
return -1;
}
int find(string &s, const char key) {
rep(i, sz(s)) {
if (s[i] == key)
return i;
}
return -1;
}
int find(string &s, int l, const char key) {
rep(i, l, sz(s)) {
if (s[i] == key)
return i;
}
return -1;
}
// N箇所について右のkeyの場所を返す
template <typename W, typename T> vi finds(const W &a, const T &key) {
int n = sz(a);
vi rpos(n, -1);
rer(i, n - 1) {
if (i < n - 1) {
rpos[i] = rpos[i + 1];
}
if (a[i] == key)
rpos[i] = i;
}
return rpos;
}
template <typename W, typename T> vi rfinds(const W &a, const T &key) {
int n = sz(a);
vi lpos(n, -1);
rep(i, n) {
if (i > 0) {
lpos[i] = lpos[i - 1];
}
if (a[i] == key)
lpos[i] = i;
}
return lpos;
}
// todoz
#if __cplusplus >= 201703L
template <typename W, typename T, class Iterable = typename W::value_type>
ll count(const W &a, const T &k) {
return count_if(a, == k);
}
/*@formatter:on*/
template <typename W, class Iterable = typename W::value_type>
vi count(const W &a) {
vi res;
for_each(a, v, if (sz(res) <= (int)v) res.resize((int)v + 1); res[v]++;);
return res;
}
#endif
/*@formatter:off*/
ll count(const str &a, const str &k) {
ll ret = 0, len = k.length();
auto pos = a.find(k);
while (pos != string::npos)
pos = a.find(k, pos + len), ++ret;
return ret;
}
/*@formatter:off*/
//'a' = 'A' = 0 として集計 既に-'a'されていても動く
vi count(str &a, int l, int r) {
vi cou(26);
char c = 'a';
if ('A' <= a[l] && a[l] <= 'Z')
c = 'A';
if ('a' <= a[l] && a[l] <= 'z')
c = 'a';
else
c = 0;
rep(i, l, r)++ cou[a[i] - c];
return cou;
}
#define couif count_if
// algorythm
ll rev(ll a) {
ll res = 0;
while (a) {
res *= 10;
res += a % 10;
a /= 10;
}
return res;
}
template <class T> auto rev(const vector<T> &a) {
auto b = a;
reverse(ALL(b));
return b;
}
/* ＼反転 */ template <class U> auto rev(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[h][w];
return b;
}
/* ｜反転 */ template <class U> auto revw(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a), vector<U>(sz(a[0])));
int W = sz(a[0]);
rep(h, sz(a)) rep(w, sz(a[0])) { b[h][W - 1 - w] = a[h][w]; }
return b;
}
/* ー反転 */ template <class U> auto revh(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a), vector<U>(sz(a[0])));
int H = sz(a);
rep(h, sz(a)) rep(w, sz(a[0])) { b[H - 1 - h][w] = a[h][w]; }
return b;
}
/* ／反転 */ template <class U> auto revr(vector<vector<U>> &a) {
vector<vector<U>> b(sz(a[0]), vector<U>(sz(a)));
int H = sz(a);
int W = sz(a[0]);
rep(h, sz(a)) rep(w, sz(a[0])) b[w][h] = a[H - 1 - h][W - 1 - w];
return b;
}
auto rev(const string &a) {
string b = a;
reverse(ALL(b));
return b;
}
template <class T> auto rev(const T &v, int i) { return v[sz(v) - 1 - i]; }
int rev(int N, int i) { return N - 1 - i; }
constexpr ll p10[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000ll,
100000000000ll,
1000000000000ll,
10000000000000ll,
100000000000000ll,
1000000000000000ll,
10000000000000000ll,
100000000000000000ll,
1000000000000000000ll};
// 0は0桁
ll keta(ll v, int if_zero_res) {
if (!v)
return if_zero_res;
if (v < p10[9]) {
if (v < p10[4]) {
if (v < p10[2]) {
if (v < p10[1]) {
if (v < p10[0])
return 0;
else
return 1;
} else
return 2;
} else {
if (v < p10[3])
return 3;
else
return 4;
}
} else {
if (v < p10[7]) {
if (v < p10[5])
return 5;
else if (v < p10[6])
return 6;
else
return 7;
} else {
if (v < p10[8])
return 8;
else
return 9;
}
}
} else {
if (v < p10[13]) {
if (v < p10[11]) {
if (v < p10[10])
return 10;
else
return 11;
} else {
if (v < p10[12])
return 12;
else
return 13;
}
} else {
if (v < p10[15]) {
if (v < p10[14])
return 14;
else
return 15;
} else {
if (v < p10[17]) {
if (v < p10[16])
return 16;
else
return 17;
} else {
if (v < p10[18])
return 18;
else
return 19;
}
}
}
}
}
#if __cplusplus >= 201703L
ll getr(ll a, ll keta) { return (a / pow<ll>(10, keta)) % 10; }
#else
ll getr(ll a, ll keta) { return (a / (int)pow(10, keta)) % 10; }
#endif
// 上から何桁目か
ll getl(ll a, ll ket) {
int sketa = keta(a, 1);
return getr(a, sketa - 1 - ket);
}
ll dsum(ll v, ll sin = 10) {
ll ret = 0;
for (; v; v /= sin)
ret += v % sin;
return ret;
}
ll mask10(ll v) { return p10[v] - 1; }
// 変換系
template <class T, class U>
auto to_v1(vector<reference_wrapper<U>> &ret, vector<T> &A) {
rep(i, sz(A)) ret.push_back(A[i]);
return ret;
}
template <class T, class U>
auto to_v1(vector<reference_wrapper<U>> &ret, vector<vector<T>> &A) {
rep(i, sz(A)) to_v1(ret, A[i]);
return ret;
}
// 参照付きで1次元に起こす
template <class T> auto to_v1(vector<vector<T>> &A) {
vector<reference_wrapper<typename decl2<decltype(A)>::type>> ret;
rep(i, sz(A)) to_v1(ret, A[i]);
return ret;
}
//[v] := iとなるようなvectorを返す
// 存在しない物は-1
// 空でも動く(なぜか)
template <class T> auto keys(const T &a) {
vector<decltype((a.begin())->fi)> res;
for (auto &&k : a)
res.push_back(k.fi);
return res;
}
template <class T> auto values(const T &a) {
vector<decltype((a.begin())->se)> res;
for (auto &&k : a)
res.push_back(k.se);
return res;
}
// todo 可変長で
template <class T> constexpr T min(T a, T b, T c) {
return a >= b ? b >= c ? c : b : a >= c ? c : a;
}
template <class T> constexpr T max(T a, T b, T c) {
return a <= b ? b <= c ? c : b : a <= c ? c : a;
}
template <class V, class T = typename V::value_type>
T min(V &a, ll s = -1, ll n = -1) {
set_lr12(s, n, sz(a));
return *min_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class V, class T = typename V::value_type>
T max(V &a, ll s = -1, ll n = -1) {
set_lr12(s, n, sz(a));
return *max_element(a.begin() + s, a.begin() + min(n, sz(a)));
}
template <class T> int mini(const vector<T> &a) {
return min_element(ALL(a)) - a.begin();
}
template <class T> int maxi(const vector<T> &a) {
return max_element(ALL(a)) - a.begin();
}
template <class T> T sum(const vector<T> &A, int l = -1, int r = -1) {
T s = 0;
set_lr12(l, r, sz(A));
rep(i, l, r) s += A[i];
return s;
}
template <class T> auto sum(const vector<vector<T>> &A) {
decl2<decltype(A)> s = 0;
rep(i, sz(A)) s += sum(A[i]);
return s;
}
template <class T> T min(const vector<T> &A, int l = -1, int r = -1) {
T s = MAX<T>();
set_lr12(l, r, sz(A));
rep(i, l, r) s = min(s, A[i]);
return s;
}
template <class T> auto min(const vector<vector<T>> &A) {
using S = decl2<decltype(A)>;
S s = MAX<S>();
rep(i, sz(A)) s = min(s, A[i]);
return s;
}
template <class T> T max(const vector<T> &A, int l = -1, int r = -1) {
T s = MIN<T>();
set_lr12(l, r, sz(A));
rep(i, l, r);
rep(i, l, r) s = max(s, A[i]);
return s;
}
template <class T> auto max(const vector<vector<T>> &A) {
using S = decl2<decltype(A)>;
S s = MIN<S>();
rep(i, sz(A)) s = max(s, A[i]);
return s;
}
template <class T> T mul(vector<T> &v, ll t = inf) {
T ret = v[0];
rep(i, 1, min(t, sz(v))) ret *= v[i];
return ret;
}
// template<class T, class U, class... W> auto sumn(vector<T> &v, U head, W...
// tail) { auto ret = sum(v[0], tail...); rep(i, 1, min(sz(v), head))ret
// += sum(v[i], tail...); return ret;} indexを持つvectorを返す
vi inds_(vi &a) {
int n = max(a) + 1;
vi ret(n, -1);
rep(i, sz(a)) {
assert(ret[a[i]] == -1);
ret[a[i]] = i;
}
return ret;
}
void clear(PQ &q) { q = PQ(); }
void clear(priority_queue<int> &q) { q = priority_queue<int>(); }
template <class T> void clear(queue<T> &q) {
while (q.size())
q.pop();
}
// template<class T> T *negarr(ll size) { T *body = (T *) malloc((size * 2 +
// 1) * sizeof(T)); return body + size;} template<class T> T *negarr2(ll h,
// ll w) { double **dummy1 = new double *[2 * h + 1]; double *dummy2 = new
// double[(2 * h + 1) * (2 * w + 1)]; dummy1[0] = dummy2 + w; for (ll i =
// 1; i <= 2 * h + 1; ++i) { dummy1[i] = dummy1[i - 1] + 2 * w + 1; } double
// **a = dummy1 + h; return a;}
template <class T> struct ruiC {
vector<T> rui;
ruiC(vector<T> &ru) : rui(ru) {}
/*先頭0*/
ruiC() : rui(1, 0) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruic ";
deb(l, r);
assert(0);
}
return rui[r] - rui[l];
}
T operator()(int r = inf) { return operator()(0, min(r, sz(rui) - 1)); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
T operator[](ll i) { return rui[i]; }
/*0から順に追加される必要がある*/
void operator+=(T v) { rui.push_back(rui.back() + v); }
void add(int i, T v) {
if (sz(rui) - 1 != i)
ole();
operator+=(v);
}
T back() { return rui.back(); }
ll size() { return rui.size(); }
auto begin() { return rui.begin(); }
auto end() { return rui.end(); }
};
template <class T> string deb_tos(const ruiC<T> &a) { return deb_tos(a.rui); }
template <class T> ostream &operator<<(ostream &os, ruiC<T> a) {
fora(v, a.rui) { os << v << " "; }
return os;
}
template <class T> vector<T> ruiv(const vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + a[i];
return ret;
}
template <class T> ruiC<T> ruic(const vector<T> &a) {
vector<T> ret = ruiv(a);
return ruiC<T>(ret);
}
template <class T> ruiC<T> ruic() { return ruiC<T>(); }
// imoは0-indexed
// ruiは1-indexed
template <class T> vector<T> imo(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] += ret[i];
return ret;
}
// #define use_rui //_imo _ruic _ruiv
#ifdef use_rui
// kと同じものの数
template <class T, class U> vi imo(const vector<T> &a, U k) {
vi equ(sz(a));
rep(i, sz(a)) { equ[i] = a[i] == k; }
return imo(equ);
}
template <class T> vector<T> imox(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) ret[i + 1] ^= ret[i];
return ret;
}
// 漸化的に最小を持つ
template <class T> vector<T> imi(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chmi(ret[i + 1], ret[i]);
return ret;
}
template <class T> vector<T> ima(const vector<T> &v) {
vector<T> ret = v;
rep(i, sz(ret) - 1) chma(ret[i + 1], ret[i]);
return ret;
}
template <class T> vector<T> rimi(const vector<T> &v) {
vector<T> ret = v;
rer(i, sz(ret) - 1, 1) chmi(ret[i - 1], ret[i]);
return ret;
}
template <class T> vector<T> rima(const vector<T> &v) {
vector<T> ret = v;
rer(i, sz(ret) - 1, 1) chma(ret[i - 1], ret[i]);
return ret;
}
template <class T> struct ruimax {
template <typename Monoid> struct SegmentTree { /*pairで処理*/
int sz;
vector<Monoid> seg;
const Monoid M1 = mp(MIN<T>(), -1);
Monoid f(Monoid a, Monoid b) { return max(a, b); }
void build(vector<T> &a) {
int n = sz(a);
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
rep(i, n) { seg[i + sz] = mp(a[i], i); }
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[k << 1], seg[(k << 1) | 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]; }
};
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
public:
int n;
ruimax(vector<T> &a) : ve(a), n(sz(a)) {
int index = -1;
T ma = MIN<T>();
rv.resize(n + 1);
ri.resize(n + 1);
rv[0] = -INF<T>;
ri[0] = -1;
rep(i, n) {
if (chma(ma, a[i])) {
index = i;
}
rv[i + 1] = ma;
ri[i + 1] = index;
}
}
T operator()(int l, int r) {
if (!(l <= r && 0 <= l && r <= n)) {
deb(l, r, n);
assert(0);
}
if (l == 0) {
return rv[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).first;
}
}
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) {
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return ri[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).second;
}
}
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template <class T> struct ruimin {
template <typename Monoid> struct SegmentTree { /*pairで処理*/
int sz;
vector<Monoid> seg;
const Monoid M1 = mp(MAX<T>(), -1);
Monoid f(Monoid a, Monoid b) { return min(a, b); }
void build(vector<T> &a) {
int n = sz(a);
sz = 1;
while (sz < n)
sz <<= 1;
seg.assign(2 * sz, M1);
rep(i, n) { seg[i + sz] = mp(a[i], i); }
for (int k = sz - 1; k > 0; k--) {
seg[k] = f(seg[k << 1], seg[(k << 1) | 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]; }
};
private:
vector<T> ve;
SegmentTree<pair<T, int>> seg;
vector<T> rv;
vector<int> ri;
bool build = false;
int n;
public:
ruimin(vector<T> &a) : ve(a), n(sz(a)) {
int index = -1;
T mi = MAX<T>();
rv.resize(n + 1);
ri.resize(n + 1);
rv[0] = INF<T>;
ri[0] = -1;
rep(i, n) {
if (chmi(mi, a[i])) {
index = i;
}
rv[i + 1] = mi;
ri[i + 1] = index;
}
}
T operator()(int l, int r) {
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return rv[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).first;
}
}
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
T getv(int l, int r) { return operator()(l, r); }
T getv(int r = inf) { return getv(0, min(r, n)); };
int geti(int l, int r) {
{
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return ri[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).second;
}
}
assert(l <= r && 0 <= l && r <= n);
if (l == 0) {
return ri[r];
} else {
if (!build)
seg.build(ve), build = true;
return seg.query(l, r).second;
}
}
int geti(int r = inf) { return geti(0, min(r, n)); };
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
}; /*@formatter:off*/
vvi() ruib(vi &a) {
vvi(res, 61, sz(a) + 1);
rep(k, 61) {
rep(i, sz(a)) { res[k][i + 1] = res[k][i] + ((a[i] >> k) & 1); }
}
return res;
}
vector<ruiC<int>> ruibc(vi &a) {
vector<ruiC<int>> ret(61);
vvi(res, 61, sz(a));
rep(k, 61) {
rep(i, sz(a)) { res[k][i] = (a[i] >> k) & 1; }
ret[k] = ruic(res[k]);
}
return ret;
}
// kと同じものの数
template <class T, class U> vi ruiv(T &a, U k) {
vi ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] + (a[i] == k);
return ret;
}
template <class T, class U> ruiC<ll> ruic(T &a, U k) {
vi ret = ruiv(a, k);
return ruiC<ll>(ret);
}
template <class T> struct ruiC2 {
int H;
vector<ruiC<T>> rui;
ruiC<T> dummy; // 変なのをよばれたときはこれを返す//todo
ruiC2(const vector<vector<T>> &ru) : rui(sz(ru)), H(sz(ru)) {
for (int h = 0; h < H; h++) {
if (sz(ru[h]) == 0)
continue;
if (sz(dummy) == 1)
dummy = ruic(vector<T>(sz(ru[h])));
rui[h] = ruic(ru[h]);
}
}
// WについてHを返す
vector<T> operator()(ll l, ll r) {
if (l > r) {
cerr << "ruic ";
deb(l, r);
assert(0);
}
vector<T> res(H);
for (int h = 0; h < H; h++)
res[h] = rui[h](l, r);
return res;
}
// HについてWを返す
ruiC<T> &operator[](ll h) {
#ifdef _DEBUG
if (h >= H) {
message += "warning ruiC h >= H";
}
#endif
if (h >= H || sz(rui[h]) == 1)
return dummy;
else
return rui[h];
}
/*@formatter:off*/
// vector<T> operator()(int r) { return operator()(0, r); }
/*ruiv[]をruic[]に変えた際意味が変わるのがまずいため()と統一*/
/*単体iを返す 累積でないことに注意(seg木との統一でこうしている)*/
// T operator[](ll i) { return rui[i + 1] - rui[i]; }
/*0から順に追加される必要がある*/
// T back() { return rui.back(); }
// ll size() { return rui.size(); }
// auto begin(){return rui.begin();}
// auto end(){return rui.end();}
};
template <class T, class U> ruiC<ll> ruicou(vector<T> &a, U b) {
vi cou(sz(a));
rep(i, sz(a)) { cou[i] = a[i] == b; }
return ruic(cou);
}
// メモリは形式によらず(26*N)
// rui(l,r)でvector(26文字について, l~rのcの個数)
// rui[h] ruic()を返す
// 添え字は'a', 'A'のまま扱う
// (予め-='a','A'されているものが渡されたらそれに従う)
template <typename Iterable, class is_Iterable = typename Iterable::value_type>
ruiC2<ll> ruicou(const Iterable &a) {
int H = max(a) + 1;
vvi(cou, H);
rep(i, sz(a)) {
if (sz(cou[a[i]]) == 0)
cou[a[i]].resize(sz(a));
cou[a[i]][i] = 1;
}
return ruiC2<ll>(cou);
}
/*@formatter:off*/
// h query
template <class T> vector<T> imoh(vector<vector<T>> &v, int w) {
vector<T> ret(sz(v));
rep(h, sz(ret)) { ret[h] = v[h][w]; }
rep(i, sz(ret) - 1) { ret[i + 1] += ret[i]; }
return ret;
}
template <class T> vector<T> ruih(vector<vector<T>> &v, int w) {
vector<T> ret(sz(v) + 1);
rep(h, sz(v)) { ret[h + 1] = v[h][w]; }
rep(i, sz(v)) { ret[i + 1] += ret[i]; }
return ret;
}
template <class T> ruiC<T> ruihc(vector<vector<T>> &a, int w) {
vector<T> ret = ruih(a, w);
return ruiC<T>(ret);
}
// xor
template <class T> struct ruixC {
vector<T> rui;
ruixC(vector<T> &ru) : rui(ru) {}
T operator()(ll l, ll r) {
if (l > r) {
cerr << "ruiXc ";
deb(l, r);
assert(0);
}
return rui[r] ^ rui[l];
}
T operator[](ll i) { return rui[i]; }
T back() { return rui.back(); }
ll size() { return rui.size(); }
};
template <class T> vector<T> ruix(vector<T> &a) {
vector<T> ret(a.size() + 1);
rep(i, a.size()) ret[i + 1] = ret[i] ^ a[i];
return ret;
}
template <class T> ruixC<ll> ruixc(vector<T> &a) {
vi ret = ruix(a);
return ruixC<ll>(ret);
}
// 差分を返す(累積を取ると元に戻る)
// 101なら
// 1111を返す
// 元の配列で[l, r)へのxorは
//[l]と[r]へのxorになる https://atcoder.jp/contests/abc155/tasks/abc155_f
vi ruix_diff(vi &A) {
int N = sz(A);
assert(N);
vi res(N + 1);
res[0] = A[0];
rep(i, 1, N) { res[i] = A[i - 1] ^ A[i]; }
res[N] = A[N - 1];
return res;
}
template <class T> vector<T> ruim(vector<T> &a) {
vector<T> res(a.size() + 1, 1);
rep(i, a.size()) res[i + 1] = res[i] * a[i];
return res;
}
// 漸化的に最小を1indexで持つ
template <class T> vector<T> ruimi(vector<T> &a) {
ll n = sz(a);
vector<T> ret(n + 1);
rep(i, 1, n) {
ret[i] = a[i - 1];
chmi(ret[i + 1], ret[i]);
}
return ret;
}
// template<class T> T *rrui(vector<T> &a) {
// 右から左にかけての半開区間 (-1 n-1]
template <class T> struct rruiC {
vector<T> rui;
int n;
rruiC(vector<T> &a) : n(sz(a)) {
rui.resize(n + 1);
rer(i, n - 1) { rui[i] = rui[i + 1] + a[i]; }
}
/*[r l)*/
T operator()(int r, int l) {
r++;
l++;
assert(l <= r && l >= 0 && r <= n);
return rui[l] - rui[r];
}
T operator()(int l) { return operator()(n - 1, l); }
T operator[](int i) { return operator()(i); }
};
template <class T> ostream &operator<<(ostream &os, rruiC<T> a) {
fora(v, a.rui) { os << v << " "; }
return os;
}
template <class T> string deb_tos(rruiC<T> &a) { return deb_tos(a.rui); }
#define rrui rruic
template <class T> rruiC<T> rruic(vector<T> &a) { return rruiC<T>(a); }
// 掛け算
template <class T> struct ruimulC {
vector<T> rv;
int n;
ruimulC(vector<T> &a) : rv(a), n(sz(a)) {
rv.resize(n + 1);
rv[0] = 1;
rep(i, n) { rv[i + 1] = a[i] * rv[i]; }
}
ruimulC() : n(0) {
rv.resize(n + 1);
rv[0] = 1;
}
void operator+=(T v) {
rv.push_back(rv.back() * v);
n++;
}
T operator()(int l, int r) {
assert(l <= r && 0 <= l && r <= n);
return rv[r] / rv[l];
}
T operator()(int r = inf) { return operator()(0, min(r, n)); }
T operator[](int r) { return operator()(0, r); }
auto begin() { return rv.begin(); }
auto end() { return rv.end(); }
};
template <class T> ruimulC<T> ruimul(vector<T> &a) { return ruimulC<T>(a); }
template <class T> ruimulC<T> ruimul() {
vector<T> a;
return ruimulC<T>(a);
}
template <class T> T *rruim(vector<T> &a) {
ll len = a.size();
T *body = (T *)malloc((len + 1) * sizeof(T));
T *res = body + 1;
res[len - 1] = 1;
rer(i, len - 1) res[i - 1] = res[i] * a[i];
return res;
}
template <class T, class U, class W> T lowerBound(ruiC<T> &a, U v, W banpei) {
return lowerBound(a.rui, v, banpei);
}
template <class T, class U, class W> T upperBound(ruiC<T> &a, U v, W banpei) {
return upperBound(a.rui, v, banpei);
}
template <class T, class U, class W> T rlowerBound(ruiC<T> &a, U v, W banpei) {
return rlowerBound(a.rui, v, banpei);
}
template <class T, class U, class W> T rupperBound(ruiC<T> &a, U v, W banpei) {
return rupperBound(a.rui, v, banpei);
}
#endif
constexpr bool bget(ll m, ll keta) {
#ifdef _DEBUG
assert(keta <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (m >> keta) & 1;
}
// bget(n)次元
// NならN-1まで
vector<vi> bget2(vi &a, int keta_size) {
vvi(res, keta_size, sz(a));
rep(k, keta_size) {
rep(i, sz(a)) { res[k][i] = bget(a[i], k); }
}
return res;
}
vi bget1(vi &a, int keta) {
vi res(sz(a));
rep(i, sz(a)) { res[i] = bget(a[i], keta); }
return res;
}
#if __cplusplus >= 201703L
ll bget(ll m, ll keta, ll sinsuu) {
m /= pow<ll>(sinsuu, keta);
return m % sinsuu;
}
#else
ll bget(ll m, ll keta, ll sinsuu) {
m /= (ll)pow(sinsuu, keta);
return m % sinsuu;
}
#endif
constexpr ll bit(ll n) {
#ifdef _DEBUG
assert(n <= 62); // オーバーフロー 1^62までしか扱えない
#endif
return (1LL << (n));
}
#if __cplusplus >= 201703L
ll bit(ll n, ll sinsuu) { return pow<ll>(sinsuu, n); }
#else
ll bit(ll n, ll sinsuu) { return (ll)pow(sinsuu, n); }
#endif
ll mask(ll n) { return (1ll << n) - 1; }
// aをbitに置きなおす
//{0, 2} -> 101
ll bit(const vi &a) {
int m = 0;
for (auto &&v : a)
m |= bit(v);
return m;
}
//{1, 1, 0} -> 011
// bitsetに置き換える感覚 i が立っていたら i bit目を立てる
ll bit_bool(vi &a) {
int m = 0;
rep(i, sz(a)) if (a[i]) m |= bit(i);
return m;
}
#define bcou __builtin_popcountll
// 最下位ビット
ll lbit(ll n) {
assert(n);
return n & -n;
}
ll lbiti(ll n) {
assert(n);
return log2(n & -n);
}
// 最上位ビット
ll hbit(ll n) {
assert(n);
n |= (n >> 1);
n |= (n >> 2);
n |= (n >> 4);
n |= (n >> 8);
n |= (n >> 16);
n |= (n >> 32);
return n - (n >> 1);
}
ll hbiti(ll n) {
assert(n);
return log2(hbit(n));
}
// ll hbitk(ll n) { ll k = 0; rer(i, 5) { ll a = k + (1ll << i); ll
// b = 1ll << a; if (b <= n)k += 1ll << i; } return k;}
// 初期化は0を渡す
ll nextComb(ll &mask, ll n, ll r) {
if (!mask)
return mask = (1LL << r) - 1;
ll x = mask & -mask; /*最下位の1*/
ll y = mask + x; /*連続した下の1を繰り上がらせる*/
ll res = ((mask & ~y) / x >> 1) | y;
if (bget(res, n))
return mask = 0;
else
return mask = res;
}
// n桁以下でビットがr個立っているもののvectorを返す
vi bitCombList(ll n, ll r) {
vi res;
ll m = 0;
while (nextComb(m, n, r)) {
res.push_back(m);
}
return res;
}
/*over*/ #define forbit1_2(i, mas) \
for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, \
i = !mas ? 0 : log2(forbitj); \
forbitm; forbitm = forbitm ^ forbitj, \
forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
/*over*/ #define forbit1_3(i, N, mas) \
for (int forbitj = !mas ? 0 : lbit(mas), forbitm = mas, \
i = !mas ? 0 : log2(forbitj); \
forbitm && i < N; forbitm = forbitm ^ forbitj, \
forbitj = !forbitm ? 1 : lbit(forbitm), i = log2(forbitj))
// masの立ってるindexを見る
// i, [N], mas
#define forbit1(...) over3(__VA_ARGS__, forbit1_3, forbit1_2)(__VA_ARGS__)
// masが立っていないindexを見る
// i, N, mas
#define forbit0(i, N, mas) forbit1(i, mask(N) & (~(mas)))
// forsubをスニペットして使う
// Mの部分集合(0,M含む)を見る 3^sz(S)個ある
#define forsub_all(m, M) for (int m = M; m != -1; m = m == 0 ? -1 : (m - 1) & M)
// BASE進数
template <size_t BASE> class base_num {
int v;
public:
base_num(int v = 0) : v(v){};
int operator[](int i) { return bget(v, i, BASE); }
void operator++() { v++; }
void operator++(signed) { v++; }
operator int() { return v; }
};
#define base3(mas, lim, BASE) for (base_num<BASE> mas; mas < lim; mas++)
#define base2(mas, lim) base3(mas, lim, 2)
#define base(...) over3(__VA_ARGS__, base3, base2, base1)(__VA_ARGS__)
// aにある物をtrueとする
vb bool_(vi a, int n) {
vb ret(max(max(a) + 1, n));
rep(i, sz(a)) ret[a[i]] = true;
return ret;
}
char itoal(ll i) { return 'a' + i; }
char itoaL(ll i) { return 'A' + i; }
ll altoi(char c) {
if ('A' <= c && c <= 'Z')
return c - 'A';
return c - 'a';
}
ll ctoi(char c) { return c - '0'; }
char itoc(ll i) { return i + '0'; }
ll vtoi(vi &v) {
ll res = 0;
if (sz(v) > 18) {
debugline("vtoi");
deb(sz(v));
ole();
}
rep(i, sz(v)) {
res *= 10;
res += v[i];
}
return res;
}
vi itov(ll i) {
vi res;
while (i) {
res.push_back(i % 10);
i /= 10;
}
res = rev(res);
return res;
}
vi stov(string &a) {
ll n = sz(a);
vi ret(n);
rep(i, n) { ret[i] = a[i] - '0'; }
return ret;
}
// 基準を満たさないものは0になる
vi stov(string &a, char one) {
ll n = sz(a);
vi ret(n);
rep(i, n) ret[i] = a[i] == one;
return ret;
}
vector<vector<ll>> ctoi(vector<vector<char>> s, char c) {
ll n = sz(s), m = sz(s[0]);
vector<vector<ll>> res(n, vector<ll>(m));
rep(i, n) rep(j, m) res[i][j] = s[i][j] == c;
return res;
}
// #define use_compress
//[i] := vを返す
// aは0~n-1で置き換えられる
vi compress(vi &a) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
#ifdef use_compress
// ind[i] := i番目に小さい数
// map[v] := vは何番目に小さいか
vi compress(vi &a, umapi &map) {
vi b;
ll len = a.size();
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
ll v = a[i];
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
map[v] = a[i];
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r) {
vi b;
ll len = a.size();
fora(v, a) { b.push_back(v); }
fora(v, r) { b.push_back(v); }
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(ALL(b), r[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vi &a, vi &r, vi &s) {
vi b;
ll len = a.size();
fora(v, a) { b.push_back(v); }
fora(v, r) { b.push_back(v); }
fora(v, s) { b.push_back(v); }
sort(b);
unique(b);
for (ll i = 0; i < len; ++i)
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
for (ll i = 0; i < sz(r); ++i)
r[i] = lower_bound(ALL(b), r[i]) - b.begin();
for (ll i = 0; i < sz(s); ++i)
r[i] = lower_bound(ALL(b), s[i]) - b.begin();
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vi> &a) {
vi b;
fora(vv, a) {
fora(v, vv) { b.push_back(v); }
}
sort(b);
unique(b);
fora(vv, a) {
fora(v, vv) { v = lower_bound(ALL(b), v) - b.begin(); }
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
vi compress(vector<vector<vi>> &a) {
vi b;
fora(vvv, a) {
fora(vv, vvv) {
fora(v, vv) { b.push_back(v); }
}
}
sort(b);
unique(b);
fora(vvv, a) {
fora(vv, vvv) {
fora(v, vv) { v = lower_bound(ALL(b), v) - b.begin(); }
}
}
ll blen = sz(b);
vi ret(blen);
rep(i, blen) { ret[i] = b[i]; }
return ret;
}
void compress(ll a[], ll len) {
vi b;
for (ll i = 0; i < len; ++i) {
b.push_back(a[i]);
}
sort(b);
unique(b);
for (ll i = 0; i < len; ++i) {
a[i] = lower_bound(ALL(b), a[i]) - b.begin();
}
}
#endif
// 要素が見つからなかったときに困る
#define binarySearch(a, v) (binary_search(ALL(a), v))
#define lowerIndex(a, v) (lower_bound(ALL(a), v) - a.begin())
#define upperIndex(a, v) (upper_bound(ALL(a), v) - a.begin())
#define rlowerIndex(a, v) (upper_bound(ALL(a), v) - a.begin() - 1)
#define rupperIndex(a, v) (lower_bound(ALL(a), v) - a.begin() - 1)
template <class T, class U, class W> T lowerBound(vector<T> &a, U v, W banpei) {
auto it = lower_bound(a.begin(), a.end(), v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T upperBound(vector<T> &a, U v, W banpei) {
auto it = upper_bound(a.begin(), a.end(), v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W>
T rlowerBound(vector<T> &a, U v, W banpei) {
auto it = upper_bound(a.begin(), a.end(), v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W>
T rupperBound(vector<T> &a, U v, W banpei) {
auto it = lower_bound(a.begin(), a.end(), v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
// todo 消せないか
template <class T, class U, class W> T lowerBound(set<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T upperBound(set<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T rlowerBound(set<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W> T rupperBound(set<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W> T lowerBound(mset<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T upperBound(mset<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.end())
return banpei;
else
return *it;
}
template <class T, class U, class W> T rlowerBound(mset<T> &a, U v, W banpei) {
auto it = a.upper_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
template <class T, class U, class W> T rupperBound(mset<T> &a, U v, W banpei) {
auto it = a.lower_bound(v);
if (it == a.begin())
return banpei;
else {
return *(--it);
}
}
#define next2(a) next(next(a))
#define prev2(a) prev(prev(a))
// 狭義の単調増加列 長さを返す
template <class T> int lis(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX<T>());
rep(i, n) {
int id = lowerIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX<T>());
}
template <class T> int lis_eq(vector<T> &a) {
int n = sz(a);
vi tail(n + 1, MAX<T>());
rep(i, n) {
int id = upperIndex(tail, a[i]); /**/
tail[id] = a[i];
}
return lowerIndex(tail, MAX<T>());
}
// iteratorを返す
// valueが1以上の物を返す 0は見つけ次第削除
// vを減らす場合 (*it).se--でいい
template <class T, class U, class V> auto lower_map(map<T, U> &m, V k) {
auto ret = m.lower_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
template <class T, class U, class V> auto upper_map(map<T, U> &m, V k) {
auto ret = m.upper_bound(k);
while (ret != m.end() && (*ret).second == 0) {
ret = m.erase(ret);
}
return ret;
}
// 存在しなければエラー
template <class T, class U, class V> auto rlower_map(map<T, U> &m, V k) {
auto ret = upper_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class T, class U, class V> auto rupper_map(map<T, U> &m, V k) {
auto ret = lower_map(m, k);
assert(ret != m.begin());
ret--;
while (1) {
if ((*ret).second != 0)
break;
assert(ret != m.begin());
auto next = ret;
--next;
m.erase(ret);
ret = next;
}
return ret;
}
template <class... T> void fin(T... s) {
out(s...);
exit(0);
}
// 便利 数学 math
// sub ⊂ top
bool subset(int sub, int top) { return (sub & top) == sub; }
//-180 ~ 180 degree
double atand(double h, double w) { return atan2(h, w) / PI * 180; }
//% -mの場合、最小の正の数を返す
ll mod(ll a, ll m) {
if (m < 0)
m *= -1;
return (a % m + m) % m;
}
// ll pow(ll a) { return a * a; };
template <class T> T fact(int v) {
static vector<T> fact(2, 1);
if (sz(fact) <= v) {
rep(i, sz(fact), v + 1) { fact.emplace_back(fact.back() * i); }
}
return fact[v];
}
ll comi(ll n, ll r) {
assert(n < 100);
static vvi(pas, 100, 100);
if (pas[0][0])
return pas[n][r];
pas[0][0] = 1;
rep(i, 1, 100) {
pas[i][0] = 1;
rep(j, 1, i + 1) pas[i][j] = pas[i - 1][j - 1] + pas[i - 1][j];
}
return pas[n][r];
}
// 二項係数の偶奇を返す
int com_mod2(int n, int r) { return n == (r | (n - r)); }
double comd2(ll n, ll r) {
static vvd(comb, 2020, 2020);
if (comb[0][0] == 0) {
comb[0][0] = 1;
rep(i, 2000) {
comb[i + 1][0] = 1;
rep(j, 1, i + 2) { comb[i + 1][j] = comb[i][j] + comb[i][j - 1]; }
}
}
return comb[n][r];
}
double comd(int n, int r) {
if (r < 0 || r > n)
return 0;
if (n < 2020)
return comd2(n, r);
static vd fact(2, 1);
if (sz(fact) <= n) {
rep(i, sz(fact), n + 1) { fact.push_back(fact.back() * i); }
}
return fact[n] / fact[n - r] / fact[r];
}
#define gcd my_gcd
ll gcd(ll a, ll b) {
while (b)
a %= b, swap(a, b);
return abs(a);
}
ll gcd(vi b) {
ll res = b[0];
rep(i, 1, sz(b)) res = gcd(b[i], res);
return res;
}
#define lcm my_lcm
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
ll lcm(vi a) {
ll res = a[0];
rep(i, 1, sz(a)) res = lcm(a[i], res);
return res;
}
ll ceil(ll a, ll b) {
if (b == 0) {
debugline("ceil");
deb(a, b);
ole();
return -1;
} else if (a < 0) {
return 0;
} else {
return (a + b - 1) / b;
}
}
#define hypot my_hypot
double hypot(double dx, double dy) { return std::sqrt(dx * dx + dy * dy); }
ll sig0(int t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
bint sig0(bint t) { return t <= 0 ? 0 : ((1 + t) * t) >> 1; }
// ll sig(ll s, ll t) { return ((s + t) * (t - s + 1)) >> 1; }
ll sig(ll s, ll t) {
if (s > t)
swap(s, t);
return sig0(t - s) + s * (t - s + 1);
}
#define tousa_i tosa_i
#define lower_tousa_i lower_tosa_i
#define upper_tousa upper_tosa
#define upper_tousa_i upper_tosa_i
ll tosa_i(ll st, ll ad, ll v) {
assert(((v - st) % ad) == 0);
return (v - st) / ad;
}
ll tosa_s(ll st, ll ad, ll len) { return st * len + sig0(len - 1) * ad; }
// ax + r (x は非負整数) で表せる整数のうち、v 以上となる最小の整数
ll lower_tosa(ll st, ll ad, ll v) {
if (st >= v)
return st;
return (v - st + ad - 1) / ad * ad + st;
}
// 第何項か
ll lower_tosa_i(ll st, ll ad, ll v) {
if (st >= v)
return 0;
return (v - st + ad - 1) / ad;
}
ll upper_tosa(ll st, ll ad, ll v) { return lower_tosa(st, ad, v + 1); }
ll upper_tosa_i(ll st, ll ad, ll v) { return lower_tosa_i(st, ad, v + 1); }
// b * res <= aを満たす [l, r)を返す div
P drange_ika(int a, int b) {
P null_p = mp(linf, linf);
if (b == 0) {
if (a >= 0) {
return mp(-linf, linf + 1) /*全て*/;
} else {
return null_p /*無い*/;
}
} else {
if (a >= 0) {
if (b > 0) {
return mp(-linf, a / b + 1);
} else {
return mp(-(a / -b), linf + 1);
}
} else {
if (b > 0) {
return mp(-linf, -ceil(-a, b) + 1);
} else {
return mp(ceil(-a, -b), linf + 1);
}
}
}
}
// v * v >= aとなる最小のvを返す
ll sqrt(ll a) {
if (a < 0) {
debugline("sqrt");
deb(a);
ole();
}
ll res = (ll)std::sqrt(a);
while (res * res < a)
++res;
return res;
}
double log(double e, double x) { return log(x) / log(e); }
/*@formatter:off*/
// 機能拡張
#define dtie(a, b) \
int a, b; \
tie(a, b)
template <class T, class U> string to_string(T a, U b) {
string res = "";
res += a;
res += b;
return res;
}
template <class T, class U, class V> string to_string(T a, U b, V c) {
string res = "";
res += a;
res += b;
res += c;
return res;
}
template <class T, class U, class V, class W>
string to_string(T a, U b, V c, W d) {
string res = "";
res += a;
res += b;
res += c;
res += d;
return res;
}
template <class T, class U, class V, class W, class X>
string to_string(T a, U b, V c, W d, X e) {
string res = "";
res += a;
res += b;
res += c;
res += d;
res += e;
return res;
}
template <class T> vector<T> sub(const vector<T> &A, int l, int r) {
assert(0 <= l && l <= r && r <= sz(A));
vector<T> ret(r - l);
std::copy(A.begin() + l, A.begin() + r, ret.begin());
return ret;
}
template <class T> vector<T> sub(const vector<T> &A, int r) {
return sub(A, 0, r);
}
template <class T> vector<T> subn(const vector<T> &A, int l, int len) {
return sub(A, l, l + len);
}
string sub(string &A, int l, int r) {
assert(0 <= l && l <= r && r <= sz(A));
return A.substr(l, r - l);
}
template <class T, class F>
// sub2で呼ぶ
vector<T> sub(const vector<vector<T>> &A, int h, int w, int ah, int aw, F f) {
vector<T> res;
while (0 <= h && h < sz(A) && 0 <= w && w < sz(A[h]) && f(A[h][w])) {
res.emplace_back(A[h][w]);
h += ah;
w += aw;
}
return res;
}
template <class T>
vector<T> sub(const vector<vector<T>> &A, int h, int w, int ah, int aw) {
return sub(A, h, w, ah, aw, [&](T v) { return true; });
}
#define sub25(A, h, w, ah, aw) sub(A, h, w, ah, aw)
#define sub26(A, h, w, ah, aw, siki_r) \
sub(A, h, w, ah, aw, [&](auto v) { return v siki_r; })
#define sub27(A, h, w, ah, aw, v, siki) \
sub(A, h, w, ah, aw, [&](auto v) { return siki; })
#define sub2(...) over7(__VA_ARGS__, sub27, sub26, sub25)(__VA_ARGS__)
constexpr int bsetlen = k5 * 2;
// constexpr int bsetlen = 5050;
#define bset bitset<bsetlen>
bool operator<(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] < b[i])
return true;
if (a[i] > b[i])
return false;
}
return false;
}
bool operator>(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] > b[i])
return true;
if (a[i] < b[i])
return false;
}
return false;
}
bool operator<=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] < b[i])
return true;
if (a[i] > b[i])
return false;
}
return true;
}
bool operator>=(bitset<bsetlen> &a, bitset<bsetlen> &b) {
rer(i, bsetlen - 1) {
if (a[i] > b[i])
return true;
if (a[i] < b[i])
return false;
}
return true;
}
string operator~(string &a) {
string res = a;
for (auto &&c : res) {
if (c == '0')
c = '1';
else if (c == '1')
c = '0';
else {
cerr << "cant ~" << a << "must bit" << endl;
exit(0);
}
}
return res;
}
ostream &operator<<(ostream &os, bset &a) {
bitset<10> b;
vi list;
rep(i, bsetlen) {
if (a[i])
list.push_back(i), b[i] = 1;
}
os << b << ", " << list;
return os;
}
int hbiti(bset &a) {
rer(i, bsetlen) {
if (a[i])
return i;
}
return -1;
}
#define hk(a, b, c) (a <= b && b < c)
// O(N/64)
bset nap(bset &a, int v) {
bset r = a | a << v;
return r;
}
bset nap(bset &a, bset &v) {
bset r = a;
rep(i, bsetlen) {
if (v[i])
r |= a << i;
}
return r;
}
template <class T> int count(set<T> &S, T l, T r) {
assert(l < r);
auto it = S.lower_bound(l);
return it != S.end() && (*it) < r;
}
// template<class T> void seth(vector<vector<T>> &S, int w, vector<T> &v)
// {assert(sz(S) == sz(v));assert(w < sz(S[0]));rep(h, sz(S)) { S[h][w] = v[h];
// }}
template <class T> vector<T> geth(vector<vector<T>> &S, int w) {
assert(w < sz(S[0]));
vector<T> ret(sz(S));
rep(h, sz(S)) { ret[h] = S[h][w]; }
return ret;
}
// vector<bool>[i]は参照を返さないため、こうしないとvb[i] |=
// trueがコンパイルエラー
vb::reference operator|=(vb::reference a, bool b) { return a = a | b; }
vb::reference operator&=(vb::reference a, bool b) { return a = a & b; }
template <class T, class U> void operator+=(pair<T, U> &a, pair<T, U> &b) {
a.fi += b.fi;
a.se += b.se;
}
template <class T, class U>
pair<T, U> operator+(const pair<T, U> &a, const pair<T, U> &b) {
return pair<T, U>(a.fi + b.fi, a.se + b.se);
}
template <class T, class U>
pair<T, U> operator-(const pair<T, U> &a, const pair<T, U> &b) {
return pair<T, U>(a.fi - b.fi, a.se - b.se);
}
template <class T, class U> pair<T, U> operator-(const pair<T, U> &a) {
return pair<T, U>(-a.first, -a.second);
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
#ifdef _DEBUG
static bool was = false;
if (!was)
message += "str += 65 is 'A' not \"65\" ";
was = true;
#endif
return lhs + (char)rv;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const int rv) {
lhs = lhs + rv;
}
template <typename CharT, typename Traits, typename Alloc>
basic_string<CharT, Traits, Alloc>
operator+(const basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
const int rv2 = rv;
return lhs + rv2;
}
template <typename CharT, typename Traits, typename Alloc>
void operator+=(basic_string<CharT, Traits, Alloc> &lhs, const signed rv) {
const int v = rv;
lhs += v;
}
template <typename CharT, typename Traits, typename Alloc>
void operator*=(basic_string<CharT, Traits, Alloc> &s, int num) {
auto bek = s;
s = "";
for (; num; num >>= 1) {
if (num & 1) {
s += bek;
}
bek += bek;
}
}
template <class T, class U> void operator+=(queue<T> &a, U v) { a.push(v); }
template <class T, class U> void operator+=(deque<T> &a, U v) {
a.push_back(v);
}
template <class T>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, vector<T> &v) {
fora(d, v) { a.push(d); }
return a;
}
template <class T, class U>
priority_queue<T, vector<T>, greater<T>> &
operator+=(priority_queue<T, vector<T>, greater<T>> &a, U v) {
a.push(v);
return a;
}
template <class T, class U>
priority_queue<T> &operator+=(priority_queue<T> &a, U v) {
a.push(v);
return a;
}
template <class T> set<T> &operator+=(set<T> &a, vector<T> v) {
fora(d, v) { a.insert(d); }
return a;
}
template <class T, class U> auto operator+=(set<T> &a, U v) {
return a.insert(v);
}
template <class T, class U> auto operator-=(set<T> &a, U v) {
return a.erase(v);
}
template <class T, class U> auto operator+=(mset<T> &a, U v) {
return a.insert(v);
}
template <class T, class U>
set<T, greater<T>> &operator+=(set<T, greater<T>> &a, U v) {
a.insert(v);
return a;
}
template <class T, class U> vector<T> &operator+=(vector<T> &a, U v) {
a.push_back(v);
return a;
}
template <class T, class U> vector<T> operator+(U v, const vector<T> &a) {
vector<T> ret = a;
ret.insert(ret.begin(), v);
return ret;
}
template <class T> vector<T> operator+(const vector<T> &a, const vector<T> &b) {
vector<T> ret;
ret = a;
fora(v, b) { ret += v; }
return ret;
}
template <class T> vector<T> &operator+=(vector<T> &a, const vector<T> &b) {
rep(i, sz(b)) { /*こうしないとa+=aで両辺が増え続けてバグる*/
a.push_back(b[i]);
}
return a;
}
template <class T, class U> map<T, U> &operator+=(map<T, U> &a, map<T, U> &b) {
for (auto &&bv : b) {
a[bv.first] += bv.second;
}
return a;
}
template <class T, class U>
vector<T> operator+(const vector<T> &a, const U &v) {
vector<T> ret = a;
ret += v;
return ret;
}
template <class T, class U> auto operator+=(uset<T> &a, U v) {
return a.insert(v);
}
template <class T> vector<T> operator%(vector<T> &a, int v) {
vi ret(sz(a));
rep(i, sz(a)) { ret[i] = a[i] % v; }
return ret;
}
template <class T> vector<T> operator%=(vector<T> &a, int v) {
rep(i, sz(a)) { a[i] %= v; }
return a;
}
vi operator&(vi &a, vi &b) {
assert(sz(a) == sz(b));
vi ret(sz(a));
rep(i, sz(a)) { ret[i] = min(a[i], b[i]); }
return ret;
}
template <class T> void operator+=(mset<T> &a, vector<T> &v) {
for (auto &&u : v)
a.insert(u);
}
template <class T> void operator+=(set<T> &a, vector<T> &v) {
for (auto &&u : v)
a.insert(u);
}
template <class T> void operator+=(vector<T> &a, set<T> &v) {
for (auto &&u : v)
a.emplace_back(u);
}
template <class T> void operator+=(vector<T> &a, mset<T> &v) {
for (auto &&u : v)
a.emplace_back(u);
}
template <class T> vector<T> &operator-=(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-=");
deb(a);
deb(b);
exit(0);
}
rep(i, sz(a)) a[i] -= b[i];
return a;
}
template <class T> vector<T> operator-(vector<T> &a, vector<T> &b) {
if (sz(a) != sz(b)) {
debugline("vector<T> operator-");
deb(a);
deb(b);
ole();
}
vector<T> res(sz(a));
rep(i, sz(a)) res[i] = a[i] - b[i];
return res;
}
// template<class T, class U> void operator*=(vector<T> &a, U b) { vector<T>
// ta = a; rep(b-1){ a+=ta; }}
template <typename T> void erase(vector<T> &v, unsigned ll i) {
v.erase(v.begin() + i);
}
template <typename T> void erase(vector<T> &v, unsigned ll s, unsigned ll e) {
v.erase(v.begin() + s, v.begin() + e);
}
template <typename T> void pop_front(vector<T> &v) { erase(v, 0); }
template <typename T> void entry(vector<T> &v, unsigned ll s, unsigned ll e) {
erase(v, e, sz(v));
erase(v, 0, s);
}
template <class T, class U> void erase(map<T, U> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <class T> void erase(set<T> &m, ll okl, ll ngr) {
m.erase(m.lower_bound(okl), m.lower_bound(ngr));
}
template <typename T> void erasen(vector<T> &v, unsigned ll s, unsigned ll n) {
v.erase(v.begin() + s, v.begin() + s + n);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, U t) {
v.insert(v.begin() + i, t);
}
template <typename T, typename U> void push_front(vector<T> &v, U t) {
v.insert(v.begin(), t);
}
template <typename T, typename U>
void insert(vector<T> &v, unsigned ll i, vector<T> list) {
for (auto &&va : list)
v.insert(v.begin() + i++, va);
}
vector<string> split(const string &a, const char deli) {
string b = a + deli;
ll l = 0, r = 0, n = b.size();
vector<string> res;
rep(i, n) {
if (b[i] == deli) {
r = i;
if (l < r)
res.push_back(b.substr(l, r - l));
l = i + 1;
}
}
return res;
}
vector<string> split(const string &a, const string deli) {
vector<string> res;
ll kn = sz(deli);
std::string::size_type Pos(a.find(deli));
ll l = 0;
while (Pos != std::string::npos) {
if (Pos - l)
res.push_back(a.substr(l, Pos - l));
l = Pos + kn;
Pos = a.find(deli, Pos + kn);
}
if (sz(a) - l)
res.push_back(a.substr(l, sz(a) - l));
return res;
}
ll stoi(string &s) { return stol(s); }
#define assert_yn(yn_v, v) \
; \
assert(yn_v == 0 || yn_v == v); \
yn_v = v;
// 不完全な対策、現状はautohotkeyで対応
int yn_v = 0;
void yn(bool a) {
assert_yn(yn_v, 1);
if (a)
cout << "yes" << endl;
else
cout << "no" << endl;
}
void fyn(bool a) {
assert_yn(yn_v, 1);
yn(a);
exit(0);
}
void Yn(bool a) {
assert_yn(yn_v, 2);
if (a)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
void fYn(bool a) {
assert_yn(yn_v, 2);
Yn(a);
exit(0);
}
void YN(bool a) {
assert_yn(yn_v, 3);
if (a)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
void fYN(bool a) {
assert_yn(yn_v, 3);
YN(a);
exit(0);
}
int ab_v = 0;
void fAb(bool a) {
assert_yn(ab_v, 1);
if (a)
cout << "Alice" << endl;
else
cout << "Bob";
}
void fAB(bool a) {
assert_yn(yn_v, 2);
if (a)
cout << "ALICE" << endl;
else
cout << "BOB";
}
int pos_v = 0;
void Possible(bool a) {
assert_yn(pos_v, 1);
if (a)
cout << "Possible" << endl;
else
cout << "Impossible" << endl;
exit(0);
}
void POSSIBLE(bool a) {
assert_yn(pos_v, 2);
if (a)
cout << "POSSIBLE" << endl;
else
cout << "IMPOSSIBLE" << endl;
exit(0);
}
void fPossible(bool a) {
assert_yn(pos_v, 1) Possible(a);
exit(0);
}
void fPOSSIBLE(bool a) {
assert_yn(pos_v, 2) POSSIBLE(a);
exit(0);
}
template <typename T> class fixed_point : T {
public:
explicit constexpr fixed_point(T &&t) noexcept : T(std::forward<T>(t)) {}
template <typename... Args>
constexpr decltype(auto) operator()(Args &&...args) const {
return T::operator()(*this, std::forward<Args>(args)...);
}
};
template <typename T>
static inline constexpr decltype(auto) fix(T &&t) noexcept {
return fixed_point<T>{std::forward<T>(t)};
}
// 未分類
// 0,2,1 1番目と2番目の次元を入れ替える
template <class T>
auto irekae(vector<vector<vector<T>>> &A, int x, int y, int z) {
#define irekae_resize_loop(a, b, c) \
resize(res, a, b, c); \
rep(i, a) rep(j, b) rep(k, c)
vector<vector<vector<T>>> res;
if (x == 0 && y == 1 && z == 2) {
res = A;
} else if (x == 0 && y == 2 && z == 1) {
irekae_resize_loop(sz(A), sz(A[0][0]), sz(A[0])) {
res[i][j][k] = A[i][k][j];
}
} else if (x == 1 && y == 0 && z == 2) {
irekae_resize_loop(sz(A[0]), sz(A), sz(A[0][0])) {
res[i][j][k] = A[j][i][k];
}
} else if (x == 1 && y == 2 && z == 0) {
irekae_resize_loop(sz(A[0]), sz(A[0][0]), sz(A)) {
res[i][j][k] = A[k][i][j];
}
} else if (x == 2 && y == 0 && z == 1) {
irekae_resize_loop(sz(A[0][0]), sz(A), sz(A[0])) {
res[i][j][k] = A[j][k][i];
}
} else if (x == 2 && y == 1 && z == 0) {
irekae_resize_loop(sz(A[0][0]), sz(A[0]), sz(A)) {
res[i][j][k] = A[k][j][i];
}
}
return res;
#undef irekae_resize_loop
}
template <class T> auto irekae(vector<vector<T>> &A, int i = 1, int j = 0) {
vvt(res, sz(A[0]), sz(A));
rep(i, sz(A)) {
rep(j, sz(A[0])) { res[j][i] = A[i][j]; }
}
return res;
}
// tou分割する
template <typename Iterable>
vector<Iterable> table(const Iterable &a, int tou = 2) {
int N = sz(a);
vector<Iterable> res(tou);
int hab = N / tou;
vi lens(tou, hab);
rep(i, N % tou) { lens[tou - 1 - i]++; }
int l = 0;
rep(i, tou) {
int len = lens[i];
int r = l + len;
res[i].resize(len);
std::copy(a.begin() + l, a.begin() + r, res[i].begin());
l = r;
}
return res;
}
// 長さn毎に分割する
template <typename Iterable>
vector<Iterable> table_n(const Iterable &a, int len) {
int N = sz(a);
vector<Iterable> res(ceil(N, len));
vi lens(N / len, len);
if (N % len)
lens.push_back(N % len);
int l = 0;
rep(i, sz(lens)) {
int len = lens[i];
int r = l + len;
res[i].resize(len);
std::copy(a.begin() + l, a.begin() + r, res[i].begin());
l = r;
}
return res;
}
// 縦を返す
vi &geth(vvi() & a, int w) {
static vi ret;
ret.resize(sz(a));
rep(i, sz(a)) { ret[i] = a[i][w]; }
return ret;
}
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} initonv;
// #define pre prev
// #define nex next
// gra mll pr
// 上下左右
const string udlr = "udlr";
string UDLR = "UDLR"; // x4と連動 UDLR.find('U') := x4[0]
vc atoz = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
vc AtoZ = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
// 右、上が正
constexpr ll h4[] = {1, -1, 0, 0};
constexpr ll w4[] = {0, 0, -1, 1};
constexpr ll h8[] = {0, 1, 0, -1, -1, 1, 1, -1};
constexpr ll w8[] = {1, 0, -1, 0, 1, -1, 1, -1};
int mei_inc(int h, int w, int H, int W, int i) {
while (++i < 4) {
if (inside(h + h4[i], w + w4[i], H, W))
return i;
}
return i;
}
#define mei(nh, nw, h, w) \
for (int i = mei_inc(h, w, H, W, -1), nh = i < 4 ? h + h4[i] : 0, \
nw = i < 4 ? w + w4[i] : 0; \
i < 4; i = mei_inc(h, w, H, W, i), nh = h + h4[i], nw = w + w4[i])
int mei_inc8(int h, int w, int H, int W, int i) {
while (++i < 8) {
if (inside(h + h8[i], w + w8[i], H, W))
return i;
}
return i;
}
#define mei8(nh, nw, h, w) \
for (int i = mei_inc8(h, w, H, W, -1), nh = i < 8 ? h + h8[i] : 0, \
nw = i < 8 ? w + w8[i] : 0; \
i < 8; i = mei_inc8(h, w, H, W, i), nh = h + h8[i], nw = w + w8[i])
int mei_incv(int h, int w, int H, int W, int i, vp &p) {
while (++i < sz(p)) {
if (inside(h + p[i].fi, w + p[i].se, H, W))
return i;
}
return i;
}
#define meiv(nh, nw, h, w, p) \
for (int i = mei_incv(h, w, H, W, -1, p), nh = i < sz(p) ? h + p[i].fi : 0, \
nw = i < sz(p) ? w + p[i].se : 0; \
i < sz(p); \
i = mei_incv(h, w, H, W, i, p), nh = h + p[i].fi, nw = w + p[i].se)
// H*Wのグリッドを斜めに分割する
// 右上
vector<vp> naname_list_ne(int H, int W) {
vector<vp> res(H + W - 1);
rep(sh, H) {
int sw = 0;
res[sh] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh--;
nw++;
if (0 <= nh && nw < W) {
res[sh] += mp(nh, nw);
} else {
break;
}
}
}
rep(sw, 1, W) {
int sh = H - 1;
res[H + sw - 1] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh--;
nw++;
if (0 <= nh && nw < W) {
res[H + sw - 1] += mp(nh, nw);
} else {
break;
}
}
}
return res;
}
// 右下
vector<vp> naname_list_se(int H, int W) {
vector<vp> res(H + W - 1);
rep(sh, H) {
int sw = 0;
res[sh] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh++;
nw++;
if (0 <= nh && nh < H && nw < W) {
res[sh] += mp(nh, nw);
} else {
break;
}
}
}
rep(sw, 1, W) {
int sh = 0;
res[H + sw - 1] += mp(sh, sw);
int nh = sh;
int nw = sw;
while (1) {
nh++;
nw++;
if (0 <= nh && nh < H && nw < W) {
res[H + sw - 1] += mp(nh, nw);
} else {
break;
}
}
}
return res;
}
// グラフ内で #undef getid
// #define getidとしているため、ここを書き直したらgraphも書き直す
#define getid_2(h, w) ((h) * (W) + (w))
#define getid_1(p) ((p).first * W + (p).second)
#define getid(...) over2(__VA_ARGS__, getid_2, getid_1)(__VA_ARGS__)
#define getp(id) mp(id / W, id % W)
// #define set_shuffle() std::random_device seed_gen;std::mt19937
// engine(seed_gen()) #define shuffle(a) std::shuffle((a).begin(), (a).end(),
// engine); 1980 開始からtime ms経っていたらtrue
vb bit_bool(int v, int len) {
assert(bit(len) > v);
vb ret(len);
rep(i, len) { ret[i] = bget(v, i); }
return ret;
}
vi range(int l, int r) {
vi ret;
ret.resize(r - l);
rep(v, l, r) { ret[v - l] = v; }
return ret;
}
vi range(int r) { return range(0, r); }
vi tov(vb &a) {
vi ret;
rep(i, sz(a)) {
if (a[i])
ret.push_back(i);
}
return ret;
}
bool kaibun(const str &S) { return S == rev(S); }
template <class T> vector<T> repeat(const vector<T> &A, int kaisu) {
vector<T> ret;
while (kaisu--) {
ret += A;
}
return ret;
}
#define rge range
#define upd update
// S[{s, t, d}]
#define strs slice_str
struct slice_str {
string S;
slice_str() {}
slice_str(const string &S) : S(S) {}
slice_str(int len, char c) : S(len, c) {}
auto size() { return S.size(); }
char &operator[](int p) { return S[p]; }
string operator[](initializer_list<int> p) {
if (sz(p) == 1) {
return S.substr(0, *(p.begin()));
} else if (sz(p) == 2) {
int l = *(p.begin());
int r = *(next(p.begin()));
return S.substr(l, r - l);
} else {
auto it = p.begin();
int s = *(it++);
int t = *(it++);
int d = *(it);
if (d == -1) {
int s_ = sz(S) - s - 1;
int t_ = sz(S) - t - 1;
return rev(S).substr(s_, t_ - s_);
} else if (d < 0) {
t = max(-1ll, t);
string ret;
while (s > t) {
ret += S[s];
s += d;
}
return ret;
} else {
t = min(sz(S), t);
string ret;
while (s < t) {
ret += S[s];
s += d;
}
return ret;
}
}
}
operator string &() { return S; }
template <class T> void operator+=(const T &a) { S += a; }
bool operator==(const slice_str &rhs) { return S == rhs.S; }
};
ostream &operator<<(ostream &os, const slice_str &a) {
os << a.S;
return os;
}
istream &operator>>(istream &iss, const slice_str &a) {
iss >> a.S;
return iss;
}
template <class T> bool can(const T &v, int i) { return 0 <= i && i < sz(v); }
#if __cplusplus >= 201703L
// template<class T> auto sum(int a, T v...) {return (v + ... + 0);}
#endif
#define VEC vector
#endif /*UNTITLED15_TEMPLATE_H*/
#endif
// † ←template終了
/*@formatter:on*/
// vectorで取れる要素数
// bool=> 1e9 * 8.32
// int => 1e8 * 2.6
// ll => 1e8 * 1.3
// 3次元以上取るとメモリがヤバい
// static配列を使う
vvc(ba);
ll N, M, H, W;
vi A, B, C;
#ifndef MINT
#define MINT
/*@formatter:off*/
template <typename T> T minv(T a, T m);
template <typename T> T minv(T a);
template <typename T> class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U> Modular(const U &x) { value = normalize(x); }
template <typename U> static Type normalize(const U &x) {
Type v;
if (-mod() <= x && x < mod())
v = static_cast<Type>(x);
else
v = static_cast<Type>(x % mod());
if (v < 0)
v += mod();
return v;
}
const Type &operator()() const { return value; }
template <typename U> explicit operator U() const {
return static_cast<U>(value);
}
constexpr static Type mod() { return T::value; }
Modular &operator+=(const Modular &other) {
if ((value += other.value) >= mod())
value -= mod();
return *this;
}
Modular &operator-=(const Modular &other) {
if ((value -= other.value) < 0)
value += mod();
return *this;
}
template <typename U> Modular &operator+=(const U &other) {
return *this += Modular(other);
}
template <typename U> Modular &operator-=(const U &other) {
return *this -= Modular(other);
}
Modular &operator++() { return *this += 1; }
Modular &operator--() { return *this -= 1; }
Modular operator++(signed) {
Modular result(*this);
*this += 1;
return result;
}
Modular operator--(signed) {
Modular result(*this);
*this -= 1;
return result;
}
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, signed>::value,
Modular>::type &
operator*=(const Modular &rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x),
d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod()));
value = m;
#else
value = normalize(static_cast<int64_t>(value) *
static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value,
Modular>::type &
operator*=(const Modular &rhs) {
int64_t q =
static_cast<int64_t>(static_cast<double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value,
Modular>::type &
operator*=(const Modular &rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular &operator/=(const Modular &other) {
return *this *= Modular(minv(other.value));
}
template <typename U>
friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);
template <typename U>
friend std::istream &operator>>(std::istream &stream, Modular<U> &number);
operator int() { return value; }
private:
Type value;
};
template <typename T>
bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value == rhs.value;
}
template <typename T, typename U>
bool operator==(const Modular<T> &lhs, U rhs) {
return lhs == Modular<T>(rhs);
}
template <typename T, typename U>
bool operator==(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) == rhs;
}
template <typename T>
bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(const Modular<T> &lhs, U rhs) {
return !(lhs == rhs);
}
template <typename T, typename U>
bool operator!=(U lhs, const Modular<T> &rhs) {
return !(lhs == rhs);
}
template <typename T>
bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) {
return lhs.value < rhs.value;
}
template <typename T>
Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T, typename U>
Modular<T> operator+(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) += rhs;
}
template <typename T>
Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T, typename U>
Modular<T> operator-(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) -= rhs;
}
template <typename T>
Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T, typename U>
Modular<T> operator*(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) *= rhs;
}
template <typename T>
Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(const Modular<T> &lhs, U rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator/(U lhs, const Modular<T> &rhs) {
return Modular<T>(lhs) /= rhs;
}
template <typename T, typename U>
Modular<T> operator%(const Modular<T> &lhs, U rhs) {
cerr << "can't mint % int" << endl;
assert(0);
exit(0);
return 0;
}
constexpr signed MOD =
// 998244353;
1e9 + 7; // MOD
using mint = Modular<std::integral_constant<decay<decltype(MOD)>::type, MOD>>;
#ifdef optional
template <class T>
optional<mint> operator+(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv + opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator-(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator*(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator/(const mint &mv, const optional<T> &opt) {
if (opt.has_value())
return mv / opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator+(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv + opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator-(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator*(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv * opt.value();
else
return optional<mint>();
}
template <class T>
optional<mint> operator/(const optional<T> &opt, const mint &mv) {
if (opt.has_value())
return mv / opt.value();
else
return optional<mint>();
}
template <class T> void operator+=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv += opt.value();
}
template <class T> void operator-=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv -= opt.value();
}
template <class T> void operator*=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv *= opt.value();
}
template <class T> void operator/=(mint &mv, const optional<T> &opt) {
if (opt.has_value())
mv /= opt.value();
}
template <class T> void operator+=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value += mv;
}
template <class T> void operator-=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value -= mv;
}
template <class T> void operator*=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value *= mv;
}
template <class T> void operator/=(const optional<T> &opt, mint &mv) {
if (opt.has_value())
opt.value /= mv;
}
#endif
// constexpr int mint_len = std::min(1400001, MOD);
vi fac, finv, inv;
vi p2;
void setmod_resize(int mint_len) {
// p2.resize(mint_len);p2[0] = 1; for (int i = 1; i < mint_len; ++i) p2[i]
// = p2[i - 1] * 2 % MOD;
int tn = sz(fac);
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = tn; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = tn; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
// 4e6 >= n なら O(r)で計算する
mint com_big(int n, int r) {
int fa = finv[r];
rep(i, r) fa *= n - i, fa %= MOD;
return mint(fa);
}
mint com(int n, int r) {
if (r < 0 || r > n)
return 0; /*nが大きくてrが小さい場合、nを上からr個掛ける*/
if (n >= sz(fac)) {
if (n <= 4e6)
setmod_resize(n + 1000);
else
return com_big(n, r);
}
return mint(finv[r] * fac[n] % MOD * finv[n - r]);
}
mint pom(int n, int r) { /* if (!sz(fac)) com(0, -1);*/
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
mint npr(int n, int r) { /* if (!sz(fac)) com(0, -1);*/
if (r < 0 || r > n)
return 0;
return mint(fac[n] * finv[n - r]);
}
mint com_grid(int n, int r) {
assert(r);
return com(n + r - 2, n - 1);
}
int nprin(int n, int r) { /* if (!sz(fac)) com(0, -1);*/
if (r < 0 || r > n)
return 0;
return fac[n] * finv[n - r] % MOD;
}
int icom(int n, int r) {
const int NUM_ = 1400001;
static ll fac[NUM_ + 1], finv[NUM_ + 1], inv[NUM_ + 1];
if (fac[0] == 0) {
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i <= NUM_; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i <= NUM_; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
if (r < 0 || r > n)
return 0;
return ((finv[r] * fac[n] % MOD) * finv[n - r]) % MOD;
}
#define ncr com
#define ncri icom
// n種類でr個選ぶ
// n個の場所にr個の物を置く
// 負が渡された場合もcomが処理出来る
mint nhr(int n, int r) {
if (n == 0 && r == 0)
return 1;
else
return com(n + r - 1, r);
}
// n種類でそれぞれ少なくとも1つは選び、r個揃える
mint nhr1(int n, int r) { return nhr(n, r - n); }
mint hom(int n, int r) {
if (n == 0 && r == 0)
return 1;
else
return com(n + r - 1, r);
}
int nhri(int n, int r) {
if (n == 0 && r == 0)
return 1;
else
return icom(n + r - 1, r);
}
// グリッドで0-indexedの最短経路 pascal
mint pas(int h, int w) { return com(h + w, w); }
template <typename T> T minv(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T> T minv(T a) {
if (a < sz(fac))
return inv[a];
T u = 0, v = 1;
T m = MOD;
while (a != 0) {
T t = m / a;
m -= t * a;
swap(a, m);
u -= t * v;
swap(u, v);
}
assert(m == 1);
return u;
}
// int型 mod m
template <typename T, typename U, typename V>
int mpow(const T a, const U b, const V m) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T, typename U>
Modular<T> mpow(const Modular<T> &a, const U &b) {
assert(b >= 0);
int x = a(), res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
//-k乗出来る
/*@formatter:on*/
template <typename T, typename U>
mint mpow(const T a, const U b) { /* assert(b >= 0);*/
if (b < 0) {
return minv(mpow(a, -b));
}
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= MOD;
(x *= x) %= MOD;
p >>= 1;
}
return res;
}
/*@formatter:off*/
template <class T> mint mpow(bint a, const T b) { return mpow((mint)a, b); }
template <typename T, typename U, typename V>
int mpowi(const T &a, const U &b, const V &m = MOD) {
assert(b >= 0);
int x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1)
(res *= x) %= m;
(x *= x) %= m;
p >>= 1;
}
return res;
}
template <typename T> string to_string(const Modular<T> &number) {
return to_string(number());
}
#ifdef _DEBUG
void yuri(const mint &a) {
stringstream st;
rep(i, 300) {
rep(j, 300) {
if ((mint)i / j == a) {
st << i << " / " << j;
i = 2000;
break;
}
}
}
string val = st.str();
if (val != "") {
deb(val);
return;
}
rep(i, 1000) {
rep(j, 1000) {
if ((mint)i / j == a) {
st << i << " / " << j;
i = 2000;
break;
}
}
}
val = st.str();
deb(val);
}
#else
#define yuri(...) ;
#endif
template <typename T>
std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
stream << number();
#ifdef _DEBUG
// stream << " -> " << yuri(number);
#endif
return stream;
}
//@formatter:off
template <typename T>
std::istream &operator>>(std::istream &stream, Modular<T> &number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
using PM = pair<mint, mint>;
using vm = vector<mint>;
using mapm = map<int, mint>;
using umapm = umap<int, mint>;
#define vvm(...) \
over4(__VA_ARGS__, vvt4, vvt3, vvt2, vvt1, vvt0)(mint, __VA_ARGS__)
#define vnm(name, ...) auto name = make_v<mint>(__VA_ARGS__)
string out_m2(mint a) {
stringstream st;
st << (int)a;
rep(i, 300) {
rep(j, 2, 300) {
if ((i % j) && (mint)i / j == a) {
st << "(" << i << "/" << j << ")";
i = 2000;
break;
}
}
}
return st.str();
}
// nhr n個の場所にr個の物を分ける
mint m1 = (mint)1;
mint half = (mint)1 / 2;
struct setmod {
// comで長さが足りない場合はsetmod_resizeでリサイズする
int mint_len = 1.4 * 1e6;
setmod() {
// p2を使う場合setmod_resizeも変える
// p2.resize(mint_len);p2[0] = 1; for (int i = 1; i < mint_len; ++i)
// p2[i] = p2[i - 1] * 2 % MOD;
fac.resize(mint_len);
finv.resize(mint_len);
inv.resize(mint_len);
inv[1] = fac[0] = finv[0] = 1;
for (int i = 2; i < mint_len; ++i)
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
for (int i = 1; i < mint_len; ++i)
fac[i] = fac[i - 1] * i % MOD, finv[i] = finv[i - 1] * inv[i] % MOD;
}
} setmodv;
template <signed S>
using mint_ = Modular<std::integral_constant<decay<signed>::type, S>>;
#endif
/*@formatter:on*/
void solve() {
in(N);
na(A, N);
rsort(A);
mint res = 0;
rep(i, N) {
mint l = pow<mint>(2, i) * i / 2;
res += (l + pow<mint>(2, i)) * pow<mint>(2, N - i - 1) * A[i];
}
res *= mpow(2, N); // Tの選び方
out(res);
}
auto my(ll n, vi &a) { return 0; }
auto sister(ll n, vi &a) {
ll ret = 0;
return ret;
}
signed main() {
solve();
#define arg n, a
#ifdef _DEBUG
bool bad = 0;
for (ll i = 0, ok = 1; i < k5 && ok; ++i) {
ll n = rand(1, 8);
vi a = ranv(n, 1, 10);
auto myres = my(arg);
auto res = sister(arg);
ok = myres == res;
if (!ok) {
out(arg);
cerr << "AC : " << res << endl;
cerr << "MY : " << myres << endl;
bad = 1;
break;
}
}
if (!bad) {
// solveを書き直す
// solveを呼び出す
}
if (was_deb && sz(res_mes)) {
cerr << "result = " << endl << res_mes << endl;
}
if (sz(message)) {
cerr << "****************************" << endl;
cerr << "Note." << endl;
cerr << message << endl;
cerr << "****************************" << endl;
}
#endif
return 0;
};
| replace | 7,971 | 7,972 | 7,971 | 7,975 | TLE | |
p02815 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
// このnamespace内のMODという値を、問題の要求に応じて変更すること
namespace Mint {
// このMODという値を、問題の要求に応じて変更すること
const ll MOD = 1000000007;
template <ll Mod> struct Modint {
ll val = 0;
// コンストラクタ long long, 空, Modintを受け取れる
Modint() = default;
Modint(const Modint &) = default;
Modint(ll _x) { val = _x >= 0 ? _x % Mod : ((_x % Mod) + Mod) % Mod; }
// 繰り返し二乗法、逆元 基本的に外部からいじるのやめたほうがよさそう。
ll modpow(ll a, ll b) const {
ll ret = 1, kakeru = a;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= Mod;
kakeru *= kakeru, kakeru %= Mod;
b >>= 1;
}
return ret;
}
Modint inv() const { return modpow((*this).val, MOD - 2); }
// 代入演算子 Modintとlong longの2通りある
Modint operator=(const Modint &p) {
val = p.val;
return (*this);
}
// 二項演算＋代入演算子 二項演算子、同値演算子はクラス外で定義する
Modint &operator+=(const Modint &p) {
val += p.val;
if (val >= Mod)
val -= Mod;
return (*this);
}
Modint &operator-=(const Modint &p) {
val -= p.val;
if (val < 0)
val += Mod;
return (*this);
}
Modint &operator*=(const Modint &p) {
val *= p.val;
val %= Mod;
return (*this);
}
Modint &operator/=(const Modint &p) {
// なんか,p.inv()を使うとthisのポインターが変換できませんって出る
// Modint tmp(p.inv());
Modint tmp(modpow(p.val, MOD - 2));
(*this) *= tmp;
return (*this);
}
};
// 加算
const Modint<MOD> operator+(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp += r;
return tmp;
}
const Modint<MOD> operator+(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp += Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator+(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp += r;
return tmp;
}
// 減算
const Modint<MOD> operator-(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp -= r;
return tmp;
}
const Modint<MOD> operator-(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp -= Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator-(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp -= r;
return tmp;
}
// 乗算
const Modint<MOD> operator*(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp *= r;
return tmp;
}
const Modint<MOD> operator*(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp *= Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator*(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp *= r;
return tmp;
}
// 除算
const Modint<MOD> operator/(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp /= r;
return tmp;
}
const Modint<MOD> operator/(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp /= Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator/(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp /= r;
return tmp;
}
// 同値演算子
const bool operator==(const Modint<MOD> &l, const Modint<MOD> &r) {
return l.val == r.val;
}
const bool operator==(const Modint<MOD> &l, const ll r) { return l.val == r; }
const bool operator==(const ll l, const Modint<MOD> &r) { return l == r.val; }
const bool operator!=(const Modint<MOD> &l, const Modint<MOD> &r) {
return !(l.val == r.val);
}
const bool operator!=(const Modint<MOD> &l, const ll r) {
return !(l.val == r);
}
const bool operator!=(const ll l, const Modint<MOD> &r) {
return !(l == r.val);
}
// istream ostream での入出力サポート
std::ostream &operator<<(std::ostream &stream, const Modint<MOD> &p) {
stream << p.val;
return stream;
}
std::istream &operator>>(std::istream &stream, Modint<MOD> &p) {
stream >> p.val;
return stream;
}
// 使う用の繰り返し二乗法 bはlong long に注意
Modint<MOD> modpow(const Modint<MOD> a, ll b) {
ll ret = 1, kakeru = a.val;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
Modint<MOD> tmpret(ret);
return tmpret;
}
} // namespace Mint
using namespace Mint;
using mint = Mint::Modint<MOD>;
namespace comb {
ll fact[500001];
ll fact_inv[500001];
const ll MOD = 1000000007;
ll modpow(ll a, ll b) {
ll base = 1, kakeru = a;
while (b > 0) {
if (b & 1)
base *= kakeru, base %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
return base;
}
void setup() {
fact[0] = 1, fact[1] = 1;
for (int i = 2; i <= 500000; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
fact_inv[500000] = modpow(fact[500000], MOD - 2);
for (int i = 499999; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1);
fact_inv[i] %= MOD;
}
}
ll combination(int a, int b) {
if (a - b < 0)
return 0;
ll ret = fact[a];
ret *= fact_inv[b], ret %= MOD;
ret *= fact_inv[a - b], ret %= MOD;
return ret;
}
ll permutation(int a, int b) {
if (a - b < 0)
return 0;
ll ret = fact[a];
ret *= fact_inv[a - b], ret %= MOD;
return ret;
}
ll homogeneous(int a, int b) { return combination(a + b - 1, b); }
} // namespace comb
int N;
ll C[100000 + 100];
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> C[i];
sort(C, C + N);
comb::setup();
mint ans = 0;
for (int i = 0; i < N; i++) {
ans += modpow(2, i) *
(modpow(2, N - i - 1) + (N - i - 1) * modpow(2, N - i - 2)) * C[i];
}
ans *= modpow(2, N);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
// このnamespace内のMODという値を、問題の要求に応じて変更すること
namespace Mint {
// このMODという値を、問題の要求に応じて変更すること
const ll MOD = 1000000007;
template <ll Mod> struct Modint {
ll val = 0;
// コンストラクタ long long, 空, Modintを受け取れる
Modint() = default;
Modint(const Modint &) = default;
Modint(ll _x) { val = _x >= 0 ? _x % Mod : ((_x % Mod) + Mod) % Mod; }
// 繰り返し二乗法、逆元 基本的に外部からいじるのやめたほうがよさそう。
ll modpow(ll a, ll b) const {
ll ret = 1, kakeru = a;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= Mod;
kakeru *= kakeru, kakeru %= Mod;
b >>= 1;
}
return ret;
}
Modint inv() const { return modpow((*this).val, MOD - 2); }
// 代入演算子 Modintとlong longの2通りある
Modint operator=(const Modint &p) {
val = p.val;
return (*this);
}
// 二項演算＋代入演算子 二項演算子、同値演算子はクラス外で定義する
Modint &operator+=(const Modint &p) {
val += p.val;
if (val >= Mod)
val -= Mod;
return (*this);
}
Modint &operator-=(const Modint &p) {
val -= p.val;
if (val < 0)
val += Mod;
return (*this);
}
Modint &operator*=(const Modint &p) {
val *= p.val;
val %= Mod;
return (*this);
}
Modint &operator/=(const Modint &p) {
// なんか,p.inv()を使うとthisのポインターが変換できませんって出る
// Modint tmp(p.inv());
Modint tmp(modpow(p.val, MOD - 2));
(*this) *= tmp;
return (*this);
}
};
// 加算
const Modint<MOD> operator+(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp += r;
return tmp;
}
const Modint<MOD> operator+(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp += Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator+(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp += r;
return tmp;
}
// 減算
const Modint<MOD> operator-(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp -= r;
return tmp;
}
const Modint<MOD> operator-(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp -= Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator-(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp -= r;
return tmp;
}
// 乗算
const Modint<MOD> operator*(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp *= r;
return tmp;
}
const Modint<MOD> operator*(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp *= Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator*(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp *= r;
return tmp;
}
// 除算
const Modint<MOD> operator/(const Modint<MOD> &l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp /= r;
return tmp;
}
const Modint<MOD> operator/(const Modint<MOD> &l, const ll r) {
Modint<MOD> tmp = l;
tmp /= Modint<MOD>(r);
return tmp;
}
const Modint<MOD> operator/(const ll l, const Modint<MOD> &r) {
Modint<MOD> tmp = l;
tmp /= r;
return tmp;
}
// 同値演算子
const bool operator==(const Modint<MOD> &l, const Modint<MOD> &r) {
return l.val == r.val;
}
const bool operator==(const Modint<MOD> &l, const ll r) { return l.val == r; }
const bool operator==(const ll l, const Modint<MOD> &r) { return l == r.val; }
const bool operator!=(const Modint<MOD> &l, const Modint<MOD> &r) {
return !(l.val == r.val);
}
const bool operator!=(const Modint<MOD> &l, const ll r) {
return !(l.val == r);
}
const bool operator!=(const ll l, const Modint<MOD> &r) {
return !(l == r.val);
}
// istream ostream での入出力サポート
std::ostream &operator<<(std::ostream &stream, const Modint<MOD> &p) {
stream << p.val;
return stream;
}
std::istream &operator>>(std::istream &stream, Modint<MOD> &p) {
stream >> p.val;
return stream;
}
// 使う用の繰り返し二乗法 bはlong long に注意
Modint<MOD> modpow(const Modint<MOD> a, ll b) {
ll ret = 1, kakeru = a.val;
while (b > 0) {
if (b & 1)
ret *= kakeru, ret %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
Modint<MOD> tmpret(ret);
return tmpret;
}
} // namespace Mint
using namespace Mint;
using mint = Mint::Modint<MOD>;
namespace comb {
ll fact[500001];
ll fact_inv[500001];
const ll MOD = 1000000007;
ll modpow(ll a, ll b) {
ll base = 1, kakeru = a;
while (b > 0) {
if (b & 1)
base *= kakeru, base %= MOD;
kakeru *= kakeru, kakeru %= MOD;
b >>= 1;
}
return base;
}
void setup() {
fact[0] = 1, fact[1] = 1;
for (int i = 2; i <= 500000; i++) {
fact[i] = (fact[i - 1] * i) % MOD;
}
fact_inv[500000] = modpow(fact[500000], MOD - 2);
for (int i = 499999; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1);
fact_inv[i] %= MOD;
}
}
ll combination(int a, int b) {
if (a - b < 0)
return 0;
ll ret = fact[a];
ret *= fact_inv[b], ret %= MOD;
ret *= fact_inv[a - b], ret %= MOD;
return ret;
}
ll permutation(int a, int b) {
if (a - b < 0)
return 0;
ll ret = fact[a];
ret *= fact_inv[a - b], ret %= MOD;
return ret;
}
ll homogeneous(int a, int b) { return combination(a + b - 1, b); }
} // namespace comb
int N;
ll C[200000 + 100];
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> C[i];
sort(C, C + N);
comb::setup();
mint ans = 0;
for (int i = 0; i < N; i++) {
ans += modpow(2, i) *
(modpow(2, N - i - 1) + (N - i - 1) * modpow(2, N - i - 2)) * C[i];
}
ans *= modpow(2, N);
cout << ans << endl;
return 0;
} | replace | 224 | 225 | 224 | 225 | 0 | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
long long a[100005], mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
b /= 2;
}
return res % mod;
}
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
long long num = qpow(4, n - 1), sum = 0;
for (long long i = 1; i <= n; i++) {
sum += num % mod * (n - i + 2) % mod * a[i] % mod;
sum %= mod;
}
cout << sum % mod << endl;
} | #include <bits/stdc++.h>
using namespace std;
long long a[200005], mod = 1e9 + 7;
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1)
res = res * a % mod;
a = a * a % mod;
b /= 2;
}
return res % mod;
}
int main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + 1 + n);
long long num = qpow(4, n - 1), sum = 0;
for (long long i = 1; i <= n; i++) {
sum += num % mod * (n - i + 2) % mod * a[i] % mod;
sum %= mod;
}
cout << sum % mod << endl;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define DEBUG(x) cerr << #x << ": " << x << endl;
#define DEBUG_VEC(v) \
cerr << #v << ":"; \
for (int i = 0; i < v.size(); i++) \
cerr << " " << v[i]; \
cerr << endl;
#define DEBUG_MAT(v) \
cerr << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
for (int j = 0; j < v[i].size(); j++) { \
cerr << v[i][j] << " "; \
} \
cerr << endl; \
}
typedef long long ll;
#define int ll
#define vi vector<int>
#define vl vector<ll>
#define vii vector<vector<int>>
#define vll vector<vector<ll>>
#define vs vector<string>
#define pii pair<int, int>
#define pis pair<int, string>
#define psi pair<string, int>
#define pll pair<ll, ll>
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
#define X first
#define Y second
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define in(x, a, b) (a <= x && x < b)
#define all(c) c.begin(), c.end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = (ll)1e18 + 1;
const long double pi = 3.1415926535897932384626433832795028841971L;
#define Sp(p) cout << setprecision(25) << fixed << p << endl;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy2[8] = {0, 1, 1, 1, 0, -1, -1, -1};
#define fio() \
cin.tie(0); \
ios::sync_with_stdio(false);
const ll MOD = 1000000007;
// const ll MOD = 998244353;
// #define mp make_pair
// #define endl '\n'
const int MAXN = 100010;
vl fact(MAXN);
vl rfact(MAXN);
ll mod_pow(ll x, ll p, ll M = MOD) {
if (p < 0) {
x = mod_pow(x, M - 2, M);
p = -p;
}
ll a = 1;
while (p) {
if (p % 2)
a = a * x % M;
x = x * x % M;
p /= 2;
}
return a;
}
ll mod_inverse(ll a, ll M = MOD) { return mod_pow(a, M - 2, M); }
void set_fact(ll n, ll M = MOD) {
fact[0] = fact[1] = rfact[0] = rfact[1] = 1;
for (ll i = 2; i <= n; i++) {
fact[i] = i * fact[i - 1] % M;
// rfact[i] = mod_inverse(fact[i], M);
}
}
// http://drken1215.hatenablog.com/entry/2018/06/08/210000
// n���傫��fact���v�Z�ł��Ȃ��Ƃ��̂ق��̌v�Z���@�ɂ��ď����Ă���
ll nCr(ll n, ll r, ll M = MOD) {
if (r > n)
return 0;
assert(fact[2] == 2);
ll ret = fact[n];
if (rfact[r] == 0) {
rfact[r] = mod_inverse(fact[r], M);
}
ret = (ret * rfact[r]) % M;
if (rfact[n - r] == 0) {
rfact[n - r] = mod_inverse(fact[n - r], M);
}
ret = (ret * rfact[n - r]) % M;
return ret;
}
ll nHr(ll n, ll r) { return nCr(n + r - 1, r); }
signed main() {
fio();
int n;
cin >> n;
vl c(n);
rep(i, n) cin >> c[i];
set_fact(n + 1);
sort(all(c));
ll ans = 0;
rep(i, n) {
ll kei = mod_pow(2, n - i) * mod_pow(4, i) % MOD * c[i] % MOD;
ll t = n - 1 - i;
ll add1 = mod_pow(2, t - 1) % MOD * (t + 2) % MOD;
ans += kei * add1 % MOD;
ans %= MOD;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define DEBUG(x) cerr << #x << ": " << x << endl;
#define DEBUG_VEC(v) \
cerr << #v << ":"; \
for (int i = 0; i < v.size(); i++) \
cerr << " " << v[i]; \
cerr << endl;
#define DEBUG_MAT(v) \
cerr << #v << endl; \
for (int i = 0; i < v.size(); i++) { \
for (int j = 0; j < v[i].size(); j++) { \
cerr << v[i][j] << " "; \
} \
cerr << endl; \
}
typedef long long ll;
#define int ll
#define vi vector<int>
#define vl vector<ll>
#define vii vector<vector<int>>
#define vll vector<vector<ll>>
#define vs vector<string>
#define pii pair<int, int>
#define pis pair<int, string>
#define psi pair<string, int>
#define pll pair<ll, ll>
template <class S, class T>
pair<S, T> operator+(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first + t.first, s.second + t.second);
}
template <class S, class T>
pair<S, T> operator-(const pair<S, T> &s, const pair<S, T> &t) {
return pair<S, T>(s.first - t.first, s.second - t.second);
}
template <class S, class T> ostream &operator<<(ostream &os, pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
#define X first
#define Y second
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep1(i, n) for (int i = (n); i > 0; i--)
#define REP(i, a, b) for (int i = a; i < b; i++)
#define in(x, a, b) (a <= x && x < b)
#define all(c) c.begin(), c.end()
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define UNIQUE(v) v.erase(std::unique(v.begin(), v.end()), v.end());
const ll inf = 1000000001;
const ll INF = (ll)1e18 + 1;
const long double pi = 3.1415926535897932384626433832795028841971L;
#define Sp(p) cout << setprecision(25) << fixed << p << endl;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int dx2[8] = {1, 1, 0, -1, -1, -1, 0, 1}, dy2[8] = {0, 1, 1, 1, 0, -1, -1, -1};
#define fio() \
cin.tie(0); \
ios::sync_with_stdio(false);
const ll MOD = 1000000007;
// const ll MOD = 998244353;
// #define mp make_pair
// #define endl '\n'
const int MAXN = 200010;
vl fact(MAXN);
vl rfact(MAXN);
ll mod_pow(ll x, ll p, ll M = MOD) {
if (p < 0) {
x = mod_pow(x, M - 2, M);
p = -p;
}
ll a = 1;
while (p) {
if (p % 2)
a = a * x % M;
x = x * x % M;
p /= 2;
}
return a;
}
ll mod_inverse(ll a, ll M = MOD) { return mod_pow(a, M - 2, M); }
void set_fact(ll n, ll M = MOD) {
fact[0] = fact[1] = rfact[0] = rfact[1] = 1;
for (ll i = 2; i <= n; i++) {
fact[i] = i * fact[i - 1] % M;
// rfact[i] = mod_inverse(fact[i], M);
}
}
// http://drken1215.hatenablog.com/entry/2018/06/08/210000
// n���傫��fact���v�Z�ł��Ȃ��Ƃ��̂ق��̌v�Z���@�ɂ��ď����Ă���
ll nCr(ll n, ll r, ll M = MOD) {
if (r > n)
return 0;
assert(fact[2] == 2);
ll ret = fact[n];
if (rfact[r] == 0) {
rfact[r] = mod_inverse(fact[r], M);
}
ret = (ret * rfact[r]) % M;
if (rfact[n - r] == 0) {
rfact[n - r] = mod_inverse(fact[n - r], M);
}
ret = (ret * rfact[n - r]) % M;
return ret;
}
ll nHr(ll n, ll r) { return nCr(n + r - 1, r); }
signed main() {
fio();
int n;
cin >> n;
vl c(n);
rep(i, n) cin >> c[i];
set_fact(n + 1);
sort(all(c));
ll ans = 0;
rep(i, n) {
ll kei = mod_pow(2, n - i) * mod_pow(4, i) % MOD * c[i] % MOD;
ll t = n - 1 - i;
ll add1 = mod_pow(2, t - 1) % MOD * (t + 2) % MOD;
ans += kei * add1 % MOD;
ans %= MOD;
}
cout << ans << endl;
} | replace | 80 | 81 | 80 | 81 | 0 | |
p02815 | C++ | Runtime Error | #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <typeinfo>
#include <utility>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
vector<ll> costs;
ll dp[200000];
ll fact[200000];
ll power(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
else if (b % 2 == 0) {
ll temp = power(a, b / 2);
return (temp * temp) % mod;
} else
return (power(a, b - 1) * a) % mod;
}
int main() {
int n;
scanf("%d", &n);
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = (fact[i - 1] * i) % mod;
for (int i = 0; i < n; i++) {
int num;
scanf("%d", &num);
costs.push_back(num);
}
sort(costs.begin(), costs.end(), greater<int>());
dp[1] = (costs[0] * 2) % mod;
for (int i = 2; i <= n; i++) {
dp[i] = (dp[i - 1] * 4) % mod;
ll temp = 0;
ll power2n = power(2, i - 2);
temp += (((costs[i - 1] * (power2n)) % mod) * (i + 1)) % mod;
temp *= (power2n * 4) % mod;
dp[i] += temp % mod;
dp[i] %= mod;
}
printf("%lld\n", dp[n]);
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <typeinfo>
#include <utility>
#include <vector>
#define mod 1000000007
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
vector<ll> costs;
ll dp[200001];
ll fact[200000];
ll power(ll a, ll b) {
if (b == 0)
return 1;
if (b == 1)
return a;
else if (b % 2 == 0) {
ll temp = power(a, b / 2);
return (temp * temp) % mod;
} else
return (power(a, b - 1) * a) % mod;
}
int main() {
int n;
scanf("%d", &n);
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = (fact[i - 1] * i) % mod;
for (int i = 0; i < n; i++) {
int num;
scanf("%d", &num);
costs.push_back(num);
}
sort(costs.begin(), costs.end(), greater<int>());
dp[1] = (costs[0] * 2) % mod;
for (int i = 2; i <= n; i++) {
dp[i] = (dp[i - 1] * 4) % mod;
ll temp = 0;
ll power2n = power(2, i - 2);
temp += (((costs[i - 1] * (power2n)) % mod) * (i + 1)) % mod;
temp *= (power2n * 4) % mod;
dp[i] += temp % mod;
dp[i] %= mod;
}
printf("%lld\n", dp[n]);
return 0;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p02815 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define taskname ""
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define for0(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef vector<cd> vcd;
typedef vector<int> vi;
template <class T> using v2d = vector<vector<T>>;
template <class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template <class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; }
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 2e5 + 10;
const ll mod = 1e9 + 7;
int n;
ll a[maxN];
ll fact[1000010], ifact[1000010];
ll power(ll a, ll b) {
ll r = 1;
while (b) {
if (b & 1) {
r = r * a % mod;
}
b /= 2;
a = a * a % mod;
}
return r;
}
void init() {
fact[0] = 1;
for (int i = 1; i <= 1e6; ++i) {
fact[i] = fact[i - 1] * i % mod;
}
ifact[1000000] = power(fact[1000000], mod - 2);
for (int i = 999999; i >= 0; --i) {
ifact[i] = ifact[i + 1] * (i + 1) % mod;
}
}
ll nCk(int n, int k) { return fact[n] * ifact[k] % mod * ifact[n - k] % mod; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
init();
cin >> n;
for1(i, n) { cin >> a[i]; }
sort(a + 1, a + n + 1, greater<ll>());
ll ans = 0;
for1(i, n) {
for1(j, i) {
ans += a[i] * j % mod * nCk(i - 1, j - 1) % mod * power(2, i) % mod *
power(4, n - i) % mod;
ans %= mod;
}
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define taskname ""
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define for0(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef vector<cd> vcd;
typedef vector<int> vi;
template <class T> using v2d = vector<vector<T>>;
template <class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template <class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; }
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 2e5 + 10;
const ll mod = 1e9 + 7;
int n;
ll a[maxN];
ll fact[1000010], ifact[1000010];
ll power(ll a, ll b) {
ll r = 1;
while (b) {
if (b & 1) {
r = r * a % mod;
}
b /= 2;
a = a * a % mod;
}
return r;
}
void init() {
fact[0] = 1;
for (int i = 1; i <= 1e6; ++i) {
fact[i] = fact[i - 1] * i % mod;
}
ifact[1000000] = power(fact[1000000], mod - 2);
for (int i = 999999; i >= 0; --i) {
ifact[i] = ifact[i + 1] * (i + 1) % mod;
}
}
ll nCk(int n, int k) { return fact[n] * ifact[k] % mod * ifact[n - k] % mod; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
init();
cin >> n;
for1(i, n) { cin >> a[i]; }
sort(a + 1, a + n + 1, greater<ll>());
ll ans = 0;
for1(i, n) {
ans += a[i] * (i + 1) % mod * power(2, i * 2 - 2) % mod * power(4, n - i) %
mod;
ans %= mod;
}
cout << ans;
return 0;
}
| replace | 69 | 74 | 69 | 72 | TLE | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) FOR(i, 0, (n))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define LAR(a, b) ((a) = max((a), (b)))
#define SML(a, b) ((a) = min((a), (b)))
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pair<int, int>> vpii;
typedef pair<int, int> pii;
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define ALL(a) (a).begin(), (a).end()
#ifdef LOCAL_DEBUG
#define DEBUG(...) printf(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
#define N 112345
#define MOD 1'000'000'007LL
ll c[N];
int main() {
int n;
scanf("%d", &n);
REP(i, n) scanf("%lld", c + i);
sort(c, c + n, greater<ll>());
ll ans = 0;
REP(i, n) ans = (ans + c[i] * (i + 2)) % MOD;
REP(i, 2 * n - 2) ans = ans * 2 % MOD;
printf("%lld\n", ans);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) FOR(i, 0, (n))
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define LAR(a, b) ((a) = max((a), (b)))
#define SML(a, b) ((a) = min((a), (b)))
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pair<int, int>> vpii;
typedef pair<int, int> pii;
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define ALL(a) (a).begin(), (a).end()
#ifdef LOCAL_DEBUG
#define DEBUG(...) printf(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
#define N 212345
#define MOD 1'000'000'007LL
ll c[N];
int main() {
int n;
scanf("%d", &n);
REP(i, n) scanf("%lld", c + i);
sort(c, c + n, greater<ll>());
ll ans = 0;
REP(i, n) ans = (ans + c[i] * (i + 2)) % MOD;
REP(i, 2 * n - 2) ans = ans * 2 % MOD;
printf("%lld\n", ans);
}
| replace | 22 | 23 | 22 | 23 | 0 | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 7;
const int MOD = 1e9 + 7;
typedef pair<int, int> pii;
template <int _MOD> struct Mint {
int v = 0;
Mint() {}
Mint(int _v) : v((_v % _MOD + _MOD) % _MOD) {}
Mint(long long _v) : v(static_cast<int>((_v % _MOD + _MOD) % _MOD)) {}
Mint operator=(const int &_v) { return *this = Mint(_v); }
Mint operator=(const long long &_v) { return *this = Mint(_v); }
bool operator!() const { return !this->v; }
bool operator<(const Mint &b) const { return v < b.v; }
bool operator>(const Mint &b) const { return v > b.v; }
bool operator==(const Mint &b) const { return v == b.v; }
bool operator!=(const Mint &b) const { return v != b.v; }
bool operator<=(const Mint &b) const { return v < b.v || v == b.v; }
bool operator>=(const Mint &b) const { return v > b.v || v == b.v; }
Mint operator+(const Mint &b) const { return Mint(v + b.v); }
Mint operator-(const Mint &b) const { return Mint(v - b.v); }
Mint operator*(const Mint &b) const { return Mint(1ll * v * b.v); }
Mint operator/(const Mint &b) const { return Mint(b.inv() * v); }
Mint &operator+=(const Mint &b) { return *this = *this + b; }
Mint &operator-=(const Mint &b) { return *this = *this - b; }
Mint &operator*=(const Mint &b) { return *this = *this * b; }
Mint &operator/=(const Mint &b) { return *this = *this / b; }
Mint operator-() const { return Mint(-v); }
Mint &operator++() { return *this += 1; }
Mint &operator--() { return *this -= 1; }
Mint operator++(int) {
Mint tmp = *this;
*this += 1;
return tmp;
}
Mint operator--(int) {
Mint tmp = *this;
*this -= 1;
return tmp;
}
Mint pow(int p) const {
Mint res(1), x(*this);
while (p) {
if (p & 1)
res = res * x;
x *= x;
p >>= 1;
}
return res;
}
Mint inv() const { return pow(_MOD - 2); }
friend istream &operator>>(istream &is, Mint &mt) { return is >> mt.v; }
friend ostream &operator<<(ostream &os, const Mint &mt) { return os << mt.v; }
};
using mint = Mint<MOD>;
int n;
int a[N];
inline void solve() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
mint res = 0, pow4 = 1;
for (int i = 1; i < n; ++i)
pow4 *= 4;
for (int i = 1; i <= n; ++i)
res += mint(i + 1) * a[i];
res *= pow4;
cout << res << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int MOD = 1e9 + 7;
typedef pair<int, int> pii;
template <int _MOD> struct Mint {
int v = 0;
Mint() {}
Mint(int _v) : v((_v % _MOD + _MOD) % _MOD) {}
Mint(long long _v) : v(static_cast<int>((_v % _MOD + _MOD) % _MOD)) {}
Mint operator=(const int &_v) { return *this = Mint(_v); }
Mint operator=(const long long &_v) { return *this = Mint(_v); }
bool operator!() const { return !this->v; }
bool operator<(const Mint &b) const { return v < b.v; }
bool operator>(const Mint &b) const { return v > b.v; }
bool operator==(const Mint &b) const { return v == b.v; }
bool operator!=(const Mint &b) const { return v != b.v; }
bool operator<=(const Mint &b) const { return v < b.v || v == b.v; }
bool operator>=(const Mint &b) const { return v > b.v || v == b.v; }
Mint operator+(const Mint &b) const { return Mint(v + b.v); }
Mint operator-(const Mint &b) const { return Mint(v - b.v); }
Mint operator*(const Mint &b) const { return Mint(1ll * v * b.v); }
Mint operator/(const Mint &b) const { return Mint(b.inv() * v); }
Mint &operator+=(const Mint &b) { return *this = *this + b; }
Mint &operator-=(const Mint &b) { return *this = *this - b; }
Mint &operator*=(const Mint &b) { return *this = *this * b; }
Mint &operator/=(const Mint &b) { return *this = *this / b; }
Mint operator-() const { return Mint(-v); }
Mint &operator++() { return *this += 1; }
Mint &operator--() { return *this -= 1; }
Mint operator++(int) {
Mint tmp = *this;
*this += 1;
return tmp;
}
Mint operator--(int) {
Mint tmp = *this;
*this -= 1;
return tmp;
}
Mint pow(int p) const {
Mint res(1), x(*this);
while (p) {
if (p & 1)
res = res * x;
x *= x;
p >>= 1;
}
return res;
}
Mint inv() const { return pow(_MOD - 2); }
friend istream &operator>>(istream &is, Mint &mt) { return is >> mt.v; }
friend ostream &operator<<(ostream &os, const Mint &mt) { return os << mt.v; }
};
using mint = Mint<MOD>;
int n;
int a[N];
inline void solve() {
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i];
sort(a + 1, a + n + 1);
reverse(a + 1, a + n + 1);
mint res = 0, pow4 = 1;
for (int i = 1; i < n; ++i)
pow4 *= 4;
for (int i = 1; i <= n; ++i)
res += mint(i + 1) * a[i];
res *= pow4;
cout << res << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
solve();
}
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02815 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// template
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(v) (v).begin(), (v).end()
typedef long long int ll;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;
const double eps = 1e-12;
void tostr(ll x, string &res) {
while (x)
res += ('0' + (x % 10)), x /= 10;
reverse(ALL(res));
return;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// template end
template <unsigned mod> struct mint {
static int get_mod() { return mod; }
int val;
int inv() const {
int tmp, a = val, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
if (x < 0)
x += mod;
return x;
}
mint() : val(0) {}
mint(ll x) : val(x >= 0 ? x % mod : mod + (x % mod)) {}
mint pow(ll t) {
mint res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
mint &operator+=(const mint &x) {
if ((val += x.val) >= mod)
val -= mod;
return *this;
}
mint &operator-=(const mint &x) {
if ((val += mod - x.val) >= mod)
val -= mod;
return *this;
}
mint &operator*=(const mint &x) {
val = (ll)val * x.val % mod;
return *this;
}
mint &operator/=(const mint &x) {
val = (ll)val * x.inv() % mod;
return *this;
}
mint operator+(const mint &x) const { return mint(*this) += x; }
mint operator-(const mint &x) const { return mint(*this) -= x; }
mint operator*(const mint &x) const { return mint(*this) *= x; }
mint operator/(const mint &x) const { return mint(*this) /= x; }
bool operator==(const mint &x) const { return val == x.val; }
bool operator!=(const mint &x) const { return val != x.val; }
};
using Mint = mint<1000000007>;
struct factorial {
vector<Mint> Fact, Finv;
public:
factorial(int maxx) {
Fact.resize(maxx + 1), Finv.resize(maxx + 1);
Fact[0] = Mint(1);
rep(i, 0, maxx) Fact[i + 1] = Fact[i] * (i + 1);
Finv[maxx] = Mint(1) / Fact[maxx];
rrep(i, maxx, 0) Finv[i - 1] = Finv[i] * i;
}
Mint fact(int n, bool inv = 0) {
if (inv)
return Finv[n];
else
return Fact[n];
}
Mint nPr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[n - r];
}
Mint nCr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[r] * Finv[n - r];
}
};
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
rep(i, 0, n) scanf("%d", &a[i]);
sort(ALL(a));
reverse(ALL(a));
Mint coeff = Mint(2).pow(n - 1), add = Mint(2).pow(n - 2), res;
rep(i, 0, n) {
res += coeff * a[i];
coeff += add;
}
res *= Mint(2).pow(n);
printf("%d\n", res.val);
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
// template
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (a); i > (b); i--)
#define ALL(v) (v).begin(), (v).end()
typedef long long int ll;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;
const double eps = 1e-12;
void tostr(ll x, string &res) {
while (x)
res += ('0' + (x % 10)), x /= 10;
reverse(ALL(res));
return;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
// template end
template <unsigned mod> struct mint {
static int get_mod() { return mod; }
int val;
int inv() const {
int tmp, a = val, b = mod, x = 1, y = 0;
while (b)
tmp = a / b, a -= tmp * b, swap(a, b), x -= tmp * y, swap(x, y);
if (x < 0)
x += mod;
return x;
}
mint() : val(0) {}
mint(ll x) : val(x >= 0 ? x % mod : mod + (x % mod)) {}
mint pow(ll t) {
mint res = 1, b = *this;
while (t) {
if (t & 1)
res *= b;
b *= b;
t >>= 1;
}
return res;
}
mint &operator+=(const mint &x) {
if ((val += x.val) >= mod)
val -= mod;
return *this;
}
mint &operator-=(const mint &x) {
if ((val += mod - x.val) >= mod)
val -= mod;
return *this;
}
mint &operator*=(const mint &x) {
val = (ll)val * x.val % mod;
return *this;
}
mint &operator/=(const mint &x) {
val = (ll)val * x.inv() % mod;
return *this;
}
mint operator+(const mint &x) const { return mint(*this) += x; }
mint operator-(const mint &x) const { return mint(*this) -= x; }
mint operator*(const mint &x) const { return mint(*this) *= x; }
mint operator/(const mint &x) const { return mint(*this) /= x; }
bool operator==(const mint &x) const { return val == x.val; }
bool operator!=(const mint &x) const { return val != x.val; }
};
using Mint = mint<1000000007>;
struct factorial {
vector<Mint> Fact, Finv;
public:
factorial(int maxx) {
Fact.resize(maxx + 1), Finv.resize(maxx + 1);
Fact[0] = Mint(1);
rep(i, 0, maxx) Fact[i + 1] = Fact[i] * (i + 1);
Finv[maxx] = Mint(1) / Fact[maxx];
rrep(i, maxx, 0) Finv[i - 1] = Finv[i] * i;
}
Mint fact(int n, bool inv = 0) {
if (inv)
return Finv[n];
else
return Fact[n];
}
Mint nPr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[n - r];
}
Mint nCr(int n, int r) {
if (n < 0 || n < r || r < 0)
return Mint(0);
else
return Fact[n] * Finv[r] * Finv[n - r];
}
};
int main() {
int n;
scanf("%d", &n);
vector<int> a(n);
rep(i, 0, n) scanf("%d", &a[i]);
if (n == 1) {
Mint res = Mint(2) * a[0];
printf("%d\n", res.val);
return 0;
}
sort(ALL(a));
reverse(ALL(a));
Mint coeff = Mint(2).pow(n - 1), add = Mint(2).pow(n - 2), res;
rep(i, 0, n) {
res += coeff * a[i];
coeff += add;
}
res *= Mint(2).pow(n);
printf("%d\n", res.val);
return 0;
} | insert | 119 | 119 | 119 | 124 | TLE | |
p02815 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
typedef long long ll;
typedef unsigned long long ull;
static const long long mod = 1000000007;
struct mint {
long long x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
(x += a.x) %= mod;
return *this;
}
mint &operator-=(const mint a) {
(x += mod - a.x) %= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint ret(*this);
return ret += a;
}
mint operator-(const mint a) const {
mint ret(*this);
return ret -= a;
}
mint operator*(const mint a) const {
mint ret(*this);
return ret *= a;
}
mint pow(ll t) const {
if (t == 0)
return mint(1);
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint ret(*this);
return ret /= a;
}
};
ostream &operator<<(ostream &os, const mint &x) {
os << x.x;
return os;
}
class modutils {
vector<mint> fact, invfact;
public:
modutils(int n = 2000005) : fact(n + 1), invfact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i;
invfact[n] = fact[n].inv();
for (int i = n; i >= 1; i--)
invfact[i - 1] = invfact[i] * i;
}
mint pow(mint x, ll n) { return x.pow(n); }
mint comb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact[n] * invfact[k] * invfact[n - k];
}
mint perm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact[n] * invfact[n - k];
}
mint fac(ll n) { return fact[n]; }
};
modutils mutil;
int main() {
int N;
cin >> N;
vector<int> v;
rep(i, N) {
int c;
cin >> c;
v.push_back(c);
}
sort(ALLOF(v));
mint ret(0);
rep(i, N) {
int a = i;
int b = N - i - 1;
mint tmp(0);
rep(j, b + 1) { tmp += mutil.pow(2, a) * mint(j + 1) * mutil.comb(b, j); }
ret += tmp * mint(v[i]);
}
ret *= mutil.pow(2, N);
cout << ret << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
typedef long long ll;
typedef unsigned long long ull;
static const long long mod = 1000000007;
struct mint {
long long x;
mint(ll x = 0) : x(x % mod) {}
mint &operator+=(const mint a) {
(x += a.x) %= mod;
return *this;
}
mint &operator-=(const mint a) {
(x += mod - a.x) %= mod;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const {
mint ret(*this);
return ret += a;
}
mint operator-(const mint a) const {
mint ret(*this);
return ret -= a;
}
mint operator*(const mint a) const {
mint ret(*this);
return ret *= a;
}
mint pow(ll t) const {
if (t == 0)
return mint(1);
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
// for prime mod
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint ret(*this);
return ret /= a;
}
};
ostream &operator<<(ostream &os, const mint &x) {
os << x.x;
return os;
}
class modutils {
vector<mint> fact, invfact;
public:
modutils(int n = 2000005) : fact(n + 1), invfact(n + 1) {
fact[0] = 1;
for (int i = 1; i <= n; i++)
fact[i] = fact[i - 1] * i;
invfact[n] = fact[n].inv();
for (int i = n; i >= 1; i--)
invfact[i - 1] = invfact[i] * i;
}
mint pow(mint x, ll n) { return x.pow(n); }
mint comb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact[n] * invfact[k] * invfact[n - k];
}
mint perm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fact[n] * invfact[n - k];
}
mint fac(ll n) { return fact[n]; }
};
modutils mutil;
int main() {
int N;
cin >> N;
vector<int> v;
rep(i, N) {
int c;
cin >> c;
v.push_back(c);
}
sort(ALLOF(v));
mint ret(0);
rep(i, N) {
int a = i;
int b = N - i - 1;
if (b > 0) {
ret += mutil.pow(2, a) * mint(v[i]) *
(mutil.pow(2, b) + mutil.pow(2, b - 1) * mint(b));
} else {
ret += mutil.pow(2, a) * mint(v[i]) * mutil.pow(2, b);
}
}
ret *= mutil.pow(2, N);
cout << ret << endl;
return 0;
}
| replace | 103 | 106 | 103 | 109 | TLE | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
constexpr int MX = 100005, MOD = 1e9 + 7;
int n;
ll c[MX], ans;
ll exp(ll ret, ll n) {
for (ll b = 2; n; n /= 2, (b *= b) %= MOD)
if (n % 2)
(ret *= b) %= MOD;
return ret;
}
int main() {
scanf("%d", &n);
rep(i, n) scanf("%lld", c + i);
sort(c, c + n, greater<ll>());
rep(i, n)(ans += c[i] * (i + 2)) %= MOD;
printf("%lld\n", exp(ans, n * 2 - 2));
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long;
constexpr int MX = 200005, MOD = 1e9 + 7;
int n;
ll c[MX], ans;
ll exp(ll ret, ll n) {
for (ll b = 2; n; n /= 2, (b *= b) %= MOD)
if (n % 2)
(ret *= b) %= MOD;
return ret;
}
int main() {
scanf("%d", &n);
rep(i, n) scanf("%lld", c + i);
sort(c, c + n, greater<ll>());
rep(i, n)(ans += c[i] * (i + 2)) %= MOD;
printf("%lld\n", exp(ans, n * 2 - 2));
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02815 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repr(i, n) for (lint i = n - 1; i >= 0; i--)
#define repi(i, ini, n) for (lint i = ini; i < n; i++)
#define repir(i, ini, n) for (lint i = n - 1; i >= ini; i--)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
#define bit(n) (1LL << n)
#define len(a) (static_cast<lint>(a.size()))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rg(v, ini, end) v.begin() + ini, v.begin() + end
#define rrg(v, ini, end) v.rbegin() + ini, v.rbegin() + end
#define ret return 0;
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
xy operator+(const xy &p) const { return xy(x + p.x, y + p.y); }
bool operator<(xy p) const {
if (y == p.y)
return x < p.x;
return y < p.y;
}
};
struct xyd {
ld x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
using vec = vector<lint>;
using vecd = vector<ld>;
using vecs = vector<string>;
using vecp = vector<xy>;
template <class T> using vect = vector<T>;
class vec2 : public vector<vector<lint>> {
public:
vec2() {}
vec2(lint n) : vector(n) {}
vec2(lint h, lint w) : vector(h, vector<lint>(w)) {}
vec2(lint h, lint w, lint v) : vector(h, vector<lint>(w, v)) {}
};
template <class T> using priq = priority_queue<T>;
template <class T> using rpriq = priority_queue<T, vector<T>, greater<T>>;
template <class Key, class Val> using hashmap = unordered_map<Key, Val>;
template <class Key> using hashset = unordered_set<Key>;
mt19937 mtrand((random_device())());
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
const lint inf = 1100100100100100100LL;
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class It> constexpr typename It::value_type mmax(It begin, It end) {
return *max_element(begin, end);
}
template <class It> constexpr typename It::value_type mmin(It begin, It end) {
return *min_element(begin, end);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
template <class T> struct Mplus {
T operator()(const T &a, const T &b) { return a + b; }
const static T id = T(0);
};
template <class It, class T = typename It::value_type, class Monoid = Mplus<T>>
T acc(It begin, It end, Monoid f = Mplus<T>()) {
return accumulate(begin, end, Monoid::id, f);
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
constexpr lint div2(lint p, lint q) { return (p + q - 1) / q; }
#if (__cplusplus < 201703L)
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
#endif
constexpr lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
lint extGCD(lint a, lint b, lint &x, lint &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
lint d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
template <class It> auto carr(It begin, It end) {
vec c;
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect<T> c;
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](const val_t &a, const val_t &b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <size_t _K, size_t _N, class... Types, size_t... indices>
auto constexpr __ModKtuple_Impl(index_sequence<indices...>,
tuple<Types...> args) {
return make_tuple(get<indices * _N + _K>(args)...);
}
template <size_t K, size_t N, class... Types>
auto constexpr ModKtuple(Types... args) {
return __ModKtuple_Impl<K, N>(
make_index_sequence<modK_belowN(K, N, sizeof...(args))>{},
forward_as_tuple(args...));
}
template <class It, class... T, class... Tsg, size_t... indices>
void __sort3_Impl(It begin, It end, tuple<T...> p, tuple<Tsg...> sgf,
index_sequence<indices...>) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p, sgf](val_t a, val_t b) {
bool neq[] = {(a.*(get<indices>(p)) != b.*(get<indices>(p)))...};
bool sg[] = {((a.*(get<indices>(p)) < b.*(get<indices>(p))) !=
(get<indices>(sgf)))...};
rep(i, sizeof...(indices)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class... T> void sort3(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
auto p_forward = ModKtuple<0, 2>(p...);
auto sgf_forward = ModKtuple<1, 2>(p...);
constexpr auto p_sz = tuple_size<decltype(p_forward)>::value;
constexpr auto sgf_sz = tuple_size<decltype(sgf_forward)>::value;
static_assert(p_sz == sgf_sz, "arg err");
__sort3_Impl(begin, end, p_forward, sgf_forward, make_index_sequence<p_sz>{});
}
template <class It, class It2> auto spacel(It i, It2 end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
bool match(string s, string r) { return regex_match(s, regex(r)); }
template <class It> bool next_comb(lint n, It begin, It end) {
auto rend = make_reverse_iterator(begin);
auto rbegin = make_reverse_iterator(end);
auto rit = rbegin;
for (; rit != rend; rit++) {
if ((rit == rbegin && (*rit) + 1 != n) ||
(rit != rbegin && (*rit) + 1 != *(rit - 1))) {
goto found;
}
}
return false;
found:;
(*rit)++;
for (auto it = rit.base(); it != end; it++) {
(*it) = (*(it - 1)) + 1;
}
return true;
}
ostream &setp(ostream &ost) {
cout << setprecision(60) << fixed;
return ost;
}
#ifdef _LOCAL
auto &dbg = cout;
#else
struct dummy_cout {
template <class T> dummy_cout &operator<<(T &&op) { return *this; }
using endl_t = basic_ostream<char, char_traits<char>>;
dummy_cout &operator<<(endl_t &(*)(endl_t &)) { return *this; }
};
dummy_cout dbg;
#endif
const ulint mod = 1000000007;
// const ulint mod = 998244353;
const ld eps = 0.0000001;
}; // namespace
struct mint {
lint n;
mint() { n = 0; }
mint(lint a) { n = a % mod; }
mint &operator+=(mint a) {
n += a.n;
n %= mod;
return *this;
}
mint &operator-=(mint a) {
n += mod;
n -= a.n;
n %= mod;
return *this;
}
mint &operator*=(mint a) {
n *= a.n;
n %= mod;
return *this;
}
mint &operator%=(mint a) {
n %= a.n;
return *this;
}
mint &operator++() {
n++;
n %= mod;
return *this;
}
mint &operator--() {
n += mod;
n--;
n %= mod;
return *this;
}
};
mint operator+(mint a, mint b) {
a += b;
return a;
}
mint operator-(mint a, mint b) {
a -= b;
return a;
}
mint operator*(mint a, mint b) {
a *= b;
return a;
}
vector<mint> invtbl;
vector<mint> finvtbl;
vector<mint> facttbl;
mint factMod(lint n) {
if (n == 0) {
return 1;
}
mint ans = 1;
while (n > 1) {
ans *= n;
n--;
}
return ans;
}
mint powMod(mint x, lint y) {
if (x.n <= 1) {
return x;
}
if (y == 0) {
return 1;
} else if (y == 1) {
return x;
} else if (y % 2 == 0) {
mint tmp = powMod(x, y / 2);
return tmp * tmp;
} else {
mint tmp = powMod(x, y / 2);
return tmp * tmp * x;
}
}
mint modinv(mint n) { return powMod(n, mod - 2); }
void preCalcInv(lint up) {
invtbl.resize(up + 1);
invtbl[1] = 1;
repb(a, 2, up) { invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a); }
}
mint operator/(mint a, mint b) {
if (b.n < invtbl.size()) {
a *= invtbl[b.n];
} else {
a *= modinv(b);
}
return a;
}
mint &operator/=(mint &a, mint b) {
a = a / b;
return a;
}
void preCalcFactInv(lint up) {
finvtbl.resize(up + 1);
finvtbl[0] = 1;
finvtbl[up] = modinv(factMod(up));
repbr(a, 1, up - 1) { finvtbl[a] = finvtbl[a + 1] * (a + 1); }
}
void preCalcFact(lint up) {
facttbl.resize(up + 1);
facttbl[0] = 1;
repb(a, 1, up) { facttbl[a] = facttbl[a - 1] * a; }
}
void preCalc(lint up) {
invtbl.resize(up + 1);
finvtbl.resize(up + 1);
facttbl.resize(up + 1);
invtbl[1] = 1;
facttbl[0] = facttbl[1] = 1;
finvtbl[0] = finvtbl[1] = 1;
repb(a, 2, up) {
facttbl[a] = facttbl[a - 1] * a;
invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a);
finvtbl[a] = finvtbl[a - 1] * invtbl[a];
}
}
mint factModInv(lint a) {
if (a < finvtbl.size()) {
return finvtbl[a];
} else {
return modinv(factMod(a));
}
}
mint nCrMod(lint n, lint r) {
if (n < r || n < 0 || r < 0) {
return 0;
}
r = mmin(r, n - r);
mint a = 1;
if (n < finvtbl.size() && n < facttbl.size()) {
a *= facttbl[n];
a *= finvtbl[r];
a *= finvtbl[n - r];
return a;
} else {
repb(i, n - r + 1, n) { a *= i; }
a *= factModInv(r);
return a;
}
}
mint nHrMod(lint n, lint r) { return nCrMod(n + r - 1, r); }
int main() {
lint n;
cin >> n;
vec c(n);
rep(i, n) cin >> c[i];
preCalc(400010);
sort(all(c));
vect<mint> cc(n);
rep(i, n) {
cc[i] = c[i];
cc[i] *= powMod(2, n + i);
}
mint ans = 0;
rep(i, n) {
mint k = 0;
rep(j, n - i) { k += (j + 1) * nCrMod(n - 1 - i, j); }
ans += cc[i] * k;
}
cout << ans.n << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repr(i, n) for (lint i = n - 1; i >= 0; i--)
#define repi(i, ini, n) for (lint i = ini; i < n; i++)
#define repir(i, ini, n) for (lint i = n - 1; i >= ini; i--)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
#define bit(n) (1LL << n)
#define len(a) (static_cast<lint>(a.size()))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rg(v, ini, end) v.begin() + ini, v.begin() + end
#define rrg(v, ini, end) v.rbegin() + ini, v.rbegin() + end
#define ret return 0;
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
xy operator+(const xy &p) const { return xy(x + p.x, y + p.y); }
bool operator<(xy p) const {
if (y == p.y)
return x < p.x;
return y < p.y;
}
};
struct xyd {
ld x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
using vec = vector<lint>;
using vecd = vector<ld>;
using vecs = vector<string>;
using vecp = vector<xy>;
template <class T> using vect = vector<T>;
class vec2 : public vector<vector<lint>> {
public:
vec2() {}
vec2(lint n) : vector(n) {}
vec2(lint h, lint w) : vector(h, vector<lint>(w)) {}
vec2(lint h, lint w, lint v) : vector(h, vector<lint>(w, v)) {}
};
template <class T> using priq = priority_queue<T>;
template <class T> using rpriq = priority_queue<T, vector<T>, greater<T>>;
template <class Key, class Val> using hashmap = unordered_map<Key, Val>;
template <class Key> using hashset = unordered_set<Key>;
mt19937 mtrand((random_device())());
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
const lint inf = 1100100100100100100LL;
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class It> constexpr typename It::value_type mmax(It begin, It end) {
return *max_element(begin, end);
}
template <class It> constexpr typename It::value_type mmin(It begin, It end) {
return *min_element(begin, end);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
template <class T> struct Mplus {
T operator()(const T &a, const T &b) { return a + b; }
const static T id = T(0);
};
template <class It, class T = typename It::value_type, class Monoid = Mplus<T>>
T acc(It begin, It end, Monoid f = Mplus<T>()) {
return accumulate(begin, end, Monoid::id, f);
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
constexpr lint div2(lint p, lint q) { return (p + q - 1) / q; }
#if (__cplusplus < 201703L)
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
#endif
constexpr lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
lint extGCD(lint a, lint b, lint &x, lint &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
lint d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
template <class It> auto carr(It begin, It end) {
vec c;
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect<T> c;
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](const val_t &a, const val_t &b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <size_t _K, size_t _N, class... Types, size_t... indices>
auto constexpr __ModKtuple_Impl(index_sequence<indices...>,
tuple<Types...> args) {
return make_tuple(get<indices * _N + _K>(args)...);
}
template <size_t K, size_t N, class... Types>
auto constexpr ModKtuple(Types... args) {
return __ModKtuple_Impl<K, N>(
make_index_sequence<modK_belowN(K, N, sizeof...(args))>{},
forward_as_tuple(args...));
}
template <class It, class... T, class... Tsg, size_t... indices>
void __sort3_Impl(It begin, It end, tuple<T...> p, tuple<Tsg...> sgf,
index_sequence<indices...>) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p, sgf](val_t a, val_t b) {
bool neq[] = {(a.*(get<indices>(p)) != b.*(get<indices>(p)))...};
bool sg[] = {((a.*(get<indices>(p)) < b.*(get<indices>(p))) !=
(get<indices>(sgf)))...};
rep(i, sizeof...(indices)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class... T> void sort3(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
auto p_forward = ModKtuple<0, 2>(p...);
auto sgf_forward = ModKtuple<1, 2>(p...);
constexpr auto p_sz = tuple_size<decltype(p_forward)>::value;
constexpr auto sgf_sz = tuple_size<decltype(sgf_forward)>::value;
static_assert(p_sz == sgf_sz, "arg err");
__sort3_Impl(begin, end, p_forward, sgf_forward, make_index_sequence<p_sz>{});
}
template <class It, class It2> auto spacel(It i, It2 end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
bool match(string s, string r) { return regex_match(s, regex(r)); }
template <class It> bool next_comb(lint n, It begin, It end) {
auto rend = make_reverse_iterator(begin);
auto rbegin = make_reverse_iterator(end);
auto rit = rbegin;
for (; rit != rend; rit++) {
if ((rit == rbegin && (*rit) + 1 != n) ||
(rit != rbegin && (*rit) + 1 != *(rit - 1))) {
goto found;
}
}
return false;
found:;
(*rit)++;
for (auto it = rit.base(); it != end; it++) {
(*it) = (*(it - 1)) + 1;
}
return true;
}
ostream &setp(ostream &ost) {
cout << setprecision(60) << fixed;
return ost;
}
#ifdef _LOCAL
auto &dbg = cout;
#else
struct dummy_cout {
template <class T> dummy_cout &operator<<(T &&op) { return *this; }
using endl_t = basic_ostream<char, char_traits<char>>;
dummy_cout &operator<<(endl_t &(*)(endl_t &)) { return *this; }
};
dummy_cout dbg;
#endif
const ulint mod = 1000000007;
// const ulint mod = 998244353;
const ld eps = 0.0000001;
}; // namespace
struct mint {
lint n;
mint() { n = 0; }
mint(lint a) { n = a % mod; }
mint &operator+=(mint a) {
n += a.n;
n %= mod;
return *this;
}
mint &operator-=(mint a) {
n += mod;
n -= a.n;
n %= mod;
return *this;
}
mint &operator*=(mint a) {
n *= a.n;
n %= mod;
return *this;
}
mint &operator%=(mint a) {
n %= a.n;
return *this;
}
mint &operator++() {
n++;
n %= mod;
return *this;
}
mint &operator--() {
n += mod;
n--;
n %= mod;
return *this;
}
};
mint operator+(mint a, mint b) {
a += b;
return a;
}
mint operator-(mint a, mint b) {
a -= b;
return a;
}
mint operator*(mint a, mint b) {
a *= b;
return a;
}
vector<mint> invtbl;
vector<mint> finvtbl;
vector<mint> facttbl;
mint factMod(lint n) {
if (n == 0) {
return 1;
}
mint ans = 1;
while (n > 1) {
ans *= n;
n--;
}
return ans;
}
mint powMod(mint x, lint y) {
if (x.n <= 1) {
return x;
}
if (y == 0) {
return 1;
} else if (y == 1) {
return x;
} else if (y % 2 == 0) {
mint tmp = powMod(x, y / 2);
return tmp * tmp;
} else {
mint tmp = powMod(x, y / 2);
return tmp * tmp * x;
}
}
mint modinv(mint n) { return powMod(n, mod - 2); }
void preCalcInv(lint up) {
invtbl.resize(up + 1);
invtbl[1] = 1;
repb(a, 2, up) { invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a); }
}
mint operator/(mint a, mint b) {
if (b.n < invtbl.size()) {
a *= invtbl[b.n];
} else {
a *= modinv(b);
}
return a;
}
mint &operator/=(mint &a, mint b) {
a = a / b;
return a;
}
void preCalcFactInv(lint up) {
finvtbl.resize(up + 1);
finvtbl[0] = 1;
finvtbl[up] = modinv(factMod(up));
repbr(a, 1, up - 1) { finvtbl[a] = finvtbl[a + 1] * (a + 1); }
}
void preCalcFact(lint up) {
facttbl.resize(up + 1);
facttbl[0] = 1;
repb(a, 1, up) { facttbl[a] = facttbl[a - 1] * a; }
}
void preCalc(lint up) {
invtbl.resize(up + 1);
finvtbl.resize(up + 1);
facttbl.resize(up + 1);
invtbl[1] = 1;
facttbl[0] = facttbl[1] = 1;
finvtbl[0] = finvtbl[1] = 1;
repb(a, 2, up) {
facttbl[a] = facttbl[a - 1] * a;
invtbl[a] = invtbl[a] = mod - invtbl[mod % a] * (mod / a);
finvtbl[a] = finvtbl[a - 1] * invtbl[a];
}
}
mint factModInv(lint a) {
if (a < finvtbl.size()) {
return finvtbl[a];
} else {
return modinv(factMod(a));
}
}
mint nCrMod(lint n, lint r) {
if (n < r || n < 0 || r < 0) {
return 0;
}
r = mmin(r, n - r);
mint a = 1;
if (n < finvtbl.size() && n < facttbl.size()) {
a *= facttbl[n];
a *= finvtbl[r];
a *= finvtbl[n - r];
return a;
} else {
repb(i, n - r + 1, n) { a *= i; }
a *= factModInv(r);
return a;
}
}
mint nHrMod(lint n, lint r) { return nCrMod(n + r - 1, r); }
int main() {
lint n;
cin >> n;
vec c(n);
rep(i, n) cin >> c[i];
preCalc(400010);
sort(all(c));
vect<mint> cc(n);
rep(i, n) {
cc[i] = c[i];
cc[i] *= powMod(2, n + i);
}
mint ans = 0;
rep(i, n) {
mint k = (n - i + 1);
if (n - i - 2 == -1) {
k *= modinv(2);
} else
k *= powMod(2, n - i - 2);
ans += cc[i] * k;
}
cout << ans.n << endl;
return 0;
}
| replace | 530 | 532 | 530 | 535 | TLE | |
p02815 | C++ | Runtime Error | // È¥°É£¡Æ¤¿¨Çð! °ÑAC´ø»ØÀ´£¡
// ¤Ø¡¡¡¡¡¡¡¡¡¡£¯|
// ¡¡¡¡/£Ü7¡¡¡¡¡¡ ¡Ï£ß/
// ¡¡ /¡¡©¦¡¡¡¡ £¯¡¡£¯ AC AC
// AC AC
// ©¦¡¡Z £ß,£¼¡¡£¯¡¡¡¡ /`©c AC AC AC
// AC ©¦¡¡¡¡¡¡¡¡¡¡©c¡¡¡¡ /¡¡¡¡¡µ AC
// AC AC AC
// ¡¡Y¡¡¡¡¡¡¡¡¡¡`¡¡ /¡¡¡¡/ / AC AC
// AC AC
// ¡¡Øé¡ñ¡¡.¡¡¡ñ¡¡¡¡¡´¡¡/¡¡/ AC AC
// AC AC
// ¡¡()¡¡ ¤Ø¡¡¡¡¡¡¡¡|¡¡£Ü¡´ AC AC
// AC AC
// ¡¡¡¡>- ._¡¡ ¥£¡¡ ©¦ £¯£¯ AC AC
// AC AC
// ¡¡ / ¤Ø¡¡¡¡ /¡¡/£¼| £Ü£Ü AC AC
// AC AC
// ¡¡ ©c_/¡¡¡¡(_£¯¡¡ ©¦£¯£¯ AC AC
// AC AC
// ¡¡¡¡ 7¡¡¡¡¡¡¡¡¡¡¡¡¡¡|£¯ AC AC
// AC AC
// ¡¡¡¡ £¾¨Dr£þ£þ`-¨D£ß/ AC AC
// AC AC
//**************************************Accepted*****************************************//
#include <bits/stdc++.h>
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define Unique(x) x.erase(unique(all(x)), x.end());
#define CIN_FILE "input.txt"
#define COUT_FILE "output.txt"
#define Pig (OO)
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
inline int read() {
#define gc getchar
int ans = 0;
bool f = 1;
char ch = gc();
while (!isdigit(ch))
f ^= ch == '-', ch = gc();
while (isdigit(ch))
ans = ((ans << 2) + ans << 1) + (ch ^ 48), ch = gc();
return f ? ans : -ans;
#undef gc
}
typedef long long ll;
/*
template <typename T>
struct modular {
constexpr modular() : val(0){}
constexpr modular(const modular<T>& _m) : val(_m.val) {}
template <typename U> constexpr modular(const U& _r = U()) {
val = -MOD <= _r && _r < MOD ? _r: _r % MOD;
if (val < 0) { val += MOD; } }
const T operator()() { return val; }
template <typename U> explicit operator U() const { return
static_cast<U>(val); } modular<T>& operator+=(const modular<T>& _m) { if ((val
+= _m.val) >= MOD) { val -= MOD; } return *this; } modular<T>& operator-=(const
modular<T>& _m) { if ((val -= _m.val) < 0) { val += MOD; } return *this; }
modular<T>& operator*=(const modular<T>& _m) { val =
modular<T>(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val)).val; return
*this; } modular<T>& operator/=(const modular<T>& _m) { T a = _m.val, b = MOD, u
= 0, v = 1; while (a != 0) { T q = b / a; b -= q * a; swap(a, b); u -= q * v;
swap(u, v); } return *this *= u; } modular<T>& operator =(const modular<T>& _m)
{ val = _m.val; return *this; } template <typename U> modular<T>&
operator+=(const U& _r) { return *this += modular<T>(_r); } template <typename
U> modular<T>& operator-=(const U& _r) { return *this -= modular<T>(_r); }
template <typename U> modular<T>& operator*=(const U& _r) { return *this *=
modular<T>(_r); } template <typename U> modular<T>& operator/=(const U& _r) {
return *this /= modular<T>(_r); } template <typename U> modular<T>& operator
=(const U& _r) { val = modular<T>(_r).val; return *this; } modular<T>
operator-() { return modular<T>(-val); } template <typename U> friend bool
operator==(const modular<U>&, const modular<U>&); friend std::istream&
operator>>(std::istream& os, modular<T>& _m) { os >> _m.val; _m *= 1; return os;
} friend std::ostream& operator<<(std::ostream& os, const modular<T>& _m) {
return os << _m.val; } template <typename U> modular<T> exp(U e) { modular<T>
res = 1; modular<T> b = val; if (e < 0) { b = 1/b; e *= -1; } for (; e; e >>= 1)
{ if (e & 1) { res *= b; } b *= b; } return res; } private: T val;
};
template <typename T> inline modular<T> operator+(const modular<T>& _lhs, const
modular<T>& _rhs) { return modular<T>(_lhs) += _rhs; } template <typename T,
typename U> inline modular<T> operator+(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) += _rhs; } template <typename T, typename U> inline
modular<T> operator+(const U& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) += _rhs; } template <typename T> inline modular<T>
operator-(const modular<T>& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) -= _rhs; } template <typename T, typename U> inline modular<T>
operator-(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) -=
_rhs; } template <typename T, typename U> inline modular<T> operator-(const U&
_lhs, const modular<T>& _rhs) { return modular<T>(_lhs) -= _rhs; } template
<typename T> inline modular<T> operator*(const modular<T>& _lhs, const
modular<T>& _rhs) { return modular<T>(_lhs) *= _rhs; } template <typename T,
typename U> inline modular<T> operator*(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) *= _rhs; } template <typename T, typename U> inline
modular<T> operator*(const U& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) *= _rhs; } template <typename T> inline modular<T>
operator/(const modular<T>& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) /= _rhs; } template <typename T, typename U> inline modular<T>
operator/(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) /=
_rhs; } template <typename T, typename U> inline modular<T> operator/(const U&
_lhs, const modular<T>& _rhs) { return modular<T>(_lhs) /= _rhs; } template
<typename T> inline bool operator==(const modular<T>& _lhs, const modular<T>&
_rhs) { return _lhs.val == _rhs.val; } template <typename T, typename U> inline
bool operator==(const modular<T>& _lhs, const U& _rhs) { return _lhs ==
modular<T>(_rhs); } template <typename T, typename U> inline bool
operator==(const U& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) ==
_rhs; } template <typename T> inline bool operator!=(const modular<T>& _lhs,
const modular<T>& _rhs) { return !(_lhs == _rhs); } template <typename T,
typename U> inline bool operator!=(const modular<T>& _lhs, const U& _rhs) {
return !(_lhs == _rhs); } template <typename T, typename U> inline bool
operator!=(const U& _lhs, const modular<T>& _rhs) { return !(_lhs == _rhs); }
typedef modular<int> mint;
*/
int n;
ll c[100010];
const ll MOD = 1000000007;
ll ans;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> c[i];
sort(c + 1, c + n + 1);
for (int i = 1; i <= n; i++)
ans = (ans + ((i + 1) * c[n - i + 1]) % MOD) % MOD;
for (int i = 0; i < n - 1; i++)
ans = (ans * 4) % MOD;
cout << ans;
// printf("Time used = %.12f",(double)(clock())/CLOCKS_PER_SEC);
return 0;
} | // È¥°É£¡Æ¤¿¨Çð! °ÑAC´ø»ØÀ´£¡
// ¤Ø¡¡¡¡¡¡¡¡¡¡£¯|
// ¡¡¡¡/£Ü7¡¡¡¡¡¡ ¡Ï£ß/
// ¡¡ /¡¡©¦¡¡¡¡ £¯¡¡£¯ AC AC
// AC AC
// ©¦¡¡Z £ß,£¼¡¡£¯¡¡¡¡ /`©c AC AC AC
// AC ©¦¡¡¡¡¡¡¡¡¡¡©c¡¡¡¡ /¡¡¡¡¡µ AC
// AC AC AC
// ¡¡Y¡¡¡¡¡¡¡¡¡¡`¡¡ /¡¡¡¡/ / AC AC
// AC AC
// ¡¡Øé¡ñ¡¡.¡¡¡ñ¡¡¡¡¡´¡¡/¡¡/ AC AC
// AC AC
// ¡¡()¡¡ ¤Ø¡¡¡¡¡¡¡¡|¡¡£Ü¡´ AC AC
// AC AC
// ¡¡¡¡>- ._¡¡ ¥£¡¡ ©¦ £¯£¯ AC AC
// AC AC
// ¡¡ / ¤Ø¡¡¡¡ /¡¡/£¼| £Ü£Ü AC AC
// AC AC
// ¡¡ ©c_/¡¡¡¡(_£¯¡¡ ©¦£¯£¯ AC AC
// AC AC
// ¡¡¡¡ 7¡¡¡¡¡¡¡¡¡¡¡¡¡¡|£¯ AC AC
// AC AC
// ¡¡¡¡ £¾¨Dr£þ£þ`-¨D£ß/ AC AC
// AC AC
//**************************************Accepted*****************************************//
#include <bits/stdc++.h>
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define Unique(x) x.erase(unique(all(x)), x.end());
#define CIN_FILE "input.txt"
#define COUT_FILE "output.txt"
#define Pig (OO)
using namespace std;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
inline int read() {
#define gc getchar
int ans = 0;
bool f = 1;
char ch = gc();
while (!isdigit(ch))
f ^= ch == '-', ch = gc();
while (isdigit(ch))
ans = ((ans << 2) + ans << 1) + (ch ^ 48), ch = gc();
return f ? ans : -ans;
#undef gc
}
typedef long long ll;
/*
template <typename T>
struct modular {
constexpr modular() : val(0){}
constexpr modular(const modular<T>& _m) : val(_m.val) {}
template <typename U> constexpr modular(const U& _r = U()) {
val = -MOD <= _r && _r < MOD ? _r: _r % MOD;
if (val < 0) { val += MOD; } }
const T operator()() { return val; }
template <typename U> explicit operator U() const { return
static_cast<U>(val); } modular<T>& operator+=(const modular<T>& _m) { if ((val
+= _m.val) >= MOD) { val -= MOD; } return *this; } modular<T>& operator-=(const
modular<T>& _m) { if ((val -= _m.val) < 0) { val += MOD; } return *this; }
modular<T>& operator*=(const modular<T>& _m) { val =
modular<T>(static_cast<int64_t>(val) * static_cast<int64_t>(_m.val)).val; return
*this; } modular<T>& operator/=(const modular<T>& _m) { T a = _m.val, b = MOD, u
= 0, v = 1; while (a != 0) { T q = b / a; b -= q * a; swap(a, b); u -= q * v;
swap(u, v); } return *this *= u; } modular<T>& operator =(const modular<T>& _m)
{ val = _m.val; return *this; } template <typename U> modular<T>&
operator+=(const U& _r) { return *this += modular<T>(_r); } template <typename
U> modular<T>& operator-=(const U& _r) { return *this -= modular<T>(_r); }
template <typename U> modular<T>& operator*=(const U& _r) { return *this *=
modular<T>(_r); } template <typename U> modular<T>& operator/=(const U& _r) {
return *this /= modular<T>(_r); } template <typename U> modular<T>& operator
=(const U& _r) { val = modular<T>(_r).val; return *this; } modular<T>
operator-() { return modular<T>(-val); } template <typename U> friend bool
operator==(const modular<U>&, const modular<U>&); friend std::istream&
operator>>(std::istream& os, modular<T>& _m) { os >> _m.val; _m *= 1; return os;
} friend std::ostream& operator<<(std::ostream& os, const modular<T>& _m) {
return os << _m.val; } template <typename U> modular<T> exp(U e) { modular<T>
res = 1; modular<T> b = val; if (e < 0) { b = 1/b; e *= -1; } for (; e; e >>= 1)
{ if (e & 1) { res *= b; } b *= b; } return res; } private: T val;
};
template <typename T> inline modular<T> operator+(const modular<T>& _lhs, const
modular<T>& _rhs) { return modular<T>(_lhs) += _rhs; } template <typename T,
typename U> inline modular<T> operator+(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) += _rhs; } template <typename T, typename U> inline
modular<T> operator+(const U& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) += _rhs; } template <typename T> inline modular<T>
operator-(const modular<T>& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) -= _rhs; } template <typename T, typename U> inline modular<T>
operator-(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) -=
_rhs; } template <typename T, typename U> inline modular<T> operator-(const U&
_lhs, const modular<T>& _rhs) { return modular<T>(_lhs) -= _rhs; } template
<typename T> inline modular<T> operator*(const modular<T>& _lhs, const
modular<T>& _rhs) { return modular<T>(_lhs) *= _rhs; } template <typename T,
typename U> inline modular<T> operator*(const modular<T>& _lhs, const U& _rhs) {
return modular<T>(_lhs) *= _rhs; } template <typename T, typename U> inline
modular<T> operator*(const U& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) *= _rhs; } template <typename T> inline modular<T>
operator/(const modular<T>& _lhs, const modular<T>& _rhs) { return
modular<T>(_lhs) /= _rhs; } template <typename T, typename U> inline modular<T>
operator/(const modular<T>& _lhs, const U& _rhs) { return modular<T>(_lhs) /=
_rhs; } template <typename T, typename U> inline modular<T> operator/(const U&
_lhs, const modular<T>& _rhs) { return modular<T>(_lhs) /= _rhs; } template
<typename T> inline bool operator==(const modular<T>& _lhs, const modular<T>&
_rhs) { return _lhs.val == _rhs.val; } template <typename T, typename U> inline
bool operator==(const modular<T>& _lhs, const U& _rhs) { return _lhs ==
modular<T>(_rhs); } template <typename T, typename U> inline bool
operator==(const U& _lhs, const modular<T>& _rhs) { return modular<T>(_lhs) ==
_rhs; } template <typename T> inline bool operator!=(const modular<T>& _lhs,
const modular<T>& _rhs) { return !(_lhs == _rhs); } template <typename T,
typename U> inline bool operator!=(const modular<T>& _lhs, const U& _rhs) {
return !(_lhs == _rhs); } template <typename T, typename U> inline bool
operator!=(const U& _lhs, const modular<T>& _rhs) { return !(_lhs == _rhs); }
typedef modular<int> mint;
*/
int n;
ll c[200010];
const ll MOD = 1000000007;
ll ans;
int main(int argc, char const *argv[]) {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++)
cin >> c[i];
sort(c + 1, c + n + 1);
for (int i = 1; i <= n; i++)
ans = (ans + ((i + 1) * c[n - i + 1]) % MOD) % MOD;
for (int i = 0; i < n - 1; i++)
ans = (ans * 4) % MOD;
cout << ans;
// printf("Time used = %.12f",(double)(clock())/CLOCKS_PER_SEC);
return 0;
} | replace | 133 | 134 | 133 | 134 | 0 | |
p02815 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
typedef priority_queue<int> PQ;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define fore(i, a) for (auto &i : a)
#define REP(i, n) for (int i = 0; i < n; i++)
#define eREP(i, n) for (int i = 0; i <= n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define eFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define rSORT(c) sort((c).rbegin(), (c).rend())
#define LB(x, a) lower_bound((x).begin(), (x).end(), (a))
#define UB(x, a) upper_bound((x).begin(), (x).end(), (a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
// vector<vector<int> > dp;
// vector<vector<vector<int> > > vvvi;
// dp=vector<vector<int> >(N, vector<int>(M,0));
// vector<pair<int,int> > v;
// v.push_back(make_pair(x,y));
// priority_queue<int,vector<int>, greater<int> > q2;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
VI C(N);
REP(i, N) cin >> C[i];
SORT(C);
int ans = 0;
int bi[100010] = {0};
int b = 1;
for (int i = 0; i <= N; i++) {
bi[i] = b;
b *= 2;
b %= mod;
}
REP(i, N) {
int a = C[i];
int cnt = bi[N - i - 1];
if (N - i - 2 >= 0)
cnt += bi[N - i - 2] * (N - i - 1);
cnt %= mod;
cnt *= bi[i];
cnt %= mod;
// cout << bi[i] << " " << bi[i] * (N - i - 1) / 2 << " " << bi[N - i-1] <<
// endl;
// if(a * cnt<0)cout << a << " " << cnt << endl;
ans += a * cnt;
ans %= mod;
}
ans *= bi[N];
ans %= mod;
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
typedef priority_queue<int> PQ;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define fore(i, a) for (auto &i : a)
#define REP(i, n) for (int i = 0; i < n; i++)
#define eREP(i, n) for (int i = 0; i <= n; i++)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define eFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define SORT(c) sort((c).begin(), (c).end())
#define rSORT(c) sort((c).rbegin(), (c).rend())
#define LB(x, a) lower_bound((x).begin(), (x).end(), (a))
#define UB(x, a) upper_bound((x).begin(), (x).end(), (a))
#define INF 1000000000
#define LLINF 9223372036854775807
#define mod 1000000007
// vector<vector<int> > dp;
// vector<vector<vector<int> > > vvvi;
// dp=vector<vector<int> >(N, vector<int>(M,0));
// vector<pair<int,int> > v;
// v.push_back(make_pair(x,y));
// priority_queue<int,vector<int>, greater<int> > q2;
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
VI C(N);
REP(i, N) cin >> C[i];
SORT(C);
int ans = 0;
int bi[200010] = {0};
int b = 1;
for (int i = 0; i <= N; i++) {
bi[i] = b;
b *= 2;
b %= mod;
}
REP(i, N) {
int a = C[i];
int cnt = bi[N - i - 1];
if (N - i - 2 >= 0)
cnt += bi[N - i - 2] * (N - i - 1);
cnt %= mod;
cnt *= bi[i];
cnt %= mod;
// cout << bi[i] << " " << bi[i] * (N - i - 1) / 2 << " " << bi[N - i-1] <<
// endl;
// if(a * cnt<0)cout << a << " " << cnt << endl;
ans += a * cnt;
ans %= mod;
}
ans *= bi[N];
ans %= mod;
cout << ans << endl;
return 0;
}
| replace | 59 | 60 | 59 | 60 | 0 | |
p02815 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for (ll i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rreps(i, e, n) for (ll i = (n)-1; i >= (e); i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define len(x) ((ll)(x).length())
struct mint {
const int mod = 1e9 + 7;
long long x;
mint(long long x = 0) : x((x % mod + mod) % mod) {}
mint &operator=(const long long a) {
x = a % mod;
return *this;
}
mint &operator=(const mint a) {
x = a.x % mod;
return *this;
}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint &operator-=(const mint a) {
if ((x += (mod - a.x)) >= mod)
x -= mod;
return *this;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll n;
cin >> n;
vector<ll> c(n);
rep(i, n) cin >> c[i];
sort(all(c));
vector<mint> e(n + 1);
rep(i, n + 1) {
if (i == 0)
e[i] = 1;
else
e[i] = e[i - 1] * 2;
}
mint ans = 0;
rep(i, n) {
ll l = i, r = n - i - 1;
ans += e[l] * (e[r] + e[r - 1] * r) * c[i];
}
ans *= e[n];
cout << ans.x << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0, i##_len = (n); i < i##_len; i++)
#define reps(i, s, n) for (ll i = (s), i##_len = (n); i < i##_len; i++)
#define rrep(i, n) for (ll i = (n)-1; i >= 0; i--)
#define rreps(i, e, n) for (ll i = (n)-1; i >= (e); i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define len(x) ((ll)(x).length())
struct mint {
const int mod = 1e9 + 7;
long long x;
mint(long long x = 0) : x((x % mod + mod) % mod) {}
mint &operator=(const long long a) {
x = a % mod;
return *this;
}
mint &operator=(const mint a) {
x = a.x % mod;
return *this;
}
mint &operator+=(const mint a) {
if ((x += a.x) >= mod)
x -= mod;
return *this;
}
mint operator+(const mint a) const {
mint res(*this);
return res += a;
}
mint &operator-=(const mint a) {
if ((x += (mod - a.x)) >= mod)
x -= mod;
return *this;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
mint &operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator*(const mint a) const {
mint res(*this);
return res *= a;
}
mint pow(ll t) const {
if (!t)
return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1)
a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint &operator/=(const mint a) { return (*this) *= a.inv(); }
mint operator/(const mint a) const {
mint res(*this);
return res /= a;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// std::ifstream in("input.txt");
// std::cin.rdbuf(in.rdbuf());
ll n;
cin >> n;
vector<ll> c(n);
rep(i, n) cin >> c[i];
sort(all(c));
vector<mint> e(n + 1);
rep(i, n + 1) {
if (i == 0)
e[i] = 1;
else
e[i] = e[i - 1] * 2;
}
mint ans = 0;
rep(i, n) {
ll l = i, r = n - i - 1;
mint tmp = e[r];
if (r > 0)
tmp += e[r - 1] * r;
tmp *= e[l];
tmp *= c[i];
ans += tmp;
}
ans *= e[n];
cout << ans.x << endl;
return 0;
}
| replace | 99 | 100 | 99 | 105 | -8 | |
p02815 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#define pi acos(-1)
#define p 1000000007
using namespace std;
int N, c[101010];
long long f2[303030], ans, F[101010];
int n, m;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]);
sort(c + 1, c + n + 1);
f2[0] = 1;
for (int i = 1; i <= n; i++)
f2[i] = f2[i - 1] * 2LL % p;
F[0] = 1;
for (int i = 1; i <= n; i++)
F[i] = (2LL * F[i - 1] % p + f2[i - 1]) % p;
for (int i = 1; i <= n; i++)
(ans += 1LL * c[i] * f2[i - 1] % p * F[n - i] % p) %= p;
printf("%lld\n", 1LL * ans * f2[n] % p);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#define pi acos(-1)
#define p 1000000007
using namespace std;
int N, c[201010];
long long f2[303030], ans, F[201010];
int n, m;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]);
sort(c + 1, c + n + 1);
f2[0] = 1;
for (int i = 1; i <= n; i++)
f2[i] = f2[i - 1] * 2LL % p;
F[0] = 1;
for (int i = 1; i <= n; i++)
F[i] = (2LL * F[i - 1] % p + f2[i - 1]) % p;
for (int i = 1; i <= n; i++)
(ans += 1LL * c[i] * f2[i - 1] % p * F[n - i] % p) %= p;
printf("%lld\n", 1LL * ans * f2[n] % p);
return 0;
}
| replace | 7 | 9 | 7 | 9 | 0 | |
p02815 | C++ | Runtime Error | // besmellah
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int maxn = 1e5 + 5, mod = 1e9 + 7;
int P2[maxn], P3[maxn], C[maxn];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
P2[0] = P3[0] = 1;
for (int i = 1; i < maxn; i++) {
P2[i] = P2[i - 1] * 2 % mod;
P3[i] = P3[i - 1] * 4 % mod;
}
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> C[i];
sort(C, C + n);
reverse(C, C + n);
int ans = 0;
for (int i = 0; i < n; i++) {
ans += C[i] * P2[i + 1] % mod * P3[n - i - 1] % mod *
(P2[i] + P2[max(0ll, i - 1)] * i % mod) % mod;
ans %= mod;
// cout << i << ' ' << C[i] << ' ' << ans << endl;
}
cout << ans;
}
| // besmellah
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int maxn = 2e5 + 5, mod = 1e9 + 7;
int P2[maxn], P3[maxn], C[maxn];
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
P2[0] = P3[0] = 1;
for (int i = 1; i < maxn; i++) {
P2[i] = P2[i - 1] * 2 % mod;
P3[i] = P3[i - 1] * 4 % mod;
}
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> C[i];
sort(C, C + n);
reverse(C, C + n);
int ans = 0;
for (int i = 0; i < n; i++) {
ans += C[i] * P2[i + 1] % mod * P3[n - i - 1] % mod *
(P2[i] + P2[max(0ll, i - 1)] * i % mod) % mod;
ans %= mod;
// cout << i << ' ' << C[i] << ' ' << ans << endl;
}
cout << ans;
}
| replace | 6 | 7 | 6 | 7 | 0 | |
p02816 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define int long long
// region TEMPLATE
#define double long double
typedef long long ll;
typedef unsigned long long ull;
template <typename T> void __read(T &a) { cin >> a; }
template <typename T, typename... Args> void __read(T &a, Args &...args) {
cin >> a;
__read(args...);
}
#define make(t, ...) \
t __VA_ARGS__; \
__read(__VA_ARGS__)
#define makev(a, n) \
VI a(n); \
FOR(n) cin >> a[i];
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define FORIT(p) for (auto it = p.begin(); it != p.end(); it++)
#define FOR(b) for (signed i = 0; i < (b); i++)
#define FORE(i, l, r) for (int i = (l); i < (r); i++)
#define NFOR(i, n) for (int i = (((int)n) - 1); i >= 0; i--)
typedef vector<int> VI;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
typedef pair<pair<int, int>, int> PPII;
constexpr ll M7 = 1000000007ll;
constexpr ll M9 = 1000000009ll;
constexpr ll MFFT = 998244353ll;
template <class T> void outv(T &a) {
for (auto &x : a)
cout << x << ' ';
}
static mt19937
rnd(static_cast<unsigned>(chrono::steady_clock::now()
.time_since_epoch()
.count())); // NOLINT(cert-err58-cpp)
template <class T>
static auto __super_speed__ =
(ios_base::sync_with_stdio(0),
cin.tie(
0)); // NOLINT(cert-err58-cpp,cppcoreguidelines-interfaces-global-init)
// endregion
const int MAXN = 200'000;
const int P = 10000 + rnd() % 1000;
int D[MAXN + 1];
void initial() {
D[0] = 1;
for (int i = 1; i <= MAXN; ++i) {
D[i] = (D[i - 1] * P) % M7;
}
}
VI calc_hash(const VI &a) {
VI h(30);
for (int b = 0; b < 30; ++b) {
for (int i = 0; i < a.size(); ++i) {
h[b] = (h[b] + ((a[i] >> b) & 1) * D[i]) % M7;
}
}
return h;
}
int32_t main() {
make(int, n);
makev(a, n);
makev(b, n);
initial();
auto ha = calc_hash(a);
auto hb = calc_hash(b);
int z = accumulate(D, D + n, 0ll) % M7;
for (int i = 0; i < n; ++i) {
int X = a[i] ^ b[0];
VI th = ha;
for (int b = 0; b < 30; ++b) {
if ((X >> b) & 1) {
th[b] = (z - th[b] + M7) % M7;
}
}
cerr << X << endl;
for (int b = 0; b < 5; ++b) {
cerr << th[b] << ' ' << hb[b] << endl;
}
cerr << endl;
if (th == hb) {
cout << i << ' ' << X << '\n';
}
for (int b = 0; b < 30; ++b) {
if ((a[i] >> b) & 1) {
ha[b] = (ha[b] + D[i] * (D[n] + M7 - 1)) % M7;
}
hb[b] = hb[b] * P % M7;
}
z = z * P % M7;
}
return 0;
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define int long long
// region TEMPLATE
#define double long double
typedef long long ll;
typedef unsigned long long ull;
template <typename T> void __read(T &a) { cin >> a; }
template <typename T, typename... Args> void __read(T &a, Args &...args) {
cin >> a;
__read(args...);
}
#define make(t, ...) \
t __VA_ARGS__; \
__read(__VA_ARGS__)
#define makev(a, n) \
VI a(n); \
FOR(n) cin >> a[i];
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define FORIT(p) for (auto it = p.begin(); it != p.end(); it++)
#define FOR(b) for (signed i = 0; i < (b); i++)
#define FORE(i, l, r) for (int i = (l); i < (r); i++)
#define NFOR(i, n) for (int i = (((int)n) - 1); i >= 0; i--)
typedef vector<int> VI;
typedef vector<vector<int>> VVI;
typedef pair<int, int> PII;
typedef pair<pair<int, int>, int> PPII;
constexpr ll M7 = 1000000007ll;
constexpr ll M9 = 1000000009ll;
constexpr ll MFFT = 998244353ll;
template <class T> void outv(T &a) {
for (auto &x : a)
cout << x << ' ';
}
static mt19937
rnd(static_cast<unsigned>(chrono::steady_clock::now()
.time_since_epoch()
.count())); // NOLINT(cert-err58-cpp)
template <class T>
static auto __super_speed__ =
(ios_base::sync_with_stdio(0),
cin.tie(
0)); // NOLINT(cert-err58-cpp,cppcoreguidelines-interfaces-global-init)
// endregion
const int MAXN = 200'000;
const int P = 10000 + rnd() % 1000;
int D[MAXN + 1];
void initial() {
D[0] = 1;
for (int i = 1; i <= MAXN; ++i) {
D[i] = (D[i - 1] * P) % M7;
}
}
VI calc_hash(const VI &a) {
VI h(30);
for (int b = 0; b < 30; ++b) {
for (int i = 0; i < a.size(); ++i) {
h[b] = (h[b] + ((a[i] >> b) & 1) * D[i]) % M7;
}
}
return h;
}
int32_t main() {
make(int, n);
makev(a, n);
makev(b, n);
initial();
auto ha = calc_hash(a);
auto hb = calc_hash(b);
int z = accumulate(D, D + n, 0ll) % M7;
for (int i = 0; i < n; ++i) {
int X = a[i] ^ b[0];
VI th = ha;
for (int b = 0; b < 30; ++b) {
if ((X >> b) & 1) {
th[b] = (z - th[b] + M7) % M7;
}
}
if (th == hb) {
cout << i << ' ' << X << '\n';
}
for (int b = 0; b < 30; ++b) {
if ((a[i] >> b) & 1) {
ha[b] = (ha[b] + D[i] * (D[n] + M7 - 1)) % M7;
}
hb[b] = hb[b] * P % M7;
}
z = z * P % M7;
}
return 0;
} | delete | 119 | 124 | 119 | 119 | TLE | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using i128 = boost::multiprecision::int128_t;
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using ld = long double;
using V = vector<int>;
using Vll = vector<ll>;
using Vld = vector<ld>;
using Vbo = vector<bool>;
using VV = vector<V>;
using VVll = vector<Vll>;
using VVld = vector<Vld>;
using VVbo = vector<Vbo>;
using VVV = vector<VV>;
using VVVll = vector<VVll>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using Pld = pair<ld, ld>;
#define rep2(i, m, n) for (int i = (m); i < (n); ++i)
#define drep2(i, m, n) for (int i = (m)-1; i >= (n); --i)
#define rep(i, n) rep2(i, 0, n)
#define drep(i, n) drep2(i, n, 0)
#define all(a) (a).begin(), (a).end()
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T> inline int sz(T &x) { return x.size(); }
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &e : v)
is >> e;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto &e : v)
os << e << ' ';
return os;
}
template <typename T> inline int count_between(vector<T> &a, T l, T r) {
return lower_bound(all(a), r) - lower_bound(all(a), l);
} // [l, r)
inline int fLog2(const int x) {
return 31 - __builtin_clz(x);
} // floor(log2(x))
inline int fLog2(const ll x) { return 63 - __builtin_clzll(x); }
inline int cLog2(const int x) {
return (x == 1) ? 0 : 32 - __builtin_clz(x - 1);
} // ceil(log2(x))
inline int cLog2(const ll x) {
return (x == 1) ? 0 : 64 - __builtin_clzll(x - 1);
}
inline int popcount(const int x) { return __builtin_popcount(x); }
inline int popcount(const ll x) { return __builtin_popcountll(x); }
const int INF = 1 << 30;
const ll INFll = 1ll << 62;
const ld EPS = 1e-10;
const ld PI = acos(-1.0);
// const int MOD = int(1e9)+7;
// const int MOD = 998244353;
struct RollingHash {
using ui64 = uint64_t;
using ui128 = __uint128_t;
static const ui64 mod = (1ull << 61) - 1;
vector<ui64> hash, power;
ui64 base;
static inline ui64 add(ui64 a, ui64 b) {
if ((a += b) >= mod)
a -= mod;
return a;
}
static inline ui64 mul(ui64 a, ui64 b) {
ui128 c = ui128(a) * b;
return add(c >> 61, c & mod);
}
static inline ui64 generate_base() {
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<ui64> rand(2, mod - 2);
return rand(mt);
}
template <typename T> RollingHash(const T &s, ui64 b = 0) : base(b) {
if (base == 0)
base = generate_base();
int n = s.size();
hash.assign(n + 1, 0);
power.assign(n + 1, 1);
rep(i, n) {
power[i + 1] = mul(power[i], base);
hash[i + 1] = add(mul(hash[i], base), s[i]);
}
}
ui64 get(int l, int r) const {
return add(hash[r], mod - mul(hash[l], power[r - l]));
}
// longest common prefix of s[l1:r1] and s[l2:r2]
int lcp(int l1, int r1, int l2, int r2) const {
int len = min(r1 - l1, r2 - l2);
int ok = 0, ng = len + 1;
while (ng - ok > 1) {
int md = (ok + ng) >> 1;
if (get(l1, l1 + md) == get(l2, l2 + md))
ok = md;
else
ng = md;
}
return ok;
}
};
int main() {
ll n;
cin >> n;
V a(n), b(n);
cin >> a >> b;
V c(n), d(n);
rep(i, n) c[i] = a[i] ^ a[(i + 1) % n];
rep(i, n) d[i] = b[i] ^ b[(i + 1) % n];
copy(all(c), back_inserter(c));
RollingHash rh1(c);
RollingHash rh2(d, rh1.base);
rep(k, n) if (rh1.get(k, k + n) == rh2.get(0, n)) {
cout << k << ' ' << (a[k] ^ b[0]) << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
// #include <boost/multiprecision/cpp_int.hpp>
// using i128 = boost::multiprecision::int128_t;
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using ld = long double;
using V = vector<int>;
using Vll = vector<ll>;
using Vld = vector<ld>;
using Vbo = vector<bool>;
using VV = vector<V>;
using VVll = vector<Vll>;
using VVld = vector<Vld>;
using VVbo = vector<Vbo>;
using VVV = vector<VV>;
using VVVll = vector<VVll>;
using P = pair<int, int>;
using Pll = pair<ll, ll>;
using Pld = pair<ld, ld>;
#define rep2(i, m, n) for (int i = (m); i < (n); ++i)
#define drep2(i, m, n) for (int i = (m)-1; i >= (n); --i)
#define rep(i, n) rep2(i, 0, n)
#define drep(i, n) drep2(i, n, 0)
#define all(a) (a).begin(), (a).end()
struct fast_ios {
fast_ios() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T> inline int sz(T &x) { return x.size(); }
template <typename T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &e : v)
is >> e;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (auto &e : v)
os << e << ' ';
return os;
}
template <typename T> inline int count_between(vector<T> &a, T l, T r) {
return lower_bound(all(a), r) - lower_bound(all(a), l);
} // [l, r)
inline int fLog2(const int x) {
return 31 - __builtin_clz(x);
} // floor(log2(x))
inline int fLog2(const ll x) { return 63 - __builtin_clzll(x); }
inline int cLog2(const int x) {
return (x == 1) ? 0 : 32 - __builtin_clz(x - 1);
} // ceil(log2(x))
inline int cLog2(const ll x) {
return (x == 1) ? 0 : 64 - __builtin_clzll(x - 1);
}
inline int popcount(const int x) { return __builtin_popcount(x); }
inline int popcount(const ll x) { return __builtin_popcountll(x); }
const int INF = 1 << 30;
const ll INFll = 1ll << 62;
const ld EPS = 1e-10;
const ld PI = acos(-1.0);
// const int MOD = int(1e9)+7;
// const int MOD = 998244353;
struct RollingHash {
using ui64 = uint64_t;
using ui128 = __uint128_t;
static const ui64 mod = (1ull << 61) - 1;
vector<ui64> hash, power;
ui64 base;
static inline ui64 add(ui64 a, ui64 b) {
if ((a += b) >= mod)
a -= mod;
return a;
}
static inline ui64 mul(ui64 a, ui64 b) {
ui128 c = ui128(a) * b;
return add(c >> 61, c & mod);
}
static inline ui64 generate_base() {
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<ui64> rand(2, mod - 2);
return rand(mt);
}
template <typename T> RollingHash(const T &s, ui64 b = 0) : base(b) {
if (base == 0)
base = generate_base();
int n = s.size();
hash.assign(n + 1, 0);
power.assign(n + 1, 1);
rep(i, n) {
power[i + 1] = mul(power[i], base);
hash[i + 1] = add(mul(hash[i], base), s[i]);
}
}
ui64 get(int l, int r) const {
return add(hash[r], mod - mul(hash[l], power[r - l]));
}
// longest common prefix of s[l1:r1] and s[l2:r2]
int lcp(int l1, int r1, int l2, int r2) const {
int len = min(r1 - l1, r2 - l2);
int ok = 0, ng = len + 1;
while (ng - ok > 1) {
int md = (ok + ng) >> 1;
if (get(l1, l1 + md) == get(l2, l2 + md))
ok = md;
else
ng = md;
}
return ok;
}
};
int main() {
ll n;
cin >> n;
V a(n), b(n);
cin >> a >> b;
V c(n), d(n);
rep(i, n) c[i] = a[i] ^ a[(i + 1) % n];
rep(i, n) d[i] = b[i] ^ b[(i + 1) % n];
c.insert(c.end(), all(c));
RollingHash rh1(c);
RollingHash rh2(d, rh1.base);
rep(k, n) if (rh1.get(k, k + n) == rh2.get(0, n)) {
cout << k << ' ' << (a[k] ^ b[0]) << '\n';
}
return 0;
}
| replace | 151 | 153 | 151 | 152 | 0 | |
p02816 | C++ | Runtime Error | #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
int n, a[200005], b[200005];
int c[200005], d[200005];
ll m[2][400005];
ll h[2][400005];
ll calc(int aa, int bb) { return c[aa] ^ d[bb]; }
int main() {
cin >> n;
rep(i, n) cin >> c[i];
rep(i, n) cin >> d[i];
rep(i, n) a[i] = (c[(i + 1) % n] ^ c[i]);
rep(i, n) b[i] = (d[(i + 1) % n] ^ d[i]);
rep(i, n) a[n + i] = a[i];
m[0][0] = m[1][0] = 1;
repn(i, 400003) {
m[0][i] = m[0][i - 1] * 37LL % mod;
m[1][i] = m[1][i - 1] * 41LL % mod;
}
rep(i, 2 * n) {
h[0][i] = m[0][i] * a[i];
h[1][i] = m[1][i] * a[i];
if (i)
h[0][i] += h[0][i - 1];
if (i)
h[1][i] += h[1][i - 1];
h[0][i] %= mod;
h[1][i] %= mod;
}
ll sum[2] = {};
rep(i, n) rep(j, 2) { sum[j] = (sum[j] + m[j][i] * b[i]) % mod; }
rep(k, n) {
ll a = h[0][k + n - 1];
if (k)
a -= h[0][k - 1];
ll b = h[1][k + n - 1];
if (k)
b -= h[1][k - 1];
a = (a % mod + mod) % mod;
b = (b % mod + mod) % mod;
ll c = sum[0];
ll d = sum[1];
c = (c * m[0][k] % mod + mod) % mod;
d = (d * m[1][k] % mod + mod) % mod;
if (a == c && b == d) {
cout << k << " " << calc(k, 0) << '\n';
}
}
} | #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define mod 1000000007
#define fi first
#define sc second
#define rep(i, x) for (int i = 0; i < x; i++)
#define repn(i, x) for (int i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
int n, a[400005], b[400005];
int c[400005], d[400005];
ll m[2][400005];
ll h[2][400005];
ll calc(int aa, int bb) { return c[aa] ^ d[bb]; }
int main() {
cin >> n;
rep(i, n) cin >> c[i];
rep(i, n) cin >> d[i];
rep(i, n) a[i] = (c[(i + 1) % n] ^ c[i]);
rep(i, n) b[i] = (d[(i + 1) % n] ^ d[i]);
rep(i, n) a[n + i] = a[i];
m[0][0] = m[1][0] = 1;
repn(i, 400003) {
m[0][i] = m[0][i - 1] * 37LL % mod;
m[1][i] = m[1][i - 1] * 41LL % mod;
}
rep(i, 2 * n) {
h[0][i] = m[0][i] * a[i];
h[1][i] = m[1][i] * a[i];
if (i)
h[0][i] += h[0][i - 1];
if (i)
h[1][i] += h[1][i - 1];
h[0][i] %= mod;
h[1][i] %= mod;
}
ll sum[2] = {};
rep(i, n) rep(j, 2) { sum[j] = (sum[j] + m[j][i] * b[i]) % mod; }
rep(k, n) {
ll a = h[0][k + n - 1];
if (k)
a -= h[0][k - 1];
ll b = h[1][k + n - 1];
if (k)
b -= h[1][k - 1];
a = (a % mod + mod) % mod;
b = (b % mod + mod) % mod;
ll c = sum[0];
ll d = sum[1];
c = (c * m[0][k] % mod + mod) % mod;
d = (d * m[1][k] % mod + mod) % mod;
if (a == c && b == d) {
cout << k << " " << calc(k, 0) << '\n';
}
}
}
| replace | 25 | 27 | 25 | 27 | 0 | |
p02816 | C++ | Runtime Error | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define Endl endl
#define mp make_pair
#define ll long long
#define ull unsinged long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define over(A) \
{ \
cout << A << endl; \
exit(0); \
}
#define all(A) A.begin(), A.end()
#define ceil(a, b) ((a - 1) / b + 1)
#define srand() \
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define rand(l, r) uniform_int_distribution<int>(l, r)(rng)
template <typename T1, typename T2> inline void chmin(T1 &x, T2 b) {
if (b < x)
x = b;
}
template <typename T1, typename T2> inline void chmax(T1 &x, T2 b) {
if (b > x)
x = b;
}
const int inf = 1039074182;
using namespace std;
int n;
int a[200005];
int b[200005];
vector<bool> vec[200005];
bool pattern[200005];
bool c[400005];
int fail[200005];
void build(bool c[], int n) {
int j = fail[0] = -1;
for (int i = 1; i <= n; i++) {
while (j >= 0 && c[i - 1] != c[j])
j = fail[j];
fail[i] = ++j;
}
}
vector<pair<int, int>> solve(int bit) {
bit = 1 << bit;
for (int i = 0; i < n; i++) {
pattern[i] = b[i] & bit;
}
for (int i = 0; i < n; i++) {
c[i] = a[i] & bit;
}
for (int i = n; i < n + n; i++) {
c[i] = c[i - n];
}
build(pattern, n);
vector<pair<int, int>> res;
for (int rev = 0; rev < 2; rev++) {
for (int i = 0, j = 0; i < n + n; i++) {
while (j >= 0 && c[i] != pattern[j])
j = fail[j];
j++;
if (j == n)
res.push_back(mp(i - n + 1, rev)), j = fail[j];
}
for (int i = 0; i < n + n; i++) {
c[i] = c[i] ^ 1;
}
}
return res;
}
int main() {
freopen("input.txt", "r", stdin);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < 30; i++) {
for (auto x : solve(i)) {
vec[x.first].push_back(x.second);
}
}
for (int i = 0; i < n; i++) {
if (vec[i].size() != 30)
continue;
int res = 0;
for (int j = 0; j < 30; j++) {
res |= (vec[i][j] << j);
}
cout << i << ' ' << res << endl;
}
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define Endl endl
#define mp make_pair
#define ll long long
#define ull unsinged long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define over(A) \
{ \
cout << A << endl; \
exit(0); \
}
#define all(A) A.begin(), A.end()
#define ceil(a, b) ((a - 1) / b + 1)
#define srand() \
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define rand(l, r) uniform_int_distribution<int>(l, r)(rng)
template <typename T1, typename T2> inline void chmin(T1 &x, T2 b) {
if (b < x)
x = b;
}
template <typename T1, typename T2> inline void chmax(T1 &x, T2 b) {
if (b > x)
x = b;
}
const int inf = 1039074182;
using namespace std;
int n;
int a[200005];
int b[200005];
vector<bool> vec[200005];
bool pattern[200005];
bool c[400005];
int fail[200005];
void build(bool c[], int n) {
int j = fail[0] = -1;
for (int i = 1; i <= n; i++) {
while (j >= 0 && c[i - 1] != c[j])
j = fail[j];
fail[i] = ++j;
}
}
vector<pair<int, int>> solve(int bit) {
bit = 1 << bit;
for (int i = 0; i < n; i++) {
pattern[i] = b[i] & bit;
}
for (int i = 0; i < n; i++) {
c[i] = a[i] & bit;
}
for (int i = n; i < n + n; i++) {
c[i] = c[i - n];
}
build(pattern, n);
vector<pair<int, int>> res;
for (int rev = 0; rev < 2; rev++) {
for (int i = 0, j = 0; i < n + n; i++) {
while (j >= 0 && c[i] != pattern[j])
j = fail[j];
j++;
if (j == n)
res.push_back(mp(i - n + 1, rev)), j = fail[j];
}
for (int i = 0; i < n + n; i++) {
c[i] = c[i] ^ 1;
}
}
return res;
}
int main() {
// freopen("input.txt","r",stdin);
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
for (int i = 0; i < 30; i++) {
for (auto x : solve(i)) {
vec[x.first].push_back(x.second);
}
}
for (int i = 0; i < n; i++) {
if (vec[i].size() != 30)
continue;
int res = 0;
for (int j = 0; j < 30; j++) {
res |= (vec[i][j] << j);
}
cout << i << ' ' << res << endl;
}
return 0;
} | replace | 86 | 87 | 86 | 87 | 0 | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, M = 2e6;
const int NB = 30;
typedef long long ll;
const ll mod = (1e9 + 7);
int n, a[N], b[N], cnt = 1, g[M][2], fail[M], val[N], track[N][NB];
void newtrie() {
cnt = 0;
g[0][0] = g[0][1] = val[0] = -1;
}
int newnode() {
++cnt;
g[cnt][0] = g[cnt][1] = val[cnt] = -1;
return cnt;
}
void addstr(const string &s, int vval) {
int cur = 0;
for (char x : s) {
int lnk = (x == '0' ? 0 : 1);
if (g[cur][lnk] == -1)
g[cur][lnk] = newnode();
cur = g[cur][lnk];
}
val[cur] = vval;
}
void mklink() {
queue<int> q;
for (int i = 0; i < 2; ++i)
if (g[0][i] != -1) {
fail[g[0][i]] = 0;
q.push(g[0][i]);
}
while (!q.empty()) {
int s = q.front();
q.pop();
for (int i = 0; i < 2; ++i)
if (g[s][i] != -1) {
int state = fail[s];
while (state > 0 && g[state][i] == -1)
state = fail[state];
state = (g[state][i] == -1 ? state : g[state][i]);
fail[g[s][i]] = state;
q.push(g[s][i]);
}
}
}
void aho(string text, vector<int> &x0, vector<int> &x1) {
x0.clear();
x1.clear();
for (int i = 0; i < n - 1; ++i)
text += text[i];
int cur = 0, i = 0;
for (char x : text) {
++i;
int v = (x == '0' ? 0 : 1);
while (cur > 0 && g[cur][v] == -1)
cur = fail[cur];
cur = (g[cur][v] == -1 ? cur : g[cur][v]);
if (val[cur] == 0)
x0.push_back(i - n);
if (val[cur] == 1)
x1.push_back(i - n);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i)
cin >> b[i];
for (int i = 0; i < n; ++i)
fill(track[i], track[i] + NB, -1);
for (int k = 0; k < NB; ++k) {
string A, B, nB;
for (int i = 0; i < n; ++i) {
A += ((a[i] & (1 << k)) ? '1' : '0');
B += ((b[i] & (1 << k)) ? '1' : '0');
nB += ((b[i] & (1 << k)) ? '0' : '1');
}
newtrie();
addstr(B, 0);
addstr(nB, 1);
mklink();
vector<int> x0, x1;
aho(A, x0, x1);
for (int x : x0)
track[x][k] = 0;
for (int x : x1)
track[x][k] = 1;
}
for (int k = 0; k < n; ++k) {
bool emotional = true;
for (int j = 0; j < NB; ++j)
if (track[k][j] == -1) {
emotional = false;
break;
}
if (emotional) {
int x = 0;
for (int j = 0; j < NB; ++j)
if (track[k][j])
x |= (1 << j);
cout << k << " " << x << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10, M = 2e6;
const int NB = 31;
typedef long long ll;
const ll mod = (1e9 + 7);
int n, a[N], b[N], cnt = 1, g[M][2], fail[M], val[N], track[N][NB];
void newtrie() {
cnt = 0;
g[0][0] = g[0][1] = val[0] = -1;
}
int newnode() {
++cnt;
g[cnt][0] = g[cnt][1] = val[cnt] = -1;
return cnt;
}
void addstr(const string &s, int vval) {
int cur = 0;
for (char x : s) {
int lnk = (x == '0' ? 0 : 1);
if (g[cur][lnk] == -1)
g[cur][lnk] = newnode();
cur = g[cur][lnk];
}
val[cur] = vval;
}
void mklink() {
queue<int> q;
for (int i = 0; i < 2; ++i)
if (g[0][i] != -1) {
fail[g[0][i]] = 0;
q.push(g[0][i]);
}
while (!q.empty()) {
int s = q.front();
q.pop();
for (int i = 0; i < 2; ++i)
if (g[s][i] != -1) {
int state = fail[s];
while (state > 0 && g[state][i] == -1)
state = fail[state];
state = (g[state][i] == -1 ? state : g[state][i]);
fail[g[s][i]] = state;
q.push(g[s][i]);
}
}
}
void aho(string text, vector<int> &x0, vector<int> &x1) {
x0.clear();
x1.clear();
for (int i = 0; i < n - 1; ++i)
text += text[i];
int cur = 0, i = 0;
for (char x : text) {
++i;
int v = (x == '0' ? 0 : 1);
while (cur > 0 && g[cur][v] == -1)
cur = fail[cur];
cur = (g[cur][v] == -1 ? cur : g[cur][v]);
if (val[cur] == 0)
x0.push_back(i - n);
if (val[cur] == 1)
x1.push_back(i - n);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i)
cin >> b[i];
for (int i = 0; i < n; ++i)
fill(track[i], track[i] + NB, -1);
for (int k = 0; k < NB; ++k) {
string A, B, nB;
for (int i = 0; i < n; ++i) {
A += ((a[i] & (1 << k)) ? '1' : '0');
B += ((b[i] & (1 << k)) ? '1' : '0');
nB += ((b[i] & (1 << k)) ? '0' : '1');
}
newtrie();
addstr(B, 0);
addstr(nB, 1);
mklink();
vector<int> x0, x1;
aho(A, x0, x1);
for (int x : x0)
track[x][k] = 0;
for (int x : x1)
track[x][k] = 1;
}
for (int k = 0; k < n; ++k) {
bool emotional = true;
for (int j = 0; j < NB; ++j)
if (track[k][j] == -1) {
emotional = false;
break;
}
if (emotional) {
int x = 0;
for (int j = 0; j < NB; ++j)
if (track[k][j])
x |= (1 << j);
cout << k << " " << x << endl;
}
}
} | replace | 2 | 4 | 2 | 4 | 0 | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vint = vector<int>;
using vll = vector<ll>;
template <typename T> using uset = unordered_set<T>;
template <typename T1, typename T2> using umap = unordered_map<T1, T2>;
constexpr int INF = (1 << 30) - 1;
constexpr ll LLINF = 1LL << 60;
constexpr int dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
constexpr int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr char el = '\n';
constexpr int mod = 1000000007;
template <typename T> T gcd(T a, T b) { return (b ? gcd(b, a % b) : a); }
template <typename T> T lcm(T a, T b) { return (a / gcd(a, b) * b); }
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
vint Z_algorithm(vint &W) {
int i = 1, j = 0;
vint Z(W.size());
Z[0] = W.size();
while (i < W.size()) {
while (i + j < W.size() && W[i + j] == W[j])
++j;
Z[i] = j;
if (j == 0) {
++i;
continue;
}
int k = 1;
while (Z[k] + k < j)
Z[i + k] = Z[k], ++k;
i += k, j -= k;
}
return (Z);
}
int main() {
int N;
cin >> N;
vint a(N), b(N);
vint A(N), B(N);
for (auto &v : a)
cin >> v;
for (auto &v : b)
cin >> v;
A = a, B = b;
for (int i = 0; i < N; i++) {
if (i > 0)
A[i - 1] ^= A[i];
}
A[N] ^= a[0];
for (int i = 0; i < N; i++) {
if (i > 0)
B[i - 1] ^= B[i];
}
B.pop_back();
copy(begin(A), end(A), back_inserter(B));
copy(begin(A), end(A), back_inserter(B));
vint ans = Z_algorithm(B);
int cnt = 0;
for (int i = N - 1; i < 2 * N - 1; i++) {
if (ans[i] >= N - 1) {
cout << (i - N + 1) << " " << (a[i - N + 1] ^ b[0]) << el;
}
}
return (0);
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vint = vector<int>;
using vll = vector<ll>;
template <typename T> using uset = unordered_set<T>;
template <typename T1, typename T2> using umap = unordered_map<T1, T2>;
constexpr int INF = (1 << 30) - 1;
constexpr ll LLINF = 1LL << 60;
constexpr int dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
constexpr int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr char el = '\n';
constexpr int mod = 1000000007;
template <typename T> T gcd(T a, T b) { return (b ? gcd(b, a % b) : a); }
template <typename T> T lcm(T a, T b) { return (a / gcd(a, b) * b); }
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
vint Z_algorithm(vint &W) {
int i = 1, j = 0;
vint Z(W.size());
Z[0] = W.size();
while (i < W.size()) {
while (i + j < W.size() && W[i + j] == W[j])
++j;
Z[i] = j;
if (j == 0) {
++i;
continue;
}
int k = 1;
while (Z[k] + k < j)
Z[i + k] = Z[k], ++k;
i += k, j -= k;
}
return (Z);
}
int main() {
int N;
cin >> N;
vint a(N), b(N);
vint A(N), B(N);
for (auto &v : a)
cin >> v;
for (auto &v : b)
cin >> v;
A = a, B = b;
for (int i = 0; i < N; i++) {
if (i > 0)
A[i - 1] ^= A[i];
}
A[N - 1] ^= a[0];
for (int i = 0; i < N; i++) {
if (i > 0)
B[i - 1] ^= B[i];
}
B.pop_back();
copy(begin(A), end(A), back_inserter(B));
copy(begin(A), end(A), back_inserter(B));
vint ans = Z_algorithm(B);
int cnt = 0;
for (int i = N - 1; i < 2 * N - 1; i++) {
if (ans[i] >= N - 1) {
cout << (i - N + 1) << " " << (a[i - N + 1] ^ b[0]) << el;
}
}
return (0);
} | replace | 62 | 63 | 62 | 63 | 0 | |
p02816 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, m, n) for (int i = int(m); i < int(n); i++)
#define all(c) begin(c), end(c)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
// using Int = long long int;
using Int = int;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007
// edit
template <unsigned mod> struct RollingHash {
vector<unsigned> hashed, power;
inline unsigned mul(unsigned a, unsigned b) const {
unsigned long long x = (unsigned long long)a * b;
unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod));
return m;
}
RollingHash(const string &s, unsigned base = 107) {
int sz = (int)s.size();
hashed.assign(sz + 1, 0);
power.assign(sz + 1, 0);
power[0] = 1;
for (int i = 0; i < sz; i++) {
power[i + 1] = mul(power[i], base);
hashed[i + 1] = mul(hashed[i], base) + s[i];
if (hashed[i + 1] >= mod)
hashed[i + 1] -= mod;
}
}
unsigned get(int l, int r) const {
unsigned ret = hashed[r] + mod - mul(hashed[l], power[r - l]);
if (ret >= mod)
ret -= mod;
return ret;
}
unsigned connect(unsigned h1, int h2, int h2len) const {
unsigned ret = mul(h1, power[h2len]) + h2;
if (ret >= mod)
ret -= mod;
return ret;
}
int LCP(const RollingHash<mod> &b, int l1, int r1, int l2, int r2) {
int len = min(r1 - l1, r2 - l2);
int low = -1, high = len + 1;
while (high - low > 1) {
int mid = (low + high) / 2;
if (get(l1, l1 + mid) == b.get(l2, l2 + mid))
low = mid;
else
high = mid;
}
return (low);
}
};
using RH7 = RollingHash<1000000007>;
using RH9 = RollingHash<1000000009>;
class Solve {
public:
Int N;
vector<Int> A, B;
void input() {
cin >> N;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; ++i)
cin >> A[i];
for (int i = 0; i < N; ++i)
cin >> B[i];
}
void input2() {
N = 200000;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; ++i)
A[i] = 81002285;
for (int i = 0; i < N; ++i)
B[i] = 81002285;
}
void solve() {
using RH = pair<RH7, RH9>;
// vector<RH> aRH(32);
// vector<RH> raRH(32); //aRHの反転したもの
// vector<RH> bRH(32);
vector<RH> aRH;
vector<RH> raRH; // aRHの反転したもの
vector<RH> bRH;
double sum_t = 0.0;
clock_t start_t = clock();
for (int i = 0; i < 30; ++i) {
string a, ra, b;
for (int j = 0; j < N; ++j) {
if (A[j] >> i & 1) {
a += '1';
} else {
a += '0';
}
ra += a.back() ^ 1;
if (B[j] >> i & 1) {
b += '1';
} else {
b += '0';
}
}
for (int j = 0; j < N; ++j) {
if (A[j] >> i & 1) {
a += '1';
} else {
a += '0';
}
ra += a.back() ^ 1;
}
// a += a;
// ra += ra;
// aRH[i] = make_pair(RH7(a), RH9(a));
// raRH[i] = make_pair(RH7(ra), RH9(ra));
// bRH[i] = make_pair(RH7(b), RH9(b));
aRH.push_back(make_pair(move(RH7(a)), move(RH9(a))));
// raRH.push_back(make_pair(RH7(ra), RH9(ra)));
// bRH.push_back(make_pair(RH7(b), RH9(b)));
raRH.push_back(make_pair(move(RH7(ra)), move(RH9(ra))));
bRH.push_back(make_pair(move(RH7(b)), move(RH9(b))));
}
clock_t end_t = clock();
sum_t += 1.0 * (end_t - start_t) / CLOCKS_PER_SEC;
vector<pair<Int, Int>> ans;
for (int k = 0; k < N; ++k) {
bool ok = true;
for (int i = 0; i < 30; ++i) {
auto bf = bRH[i].first.get(0, N);
auto bs = bRH[i].second.get(0, N);
bool flag1 = aRH[i].first.get(k, k + N) == bf &&
aRH[i].second.get(k, k + N) == bs;
bool flag2 = raRH[i].first.get(k, k + N) == bf &&
raRH[i].second.get(k, k + N) == bs;
if (!flag1 && !flag2) {
ok = false;
break;
}
}
if (ok) {
Int x = A[k] ^ B[0];
ans.emplace_back(k, x);
}
}
sort(all(ans));
for (auto e : ans) {
// cout << e.first << " " << e.second << endl;
printf("%d %d\n", e.first, e.second);
}
// double uku = sum_t;
// cout << uku << endl;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
// Solve().solve();
Solve solve;
solve.input();
solve.solve();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <climits>
#include <complex>
#include <cstring>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#define rep(i, m, n) for (int i = int(m); i < int(n); i++)
#define all(c) begin(c), end(c)
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
// using Int = long long int;
using Int = int;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007
// edit
template <unsigned mod> struct RollingHash {
vector<unsigned> hashed, power;
inline unsigned mul(unsigned a, unsigned b) const {
unsigned long long x = (unsigned long long)a * b;
unsigned xh = (unsigned)(x >> 32), xl = (unsigned)x, d, m;
asm("divl %4; \n\t" : "=a"(d), "=d"(m) : "d"(xh), "a"(xl), "r"(mod));
return m;
}
RollingHash(const string &s, unsigned base = 107) {
int sz = (int)s.size();
hashed.assign(sz + 1, 0);
power.assign(sz + 1, 0);
power[0] = 1;
for (int i = 0; i < sz; i++) {
power[i + 1] = mul(power[i], base);
hashed[i + 1] = mul(hashed[i], base) + s[i];
if (hashed[i + 1] >= mod)
hashed[i + 1] -= mod;
}
}
unsigned get(int l, int r) const {
unsigned ret = hashed[r] + mod - mul(hashed[l], power[r - l]);
if (ret >= mod)
ret -= mod;
return ret;
}
unsigned connect(unsigned h1, int h2, int h2len) const {
unsigned ret = mul(h1, power[h2len]) + h2;
if (ret >= mod)
ret -= mod;
return ret;
}
int LCP(const RollingHash<mod> &b, int l1, int r1, int l2, int r2) {
int len = min(r1 - l1, r2 - l2);
int low = -1, high = len + 1;
while (high - low > 1) {
int mid = (low + high) / 2;
if (get(l1, l1 + mid) == b.get(l2, l2 + mid))
low = mid;
else
high = mid;
}
return (low);
}
};
using RH7 = RollingHash<1000000007>;
using RH9 = RollingHash<1000000009>;
class Solve {
public:
Int N;
vector<Int> A, B;
void input() {
cin >> N;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; ++i)
cin >> A[i];
for (int i = 0; i < N; ++i)
cin >> B[i];
}
void input2() {
N = 200000;
A.resize(N);
B.resize(N);
for (int i = 0; i < N; ++i)
A[i] = 81002285;
for (int i = 0; i < N; ++i)
B[i] = 81002285;
}
void solve() {
using RH = pair<RH7, RH9>;
// vector<RH> aRH(32);
// vector<RH> raRH(32); //aRHの反転したもの
// vector<RH> bRH(32);
vector<RH> aRH;
vector<RH> raRH; // aRHの反転したもの
vector<RH> bRH;
double sum_t = 0.0;
clock_t start_t = clock();
for (int i = 0; i < 30; ++i) {
string a, ra, b;
for (int j = 0; j < N; ++j) {
if (A[j] >> i & 1) {
a += '1';
} else {
a += '0';
}
ra += a.back() ^ 1;
if (B[j] >> i & 1) {
b += '1';
} else {
b += '0';
}
}
for (int j = 0; j < N; ++j) {
if (A[j] >> i & 1) {
a += '1';
} else {
a += '0';
}
ra += a.back() ^ 1;
}
// a += a;
// ra += ra;
// aRH[i] = make_pair(RH7(a), RH9(a));
// raRH[i] = make_pair(RH7(ra), RH9(ra));
// bRH[i] = make_pair(RH7(b), RH9(b));
aRH.push_back(make_pair(move(RH7(a)), move(RH9(a))));
// raRH.push_back(make_pair(RH7(ra), RH9(ra)));
// bRH.push_back(make_pair(RH7(b), RH9(b)));
raRH.push_back(make_pair(move(RH7(ra)), move(RH9(ra))));
bRH.push_back(make_pair(move(RH7(b)), move(RH9(b))));
}
clock_t end_t = clock();
sum_t += 1.0 * (end_t - start_t) / CLOCKS_PER_SEC;
vector<pair<Int, Int>> ans;
for (int k = 0; k < N; ++k) {
bool ok = true;
for (int i = 0; i < 30; ++i) {
auto bf = bRH[i].first.get(0, N);
// auto bs = bRH[i].second.get(0, N);
// bool flag1 = aRH[i].first.get(k, k + N) == bf &&
// aRH[i].second.get(k, k + N) == bs;
// bool flag2 = raRH[i].first.get(k, k + N) == bf &&
// raRH[i].second.get(k, k + N) == bs;
bool flag1 = aRH[i].first.get(k, k + N) == bf;
bool flag2 = raRH[i].first.get(k, k + N) == bf;
if (!flag1 && !flag2) {
ok = false;
break;
}
}
if (ok) {
Int x = A[k] ^ B[0];
ans.emplace_back(k, x);
}
}
sort(all(ans));
for (auto e : ans) {
// cout << e.first << " " << e.second << endl;
printf("%d %d\n", e.first, e.second);
}
// double uku = sum_t;
// cout << uku << endl;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
// Solve().solve();
Solve solve;
solve.input();
solve.solve();
return 0;
}
| replace | 197 | 203 | 197 | 206 | TLE | |
p02816 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T> using Vvec = vector<vector<T>>;
template <class T> void debug(T &v) {
for (auto &x : v)
cout << x << " ";
cout << endl;
}
// KMP
template <class T> std::vector<int> KMP(T &S) {
std::vector<int> A(S.size());
A[0] = -1;
int j = -1;
for (int i = 0; i < S.size(); i++) {
while (j > -1 && S[j] != S[i])
j = A[j];
j++;
A[i + 1] = j;
}
return A;
}
// detect T from S
template <class Type> std::vector<int> matchedIndex(Type &S, Type &T) {
std::vector<int> ret;
std::vector<int> A = KMP(T);
for (int m = 0, i = 0; m + T.size() <= S.size();) {
while (m + i < S.size() && i < T.size() && S[m + i] == T[i])
i++;
if (i == T.size())
ret.push_back(m);
m += std::max(i - A[i], 1);
i = std::max(A[i], 0);
}
return ret;
}
int main() {
int N;
cin >> N;
vector<int> a(N), b(N);
for (auto &x : a)
cin >> x;
for (auto &x : b)
cin >> x;
a.push_back(a[0]);
b.push_back(b[0]);
vector<int> c(N), d(2 * N);
for (int i = 0; i < N; i++) {
c[i] = a[i] ^ a[i + 1];
d[i] = b[i] ^ b[i + 1];
d[N + i] = d[i];
}
d.pop_back();
vector<int> index = matchedIndex(d, c);
for (auto &k : index) {
k = (N - k) % N;
}
sort(index.begin(), index.end());
for (auto &k : index) {
cout << k << " " << (a[k] ^ b[0]) << endl;
}
} | #include <algorithm>
#include <bitset>
#include <iostream>
#include <queue>
#include <set>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T> using Vvec = vector<vector<T>>;
template <class T> void debug(T &v) {
for (auto &x : v)
cout << x << " ";
cout << endl;
}
// KMP
template <class T> std::vector<int> KMP(T &S) {
std::vector<int> A(S.size() + 1);
A[0] = -1;
int j = -1;
for (int i = 0; i < S.size(); i++) {
while (j > -1 && S[j] != S[i])
j = A[j];
j++;
A[i + 1] = j;
}
return A;
}
// detect T from S
template <class Type> std::vector<int> matchedIndex(Type &S, Type &T) {
std::vector<int> ret;
std::vector<int> A = KMP(T);
for (int m = 0, i = 0; m + T.size() <= S.size();) {
while (m + i < S.size() && i < T.size() && S[m + i] == T[i])
i++;
if (i == T.size())
ret.push_back(m);
m += std::max(i - A[i], 1);
i = std::max(A[i], 0);
}
return ret;
}
int main() {
int N;
cin >> N;
vector<int> a(N), b(N);
for (auto &x : a)
cin >> x;
for (auto &x : b)
cin >> x;
a.push_back(a[0]);
b.push_back(b[0]);
vector<int> c(N), d(2 * N);
for (int i = 0; i < N; i++) {
c[i] = a[i] ^ a[i + 1];
d[i] = b[i] ^ b[i + 1];
d[N + i] = d[i];
}
d.pop_back();
vector<int> index = matchedIndex(d, c);
for (auto &k : index) {
k = (N - k) % N;
}
sort(index.begin(), index.end());
for (auto &k : index) {
cout << k << " " << (a[k] ^ b[0]) << endl;
}
} | replace | 24 | 25 | 24 | 25 | 0 | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define ldb ldouble
// typedef tuple <int, int, int> t3;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<db, db> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
#define siz(x) (int)(x).size()
#define Y second
#define X first
#define IN insert
#define PB push_back
#define P pop_back
#define PU push
#define PO pop
// #define F find
#define ED end()
#define MP(a, b) make_pair(a, b)
// #define MOD 1000000007ll
#define INF 1000000000
#define endl "\n"
#define rep(a, i, b) for (ll i = (a); i < (b); ++i)
#define reps(a, i, b) for (ll i = (a); i <= (b); ++i)
#define repd(num, i, ed) for (ll(i) = (num)-1; (i) >= ed; --(i))
#define repkt(bg, i, num, kt) for (ll(i) = (bg); (i) < (num) && (kt); ++(i))
#define repchar(i) for (char(i) = 48; (i) <= 122; (i)++)
#define in(n) scanf("%lld", &n)
#define out(n) printf("%lld\n", n)
#define outS(s) printf("%s\n", s)
#define setA(a, n) \
for (ll i = 0, j = sizeof(a) / sizeof(a[0]); i < j; ++i) \
a[i] = n;
#define repe(num, i, ed) for (ll(i) = (num); (i) >= ed; --(i))
// const int INF=0x3f3f3f3f;
const db PI = acos(-1);
const ll mod = 1e9 + 7;
const ll N = 2e6 + 5, K = 105;
const int si = (1 << 20);
const ll add = 1e4;
const ll M = 100 + 5;
const double INFdb = 1e10;
int n;
vector<pair<int, int>> ans;
struct rollingHash {
int hash_mod = 1000000007;
int hash = 10007;
vi ha;
vi pow_hash;
rollingHash(const vi &s) {
int nn = (int)s.size();
ha.assign(nn + 1, 0);
pow_hash.assign(nn + 1, 1);
for (int i = 0; i < nn; ++i) {
ha[i + 1] = ((ll)ha[i] * hash + s[i]) % hash_mod;
pow_hash[i + 1] = ((ll)pow_hash[i] * hash) % hash_mod;
}
}
int get(int l, int r) {
return (ha[r] + hash_mod - ((ll)ha[l] * pow_hash[r - l]) % hash_mod) %
hash_mod;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("out.txt", "w", stdout);
#endif
cin >> n;
vi a(n), b(n);
vi xor_a(n * 2), xor_b(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i)
cin >> b[i];
for (int i = 0; i < n; ++i) {
xor_a[i] = a[i] ^ a[(i + 1) % n];
}
for (int i = 0; i < n; ++i) {
xor_b[i] = b[i] ^ b[(i + 1) % n];
}
for (int i = 0; i < n; ++i)
xor_a[i + n] = xor_a[i];
// for(int i=0;i<n;++i) cout<<xor_a[i]<<" ";
rollingHash hash_a(xor_a), hash_b(xor_b);
for (int i = 0; i < n; ++i) {
// cout<<hash_a.get(i,i+n)<<endl;
if (hash_a.get(i, i + n) == hash_b.get(0, n)) {
int x = a[i] ^ b[0];
ans.emplace_back(i, x);
}
}
for (pair<int, int> x : ans) {
cout << x.X << " " << x.Y << endl;
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define ldb ldouble
// typedef tuple <int, int, int> t3;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<db, db> pdd;
typedef vector<int> vi;
typedef vector<ll> vll;
#define siz(x) (int)(x).size()
#define Y second
#define X first
#define IN insert
#define PB push_back
#define P pop_back
#define PU push
#define PO pop
// #define F find
#define ED end()
#define MP(a, b) make_pair(a, b)
// #define MOD 1000000007ll
#define INF 1000000000
#define endl "\n"
#define rep(a, i, b) for (ll i = (a); i < (b); ++i)
#define reps(a, i, b) for (ll i = (a); i <= (b); ++i)
#define repd(num, i, ed) for (ll(i) = (num)-1; (i) >= ed; --(i))
#define repkt(bg, i, num, kt) for (ll(i) = (bg); (i) < (num) && (kt); ++(i))
#define repchar(i) for (char(i) = 48; (i) <= 122; (i)++)
#define in(n) scanf("%lld", &n)
#define out(n) printf("%lld\n", n)
#define outS(s) printf("%s\n", s)
#define setA(a, n) \
for (ll i = 0, j = sizeof(a) / sizeof(a[0]); i < j; ++i) \
a[i] = n;
#define repe(num, i, ed) for (ll(i) = (num); (i) >= ed; --(i))
// const int INF=0x3f3f3f3f;
const db PI = acos(-1);
const ll mod = 1e9 + 7;
const ll N = 2e6 + 5, K = 105;
const int si = (1 << 20);
const ll add = 1e4;
const ll M = 100 + 5;
const double INFdb = 1e10;
int n;
vector<pair<int, int>> ans;
struct rollingHash {
int hash_mod = 1000000007;
int hash = 10007;
vi ha;
vi pow_hash;
rollingHash(const vi &s) {
int nn = (int)s.size();
ha.assign(nn + 1, 0);
pow_hash.assign(nn + 1, 1);
for (int i = 0; i < nn; ++i) {
ha[i + 1] = ((ll)ha[i] * hash + s[i]) % hash_mod;
pow_hash[i + 1] = ((ll)pow_hash[i] * hash) % hash_mod;
}
}
int get(int l, int r) {
return (ha[r] + hash_mod - ((ll)ha[l] * pow_hash[r - l]) % hash_mod) %
hash_mod;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
// #endif
cin >> n;
vi a(n), b(n);
vi xor_a(n * 2), xor_b(n);
for (int i = 0; i < n; ++i)
cin >> a[i];
for (int i = 0; i < n; ++i)
cin >> b[i];
for (int i = 0; i < n; ++i) {
xor_a[i] = a[i] ^ a[(i + 1) % n];
}
for (int i = 0; i < n; ++i) {
xor_b[i] = b[i] ^ b[(i + 1) % n];
}
for (int i = 0; i < n; ++i)
xor_a[i + n] = xor_a[i];
// for(int i=0;i<n;++i) cout<<xor_a[i]<<" ";
rollingHash hash_a(xor_a), hash_b(xor_b);
for (int i = 0; i < n; ++i) {
// cout<<hash_a.get(i,i+n)<<endl;
if (hash_a.get(i, i + n) == hash_b.get(0, n)) {
int x = a[i] ^ b[0];
ans.emplace_back(i, x);
}
}
for (pair<int, int> x : ans) {
cout << x.X << " " << x.Y << endl;
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
} | replace | 83 | 87 | 83 | 87 | 0 |
Time elapsed: 27ms
|
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec)
ndarray(v, args...);
}
template <typename T> bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T> bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
#define dbg(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds; // find_by_order(), order_of_key()
template<typename TK> using pbds_set = tree<TK, null_type, less<TK>,
rb_tree_tag, tree_order_statistics_node_update>; template<typename TK, typename
TV> using pbds_map = tree<TK, TV, less<TK>, rb_tree_tag,
tree_order_statistics_node_update>;
*/
vector<int> z_algorithm(const vector<int> &s) {
vector<int> ans(s.size());
ans[0] = s.size();
int i = 1, j = 0;
while (i < (int)s.size()) {
while (i + j < (int)s.size() && s[j] == s[i + j])
++j;
ans[i] = j;
if (!j) {
++i;
continue;
}
int k = 1;
while (i + k < (int)s.size() && k + ans[k] < j)
ans[i + k] = ans[k], ++k;
i += k;
j -= k;
}
return ans;
}
int main() {
int N;
cin >> N;
vector<int> a(N), b(N);
cin >> a >> b;
vector<int> xx(N * 3 - 1);
xx[N - 1] = -1;
REP(i, N - 1) xx[i] = b[i] ^ b[i + 1];
REP(i, 2 * N) xx[i + N] = a[i % N] ^ a[(i + 1) % N];
vector<int> z = z_algorithm(xx);
REP(i, N) {
if (z[N + i] >= N - 1) {
printf("%d %d\n", i, a[i] ^ b[0]);
}
}
}
| #include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((lint)(x).size())
#define POW2(n) (1LL << (n))
#define FOR(i, begin, end) \
for (int i = (begin), i##_end_ = (end); i < i##_end_; i++)
#define IFOR(i, begin, end) \
for (int i = (end)-1, i##_begin_ = (begin); i >= i##_begin_; i--)
#define REP(i, n) FOR(i, 0, n)
#define IREP(i, n) IFOR(i, 0, n)
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec)
is >> v;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec)
os << v << ",";
os << "]";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec)
os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp)
os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec)
ndarray(v, args...);
}
template <typename T> bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T> bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
#define dbg(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ") " << __FILE__ << endl;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds; // find_by_order(), order_of_key()
template<typename TK> using pbds_set = tree<TK, null_type, less<TK>,
rb_tree_tag, tree_order_statistics_node_update>; template<typename TK, typename
TV> using pbds_map = tree<TK, TV, less<TK>, rb_tree_tag,
tree_order_statistics_node_update>;
*/
vector<int> z_algorithm(const vector<int> &s) {
vector<int> ans(s.size());
ans[0] = s.size();
int i = 1, j = 0;
while (i < (int)s.size()) {
while (i + j < (int)s.size() && s[j] == s[i + j])
++j;
ans[i] = j;
if (!j) {
++i;
continue;
}
int k = 1;
while (i + k < (int)s.size() && k + ans[k] < j)
ans[i + k] = ans[k], ++k;
i += k;
j -= k;
}
return ans;
}
int main() {
int N;
cin >> N;
vector<int> a(N), b(N);
cin >> a >> b;
vector<int> xx(N * 3);
xx[N - 1] = -1;
REP(i, N - 1) xx[i] = b[i] ^ b[i + 1];
REP(i, 2 * N) xx[i + N] = a[i % N] ^ a[(i + 1) % N];
vector<int> z = z_algorithm(xx);
REP(i, N) {
if (z[N + i] >= N - 1) {
printf("%d %d\n", i, a[i] ^ b[0]);
}
}
}
| replace | 158 | 159 | 158 | 159 | 0 | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int h = 126257;
const int mod = 1e9 + 7;
int a[200001], b[400001];
LL p[400001];
int A[30][400001];
int B[2][30][200001];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
scanf("%d", &b[i]);
for (int i = n + 1; i <= n + n; i++)
a[i] = a[i - n];
p[0] = 1;
for (int i = 1; i <= n + n; i++)
p[i] = p[i - 1] * h % mod;
for (int i = 1; i <= n + n; i++) {
for (int j = 0; j < 30; j++) {
A[j][i] = (A[j][i - 1] + ((a[i] >> j) & 1) * p[i]) % mod;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 30; j++) {
B[0][j][i] = (B[0][j][i - 1] + ((b[i] >> j) & 1) * p[i]) % mod;
B[1][j][i] = (B[1][j][i - 1] + ((1 - ((b[i] >> j) & 1)) * p[i])) % mod;
}
}
for (int i = 1; i <= n; i++) {
int x = a[i] ^ b[1];
bool ok = 1;
for (int j = 0; j < 30; j++) {
if ((x >> j) & 1) {
int Pa = (A[j][i + n - 1] - A[j][i - 1] + mod) % mod *
p[n + n - (i + n - 1)] % mod;
int Pb = B[1][j][n] * p[n + n - n] % mod;
if (Pa != Pb) {
ok = 0;
break;
}
} else {
int Pa = (A[j][i + n - 1] - A[j][i - 1] + mod) % mod *
p[n + n - (i + n - 1)] % mod;
int Pb = B[0][j][n] * p[n + n - n] % mod;
if (Pa != Pb) {
ok = 0;
break;
}
}
}
if (ok)
printf("%d %d\n", i - 1, x);
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int h = 126257;
const int mod = 1e9 + 7;
int a[400001], b[200001];
LL p[400001];
int A[30][400001];
int B[2][30][200001];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (int i = 1; i <= n; i++)
scanf("%d", &b[i]);
for (int i = n + 1; i <= n + n; i++)
a[i] = a[i - n];
p[0] = 1;
for (int i = 1; i <= n + n; i++)
p[i] = p[i - 1] * h % mod;
for (int i = 1; i <= n + n; i++) {
for (int j = 0; j < 30; j++) {
A[j][i] = (A[j][i - 1] + ((a[i] >> j) & 1) * p[i]) % mod;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 30; j++) {
B[0][j][i] = (B[0][j][i - 1] + ((b[i] >> j) & 1) * p[i]) % mod;
B[1][j][i] = (B[1][j][i - 1] + ((1 - ((b[i] >> j) & 1)) * p[i])) % mod;
}
}
for (int i = 1; i <= n; i++) {
int x = a[i] ^ b[1];
bool ok = 1;
for (int j = 0; j < 30; j++) {
if ((x >> j) & 1) {
int Pa = (A[j][i + n - 1] - A[j][i - 1] + mod) % mod *
p[n + n - (i + n - 1)] % mod;
int Pb = B[1][j][n] * p[n + n - n] % mod;
if (Pa != Pb) {
ok = 0;
break;
}
} else {
int Pa = (A[j][i + n - 1] - A[j][i - 1] + mod) % mod *
p[n + n - (i + n - 1)] % mod;
int Pb = B[0][j][n] * p[n + n - n] % mod;
if (Pa != Pb) {
ok = 0;
break;
}
}
}
if (ok)
printf("%d %d\n", i - 1, x);
}
} | replace | 5 | 6 | 5 | 6 | 127 | /tmp/2b443849-766a-4a6d-8ba6-7df974683448.out: error while loading shared libraries: libc.so.6: failed to map segment from shared object
|
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
using namespace std;
typedef long long ll;
typedef double db;
typedef long double ldb;
template <class T> inline void checkmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <class T> inline void checkmax(T &a, const T &b) {
if (b > a)
a = b;
}
const int inf = 1e9 + 10;
const int maxn = 1e5 + 10;
const ll base = 1e9 + 7;
const ll mod = 2038077799;
ll ha, hb, a[maxn], b[maxn], difa[maxn], difb[maxn];
int n;
ll getval(ll x, ll k, ll mod) {
if (k == 0)
return 1ll;
if (k == 1)
return x;
ll res = getval(x, k / 2, mod);
res = (res * res) % mod;
if (k & 1)
res = (res * x) % mod;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%lld", &a[i]);
for (int i = 0; i < n; i++)
scanf("%lld", &b[i]);
for (int i = 0; i < n; i++)
difa[i] = a[i] ^ a[(i + 1) % n];
for (int i = 0; i < n; i++)
difb[i] = b[i] ^ b[(i + 1) % n];
ha = hb = 0;
for (int i = 0; i < n; i++) {
ha *= base;
ha %= mod;
ha += difa[i];
ha %= mod;
}
for (int i = 0; i < n; i++) {
hb *= base;
hb %= mod;
hb += difb[i];
hb %= mod;
}
ll val = getval(base, n - 1, mod);
vector<int> ans;
for (int i = 0; i < n; i++) {
if (ha == hb) {
ans.pb(i);
}
ll now = val * difa[i];
now %= mod;
ha += mod - now;
ha %= mod;
ha *= base;
ha %= mod;
ha += difa[i];
ha %= mod;
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " " << (a[0] ^ b[(n - ans[i]) % n]) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define fst first
#define snd second
using namespace std;
typedef long long ll;
typedef double db;
typedef long double ldb;
template <class T> inline void checkmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <class T> inline void checkmax(T &a, const T &b) {
if (b > a)
a = b;
}
const int inf = 1e9 + 10;
const int maxn = 2e5 + 10;
const ll base = 1e9 + 7;
const ll mod = 2038077799;
ll ha, hb, a[maxn], b[maxn], difa[maxn], difb[maxn];
int n;
ll getval(ll x, ll k, ll mod) {
if (k == 0)
return 1ll;
if (k == 1)
return x;
ll res = getval(x, k / 2, mod);
res = (res * res) % mod;
if (k & 1)
res = (res * x) % mod;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%lld", &a[i]);
for (int i = 0; i < n; i++)
scanf("%lld", &b[i]);
for (int i = 0; i < n; i++)
difa[i] = a[i] ^ a[(i + 1) % n];
for (int i = 0; i < n; i++)
difb[i] = b[i] ^ b[(i + 1) % n];
ha = hb = 0;
for (int i = 0; i < n; i++) {
ha *= base;
ha %= mod;
ha += difa[i];
ha %= mod;
}
for (int i = 0; i < n; i++) {
hb *= base;
hb %= mod;
hb += difb[i];
hb %= mod;
}
ll val = getval(base, n - 1, mod);
vector<int> ans;
for (int i = 0; i < n; i++) {
if (ha == hb) {
ans.pb(i);
}
ll now = val * difa[i];
now %= mod;
ha += mod - now;
ha %= mod;
ha *= base;
ha %= mod;
ha += difa[i];
ha %= mod;
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << " " << (a[0] ^ b[(n - ans[i]) % n]) << endl;
}
return 0;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p02816 | C++ | Time Limit Exceeded | /*
AuThOr GaRyMr
*/
#include <bits/stdc++.h>
#define rb(a, b, c) for (int a = b; a <= c; ++a)
#define rl(a, b, c) for (int a = b; a >= c; --a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a, b) make_pair(a, b)
#define FIR first
#define SEC second
#define FREO freopen("check.out", "w", stdout)
#define rep(a, b) for (int a = 0; a < b; ++a)
#define KEEP while (1)
#define SRAND \
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng() % a
#define ALL(a) a.begin(), a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
using namespace std;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> mp;
typedef pair<mp, mp> superpair;
vector<int> each[30];
int n, bit[200000 + 1][30];
int z[700000 + 1];
string b[30];
void z_function(string S) {
// cout<<S<<endl;
int len = S.length();
S = '$' + S;
int l, r;
memset(z, 0, sizeof(z));
rb(i, 2, len) if (S[i] != S[i - 1]) break;
else z[2]++;
l = 2, r = z[2] + 1;
rb(i, 3, len) {
if (i <= r) {
z[i] = z[i - (l) + 1];
z[i] = min(z[i], r - i + 1);
if (z[i] + i - 1 == r) {
int ite = z[i] + 1;
rb(j, r + 1, len) {
if (S[j] != S[ite++])
break;
z[i]++;
}
l = i, r = i + z[i] - 1;
}
} else {
int ite = 1;
rb(j, i, len) {
if (S[j] != S[ite++])
break;
z[i]++;
}
l = i, r = i + z[i] - 1;
}
}
}
int a[200000 + 1], sb[200000 + 1];
void run(int is) {
string A = "";
rb(i, 1, n) A = A + char('0' + bit[i][is]);
z_function(A + '&' + b[is] + b[is]);
rb(i, n + 3, n + 2 + n) {
if (z[i] == n) {
each[is].PB(n + 2 + n - i);
}
}
rb(i, 1, n) if (A[i - 1] == '0') A[i - 1] = '1';
else A[i - 1] = '0';
z_function(A + '&' + b[is] + b[is]);
rb(i, n + 3, n + 2 + n) {
if (z[i] == n) {
each[is].PB(n + 2 + n - i);
}
}
}
int main() {
fastio;
cin >> n;
rb(i, 1, n) {
int ai;
cin >> ai;
a[i] = ai;
rep(j, 30) { bit[i][j] = bool(ai & (1 << j)); }
}
rep(i, 30) b[i] = ""; // return 0;
rb(i, 1, n) {
int bi;
cin >> bi;
sb[i] = bi;
rep(j, 30) { b[j] += char('0' + (bool)(bi & (1 << j))); }
}
rep(i, 30) {
run(i);
sort(ALL(each[i]));
}
rep(i, n) {
int ok = 1;
rep(j, 30) {
if (binary_search(ALL(each[j]), i)) {
} else
ok = 0;
}
if (ok)
cout << i << " " << (a[1 + i] ^ sb[1]) << endl;
}
return 0;
}
| /*
AuThOr GaRyMr
*/
#include <bits/stdc++.h>
#define rb(a, b, c) for (int a = b; a <= c; ++a)
#define rl(a, b, c) for (int a = b; a >= c; --a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a, b) make_pair(a, b)
#define FIR first
#define SEC second
#define FREO freopen("check.out", "w", stdout)
#define rep(a, b) for (int a = 0; a < b; ++a)
#define KEEP while (1)
#define SRAND \
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng() % a
#define ALL(a) a.begin(), a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
using namespace std;
const int INF = 0x3f3f3f3f;
typedef pair<int, int> mp;
typedef pair<mp, mp> superpair;
vector<int> each[30];
int n, bit[200000 + 1][30];
int z[700000 + 1];
string b[30];
void z_function(string S) {
// cout<<S<<endl;
int len = S.length();
S = '$' + S;
int l, r;
memset(z, 0, sizeof(z));
rb(i, 2, len) if (S[i] != S[i - 1]) break;
else z[2]++;
l = 2, r = z[2] + 1;
rb(i, 3, len) {
if (i <= r) {
z[i] = z[i - (l) + 1];
z[i] = min(z[i], r - i + 1);
if (z[i] + i - 1 == r) {
int ite = z[i] + 1;
rb(j, r + 1, len) {
if (S[j] != S[ite++])
break;
z[i]++;
}
l = i, r = i + z[i] - 1;
}
} else {
int ite = 1;
rb(j, i, len) {
if (S[j] != S[ite++])
break;
z[i]++;
}
l = i, r = i + z[i] - 1;
}
}
}
int a[200000 + 1], sb[200000 + 1];
void run(int is) {
string A = "";
rb(i, 1, n) A += char('0' + bit[i][is]);
z_function(A + '&' + b[is] + b[is]);
rb(i, n + 3, n + 2 + n) {
if (z[i] == n) {
each[is].PB(n + 2 + n - i);
}
}
rb(i, 1, n) if (A[i - 1] == '0') A[i - 1] = '1';
else A[i - 1] = '0';
z_function(A + '&' + b[is] + b[is]);
rb(i, n + 3, n + 2 + n) {
if (z[i] == n) {
each[is].PB(n + 2 + n - i);
}
}
}
int main() {
fastio;
cin >> n;
rb(i, 1, n) {
int ai;
cin >> ai;
a[i] = ai;
rep(j, 30) { bit[i][j] = bool(ai & (1 << j)); }
}
rep(i, 30) b[i] = ""; // return 0;
rb(i, 1, n) {
int bi;
cin >> bi;
sb[i] = bi;
rep(j, 30) { b[j] += char('0' + (bool)(bi & (1 << j))); }
}
rep(i, 30) {
run(i);
sort(ALL(each[i]));
}
rep(i, n) {
int ok = 1;
rep(j, 30) {
if (binary_search(ALL(each[j]), i)) {
} else
ok = 0;
}
if (ok)
cout << i << " " << (a[1 + i] ^ sb[1]) << endl;
}
return 0;
}
| replace | 66 | 67 | 66 | 67 | TLE | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using u64 = std::uint_fast64_t;
class RollingHash {
private:
using u64 = std::uint_fast64_t;
const u64 mod = ((u64)1 << 61) - 1;
std::vector<u64> hashes, pows;
inline u64 add(u64 a, u64 b) const {
a += b;
if (a >= mod)
a -= mod;
return a;
}
inline u64 sub(u64 a, u64 b) const {
if (a < b)
a += mod;
a -= b;
return a;
}
inline u64 mul(u64 a, u64 b) const {
u64 ah = a >> 31, al = a & (((u64)1 << 31) - 1), bh = b >> 31,
bl = b & (((u64)1 << 31) - 1), m = ah * bl + al * bh,
v = (ah * bh << 1) + (m >> 30) + ((m & (((u64)1 << 30) - 1)) << 31) +
al * bl;
v = (v & (((u64)1 << 61) - 1)) + (v >> 61);
return v;
}
public:
template <typename T>
RollingHash(const T &S, u64 base = 10007)
: hashes(S.size() + 1, 0), pows(S.size() + 1, 0) {
pows[0] = 1;
for (size_t i = 0; i < S.size(); i++) {
pows[i + 1] = mul(pows[i], base);
hashes[i + 1] = add(mul(hashes[i], base), S[i]);
}
}
// S[r, l)
u64 slice(int l, int r) const {
return sub(hashes[r], mul(hashes[l], pows[r - l]));
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<u64> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
vector<u64> S(N), T(N);
for (int i = 0; i < N; i++) {
S[i] = A[i] ^ A[(i + 1) % N];
T[i] = B[i] ^ B[(i + 1) % N];
}
copy(S.begin(), S.end(), back_inserter(S));
RollingHash rhs(S), rht(T);
for (int i = 0; i < N; i++) {
if (rhs.slice(i, i + N) == rht.slice(0, N)) {
cout << i << " " << (A[i] ^ B[0]) << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using u64 = std::uint_fast64_t;
class RollingHash {
private:
using u64 = std::uint_fast64_t;
const u64 mod = ((u64)1 << 61) - 1;
std::vector<u64> hashes, pows;
inline u64 add(u64 a, u64 b) const {
a += b;
if (a >= mod)
a -= mod;
return a;
}
inline u64 sub(u64 a, u64 b) const {
if (a < b)
a += mod;
a -= b;
return a;
}
inline u64 mul(u64 a, u64 b) const {
u64 ah = a >> 31, al = a & (((u64)1 << 31) - 1), bh = b >> 31,
bl = b & (((u64)1 << 31) - 1), m = ah * bl + al * bh,
v = (ah * bh << 1) + (m >> 30) + ((m & (((u64)1 << 30) - 1)) << 31) +
al * bl;
v = (v & (((u64)1 << 61) - 1)) + (v >> 61);
return v;
}
public:
template <typename T>
RollingHash(const T &S, u64 base = 10007)
: hashes(S.size() + 1, 0), pows(S.size() + 1, 0) {
pows[0] = 1;
for (size_t i = 0; i < S.size(); i++) {
pows[i + 1] = mul(pows[i], base);
hashes[i + 1] = add(mul(hashes[i], base), S[i]);
}
}
// S[r, l)
u64 slice(int l, int r) const {
return sub(hashes[r], mul(hashes[l], pows[r - l]));
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<u64> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
vector<u64> S(N), T(N);
for (int i = 0; i < N; i++) {
S[i] = A[i] ^ A[(i + 1) % N];
T[i] = B[i] ^ B[(i + 1) % N];
}
for (int i = 0; i < N; i++) {
S.emplace_back(S[i]);
}
RollingHash rhs(S), rht(T);
for (int i = 0; i < N; i++) {
if (rhs.slice(i, i + N) == rht.slice(0, N)) {
cout << i << " " << (A[i] ^ B[0]) << '\n';
}
}
return 0;
}
| replace | 70 | 71 | 70 | 73 | 0 | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
class RollingHash {
private:
const uint64_t mod = (1ULL << 61) - 1;
std::vector<uint64_t> hashes, pows;
inline uint64_t add(uint64_t a, uint64_t b) const {
a += b;
if (a >= mod)
a -= mod;
return a;
}
inline uint64_t sub(uint64_t a, uint64_t b) const {
if (a < b)
a += mod;
a -= b;
return a;
}
inline uint64_t mul(uint64_t a, uint64_t b) const {
uint64_t ah = a >> 31, al = a & ((1ULL << 31) - 1), bh = b >> 31,
bl = b & ((1ULL << 31) - 1), m = ah * bl + al * bh,
v = (ah * bh << 1) + (m >> 30) + ((m & ((1ULL << 30) - 1)) << 31) +
al * bl;
v = (v & ((1ULL << 61) - 1)) + (v >> 61);
return v;
}
public:
template <typename T>
RollingHash(const T &S, uint64_t base = 10007)
: hashes(S.size() + 1, 0), pows(S.size() + 1, 0) {
pows[0] = 1;
for (size_t i = 0; i < S.size(); i++) {
pows[i + 1] = mul(pows[i], base);
hashes[i + 1] = add(mul(hashes[i], base), S[i]);
}
}
// S[r, l)
uint64_t slice(int l, int r) const {
return sub(hashes[r], mul(hashes[l], pows[r - l]));
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
vector<int> C(N), D(N);
for (int i = 0; i < N; i++) {
C[i] = A[i] ^ A[(i + 1) % N];
D[i] = B[i] ^ B[(i + 1) % N];
}
for (int c : C) {
C.emplace_back(c);
}
RollingHash rhc(C), rhd(D);
for (int i = 0; i < N; i++) {
if (rhc.slice(i, i + N) == rhd.slice(0, N)) {
cout << i << ' ' << (A[i] ^ B[0]) << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
class RollingHash {
private:
const uint64_t mod = (1ULL << 61) - 1;
std::vector<uint64_t> hashes, pows;
inline uint64_t add(uint64_t a, uint64_t b) const {
a += b;
if (a >= mod)
a -= mod;
return a;
}
inline uint64_t sub(uint64_t a, uint64_t b) const {
if (a < b)
a += mod;
a -= b;
return a;
}
inline uint64_t mul(uint64_t a, uint64_t b) const {
uint64_t ah = a >> 31, al = a & ((1ULL << 31) - 1), bh = b >> 31,
bl = b & ((1ULL << 31) - 1), m = ah * bl + al * bh,
v = (ah * bh << 1) + (m >> 30) + ((m & ((1ULL << 30) - 1)) << 31) +
al * bl;
v = (v & ((1ULL << 61) - 1)) + (v >> 61);
return v;
}
public:
template <typename T>
RollingHash(const T &S, uint64_t base = 10007)
: hashes(S.size() + 1, 0), pows(S.size() + 1, 0) {
pows[0] = 1;
for (size_t i = 0; i < S.size(); i++) {
pows[i + 1] = mul(pows[i], base);
hashes[i + 1] = add(mul(hashes[i], base), S[i]);
}
}
// S[r, l)
uint64_t slice(int l, int r) const {
return sub(hashes[r], mul(hashes[l], pows[r - l]));
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> A(N), B(N);
for (int i = 0; i < N; i++) {
cin >> A[i];
}
for (int i = 0; i < N; i++) {
cin >> B[i];
}
vector<int> C(N), D(N);
for (int i = 0; i < N; i++) {
C[i] = A[i] ^ A[(i + 1) % N];
D[i] = B[i] ^ B[(i + 1) % N];
}
for (int i = 0; i < N; i++) {
C.emplace_back(C[i]);
}
RollingHash rhc(C), rhd(D);
for (int i = 0; i < N; i++) {
if (rhc.slice(i, i + N) == rhd.slice(0, N)) {
cout << i << ' ' << (A[i] ^ B[0]) << '\n';
}
}
return 0;
}
| replace | 66 | 68 | 66 | 68 | 0 | |
p02816 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
};
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<mod>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main() {
iosetup;
int N;
cin >> N;
vector<int> a(N), b(N);
rep(i, 0, N) cin >> a[i];
rep(i, 0, N) cin >> b[i];
bool flag = 0;
rep(i, 0, N) {
if (!flag) {
if ((a[i] ^ b[0]) == (a[(i + 1) % N] ^ b[1])) {
int x = a[i] ^ b[0];
rep(j, 0, N) {
if ((a[(i + j) % N] ^ x) != b[j]) {
return 0;
}
}
cout << i << " " << x << endl;
}
} else {
int x = (a[i] ^ b[0]);
if (x == (a[(i + 1) % N] ^ b[1])) {
cout << i << " " << x << endl;
}
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = b - 1; i >= a; i--)
#define ALL(a) a.begin(), a.end()
#define pii pair<int, int>
#pragma GCC optimize("Ofast")
#define pcnt __builtin_popcount
#define buli(x) __builtin_popcountll(x)
#define pb push_back
#define mp make_pair
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
};
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
};
inline void IN(void) { return; }
template <typename First, typename... Rest>
void IN(First &first, Rest &...rest) {
cin >> first;
IN(rest...);
return;
}
inline void OUT(void) {
cout << "\n";
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest) {
cout << first << " ";
OUT(rest...);
return;
}
const double EPS = 1e-9;
const int mod = 1e9 + 7;
const int INF = 1e9;
const long long LLINF = 1e18;
long long lcm(ll a, ll b) { return a * b / __gcd(a, b); }
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
template <int mod> struct ModInt {
int x;
ModInt() : x(0) {}
ModInt(int64_t y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}
ModInt &operator+=(const ModInt &p) {
if ((x += p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator-=(const ModInt &p) {
if ((x += mod - p.x) >= mod)
x -= mod;
return *this;
}
ModInt &operator*=(const ModInt &p) {
x = (int)(1LL * x * p.x % mod);
return *this;
}
ModInt &operator/=(const ModInt &p) {
*this *= p.inverse();
return *this;
}
ModInt operator-() const { return ModInt(-x); }
ModInt operator+(const ModInt &p) const { return ModInt(*this) += p; }
ModInt operator-(const ModInt &p) const { return ModInt(*this) -= p; }
ModInt operator*(const ModInt &p) const { return ModInt(*this) *= p; }
ModInt operator/(const ModInt &p) const { return ModInt(*this) /= p; }
bool operator==(const ModInt &p) const { return x == p.x; }
bool operator!=(const ModInt &p) const { return x != p.x; }
ModInt inverse() const {
int a = x, b = mod, u = 1, v = 0, t;
while (b > 0) {
t = a / b;
swap(a -= t * b, b);
swap(u -= t * v, v);
}
return ModInt(u);
}
ModInt pow(int64_t n) const {
ModInt ret(1), mul(x);
while (n > 0) {
if (n & 1)
ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
friend ostream &operator<<(ostream &os, const ModInt &p) { return os << p.x; }
friend istream &operator>>(istream &is, ModInt &a) {
int64_t t;
is >> t;
a = ModInt<mod>(t);
return (is);
}
static int get_mod() { return mod; }
};
using modint = ModInt<mod>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main() {
iosetup;
int N;
cin >> N;
vector<int> a(N), b(N);
rep(i, 0, N) cin >> a[i];
rep(i, 0, N) cin >> b[i];
bool flag = 0;
rep(i, 0, N) {
if (!flag) {
if ((a[i] ^ b[0]) == (a[(i + 1) % N] ^ b[1])) {
int x = a[i] ^ b[0];
rep(j, 0, N) {
if ((a[(i + j) % N] ^ x) != b[j]) {
return 0;
}
}
flag = true;
cout << i << " " << x << endl;
}
} else {
int x = (a[i] ^ b[0]);
if (x == (a[(i + 1) % N] ^ b[1])) {
cout << i << " " << x << endl;
}
}
}
return 0;
} | insert | 136 | 136 | 136 | 137 | TLE | |
p02816 | C++ | Time Limit Exceeded | #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define pb(a) push_back
#define print(x) cout << (x) << endl
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), n)
#define ub(v, n) upper_bound(v.begin(), v.end(), n)
// #define int long long
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> P;
const int MOD = 998244353;
const int MAX = 200020;
const double pi = acos(-1);
const double EPS = 1e-12;
const ll INF = 2e18;
bool cnt[2][200020][33];
template <typename T, T MOD1, T MOD2, T B1, T B2> struct RollingHash {
vector<T> hash[2], p[2];
T MOD[2] = {MOD1, MOD2};
T B[2] = {B1, B2};
// RollingHash(const string &s) {
// int N = s.size();
// for (int k = 0; k < 2; k++) {
// hash[k].assign(N + 1, 0);
// p[k].assign(N + 1, 1);
// for (int i = 0; i < N; i++) {
// hash[k][i + 1] = (hash[k][i] * B[k] + s[i]) % MOD[k];
// p[k][i + 1] = p[k][i] * B[k] % MOD[k];
// }
// }
// }
void init(const string &s) {
int N = s.size();
for (int k = 0; k < 2; k++) {
hash[k].assign(N + 1, 0);
p[k].assign(N + 1, 1);
for (int i = 0; i < N; i++) {
hash[k][i + 1] = (hash[k][i] * B[k] + s[i]) % MOD[k];
p[k][i + 1] = p[k][i] * B[k] % MOD[k];
}
}
}
// S[l,r)
pair<T, T> find(int l, int r) {
T res1 = hash[0][r] + MOD[0] - hash[0][l] * p[0][r - l] % MOD[0];
res1 = (res1 >= MOD[0]) ? res1 - MOD[0] : res1;
T res2 = hash[1][r] + MOD[1] - hash[1][l] * p[1][r - l] % MOD[1];
res2 = (res2 >= MOD[1]) ? res2 - MOD[1] : res2;
return make_pair(res1, res2);
}
T find1(int l, int r) {
T res1 = hash[0][r] + MOD[0] - hash[0][l] * p[0][r - l] % MOD[0];
return (res1 >= MOD[0]) ? res1 - MOD[0] : res1;
}
T find2(int l, int r) {
T res2 = hash[1][r] + MOD[1] - hash[1][l] * p[1][r - l] % MOD[1];
return (res2 >= MOD[1]) ? res2 - MOD[1] : res2;
}
};
using RH = RollingHash<ll, (ll)1e9 + 7, (ll)1e9 + 9, 1234567, 7654343>;
// RH rh(S);
RH rhS[30], rhT[30], rhTrev[30];
int A[200020], B[200020];
string S[30], T[30], Trev[30];
void solve() {
int N;
cin >> N;
REP(i, N) cin >> A[i];
REP(i, N) cin >> B[i];
REP(i, N) {
REP(j, 30) {
if (A[i] & (1 << j))
cnt[0][i][j] = 1;
if (B[i] & (1 << j))
cnt[1][i][j] = 1;
}
}
bool found = false;
REP(j, 30) {
REP(i, N) {
if (cnt[0][i][j])
S[j] += '1';
else
S[j] += '0';
if (cnt[1][i][j]) {
T[j] += '1';
Trev[j] += '0';
} else {
T[j] += '0';
Trev[j] += '1';
}
}
}
// using RH = RollingHash<ll, (ll)1e9 + 7, (ll)1e9 + 9, 1234567, 7654343>;
REP(j, 30) {
rhS[j].init(S[j]);
rhT[j].init(T[j]);
rhTrev[j].init(Trev[j]);
}
ll ans = 0;
vector<P> v;
int k = 0;
int c = N - k;
REP(j, 30) {
if ((rhS[j].find1(0, N - k) == rhT[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhT[j].find1(0, k)) ||
(rhS[j].find1(0, N - k) == rhTrev[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhTrev[j].find1(0, k))) {
} else
goto END2;
}
pe(0);
print(B[0] ^ A[0]);
END2:
FORR(k, N, 1) {
c = N - k;
REP(j, 30) {
if ((rhS[j].find1(0, N - k) == rhT[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhT[j].find1(0, k)) ||
(rhS[j].find1(0, N - k) == rhTrev[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhTrev[j].find1(0, k))) {
} else
goto END;
}
pe(c);
print(B[0] ^ A[c]);
// v.push_back({ c,B[0] ^ A[c] });
END:;
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
// int q;cin>>q;
// while(q--)
solve();
}
| #pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define pb(a) push_back
#define print(x) cout << (x) << endl
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), n)
#define ub(v, n) upper_bound(v.begin(), v.end(), n)
// #define int long long
#define all(x) (x).begin(), (x).end()
#define print_space(v) \
REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> P;
const int MOD = 998244353;
const int MAX = 200020;
const double pi = acos(-1);
const double EPS = 1e-12;
const ll INF = 2e18;
bool cnt[2][200020][33];
template <typename T, T MOD1, T MOD2, T B1, T B2> struct RollingHash {
vector<T> hash[2], p[2];
T MOD[2] = {MOD1, MOD2};
T B[2] = {B1, B2};
// RollingHash(const string &s) {
// int N = s.size();
// for (int k = 0; k < 2; k++) {
// hash[k].assign(N + 1, 0);
// p[k].assign(N + 1, 1);
// for (int i = 0; i < N; i++) {
// hash[k][i + 1] = (hash[k][i] * B[k] + s[i]) % MOD[k];
// p[k][i + 1] = p[k][i] * B[k] % MOD[k];
// }
// }
// }
void init(const string &s) {
int N = s.size();
for (int k = 0; k < 1; k++) {
hash[k].assign(N + 1, 0);
p[k].assign(N + 1, 1);
for (int i = 0; i < N; i++) {
hash[k][i + 1] = (hash[k][i] * B[k] + s[i]) % MOD[k];
p[k][i + 1] = p[k][i] * B[k] % MOD[k];
}
}
}
// S[l,r)
pair<T, T> find(int l, int r) {
T res1 = hash[0][r] + MOD[0] - hash[0][l] * p[0][r - l] % MOD[0];
res1 = (res1 >= MOD[0]) ? res1 - MOD[0] : res1;
T res2 = hash[1][r] + MOD[1] - hash[1][l] * p[1][r - l] % MOD[1];
res2 = (res2 >= MOD[1]) ? res2 - MOD[1] : res2;
return make_pair(res1, res2);
}
T find1(int l, int r) {
T res1 = hash[0][r] + MOD[0] - hash[0][l] * p[0][r - l] % MOD[0];
return (res1 >= MOD[0]) ? res1 - MOD[0] : res1;
}
T find2(int l, int r) {
T res2 = hash[1][r] + MOD[1] - hash[1][l] * p[1][r - l] % MOD[1];
return (res2 >= MOD[1]) ? res2 - MOD[1] : res2;
}
};
using RH = RollingHash<ll, (ll)1e9 + 7, (ll)1e9 + 9, 1234567, 7654343>;
// RH rh(S);
RH rhS[30], rhT[30], rhTrev[30];
int A[200020], B[200020];
string S[30], T[30], Trev[30];
void solve() {
int N;
cin >> N;
REP(i, N) cin >> A[i];
REP(i, N) cin >> B[i];
REP(i, N) {
REP(j, 30) {
if (A[i] & (1 << j))
cnt[0][i][j] = 1;
if (B[i] & (1 << j))
cnt[1][i][j] = 1;
}
}
bool found = false;
REP(j, 30) {
REP(i, N) {
if (cnt[0][i][j])
S[j] += '1';
else
S[j] += '0';
if (cnt[1][i][j]) {
T[j] += '1';
Trev[j] += '0';
} else {
T[j] += '0';
Trev[j] += '1';
}
}
}
// using RH = RollingHash<ll, (ll)1e9 + 7, (ll)1e9 + 9, 1234567, 7654343>;
REP(j, 30) {
rhS[j].init(S[j]);
rhT[j].init(T[j]);
rhTrev[j].init(Trev[j]);
}
ll ans = 0;
vector<P> v;
int k = 0;
int c = N - k;
REP(j, 30) {
if ((rhS[j].find1(0, N - k) == rhT[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhT[j].find1(0, k)) ||
(rhS[j].find1(0, N - k) == rhTrev[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhTrev[j].find1(0, k))) {
} else
goto END2;
}
pe(0);
print(B[0] ^ A[0]);
END2:
FORR(k, N, 1) {
c = N - k;
REP(j, 30) {
if ((rhS[j].find1(0, N - k) == rhT[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhT[j].find1(0, k)) ||
(rhS[j].find1(0, N - k) == rhTrev[j].find1(k, N) &&
rhS[j].find1(N - k, N) == rhTrev[j].find1(0, k))) {
} else
goto END;
}
pe(c);
print(B[0] ^ A[c]);
// v.push_back({ c,B[0] ^ A[c] });
END:;
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
// int q;cin>>q;
// while(q--)
solve();
}
| replace | 81 | 82 | 81 | 82 | TLE | |
p02816 | C++ | Runtime Error | // #undef _DEBUG
// #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
#define int long long // todo 消したら動かない intの代わりにsignedを使う
#define ll long long
auto start_time = system_clock::now();
auto past_time = system_clock::now();
#define debugName(VariableName) #VariableName
// 最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
#define rand xor128_
/*@formatter:on*/
unsigned long xor128_(void) {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
/*@formatter:on*/
ll rand(ll min, ll max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
if (rand() % 2) {
return rand(0, max);
} else {
return -rand(0, -min);
}
}
}
#define sz(a) ((int)a.size())
const int inf = (int)1e9 + 100;
/*@formatter:off*/
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} initonv;
#define pre prev
#define nex next
// hashを共有したくない場合、中に書く
const uint64_t base = rand((uint64_t)868491463, ((uint64_t)1 << 61) - 1 - 1);
// 安全で爆速なrollinghash
class roll {
/*@formatter:on*/
static constexpr uint64_t mask30 = ((uint64_t)1 << 30) - 1;
static constexpr uint64_t mask31 = ((uint64_t)1 << 31) - 1;
static constexpr uint64_t mask61 = ((uint64_t)1 << 61) - 1;
static constexpr uint64_t offset = mask61 * 7;
static constexpr uint64_t mod(const uint64_t x) {
const uint64_t y = (x >> 61) + (x & mask61);
return y >= mask61 ? y - mask61 : y;
}
static constexpr uint64_t mul(const uint64_t x, const uint64_t y) {
const uint64_t xh = x >> 31, xl = x & mask31;
const uint64_t yh = y >> 31, yl = y & mask31;
const uint64_t z = xl * yh + xh * yl;
const uint64_t zh = z >> 30, zl = z & mask30;
return xh * yh * 2 + zh + (zl << 31) + xl * yl;
}
const std::size_t siz;
vector<uint64_t> pow, h;
public:
template <typename T>
roll(T &A) : siz(sz(A)), pow(siz + 1, 1), h(siz + 1, 0) {
for (std::size_t i = 1; i <= siz; i++) {
pow[i] = mod(mul(pow[i - 1], base)),
h[i] = mod(mul(h[i - 1], base) + A[i - 1]);
}
}
uint64_t operator()(const std::size_t l, const std::size_t r) {
return mod(h[r] + offset - mul(h[l], pow[r - l]));
}
uint64_t operator()(int r = inf) { return operator()(0, min((int)siz, r)); }
// get lcp of S[a:] and T[b:]
// 接頭語がどれだけ一致するか
// 範囲の重複を含む
int lcp_dup(int a, int b) {
int len = min((int)siz - a, (int)siz - b);
int low = 0, high = len;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (operator()(a, a + mid) != operator()(b, b + mid))
high = mid;
else
low = mid;
}
return low;
}
// 重複を認めない
int lcp_not(int a, int b) {
return min(lcp_dup(a, b), b - a);
} //@formatter:on
};
// 動かない場合roll2
// roll ro(list);
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
int getrandmax() {
static uint32_t y = time(NULL);
y ^= (y << 13);
y ^= (y >> 17);
y ^= (y << 5);
return abs((int)y);
}
int getrand(int l, int r) { // [l, r]
return getrandmax() % (r - l + 1) + l;
}
typedef ModInt<1000000007> mint1;
typedef ModInt<1000000009> mint2;
int primes[10] = {10007, 10009, 10037, 10039, 10061,
10067, 10069, 10079, 10091, 10093};
bool isShuffle = false;
struct RollingHash {
mint1 p1;
mint2 p2;
int n;
vector<mint1> m1;
vector<mint2> m2;
vector<mint1> v1;
vector<mint2> v2;
RollingHash() {
if (!isShuffle) {
rep(i, 0, 101) {
int a = getrand(0, 9);
int b = getrand(0, 9);
swap(primes[a], primes[b]);
}
isShuffle = true;
}
p1 = primes[0], p2 = primes[1];
}
void init(string s, char o = 'a') {
vector<int> v;
fore(c, s) v.push_back(c - o);
init(v);
}
void init(vector<int> s) {
n = s.size();
m1.resize(n);
m2.resize(n);
v1.resize(n);
v2.resize(n);
m1[0] = 1;
m2[0] = 1;
v1[0] = s[0];
v2[0] = s[0];
rep(i, 1, n) {
m1[i] = m1[i - 1] * p1;
m2[i] = m2[i - 1] * p2;
v1[i] = v1[i - 1] + m1[i] * s[i];
v2[i] = v2[i - 1] + m2[i] * s[i];
}
}
inline pair<mint1, mint2> hash(int l, int r) { // s[l..r]
assert(l <= r);
assert(r < n);
mint1 a = v1[r];
if (l)
a -= v1[l - 1];
a *= m1[n - 1 - r];
mint2 b = v2[r];
if (l)
b -= v2[l - 1];
b *= m2[n - 1 - r];
return {a, b};
}
inline ll llhash(int l, int r) { // s[l..r]
auto h = hash(l, r);
return 1LL * h.first.get() * h.second.Mod + h.second.get();
}
};
using vi = vector<int>;
int N;
void solve() {
cin >> N;
vi A(N), B(N), A2(N), B2(N);
rep(i, 0, N) cin >> A[i];
rep(i, 0, N) cin >> B[i];
rep(i, 0, N) A2[i] = A[i] ^ A[(i + 1) % N];
rep(i, 0, N) B2[i] = B[i] ^ B[(i + 1) % N];
vector<int> v;
rep(i, 0, N) v.push_back(A2[i]);
rep(i, 0, N) v.push_back(A2[i]);
rep(i, 0, N) v.push_back(B2[i]);
RollingHash rh;
rh.init(v);
rep(k, 0, N) if (rh.hash(k, k + N) == rh.hash(N * 2, N * 2 + N)) {
int x = A[k] ^ B[0];
cout << k << " " << x << endl;
}
}
auto my(ll n, vi &a) { return 0; }
auto sister(ll n, vi &a) {
ll ret = 0;
return ret;
}
signed main() {
solve();
return 0;
};
| // #undef _DEBUG
// #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace std::chrono;
#define int long long // todo 消したら動かない intの代わりにsignedを使う
#define ll long long
auto start_time = system_clock::now();
auto past_time = system_clock::now();
#define debugName(VariableName) #VariableName
// 最大引数がN
#define over2(o1, o2, name, ...) name
#define over3(o1, o2, o3, name, ...) name
#define over4(o1, o2, o3, o4, name, ...) name
#define over5(o1, o2, o3, o4, o5, name, ...) name
#define over6(o1, o2, o3, o4, o5, o6, name, ...) name
#define over7(o1, o2, o3, o4, o5, o6, o7, name, ...) name
#define over8(o1, o2, o3, o4, o5, o6, o7, o8, name, ...) name
#define over9(o1, o2, o3, o4, o5, o6, o7, o8, o9, name, ...) name
#define over10(o1, o2, o3, o4, o5, o6, o7, o8, o9, o10, name, ...) name
#define rep(i, a, b) for (int i = a; i < b; i++)
#define rrep(i, a, b) for (int i = a; i >= b; i--)
#define fore(i, a) for (auto &i : a)
#define all(x) (x).begin(), (x).end()
#define rand xor128_
/*@formatter:on*/
unsigned long xor128_(void) {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
/*@formatter:on*/
ll rand(ll min, ll max) {
assert(min <= max);
if (min >= 0 && max >= 0) {
return rand() % (max + 1 - min) + min;
} else if (max < 0) {
return -rand(-max, -min);
} else {
if (rand() % 2) {
return rand(0, max);
} else {
return -rand(0, -min);
}
}
}
#define sz(a) ((int)a.size())
const int inf = (int)1e9 + 100;
/*@formatter:off*/
//@起動時
struct initon {
initon() {
cin.tie(0);
ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(16);
srand((unsigned)clock() + (unsigned)time(NULL));
};
} initonv;
#define pre prev
#define nex next
// hashを共有したくない場合、中に書く
const uint64_t base = rand((uint64_t)868491463, ((uint64_t)1 << 61) - 1 - 1);
// 安全で爆速なrollinghash
class roll {
/*@formatter:on*/
static constexpr uint64_t mask30 = ((uint64_t)1 << 30) - 1;
static constexpr uint64_t mask31 = ((uint64_t)1 << 31) - 1;
static constexpr uint64_t mask61 = ((uint64_t)1 << 61) - 1;
static constexpr uint64_t offset = mask61 * 7;
static constexpr uint64_t mod(const uint64_t x) {
const uint64_t y = (x >> 61) + (x & mask61);
return y >= mask61 ? y - mask61 : y;
}
static constexpr uint64_t mul(const uint64_t x, const uint64_t y) {
const uint64_t xh = x >> 31, xl = x & mask31;
const uint64_t yh = y >> 31, yl = y & mask31;
const uint64_t z = xl * yh + xh * yl;
const uint64_t zh = z >> 30, zl = z & mask30;
return xh * yh * 2 + zh + (zl << 31) + xl * yl;
}
const std::size_t siz;
vector<uint64_t> pow, h;
public:
template <typename T>
roll(T &A) : siz(sz(A)), pow(siz + 1, 1), h(siz + 1, 0) {
for (std::size_t i = 1; i <= siz; i++) {
pow[i] = mod(mul(pow[i - 1], base)),
h[i] = mod(mul(h[i - 1], base) + A[i - 1]);
}
}
uint64_t operator()(const std::size_t l, const std::size_t r) {
return mod(h[r] + offset - mul(h[l], pow[r - l]));
}
uint64_t operator()(int r = inf) { return operator()(0, min((int)siz, r)); }
// get lcp of S[a:] and T[b:]
// 接頭語がどれだけ一致するか
// 範囲の重複を含む
int lcp_dup(int a, int b) {
int len = min((int)siz - a, (int)siz - b);
int low = 0, high = len;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (operator()(a, a + mid) != operator()(b, b + mid))
high = mid;
else
low = mid;
}
return low;
}
// 重複を認めない
int lcp_not(int a, int b) {
return min(lcp_dup(a, b), b - a);
} //@formatter:on
};
// 動かない場合roll2
// roll ro(list);
//---------------------------------------------------------------------------------------------------
template <int MOD> struct ModInt {
static const int Mod = MOD;
unsigned x;
ModInt() : x(0) {}
ModInt(signed sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
ModInt(signed long long sig) { x = sig < 0 ? sig % MOD + MOD : sig % MOD; }
int get() const { return (int)x; }
ModInt &operator+=(ModInt that) {
if ((x += that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator-=(ModInt that) {
if ((x += MOD - that.x) >= MOD)
x -= MOD;
return *this;
}
ModInt &operator*=(ModInt that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }
ModInt operator+(ModInt that) const { return ModInt(*this) += that; }
ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }
ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }
ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }
ModInt inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
std::swap(a, b);
u -= t * v;
std::swap(u, v);
}
return ModInt(u);
}
bool operator==(ModInt that) const { return x == that.x; }
bool operator!=(ModInt that) const { return x != that.x; }
ModInt operator-() const {
ModInt t;
t.x = x == 0 ? 0 : Mod - x;
return t;
}
};
template <int MOD> ModInt<MOD> operator^(ModInt<MOD> a, unsigned long long k) {
ModInt<MOD> r = 1;
while (k) {
if (k & 1)
r *= a;
a *= a;
k >>= 1;
}
return r;
}
int getrandmax() {
static uint32_t y = time(NULL);
y ^= (y << 13);
y ^= (y >> 17);
y ^= (y << 5);
return abs((int)y);
}
int getrand(int l, int r) { // [l, r]
return getrandmax() % (r - l + 1) + l;
}
typedef ModInt<1000000007> mint1;
typedef ModInt<1000000009> mint2;
int primes[10] = {10007, 10009, 10037, 10039, 10061,
10067, 10069, 10079, 10091, 10093};
bool isShuffle = false;
struct RollingHash {
mint1 p1;
mint2 p2;
int n;
vector<mint1> m1;
vector<mint2> m2;
vector<mint1> v1;
vector<mint2> v2;
RollingHash() {
if (!isShuffle) {
rep(i, 0, 101) {
int a = getrand(0, 9);
int b = getrand(0, 9);
swap(primes[a], primes[b]);
}
isShuffle = true;
}
p1 = primes[0], p2 = primes[1];
}
void init(string s, char o = 'a') {
vector<int> v;
fore(c, s) v.push_back(c - o);
init(v);
}
void init(vector<int> s) {
n = s.size();
m1.resize(n);
m2.resize(n);
v1.resize(n);
v2.resize(n);
m1[0] = 1;
m2[0] = 1;
v1[0] = s[0];
v2[0] = s[0];
rep(i, 1, n) {
m1[i] = m1[i - 1] * p1;
m2[i] = m2[i - 1] * p2;
v1[i] = v1[i - 1] + m1[i] * s[i];
v2[i] = v2[i - 1] + m2[i] * s[i];
}
}
inline pair<mint1, mint2> hash(int l, int r) { // s[l..r]
assert(l <= r);
assert(r < n);
mint1 a = v1[r];
if (l)
a -= v1[l - 1];
a *= m1[n - 1 - r];
mint2 b = v2[r];
if (l)
b -= v2[l - 1];
b *= m2[n - 1 - r];
return {a, b};
}
inline ll llhash(int l, int r) { // s[l..r]
auto h = hash(l, r);
return 1LL * h.first.get() * h.second.Mod + h.second.get();
}
};
using vi = vector<int>;
int N;
void solve() {
cin >> N;
vi A(N), B(N), A2(N), B2(N);
rep(i, 0, N) cin >> A[i];
rep(i, 0, N) cin >> B[i];
rep(i, 0, N) A2[i] = A[i] ^ A[(i + 1) % N];
rep(i, 0, N) B2[i] = B[i] ^ B[(i + 1) % N];
vector<int> v;
rep(i, 0, N) v.push_back(A2[i]);
rep(i, 0, N) v.push_back(A2[i]);
rep(i, 0, N) v.push_back(B2[i]);
RollingHash rh;
rh.init(v);
rep(k, 0, N) if (rh.hash(k, k + N - 1) == rh.hash(N * 2, N * 2 + N - 1)) {
int x = A[k] ^ B[0];
cout << k << " " << x << endl;
}
}
auto my(ll n, vi &a) { return 0; }
auto sister(ll n, vi &a) {
ll ret = 0;
return ret;
}
signed main() {
solve();
return 0;
};
| replace | 288 | 289 | 288 | 289 | -6 | 6d2ca680-13a2-4a7d-86aa-0e209316e8bf.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02816/C++/s642465429.cpp:182: std::pair<ModInt<1000000007>, ModInt<1000000009> > RollingHash::hash(long long int, long long int): Assertion `r < n' failed.
|
p02816 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
typedef pair<ll, ll> p;
typedef vector<int> vec;
using Graph = vector<vector<int>>;
using graph = vector<vector<ll>>;
const int inf = 1e9 + 7;
const long long MOD = 1000000007;
// ローリングハッシュ
struct RollingHash {
static const int base1 = 1007, base2 = 2009;
static const int mod1 = 1000000007, mod2 = 1000000009;
vector<long long> hash1, hash2, power1, power2;
// construct
RollingHash(const vector<ll> &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
}
}
// get hash of S[left:right]
inline pair<long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
return {res1, res2};
}
};
int main() {
int n;
vector<int> k;
cin >> n;
vector<ll> a(n), b(n), A(n * 2), B(n);
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
rep(i, n - 1) {
A[i] = a[i] ^ a[i + 1];
B[i] = b[i] ^ b[i + 1];
A[i + n] = a[i] ^ a[i + 1];
}
A[n - 1] = a[n - 1] ^ a[0];
B[n - 1] = b[n - 1] ^ b[0];
A[2 * n - 1] = a[n - 1] ^ a[0];
RollingHash rha(A), rhb(B);
p pb = rhb.get(0, n);
rep(i, n) {
if (pb == rha.get(i, i + n)) {
k.push_back(i);
}
}
rep(i, k.size()) {
int x = a[k[i]] ^ b[0];
bool flg = true;
repd(j, 1, n) {
if ((a[(k[i] + j) % n] ^ b[j]) != x)
flg = false;
}
if (flg)
cout << k[i] << " " << x << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define repd(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) repd(i, 0, n)
#define all(x) (x).begin(), (x).end()
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
typedef pair<ll, ll> p;
typedef vector<int> vec;
using Graph = vector<vector<int>>;
using graph = vector<vector<ll>>;
const int inf = 1e9 + 7;
const long long MOD = 1000000007;
// ローリングハッシュ
struct RollingHash {
static const int base1 = 1007, base2 = 2009;
static const int mod1 = 1000000007, mod2 = 1000000009;
vector<long long> hash1, hash2, power1, power2;
// construct
RollingHash(const vector<ll> &S) {
int n = (int)S.size();
hash1.assign(n + 1, 0);
hash2.assign(n + 1, 0);
power1.assign(n + 1, 1);
power2.assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash1[i + 1] = (hash1[i] * base1 + S[i]) % mod1;
hash2[i + 1] = (hash2[i] * base2 + S[i]) % mod2;
power1[i + 1] = (power1[i] * base1) % mod1;
power2[i + 1] = (power2[i] * base2) % mod2;
}
}
// get hash of S[left:right]
inline pair<long long, long long> get(int l, int r) const {
long long res1 = hash1[r] - hash1[l] * power1[r - l] % mod1;
if (res1 < 0)
res1 += mod1;
long long res2 = hash2[r] - hash2[l] * power2[r - l] % mod2;
if (res2 < 0)
res2 += mod2;
return {res1, res2};
}
};
int main() {
int n;
vector<int> k;
cin >> n;
vector<ll> a(n), b(n), A(n * 2), B(n);
rep(i, n) cin >> a[i];
rep(i, n) cin >> b[i];
rep(i, n - 1) {
A[i] = a[i] ^ a[i + 1];
B[i] = b[i] ^ b[i + 1];
A[i + n] = a[i] ^ a[i + 1];
}
A[n - 1] = a[n - 1] ^ a[0];
B[n - 1] = b[n - 1] ^ b[0];
A[2 * n - 1] = a[n - 1] ^ a[0];
RollingHash rha(A), rhb(B);
p pb = rhb.get(0, n);
rep(i, n) {
if (pb == rha.get(i, i + n)) {
k.push_back(i);
}
}
rep(i, k.size()) {
int x = a[k[i]] ^ b[0];
bool flg = true;
if (flg)
cout << k[i] << " " << x << endl;
}
return 0;
} | replace | 101 | 105 | 101 | 102 | TLE | |
p02816 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// std::vector Declaration
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
// std::vector Declaration and Initialization
template <typename T> vector<T> make_vector(size_t a, T x) {
return vector<T>(a, x);
}
template <typename T, typename U, typename... Ts>
auto make_vector(size_t a, U b, Ts... ts) {
return vector<decltype(make_vector<T>(b, ts...))>(a,
make_vector<T>(b, ts...));
}
// std::vector Input
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &e : v)
is >> e;
return is;
}
// std::vector Debug
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
bool a = 1;
for (auto e : v) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "]";
return os;
}
// std::array Debug
template <typename T, size_t n>
ostream &operator<<(ostream &os, const array<T, n> &v) {
os << "[";
bool a = 1;
for (auto e : v) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "]";
return os;
}
// std::deque Debug
template <typename T> ostream &operator<<(ostream &os, const deque<T> &d) {
os << "[";
bool a = 1;
for (auto e : d) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "]";
return os;
}
// std::pair Debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << " " << p.second << ")";
return os;
}
// std::set Debug
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
os << "{";
bool a = 1;
for (auto e : st) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "}";
return os;
}
// std::multiset Debug
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &st) {
os << "{";
bool a = 1;
for (auto e : st) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "}";
return os;
}
// std::map Debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
os << "{";
bool a = 1;
for (auto e : mp) {
os << (a ? "" : " ");
os << e.first << ":" << e.second;
a = 0;
}
os << "}";
return os;
}
// std::tuple Debug
template <int N, class Tuple> void out(ostream &os, const Tuple &t) {}
template <int N, class Tuple, class H, class... Ts>
void out(ostream &os, const Tuple &t) {
if (N)
os << " ";
os << get<N>(t);
out<N + 1, Tuple, Ts...>(os, t);
}
template <class... Ts> ostream &operator<<(ostream &os, const tuple<Ts...> &t) {
os << "(";
out<0, tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
// Debug
#define DUMP(x) cerr << #x << " = " << (x) << endl
// Weighted edge
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
friend ostream &operator<<(ostream &os, const edge &e) {
return os << "(" << e.src << "->" << e.to << ":" << e.cost << ")";
}
};
using LL = long long;
#define fs first
#define sc second
const LL MOD = 1e9 + 7;
struct RollingHash {
const int base = 9973;
const int mod[2] = {999999937, 1000000007};
vector<int> s;
vector<LL> hash[2], pow[2];
RollingHash(const vector<int> &cs) : s(cs) {
int n = s.size();
for (int id = 0; id < 2; ++id) {
hash[id].assign(n + 1, 0);
pow[id].assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash[id][i + 1] = (hash[id][i] * base + s[i]) % mod[id];
pow[id][i + 1] = pow[id][i] * base % mod[id];
}
}
}
// get hash of s[l:r)
LL get(int l, int r, int id = 0) {
LL res = hash[id][r] - hash[id][l] * pow[id][r - l] % mod[id];
if (res < 0)
res += mod[id];
return res;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<LL> a(N), b(N);
cin >> a >> b;
map<LL, int> mp;
for (int i = 0; i < N; ++i) {
mp[a[(i + 1) % N] ^ a[i]];
mp[b[(i + 1) % N] ^ b[i]];
}
int cnt = 0;
for (auto &p : mp) {
p.sc = cnt++;
}
vector<int> A(2 * N), B(N);
for (int i = 0; i < 2 * N; ++i) {
A[i] = mp[a[(i + 1) % N] ^ a[i % N]];
}
for (int i = 0; i < 2 * N; ++i) {
B[i] = mp[b[(i + 1) % N] ^ b[i]];
}
RollingHash r1(A), r2(B);
vector<pair<int, LL>> ans;
for (int k = 0; k < N; ++k) {
if (r1.get(k, k + N, 0) == r2.get(0, N, 0) &&
r1.get(k, k + N, 1) == r2.get(0, N, 1)) {
ans.push_back({k, a[k] ^ b[0]});
}
}
for (auto &p : ans) {
cout << p.fs << " " << p.sc << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
// std::vector Declaration
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
// std::vector Declaration and Initialization
template <typename T> vector<T> make_vector(size_t a, T x) {
return vector<T>(a, x);
}
template <typename T, typename U, typename... Ts>
auto make_vector(size_t a, U b, Ts... ts) {
return vector<decltype(make_vector<T>(b, ts...))>(a,
make_vector<T>(b, ts...));
}
// std::vector Input
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &e : v)
is >> e;
return is;
}
// std::vector Debug
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[";
bool a = 1;
for (auto e : v) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "]";
return os;
}
// std::array Debug
template <typename T, size_t n>
ostream &operator<<(ostream &os, const array<T, n> &v) {
os << "[";
bool a = 1;
for (auto e : v) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "]";
return os;
}
// std::deque Debug
template <typename T> ostream &operator<<(ostream &os, const deque<T> &d) {
os << "[";
bool a = 1;
for (auto e : d) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "]";
return os;
}
// std::pair Debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << " " << p.second << ")";
return os;
}
// std::set Debug
template <typename T> ostream &operator<<(ostream &os, const set<T> &st) {
os << "{";
bool a = 1;
for (auto e : st) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "}";
return os;
}
// std::multiset Debug
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &st) {
os << "{";
bool a = 1;
for (auto e : st) {
os << (a ? "" : " ");
os << e;
a = 0;
}
os << "}";
return os;
}
// std::map Debug
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &mp) {
os << "{";
bool a = 1;
for (auto e : mp) {
os << (a ? "" : " ");
os << e.first << ":" << e.second;
a = 0;
}
os << "}";
return os;
}
// std::tuple Debug
template <int N, class Tuple> void out(ostream &os, const Tuple &t) {}
template <int N, class Tuple, class H, class... Ts>
void out(ostream &os, const Tuple &t) {
if (N)
os << " ";
os << get<N>(t);
out<N + 1, Tuple, Ts...>(os, t);
}
template <class... Ts> ostream &operator<<(ostream &os, const tuple<Ts...> &t) {
os << "(";
out<0, tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
// Debug
#define DUMP(x) cerr << #x << " = " << (x) << endl
// Weighted edge
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
friend ostream &operator<<(ostream &os, const edge &e) {
return os << "(" << e.src << "->" << e.to << ":" << e.cost << ")";
}
};
using LL = long long;
#define fs first
#define sc second
const LL MOD = 1e9 + 7;
struct RollingHash {
const int base = 9973;
const int mod[2] = {999999937, 1000000007};
vector<int> s;
vector<LL> hash[2], pow[2];
RollingHash(const vector<int> &cs) : s(cs) {
int n = s.size();
for (int id = 0; id < 2; ++id) {
hash[id].assign(n + 1, 0);
pow[id].assign(n + 1, 1);
for (int i = 0; i < n; ++i) {
hash[id][i + 1] = (hash[id][i] * base + s[i]) % mod[id];
pow[id][i + 1] = pow[id][i] * base % mod[id];
}
}
}
// get hash of s[l:r)
LL get(int l, int r, int id = 0) {
LL res = hash[id][r] - hash[id][l] * pow[id][r - l] % mod[id];
if (res < 0)
res += mod[id];
return res;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<LL> a(N), b(N);
cin >> a >> b;
map<LL, int> mp;
for (int i = 0; i < N; ++i) {
mp[a[(i + 1) % N] ^ a[i]];
mp[b[(i + 1) % N] ^ b[i]];
}
int cnt = 0;
for (auto &p : mp) {
p.sc = cnt++;
}
vector<int> A(2 * N), B(N);
for (int i = 0; i < 2 * N; ++i) {
A[i] = mp[a[(i + 1) % N] ^ a[i % N]];
}
for (int i = 0; i < N; ++i) {
B[i] = mp[b[(i + 1) % N] ^ b[i]];
}
RollingHash r1(A), r2(B);
vector<pair<int, LL>> ans;
for (int k = 0; k < N; ++k) {
if (r1.get(k, k + N, 0) == r2.get(0, N, 0) &&
r1.get(k, k + N, 1) == r2.get(0, N, 1)) {
ans.push_back({k, a[k] ^ b[0]});
}
}
for (auto &p : ans) {
cout << p.fs << " " << p.sc << endl;
}
return 0;
}
| replace | 217 | 218 | 217 | 218 | 0 | |
p02816 | C++ | Time Limit Exceeded | // abc150
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define mod 1000000007
using namespace std;
typedef long long ll;
template <class T> using V = vector<T>;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
typedef unsigned long long ull;
typedef long double ldouble;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const ll INF = 1e18;
const ull B = 1000000007; // ハッシュの基数
// aはbに含まれているか？
bool contain(string a, string b) {
int al = a.length(), bl = b.length();
if (al > bl)
return false;
// Bのal乗を計算
ull t = 1;
for (int i = 0; i < al; i++)
t *= B;
// aとbの最初のal文字に関するハッシュ値を計算
ull ah = 0, bh = 0;
for (int i = 0; i < al; i++)
ah = ah * B + a[i];
for (int i = 0; i < al; i++)
bh = bh * B + b[i];
// bの場所を1つずつ進めながらハッシュ値をチェック
for (int i = 0; i + al <= bl; i++) {
if (ah == bh)
return true; // bのi文字目からのal文字が一致
if (i + al < bl)
bh = bh * B + b[i + al] - b[i] * t;
}
return false;
}
int main() {
int n;
cin >> n;
V<ll> a(n), b(n), c(n - 1), d(n);
cinf(n, a);
cinf(n, b);
rep(i, n - 1) c[i] = (b[i] ^ b[i + 1]);
rep(i, n) d[i] = (a[i % n] ^ a[(i + 1) % n]);
if (n == 1) {
cout << 0 << ' ' << (a[0] ^ b[0]) << endl;
} else {
priority_queue<P, V<P>, greater<P>> que;
int cl = n - 1, dl = n; // a->c,b->d
// Bのal乗を計算
ull t = 1;
for (int i = 0; i < cl; i++)
t *= B;
// aとbの最初のal文字に関するハッシュ値を計算
ull ch = 0, dh = 0;
for (int i = 0; i < cl; i++)
ch = ch * B + c[i];
for (int i = 0; i < cl; i++)
dh = dh * B + d[i];
// bの場所を1つずつ進めながらハッシュ値をチェック
for (int i = 0; i < dl; i++) {
if (ch == dh) {
bool ok = 1;
for (int j = 0; j < cl; j++) {
if (c[j] != d[(j + i) % n]) {
ok = 0;
}
}
if (ok) {
P p = P(i, (b[0] ^ a[i]));
que.push(p);
}
} // dのi文字目からのcl文字が一致
dh = dh * B + d[(i + cl) % n] - d[i % n] * t;
}
while (!que.empty()) {
P p = que.top();
que.pop();
cout << p.ft << ' ' << p.sc << '\n';
}
}
} | // abc150
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define cinf(n, x) \
for (int i = 0; i < (n); i++) \
cin >> x[i];
#define ft first
#define sc second
#define pb push_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(), (v).end()
#define mod 1000000007
using namespace std;
typedef long long ll;
template <class T> using V = vector<T>;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
typedef unsigned long long ull;
typedef long double ldouble;
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const ll INF = 1e18;
const ull B = 1000000007; // ハッシュの基数
// aはbに含まれているか？
bool contain(string a, string b) {
int al = a.length(), bl = b.length();
if (al > bl)
return false;
// Bのal乗を計算
ull t = 1;
for (int i = 0; i < al; i++)
t *= B;
// aとbの最初のal文字に関するハッシュ値を計算
ull ah = 0, bh = 0;
for (int i = 0; i < al; i++)
ah = ah * B + a[i];
for (int i = 0; i < al; i++)
bh = bh * B + b[i];
// bの場所を1つずつ進めながらハッシュ値をチェック
for (int i = 0; i + al <= bl; i++) {
if (ah == bh)
return true; // bのi文字目からのal文字が一致
if (i + al < bl)
bh = bh * B + b[i + al] - b[i] * t;
}
return false;
}
int main() {
int n;
cin >> n;
V<ll> a(n), b(n), c(n - 1), d(n);
cinf(n, a);
cinf(n, b);
rep(i, n - 1) c[i] = (b[i] ^ b[i + 1]);
rep(i, n) d[i] = (a[i % n] ^ a[(i + 1) % n]);
if (n == 1) {
cout << 0 << ' ' << (a[0] ^ b[0]) << endl;
} else {
priority_queue<P, V<P>, greater<P>> que;
int cl = n - 1, dl = n; // a->c,b->d
// Bのal乗を計算
ull t = 1;
for (int i = 0; i < cl; i++)
t *= B;
// aとbの最初のal文字に関するハッシュ値を計算
ull ch = 0, dh = 0;
for (int i = 0; i < cl; i++)
ch = ch * B + c[i];
for (int i = 0; i < cl; i++)
dh = dh * B + d[i];
// bの場所を1つずつ進めながらハッシュ値をチェック
for (int i = 0; i < dl; i++) {
if (ch == dh) {
P p = P(i, (b[0] ^ a[i]));
que.push(p);
} // dのi文字目からのcl文字が一致
dh = dh * B + d[(i + cl) % n] - d[i % n] * t;
}
while (!que.empty()) {
P p = que.top();
que.pop();
cout << p.ft << ' ' << p.sc << '\n';
}
}
} | replace | 97 | 107 | 97 | 99 | TLE | |
p02817 | Python | Runtime Error | s, t = input()
print(s + t)
| s, t = map(str, input().split())
print(t + s)
| replace | 0 | 2 | 0 | 2 | ValueError: too many values to unpack (expected 2) | Traceback (most recent call last):
File "/home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02817/Python/s530679524.py", line 1, in <module>
s, t = input()
ValueError: too many values to unpack (expected 2)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.