problem_id stringlengths 6 6 | buggy_code stringlengths 8 526k ⌀ | fixed_code stringlengths 12 526k ⌀ | labels listlengths 0 15 ⌀ | buggy_submission_id int64 1 1.54M ⌀ | fixed_submission_id int64 2 1.54M ⌀ | user_id stringlengths 10 10 ⌀ | language stringclasses 9 values |
|---|---|---|---|---|---|---|---|
p02962 | //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <cstdint>
#include <vector>
namespace n91 {
template <class Base> struct m2e61m1_rolling_hash {
using u64 = std::uint_fast64_t;
using value_type = u64;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
static constexpr u64 mask2(const int exp) noexcept {
return (static_cast<u64>(1) << exp) - static_cast<u64>(1);
}
static constexpr u64 Mod = mask2(61);
static constexpr u64 cyclic(const u64 v) noexcept {
return ((v & mask2(30)) << 31) + (v >> 31);
}
static constexpr u64 calc(u64 v) noexcept {
if (v > Mod) {
v = (v & mask2(61)) + (v >> 61);
}
if (v > Mod) {
return v -= Mod;
}
return Mod;
}
static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
/*
using t = __int128;
return t(l) * t(r) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld));
//*/
}
static constexpr u64 multiplies_plus(const u64 l, const u64 r,
const u64 c) noexcept {
/*
using t = __int128;
return (t(l) * t(r) + t(c)) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld) + c);
//*/
}
container_type prefix, power;
public:
template <class InputIterator>
explicit m2e61m1_rolling_hash(InputIterator first,
const InputIterator last) noexcept
: prefix(), power() {
const size_type n = static_cast<size_type>(std::distance(first, last));
prefix.reserve(n + static_cast<size_type>(1));
prefix.push_back(static_cast<value_type>(0));
for (; first != last; ++first) {
prefix.push_back(multiplies_plus(prefix.back(), Base::value, *first));
}
power.reserve(n + static_cast<size_type>(1));
power.push_back(static_cast<value_type>(1));
for (size_type i = static_cast<size_type>(0); i != n; ++i) {
power.push_back(multiplies(power.back(), Base::value));
}
}
value_type operator()(const size_type first,
const size_type last) const noexcept {
return multiplies_plus(prefix[first], power[last - first],
Mod - prefix[last]);
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using hash = m2e61m1_rolling_hash<std::integral_constant<u64, 62479294>>;
auto s = scan<std::string>();
const auto t = scan<std::string>();
const usize m = t.size();
while (s.size() < m) {
s = s + s;
}
const usize n = s.size();
s = s + s;
const hash sh(s.cbegin(), s.cend());
const u64 th = hash(t.cbegin(), t.cend())(0_z, m);
std::vector<usize> next(n, n), prev(n, n);
for (const auto i : rep(0_z, n)) {
if (sh(i, i + m) == th) {
next[i] = (i + m) % n;
prev[next[i]] = i;
}
}
usize r_cnt = 0_z;
usize ans = 0_z;
for (const auto i : rep(0_z, n)) {
if (prev[i] == n) {
++r_cnt;
usize count = 0_z;
usize v = next[i];
while (v != n) {
++r_cnt;
v = next[v];
++count;
}
ans = std::max(ans, count);
}
}
if (r_cnt == n) {
std::cout << ans << std::endl;
} else {
std::cout << "-1" << std::endl;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <cstdint>
#include <vector>
namespace n91 {
template <class Base> struct m2e61m1_rolling_hash {
using u64 = std::uint_fast64_t;
using value_type = u64;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
static constexpr u64 mask2(const int exp) noexcept {
return (static_cast<u64>(1) << exp) - static_cast<u64>(1);
}
static constexpr u64 Mod = mask2(61);
static constexpr u64 cyclic(const u64 v) noexcept {
return ((v & mask2(30)) << 31) + (v >> 30);
}
static constexpr u64 calc(u64 v) noexcept {
if (v > Mod) {
v = (v & mask2(61)) + (v >> 61);
}
if (v > Mod) {
return v -= Mod;
}
return v;
}
static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
/*
using t = __int128;
return t(l) * t(r) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld));
//*/
}
static constexpr u64 multiplies_plus(const u64 l, const u64 r,
const u64 c) noexcept {
/*
using t = __int128;
return (t(l) * t(r) + t(c)) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld) + c);
//*/
}
container_type prefix, power;
public:
template <class InputIterator>
explicit m2e61m1_rolling_hash(InputIterator first,
const InputIterator last) noexcept
: prefix(), power() {
const size_type n = static_cast<size_type>(std::distance(first, last));
prefix.reserve(n + static_cast<size_type>(1));
prefix.push_back(static_cast<value_type>(0));
for (; first != last; ++first) {
prefix.push_back(multiplies_plus(prefix.back(), Base::value, *first));
}
power.reserve(n + static_cast<size_type>(1));
power.push_back(static_cast<value_type>(1));
for (size_type i = static_cast<size_type>(0); i != n; ++i) {
power.push_back(multiplies(power.back(), Base::value));
}
}
value_type operator()(const size_type first,
const size_type last) const noexcept {
return multiplies_plus(prefix[first], power[last - first],
Mod - prefix[last]);
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using hash = m2e61m1_rolling_hash<std::integral_constant<u64, 100>>;
auto s = scan<std::string>();
const auto t = scan<std::string>();
const usize m = t.size();
while (s.size() < m) {
s = s + s;
}
const usize n = s.size();
s = s + s;
const hash sh(s.cbegin(), s.cend());
const u64 th = hash(t.cbegin(), t.cend())(0_z, m);
std::vector<usize> next(n, n), prev(n, n);
for (const auto i : rep(0_z, n)) {
if (sh(i, i + m) == th) {
next[i] = (i + m) % n;
prev[next[i]] = i;
}
}
usize r_cnt = 0_z;
usize ans = 0_z;
for (const auto i : rep(0_z, n)) {
if (prev[i] == n) {
++r_cnt;
usize count = 0_z;
usize v = next[i];
while (v != n) {
++r_cnt;
v = next[v];
++count;
}
ans = std::max(ans, count);
}
}
if (r_cnt == n) {
std::cout << ans << std::endl;
} else {
std::cout << "-1" << std::endl;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| [
"literal.number.change",
"function.return_value.change",
"expression.operation.binary.change",
"identifier.change"
] | 770,907 | 770,908 | u708618797 | cpp |
p02962 | //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <cstdint>
#include <vector>
namespace n91 {
template <class Base> struct m2e61m1_rolling_hash {
using u64 = std::uint_fast64_t;
using value_type = u64;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
static constexpr u64 mask2(const int exp) noexcept {
return (static_cast<u64>(1) << exp) - static_cast<u64>(1);
}
static constexpr u64 Mod = mask2(61);
static constexpr u64 cyclic(const u64 v) noexcept {
return ((v & mask2(30)) << 31) + (v >> 30);
}
static constexpr u64 calc(u64 v) noexcept {
if (v > Mod) {
v = (v & mask2(61)) + (v >> 61);
}
if (v > Mod) {
return v -= Mod;
}
return Mod;
}
static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
/*
using t = __int128;
return t(l) * t(r) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld));
//*/
}
static constexpr u64 multiplies_plus(const u64 l, const u64 r,
const u64 c) noexcept {
/*
using t = __int128;
return (t(l) * t(r) + t(c)) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld) + c);
//*/
}
container_type prefix, power;
public:
template <class InputIterator>
explicit m2e61m1_rolling_hash(InputIterator first,
const InputIterator last) noexcept
: prefix(), power() {
const size_type n = static_cast<size_type>(std::distance(first, last));
prefix.reserve(n + static_cast<size_type>(1));
prefix.push_back(static_cast<value_type>(0));
for (; first != last; ++first) {
prefix.push_back(multiplies_plus(prefix.back(), Base::value, *first));
}
power.reserve(n + static_cast<size_type>(1));
power.push_back(static_cast<value_type>(1));
for (size_type i = static_cast<size_type>(0); i != n; ++i) {
power.push_back(multiplies(power.back(), Base::value));
}
}
value_type operator()(const size_type first,
const size_type last) const noexcept {
return multiplies_plus(prefix[first], power[last - first],
Mod - prefix[last]);
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using hash = m2e61m1_rolling_hash<std::integral_constant<u64, 62479294>>;
auto s = scan<std::string>();
const auto t = scan<std::string>();
const usize m = t.size();
while (s.size() < m) {
s = s + s;
}
const usize n = s.size();
s = s + s;
const hash sh(s.cbegin(), s.cend());
const u64 th = hash(t.cbegin(), t.cend())(0_z, m);
std::vector<usize> next(n, n), prev(n, n);
for (const auto i : rep(0_z, n)) {
if (sh(i, i + m) == th) {
next[i] = (i + m) % n;
prev[next[i]] = i;
}
}
usize r_cnt = 0_z;
usize ans = 0_z;
for (const auto i : rep(0_z, n)) {
if (prev[i] == n) {
++r_cnt;
usize count = 0_z;
usize v = next[i];
while (v != n) {
++r_cnt;
v = next[v];
++count;
}
ans = std::max(ans, count);
}
}
if (r_cnt == n) {
std::cout << ans << std::endl;
} else {
std::cout << "-1" << std::endl;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| //#define NDEBUG
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
constexpr usize operator"" _z(unsigned long long x) noexcept {
return static_cast<usize>(x);
}
class rep {
const usize f, l;
public:
class itr {
friend rep;
usize i;
constexpr itr(const usize x) noexcept : i(x) {}
public:
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr rep(const usize first, const usize last) noexcept
: f(first), l(last) {}
constexpr itr begin() const noexcept { return itr(f); }
constexpr itr end() const noexcept { return itr(l); }
};
class revrep {
const usize f, l;
public:
class itr {
friend revrep;
usize i;
constexpr itr(usize x) noexcept : i(x) {}
public:
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {}
constexpr itr begin() const noexcept { return itr(l); }
constexpr itr end() const noexcept { return itr(f); }
};
template <class T> using vec_alias = std::vector<T>;
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) {
return a < b ? b - a : a - b;
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <cstdint>
#include <vector>
namespace n91 {
template <class Base> struct m2e61m1_rolling_hash {
using u64 = std::uint_fast64_t;
using value_type = u64;
using container_type = std::vector<value_type>;
using size_type = typename container_type::size_type;
static constexpr u64 mask2(const int exp) noexcept {
return (static_cast<u64>(1) << exp) - static_cast<u64>(1);
}
static constexpr u64 Mod = mask2(61);
static constexpr u64 cyclic(const u64 v) noexcept {
return ((v & mask2(30)) << 31) + (v >> 30);
}
static constexpr u64 calc(u64 v) noexcept {
if (v > Mod) {
v = (v & mask2(61)) + (v >> 61);
}
if (v > Mod) {
return v -= Mod;
}
return v;
}
static constexpr u64 multiplies(const u64 l, const u64 r) noexcept {
/*
using t = __int128;
return t(l) * t(r) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld));
//*/
}
static constexpr u64 multiplies_plus(const u64 l, const u64 r,
const u64 c) noexcept {
/*
using t = __int128;
return (t(l) * t(r) + t(c)) % t(Mod);
/*/
const u64 lu = l >> 31, ld = l & mask2(31), ru = r >> 31,
rd = r & mask2(31);
return calc((lu * ru << 1) + ld * rd + cyclic(lu * rd + ru * ld) + c);
//*/
}
container_type prefix, power;
public:
template <class InputIterator>
explicit m2e61m1_rolling_hash(InputIterator first,
const InputIterator last) noexcept
: prefix(), power() {
const size_type n = static_cast<size_type>(std::distance(first, last));
prefix.reserve(n + static_cast<size_type>(1));
prefix.push_back(static_cast<value_type>(0));
for (; first != last; ++first) {
prefix.push_back(multiplies_plus(prefix.back(), Base::value, *first));
}
power.reserve(n + static_cast<size_type>(1));
power.push_back(static_cast<value_type>(1));
for (size_type i = static_cast<size_type>(0); i != n; ++i) {
power.push_back(multiplies(power.back(), Base::value));
}
}
value_type operator()(const size_type first,
const size_type last) const noexcept {
return multiplies_plus(prefix[first], power[last - first],
Mod - prefix[last]);
}
};
} // namespace n91
#include <algorithm>
#include <array>
#include <iostream>
#include <string>
#include <utility>
namespace n91 {
void main_() {
using hash = m2e61m1_rolling_hash<std::integral_constant<u64, 100>>;
auto s = scan<std::string>();
const auto t = scan<std::string>();
const usize m = t.size();
while (s.size() < m) {
s = s + s;
}
const usize n = s.size();
s = s + s;
const hash sh(s.cbegin(), s.cend());
const u64 th = hash(t.cbegin(), t.cend())(0_z, m);
std::vector<usize> next(n, n), prev(n, n);
for (const auto i : rep(0_z, n)) {
if (sh(i, i + m) == th) {
next[i] = (i + m) % n;
prev[next[i]] = i;
}
}
usize r_cnt = 0_z;
usize ans = 0_z;
for (const auto i : rep(0_z, n)) {
if (prev[i] == n) {
++r_cnt;
usize count = 0_z;
usize v = next[i];
while (v != n) {
++r_cnt;
v = next[v];
++count;
}
ans = std::max(ans, count);
}
}
if (r_cnt == n) {
std::cout << ans << std::endl;
} else {
std::cout << "-1" << std::endl;
}
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| [
"identifier.change",
"function.return_value.change",
"literal.number.change"
] | 770,909 | 770,908 | u708618797 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
#define modulo 1000000007
#define mod(mod_x) ((((long long)mod_x)) % modulo)
#define Inf 10000000000000000
struct rolling_hash {
vector<long long> h;
vector<vector<long long>> t_hash;
vector<vector<long long>> power;
long long b;
string t;
rolling_hash(string &T) {
h.push_back(998244353);
h.push_back(1000000007);
h.push_back(1000000009);
t_hash.resize(h.size(), vector<long long>(T.size() + 1, 0));
power.resize(h.size(), vector<long long>(T.size() + 1, 1));
b = 1010101;
t = T;
for (int i = 0; i < h.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
power[i][j] = (power[i][j - 1] * b) % h[i];
}
}
for (int i = 0; i < h.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
t_hash[i][j] = ((t_hash[i][j - 1] * b + (long long)t[j - 1])) % h[i];
}
}
}
//[l,r)
vector<long long> get(int l, int r) {
vector<long long> ret(h.size());
for (int i = 0; i < h.size(); i++) {
ret[i] = t_hash[i][r] - (t_hash[i][l] * power[i][r - l]);
if (ret[i] >= 0)
ret[i] %= h[i];
else {
ret[i] = (-ret[i] % h[i]);
ret[i] = (h[i] - ret[i]) % h[i];
}
}
return ret;
}
};
int main() {
string s, t;
cin >> s >> t;
rolling_hash ro_t(t);
int sz = s.size();
while (true) {
if (s.size() >= t.size() * 2)
break;
s = s + s;
}
rolling_hash ro_s(s);
vector<vector<int>> E(sz, vector<int>(0));
vector<int> jisuu(sz, 0);
for (int i = 0; i < sz; i++) {
if (ro_s.get(i, i + t.size()) == ro_t.get(0, t.size())) {
int k = (i + (int)t.size()) % sz;
E[i].push_back(k);
jisuu[k]++;
}
}
queue<int> que;
vector<int> sorted(0);
for (int i = 0; i < sz; i++) {
if (jisuu[i] == 0) {
que.push(i);
}
}
while (que.size() != 0) {
int x = que.front();
que.pop();
sorted.push_back(x);
for (int i = 0; i < E[x].size(); i++) {
int a = E[x][i];
jisuu[a]--;
if (jisuu[a] == 0)
que.push(a);
}
}
vector<int> dis(sz, -1);
if (sorted.size() != sz) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < sz; i++) {
int now = sorted[i];
vector<int> k(0);
int cnt = 0;
while (true) {
if (dis[now] != -1) {
cnt += dis[now];
break;
}
k.push_back(now);
if (E[now].size() == 0)
break;
cnt++;
now = E[now][0];
}
for (int j = 0; j < k.size(); j++) {
dis[k[j]] = cnt - j;
}
}
int ans = 0;
for (int i = 0; i < sz; i++)
ans = max(ans, dis[i]);
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define modulo 1000000007
#define mod(mod_x) ((((long long)mod_x)) % modulo)
#define Inf 10000000000000000
struct rolling_hash {
vector<long long> h;
vector<vector<long long>> t_hash;
vector<vector<long long>> power;
long long b;
string t;
rolling_hash(string &T) {
h.push_back(998244353);
h.push_back(1000000007);
h.push_back(1000000009);
t_hash.resize(h.size(), vector<long long>(T.size() + 1, 0));
power.resize(h.size(), vector<long long>(T.size() + 1, 1));
b = 1010101;
t = T;
for (int i = 0; i < h.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
power[i][j] = (power[i][j - 1] * b) % h[i];
}
}
for (int i = 0; i < h.size(); i++) {
for (int j = 1; j <= t.size(); j++) {
t_hash[i][j] = ((t_hash[i][j - 1] * b + (long long)t[j - 1])) % h[i];
}
}
}
//[l,r)
vector<long long> get(int l, int r) {
vector<long long> ret(h.size());
for (int i = 0; i < h.size(); i++) {
ret[i] = t_hash[i][r] - (t_hash[i][l] * power[i][r - l]);
if (ret[i] >= 0)
ret[i] %= h[i];
else {
ret[i] = (-ret[i] % h[i]);
ret[i] = (h[i] - ret[i]) % h[i];
}
}
return ret;
}
};
int main() {
string s, t;
cin >> s >> t;
rolling_hash ro_t(t);
int sz = s.size();
s = s + s;
while (true) {
if (s.size() >= t.size() * 2)
break;
s = s + s;
}
rolling_hash ro_s(s);
vector<vector<int>> E(sz, vector<int>(0));
vector<int> jisuu(sz, 0);
for (int i = 0; i < sz; i++) {
if (ro_s.get(i, i + t.size()) == ro_t.get(0, t.size())) {
int k = (i + (int)t.size()) % sz;
E[i].push_back(k);
jisuu[k]++;
}
}
queue<int> que;
vector<int> sorted(0);
for (int i = 0; i < sz; i++) {
if (jisuu[i] == 0) {
que.push(i);
}
}
while (que.size() != 0) {
int x = que.front();
que.pop();
sorted.push_back(x);
for (int i = 0; i < E[x].size(); i++) {
int a = E[x][i];
jisuu[a]--;
if (jisuu[a] == 0)
que.push(a);
}
}
vector<int> dis(sz, -1);
if (sorted.size() != sz) {
cout << -1 << endl;
return 0;
}
for (int i = 0; i < sz; i++) {
int now = sorted[i];
vector<int> k(0);
int cnt = 0;
while (true) {
if (dis[now] != -1) {
cnt += dis[now];
break;
}
k.push_back(now);
if (E[now].size() == 0)
break;
cnt++;
now = E[now][0];
}
for (int j = 0; j < k.size(); j++) {
dis[k[j]] = cnt - j;
}
}
int ans = 0;
for (int i = 0; i < sz; i++)
ans = max(ans, dis[i]);
cout << ans << endl;
return 0;
}
| [
"assignment.add"
] | 770,918 | 770,919 | u118797367 | cpp |
p02962 | #include <algorithm> // minmax, sort, swap
#include <climits> // INT_MIN, LLONG_MIN
#include <cmath> // long, trig, pow
#include <cstdio> // printf, scanf
#include <deque> // deque
#include <functional> // std::function<void(int)>
#include <iomanip> // cout<<setprecision(n)
#include <iostream> // cin, cout, cerr, clog
#include <map> // key-value pairs sorted by keys
#include <numeric> // iota, accumulate, inner_product
#include <queue> // queue, priority_queue
#include <set> // set
#include <string> // string, stoi, to_string
#include <unordered_map> // hashed by keys
#include <unordered_set> // hashed by keys
#include <vector> // vector
#define rep(i, n) for (int i = 0; i < n; i++)
#define ENDL "\n"
#define print(i) std::cout << (i) << "\n"
#define int long long // at least int64 > 9*10^18
#define all(v) v.begin(), v.end()
#define ceil(a, b) (a % b ? a / b + 1 : a / b)
#define dump1(v) \
for (auto i : v) \
std::cout << i << ' '; \
std::cout << "\n";
struct FastIO {
FastIO() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
} fastio;
struct ZAlgorithm {
std::vector<int> z;
ZAlgorithm(std::string s) : z(s.size(), 0) {
int l, r;
// [l,r)
l = r = 0;
for (int i = 1; i < s.size(); i++) {
if (i >= r) {
l = r = i;
while (r < s.size() && s[r] == s[r - l])
r++;
z[i] = r - l;
continue;
}
if (z[i - l] < r - i) {
z[i] = z[i - l];
continue;
}
l = i;
while (r < s.size() && s[r] == s[r - l])
r++;
z[i] = r - l;
continue;
}
z[0] = s.size();
}
};
int dfs(int i, int c, std::vector<int> &to, std::vector<int> &went) {
if (to[c] == i)
return -1;
if (to[c] == -1)
return 0;
if (went[c] > 0)
return went[c];
int x = dfs(i, to[c], to, went);
if (x == -1)
return -1;
return went[c] = x + 1;
}
signed main() {
std::string s;
std::string t;
std::cin >> s >> t;
std::string a = "";
int t_sz = t.size();
int s_sz = s.size();
while (a.size() < s_sz + t_sz)
a += s;
std::string x = t + '$' + a;
ZAlgorithm z(x);
std::vector<int> zz(s_sz);
rep(i, s_sz) zz[i] = z.z[t_sz + 1 + i];
std::vector<int> to(s_sz, -1);
rep(i, s_sz) if (zz[i] == t_sz) to[i] = (i + t_sz) % s_sz;
std::vector<int> went(s_sz, 0);
rep(i, s_sz) {
if (zz[i] != t_sz)
continue;
if (dfs(i, i, to, went) == -1) {
print(-1);
return 0;
}
}
int max = 0;
for (auto i : went)
max = std::max(max, i);
dump1(went);
print(max);
return 0;
}
| #include <algorithm> // minmax, sort, swap
#include <climits> // INT_MIN, LLONG_MIN
#include <cmath> // long, trig, pow
#include <cstdio> // printf, scanf
#include <deque> // deque
#include <functional> // std::function<void(int)>
#include <iomanip> // cout<<setprecision(n)
#include <iostream> // cin, cout, cerr, clog
#include <map> // key-value pairs sorted by keys
#include <numeric> // iota, accumulate, inner_product
#include <queue> // queue, priority_queue
#include <set> // set
#include <string> // string, stoi, to_string
#include <unordered_map> // hashed by keys
#include <unordered_set> // hashed by keys
#include <vector> // vector
#define rep(i, n) for (int i = 0; i < n; i++)
#define ENDL "\n"
#define print(i) std::cout << (i) << "\n"
#define int long long // at least int64 > 9*10^18
#define all(v) v.begin(), v.end()
#define ceil(a, b) (a % b ? a / b + 1 : a / b)
#define dump1(v) \
for (auto i : v) \
std::cout << i << ' '; \
std::cout << "\n";
struct FastIO {
FastIO() {
std::cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
} fastio;
struct ZAlgorithm {
std::vector<int> z;
ZAlgorithm(std::string s) : z(s.size(), 0) {
int l, r;
// [l,r)
l = r = 0;
for (int i = 1; i < s.size(); i++) {
if (i >= r) {
l = r = i;
while (r < s.size() && s[r] == s[r - l])
r++;
z[i] = r - l;
continue;
}
if (z[i - l] < r - i) {
z[i] = z[i - l];
continue;
}
l = i;
while (r < s.size() && s[r] == s[r - l])
r++;
z[i] = r - l;
continue;
}
z[0] = s.size();
}
};
int dfs(int i, int c, std::vector<int> &to, std::vector<int> &went) {
if (to[c] == i)
return -1;
if (to[c] == -1)
return 0;
if (went[c] > 0)
return went[c];
int x = dfs(i, to[c], to, went);
if (x == -1)
return -1;
return went[c] = x + 1;
}
signed main() {
std::string s;
std::string t;
std::cin >> s >> t;
std::string a = "";
int t_sz = t.size();
int s_sz = s.size();
while (a.size() < s_sz + t_sz)
a += s;
std::string x = t + '$' + a;
ZAlgorithm z(x);
std::vector<int> zz(s_sz);
rep(i, s_sz) zz[i] = z.z[t_sz + 1 + i];
std::vector<int> to(s_sz, -1);
rep(i, s_sz) if (zz[i] == t_sz) to[i] = (i + t_sz) % s_sz;
std::vector<int> went(s_sz, 0);
rep(i, s_sz) {
if (zz[i] != t_sz)
continue;
if (dfs(i, i, to, went) == -1) {
print(-1);
return 0;
}
}
int max = 0;
for (auto i : went)
max = std::max(max, i);
print(max);
return 0;
}
| [
"call.remove"
] | 770,929 | 770,930 | u128456980 | cpp |
p02962 | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
const int iINF = 2147483647 / 2;
const long long int llINF = 9223372036854775807 / 2;
using namespace std;
using ll = long long int;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
typedef pair<ll, ll> pll;
bool paircomp(const pll &a, const pll &b) {
if (a.first == b.first)
return a.second < b.second;
return a.first < b.first;
}
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define AUTO(i, m) for (auto &i : m)
#define ALL(a) (a).begin(), (a).end()
#define MAX(vec) *std::max_element(vec.begin(), vec.end())
#define MIN(vec) *std::min_element(vec.begin(), vec.end())
#define ARGMAX(vec) \
std::distance(vec.begin(), std::max_element(vec.begin(), vec.end()))
#define ARGMIN(vec) \
std::distance(vec.begin(), std::min_element(vec.begin(), vec.end()))
#define REV(T) greater<T>()
#define PQ(T) priority_queue<T, vector<T>, greater<T>>
#define VVL(a, b, c) vector<vector<ll>>(a, vector<ll>(b, c))
#define VVVL(a, b, c, d) \
vector<vector<vector<ll>>>(a, vector<vector<ll>>(b, vector<ll>(c, d)))
#define SP(a) setprecision(a)
#define SQRT(a) sqrt((long double)(a))
#define DPOW(a, b) pow((long double)(a), (long double)(b))
#define UNIQUE(vec) \
do { \
sort(ALL((vec))); \
(vec).erase(std::unique(ALL((vec))), (vec).end()); \
} while (0)
ll POW(ll n, ll m) {
if (m == 0) {
return 1;
} else if (m % 2 == 0) {
ll tmp = POW(n, m / 2);
return (tmp * tmp);
} else {
return (n * POW(n, m - 1));
}
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
vl kmp(const string &s, const string &t) {
vl ta(t.size() + 1);
{
ta[0] = -1;
ll j = -1;
for (ll i = 0; i < t.size(); i++) {
while (j >= 0 && t[i] != t[j])
j = ta[j];
ta[i + 1] = ++j;
}
}
vl ret;
ll m = 0, i = 0, n = s.size();
while (m + i < n) {
if (t[i] == s[m + i]) {
if (++i == (ll)t.size()) {
ret.push_back(m);
m = m + i - ta[i];
i = ta[i];
}
} else {
m = m + i - ta[i];
if (i > 0)
i = ta[i];
}
}
return ret;
}
struct UnionFind {
vector<ll> data;
UnionFind(ll sz) { data.assign(sz, -1); }
bool unite(ll x, ll y) {
x = root(x), y = root(y);
if (x == y)
return (false);
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
ll root(ll k) {
if (data[k] < 0)
return (k);
return (data[k] = root(data[k]));
}
ll size(ll k) { return (-data[root(k)]); }
ll same(ll a, ll b) { return root(a) == root(b); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
ll slen = s.size();
ll tlen = t.size();
string ss = s;
while (ss.size() < tlen)
ss += s;
// ss += ss;
vl z = kmp(ss, t);
auto uf = UnionFind(slen);
REP(i, z.size()) {
ll x = z[i];
if (x >= slen)
continue; //重複するため
ll y = (x + tlen) % slen;
if (!uf.unite(x, y)) { //ループしてる
cout << -1 << endl;
return 0;
}
}
ll ans = 0;
REP(i, slen) ans = max(ans, uf.size(i) - 1LL);
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
const int iINF = 2147483647 / 2;
const long long int llINF = 9223372036854775807 / 2;
using namespace std;
using ll = long long int;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
typedef pair<ll, ll> pll;
bool paircomp(const pll &a, const pll &b) {
if (a.first == b.first)
return a.second < b.second;
return a.first < b.first;
}
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define AUTO(i, m) for (auto &i : m)
#define ALL(a) (a).begin(), (a).end()
#define MAX(vec) *std::max_element(vec.begin(), vec.end())
#define MIN(vec) *std::min_element(vec.begin(), vec.end())
#define ARGMAX(vec) \
std::distance(vec.begin(), std::max_element(vec.begin(), vec.end()))
#define ARGMIN(vec) \
std::distance(vec.begin(), std::min_element(vec.begin(), vec.end()))
#define REV(T) greater<T>()
#define PQ(T) priority_queue<T, vector<T>, greater<T>>
#define VVL(a, b, c) vector<vector<ll>>(a, vector<ll>(b, c))
#define VVVL(a, b, c, d) \
vector<vector<vector<ll>>>(a, vector<vector<ll>>(b, vector<ll>(c, d)))
#define SP(a) setprecision(a)
#define SQRT(a) sqrt((long double)(a))
#define DPOW(a, b) pow((long double)(a), (long double)(b))
#define UNIQUE(vec) \
do { \
sort(ALL((vec))); \
(vec).erase(std::unique(ALL((vec))), (vec).end()); \
} while (0)
ll POW(ll n, ll m) {
if (m == 0) {
return 1;
} else if (m % 2 == 0) {
ll tmp = POW(n, m / 2);
return (tmp * tmp);
} else {
return (n * POW(n, m - 1));
}
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
vl kmp(const string &s, const string &t) {
vl ta(t.size() + 1);
{
ta[0] = -1;
ll j = -1;
for (ll i = 0; i < t.size(); i++) {
while (j >= 0 && t[i] != t[j])
j = ta[j];
ta[i + 1] = ++j;
}
}
vl ret;
ll m = 0, i = 0, n = s.size();
while (m + i < n) {
if (t[i] == s[m + i]) {
if (++i == (ll)t.size()) {
ret.push_back(m);
m = m + i - ta[i];
i = ta[i];
}
} else {
m = m + i - ta[i];
if (i > 0)
i = ta[i];
}
}
return ret;
}
struct UnionFind {
vector<ll> data;
UnionFind(ll sz) { data.assign(sz, -1); }
bool unite(ll x, ll y) {
x = root(x), y = root(y);
if (x == y)
return (false);
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
ll root(ll k) {
if (data[k] < 0)
return (k);
return (data[k] = root(data[k]));
}
ll size(ll k) { return (-data[root(k)]); }
ll same(ll a, ll b) { return root(a) == root(b); }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s, t;
cin >> s >> t;
ll slen = s.size();
ll tlen = t.size();
string ss = s;
while (ss.size() < tlen)
ss += s;
ss += ss;
vl z = kmp(ss, t);
auto uf = UnionFind(slen);
REP(i, z.size()) {
ll x = z[i];
if (x >= slen)
continue; //重複するため
ll y = (x + tlen) % slen;
if (!uf.unite(x, y)) { //ループしてる
cout << -1 << endl;
return 0;
}
}
ll ans = 0;
REP(i, slen) ans = max(ans, uf.size(i) - 1LL);
cout << ans << endl;
return 0;
}
| [
"assignment.add"
] | 770,955 | 770,956 | u050865477 | cpp |
p02962 | #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using i64 = int64_t;
using i32 = int32_t;
template <class T, class U> void init_n(vector<T> &v, size_t n, U x) {
v = vector<T>(n, x);
}
template <class T> void init_n(vector<T> &v, size_t n) { init_n(v, n, T()); }
template <class T> void read_n(vector<T> &v, size_t n, size_t o = 0) {
v = vector<T>(n + o);
for (size_t i = o; i < n + o; ++i)
cin >> v[i];
}
template <class T> void read_n(T a[], size_t n, size_t o = 0) {
for (size_t i = o; i < n + o; ++i)
cin >> a[i];
}
template <class T> T gabs(const T &x) { return max(x, -x); }
#define abs gabs
template <unsigned long long M, unsigned long long B> struct BasicRollingHash {
using Uint = unsigned long long;
using U128 = __uint128_t;
vector<Uint> hashes, pows;
template <class T> BasicRollingHash(const T &s) { init(s); }
template <class T> void init(const T &s) {
size_t n = s.size();
hashes.assign(n + 1, 0);
pows.assign(n + 1, 0);
pows[0] = 1;
for (size_t i = 1; i <= n; ++i) {
hashes[i] = U128(hashes[i - 1] + s[i - 1]) * B % M;
pows[i] = U128(pows[i - 1]) * B % M;
}
}
template <class T> static Uint hash_once(const T &s) {
Uint h = 0;
for (size_t i = 1; i <= s.size(); ++i) {
h = U128(h + s[i - 1]) * B % M;
}
return h;
}
// [l, r)
Uint hash(size_t l, size_t r) const {
r = min(r, size());
U128 h = M + U128(hashes[r]) - U128(pows[r - l]) * hashes[l] % M;
if (h > M)
h -= M;
return h;
}
size_t size() const { return hashes.size() - 1; }
template <class T>
vector<size_t> search_all(const T &s, size_t l = 0,
size_t r = 1 << 30) const {
auto h = hash_once(s);
int n = s.size();
vector<size_t> res;
for (int i = l; i <= int(min(r, size() - n)); ++i) {
if (hash(i, i + n) == h)
res.push_back(i);
}
return res;
}
};
using RollingHash = BasicRollingHash<(1ull << 61) - 1, 263>;
int main() {
string s, t;
cin >> s >> t;
while (s.size() < t.size()) {
s += s;
}
i64 n = s.size();
s = s + s + s;
auto ms = RollingHash(s).search_all(t);
vector<i64> dp(s.size());
vector<bool> mp(s.size());
i64 m = t.size();
for (i64 i : ms) {
mp[i] = true;
}
i64 ans = 0;
for (i64 i = 0; i < s.size(); ++i) {
if (mp[i])
dp[i]++;
if (i - m >= 0)
dp[i] += dp[i - m];
if (i < 2 * n) {
ans = max(ans, dp[i]);
} else if (ans > dp[i]) {
cout << -1 << endl;
return 0;
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using i64 = int64_t;
using i32 = int32_t;
template <class T, class U> void init_n(vector<T> &v, size_t n, U x) {
v = vector<T>(n, x);
}
template <class T> void init_n(vector<T> &v, size_t n) { init_n(v, n, T()); }
template <class T> void read_n(vector<T> &v, size_t n, size_t o = 0) {
v = vector<T>(n + o);
for (size_t i = o; i < n + o; ++i)
cin >> v[i];
}
template <class T> void read_n(T a[], size_t n, size_t o = 0) {
for (size_t i = o; i < n + o; ++i)
cin >> a[i];
}
template <class T> T gabs(const T &x) { return max(x, -x); }
#define abs gabs
template <unsigned long long M, unsigned long long B> struct BasicRollingHash {
using Uint = unsigned long long;
using U128 = __uint128_t;
vector<Uint> hashes, pows;
template <class T> BasicRollingHash(const T &s) { init(s); }
template <class T> void init(const T &s) {
size_t n = s.size();
hashes.assign(n + 1, 0);
pows.assign(n + 1, 0);
pows[0] = 1;
for (size_t i = 1; i <= n; ++i) {
hashes[i] = U128(hashes[i - 1] + s[i - 1]) * B % M;
pows[i] = U128(pows[i - 1]) * B % M;
}
}
template <class T> static Uint hash_once(const T &s) {
Uint h = 0;
for (size_t i = 1; i <= s.size(); ++i) {
h = U128(h + s[i - 1]) * B % M;
}
return h;
}
// [l, r)
Uint hash(size_t l, size_t r) const {
r = min(r, size());
U128 h = M + U128(hashes[r]) - U128(pows[r - l]) * hashes[l] % M;
if (h > M)
h -= M;
return h;
}
size_t size() const { return hashes.size() - 1; }
template <class T>
vector<size_t> search_all(const T &s, size_t l = 0,
size_t r = 1 << 30) const {
auto h = hash_once(s);
int n = s.size();
vector<size_t> res;
for (int i = l; i <= int(min(r, size() - n)); ++i) {
if (hash(i, i + n) == h)
res.push_back(i);
}
return res;
}
};
using RollingHash = BasicRollingHash<(1ull << 61) - 1, 263>;
int main() {
string s, t;
cin >> s >> t;
while (s.size() < t.size()) {
s += s;
}
i64 n = s.size();
s = s + s + s + s;
auto ms = RollingHash(s).search_all(t);
vector<i64> dp(s.size());
vector<bool> mp(s.size());
i64 m = t.size();
for (i64 i : ms) {
mp[i] = true;
}
i64 ans = 0;
for (i64 i = 0; i < s.size(); ++i) {
if (mp[i]) {
dp[i]++;
if (i - m >= 0)
dp[i] += dp[i - m];
}
if (i < 2 * n) {
ans = max(ans, dp[i]);
} else if (ans < dp[i]) {
cout << -1 << endl;
return 0;
}
}
cout << ans << endl;
return 0;
}
| [
"assignment.change",
"misc.opposites",
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 770,985 | 770,984 | u090994275 | cpp |
p02962 | #include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define ALL(x) x.begin(), x.end()
#define db(x) cout << #x << "=" << x << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, m, n) for (int i = m; i < n; i++)
#define repr(i, n, m) for (int i = n; i >= m; i--)
#define INF (1e9)
#define PI (acos(-1))
using namespace std;
typedef long long ll;
//文字列検索 KMP法
// kmp をやるための前計算
// 0-iの接頭辞と接尾辞が何文字まであっているかをTableに保存
vector<int> makeTable(const string &s) {
int n = s.size();
vector<int> ret(n + 1);
ret[0] = -1;
int j = -1;
for (int i = 0; i < n; i++) {
while (j >= 0 && s[i] != s[j])
j = ret[j];
ret[i + 1] = ++j;
}
return ret;
}
// str の中に word とマッチする場所のリストを返す
// ret のそれぞれの要素 el は, 「str[el] からの文字列が word
// と一致する」ことを示す
vector<int> kmp(const string &str, const string &word) {
vector<int> table = makeTable(word), ret;
int m = 0, i = 0, n = str.size();
while (m + i < n) {
if (word[i] == str[m + i]) {
if (++i == (int)(word.size())) {
ret.push_back(m);
m = m + i - table[i];
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return ret;
}
int main() {
string s, t;
cin >> s >> t;
int sl = s.length();
int tl = t.length();
string news = "";
int n = min(1, (2 * tl) / sl); //ここ？
news.reserve(sl * (n + 1));
rep(i, n + 1) { news += s; }
int newsl = news.length();
vector<int> kr = kmp(news, t);
//入ってたら1、通ったら-1
int a[sl] = {};
int ctr[sl] = {};
rep(i, kr.size()) {
if (kr[i] >= sl)
break;
a[kr[i]] = 1;
}
int maxct = 0;
rep(i, sl) {
if (a[i] != 1)
continue;
int itr;
int ct = 0;
itr = i;
while (a[itr] == 1) {
ct++;
a[itr] = -1;
itr = (itr + tl) % sl;
}
if (itr == i) {
std::cout << -1 << '\n';
return 0;
}
ct += ctr[itr];
ctr[i] = ct;
maxct = max(maxct, ct);
}
cout << maxct << endl;
return 0;
}
| #include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define ALL(x) x.begin(), x.end()
#define db(x) cout << #x << "=" << x << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, m, n) for (int i = m; i < n; i++)
#define repr(i, n, m) for (int i = n; i >= m; i--)
#define INF (1e9)
#define PI (acos(-1))
using namespace std;
typedef long long ll;
//文字列検索 KMP法
// kmp をやるための前計算
// 0-iの接頭辞と接尾辞が何文字まであっているかをTableに保存
vector<int> makeTable(const string &s) {
int n = s.size();
vector<int> ret(n + 1);
ret[0] = -1;
int j = -1;
for (int i = 0; i < n; i++) {
while (j >= 0 && s[i] != s[j])
j = ret[j];
ret[i + 1] = ++j;
}
return ret;
}
// str の中に word とマッチする場所のリストを返す
// ret のそれぞれの要素 el は, 「str[el] からの文字列が word
// と一致する」ことを示す
vector<int> kmp(const string &str, const string &word) {
vector<int> table = makeTable(word), ret;
int m = 0, i = 0, n = str.size();
while (m + i < n) {
if (word[i] == str[m + i]) {
if (++i == (int)(word.size())) {
ret.push_back(m);
m = m + i - table[i];
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return ret;
}
int main() {
string s, t;
cin >> s >> t;
int sl = s.length();
int tl = t.length();
string news = "";
int n = max(1, (2 * tl) / sl); //ここ？
news.reserve(sl * (n + 1));
rep(i, n + 1) { news += s; }
int newsl = news.length();
vector<int> kr = kmp(news, t);
//入ってたら1、通ったら-1
int a[sl] = {};
int ctr[sl] = {};
rep(i, kr.size()) {
if (kr[i] >= sl)
break;
a[kr[i]] = 1;
}
int maxct = 0;
rep(i, sl) {
if (a[i] != 1)
continue;
int itr;
int ct = 0;
itr = i;
while (a[itr] == 1) {
ct++;
a[itr] = -1;
itr = (itr + tl) % sl;
}
if (itr == i) {
std::cout << -1 << '\n';
return 0;
}
ct += ctr[itr];
ctr[i] = ct;
maxct = max(maxct, ct);
}
cout << maxct << endl;
return 0;
}
| [
"misc.opposites",
"identifier.change",
"call.function.change"
] | 770,986 | 770,987 | u556276145 | cpp |
p02962 | #include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define ALL(x) x.begin(), x.end()
#define db(x) cout << #x << "=" << x << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, m, n) for (int i = m; i < n; i++)
#define repr(i, n, m) for (int i = n; i >= m; i--)
#define INF (1e9)
#define PI (acos(-1))
using namespace std;
typedef long long ll;
//文字列検索 KMP法
// kmp をやるための前計算
// 0-iの接頭辞と接尾辞が何文字まであっているかをTableに保存
vector<int> makeTable(const string &s) {
int n = s.size();
vector<int> ret(n + 1);
ret[0] = -1;
int j = -1;
for (int i = 0; i < n; i++) {
while (j >= 0 && s[i] != s[j])
j = ret[j];
ret[i + 1] = ++j;
}
return ret;
}
// str の中に word とマッチする場所のリストを返す
// ret のそれぞれの要素 el は, 「str[el] からの文字列が word
// と一致する」ことを示す
vector<int> kmp(const string &str, const string &word) {
vector<int> table = makeTable(word), ret;
int m = 0, i = 0, n = str.size();
while (m + i < n) {
if (word[i] == str[m + i]) {
if (++i == (int)(word.size())) {
ret.push_back(m);
m = m + i - table[i];
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return ret;
}
int main() {
string s, t;
cin >> s >> t;
int sl = s.length();
int tl = t.length();
string news = "";
int n = (2 * tl) / sl;
news.reserve(sl * (n + 1));
rep(i, n + 1) { news += s; }
int newsl = news.length();
vector<int> kr = kmp(news, t);
//入ってたら1、通ったら-1
int a[sl] = {};
int ctr[sl] = {};
rep(i, kr.size()) {
if (kr[i] >= sl)
break;
a[kr[i]] = 1;
}
int maxct = 0;
rep(i, sl) {
if (a[i] != 1)
continue;
int itr;
int ct = 0;
itr = i;
while (a[itr] == 1) {
ct++;
a[itr] = -1;
itr = (itr + tl) % sl;
}
if (itr == i) {
std::cout << -1 << '\n';
return 0;
}
ct += ctr[itr];
ctr[i] = ct;
maxct = max(maxct, ct);
}
cout << maxct << endl;
return 0;
}
| #include <bits/stdc++.h>
#define SORT(x) sort((x).begin(), (x).end())
#define ALL(x) x.begin(), x.end()
#define db(x) cout << #x << "=" << x << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define reps(i, m, n) for (int i = m; i < n; i++)
#define repr(i, n, m) for (int i = n; i >= m; i--)
#define INF (1e9)
#define PI (acos(-1))
using namespace std;
typedef long long ll;
//文字列検索 KMP法
// kmp をやるための前計算
// 0-iの接頭辞と接尾辞が何文字まであっているかをTableに保存
vector<int> makeTable(const string &s) {
int n = s.size();
vector<int> ret(n + 1);
ret[0] = -1;
int j = -1;
for (int i = 0; i < n; i++) {
while (j >= 0 && s[i] != s[j])
j = ret[j];
ret[i + 1] = ++j;
}
return ret;
}
// str の中に word とマッチする場所のリストを返す
// ret のそれぞれの要素 el は, 「str[el] からの文字列が word
// と一致する」ことを示す
vector<int> kmp(const string &str, const string &word) {
vector<int> table = makeTable(word), ret;
int m = 0, i = 0, n = str.size();
while (m + i < n) {
if (word[i] == str[m + i]) {
if (++i == (int)(word.size())) {
ret.push_back(m);
m = m + i - table[i];
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return ret;
}
int main() {
string s, t;
cin >> s >> t;
int sl = s.length();
int tl = t.length();
string news = "";
int n = max(1, (2 * tl) / sl); //ここ？
news.reserve(sl * (n + 1));
rep(i, n + 1) { news += s; }
int newsl = news.length();
vector<int> kr = kmp(news, t);
//入ってたら1、通ったら-1
int a[sl] = {};
int ctr[sl] = {};
rep(i, kr.size()) {
if (kr[i] >= sl)
break;
a[kr[i]] = 1;
}
int maxct = 0;
rep(i, sl) {
if (a[i] != 1)
continue;
int itr;
int ct = 0;
itr = i;
while (a[itr] == 1) {
ct++;
a[itr] = -1;
itr = (itr + tl) % sl;
}
if (itr == i) {
std::cout << -1 << '\n';
return 0;
}
ct += ctr[itr];
ctr[i] = ct;
maxct = max(maxct, ct);
}
cout << maxct << endl;
return 0;
}
| [
"call.add",
"call.arguments.change"
] | 770,991 | 770,987 | u556276145 | cpp |
p02962 | // By Hacheylight
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
//#define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define loop(it, v) for (auto it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (int i = head[x]; i; i = e[i].nxt)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, sum) memset(a, sum, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define SC(t, x) static_cast<t>(x)
#define ub upper_bound
#define lb lower_bound
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define pof pop_front
#define pob pop_back
#define fi first
#define se second
#define y1 y1_
#define Pi acos(-1.0)
#define iv inline void
#define enter cout << endl
#define siz(x) ((int)x.size())
#define file(x) freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout)
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<int, pii> tri;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<vi> vvi;
typedef queue<int> qi;
typedef queue<pii> qii;
typedef set<int> si;
typedef map<int, int> mii;
typedef map<string, int> msi;
const int N = 4000010;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const ll linf = 2e18;
const int mod = 1000000007;
const double eps = 1e-7;
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T> void print(T a) {
cout << a << endl;
exit(0);
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
void add(int &a, int b) { a = a + b < mod ? a + b : a + b - mod; }
void sub(int &a, int b) { a = (a - b + mod) % mod; }
void mul(int &a, int b) { a = (ll)a * b % mod; }
int addv(int a, int b) { return (a += b) >= mod ? a -= mod : a; }
int subv(int a, int b) { return (a -= b) < 0 ? a += mod : a; }
int mulv(int a, int b) { return (ll)a * b % mod; }
int read() {
int f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-')
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int pw(int a, int b) {
int s = 1;
for (; b; b >>= 1, a = (ll)a * a % mod)
if (b & 1)
s = (ll)s * a % mod;
return s;
}
char s[N], t[N];
int n, m, k, ans;
int fail[N], dp[N];
signed main() {
scanf("%s%s", s + 1, t + 1);
k = strlen(s + 1), n = k, m = strlen(t + 1);
while (n < m * 2) {
rep(i, 1, n) s[n + i] = s[i];
n *= 2;
}
rep(i, 1, n) s[n + i] = s[i];
n *= 2;
fail[0] = -1;
rep(i, 1, m) {
int j = i - 1;
for (int j = i - 1; j && t[fail[j] + 1] != t[i]; j = fail[j])
;
fail[i] = fail[j] + 1;
}
int j = 0;
rep(i, 1, n) {
for (; ~j && s[i] != t[j + 1]; j = fail[j])
;
j++;
if (j == m)
dp[i] = dp[i - m] + 1, chmax(ans, dp[i]);
}
if (ans >= n / m - 1)
ans = -1;
printf("%d\n", ans);
return 0;
}
| // By Hacheylight
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
//#define int long long
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define loop(it, v) for (auto it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (int i = head[x]; i; i = e[i].nxt)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, sum) memset(a, sum, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define SC(t, x) static_cast<t>(x)
#define ub upper_bound
#define lb lower_bound
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define pof pop_front
#define pob pop_back
#define fi first
#define se second
#define y1 y1_
#define Pi acos(-1.0)
#define iv inline void
#define enter cout << endl
#define siz(x) ((int)x.size())
#define file(x) freopen(x ".in", "r", stdin), freopen(x ".out", "w", stdout)
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<int, pii> tri;
typedef vector<int> vi;
typedef vector<pii> vii;
typedef vector<vi> vvi;
typedef queue<int> qi;
typedef queue<pii> qii;
typedef set<int> si;
typedef map<int, int> mii;
typedef map<string, int> msi;
const int N = 4000010;
const int INF = 0x3f3f3f3f;
const int iinf = 1 << 30;
const ll linf = 2e18;
const int mod = 1000000007;
const double eps = 1e-7;
void douout(double x) { printf("%lf\n", x + 0.0000000001); }
template <class T> void print(T a) {
cout << a << endl;
exit(0);
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
void add(int &a, int b) { a = a + b < mod ? a + b : a + b - mod; }
void sub(int &a, int b) { a = (a - b + mod) % mod; }
void mul(int &a, int b) { a = (ll)a * b % mod; }
int addv(int a, int b) { return (a += b) >= mod ? a -= mod : a; }
int subv(int a, int b) { return (a -= b) < 0 ? a += mod : a; }
int mulv(int a, int b) { return (ll)a * b % mod; }
int read() {
int f = 1, x = 0;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-')
f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int pw(int a, int b) {
int s = 1;
for (; b; b >>= 1, a = (ll)a * a % mod)
if (b & 1)
s = (ll)s * a % mod;
return s;
}
char s[N], t[N];
int n, m, k, ans;
int fail[N], dp[N];
signed main() {
scanf("%s%s", s + 1, t + 1);
k = strlen(s + 1), n = k, m = strlen(t + 1);
while (n < m * 2) {
rep(i, 1, n) s[n + i] = s[i];
n *= 2;
}
rep(i, 1, n) s[n + i] = s[i];
n *= 2;
fail[0] = -1;
rep(i, 1, m) {
int j = i - 1;
for (; j && t[fail[j] + 1] != t[i]; j = fail[j])
;
fail[i] = fail[j] + 1;
}
int j = 0;
rep(i, 1, n) {
for (; ~j && s[i] != t[j + 1]; j = fail[j])
;
j++;
if (j == m)
dp[i] = dp[i - m] + 1, chmax(ans, dp[i]);
}
if (ans >= n / m - 1)
ans = -1;
printf("%d\n", ans);
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"variable_declaration.remove"
] | 771,003 | 771,004 | u049262741 | cpp |
p02962 | /*********************
* Author: xuziyuan *
*********************/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
#define LL long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#define mpr make_pair
#define sqr(a) ((a) * (a))
using namespace std;
const LL MOD = 1e9 + 7;
string s, ss, t;
LL h[4000010], h2[4000010], pw[4000010], pw2[4000010],
hn = 998544353, hn2 = 827122193, ht[1000010], ht2[1000010], res[4000010],
ans = 0;
pii gethash(LL a, LL b) {
return {(h[b + 1] - h[a] * pw[b - a + 1] % MOD + MOD) % MOD,
(h2[b + 1] - h2[a] * pw2[b - a + 1] % MOD + MOD) % MOD};
}
pii gethash2(LL a, LL b) {
return {(ht[b + 1] - ht[a] * pw[b - a + 1] % MOD + MOD) % MOD,
(ht2[b + 1] - ht2[a] * pw2[b - a + 1] % MOD + MOD) % MOD};
}
int main() {
pw[0] = pw2[0] = 1;
repn(i, 4000005) {
pw[i] = pw[i - 1] * hn % MOD;
pw2[i] = pw2[i - 1] * hn2 % MOD;
}
cin >> s >> t;
ss = s;
s += s;
s += s;
repn(i, s.size()) {
h[i] = (h[i - 1] * hn + s[i - 1] - 'a') % MOD;
h2[i] = (h2[i - 1] * hn2 + s[i - 1] - 'a') % MOD;
}
repn(i, t.size()) {
ht[i] = (ht[i - 1] * hn + t[i - 1] - 'a') % MOD;
ht2[i] = (ht2[i - 1] * hn2 + t[i - 1] - 'a') % MOD;
}
bool iss = true;
rep(i, s.size()) {
LL lb = i, num = 0;
while (lb < s.size()) {
if (gethash(lb, min(lb + (LL)t.size() - 1, (LL)s.size() - 1)) !=
gethash2(0, min(lb + (LL)t.size() - 1, (LL)s.size() - 1) - lb))
break;
num++;
lb += t.size();
if (clock() >= 500) {
iss = false;
break;
}
}
if (lb >= s.size()) {
puts("-1");
return 0;
}
ans = max(ans, num);
if (!iss)
break;
}
ans = 0;
rep(i, s.size()) {
if (i + t.size() - 1 >= s.size())
break;
if (gethash(i, i + (LL)t.size() - 1) != gethash2(0, t.size() - 1))
continue;
if (i - (LL)t.size() < 0)
res[i] = 1;
else
res[i] = res[i - t.size()] + 1;
if (res[i] * (LL)t.size() > floor((double)ss.size() * 2.5)) {
puts("-1");
return 0;
}
ans = max(ans, res[i]);
}
cout << ans << endl;
return 0;
} | /*********************
* Author: xuziyuan *
*********************/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
#define LL long long
#define pii pair<int, int>
#define pb push_back
#define fi first
#define se second
#define mpr make_pair
#define sqr(a) ((a) * (a))
using namespace std;
const LL MOD = 1e9 + 7;
string s, ss, t;
LL h[4000010], h2[4000010], pw[4000010], pw2[4000010],
hn = 998544353, hn2 = 827122193, ht[1000010], ht2[1000010], res[4000010],
ans = 0;
pii gethash(LL a, LL b) {
return {(h[b + 1] - h[a] * pw[b - a + 1] % MOD + MOD) % MOD,
(h2[b + 1] - h2[a] * pw2[b - a + 1] % MOD + MOD) % MOD};
}
pii gethash2(LL a, LL b) {
return {(ht[b + 1] - ht[a] * pw[b - a + 1] % MOD + MOD) % MOD,
(ht2[b + 1] - ht2[a] * pw2[b - a + 1] % MOD + MOD) % MOD};
}
int main() {
pw[0] = pw2[0] = 1;
repn(i, 4000005) {
pw[i] = pw[i - 1] * hn % MOD;
pw2[i] = pw2[i - 1] * hn2 % MOD;
}
cin >> s >> t;
ss = s;
s += s;
s += s;
repn(i, s.size()) {
h[i] = (h[i - 1] * hn + s[i - 1] - 'a') % MOD;
h2[i] = (h2[i - 1] * hn2 + s[i - 1] - 'a') % MOD;
}
repn(i, t.size()) {
ht[i] = (ht[i - 1] * hn + t[i - 1] - 'a') % MOD;
ht2[i] = (ht2[i - 1] * hn2 + t[i - 1] - 'a') % MOD;
}
bool iss = true;
rep(i, ss.size()) {
LL lb = i, num = 0;
while (lb < s.size()) {
if (gethash(lb, min(lb + (LL)t.size() - 1, (LL)s.size() - 1)) !=
gethash2(0, min(lb + (LL)t.size() - 1, (LL)s.size() - 1) - lb))
break;
num++;
lb += t.size();
if (clock() >= 500) {
iss = false;
break;
}
}
if (lb >= s.size()) {
puts("-1");
return 0;
}
ans = max(ans, num);
if (!iss)
break;
}
ans = 0;
rep(i, s.size()) {
if (i + t.size() - 1 >= s.size())
break;
if (gethash(i, i + (LL)t.size() - 1) != gethash2(0, t.size() - 1))
continue;
if (i - (LL)t.size() < 0)
res[i] = 1;
else
res[i] = res[i - t.size()] + 1;
if (res[i] * (LL)t.size() > floor((double)ss.size() * 2.5)) {
puts("-1");
return 0;
}
ans = max(ans, res[i]);
}
cout << ans << endl;
return 0;
} | [
"identifier.change",
"call.arguments.change"
] | 771,009 | 771,010 | u977365687 | cpp |
p02962 | #include "bits/stdc++.h"
using namespace std;
using ll = int64_t;
// A[i] := SとSのi文字目以降の最長共通接頭辞の長さ
//としたものを返す
//参考:http://snuke.hatenablog.com/entry/2014/12/03/214243
vector<ll> Z_algorithm(const string &S) {
vector<ll> A(S.size());
A[0] = S.size();
ll i = 1, j = 0;
while (i < S.size()) {
while (i + j < S.size() && S[j] == S[i + j]) {
j++;
}
A[i] = j;
if (j == 0) {
i++;
continue;
}
ll k = 1;
while (i + k < S.size() && k + A[k] < j) {
A[i + k] = A[k];
k++;
}
i += k;
j -= k;
}
return A;
}
int main() {
string s, t;
cin >> s >> t;
string concat = s;
while (concat.size() < 2 * t.size()) {
concat += s;
}
concat = t + "$" + concat;
vector<ll> Z = Z_algorithm(concat);
vector<bool> match(s.size(), false);
for (uint64_t i = 0; i < s.size(); i++) {
match[i] = (Z[i + t.size() + 1] == t.size());
}
// i番目のノードから続くパス長
vector<int64_t> num(s.size(), -1);
for (uint64_t i = 0; i < s.size(); i++) {
if (!match[i]) {
num[i] = 0;
continue;
}
if (num[i] != -1) {
continue;
}
stack<int64_t> st;
st.push(i);
int64_t curr = (i + t.size()) % s.size();
while (true) {
if (curr == i) { //ループした
cout << -1 << endl;
return 0;
}
if (num[curr] != -1) { //すでに調べたノードに到達した
break;
}
if (!match[curr]) { //次がない
num[curr] = 0;
break;
}
st.push(curr);
curr = (curr + t.size()) % s.size();
}
while (!st.empty()) {
int64_t top = st.top();
st.pop();
num[top] = num[(top + t.size()) % s.size()] + 1;
}
}
cout << *max_element(num.begin(), num.end()) << endl;
} | #include "bits/stdc++.h"
using namespace std;
using ll = int64_t;
// A[i] := SとSのi文字目以降の最長共通接頭辞の長さ
//としたものを返す
//参考:http://snuke.hatenablog.com/entry/2014/12/03/214243
vector<ll> Z_algorithm(const string &S) {
vector<ll> A(S.size());
A[0] = S.size();
ll i = 1, j = 0;
while (i < S.size()) {
while (i + j < S.size() && S[j] == S[i + j]) {
j++;
}
A[i] = j;
if (j == 0) {
i++;
continue;
}
ll k = 1;
while (i + k < S.size() && k + A[k] < j) {
A[i + k] = A[k];
k++;
}
i += k;
j -= k;
}
return A;
}
int main() {
string s, t;
cin >> s >> t;
string concat = s;
while (concat.size() < t.size()) {
concat += s;
}
concat = t + "$" + concat + concat;
vector<ll> Z = Z_algorithm(concat);
vector<bool> match(s.size(), false);
for (uint64_t i = 0; i < s.size(); i++) {
match[i] = (Z[i + t.size() + 1] == t.size());
}
// i番目のノードから続くパス長
vector<int64_t> num(s.size(), -1);
for (uint64_t i = 0; i < s.size(); i++) {
if (!match[i]) {
num[i] = 0;
continue;
}
if (num[i] != -1) {
continue;
}
stack<int64_t> st;
st.push(i);
int64_t curr = (i + t.size()) % s.size();
while (true) {
if (curr == i) { //ループした
cout << -1 << endl;
return 0;
}
if (num[curr] != -1) { //すでに調べたノードに到達した
break;
}
if (!match[curr]) { //次がない
num[curr] = 0;
break;
}
st.push(curr);
curr = (curr + t.size()) % s.size();
}
while (!st.empty()) {
int64_t top = st.top();
st.pop();
num[top] = num[(top + t.size()) % s.size()] + 1;
}
}
cout << *max_element(num.begin(), num.end()) << endl;
} | [
"expression.operation.binary.remove",
"assignment.change"
] | 771,015 | 771,016 | u456065785 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
template <typename T> vector<int> build_kmp(const T &s) {
vector<int> f(s.size());
int fp = f[0] = -1;
for (int i = 1; i < s.size(); ++i) {
while (~fp && s[fp + 1] != s[i])
fp = f[fp];
if (s[fp + 1] == s[i])
++fp;
f[i] = fp;
}
return f;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
int m = t.size();
while (t.size() <= s.size() * 2)
t += t;
while (s.size() <= t.size() * 2)
s += s;
auto kmp = build_kmp(t);
int ans = 0, i = -1;
for (auto c : s) {
while (i != -1 and t[i + 1] != c)
i = kmp[i];
if (t[i + 1] == c)
++i;
ans = max(ans, (i + 1) / m);
if (i == t.size() - 1)
i = kmp[i];
}
cout << (ans == t.size() * m ? -1 : ans) << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
template <typename T> vector<int> build_kmp(const T &s) {
vector<int> f(s.size());
int fp = f[0] = -1;
for (int i = 1; i < s.size(); ++i) {
while (~fp && s[fp + 1] != s[i])
fp = f[fp];
if (s[fp + 1] == s[i])
++fp;
f[i] = fp;
}
return f;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string s, t;
cin >> s >> t;
int m = t.size();
while (t.size() <= s.size() * 2)
t += t;
while (s.size() <= t.size() * 2)
s += s;
auto kmp = build_kmp(t);
int ans = 0, i = -1;
for (auto c : s) {
while (i != -1 and t[i + 1] != c)
i = kmp[i];
if (t[i + 1] == c)
++i;
ans = max(ans, (i + 1) / m);
if (i == t.size() - 1)
i = kmp[i];
}
cout << (ans * m == t.size() ? -1 : ans) << '\n';
}
| [
"expression.operation.binary.remove"
] | 771,025 | 771,026 | u459737327 | cpp |
p02962 | #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#define debug(x) // std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x, y) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3( \
x, y, \
z) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"
using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
for (auto &&w : v) {
fill_v(w, x);
}
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
const std::vector<std::vector<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
s << "\n";
for (auto &&elm : v) {
s << elm << "\t";
}
s << "\n";
return s;
}
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(std::string &s) {
char BUF[3000000];
scanf(" %s", BUF);
s = std::string(BUF);
}
template <typename T> inline void scan(std::vector<T> &v) {
for (auto &&sv : v) {
scan(sv);
}
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
scan(f);
scan(args...);
}
inline void print(int a) { printf("%d\n", a); }
inline void print(ll a) { printf("%lld\n", a); }
inline void print(double a) { printf("%.12f\n", a); }
inline void print(std::string s) { std::cout << s << "\n"; }
using namespace std;
class RollingHash {
using ll = long long;
private:
std::vector<ll> data;
ll base;
std::vector<ll> mod;
std::vector<std::vector<ll>> power_base;
std::vector<std::vector<ll>> hash;
void assign_base() {
std::random_device rnd;
std::mt19937 mt(rnd());
base = mt() % (mod[0] - 3) + 2;
}
void assign_hash() {
power_base.assign(data.size(), std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < mod.size(); ++i) {
power_base[0][i] = 1;
}
for (size_t i = 0; i < data.size() - 1; ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
power_base[i + 1][j] = power_base[i][j] * base % mod[j];
}
}
hash.assign(data.size() + 1, std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < data.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash[i + 1][j] = (hash[i][j] + data[i] * power_base[i][j]) % mod[j];
}
}
}
public:
RollingHash() {}
RollingHash(std::vector<ll> &v) : data(v) {
mod = {1000000007, 1000000009, 1000000021, 1000000087};
assign_base();
assign_hash();
}
RollingHash(std::vector<ll> &v, std::vector<ll> &m) : data(v), mod(m) {
std::sort(std::begin(mod), std::end(mod));
assign_base();
assign_hash();
}
std::vector<int> include(std::vector<ll> data2) {
std::vector<int> ret;
if (data.size() < data2.size()) {
return ret;
}
std::vector<ll> hash2(mod.size(), 0);
for (size_t i = 0; i < data2.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash2[j] = (hash2[j] + data2[i] * power_base[i][j]) % mod[j];
}
}
for (size_t i = 0; i < data.size() - data2.size() + 1; ++i) {
bool flag = true;
for (size_t j = 0; j < mod.size(); ++j) {
if (hash[i + data2.size()][j] !=
(hash[i][j] + hash2[j] * power_base[i][j]) % mod[j]) {
flag = false;
break;
}
}
if (flag) {
ret.push_back(i);
}
}
return ret;
}
};
int main() {
string s, t;
scan(s);
scan(t);
int sl = s.length();
int tl = t.length();
string x;
int scnt = (sl + tl - 2 + sl - 1) / sl;
rep(i, scnt) { x += s; }
int xl = x.length();
vll vx(xl, 0);
rep(i, xl) { vx[i] = x[i] - '/'; }
vll vt(tl, 0);
rep(i, tl) { vt[i] = t[i] - '/'; }
RollingHash rh(vx);
auto match = rh.include(vt);
debug(x);
debug(t);
debug(match);
vi g(sl, -1);
vi dig_in(sl, 0);
for (int ind : match) {
if (ind >= sl) {
break;
}
g[ind] = (ind + tl) % sl;
dig_in[g[ind]] += 1;
}
int ans = 0;
vector<bool> arrived(sl, false);
rep(i, sl) {
if (dig_in[i] > 0) {
continue;
}
set<int> si;
int current_index = i;
si.insert(current_index);
arrived[current_index] = true;
while (true) {
int next_index = g[current_index];
if (next_index == -1) {
break;
}
current_index = next_index;
si.insert(current_index);
arrived[current_index] = true;
}
ans = max(ans, (int)si.size() - 1);
}
rep(i, sl) {
if (!arrived[i]) {
ans = -1;
break;
}
}
print(ans);
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#define debug(x) // std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x, y) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3( \
x, y, \
z) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"
using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
for (auto &&w : v) {
fill_v(w, x);
}
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
const std::vector<std::vector<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
s << "\n";
for (auto &&elm : v) {
s << elm << "\t";
}
s << "\n";
return s;
}
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(std::string &s) {
char BUF[3000000];
scanf(" %s", BUF);
s = std::string(BUF);
}
template <typename T> inline void scan(std::vector<T> &v) {
for (auto &&sv : v) {
scan(sv);
}
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
scan(f);
scan(args...);
}
inline void print(int a) { printf("%d\n", a); }
inline void print(ll a) { printf("%lld\n", a); }
inline void print(double a) { printf("%.12f\n", a); }
inline void print(std::string s) { std::cout << s << "\n"; }
using namespace std;
class RollingHash {
using ll = long long;
private:
std::vector<ll> data;
ll base;
std::vector<ll> mod;
std::vector<std::vector<ll>> power_base;
std::vector<std::vector<ll>> hash;
void assign_base() {
std::random_device rnd;
std::mt19937 mt(rnd());
base = mt() % (mod[0] - 3) + 2;
}
void assign_hash() {
power_base.assign(data.size(), std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < mod.size(); ++i) {
power_base[0][i] = 1;
}
for (size_t i = 0; i < data.size() - 1; ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
power_base[i + 1][j] = power_base[i][j] * base % mod[j];
}
}
hash.assign(data.size() + 1, std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < data.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash[i + 1][j] = (hash[i][j] + data[i] * power_base[i][j]) % mod[j];
}
}
}
public:
RollingHash() {}
RollingHash(std::vector<ll> &v) : data(v) {
mod = {1000000007, 1000000009, 1000000021, 1000000087};
assign_base();
assign_hash();
}
RollingHash(std::vector<ll> &v, std::vector<ll> &m) : data(v), mod(m) {
std::sort(std::begin(mod), std::end(mod));
assign_base();
assign_hash();
}
std::vector<int> include(std::vector<ll> data2) {
std::vector<int> ret;
if (data.size() < data2.size()) {
return ret;
}
std::vector<ll> hash2(mod.size(), 0);
for (size_t i = 0; i < data2.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash2[j] = (hash2[j] + data2[i] * power_base[i][j]) % mod[j];
}
}
for (size_t i = 0; i < data.size() - data2.size() + 1; ++i) {
bool flag = true;
for (size_t j = 0; j < mod.size(); ++j) {
if (hash[i + data2.size()][j] !=
(hash[i][j] + hash2[j] * power_base[i][j]) % mod[j]) {
flag = false;
break;
}
}
if (flag) {
ret.push_back(i);
}
}
return ret;
}
};
int main() {
string s, t;
scan(s);
scan(t);
int sl = s.length();
int tl = t.length();
string x;
int scnt = (sl + tl - 1 + sl - 1) / sl;
rep(i, scnt) { x += s; }
int xl = x.length();
vll vx(xl, 0);
rep(i, xl) { vx[i] = x[i] - '/'; }
vll vt(tl, 0);
rep(i, tl) { vt[i] = t[i] - '/'; }
RollingHash rh(vx);
auto match = rh.include(vt);
debug(x);
debug(t);
debug(match);
vi g(sl, -1);
vi dig_in(sl, 0);
for (int ind : match) {
if (ind >= sl) {
break;
}
g[ind] = (ind + tl) % sl;
dig_in[g[ind]] += 1;
}
int ans = 0;
vector<bool> arrived(sl, false);
rep(i, sl) {
if (dig_in[i] > 0) {
continue;
}
set<int> si;
int current_index = i;
si.insert(current_index);
arrived[current_index] = true;
while (true) {
int next_index = g[current_index];
if (next_index == -1) {
break;
}
current_index = next_index;
si.insert(current_index);
arrived[current_index] = true;
}
ans = max(ans, (int)si.size() - 1);
}
rep(i, sl) {
if (!arrived[i]) {
ans = -1;
break;
}
}
print(ans);
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 771,051 | 771,052 | u500496457 | cpp |
p02962 | #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#define debug(x) // std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x, y) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3( \
x, y, \
z) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"
using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
for (auto &&w : v) {
fill_v(w, x);
}
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
const std::vector<std::vector<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
s << "\n";
for (auto &&elm : v) {
s << elm << "\t";
}
s << "\n";
return s;
}
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(std::string &s) {
char BUF[3000000];
scanf(" %s", BUF);
s = std::string(BUF);
}
template <typename T> inline void scan(std::vector<T> &v) {
for (auto &&sv : v) {
scan(sv);
}
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
scan(f);
scan(args...);
}
inline void print(int a) { printf("%d\n", a); }
inline void print(ll a) { printf("%lld\n", a); }
inline void print(double a) { printf("%.12f\n", a); }
inline void print(std::string s) { std::cout << s << "\n"; }
using namespace std;
class RollingHash {
using ll = long long;
private:
std::vector<ll> data;
ll base;
std::vector<ll> mod;
std::vector<std::vector<ll>> power_base;
std::vector<std::vector<ll>> hash;
void assign_base() {
std::random_device rnd;
std::mt19937 mt(rnd());
base = mt() % (mod[0] - 3) + 2;
}
void assign_hash() {
power_base.assign(data.size(), std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < mod.size(); ++i) {
power_base[0][i] = 1;
}
for (size_t i = 0; i < data.size() - 1; ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
power_base[i + 1][j] = power_base[i][j] * base % mod[j];
}
}
hash.assign(data.size() + 1, std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < data.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash[i + 1][j] = (hash[i][j] + data[i] * power_base[i][j]) % mod[j];
}
}
}
public:
RollingHash() {}
RollingHash(std::vector<ll> &v) : data(v) {
mod = {1000000007, 1000000009, 1000000021};
assign_base();
assign_hash();
}
RollingHash(std::vector<ll> &v, std::vector<ll> &m) : data(v), mod(m) {
std::sort(std::begin(mod), std::end(mod));
assign_base();
assign_hash();
}
std::vector<int> include(std::vector<ll> data2) {
std::vector<int> ret;
if (data.size() < data2.size()) {
return ret;
}
std::vector<ll> hash2(mod.size(), 0);
for (size_t i = 0; i < data2.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash2[j] = (hash2[j] + data2[i] * power_base[i][j]) % mod[j];
}
}
for (size_t i = 0; i < data.size() - data2.size() + 1; ++i) {
bool flag = true;
for (size_t j = 0; j < mod.size(); ++j) {
if (hash[i + data2.size()][j] !=
(hash[i][j] + hash2[j] * power_base[i][j]) % mod[j]) {
flag = false;
break;
}
}
if (flag) {
ret.push_back(i);
}
}
return ret;
}
};
int main() {
string s, t;
scan(s);
scan(t);
int sl = s.length();
int tl = t.length();
string x;
int scnt = (sl + tl - 2 + sl - 1) / sl;
rep(i, scnt) { x += s; }
int xl = x.length();
vll vx(xl, 0);
rep(i, xl) { vx[i] = x[i] - '/'; }
vll vt(tl, 0);
rep(i, tl) { vt[i] = t[i] - '/'; }
RollingHash rh(vx);
auto match = rh.include(vt);
debug(x);
debug(t);
debug(match);
vi g(sl, -1);
vi dig_in(sl, 0);
for (int ind : match) {
if (ind >= sl) {
break;
}
g[ind] = (ind + tl) % sl;
dig_in[g[ind]] += 1;
}
int ans = 0;
vector<bool> arrived(sl, false);
rep(i, sl) {
if (dig_in[i] > 0) {
continue;
}
set<int> si;
int current_index = i;
si.insert(current_index);
arrived[current_index] = true;
while (true) {
int next_index = g[current_index];
if (next_index == -1) {
break;
}
current_index = next_index;
si.insert(current_index);
arrived[current_index] = true;
}
ans = max(ans, (int)si.size() - 1);
}
rep(i, sl) {
if (!arrived[i]) {
ans = -1;
break;
}
}
print(ans);
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define FOR(i, k, n) for (int(i) = (k); (i) < (n); ++(i))
#define rep(i, n) FOR(i, 0, n)
#define all(v) begin(v), end(v)
#define debug(x) // std::cerr<<#x<<": "<<x<<"\n"
#define debug2(x, y) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<"\n"
#define debug3( \
x, y, \
z) // std::cerr<<#x<<": "<<x<<", "<<#y<<": "<<y<<", "<<#z<<": "<<z<<"\n"
using ll = long long;
using vi = std::vector<int>;
using vvi = std::vector<vi>;
using vll = std::vector<ll>;
using vvll = std::vector<vll>;
template <typename T> using vvec = std::vector<std::vector<T>>;
template <typename T> auto make_v(size_t sz) { return std::vector<T>(sz); }
template <typename T, typename... Ts> auto make_v(size_t sz, Ts... ts) {
return std::vector<decltype(make_v<T>(ts...))>(sz, make_v<T>(ts...));
}
template <typename T> void fill_v(T &var, const T &x) { var = x; }
template <typename V, typename T> void fill_v(V &v, const T &x) {
for (auto &&w : v) {
fill_v(w, x);
}
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::vector<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s,
const std::vector<std::vector<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<T> &v) {
int sz = v.size();
s << "\n";
rep(i, sz) {
s << v[i];
if (i < sz - 1) {
s << "\t";
}
}
s << "\n";
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::deque<std::deque<T>> &v) {
for (auto &&w : v) {
s << w;
}
return s;
}
template <typename T>
std::ostream &operator<<(std::ostream &s, const std::set<T> &v) {
s << "\n";
for (auto &&elm : v) {
s << elm << "\t";
}
s << "\n";
return s;
}
inline void scan(int &a) { scanf("%d", &a); }
inline void scan(ll &a) { scanf("%lld", &a); }
inline void scan(char &a) { scanf(" %c", &a); }
inline void scan(double &a) { scanf("%lf", &a); }
inline void scan(std::string &s) {
char BUF[3000000];
scanf(" %s", BUF);
s = std::string(BUF);
}
template <typename T> inline void scan(std::vector<T> &v) {
for (auto &&sv : v) {
scan(sv);
}
}
template <typename First, typename... Args>
inline void scan(First &f, Args &...args) {
scan(f);
scan(args...);
}
inline void print(int a) { printf("%d\n", a); }
inline void print(ll a) { printf("%lld\n", a); }
inline void print(double a) { printf("%.12f\n", a); }
inline void print(std::string s) { std::cout << s << "\n"; }
using namespace std;
class RollingHash {
using ll = long long;
private:
std::vector<ll> data;
ll base;
std::vector<ll> mod;
std::vector<std::vector<ll>> power_base;
std::vector<std::vector<ll>> hash;
void assign_base() {
std::random_device rnd;
std::mt19937 mt(rnd());
base = mt() % (mod[0] - 3) + 2;
}
void assign_hash() {
power_base.assign(data.size(), std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < mod.size(); ++i) {
power_base[0][i] = 1;
}
for (size_t i = 0; i < data.size() - 1; ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
power_base[i + 1][j] = power_base[i][j] * base % mod[j];
}
}
hash.assign(data.size() + 1, std::vector<ll>(mod.size(), 0));
for (size_t i = 0; i < data.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash[i + 1][j] = (hash[i][j] + data[i] * power_base[i][j]) % mod[j];
}
}
}
public:
RollingHash() {}
RollingHash(std::vector<ll> &v) : data(v) {
mod = {1000000007, 1000000009, 1000000021, 1000000087};
assign_base();
assign_hash();
}
RollingHash(std::vector<ll> &v, std::vector<ll> &m) : data(v), mod(m) {
std::sort(std::begin(mod), std::end(mod));
assign_base();
assign_hash();
}
std::vector<int> include(std::vector<ll> data2) {
std::vector<int> ret;
if (data.size() < data2.size()) {
return ret;
}
std::vector<ll> hash2(mod.size(), 0);
for (size_t i = 0; i < data2.size(); ++i) {
for (size_t j = 0; j < mod.size(); ++j) {
hash2[j] = (hash2[j] + data2[i] * power_base[i][j]) % mod[j];
}
}
for (size_t i = 0; i < data.size() - data2.size() + 1; ++i) {
bool flag = true;
for (size_t j = 0; j < mod.size(); ++j) {
if (hash[i + data2.size()][j] !=
(hash[i][j] + hash2[j] * power_base[i][j]) % mod[j]) {
flag = false;
break;
}
}
if (flag) {
ret.push_back(i);
}
}
return ret;
}
};
int main() {
string s, t;
scan(s);
scan(t);
int sl = s.length();
int tl = t.length();
string x;
int scnt = (sl + tl - 1 + sl - 1) / sl;
rep(i, scnt) { x += s; }
int xl = x.length();
vll vx(xl, 0);
rep(i, xl) { vx[i] = x[i] - '/'; }
vll vt(tl, 0);
rep(i, tl) { vt[i] = t[i] - '/'; }
RollingHash rh(vx);
auto match = rh.include(vt);
debug(x);
debug(t);
debug(match);
vi g(sl, -1);
vi dig_in(sl, 0);
for (int ind : match) {
if (ind >= sl) {
break;
}
g[ind] = (ind + tl) % sl;
dig_in[g[ind]] += 1;
}
int ans = 0;
vector<bool> arrived(sl, false);
rep(i, sl) {
if (dig_in[i] > 0) {
continue;
}
set<int> si;
int current_index = i;
si.insert(current_index);
arrived[current_index] = true;
while (true) {
int next_index = g[current_index];
if (next_index == -1) {
break;
}
current_index = next_index;
si.insert(current_index);
arrived[current_index] = true;
}
ans = max(ans, (int)si.size() - 1);
}
rep(i, sl) {
if (!arrived[i]) {
ans = -1;
break;
}
}
print(ans);
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change"
] | 771,053 | 771,052 | u500496457 | cpp |
p02962 | #include <bits/stdc++.h>
using namespace std;
vector<int> Z_Algorithm(string &s) {
vector<int> ret(s.size());
for (int i = 1, j = 0; i < s.size(); i++) {
if (i + ret[i - j] < j + ret[j]) {
ret[i] = ret[i - j];
} else {
int k = max(0, j + ret[j] - i);
while (i + k < s.size() && s[k] == s[i + k])
k++;
ret[i] = k;
j = i;
}
}
ret[0] = s.size();
return ret;
}
// one-based numbering
struct UnionFind {
vector<int> data;
// i: (data[i] < 0) -> group size, (data[i] > 0) -> parent;
UnionFind(int n) { data.resize(n + 1, -1); }
int find(int x) {
if (data[x] < 0)
return x;
else
return data[x] = find(data[x]);
}
int size(int x) { return -data[find(x)]; }
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
return true;
}
bool same(int x, int y) {
x = find(x);
y = find(y);
return x == y;
}
};
int main() {
string s, t;
cin >> s >> t;
string r = t;
while (r.size() < t.size() * 3) {
r.append(s);
}
vector<int> z = Z_Algorithm(r);
UnionFind uf(s.size());
for (int i = 0; i < s.size(); i++) {
if (z[t.size() + i] >= t.size()) {
int u = i + 1, v = ((i + t.size()) % s.size()) + 1;
if (u == v || uf.same(u, v)) {
cout << -1 << endl;
return 0;
}
uf.unite(u, v);
}
}
int ans = 0;
for (auto x : uf.data) {
if (x < 0)
ans = max(ans, -x - 1);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
vector<int> Z_Algorithm(string &s) {
vector<int> ret(s.size());
for (int i = 1, j = 0; i < s.size(); i++) {
if (i + ret[i - j] < j + ret[j]) {
ret[i] = ret[i - j];
} else {
int k = max(0, j + ret[j] - i);
while (i + k < s.size() && s[k] == s[i + k])
k++;
ret[i] = k;
j = i;
}
}
ret[0] = s.size();
return ret;
}
// one-based numbering
struct UnionFind {
vector<int> data;
// i: (data[i] < 0) -> group size, (data[i] > 0) -> parent;
UnionFind(int n) { data.resize(n + 1, -1); }
int find(int x) {
if (data[x] < 0)
return x;
else
return data[x] = find(data[x]);
}
int size(int x) { return -data[find(x)]; }
bool unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return false;
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
return true;
}
bool same(int x, int y) {
x = find(x);
y = find(y);
return x == y;
}
};
int main() {
string s, t;
cin >> s >> t;
string r = t + s + s;
while (r.size() < t.size() * 3) {
r.append(s);
}
vector<int> z = Z_Algorithm(r);
UnionFind uf(s.size());
for (int i = 0; i < s.size(); i++) {
if (z[t.size() + i] >= t.size()) {
int u = i + 1, v = ((i + t.size()) % s.size()) + 1;
if (u == v || uf.same(u, v)) {
cout << -1 << endl;
return 0;
}
uf.unite(u, v);
}
}
int ans = 0;
for (auto x : uf.data) {
if (x < 0)
ans = max(ans, -x - 1);
}
cout << ans << endl;
return 0;
} | [
"assignment.change"
] | 771,058 | 771,059 | u521364030 | cpp |
p02962 | // #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using vi = vector<int>;
vi init(string &P) {
vi b(P.size() + 1);
int i = 0, j = -1;
b[0] = -1;
while (i < P.size()) {
while (j >= 0 && P[i] != P[j])
j = b[j];
b[++i] = ++j;
}
return b;
}
vi kmp(string &T, string &P, vi &b) {
vi ret;
int i = 0, j = 0;
while (i < T.size()) {
while (j >= 0 && T[i] != P[j])
j = b[j];
++i;
++j;
if (j == P.size()) {
ret.push_back(i - j);
j = b[j];
}
}
return ret;
}
std::string operator*(const std::string &s, size_t n) {
std::string result;
result.reserve(s.size() * n);
for (size_t i = 0; i < n; ++i) {
result += s;
}
return result;
}
void solve() {
string s, t;
cin >> s >> t;
if (s.length() < t.length())
s = s * ((t.length() + s.length() - 1) / s.length());
int n = s.length();
s = s * 3;
int lo = 0;
int hi = (s.length() + t.length() - 1) / t.length();
while (lo < hi) {
int mi = (lo + hi) / 2;
string u = t * mi;
vi b = init(u);
vi m = kmp(s, u, b);
if (m.empty() == string::npos)
hi = mi;
else
lo = mi + 1;
}
string u = t * (lo - 1);
if (u.length() >= 2 * n) {
cout << -1 << '\n';
return;
}
cout << lo - 1 << '\n';
return;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout << std::boolalpha;
std::cout << std::fixed << std::setprecision(6);
solve();
}
| // #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2,fma")
// #pragma GCC optimize("unroll-loops")
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using vi = vector<int>;
vi init(string &P) {
vi b(P.size() + 1);
int i = 0, j = -1;
b[0] = -1;
while (i < P.size()) {
while (j >= 0 && P[i] != P[j])
j = b[j];
b[++i] = ++j;
}
return b;
}
vi kmp(string &T, string &P, vi &b) {
vi ret;
int i = 0, j = 0;
while (i < T.size()) {
while (j >= 0 && T[i] != P[j])
j = b[j];
++i;
++j;
if (j == P.size()) {
ret.push_back(i - j);
j = b[j];
}
}
return ret;
}
std::string operator*(const std::string &s, size_t n) {
std::string result;
result.reserve(s.size() * n);
for (size_t i = 0; i < n; ++i) {
result += s;
}
return result;
}
void solve() {
string s, t;
cin >> s >> t;
if (s.length() < t.length())
s = s * ((t.length() + s.length() - 1) / s.length());
int n = s.length();
s = s * 3;
int lo = 0;
int hi = (s.length() + t.length() - 1) / t.length();
while (lo < hi) {
int mi = (lo + hi) / 2;
string u = t * mi;
vi b = init(u);
vi m = kmp(s, u, b);
if (m.empty())
hi = mi;
else
lo = mi + 1;
}
string u = t * (lo - 1);
if (u.length() >= 2 * n) {
cout << -1 << '\n';
return;
}
cout << lo - 1 << '\n';
return;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout << std::boolalpha;
std::cout << std::fixed << std::setprecision(6);
solve();
}
| [
"expression.operation.binary.remove"
] | 771,065 | 771,066 | u562319622 | cpp |
p02964 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<ll> vll;
typedef vector<ld> vld;
typedef vector<pll> vpl;
typedef vector<vll> vvll;
#define ALL(a) a.begin(), a.end()
#define SZ(a) ((int)a.size())
#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 FOR(i, a, b) for (int i = (a); i < (b); i++)
#define PB push_back
#define EB emplace_back
#define MP(a, b) make_pair(a, b)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
const int inf = 1e9;
const ll linf = 1LL << 50;
const double eps = 1e-10;
const int MOD = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
vvll edge(45, vll(2e5, -1));
vll a(2e5);
ll n, k;
vvll s(2e5);
ll jp(ll x) {
if (edge[0][x] != -1)
return edge[0][x];
auto it = upper_bound(ALL(s[a[x]]), x);
ll next;
if (it == s[a[x]].end())
next = s[a[x]][0];
else
next = *it;
next = (next + 1) % n;
if (s[a[x]].size() == 1) {
if (*it == n - 1)
edge[0][x] = n;
else
edge[0][x] = next;
} else if (next <= x)
edge[0][x] = next;
else
edge[0][x] = jp(next);
return edge[0][x];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
REP(i, n) cin >> a[i];
REP(i, n) s[a[i]].push_back(i);
REP(i, n)
jp(i);
edge[0][n] = 0;
REP(i, 44) {
REP(j, n + 1)
edge[i + 1][j] = edge[i][edge[i][j]];
}
ll target = k - 1;
ll now = 0;
REP(i, 45) {
if ((target >> i) & 1)
now = edge[i][now];
}
// REP(j,3){
// cout<<j<<endl;
// REP(i,n+1)cout<<edge[j][i]<<" ";
// cout<<endl;
// }
// create ans
set<ll> se;
vll ans;
for (ll i = now; i < n; i++) {
ll p = se.size();
se.insert(a[i]);
ll ne = se.size();
if (p == ne) {
// pop vector
while (ans.size() != 0) {
ll t = ans.back();
ans.pop_back();
se.erase(t);
if (t == a[i])
break;
}
} else
ans.push_back(a[i]);
}
REP(i, ans.size()) {
if (i != 0)
cout << " ";
cout << ans[i];
}
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef vector<ll> vll;
typedef vector<ld> vld;
typedef vector<pll> vpl;
typedef vector<vll> vvll;
#define ALL(a) a.begin(), a.end()
#define SZ(a) ((int)a.size())
#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 FOR(i, a, b) for (int i = (a); i < (b); i++)
#define PB push_back
#define EB emplace_back
#define MP(a, b) make_pair(a, b)
#define SORT_UNIQUE(c) \
(sort(c.begin(), c.end()), \
c.resize(distance(c.begin(), unique(c.begin(), c.end()))))
#define GET_POS(c, x) (lower_bound(c.begin(), c.end(), x) - c.begin())
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
const int inf = 1e9;
const ll linf = 1LL << 50;
const double eps = 1e-10;
const int MOD = 1e9 + 7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
vvll edge(45, vll(2e5, -1));
vll a(2e5);
ll n, k;
vvll s(2e5);
ll jp(ll x) {
if (edge[0][x] != -1)
return edge[0][x];
auto it = upper_bound(ALL(s[a[x]]), x);
ll next;
if (it == s[a[x]].end())
next = s[a[x]][0];
else
next = *it;
next = (next + 1) % n;
if (s[a[x]].size() == 1) {
if (x == n - 1)
edge[0][x] = n;
else
edge[0][x] = next;
} else if (next <= x)
edge[0][x] = next;
else
edge[0][x] = jp(next);
return edge[0][x];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k;
REP(i, n) cin >> a[i];
REP(i, n) s[a[i]].push_back(i);
REP(i, n)
jp(i);
edge[0][n] = 0;
REP(i, 44) {
REP(j, n + 1)
edge[i + 1][j] = edge[i][edge[i][j]];
}
ll target = k - 1;
ll now = 0;
REP(i, 45) {
if ((target >> i) & 1)
now = edge[i][now];
}
// create ans
set<ll> se;
vll ans;
for (ll i = now; i < n; i++) {
ll p = se.size();
se.insert(a[i]);
ll ne = se.size();
if (p == ne) {
// pop vector
while (ans.size() != 0) {
ll t = ans.back();
ans.pop_back();
se.erase(t);
if (t == a[i])
break;
}
} else
ans.push_back(a[i]);
}
REP(i, ans.size()) {
if (i != 0)
cout << " ";
cout << ans[i];
}
cout << endl;
}
| [
"control_flow.branch.if.condition.change"
] | 771,908 | 771,909 | u194908943 | cpp |
p02964 | #include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for (LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for (LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) (v).erase(unique(ALL(v)), (v).end())
#define bit(i) (1LL << (i))
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
return (a > b ? a = b, true : false);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
return (a < b ? a = b, true : false);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
LLI n, k;
while (cin >> n >> k) {
vector<LLI> a(n);
cin >> a;
vector<LLI> b;
REP(i, n) b.push_back(a[i]);
REP(i, n) b.push_back(a[i]);
vector<vector<LLI>> poss(400000);
REP(i, 2 * n) { poss[b[i]].push_back(i); }
vector<LLI> next(n);
REP(i, n) {
next[i] = *upper_bound(ALL(poss[a[i]]), i);
if (next[i] >= n)
next[i] -= n;
}
// join(cerr, ALL(next));
LLI cycle = 1;
LLI j = 0;
vector<LLI> last;
REP(i, n) {
if (next[j] <= j) {
++cycle;
last.push_back(j);
}
(j = next[j] + 1) %= n;
if (j == 0)
break;
}
// join(cerr, ALL(last));
// cerr << cycle << endl;
k %= cycle;
vector<LLI> ans;
if (k != 0) {
FOR(i, last[k - 1], n) {
if (next[i] > i and next[i] < n) {
i = next[i] + 1;
} else {
ans.push_back(a[i]);
}
}
}
join(cout, ALL(ans));
}
return 0;
}
| #include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for (LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for (LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for (LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for (auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for (auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c, x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) (v).erase(unique(ALL(v)), (v).end())
#define bit(i) (1LL << (i))
#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif
#define gcd __gcd
using namespace std;
template <class T> constexpr T lcm(T m, T n) { return m / gcd(m, n) * n; }
template <typename I> void join(ostream &ost, I s, I t, string d = " ") {
for (auto i = s; i != t; ++i) {
if (i != s)
ost << d;
ost << *i;
}
ost << endl;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &a : v)
is >> a;
return is;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
return (a > b ? a = b, true : false);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
return (a < b ? a = b, true : false);
}
template <typename T, size_t N, typename U>
void fill_array(T (&a)[N], const U &v) {
fill((U *)a, (U *)(a + N), v);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
LLI n, k;
while (cin >> n >> k) {
vector<LLI> a(n);
cin >> a;
vector<LLI> b;
REP(i, n) b.push_back(a[i]);
REP(i, n) b.push_back(a[i]);
vector<vector<LLI>> poss(400000);
REP(i, 2 * n) { poss[b[i]].push_back(i); }
vector<LLI> next(n);
REP(i, n) {
next[i] = *upper_bound(ALL(poss[a[i]]), i);
if (next[i] >= n)
next[i] -= n;
}
// join(cerr, ALL(next));
LLI cycle = 1;
LLI j = 0;
vector<LLI> last;
REP(i, n) {
if (next[j] <= j) {
++cycle;
last.push_back(j);
}
(j = next[j] + 1) %= n;
if (j == 0)
break;
}
// join(cerr, ALL(last));
// cerr << cycle << endl;
k %= cycle;
// cerr << k << endl;
vector<LLI> ans;
if (k != 0) {
FOR(i, last[k - 1], n) {
if (next[i] > i and next[i] < n) {
// cerr << i << " : " << next[i] << endl;
i = next[i];
} else {
ans.push_back(a[i]);
}
}
}
join(cout, ALL(ans));
}
return 0;
}
| [
"expression.operation.binary.remove"
] | 771,949 | 771,950 | u543167400 | cpp |
p02964 | #ifndef LOCAL
#pragma GCC optimize("Ofast")
#endif
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
constexpr T inf = numeric_limits<T>::max() / (T)2 - (T)123456;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832;
constexpr long double Golden = 1.61803398874989484820;
#define iostream_untie true
#define stdout_precision 10
#define stderr_precision 10
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int_fast64_t i = 0; i < (int_fast64_t)(n); ++i)
#define rrep(i, n) for (int_fast64_t i = (int_fast64_t)(n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << std::fixed << std::setprecision(stdout_precision);
std::cerr << std::fixed << std::setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("stderr.txt", "wt", stderr)) {
freopen("CON", "wt", stderr);
std::cerr << "Failed to open the stderr file\n";
}
if (!freopen("stdout.txt", "wt", stdout)) {
freopen("CON", "wt", stdout);
std::cerr << "Failed to open the stdout file\n";
}
if (!freopen("stdin.txt", "rt", stdin)) {
freopen("CON", "rt", stdin);
std::cerr << "Failed to open the stdin file.\n";
}
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class tuple_t, size_t index = tuple_size<tuple_t>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, tuple_t const &t) {
hashval_calc<tuple_t, index - 1>::apply(seed, t);
hash_combine(seed, get<index>(t));
}
};
template <class tuple_t> struct hashval_calc<tuple_t, 0> {
static void apply(size_t &seed, tuple_t const &t) {
hash_combine(seed, get<0>(t));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &t) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, t);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> istream &operator>>(istream &s, vector<T> &v) {
for (T &e : v) {
s >> e;
}
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i) {
s << (i ? " " : "") << v[i];
}
return s;
}
template <class tuple_t, size_t index> struct tupleos {
static ostream &apply(ostream &s, const tuple_t &t) {
tupleos<tuple_t, index - 1>::apply(s, t);
return s << " " << get<index>(t);
}
};
template <class tuple_t> struct tupleos<tuple_t, 0> {
static ostream &apply(ostream &s, const tuple_t &t) { return s << get<0>(t); }
};
template <class... T> ostream &operator<<(ostream &s, const tuple<T...> &t) {
return tupleos<tuple<T...>, tuple_size<tuple<T...>>::value - 1>::apply(s, t);
}
template <> ostream &operator<<(ostream &s, const tuple<> &t) { return s; }
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
template <class P> void read(P __first, P __second) {
for (P i = __first; i != __second; ++i)
cin >> *i;
}
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, int e) { return (n >> e) & 1; }
constexpr int_fast64_t mask(int_fast64_t n, int e) {
return n & ((1 << e) - 1);
}
constexpr int ilog(int_fast64_t x, int_fast64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
int_fast64_t binry(int_fast64_t ok, int_fast64_t ng,
const function<bool(int_fast64_t)> &fn) {
while (abs(ok - ng) > 1) {
int_fast64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> vector<int> cmprs(const vector<T> &v) {
vector<T> tmp = v;
vector<int> ret;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (T i : v)
ret.emplace_back(lower_bound(begin(tmp), end(tmp), i) - begin(tmp));
return ret;
}
template <class T> vector<int> cmprs(const T *__first, const T *__last) {
return cmprs(vector<T>(__first, __last));
}
void for_subset(int_fast64_t s, const function<void(int_fast64_t)> &fn) {
int_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
i64 n, K;
i64 a[1 << 20];
vector<int> pos;
bool is[1 << 20];
int nx[1 << 20];
int las[1 << 20];
void solve() {
rep(i, n) a[i + n] = a[i];
for (int i = 1; i <= 200000; ++i)
las[i] = n * 2;
for (int i = n * 2 - 1; i >= 0; --i) {
nx[i] = las[a[i]];
las[a[i]] = i;
// dump(i,nx[i]);
}
i64 peri = 0;
int now = 0;
while (!is[now]) {
// dump(now);
is[now] = true;
// pos.emplace_back(now);
peri += nx[now] - now + 1;
now = (nx[now] + 1) % n;
}
K = K * n % peri;
assert(now == 0);
vector<int> ans;
while (K) {
if (K >= nx[now] - now + 1) {
K -= nx[now] - now + 1;
} else {
// dump(now,K);
for (int i = 0; i < K; ++i) {
if (nx[now + i] < now + K) {
i = nx[i + now];
} else {
ans.emplace_back(a[i + now]);
}
}
K = 0;
}
now = (nx[now] + 1) % n;
}
cout << ans << endl;
}
signed main() {
cin >> n >> K;
rep(i, n) cin >> a[i];
solve();
}
| #ifndef LOCAL
#pragma GCC optimize("Ofast")
#endif
#include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
using namespace std;
using i64 = int_fast64_t;
using pii = pair<int, int>;
using pli = pair<int_fast64_t, int>;
using pll = pair<int_fast64_t, int_fast64_t>;
template <class T> using heap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T>
constexpr T inf = numeric_limits<T>::max() / (T)2 - (T)123456;
constexpr int dx[9] = {1, 0, -1, 0, 1, -1, -1, 1, 0};
constexpr int dy[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0};
constexpr long double Pi = 3.1415926535897932384626433832;
constexpr long double Golden = 1.61803398874989484820;
#define iostream_untie true
#define stdout_precision 10
#define stderr_precision 10
#define itrep(i, v) for (auto i = begin(v); i != end(v); ++i)
#define ritrep(i, v) for (auto i = rbegin(v); i != rend(v); ++i)
#define rep(i, n) for (int_fast64_t i = 0; i < (int_fast64_t)(n); ++i)
#define rrep(i, n) for (int_fast64_t i = (int_fast64_t)(n)-1; i >= 0; --i)
#define all(v) begin(v), end(v)
#define rall(v) rbegin(v), rend(v)
#define fir first
#define sec second
#define u_map unordered_map
#define u_set unordered_set
#define l_bnd lower_bound
#define u_bnd upper_bound
#define emp emplace
#define emf emplace_front
#define emb emplace_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define popcnt __builtin_popcount
namespace setup {
struct setupper {
setupper() {
if (iostream_untie) {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cerr.tie(nullptr);
}
std::cout << std::fixed << std::setprecision(stdout_precision);
std::cerr << std::fixed << std::setprecision(stderr_precision);
#ifdef LOCAL
if (!freopen("stderr.txt", "wt", stderr)) {
freopen("CON", "wt", stderr);
std::cerr << "Failed to open the stderr file\n";
}
if (!freopen("stdout.txt", "wt", stdout)) {
freopen("CON", "wt", stdout);
std::cerr << "Failed to open the stdout file\n";
}
if (!freopen("stdin.txt", "rt", stdin)) {
freopen("CON", "rt", stdin);
std::cerr << "Failed to open the stdin file.\n";
}
// auto print_atexit = []() {
// std::cerr << "Exec time : " << clock() / (double)CLOCKS_PER_SEC *
// 1000.0 << "ms\n"; std::cerr << "------------\n";
// };
// atexit((void(*)())print_atexit);
#endif
}
} __setupper;
} // namespace setup
namespace std {
template <class RAitr> void rsort(RAitr __first, RAitr __last) {
sort(__first, __last, greater<>());
}
template <class T> void hash_combine(size_t &seed, T const &key) {
seed ^= hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
size_t seed = 0;
hash_combine(seed, pr.first);
hash_combine(seed, pr.second);
return seed;
}
};
template <class tuple_t, size_t index = tuple_size<tuple_t>::value - 1>
struct hashval_calc {
static void apply(size_t &seed, tuple_t const &t) {
hashval_calc<tuple_t, index - 1>::apply(seed, t);
hash_combine(seed, get<index>(t));
}
};
template <class tuple_t> struct hashval_calc<tuple_t, 0> {
static void apply(size_t &seed, tuple_t const &t) {
hash_combine(seed, get<0>(t));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &t) const {
size_t seed = 0;
hashval_calc<tuple<T...>>::apply(seed, t);
return seed;
}
};
} // namespace std
template <class T, class U> istream &operator>>(istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(ostream &s, const pair<T, U> p) {
return s << p.first << " " << p.second;
}
template <class T> istream &operator>>(istream &s, vector<T> &v) {
for (T &e : v) {
s >> e;
}
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
for (size_t i = 0; i < v.size(); ++i) {
s << (i ? " " : "") << v[i];
}
return s;
}
template <class tuple_t, size_t index> struct tupleos {
static ostream &apply(ostream &s, const tuple_t &t) {
tupleos<tuple_t, index - 1>::apply(s, t);
return s << " " << get<index>(t);
}
};
template <class tuple_t> struct tupleos<tuple_t, 0> {
static ostream &apply(ostream &s, const tuple_t &t) { return s << get<0>(t); }
};
template <class... T> ostream &operator<<(ostream &s, const tuple<T...> &t) {
return tupleos<tuple<T...>, tuple_size<tuple<T...>>::value - 1>::apply(s, t);
}
template <> ostream &operator<<(ostream &s, const tuple<> &t) { return s; }
#define dump(...) \
cerr << " [ " << __LINE__ << " : " << __FUNCTION__ << " ] " << #__VA_ARGS__ \
<< " : "; \
dump_func(__VA_ARGS__)
template <class T> void dump_func(T x) { cerr << x << '\n'; }
template <class T, class... Rest> void dump_func(T x, Rest... rest) {
cerr << x << ",";
dump_func(rest...);
}
template <class T> void write(T x) { cout << x << '\n'; }
template <class T, class... Rest> void write(T x, Rest... rest) {
cout << x << ' ';
write(rest...);
}
void writeln() {}
template <class T, class... Rest> void writeln(T x, Rest... rest) {
cout << x << '\n';
writeln(rest...);
}
#define esc(...) writeln(__VA_ARGS__), exit(0)
template <class P> void read(P __first, P __second) {
for (P i = __first; i != __second; ++i)
cin >> *i;
}
namespace updater {
template <class T> static void add(T &x, const T &y) { x += y; }
template <class T> static void ext_add(T &x, const T &y, size_t w) {
x += y * w;
}
template <class T> static void mul(T &x, const T &y) { x *= y; }
template <class T> static void ext_mul(T &x, const T &y, size_t w) {
x *= (T)pow(y, w);
}
template <class T> static bool chmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
template <class T> static bool chmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
}; // namespace updater
using updater::add;
using updater::chmax;
using updater::chmin;
template <class T> constexpr T minf(const T &x, const T &y) {
return min(x, y);
}
template <class T> constexpr T maxf(const T &x, const T &y) {
return max(x, y);
}
constexpr bool bit(i64 n, int e) { return (n >> e) & 1; }
constexpr int_fast64_t mask(int_fast64_t n, int e) {
return n & ((1 << e) - 1);
}
constexpr int ilog(int_fast64_t x, int_fast64_t b = 2) {
return x ? 1 + ilog(x / b, b) : -1;
}
int_fast64_t binry(int_fast64_t ok, int_fast64_t ng,
const function<bool(int_fast64_t)> &fn) {
while (abs(ok - ng) > 1) {
int_fast64_t mid = (ok + ng) / 2;
(fn(mid) ? ok : ng) = mid;
}
return ok;
}
template <class A, size_t N, class T> void init(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
template <class T> vector<int> cmprs(const vector<T> &v) {
vector<T> tmp = v;
vector<int> ret;
sort(begin(tmp), end(tmp));
tmp.erase(unique(begin(tmp), end(tmp)), end(tmp));
for (T i : v)
ret.emplace_back(lower_bound(begin(tmp), end(tmp), i) - begin(tmp));
return ret;
}
template <class T> vector<int> cmprs(const T *__first, const T *__last) {
return cmprs(vector<T>(__first, __last));
}
void for_subset(int_fast64_t s, const function<void(int_fast64_t)> &fn) {
int_fast64_t tmp = s;
do {
fn(tmp);
} while ((--tmp &= s) != s);
}
/* The main code follows. */
i64 n, K;
i64 a[1 << 20];
vector<int> pos;
bool is[1 << 20];
int nx[1 << 20];
int las[1 << 20];
void solve() {
rep(i, n) a[i + n] = a[i];
for (int i = 1; i <= 200100; ++i)
las[i] = n * 2;
for (int i = n * 2 - 1; i >= 0; --i) {
nx[i] = las[a[i]];
las[a[i]] = i;
// dump(i,nx[i]);
}
i64 peri = 0;
int now = 0;
while (!is[now]) {
// dump(now);
is[now] = true;
// pos.emplace_back(now);
peri += nx[now] - now + 1;
now = (nx[now] + 1) % n;
}
K = K * n % peri;
assert(now == 0);
vector<int> ans;
while (K) {
if (K >= nx[now] - now + 1) {
K -= nx[now] - now + 1;
} else {
// dump(now,K);
for (int i = 0; i < K; ++i) {
if (nx[now + i] < now + K) {
i = nx[i + now] - now;
} else {
ans.emplace_back(a[i + now]);
}
}
K = 0;
}
now = (nx[now] + 1) % n;
}
cout << ans << endl;
}
signed main() {
cin >> n >> K;
rep(i, n) cin >> a[i];
solve();
}
| [
"literal.number.change",
"control_flow.loop.for.condition.change",
"expression.operation.binary.change",
"assignment.change"
] | 771,955 | 771,956 | u629015299 | cpp |
p02964 | // ███▓▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓╬╬╬╬╬╬▓█
// ███▓███████▓▓╬╬╬╬╬╬╬╬╬╬╬╬▓███▓▓▓▓█▓╬╬╬▓█
// ███████▓█████▓▓╬╬╬╬╬╬╬╬▓███▓╬╬╬╬╬╬╬▓╬╬▓█
// ████▓▓▓▓╬╬▓█████╬╬╬╬╬╬███▓╬╬╬╬╬╬╬╬╬╬╬╬╬█
// ███▓▓▓▓╬╬╬╬╬╬▓██╬╬╬╬╬╬▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ████▓▓▓╬╬╬╬╬╬╬▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ███▓█▓███████▓▓███▓╬╬╬╬╬╬▓███████▓╬╬╬╬▓█
// ████████████████▓█▓╬╬╬╬╬▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬█
// ███▓▓▓▓▓▓▓╬╬▓▓▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ████▓▓▓╬╬╬╬▓▓▓▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ███▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// █████▓▓▓▓▓▓▓▓█▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// █████▓▓▓▓▓▓▓██▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// █████▓▓▓▓▓████▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// ████▓█▓▓▓▓██▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// ████▓▓███▓▓▓▓▓▓▓██▓╬╬╬╬╬╬╬╬╬╬╬╬█▓╬▓╬╬▓██
// █████▓███▓▓▓▓▓▓▓▓████▓▓╬╬╬╬╬╬╬█▓╬╬╬╬╬▓██
// █████▓▓█▓███▓▓▓████╬▓█▓▓╬╬╬▓▓█▓╬╬╬╬╬╬███
// ██████▓██▓███████▓╬╬╬▓▓╬▓▓██▓╬╬╬╬╬╬╬▓███
// ███████▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬████
// ███████▓▓██▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓████
// ████████▓▓▓█████▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█████
// █████████▓▓▓█▓▓▓▓▓███▓╬╬╬╬╬╬╬╬╬╬╬▓██████
// ██████████▓▓▓█▓▓▓╬▓██╬╬╬╬╬╬╬╬╬╬╬▓███████
// ███████████▓▓█▓▓▓▓███▓╬╬╬╬╬╬╬╬╬▓████████
// ██████████████▓▓▓███▓▓╬╬╬╬╬╬╬╬██████████
// ███████████████▓▓▓██▓▓╬╬╬╬╬╬▓███████████
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define pb push_back
#define x first
#define y second
#define mp make_pair
#define len(a) int(a.size())
#define files(FILENAME) \
read(FILENAME); \
write(FILENAME)
#define read(FILENAME) freopen((string(FILENAME) + ".in").c_str(), "r", stdin)
#define write(FILENAME) \
freopen((string(FILENAME) + ".out").c_str(), "w", stdout)
using namespace std;
template <typename T1, typename T2> inline void chkmin(T1 &x, T2 y) {
if (x > y)
x = y;
}
template <typename T1, typename T2> inline void chkmax(T1 &x, T2 y) {
if (x < y)
x = y;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << ' ' << _p.second;
return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) {
return _out;
}
_out << _v.front();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T> inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
typedef unsigned long long base;
typedef pair<int, int> point;
typedef complex<double> comp;
const int N = 2e5 + 5;
const int LOG = 40;
base n;
base k;
vector<int> a;
base nxt[LOG][N];
int lst[N];
base curt = 0;
vector<int> ans;
int main() {
ios::sync_with_stdio(0);
srand(time(0));
cin >> n >> k;
a.resize(n);
cin >> a;
for (int i = 0; i < n; ++i) {
a.pb(a[i]);
lst[i] = -1;
}
for (int i = 0; i < n * 2; ++i) {
if (lst[a[i]] != -1 && lst[a[i]] < n) {
nxt[0][lst[a[i]]] = i - lst[a[i]];
}
lst[a[i]] = i;
}
for (int t = 0; t + 1 < LOG; ++t) {
for (int i = 0; i < n; ++i) {
int j = (i + nxt[t][i] + 1) % n;
nxt[t + 1][i] = nxt[t][i] + 1 + nxt[t][j];
chkmin(nxt[t + 1][i], 1e18);
}
}
curt = 0;
while (curt < n * k) {
int i = curt % n;
for (int step = 5; step--;) {
for (int t = LOG; t--;) {
base v = nxt[t][i];
if (curt + v < n * k) {
curt += v + 1;
i = curt % n;
++t;
}
}
}
if (curt < n * k) {
ans.pb(a[i]);
++curt;
}
}
cout << ans << '\n';
}
| // ███▓▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓▓▓╬╬╬╬╬╬▓█
// ███▓███████▓▓╬╬╬╬╬╬╬╬╬╬╬╬▓███▓▓▓▓█▓╬╬╬▓█
// ███████▓█████▓▓╬╬╬╬╬╬╬╬▓███▓╬╬╬╬╬╬╬▓╬╬▓█
// ████▓▓▓▓╬╬▓█████╬╬╬╬╬╬███▓╬╬╬╬╬╬╬╬╬╬╬╬╬█
// ███▓▓▓▓╬╬╬╬╬╬▓██╬╬╬╬╬╬▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ████▓▓▓╬╬╬╬╬╬╬▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ███▓█▓███████▓▓███▓╬╬╬╬╬╬▓███████▓╬╬╬╬▓█
// ████████████████▓█▓╬╬╬╬╬▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬█
// ███▓▓▓▓▓▓▓╬╬▓▓▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ████▓▓▓╬╬╬╬▓▓▓▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// ███▓█▓▓▓▓▓▓▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// █████▓▓▓▓▓▓▓▓█▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█
// █████▓▓▓▓▓▓▓██▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// █████▓▓▓▓▓████▓▓▓█▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// ████▓█▓▓▓▓██▓▓▓▓██╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬██
// ████▓▓███▓▓▓▓▓▓▓██▓╬╬╬╬╬╬╬╬╬╬╬╬█▓╬▓╬╬▓██
// █████▓███▓▓▓▓▓▓▓▓████▓▓╬╬╬╬╬╬╬█▓╬╬╬╬╬▓██
// █████▓▓█▓███▓▓▓████╬▓█▓▓╬╬╬▓▓█▓╬╬╬╬╬╬███
// ██████▓██▓███████▓╬╬╬▓▓╬▓▓██▓╬╬╬╬╬╬╬▓███
// ███████▓██▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬████
// ███████▓▓██▓▓▓▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓████
// ████████▓▓▓█████▓▓╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬╬▓█████
// █████████▓▓▓█▓▓▓▓▓███▓╬╬╬╬╬╬╬╬╬╬╬▓██████
// ██████████▓▓▓█▓▓▓╬▓██╬╬╬╬╬╬╬╬╬╬╬▓███████
// ███████████▓▓█▓▓▓▓███▓╬╬╬╬╬╬╬╬╬▓████████
// ██████████████▓▓▓███▓▓╬╬╬╬╬╬╬╬██████████
// ███████████████▓▓▓██▓▓╬╬╬╬╬╬▓███████████
// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
// #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define pb push_back
#define x first
#define y second
#define mp make_pair
#define len(a) int(a.size())
#define files(FILENAME) \
read(FILENAME); \
write(FILENAME)
#define read(FILENAME) freopen((string(FILENAME) + ".in").c_str(), "r", stdin)
#define write(FILENAME) \
freopen((string(FILENAME) + ".out").c_str(), "w", stdout)
using namespace std;
template <typename T1, typename T2> inline void chkmin(T1 &x, T2 y) {
if (x > y)
x = y;
}
template <typename T1, typename T2> inline void chkmax(T1 &x, T2 y) {
if (x < y)
x = y;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const pair<T, U> &_p) {
_out << _p.first << ' ' << _p.second;
return _out;
}
template <typename T, typename U>
inline istream &operator>>(istream &_in, pair<T, U> &_p) {
_in >> _p.first >> _p.second;
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const vector<T> &_v) {
if (_v.empty()) {
return _out;
}
_out << _v.front();
for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T> inline istream &operator>>(istream &_in, vector<T> &_v) {
for (auto &_i : _v) {
_in >> _i;
}
return _in;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_set<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T>
inline ostream &operator<<(ostream &_out, const unordered_multiset<T> &_s) {
if (_s.empty()) {
return _out;
}
_out << *_s.begin();
for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) {
_out << ' ' << *_it;
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
template <typename T, typename U>
inline ostream &operator<<(ostream &_out, const unordered_map<T, U> &_m) {
if (_m.empty()) {
return _out;
}
_out << '(' << _m.begin()->first << ": " << _m.begin()->second << ')';
for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) {
_out << ", (" << _it->first << ": " << _it->second << ')';
}
return _out;
}
typedef unsigned long long base;
typedef pair<int, int> point;
typedef complex<double> comp;
const int N = 2e5 + 5;
const int LOG = 40;
base n;
base k;
vector<int> a;
base nxt[LOG][N];
int lst[N];
base curt = 0;
vector<int> ans;
int main() {
ios::sync_with_stdio(0);
srand(time(0));
cin >> n >> k;
a.resize(n);
cin >> a;
for (int i = 0; i < n; ++i) {
a.pb(a[i]);
lst[a[i]] = -1;
}
for (int i = 0; i < n * 2; ++i) {
if (lst[a[i]] != -1 && lst[a[i]] < n) {
nxt[0][lst[a[i]]] = i - lst[a[i]];
}
lst[a[i]] = i;
}
for (int t = 0; t + 1 < LOG; ++t) {
for (int i = 0; i < n; ++i) {
int j = (i + nxt[t][i] + 1) % n;
nxt[t + 1][i] = nxt[t][i] + 1 + nxt[t][j];
chkmin(nxt[t + 1][i], 1e18);
}
}
curt = 0;
while (curt < n * k) {
int i = curt % n;
for (int step = 5; step--;) {
for (int t = LOG; t--;) {
base v = nxt[t][i];
if (curt + v < n * k) {
curt += v + 1;
i = curt % n;
++t;
}
}
}
if (curt < n * k) {
ans.pb(a[i]);
++curt;
}
}
cout << ans << '\n';
}
| [] | 771,957 | 771,958 | u135773862 | cpp |
p02964 | #include <bits/stdc++.h> // Tomasz Nowak
using namespace std; // XIII LO Szczecin
using LL = long long; // Poland
#define FOR(i, l, r) for (int i = (l); i <= (r); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
template <class T> int size(T &&x) { return int(x.size()); }
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <class T>
auto operator<<(ostream &out, T &&x) -> decltype(x.begin(), out) {
out << '{';
for (auto it = x.begin(); it != x.end(); ++it)
out << *it << (it == prev(x.end()) ? "" : ", ");
return out << '}';
}
void dump() {}
template <class T, class... Args> void dump(T &&x, Args... args) {
cerr << x << "; ";
dump(args...);
}
#ifdef DEBUG
struct Nl {
~Nl() { cerr << '\n'; }
};
#define debug(x...) \
cerr << (strcmp(#x, "") ? #x ": " : ""), dump(x), Nl(), cerr << ""
#else
#define debug(...) 0 && cerr
#endif
mt19937_64 rng(0);
int rd(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
// end of templates
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
LL k;
cin >> n >> k;
vector<int> a(n);
REP(i, n)
cin >> a[i];
REP(i, n)
a.emplace_back(a[i]);
debug(a);
vector<int> nxt(2 * n, 2 * n);
vector<int> last(int(2e5) + 1, -1);
for (int i = 2 * n - 1; i >= 0; --i) {
if (last[a[i]] != -1)
nxt[i] = last[a[i]];
last[a[i]] = i;
}
debug(nxt);
int lg = 0;
LL pot2 = 1;
while (pot2 <= k * n) {
pot2 *= 2;
++lg;
}
lg += 2;
vector<vector<pair<int, int>>> ptr(n, vector<pair<int, int>>(lg + 1));
REP(i, n) {
int layerdelta = (nxt[i] + 1) >= n;
if (nxt[i] + 1 == 2 * n)
++layerdelta;
ptr[i][0] = {(nxt[i] + 1) % n, layerdelta};
}
for (int l = 1; l <= lg; ++l)
REP(i, n) {
int half = ptr[i][l - 1].first;
ptr[i][l] = {ptr[half][l - 1].first,
ptr[i][l - 1].second + ptr[half][l - 1].second};
}
debug(ptr);
int i = 0, layer = 1;
for (int l = lg; l >= 0; --l) {
int nxtlayer = layer + ptr[i][l].second;
if (nxtlayer > k)
continue;
i = ptr[i][l].first;
layer = nxtlayer;
debug(i, layer);
}
debug(i, layer) << "ended jumping";
vector<bool> inside(int(2e5) + 1, false);
vector<int> que;
auto simulate_until_end = [&] {
while (i < n) {
if (inside[a[i]]) {
while (inside[a[i]]) {
int x = que.back();
que.pop_back();
inside[x] = false;
}
} else {
que.emplace_back(a[i]);
inside[a[i]] = true;
}
++i;
}
};
if (layer < k) {
simulate_until_end();
i = 0;
++layer;
}
if (layer == k) {
simulate_until_end();
i = 0;
++layer;
}
debug(i, layer);
debug(que);
for (int x : que)
cout << x << ' ';
cout << '\n';
}
| #include <bits/stdc++.h> // Tomasz Nowak
using namespace std; // XIII LO Szczecin
using LL = long long; // Poland
#define FOR(i, l, r) for (int i = (l); i <= (r); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
template <class T> int size(T &&x) { return int(x.size()); }
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &p) {
return out << '(' << p.first << ", " << p.second << ')';
}
template <class T>
auto operator<<(ostream &out, T &&x) -> decltype(x.begin(), out) {
out << '{';
for (auto it = x.begin(); it != x.end(); ++it)
out << *it << (it == prev(x.end()) ? "" : ", ");
return out << '}';
}
void dump() {}
template <class T, class... Args> void dump(T &&x, Args... args) {
cerr << x << "; ";
dump(args...);
}
#ifdef DEBUG
struct Nl {
~Nl() { cerr << '\n'; }
};
#define debug(x...) \
cerr << (strcmp(#x, "") ? #x ": " : ""), dump(x), Nl(), cerr << ""
#else
#define debug(...) 0 && cerr
#endif
mt19937_64 rng(0);
int rd(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
// end of templates
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
LL k;
cin >> n >> k;
vector<int> a(n);
REP(i, n)
cin >> a[i];
REP(i, n)
a.emplace_back(a[i]);
debug(a);
vector<int> nxt(2 * n, 2 * n);
vector<int> last(int(2e5) + 1, -1);
for (int i = 2 * n - 1; i >= 0; --i) {
if (last[a[i]] != -1)
nxt[i] = last[a[i]];
last[a[i]] = i;
}
debug(nxt);
int lg = 0;
LL pot2 = 1;
while (pot2 <= k * n) {
pot2 *= 2;
++lg;
}
lg += 2;
vector<vector<pair<int, LL>>> ptr(n, vector<pair<int, LL>>(lg + 1));
REP(i, n) {
int layerdelta = (nxt[i] + 1) >= n;
if (nxt[i] + 1 == 2 * n)
++layerdelta;
ptr[i][0] = {(nxt[i] + 1) % n, layerdelta};
}
for (int l = 1; l <= lg; ++l)
REP(i, n) {
int half = ptr[i][l - 1].first;
ptr[i][l] = {ptr[half][l - 1].first,
ptr[i][l - 1].second + ptr[half][l - 1].second};
}
debug(ptr);
int i = 0;
LL layer = 1;
for (int l = lg; l >= 0; --l) {
LL nxtlayer = layer + ptr[i][l].second;
if (nxtlayer > k)
continue;
i = ptr[i][l].first;
layer = nxtlayer;
debug(i, layer);
}
debug(i, layer) << "ended jumping";
vector<bool> inside(int(2e5) + 1, false);
vector<int> que;
auto simulate_until_end = [&] {
while (i < n) {
if (inside[a[i]]) {
while (inside[a[i]]) {
int x = que.back();
que.pop_back();
inside[x] = false;
}
} else {
que.emplace_back(a[i]);
inside[a[i]] = true;
}
++i;
}
};
if (layer < k) {
simulate_until_end();
i = 0;
++layer;
}
if (layer == k) {
simulate_until_end();
i = 0;
++layer;
}
debug(i, layer);
debug(que);
for (int x : que)
cout << x << ' ';
cout << '\n';
}
| [
"call.arguments.change",
"variable_declaration.type.change"
] | 771,959 | 771,960 | u412965895 | cpp |
p02964 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
using namespace chrono;
#ifdef DEBUG
//~ #define LOCAL_INPUT_FILE
#else
//#define USE_FILE_IO
#endif
#ifdef USE_FILE_IO
#define INPUT_FILE "input.txt"
#define OUTPUT_FILE "output.txt"
#define cin ____cin
#define cout ____cout
ifstream cin(INPUT_FILE);
ofstream cout(OUTPUT_FILE);
#else
#ifdef LOCAL_INPUT_FILE
#define cin ____cin
ifstream cin("input.txt");
#endif
#endif
const int infinity = (int)1e9 + 42;
const int64_t llInfinity = (int64_t)1e18 + 256;
const int module = (int)1e9 + 7;
const long double eps = 1e-8;
mt19937_64 randGen(system_clock().now().time_since_epoch().count());
inline void raiseError(string errorCode) {
cerr << "Error : " << errorCode << endl;
exit(42);
}
signed main() {
#ifndef USE_FILE_IO
ios_base::sync_with_stdio(false);
#endif
int n;
int64_t k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> next((int)4e5, n);
for (int i = 0; i < n; ++i) {
next[a[i]] = min(next[a[i]], i);
}
vector<pair<int, int>> jmp(n);
for (int i = n - 1; i >= 0; --i) {
jmp[i] = {next[a[i]], next[a[i]] <= i};
next[a[i]] = i;
}
int v = 0, cnt = 0;
vector<int> res;
res.push_back(0);
do {
res.back() = v;
int to = jmp[v].first;
if (jmp[v].second) {
++cnt;
res.push_back(to + 1);
}
v = to + 1;
if (v >= n) {
++cnt;
break;
}
} while (v != 0);
--k;
k %= cnt;
vector<int> qq(begin(a) + res[k], end(a));
{
vector<int> cnt((int)4e5);
vector<int> s;
for (int x : a) {
if (!cnt[x]) {
++cnt[x];
s.push_back(x);
} else {
while (cnt[x]) {
assert(!s.empty());
--cnt[s.back()];
s.pop_back();
}
}
}
for (int i : s) {
cout << i << " ";
}
cout << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
using namespace chrono;
#ifdef DEBUG
//~ #define LOCAL_INPUT_FILE
#else
//#define USE_FILE_IO
#endif
#ifdef USE_FILE_IO
#define INPUT_FILE "input.txt"
#define OUTPUT_FILE "output.txt"
#define cin ____cin
#define cout ____cout
ifstream cin(INPUT_FILE);
ofstream cout(OUTPUT_FILE);
#else
#ifdef LOCAL_INPUT_FILE
#define cin ____cin
ifstream cin("input.txt");
#endif
#endif
const int infinity = (int)1e9 + 42;
const int64_t llInfinity = (int64_t)1e18 + 256;
const int module = (int)1e9 + 7;
const long double eps = 1e-8;
mt19937_64 randGen(system_clock().now().time_since_epoch().count());
inline void raiseError(string errorCode) {
cerr << "Error : " << errorCode << endl;
exit(42);
}
signed main() {
#ifndef USE_FILE_IO
ios_base::sync_with_stdio(false);
#endif
int n;
int64_t k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<int> next((int)4e5, n);
for (int i = 0; i < n; ++i) {
next[a[i]] = min(next[a[i]], i);
}
vector<pair<int, int>> jmp(n);
for (int i = n - 1; i >= 0; --i) {
jmp[i] = {next[a[i]], next[a[i]] <= i};
next[a[i]] = i;
}
int v = 0, cnt = 0;
vector<int> res;
res.push_back(0);
do {
res.back() = v;
int to = jmp[v].first;
if (jmp[v].second) {
++cnt;
res.push_back(to + 1);
}
v = to + 1;
if (v >= n) {
++cnt;
break;
}
} while (v != 0);
--k;
k %= cnt;
vector<int> qq(begin(a) + res[k], end(a));
{
vector<int> cnt((int)4e5);
vector<int> s;
for (int x : qq) {
if (!cnt[x]) {
++cnt[x];
s.push_back(x);
} else {
while (cnt[x]) {
assert(!s.empty());
--cnt[s.back()];
s.pop_back();
}
}
}
for (int i : s) {
cout << i << " ";
}
cout << endl;
}
return 0;
}
| [
"identifier.change"
] | 771,973 | 771,974 | u094022977 | cpp |
p02964 | #include <bits/stdc++.h>
using namespace std;
const int MX = 200000;
int a[MX], fst[MX + 1], lst[MX + 1], seen[MX + 1];
int main() {
int n;
long long k;
ignore = scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++)
ignore = scanf("%d", a + i);
fill(lst, lst + n + 1, -1);
fst[n] = -1;
for (int i = n - 1; i >= 0; i--) {
int x = a[i];
if (lst[x] == -1)
fst[i] = x;
else
fst[i] = fst[lst[x] + 1];
lst[x] = i;
}
fill(seen, seen + n + 1, -1);
seen[n] = 0;
seen[0] = 1;
vector<int> f = {n, 0};
for (int i = 2; i <= k; i++) {
int p = f.back();
if (fst[p] == -1) {
f.push_back(0);
} else {
f.push_back(lst[fst[p]] + 1);
}
p = f.back();
if (seen[p] != -1) {
int s = seen[p];
k = (k - s) % (i - s) + s;
} else
seen[p] = i;
}
vector<int> ans;
set<int> S;
for (int x = f[k]; x < n; x++) {
if (S.insert(a[x]).second) {
ans.push_back(a[x]);
} else {
while (S.count(a[x]) == 1) {
S.erase(ans.back());
ans.pop_back();
}
}
}
for (int x : ans)
printf("%d ", x);
printf("\n");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MX = 200000;
int a[MX], fst[MX + 1], lst[MX + 1], seen[MX + 1];
int main() {
int n;
long long k;
ignore = scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++)
ignore = scanf("%d", a + i);
fill(lst, lst + MX + 1, -1);
fst[n] = -1;
for (int i = n - 1; i >= 0; i--) {
int x = a[i];
if (lst[x] == -1)
fst[i] = x;
else
fst[i] = fst[lst[x] + 1];
lst[x] = i;
}
fill(seen, seen + n + 1, -1);
seen[n] = 0;
seen[0] = 1;
vector<int> f = {n, 0};
for (int i = 2; i <= k; i++) {
int p = f.back();
if (fst[p] == -1) {
f.push_back(0);
} else {
f.push_back(lst[fst[p]] + 1);
}
p = f.back();
if (seen[p] != -1) {
int s = seen[p];
k = (k - s) % (i - s) + s;
} else
seen[p] = i;
}
vector<int> ans;
set<int> S;
for (int x = f[k]; x < n; x++) {
if (S.insert(a[x]).second) {
ans.push_back(a[x]);
} else {
while (S.count(a[x]) == 1) {
S.erase(ans.back());
ans.pop_back();
}
}
}
for (int x : ans)
printf("%d ", x);
printf("\n");
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 771,977 | 771,978 | u037304230 | cpp |
p02964 | #include <bits/stdc++.h>
using namespace std;
const int MX = 200000;
int a[MX], fst[MX + 1], lst[MX + 1], seen[MX + 1];
int main() {
int n;
long long k;
ignore = scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++)
ignore = scanf("%d", a + i);
fill(lst, lst + n, -1);
fst[n] = -1;
for (int i = n - 1; i >= 0; i--) {
int x = a[i];
if (lst[x] == -1)
fst[i] = x;
else
fst[i] = fst[lst[x] + 1];
lst[x] = i;
}
fill(seen, seen + n + 1, -1);
seen[n] = 0;
seen[0] = 1;
vector<int> f = {n, 0};
for (int i = 2; i <= k; i++) {
int p = f.back();
if (fst[p] == -1) {
f.push_back(0);
} else {
f.push_back(lst[fst[p]] + 1);
}
p = f.back();
if (seen[p] != -1) {
int s = seen[p];
k = (k - s) % (i - s) + s;
} else
seen[p] = i;
}
vector<int> ans;
set<int> S;
for (int x = f[k]; x < n; x++) {
if (S.insert(a[x]).second) {
ans.push_back(a[x]);
} else {
while (S.count(a[x]) == 1) {
S.erase(ans.back());
ans.pop_back();
}
}
}
for (int x : ans)
printf("%d ", x);
printf("\n");
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MX = 200000;
int a[MX], fst[MX + 1], lst[MX + 1], seen[MX + 1];
int main() {
int n;
long long k;
ignore = scanf("%d %lld", &n, &k);
for (int i = 0; i < n; i++)
ignore = scanf("%d", a + i);
fill(lst, lst + MX + 1, -1);
fst[n] = -1;
for (int i = n - 1; i >= 0; i--) {
int x = a[i];
if (lst[x] == -1)
fst[i] = x;
else
fst[i] = fst[lst[x] + 1];
lst[x] = i;
}
fill(seen, seen + n + 1, -1);
seen[n] = 0;
seen[0] = 1;
vector<int> f = {n, 0};
for (int i = 2; i <= k; i++) {
int p = f.back();
if (fst[p] == -1) {
f.push_back(0);
} else {
f.push_back(lst[fst[p]] + 1);
}
p = f.back();
if (seen[p] != -1) {
int s = seen[p];
k = (k - s) % (i - s) + s;
} else
seen[p] = i;
}
vector<int> ans;
set<int> S;
for (int x = f[k]; x < n; x++) {
if (S.insert(a[x]).second) {
ans.push_back(a[x]);
} else {
while (S.count(a[x]) == 1) {
S.erase(ans.back());
ans.pop_back();
}
}
}
for (int x : ans)
printf("%d ", x);
printf("\n");
return 0;
}
| [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 771,979 | 771,978 | u037304230 | cpp |
p02965 | #include <bits/stdc++.h>
#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) {
assert(x > 0);
return 31 - __builtin_clz(x);
} // floor(log2(x))
inline int fLog2(const ll x) {
assert(x > 0);
return 63 - __builtin_clzll(x);
}
inline int cLog2(const int x) {
assert(x > 0);
return (x == 1) ? 0 : 32 - __builtin_clz(x - 1);
} // ceil(log2(x))
inline int cLog2(const ll x) {
assert(x > 0);
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 mint {
ll x;
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 -= a.x) < 0)
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;
}
mint &operator/=(const mint r) {
ll a = r.x, b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
x = x * u % MOD;
if (x < 0)
x += MOD;
return *this;
}
mint operator/(const mint a) const { return mint(*this) /= a; }
};
// istream& operator>>(istream& is, mint& a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
using Vm = vector<mint>;
using VVm = vector<Vm>;
using VVVm = vector<VVm>;
// initialization
const int F_MAX = int(3e6) + 10;
ll fac[F_MAX], finv[F_MAX], inv[F_MAX];
void binom_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < F_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;
}
}
mint binom(int n, int k) {
if (k < 0 || n < k)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD);
}
mint perm(int n, int k) {
if (k < 0 || n < k)
return 0;
return fac[n] * finv[n - k];
}
int main() {
binom_init();
int n, m;
cin >> n >> m;
mint ans = 0;
rep(k, n + 1) {
mint res = 0;
int l = 3 * m - k;
if (l >= 0 && l % 2 == 0)
res += binom(n + l / 2 - 1, l / 2);
l = 3 * m - (2 * m + k);
if (l >= 0 && l % 2 == 0)
res -= binom(n + l / 2 - 1, l / 2) * k;
l = 3 * m - (2 * m + 2 + k);
if (l >= 0 && l % 2 == 0)
res -= binom(n + l / 2 - 1, l / 2) * (n - k);
ans += res * binom(n, k);
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
#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) {
assert(x > 0);
return 31 - __builtin_clz(x);
} // floor(log2(x))
inline int fLog2(const ll x) {
assert(x > 0);
return 63 - __builtin_clzll(x);
}
inline int cLog2(const int x) {
assert(x > 0);
return (x == 1) ? 0 : 32 - __builtin_clz(x - 1);
} // ceil(log2(x))
inline int cLog2(const ll x) {
assert(x > 0);
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 mint {
ll x;
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 -= a.x) < 0)
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;
}
mint &operator/=(const mint r) {
ll a = r.x, b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
x = x * u % MOD;
if (x < 0)
x += MOD;
return *this;
}
mint operator/(const mint a) const { return mint(*this) /= a; }
};
// istream& operator>>(istream& is, mint& a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
using Vm = vector<mint>;
using VVm = vector<Vm>;
using VVVm = vector<VVm>;
// initialization
const int F_MAX = int(3e6) + 10;
ll fac[F_MAX], finv[F_MAX], inv[F_MAX];
void binom_init() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < F_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;
}
}
mint binom(int n, int k) {
if (k < 0 || n < k)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD);
}
mint perm(int n, int k) {
if (k < 0 || n < k)
return 0;
return fac[n] * finv[n - k];
}
int main() {
binom_init();
int n, m;
cin >> n >> m;
mint ans = 0;
rep(k, min(n, m) + 1) {
mint res = 0;
int l = 3 * m - k;
if (l >= 0 && l % 2 == 0)
res += binom(n + l / 2 - 1, l / 2);
l = 3 * m - (2 * m + k);
if (l >= 0 && l % 2 == 0)
res -= binom(n + l / 2 - 1, l / 2) * k;
l = 3 * m - (2 * m + 2 + k);
if (l >= 0 && l % 2 == 0)
res -= binom(n + l / 2 - 1, l / 2) * (n - k);
ans += res * binom(n, k);
}
cout << ans << '\n';
return 0;
}
| [
"call.add",
"call.arguments.add"
] | 771,980 | 771,981 | u366381207 | cpp |
p02965 | //雪花飄飄北風嘯嘯
//天地一片蒼茫
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define ll long long
#define ii pair<ll, ll>
#define iii pair<ii, ll>
#define fi first
#define se second
#define endl '\n'
#define debug(x) cout << #x << " is " << x << endl;
#define rep(x, start, end) \
for (auto x = (start) - ((start) > (end)); x != (end) - ((start) > (end)); \
((start) < (end) ? x++ : x--))
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
ll MAX(ll a) { return a; }
ll MIN(ll a) { return a; }
template <typename... Args> ll MAX(ll a, Args... args) {
return max(a, MAX(args...));
}
template <typename... Args> ll MIN(ll a, Args... args) {
return min(a, MIN(args...));
}
#define indexed_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
ll qexp(ll b, ll p, int m) {
ll res = 1;
while (p) {
if (p & 1)
res = (res * b) % m;
b = (b * b) % m;
p >>= 1;
}
return res;
}
ll inv(ll i) { return qexp(i, MOD - 2, MOD); }
ll fac[2000005];
ll ifac[2000005];
ll nCk(int i, int j) {
if (i < j)
return 0; // big bruh
return fac[i] * ifac[j] % MOD * ifac[i - j] % MOD;
}
ll fix(ll i) {
i %= MOD;
if (i < 0)
i += MOD;
return i;
}
ll dist(int i, int j) { // distribute j things among i ppl
return nCk(i + j - 1, i - 1);
}
int n, m;
ll comp[1000005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fac[0] = 1;
rep(x, 1, 2000005) fac[x] = fac[x - 1] * x % MOD;
rep(x, 0, 2000005) ifac[x] = inv(fac[x]);
cin >> n >> m;
comp[0] = n * dist(n - 1, 0) % MOD;
rep(x, 1, 1000005) comp[x] = (comp[x - 1] + n * dist(n - 1, x)) % MOD;
ll ans = 0;
for (int x = m; x >= 0; x -= 2)
if (x <= n) {
int k = (3 * m - x) / 2;
// cout<<k<<" "<<x<<endl;
// each number is form 2A+B
// case 1: there exists a number with A=m
ans = fix(ans + n * dist(n - 1, k - m) % MOD * nCk(n - 1, x));
// case 2: bigest number <2m
ans = fix(ans + (dist(n, k) - comp[k - m]) * nCk(n, x));
// cout<<ans<<endl;
}
cout << ans << endl;
}
| //雪花飄飄北風嘯嘯
//天地一片蒼茫
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define ll long long
#define ii pair<ll, ll>
#define iii pair<ii, ll>
#define fi first
#define se second
#define endl '\n'
#define debug(x) cout << #x << " is " << x << endl;
#define rep(x, start, end) \
for (auto x = (start) - ((start) > (end)); x != (end) - ((start) > (end)); \
((start) < (end) ? x++ : x--))
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
ll MAX(ll a) { return a; }
ll MIN(ll a) { return a; }
template <typename... Args> ll MAX(ll a, Args... args) {
return max(a, MAX(args...));
}
template <typename... Args> ll MIN(ll a, Args... args) {
return min(a, MIN(args...));
}
#define indexed_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int MOD = 998244353;
ll qexp(ll b, ll p, int m) {
ll res = 1;
while (p) {
if (p & 1)
res = (res * b) % m;
b = (b * b) % m;
p >>= 1;
}
return res;
}
ll inv(ll i) { return qexp(i, MOD - 2, MOD); }
ll fac[2000005];
ll ifac[2000005];
ll nCk(int i, int j) {
if (i < j)
return 0; // big bruh
return fac[i] * ifac[j] % MOD * ifac[i - j] % MOD;
}
ll fix(ll i) {
i %= MOD;
if (i < 0)
i += MOD;
return i;
}
ll dist(int i, int j) { // distribute j things among i ppl
return nCk(i + j - 1, i - 1);
}
int n, m;
ll comp[1000005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fac[0] = 1;
rep(x, 1, 2000005) fac[x] = fac[x - 1] * x % MOD;
rep(x, 0, 2000005) ifac[x] = inv(fac[x]);
cin >> n >> m;
comp[0] = n * dist(n - 1, 0) % MOD;
rep(x, 1, 1000005) comp[x] = (comp[x - 1] + n * dist(n - 1, x)) % MOD;
ll ans = 0;
for (int x = m; x >= 0; x -= 2)
if (x <= n) {
int k = (3 * m - x) / 2;
// cout<<k<<" "<<x<<endl;
// each number is form 2A+B
// case 1: there exists a number with A=m
ans = fix(ans + n * dist(n - 1, k - m) % MOD * nCk(n - 1, x));
// case 2: bigest number <2m
ans = fix(ans + (dist(n, k) - comp[k - m]) * nCk(n, x));
// cout<<ans<<endl;
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change"
] | 771,987 | 771,988 | u780811667 | cpp |
p02965 | //雪花飄飄北風嘯嘯
//天地一片蒼茫
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define ll long long
#define ii pair<ll, ll>
#define iii pair<ii, ll>
#define fi first
#define se second
#define endl '\n'
#define debug(x) cout << #x << " is " << x << endl;
#define rep(x, start, end) \
for (auto x = (start) - ((start) > (end)); x != (end) - ((start) > (end)); \
((start) < (end) ? x++ : x--))
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
ll MAX(ll a) { return a; }
ll MIN(ll a) { return a; }
template <typename... Args> ll MAX(ll a, Args... args) {
return max(a, MAX(args...));
}
template <typename... Args> ll MIN(ll a, Args... args) {
return min(a, MIN(args...));
}
#define indexed_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
ll qexp(ll b, ll p, int m) {
ll res = 1;
while (p) {
if (p & 1)
res = (res * b) % m;
b = (b * b) % m;
p >>= 1;
}
return res;
}
ll inv(ll i) { return qexp(i, MOD - 2, MOD); }
ll fac[1000005];
ll ifac[1000005];
ll nCk(int i, int j) {
if (i < j)
return 0; // big bruh
return fac[i] * ifac[j] % MOD * ifac[i - j] % MOD;
}
ll fix(ll i) {
i %= MOD;
if (i < 0)
i += MOD;
return i;
}
ll dist(int i, int j) { // distribute j things among i ppl
return nCk(i + j - 1, i - 1);
}
int n, m;
ll comp[1000005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fac[0] = 1;
rep(x, 1, 1000005) fac[x] = fac[x - 1] * x % MOD;
rep(x, 0, 1000005) ifac[x] = inv(fac[x]);
cin >> n >> m;
comp[0] = n * dist(n - 1, 0) % MOD;
rep(x, 1, 1000005) comp[x] = (comp[x - 1] + n * dist(n - 1, x)) % MOD;
ll ans = 0;
for (int x = m; x >= 0; x -= 2)
if (x <= n) {
int k = (3 * m - x) / 2;
// cout<<k<<" "<<x<<endl;
// each number is form 2A+B
// case 1: there exists a number with A=m
ans = fix(ans + n * dist(n - 1, k - m) % MOD * nCk(n - 1, x));
// case 2: bigest number <2m
ans = fix(ans + (dist(n, k) - comp[k - m]) * nCk(n, x));
// cout<<ans<<endl;
}
cout << ans << endl;
}
| //雪花飄飄北風嘯嘯
//天地一片蒼茫
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
#define ll long long
#define ii pair<ll, ll>
#define iii pair<ii, ll>
#define fi first
#define se second
#define endl '\n'
#define debug(x) cout << #x << " is " << x << endl;
#define rep(x, start, end) \
for (auto x = (start) - ((start) > (end)); x != (end) - ((start) > (end)); \
((start) < (end) ? x++ : x--))
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
ll MAX(ll a) { return a; }
ll MIN(ll a) { return a; }
template <typename... Args> ll MAX(ll a, Args... args) {
return max(a, MAX(args...));
}
template <typename... Args> ll MIN(ll a, Args... args) {
return min(a, MIN(args...));
}
#define indexed_set \
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update>
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int MOD = 998244353;
ll qexp(ll b, ll p, int m) {
ll res = 1;
while (p) {
if (p & 1)
res = (res * b) % m;
b = (b * b) % m;
p >>= 1;
}
return res;
}
ll inv(ll i) { return qexp(i, MOD - 2, MOD); }
ll fac[2000005];
ll ifac[2000005];
ll nCk(int i, int j) {
if (i < j)
return 0; // big bruh
return fac[i] * ifac[j] % MOD * ifac[i - j] % MOD;
}
ll fix(ll i) {
i %= MOD;
if (i < 0)
i += MOD;
return i;
}
ll dist(int i, int j) { // distribute j things among i ppl
return nCk(i + j - 1, i - 1);
}
int n, m;
ll comp[1000005];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fac[0] = 1;
rep(x, 1, 2000005) fac[x] = fac[x - 1] * x % MOD;
rep(x, 0, 2000005) ifac[x] = inv(fac[x]);
cin >> n >> m;
comp[0] = n * dist(n - 1, 0) % MOD;
rep(x, 1, 1000005) comp[x] = (comp[x - 1] + n * dist(n - 1, x)) % MOD;
ll ans = 0;
for (int x = m; x >= 0; x -= 2)
if (x <= n) {
int k = (3 * m - x) / 2;
// cout<<k<<" "<<x<<endl;
// each number is form 2A+B
// case 1: there exists a number with A=m
ans = fix(ans + n * dist(n - 1, k - m) % MOD * nCk(n - 1, x));
// case 2: bigest number <2m
ans = fix(ans + (dist(n, k) - comp[k - m]) * nCk(n, x));
// cout<<ans<<endl;
}
cout << ans << endl;
}
| [
"literal.number.change",
"variable_declaration.value.change",
"variable_declaration.array_dimensions.change",
"assignment.variable.change",
"call.arguments.change"
] | 771,989 | 771,988 | u780811667 | cpp |
p02965 | #include <bits/stdc++.h>
const double PI = 3.14159265358979323846;
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
//#define rep(i, n) for (ll i = 0; i < (n); ++i)
// typedef pair<ll, ll> P;
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
std::istream &operator>>(std::istream &in, set<int> &o) {
ll a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
// ifstream myfile("C:\\Users\\riku\\Downloads\\0_00.txt");
// ofstream outfile("log.txt");
// outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0')
// << rank << endl;
// std::cout << std::bitset<8>(9);
// const ll mod = 1e10;
typedef priority_queue<P, vector<P>, greater<P>> PQ_ASK;
struct Edge {
int to, color;
ll cost;
};
ll rec(vector<vector<Edge>> &g, int start, int now, int goal, int prev) {
if (goal == now)
return 0;
for (Edge e : g[now]) {
if (e.to == prev)
continue;
ll c = rec(g, start, e.to, goal, now);
if (c == -1)
continue;
return c + e.cost;
}
return -1;
}
struct Query {
int color;
ll cost;
int from, to;
// <edge, cost>
map<int, ll> costs;
map<int, ll> counts;
};
std::istream &operator>>(std::istream &in, Query &o) {
cin >> o.color >> o.cost >> o.from >> o.to;
o.color--;
o.from--;
o.to--;
return in;
}
const int mod = 1000000007;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
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;
}
// 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 res(*this);
return res /= a;
}
friend std::istream &operator>>(std::istream &in, mint &o) {
ll a;
in >> a;
o = a;
return in;
}
friend std::ostream &operator<<(std::ostream &out, const mint &o) {
out << o.x;
return out;
}
};
const int vcmax = (1 << 21) + 10;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} combination(vcmax);
mint sub(int n, int a, int b) {
cmin(b, n);
mint ans = 0;
for (int i = a % 2; i <= min({
n,
a,
b,
});
i += 2) {
ans += combination((a - i) / 2 + n - 1, n - 1) * combination(n, i);
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
mint ans = sub(n, 3 * m, m);
ans -= (sub(n, m, m) - sub(n - 1, m, m)) * n;
cout << ans << endl;
} | #include <bits/stdc++.h>
const double PI = 3.14159265358979323846;
using namespace std;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
//#define rep(i, n) for (ll i = 0; i < (n); ++i)
// typedef pair<ll, ll> P;
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
std::istream &operator>>(std::istream &in, set<int> &o) {
ll a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
// ifstream myfile("C:\\Users\\riku\\Downloads\\0_00.txt");
// ofstream outfile("log.txt");
// outfile << setw(6) << setfill('0') << prefecture << setw(6) << setfill('0')
// << rank << endl;
// std::cout << std::bitset<8>(9);
// const ll mod = 1e10;
typedef priority_queue<P, vector<P>, greater<P>> PQ_ASK;
struct Edge {
int to, color;
ll cost;
};
ll rec(vector<vector<Edge>> &g, int start, int now, int goal, int prev) {
if (goal == now)
return 0;
for (Edge e : g[now]) {
if (e.to == prev)
continue;
ll c = rec(g, start, e.to, goal, now);
if (c == -1)
continue;
return c + e.cost;
}
return -1;
}
struct Query {
int color;
ll cost;
int from, to;
// <edge, cost>
map<int, ll> costs;
map<int, ll> counts;
};
std::istream &operator>>(std::istream &in, Query &o) {
cin >> o.color >> o.cost >> o.from >> o.to;
o.color--;
o.from--;
o.to--;
return in;
}
const int mod = 998244353;
struct mint {
ll x; // typedef long long ll;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
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 {
mint res(*this);
return res += a;
}
mint operator-(const mint a) const {
mint res(*this);
return res -= a;
}
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;
}
// 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 res(*this);
return res /= a;
}
friend std::istream &operator>>(std::istream &in, mint &o) {
ll a;
in >> a;
o = a;
return in;
}
friend std::ostream &operator<<(std::ostream &out, const mint &o) {
out << o.x;
return out;
}
};
const int vcmax = (1 << 21) + 10;
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i)
fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i)
ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n)
return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
} combination(vcmax);
mint sub(int n, int a, int b) {
cmin(b, n);
mint ans = 0;
for (int i = a % 2; i <= min({
n,
a,
b,
});
i += 2) {
ans += combination((a - i) / 2 + n - 1, n - 1) * combination(n, i);
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
mint ans = sub(n, 3 * m, m);
ans -= (sub(n, m, m) - sub(n - 1, m, m)) * n;
cout << ans << endl;
} | [
"literal.number.change",
"variable_declaration.value.change"
] | 771,998 | 771,999 | u564182781 | cpp |
p02964 | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = 1e+14;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(), c.end()
#define pb push_back
void Yes() {
cout << "Yes" << endl;
exit(0);
}
void No() {
cout << "No" << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
ll K;
cin >> K;
vector<int> A(N);
map<int, int> mp;
vector<int> vec(N);
rep(i, N) { cin >> A[i]; }
bool check[200200];
rep(i, N) check[i] = false;
rep(i, 2 * N) {
int j = i % N;
if ((mp.find(A[j]) != mp.end()) && check[mp[A[j]]] == false) {
vec[mp[A[j]] % N] = i - mp[A[j]] + 1;
check[mp[A[j]]] = true;
}
mp[A[j]] = i;
}
bool c[200200];
rep(i, N) c[i] = false;
vector<ll> d;
set<ll> e;
d.pb(0);
e.insert(0);
ll k = -1LL;
while (c[(k + 1) % N] != true) {
c[(k + 1) % N] = true;
k += vec[(k + 1) % N];
d.pb(k + 1);
e.insert(k + 1);
}
ll X = k + 1;
ll M = (N * K - 1) % X;
ll Y = *(lower_bound(all(d), M) - (e.find(M) != e.end() ? 1 : 0));
ll Z = M - Y + 1;
map<int, int> mp2;
vector<int> ans;
for (ll i = Y; i <= M; i++) {
if (mp2[A[i % N]] != 0) {
while (ans.back() != A[i % N]) {
mp2[ans.back()]--;
ans.pop_back();
}
ans.pop_back();
mp2[A[i % N]]--;
} else {
ans.push_back(A[i % N]);
mp2[A[i % N]]++;
}
}
for (int r = 0; r < ans.size(); r++) {
cout << ans[r] << " ";
}
cout << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <ciso646>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int ui;
const ll mod = 1000000007;
typedef long double ld;
const ll INF = 1e+14;
typedef pair<int, int> P;
#define stop \
char nyaa; \
cin >> nyaa;
#define rep(i, n) for (int i = 0; i < n; i++)
#define per(i, n) for (int i = n - 1; i >= 0; i--)
#define Rep(i, sta, n) for (int i = sta; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define per1(i, n) for (int i = n; i >= 1; i--)
#define Rep1(i, sta, n) for (int i = sta; i <= n; i++)
typedef complex<ld> Point;
const ld eps = 1e-8;
const ld pi = acos(-1.0);
typedef pair<ld, ld> LDP;
typedef pair<ll, ll> LP;
#define fr first
#define sc second
#define all(c) c.begin(), c.end()
#define pb push_back
void Yes() {
cout << "Yes" << endl;
exit(0);
}
void No() {
cout << "No" << endl;
exit(0);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
ll K;
cin >> K;
vector<int> A(N);
map<int, int> mp;
vector<int> vec(N);
rep(i, N) { cin >> A[i]; }
bool check[200200];
rep(i, N) check[i] = false;
rep(i, 2 * N) {
int j = i % N;
if ((mp.find(A[j]) != mp.end()) && check[mp[A[j]]] == false) {
vec[mp[A[j]] % N] = i - mp[A[j]] + 1;
check[mp[A[j]]] = true;
}
mp[A[j]] = i;
}
bool c[200200];
rep(i, N) c[i] = false;
vector<ll> d;
set<ll> e;
d.pb(0);
e.insert(0);
ll k = -1LL;
while (c[(k + 1) % N] != true) {
c[(k + 1) % N] = true;
k += vec[(k + 1) % N];
d.pb(k + 1);
e.insert(k + 1);
}
ll X = k + 1;
ll M = (N * K - 1) % X;
ll Y = *(lower_bound(all(d), M) - (e.find(M) != e.end() ? 0 : 1));
ll Z = M - Y + 1;
map<int, int> mp2;
vector<int> ans;
for (ll i = Y; i <= M; i++) {
if (mp2[A[i % N]] != 0) {
while (ans.back() != A[i % N]) {
mp2[ans.back()]--;
ans.pop_back();
}
ans.pop_back();
mp2[A[i % N]]--;
} else {
ans.push_back(A[i % N]);
mp2[A[i % N]]++;
}
}
for (int r = 0; r < ans.size(); r++) {
cout << ans[r] << " ";
}
cout << endl;
return 0;
} | [] | 772,089 | 772,090 | u508571192 | cpp |
p02965 | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define MOD 998244353
ll N, M;
ll Fa[5050505];
ll i, j, k, ans;
ll moddiv(ll a, ll b) {
a %= MOD;
b %= MOD;
for (ll m = MOD - 2; m > 0; m /= 2) {
if (m & 1) {
a = a * b % MOD;
}
b = b * b % MOD;
}
return a;
}
int main() {
scanf("%lld%lld", &N, &M);
Fa[0] = 1;
fornum(i, 0, N + M * 3) { Fa[i + 1] = (Fa[i] * (i + 1)) % MOD; }
for (i = M % 2; i <= N && i <= M; i += 2) {
ll b = 3 * M - i;
ans = (ans + moddiv(Fa[N], Fa[i] * Fa[N - i]) *
(moddiv(Fa[b / 2 + N - 1], Fa[N - 1] * Fa[b / 2]))) %
MOD;
ll c = M - i;
if (i == N) {
ans = (ans - moddiv(Fa[c / 2 + N - 1], Fa[N - 1] * Fa[c / 2]) * N % MOD +
MOD) %
MOD;
} else {
ans = (ans -
(moddiv(Fa[N], Fa[N - i] * Fa[i]) *
moddiv(Fa[c / 2 + N - 1], Fa[N - 1] * Fa[c / 2]) % MOD * N %
MOD -
moddiv(Fa[N - 1], Fa[N - 1 - i] * Fa[i]) *
moddiv(Fa[c / 2 + N - 2], Fa[N - 2] * Fa[c / 2]) % MOD * N %
MOD +
MOD) +
MOD) %
MOD;
}
// printf("%lld\n", ans);
}
printf("%lld", ans);
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define fornum(A, B, C) for (A = B; A < C; A++)
#define mp make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
using namespace std;
/////////////////////////////////////////////////////
#define MOD 998244353
ll N, M;
ll Fa[5050505];
ll i, j, k, ans;
ll moddiv(ll a, ll b) {
a %= MOD;
b %= MOD;
for (ll m = MOD - 2; m > 0; m /= 2) {
if (m & 1) {
a = a * b % MOD;
}
b = b * b % MOD;
}
return a;
}
int main() {
scanf("%lld%lld", &N, &M);
Fa[0] = 1;
fornum(i, 0, N + M * 3) { Fa[i + 1] = (Fa[i] * (i + 1)) % MOD; }
for (i = M % 2; i <= N && i <= M; i += 2) {
ll b = 3 * M - i;
ans = (ans + moddiv(Fa[N], Fa[i] * Fa[N - i]) *
(moddiv(Fa[b / 2 + N - 1], Fa[N - 1] * Fa[b / 2]))) %
MOD;
ll c = M - i;
if (i == N) {
ans = (ans - moddiv(Fa[c / 2 + N - 1], Fa[N - 1] * Fa[c / 2]) * N % MOD +
MOD) %
MOD;
} else {
ans =
(ans -
(moddiv(Fa[N], Fa[N - i] * Fa[i]) *
moddiv(Fa[c / 2 + N - 1], Fa[N - 1] * Fa[c / 2]) % MOD * N % MOD) +
(moddiv(Fa[N - 1], Fa[N - 1 - i] * Fa[i]) *
moddiv(Fa[c / 2 + N - 2], Fa[N - 2] * Fa[c / 2]) % MOD * N % MOD) +
MOD) %
MOD;
}
// printf("%lld\n", ans);
}
printf("%lld", ans);
return 0;
} | [
"assignment.value.change",
"expression.operation.binary.change"
] | 772,103 | 772,104 | u259396003 | cpp |
p02965 | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define int long long
#define endl '\n'
#define INF 1000000000000000009
#define all(a) a.begin(), a.end()
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
template <class T, class S> bool chmax(T &a, const S &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class S> bool chmin(T &a, const S &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll n, ll m) { return (m ? gcd(m, n % m) : n); }
ll lcm(ll n, ll m) { return n / gcd(n, m) * m; }
ll mod = 998244353;
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
ll modpow(ll a, ll b) {
ll ans = 1;
a %= mod;
while (b) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
vector<ll> fac(10000010);
vector<ll> inv(1000010);
vector<ll> facinv(10000010);
void modcalc(int n) {
fac[0] = fac[1] = 1;
inv[1] = 1;
facinv[0] = facinv[1] = 1;
for (int i = 2; i <= n; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
facinv[i] = facinv[i - 1] * inv[i] % mod;
}
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[n - k] % mod;
}
ll modhom(ll n, ll k) {
if (n < 0 || k < 0)
return 0;
if (n == 0 && k == 0)
return 1;
return modcomb(n + k - 1, k);
}
template <class T> class segtree {
int n;
vector<T> data;
T def;
function<T(T, T)> operation;
function<T(T, T)> update;
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return data[k];
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return operation(c1, c2);
}
public:
segtree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
T query(int a, int b) { return _query(a, b, 0, 0, n); }
T operator[](int i) { return data[i + n - 1]; }
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
modcalc(3000010);
ll n, m;
cin >> n >> m;
ll ans = modhom(n, 3 * m);
for (ll i = 0; i < m; i++) {
ans = (ans - n * modhom(n - 1, i) % mod + mod) % mod;
}
for (ll i = m + 1; i <= n; i++) {
if ((3 * m - i) % 2 == 0) {
ans =
(ans - modcomb(n, i) * modhom(n, (3 * m - i) / 2) % mod + mod) % mod;
}
}
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define int long long
#define endl '\n'
#define INF 1000000000000000009
#define all(a) a.begin(), a.end()
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
template <class T, class S> bool chmax(T &a, const S &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T, class S> bool chmin(T &a, const S &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
ll gcd(ll n, ll m) { return (m ? gcd(m, n % m) : n); }
ll lcm(ll n, ll m) { return n / gcd(n, m) * m; }
ll mod = 998244353;
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
ll modpow(ll a, ll b) {
ll ans = 1;
a %= mod;
while (b) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
vector<ll> fac(10000010);
vector<ll> inv(10000010);
vector<ll> facinv(10000010);
void modcalc(int n) {
fac[0] = fac[1] = 1;
inv[1] = 1;
facinv[0] = facinv[1] = 1;
for (int i = 2; i <= n; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
facinv[i] = facinv[i - 1] * inv[i] % mod;
}
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
return fac[n] * facinv[n - k] % mod;
}
ll modhom(ll n, ll k) {
if (n < 0 || k < 0)
return 0;
if (n == 0 && k == 0)
return 1;
return modcomb(n + k - 1, k);
}
template <class T> class segtree {
int n;
vector<T> data;
T def;
function<T(T, T)> operation;
function<T(T, T)> update;
T _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return data[k];
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return operation(c1, c2);
}
public:
segtree(size_t _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
void change(int i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
T query(int a, int b) { return _query(a, b, 0, 0, n); }
T operator[](int i) { return data[i + n - 1]; }
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
modcalc(3000010);
ll n, m;
cin >> n >> m;
ll ans = modhom(n, 3 * m);
for (ll i = 0; i < m; i++) {
ans = (ans - n * modhom(n - 1, i) % mod + mod) % mod;
}
for (ll i = m + 1; i <= n; i++) {
if ((3 * m - i) % 2 == 0) {
ans =
(ans - modcomb(n, i) * modhom(n, (3 * m - i) / 2) % mod + mod) % mod;
}
}
cout << ans << endl;
}
| [
"literal.number.change",
"call.arguments.change"
] | 772,111 | 772,112 | u179970156 | cpp |
p02965 | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 998244353;
ll fac[3000010];
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
void modfac() {
fac[0] = 1;
for (ll i = 1; i < 3000010; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return (fac[n] * modinv(fac[n - k])) % mod;
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return ((fac[n] * modinv(fac[k])) % mod * modinv(fac[n - k])) % mod;
}
ll modhom(ll n, ll k) {
if (n == 0 && k == 0)
return 1;
else if (n < 0 || k < 0)
return 0;
else
return modcomb(n + k - 1, k);
}
ll modpow(ll a, ll b) {
ll ans = 1;
a %= mod;
while (b) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
modfac();
ll n, m;
cin >> n >> m;
ll ans = modhom(n, 3 * m);
for (ll i = m + 1; i <= n; i++) {
if ((3 * m - i) % 2 == 0) {
ans =
(ans - modcomb(n, i) * modhom(n, (3 * m - i) / 2) % mod + mod) % mod;
ans =
(ans + modcomb(n, i) * modhom(n, (m - i) / 2) % mod * n % mod) % mod;
ans = (ans -
modcomb(n - 1, i) * modhom(n - 1, (m - i) / 2) % mod * n % mod +
mod) %
mod;
}
}
ans = (ans - modhom(n, m) * n % mod) % mod;
ans = (ans + modhom(n - 1, m) * n % mod) % mod;
cout << ans << endl;
} | #include <iostream>
using namespace std;
typedef long long ll;
ll mod = 998244353;
ll fac[3000010];
ll modinv(ll a) {
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= mod;
if (u < 0)
u += mod;
return u;
}
void modfac() {
fac[0] = 1;
for (ll i = 1; i < 3000010; i++) {
fac[i] = (fac[i - 1] * i) % mod;
}
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return (fac[n] * modinv(fac[n - k])) % mod;
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k)
return 0;
else
return ((fac[n] * modinv(fac[k])) % mod * modinv(fac[n - k])) % mod;
}
ll modhom(ll n, ll k) {
if (n == 0 && k == 0)
return 1;
else if (n < 0 || k < 0)
return 0;
else
return modcomb(n + k - 1, k);
}
ll modpow(ll a, ll b) {
ll ans = 1;
a %= mod;
while (b) {
if (b & 1)
ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
int main() {
modfac();
ll n, m;
cin >> n >> m;
ll ans = modhom(n, 3 * m);
for (ll i = m + 1; i <= n; i++) {
if ((3 * m - i) % 2 == 0) {
ans =
(ans - modcomb(n, i) * modhom(n, (3 * m - i) / 2) % mod + mod) % mod;
ans =
(ans + modcomb(n, i) * modhom(n, (m - i) / 2) % mod * n % mod) % mod;
ans = (ans -
modcomb(n - 1, i) * modhom(n - 1, (m - i) / 2) % mod * n % mod +
mod) %
mod;
}
}
ans = (ans - modhom(n, m) * n % mod) % mod;
ans = (ans + modhom(n - 1, m) * n % mod) % mod;
cout << (ans + mod) % mod << endl;
}
| [
"expression.operation.binary.add"
] | 772,113 | 772,114 | u179970156 | cpp |
p02965 | #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<LL, LL> P;
const LL mod = 998244353;
const LL LINF = 1LL << 60;
const int INF = 1 << 30;
vector<LL> fact;
vector<LL> inver(3000001);
LL combi(int n, int r) {
if (n < r || n < 0 || r < 0)
return 0;
return fact[n] % mod * inver[n - r] % mod * inver[r] % mod;
}
LL fpow(LL a, LL n) {
LL x = 1;
while (n > 0) {
if (n & 1) {
x = x * a % mod;
}
a = a * a % mod;
n >>= 1;
}
return x;
}
void set_combi() {
LL s = 1;
fact.push_back(1);
for (int i = 1; i <= 3000000; i++) {
s *= i;
s %= mod;
fact.push_back(s);
}
inver[3000000] = fpow(fact[3000000], mod - 2);
for (int i = 2999999; i >= 0; i--) {
inver[i] = inver[i + 1] * (i + 1) % mod;
}
}
LL hcombi(int n, int r) { return combi(n + r - 1, r); }
int main() {
set_combi();
LL n, m;
cin >> n >> m;
LL ans = 0;
for (int i = min(n, m); i >= 0; i -= 2) {
ans = (ans + hcombi(n, m + (m - i) / 2) * combi(n, i)) % mod;
}
for (int i = 2 * m + 1; i <= 3 * m; i++) {
ans = (ans - (n * hcombi(n - 1, 3 * m - i)) % mod + mod) % mod;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define ALL(A) A.begin(), A.end()
#define RALL(A) A.rbegin(), A.rend()
typedef long long LL;
typedef pair<LL, LL> P;
const LL mod = 998244353;
const LL LINF = 1LL << 60;
const int INF = 1 << 30;
vector<LL> fact;
vector<LL> inver(3000001);
LL combi(int n, int r) {
if (n < r || n < 0 || r < 0)
return 0;
return fact[n] % mod * inver[n - r] % mod * inver[r] % mod;
}
LL fpow(LL a, LL n) {
LL x = 1;
while (n > 0) {
if (n & 1) {
x = x * a % mod;
}
a = a * a % mod;
n >>= 1;
}
return x;
}
void set_combi() {
LL s = 1;
fact.push_back(1);
for (int i = 1; i <= 3000000; i++) {
s *= i;
s %= mod;
fact.push_back(s);
}
inver[3000000] = fpow(fact[3000000], mod - 2);
for (int i = 2999999; i >= 0; i--) {
inver[i] = inver[i + 1] * (i + 1) % mod;
}
}
LL hcombi(int n, int r) { return combi(n + r - 1, r); }
int main() {
set_combi();
LL n, m;
cin >> n >> m;
LL ans = 0;
for (int i = m; i >= 0; i -= 2) {
ans = (ans + hcombi(n, m + (m - i) / 2) * combi(n, i)) % mod;
}
for (int i = 2 * m + 1; i <= 3 * m; i++) {
ans = (ans - (n * hcombi(n - 1, 3 * m - i)) % mod + mod) % mod;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.for.initializer.change",
"call.remove",
"call.arguments.change"
] | 772,156 | 772,157 | u640323045 | cpp |
p02965 | #include <bits/stdc++.h>
using namespace std;
const int N = 1000005, P = 998244353;
int n, m, fac[2 * N], ifac[2 * N];
int power(int a, int x) {
int ans = 1;
for (; x; x >>= 1, a = 1LL * a * a % P)
if (x & 1)
ans = 1LL * ans * a % P;
return ans;
}
int binom(int n, int m) {
return n < m || m < 0 ? 0 : 1LL * fac[n] * ifac[m] % P * ifac[n - m] % P;
}
int main() {
scanf("%d%d", &n, &m);
int lim = 3 * m / 2 + n;
for (int i = fac[0] = 1; i <= lim; ++i)
fac[i] = 1LL * fac[i - 1] * i % P;
ifac[lim] = power(fac[lim], P - 2);
for (int i = lim; i; --i)
ifac[i - 1] = 1LL * ifac[i] * i % P;
int ans = 0;
for (int i = m & 1; i <= n && i <= m; i += 2) {
int s = (3 * m + 2 * n - i) / 2;
for (int a = 0; a <= min(1, i) && a * m <= s - n; ++a)
for (int b = 0; b <= min(n - 1, 1) && a * m + b * (m + 1) <= s - n; ++b)
ans = (ans + ((a ^ b) & 1 ? -1LL : 1LL) * binom(n, i) % P *
binom(i, a) % P * binom(n - i, b) % P *
binom(s - a * m - b * (m + 1) - 1, n - 1)) %
P;
}
printf("%d\n", ans);
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 1000005, P = 998244353;
int n, m, fac[2 * N], ifac[2 * N];
int power(int a, int x) {
int ans = 1;
for (; x; x >>= 1, a = 1LL * a * a % P)
if (x & 1)
ans = 1LL * ans * a % P;
return ans;
}
int binom(int n, int m) {
return n < m || m < 0 ? 0 : 1LL * fac[n] * ifac[m] % P * ifac[n - m] % P;
}
int main() {
scanf("%d%d", &n, &m);
int lim = 3 * m / 2 + n;
for (int i = fac[0] = 1; i <= lim; ++i)
fac[i] = 1LL * fac[i - 1] * i % P;
ifac[lim] = power(fac[lim], P - 2);
for (int i = lim; i; --i)
ifac[i - 1] = 1LL * ifac[i] * i % P;
int ans = 0;
for (int i = m & 1; i <= n && i <= m; i += 2) {
int s = (3 * m + 2 * n - i) / 2;
for (int a = 0; a <= min(1, i) && a * m <= s - n; ++a)
for (int b = 0; b <= min(n - 1, 1) && a * m + b * (m + 1) <= s - n; ++b)
ans = (ans + ((a ^ b) & 1 ? -1LL : 1LL) * binom(n, i) % P *
binom(i, a) % P * binom(n - i, b) % P *
binom(s - a * m - b * (m + 1) - 1, n - 1)) %
P;
}
printf("%d\n", (ans + P) % P);
}
| [
"call.arguments.change"
] | 772,160 | 772,161 | u760178976 | cpp |
p02965 | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string.h>
#define N 2000005
using namespace std;
typedef long long ll;
const int mod = 998244353;
int n, m;
ll f[N], inv[N];
ll C(int n, int m) { return f[n] * inv[m] % mod * inv[n - m] % mod; }
ll solve(int n, int m) {
ll ans = 0;
for (int i = m & 1; i <= m; i += 2) {
ll w = C(n, i);
int res = m * 3 - i >> 1;
ans = (ans + w * C(res + n - 1, n - 1)) % mod;
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
f[0] = f[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= 2000002; i++)
f[i] = f[i - 1] * i % mod, inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i <= 2000002; i++)
inv[i] = inv[i - 1] * inv[i] % mod;
ll ans = (solve(n, m) - C(n + m - 2, n - 1) * n) % mod;
ans = (ans + mod) % mod;
printf("%lld", ans);
return 0;
}
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <string.h>
#define N 2000005
using namespace std;
typedef long long ll;
const int mod = 998244353;
int n, m;
ll f[N], inv[N];
ll C(int n, int m) { return f[n] * inv[m] % mod * inv[n - m] % mod; }
ll solve(int n, int m) {
ll ans = 0;
for (int i = m & 1; i <= m && i <= n; i += 2) {
ll w = C(n, i);
int res = m * 3 - i >> 1;
ans = (ans + w * C(res + n - 1, n - 1)) % mod;
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
f[0] = f[1] = inv[0] = inv[1] = 1;
for (int i = 2; i <= 2000002; i++)
f[i] = f[i - 1] * i % mod, inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i <= 2000002; i++)
inv[i] = inv[i - 1] * inv[i] % mod;
ll ans = (solve(n, m) - C(n + m - 2, n - 1) * n) % mod;
ans = (ans + mod) % mod;
printf("%lld", ans);
return 0;
}
| [
"control_flow.loop.for.condition.change"
] | 772,168 | 772,169 | u743451419 | cpp |
p02965 | #include <bits/stdc++.h>
using namespace std;
long long ans, n, m, mod = 998244353ll, fact[5000005], invfact[5000005], tmp;
long long fastp(long long base, long long exp) {
if (exp == 0)
return 1ll;
long long tmp2 = fastp(base, exp / 2ll);
tmp2 = (tmp2 * tmp2) % mod;
if (exp % 2 == 1)
tmp2 *= base;
return tmp2 % mod;
}
long long binom(long long a, long long b) {
if (b > a)
return 0ll;
return ((fact[a] * invfact[b]) % mod * invfact[a - b]) % mod;
}
int main() {
cin >> n >> m;
fact[0] = 1;
for (long long i = 1; i < 5000005; i++)
fact[i] = (fact[i - 1] * i) % mod;
invfact[5000004] = fastp(fact[5000004], mod - 2ll);
for (long long i = 5000003; i >= 0; i--)
invfact[i] = (invfact[i + 1] * (i + 1ll)) % mod;
ans = binom(n + 3ll * m - 1ll, n - 1ll);
for (int i = 0; i < m; i++) {
ans -= (fastp(n, i) * binom(n, m * 3 - 2 * i)) % mod;
ans = (ans % mod + mod) % mod;
}
for (int i = 2 * m + 1; i <= (3 * m); i++) {
tmp += binom(n - 2 + 3 * m - i, n - 2);
tmp %= mod;
}
ans -= (n * tmp) % mod;
ans = (ans % mod + mod) % mod;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
long long ans, n, m, mod = 998244353ll, fact[5000005], invfact[5000005], tmp;
long long fastp(long long base, long long exp) {
if (exp == 0)
return 1ll;
long long tmp2 = fastp(base, exp / 2ll);
tmp2 = (tmp2 * tmp2) % mod;
if (exp % 2 == 1)
tmp2 *= base;
return tmp2 % mod;
}
long long binom(long long a, long long b) {
if (b > a)
return 0ll;
return ((fact[a] * invfact[b]) % mod * invfact[a - b]) % mod;
}
int main() {
cin >> n >> m;
fact[0] = 1;
for (long long i = 1; i < 5000005; i++)
fact[i] = (fact[i - 1] * i) % mod;
invfact[5000004] = fastp(fact[5000004], mod - 2ll);
for (long long i = 5000003; i >= 0; i--)
invfact[i] = (invfact[i + 1] * (i + 1ll)) % mod;
ans = binom(n + 3ll * m - 1ll, n - 1ll);
// cout<<ans<<endl;
for (int i = 0; i < m; i++) {
ans -= (binom(n + i - 1, i) * binom(n, m * 3 - 2 * i)) % mod;
ans = (ans % mod + mod) % mod;
}
for (int i = 2 * m + 1; i <= (3 * m); i++) {
tmp += binom(n - 2 + 3 * m - i, n - 2);
tmp %= mod;
}
// cout<<tmp<<endl;
ans -= (n * tmp) % mod;
ans = (ans % mod + mod) % mod;
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.change",
"call.function.change",
"expression.operation.binary.change",
"assignment.change"
] | 772,182 | 772,183 | u036145426 | cpp |
p02965 | #include <bits/stdc++.h>
using namespace std;
long long ans, n, m, mod = 998244353ll, fact[5000005], invfact[5000005], tmp;
long long fastp(long long base, long long exp) {
if (exp == 0)
return 1ll;
long long tmp2 = fastp(base, exp / 2ll);
tmp2 = (tmp2 * tmp2) % mod;
if (exp % 2 == 1)
tmp2 *= base;
return tmp2 % mod;
}
long long binom(long long a, long long b) {
if (b > a)
return 0ll;
return ((fact[a] * invfact[b]) % mod * invfact[a - b]) % mod;
}
int main() {
cin >> n >> m;
fact[0] = 1;
for (long long i = 1; i < 5000005; i++)
fact[i] = (fact[i - 1] * i) % mod;
invfact[5000004] = fastp(fact[5000004], mod - 2ll);
for (long long i = 5000003; i >= 0; i--)
invfact[i] = (invfact[i + 1] * (i + 1ll)) % mod;
ans = binom(n + 3ll * m - 1ll, n - 1ll);
for (int i = 0; i < m; i++) {
ans -= (binom(n, i) * binom(n, m * 3 - 2 * i)) % mod;
ans = (ans % mod + mod) % mod;
}
for (int i = 2 * m + 1; i <= (3 * m); i++) {
tmp += binom(n - 2 + 3 * m - i, n - 2);
tmp %= mod;
}
ans -= (n * tmp) % mod;
ans = (ans % mod + mod) % mod;
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
long long ans, n, m, mod = 998244353ll, fact[5000005], invfact[5000005], tmp;
long long fastp(long long base, long long exp) {
if (exp == 0)
return 1ll;
long long tmp2 = fastp(base, exp / 2ll);
tmp2 = (tmp2 * tmp2) % mod;
if (exp % 2 == 1)
tmp2 *= base;
return tmp2 % mod;
}
long long binom(long long a, long long b) {
if (b > a)
return 0ll;
return ((fact[a] * invfact[b]) % mod * invfact[a - b]) % mod;
}
int main() {
cin >> n >> m;
fact[0] = 1;
for (long long i = 1; i < 5000005; i++)
fact[i] = (fact[i - 1] * i) % mod;
invfact[5000004] = fastp(fact[5000004], mod - 2ll);
for (long long i = 5000003; i >= 0; i--)
invfact[i] = (invfact[i + 1] * (i + 1ll)) % mod;
ans = binom(n + 3ll * m - 1ll, n - 1ll);
// cout<<ans<<endl;
for (int i = 0; i < m; i++) {
ans -= (binom(n + i - 1, i) * binom(n, m * 3 - 2 * i)) % mod;
ans = (ans % mod + mod) % mod;
}
for (int i = 2 * m + 1; i <= (3 * m); i++) {
tmp += binom(n - 2 + 3 * m - i, n - 2);
tmp %= mod;
}
// cout<<tmp<<endl;
ans -= (n * tmp) % mod;
ans = (ans % mod + mod) % mod;
cout << ans << endl;
return 0;
}
| [
"assignment.change"
] | 772,184 | 772,183 | u036145426 | cpp |
p02965 | #include <iostream>
#define llint long long
#define mod 998244353
using namespace std;
llint n, m;
const int FACT_MAX = 4000005;
llint fact[FACT_MAX], fact_inv[FACT_MAX];
llint modpow(llint a, llint n) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2) % mod;
}
}
void make_fact() {
llint val = 1;
fact[0] = 1;
for (int i = 1; i < FACT_MAX; i++) {
val *= i;
val %= mod;
fact[i] = val;
}
fact_inv[FACT_MAX - 1] = modpow(fact[FACT_MAX - 1], mod - 2);
for (int i = FACT_MAX - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % mod;
}
}
llint comb(llint n, llint k) {
llint ret = 1;
ret *= fact[n];
ret *= fact_inv[k], ret %= mod;
ret *= fact_inv[n - k], ret %= mod;
return ret;
}
int main(void) {
cin >> n >> m;
make_fact();
llint ans = 0;
for (int i = 0; i <= m; i++) {
if (m % 2 != i % 2)
continue;
llint rem = (3 * m - i) / 2;
llint tmp = comb(rem + n - 1, n - 1);
if (rem - (m + 1) >= 0)
tmp += mod - (n - i) * comb(rem - (m + 1) + n - 1, n - 1) % mod,
tmp %= mod;
if (rem - m >= 0)
tmp += mod - i * comb(rem - m + n - 1, n - 1) % mod, tmp %= mod;
ans += tmp * comb(n, i) % mod, ans %= mod;
}
cout << ans << endl;
return 0;
} | #include <iostream>
#define llint long long
#define mod 998244353
using namespace std;
llint n, m;
const int FACT_MAX = 4000005;
llint fact[FACT_MAX], fact_inv[FACT_MAX];
llint modpow(llint a, llint n) {
if (n == 0)
return 1;
if (n % 2) {
return ((a % mod) * (modpow(a, n - 1) % mod)) % mod;
} else {
return modpow((a * a) % mod, n / 2) % mod;
}
}
void make_fact() {
llint val = 1;
fact[0] = 1;
for (int i = 1; i < FACT_MAX; i++) {
val *= i;
val %= mod;
fact[i] = val;
}
fact_inv[FACT_MAX - 1] = modpow(fact[FACT_MAX - 1], mod - 2);
for (int i = FACT_MAX - 2; i >= 0; i--) {
fact_inv[i] = fact_inv[i + 1] * (i + 1) % mod;
}
}
llint comb(llint n, llint k) {
llint ret = 1;
ret *= fact[n];
ret *= fact_inv[k], ret %= mod;
ret *= fact_inv[n - k], ret %= mod;
return ret;
}
int main(void) {
cin >> n >> m;
make_fact();
llint ans = 0;
for (int i = 0; i <= min(m, n); i++) {
if (m % 2 != i % 2)
continue;
llint rem = (3 * m - i) / 2;
llint tmp = comb(rem + n - 1, n - 1);
if (rem - (m + 1) >= 0)
tmp += mod - (n - i) * comb(rem - (m + 1) + n - 1, n - 1) % mod,
tmp %= mod;
if (rem - m >= 0)
tmp += mod - i * comb(rem - m + n - 1, n - 1) % mod, tmp %= mod;
ans += tmp * comb(n, i) % mod, ans %= mod;
}
cout << ans << endl;
return 0;
} | [
"control_flow.loop.for.condition.change",
"call.add",
"call.arguments.add"
] | 772,187 | 772,188 | u319282133 | cpp |
p02965 | #include <bits/stdc++.h>
using namespace std;
const int N = 3000300;
const int mod = 998244353;
void add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
void sub(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
int mul(int x, int y) { return (long long)x * y % mod; }
int pw(int x, int y) {
int ans = 1;
for (; y > 0; y >>= 1, x = mul(x, x)) {
if (y & 1)
ans = mul(ans, x);
}
return ans;
}
int fact[N];
int ifact[N];
int C(int n, int k) {
if (n < k || k < 0)
return 0;
return mul(fact[n], mul(ifact[k], ifact[n - k]));
}
void precalc() {
fact[0] = 1;
for (int i = 1; i < N; ++i) {
fact[i] = mul(fact[i - 1], i);
}
ifact[N - 1] = pw(fact[N - 1], mod - 2);
for (int i = N - 1; i > 0; --i) {
ifact[i - 1] = mul(ifact[i], i);
}
}
int main() {
ios_base::sync_with_stdio(false);
precalc();
int n, m;
cin >> n >> m;
int ans = C(3 * m + n - 1, n - 1);
sub(ans, mul(n, C(m - 1 + n - 1, n - 1)));
for (int i = m + 2; i <= n; ++i) {
sub(ans, mul(C(n, i), C((3 * m - i) / 2 + n - 1, n - 1)));
}
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
const int N = 3000300;
const int mod = 998244353;
void add(int &x, int y) {
x += y;
if (x >= mod)
x -= mod;
}
void sub(int &x, int y) {
x -= y;
if (x < 0)
x += mod;
}
int mul(int x, int y) { return (long long)x * y % mod; }
int pw(int x, int y) {
int ans = 1;
for (; y > 0; y >>= 1, x = mul(x, x)) {
if (y & 1)
ans = mul(ans, x);
}
return ans;
}
int fact[N];
int ifact[N];
int C(int n, int k) {
if (n < k || k < 0)
return 0;
return mul(fact[n], mul(ifact[k], ifact[n - k]));
}
void precalc() {
fact[0] = 1;
for (int i = 1; i < N; ++i) {
fact[i] = mul(fact[i - 1], i);
}
ifact[N - 1] = pw(fact[N - 1], mod - 2);
for (int i = N - 1; i > 0; --i) {
ifact[i - 1] = mul(ifact[i], i);
}
}
int main() {
ios_base::sync_with_stdio(false);
precalc();
int n, m;
cin >> n >> m;
int ans = C(3 * m + n - 1, n - 1);
sub(ans, mul(n, C(m - 1 + n - 1, n - 1)));
for (int i = m + 2; i <= n; i += 2) {
sub(ans, mul(C(n, i), C((3 * m - i) / 2 + n - 1, n - 1)));
}
cout << ans << "\n";
} | [
"control_flow.loop.for.update.change",
"assignment.change"
] | 772,191 | 772,192 | u434765267 | cpp |
p02965 | #include "bits/stdc++.h"
using namespace std;
using ll = int64_t;
constexpr ll MOD = 998244353;
class Combination {
public:
Combination(ll max_num) {
fact_.resize(max_num + 1, 1);
inv_fact_.resize(max_num + 1, 1);
for (ll i = 2; i <= max_num; i++) {
fact_[i] = i * fact_[i - 1] % MOD;
inv_fact_[i] = MODpow(fact_[i], MOD - 2);
assert(fact_[i] * inv_fact_[i] % MOD == 1);
}
}
ll operator()(ll n, ll m) const {
if (m < 0 || m > n)
return 0;
return fact_[n] * inv_fact_[n - m] % MOD * inv_fact_[m] % MOD;
}
private:
ll MODpow(ll n, ll m) const {
ll result = 1;
while (m) {
if (m % 2 == 1) {
result *= n;
result %= MOD;
}
m /= 2;
n *= n;
n %= MOD;
}
return result;
}
vector<ll> fact_, inv_fact_;
} comb(3e6);
//サイズがnの非負整数配列で総和がsであり奇数の要素がm個以下であるものの場合の数
ll f(ll n, ll s, ll m) {
ll result = 0;
//奇数の数を全探索
for (ll a = s % 1; a <= min(n, m); a += 2) {
//まず奇数になるところを決める
ll curr_num = comb(n, a);
//上で選んだ箇所に1を入れたとする
//残りs - aをn個の要素にそれぞれ偶数となるように分ければ良い
//そのような分け方は結局(s - a) / 2をn個に分ける
//要素と仕切りのやつ
(curr_num *= comb((s - a) / 2 + n - 1, n - 1)) %= MOD;
(result += curr_num) %= MOD;
}
return result;
}
int main() {
ll N, M;
cin >> N >> M;
//最大値が2Mを超えないという条件を無視した数
ll ans = f(N, 3 * M, M);
//最大値が2Mを超えるものの数を引く
// 2Mを超えるのは1箇所。その1箇所が左端として、そこから2Mを引いた配列を考える
// その配列はN要素で合計がMで奇数がM個以下
// しかし左端が0になってはいけないのでN -
// 1要素で合計Mで奇数がM個以下となるものを引く
ll illegal = (f(N, M, M) + MOD - f(N - 1, M, M)) % MOD;
// 2Mを超えるものがどこに来るかはN通りあり得るのでN倍する
(ans += MOD - N * illegal % MOD) %= MOD;
cout << ans << endl;
} | #include "bits/stdc++.h"
using namespace std;
using ll = int64_t;
constexpr ll MOD = 998244353;
class Combination {
public:
Combination(ll max_num) {
fact_.resize(max_num + 1, 1);
inv_fact_.resize(max_num + 1, 1);
for (ll i = 2; i <= max_num; i++) {
fact_[i] = i * fact_[i - 1] % MOD;
inv_fact_[i] = MODpow(fact_[i], MOD - 2);
assert(fact_[i] * inv_fact_[i] % MOD == 1);
}
}
ll operator()(ll n, ll m) const {
if (m < 0 || m > n)
return 0;
return fact_[n] * inv_fact_[n - m] % MOD * inv_fact_[m] % MOD;
}
private:
ll MODpow(ll n, ll m) const {
ll result = 1;
while (m) {
if (m % 2 == 1) {
result *= n;
result %= MOD;
}
m /= 2;
n *= n;
n %= MOD;
}
return result;
}
vector<ll> fact_, inv_fact_;
} comb(3e6);
//サイズがnの非負整数配列で総和がsであり奇数の要素がm個以下であるものの場合の数
ll f(ll n, ll s, ll m) {
ll result = 0;
//奇数の数を全探索
for (ll a = s % 2; a <= min(n, m); a += 2) {
//まず奇数になるところを決める
ll curr_num = comb(n, a);
//上で選んだ箇所に1を入れたとする
//残りs - aをn個の要素にそれぞれ偶数となるように分ければ良い
//そのような分け方は結局(s - a) / 2をn個に分ける
//要素と仕切りのやつ
(curr_num *= comb((s - a) / 2 + n - 1, n - 1)) %= MOD;
(result += curr_num) %= MOD;
}
return result;
}
int main() {
ll N, M;
cin >> N >> M;
//最大値が2Mを超えないという条件を無視した数
ll ans = f(N, 3 * M, M);
//最大値が2Mを超えるものの数を引く
// 2Mを超えるのは1箇所。その1箇所が左端として、そこから2Mを引いた配列を考える
// その配列はN要素で合計がMで奇数がM個以下
// しかし左端が0になってはいけないのでN -
// 1要素で合計Mで奇数がM個以下となるものを引く
ll illegal = (f(N, M, M) + MOD - f(N - 1, M, M)) % MOD;
// 2Mを超えるものがどこに来るかはN通りあり得るのでN倍する
(ans += MOD - N * illegal % MOD) %= MOD;
cout << ans << endl;
} | [
"literal.number.change",
"control_flow.loop.for.initializer.change",
"expression.off_by_one",
"expression.operation.binary.change"
] | 772,205 | 772,206 | u456065785 | cpp |
p02965 | #include <bits/stdc++.h>
using namespace std;
const int N = 3 * 1000 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
const int M = 998244353;
int n, m;
long long F[N];
bool read() {
if (!(cin >> n >> m))
return false;
return true;
}
long long naive() {
vector<vector<vector<long long>>> dp(
n + 1,
vector<vector<long long>>(3 * m + 1, vector<long long>(n + 1, 0ll)));
dp[0][0][0] = 1;
for (int i = 0; i < n; ++i)
for (int s = 0; s <= 3 * m; ++s)
for (int j = 0; j <= i; ++j)
for (int c = 0; c <= 2 * m && c + s <= 3 * m; ++c) {
if (j + c % 2 > n)
continue;
dp[i + 1][s + c][j + c % 2] += dp[i][s][j];
dp[i + 1][s + c][j + c % 2] %= M;
}
auto res = 0ll;
for (int j = 0; j <= 2 * m && j <= n; ++j)
res = (res + dp[n][3 * m][j]) % M;
return res;
}
long long bpow(long long a, int n, long long M) {
auto res = 1ll;
for (; n > 0; n /= 2, a = a * a % M)
if (n & 1)
res = res * a % M;
return res;
}
long long rev(long long x) { return bpow(x, M - 2, M); }
long long binomial(int n, int k) {
return n < 0 || k < 0 || k > n ? 0ll : F[n] * rev(F[k] * F[n - k] % M) % M;
}
long long gay(int s, int n) {
return s == 0 ? 1ll : binomial(s + n - 1, n - 1);
}
long long sol() {
auto res = gay(3 * m, n);
for (int mx = 2 * m + 1; mx <= 3 * m; ++mx) {
auto cur = gay(3 * m - mx, n - 1) * n % M;
res = (res + M - cur) % M;
}
for (int odd = 2 * m + 1; odd <= 3 * m; ++odd)
if ((3 * m - odd) % 2 == 0) {
auto cur = gay((3 * m - odd) / 2, n) * binomial(n, odd) % M;
res = (res + M - cur) % M;
}
return res;
}
void solve() {
F[0] = 1ll;
for (int i = 1; i < N; ++i)
F[i] = i * F[i - 1] % M;
cout << sol() << endl;
/*for (n = 2; n <= 500; ++n)
for (m = 1; m <= 10; ++m) {
auto r1 = sol();
auto r2 = naive();
if (r1 != r2) {
cout << n << ' ' << m << " : " << r1 << ' ' << r2 << endl;
}
}*/
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 5 * 1000 * 1000 + 17;
const int MOD = 1000 * 1000 * 1000 + 7;
const int M = 998244353;
int n, m;
long long F[N];
bool read() {
if (!(cin >> n >> m))
return false;
return true;
}
long long naive() {
vector<vector<vector<long long>>> dp(
n + 1,
vector<vector<long long>>(3 * m + 1, vector<long long>(n + 1, 0ll)));
dp[0][0][0] = 1;
for (int i = 0; i < n; ++i)
for (int s = 0; s <= 3 * m; ++s)
for (int j = 0; j <= i; ++j)
for (int c = 0; c <= 2 * m && c + s <= 3 * m; ++c) {
if (j + c % 2 > n)
continue;
dp[i + 1][s + c][j + c % 2] += dp[i][s][j];
dp[i + 1][s + c][j + c % 2] %= M;
}
auto res = 0ll;
for (int j = 0; j <= 2 * m && j <= n; ++j)
res = (res + dp[n][3 * m][j]) % M;
return res;
}
long long bpow(long long a, int n, long long M) {
auto res = 1ll;
for (; n > 0; n /= 2, a = a * a % M)
if (n & 1)
res = res * a % M;
return res;
}
long long rev(long long x) { return bpow(x, M - 2, M); }
long long binomial(int n, int k) {
return n < 0 || k < 0 || k > n ? 0ll : F[n] * rev(F[k] * F[n - k] % M) % M;
}
long long gay(int s, int n) {
return s == 0 ? 1ll : binomial(s + n - 1, n - 1);
}
long long sol() {
auto res = gay(3 * m, n);
for (int mx = 2 * m + 1; mx <= 3 * m; ++mx) {
auto cur = gay(3 * m - mx, n - 1) * n % M;
res = (res + M - cur) % M;
}
for (int odd = m + 1; odd <= 3 * m; ++odd)
if ((3 * m - odd) % 2 == 0) {
auto cur = gay((3 * m - odd) / 2, n) * binomial(n, odd) % M;
res = (res + M - cur) % M;
}
return res;
}
void solve() {
F[0] = 1ll;
for (int i = 1; i < N; ++i)
F[i] = i * F[i - 1] % M;
cout << sol() << endl;
/*for (n = 2; n <= 500; ++n)
for (m = 1; m <= 10; ++m) {
auto r1 = sol();
auto r2 = naive();
if (r1 != r2) {
cout << n << ' ' << m << " : " << r1 << ' ' << r2 << endl;
}
}*/
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
while (read())
solve();
return 0;
}
| [
"literal.number.change",
"expression.operation.binary.change",
"control_flow.loop.for.initializer.change",
"expression.operation.binary.remove"
] | 772,214 | 772,215 | u138919616 | cpp |
p02965 | #include <iostream>
using namespace std;
typedef long long ll;
#define M 998244353
#define Z 3000000
ll pot(int a, int b) {
if (b == 0)
return 1;
ll x = pot(a, b / 2);
x = x * x % M;
if (b % 2)
x = x * a % M;
return x;
}
ll inv(ll x) { return pot(x, M - 2); }
ll ff[Z + 1];
ll ii[Z + 1];
ll ncr(int a, int b) { return ff[a] * ii[b] % M * ii[a - b] % M; }
ll calc(int n, int k) { return ncr(k + n - 1, k); }
int n, m;
int main() {
ff[0] = 1;
for (int i = 1; i <= Z; i++)
ff[i] = ff[i - 1] * i % M;
ii[Z] = inv(ff[Z]);
for (int i = Z - 1; i >= 0; i--)
ii[i] = ii[i + 1] * (i + 1) % M;
cin >> n >> m;
ll x = calc(n, 2 * m + m);
for (int i = 2 * m + 1; i <= 2 * m + m; i++) {
ll u = n * calc(n - 1, 2 * m + m - i) % M;
x = (x - u) % M;
if (x < 0)
x += M;
}
if (m < n) {
for (int i = m + 1; i <= n; i++) {
if (2 * m + m - i <= 0 || (2 * m + m - i) % 2 == 1)
continue;
ll u = ncr(n, i) * calc(n, (2 * m + m - i) / 2) % M;
x = (x - u) % M;
if (x < 0)
x += M;
}
}
cout << x << "\n";
}
| #include <iostream>
using namespace std;
typedef long long ll;
#define M 998244353
#define Z 3000000
ll pot(int a, int b) {
if (b == 0)
return 1;
ll x = pot(a, b / 2);
x = x * x % M;
if (b % 2)
x = x * a % M;
return x;
}
ll inv(ll x) { return pot(x, M - 2); }
ll ff[Z + 1];
ll ii[Z + 1];
ll ncr(int a, int b) { return ff[a] * ii[b] % M * ii[a - b] % M; }
ll calc(int n, int k) { return ncr(k + n - 1, k); }
int n, m;
int main() {
ff[0] = 1;
for (int i = 1; i <= Z; i++)
ff[i] = ff[i - 1] * i % M;
ii[Z] = inv(ff[Z]);
for (int i = Z - 1; i >= 0; i--)
ii[i] = ii[i + 1] * (i + 1) % M;
cin >> n >> m;
ll x = calc(n, 2 * m + m);
for (int i = 2 * m + 1; i <= 2 * m + m; i++) {
ll u = n * calc(n - 1, 2 * m + m - i) % M;
x = (x - u) % M;
if (x < 0)
x += M;
}
if (m < n) {
for (int i = m + 1; i <= n; i++) {
if (2 * m + m - i < 0 || (2 * m + m - i) % 2 == 1)
continue;
ll u = ncr(n, i) * calc(n, (2 * m + m - i) / 2) % M;
x = (x - u) % M;
if (x < 0)
x += M;
}
}
cout << x << "\n";
}
| [
"expression.operator.compare.change",
"control_flow.branch.if.condition.change"
] | 772,216 | 772,217 | u068910003 | cpp |
p02965 | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
constexpr ll mod = 998244353;
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
int main() {
ll n, m;
cin >> n >> m;
mod_build(3000000);
ll ok = comb(n - 1 + 3 * m, 3 * m), ng = comb(n - 1 + m - 1, m - 1);
REP(i, m + 1, n + 1) {
int s = 3 * m - i, t = m - i;
if (s % 2 == 0)
ok += mod - comb(n, i) * comb(n + s / 2 - 1, n - 1) % mod;
if (t % 2 == 0) {
ng += mod - comb(n - 1, i - 1) * comb(n + t / 2 - 1, n - 1) % mod;
ng += mod - comb(n - 1, i) * comb(n + t / 2 - 2, n - 1) % mod;
}
}
ok %= mod;
ng = ng * n % mod;
cout << (ok - ng + mod) % mod << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
constexpr ll mod = 998244353;
vector<ll> inv, fact, invfact;
void mod_build(int n = 101010) {
fact.resize(n + 1);
inv.resize(n + 1);
invfact.resize(n + 1);
fact[0] = inv[0] = invfact[0] = 1;
inv[1] = 1;
rep(i, n) {
fact[i + 1] = fact[i] * (i + 1) % mod;
if (i > 0)
inv[i + 1] = mod - inv[mod % (i + 1)] * (mod / (i + 1)) % mod;
invfact[i + 1] = invfact[i] * inv[i + 1] % mod;
}
}
ll perm(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return fact[n] * invfact[n - k] % mod;
}
ll comb(int n, int k) {
if (n < 0 || k < 0 || k > n)
return 0;
return (fact[n] * invfact[n - k] % mod) * invfact[k] % mod;
}
ll powmod(ll n, ll k) {
k %= mod - 1;
if (k < 0)
k += mod - 1;
ll ret = 1;
while (k) {
if (k & 1)
ret = ret * n % mod;
n = n * n % mod;
k >>= 1;
}
return ret;
}
int main() {
ll n, m;
cin >> n >> m;
mod_build(3000000);
ll ok = comb(n - 1 + 3 * m, 3 * m), ng = comb(n - 1 + m - 1, m - 1);
REP(i, m + 1, n + 1) {
int s = 3 * m - i, t = m - i;
if (s % 2 == 0)
ok += mod - comb(n, i) * comb(n + s / 2 - 1, n - 1) % mod;
if (t % 2 == 0) {
ng += mod - comb(n - 1, i - 1) * comb(n + t / 2 - 1, n - 1) % mod;
ng += mod - comb(n - 1, i) * comb(n + t / 2 - 2, n - 1) % mod;
}
}
ok %= mod;
ng %= mod;
ng = ng * n % mod;
cout << (ok - ng + mod) % mod << endl;
return 0;
} | [
"assignment.add"
] | 772,244 | 772,245 | u352642493 | cpp |
p02965 | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(20);
}
} fast;
/* define */
#define FOR(I, X, Y) for (long long(I) = (X); (I) < (Y); (I)++)
#define REP(I, X, Y) for (long long(I) = (Y)-1; (I) >= (X); (I)--)
#define ALL(X) (X).begin(), (X).end()
#define pb push_back
#define COUNT(V, X) \
(upper_bound((V).begin(), (V).end(), X) - \
lower_bound((V).begin(), (V).end(), X))
#define debug(x) cerr << #x << ':' << x << endl;
#define DEBUG(v) \
{ \
cerr << #v << ':'; \
for (auto xv : v) \
cerr << xv << ' '; \
cerr << endl; \
}
#define Yes(X) cout << (X ? "Yes" : "No") << endl;
#define YES(X) cout << (X ? "YES" : "NO") << endl;
#define ctoi(C) (C - '0')
#define pow2(x) ((long long)((long long)1 << x))
/* alias */
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vii = vector<vector<int>>;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using pi = pair<int, int>;
using pl = pair<long long, long long>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const long long dx[] = {1, 0, -1, 0};
const long long dy[] = {0, 1, 0, -1};
const long long dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long dx9[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
const long long dy9[] = {0, 1, 1, 1, 0, -1, -1, -1, 0};
const int INF = 998244353;
const long long LINF = 1000000000000000007;
/* func */
template <typename T1, typename T2> inline bool chmin(T1 &a, const T2 &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, const T2 &b) {
if (a < b)
a = b;
return a < b;
}
long long max(long long x, int y) { return max(x, (long long)y); }
long long max(int x, long long y) { return max((long long)x, y); }
long long min(long long x, int y) { return min(x, (long long)y); }
long long min(int x, long long y) { return min((long long)x, y); }
/* library */
long long POW(long long x, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n % 2)
ans *= x;
x *= x;
x %= mod;
ans %= mod;
n >>= 1;
}
return ans;
}
vector<long long> factorial(2, 1);
long long comb(long long n, long long k, long long p) {
if (n < k || n < 0 || k < 0)
return 0;
while (factorial.size() <= n) {
long long i = factorial.size();
factorial.push_back(i * factorial[i - 1] % p);
}
return ((factorial[n] * POW(factorial[k], p - 2, p)) % p) *
POW(factorial[n - k], p - 2, p) % p;
}
long long TwelvefoldWay4(long long n, long long k, long long MOD) {
return comb(n + k - 1, n, MOD);
}
/* main */
signed main() {
ll N, M;
cin >> N >> M;
ll ans = 0;
for (ll i = 0; i <= M; i += 2) {
ll tmp1 = TwelvefoldWay4((M + i / (ll)2), N, INF);
ll tmp2 =
((i != 0 ? TwelvefoldWay4(i / (ll)2 - (ll)1, N, INF) : (ll)0) * N) %
INF;
ll tmp3 = comb(N, M - i, INF);
ll tmp4 = (TwelvefoldWay4(i / 2, N - 1, INF) * N) % INF;
ll tmp5 = comb(N - 1, M - i - 1, INF);
// cerr << i << tmp1 << ' ' << tmp2 << ' ' << tmp3 << ' ' << tmp4 << ' ' <<
// tmp5 << endl;
ans += (((tmp1 - tmp2 + INF) % INF) * tmp3) % INF;
ans -= (tmp4 * tmp5) % INF;
ans %= INF;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
cout.precision(20);
}
} fast;
/* define */
#define FOR(I, X, Y) for (long long(I) = (X); (I) < (Y); (I)++)
#define REP(I, X, Y) for (long long(I) = (Y)-1; (I) >= (X); (I)--)
#define ALL(X) (X).begin(), (X).end()
#define pb push_back
#define COUNT(V, X) \
(upper_bound((V).begin(), (V).end(), X) - \
lower_bound((V).begin(), (V).end(), X))
#define debug(x) cerr << #x << ':' << x << endl;
#define DEBUG(v) \
{ \
cerr << #v << ':'; \
for (auto xv : v) \
cerr << xv << ' '; \
cerr << endl; \
}
#define Yes(X) cout << (X ? "Yes" : "No") << endl;
#define YES(X) cout << (X ? "YES" : "NO") << endl;
#define ctoi(C) (C - '0')
#define pow2(x) ((long long)((long long)1 << x))
/* alias */
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vii = vector<vector<int>>;
using vl = vector<long long>;
using vll = vector<vector<long long>>;
using pi = pair<int, int>;
using pl = pair<long long, long long>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const long long dx[] = {1, 0, -1, 0};
const long long dy[] = {0, 1, 0, -1};
const long long dx8[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long dy8[] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long dx9[] = {1, 1, 0, -1, -1, -1, 0, 1, 0};
const long long dy9[] = {0, 1, 1, 1, 0, -1, -1, -1, 0};
const int INF = 998244353;
const long long LINF = 1000000000000000007;
/* func */
template <typename T1, typename T2> inline bool chmin(T1 &a, const T2 &b) {
if (a > b)
a = b;
return a > b;
}
template <typename T1, typename T2> inline bool chmax(T1 &a, const T2 &b) {
if (a < b)
a = b;
return a < b;
}
long long max(long long x, int y) { return max(x, (long long)y); }
long long max(int x, long long y) { return max((long long)x, y); }
long long min(long long x, int y) { return min(x, (long long)y); }
long long min(int x, long long y) { return min((long long)x, y); }
/* library */
long long POW(long long x, long long n, long long mod) {
long long ans = 1;
while (n) {
if (n % 2)
ans *= x;
x *= x;
x %= mod;
ans %= mod;
n >>= 1;
}
return ans;
}
vector<long long> factorial(2, 1);
long long comb(long long n, long long k, long long p) {
if (n < k || n < 0 || k < 0)
return 0;
while (factorial.size() <= n) {
long long i = factorial.size();
factorial.push_back(i * factorial[i - 1] % p);
}
return ((factorial[n] * POW(factorial[k], p - 2, p)) % p) *
POW(factorial[n - k], p - 2, p) % p;
}
long long TwelvefoldWay4(long long n, long long k, long long MOD) {
return comb(n + k - 1, n, MOD);
}
/* main */
signed main() {
ll N, M;
cin >> N >> M;
ll ans = 0;
for (ll i = 0; i <= M; i += 2) {
ll tmp1 = TwelvefoldWay4((M + i / (ll)2), N, INF);
ll tmp2 =
((i != 0 ? TwelvefoldWay4(i / (ll)2 - (ll)1, N, INF) : (ll)0) * N) %
INF;
ll tmp3 = comb(N, M - i, INF);
ll tmp4 = (TwelvefoldWay4(i / 2, N - 1, INF) * N) % INF;
ll tmp5 = comb(N - 1, M - i - 1, INF);
// cerr << i << tmp1 << ' ' << tmp2 << ' ' << tmp3 << ' ' << tmp4 << ' ' <<
// tmp5 << endl;
ans += (((tmp1 - tmp2 + INF) % INF) * tmp3) % INF;
ans -= (tmp4 * tmp5) % INF;
ans += INF;
ans %= INF;
}
cout << ans << endl;
}
| [
"assignment.add"
] | 772,250 | 772,251 | u205561862 | cpp |
p02966 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int n, a[maxn][maxn];
long long suma[maxn][maxn], sumb[maxn][maxn], f[maxn][maxn], ans = 1e18;
inline int getsum(int a, int b, int c) {
return sumb[b + 1][c] + suma[n][b] - suma[n][a] + suma[c][a] - suma[c][b];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i ^ j)
scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
suma[i][j] =
suma[i - 1][j] + suma[i][j - 1] - suma[i - 1][j - 1] + a[i][j];
for (int j = 1; j <= n; j++)
for (int i = j; i >= 1; i--)
sumb[i][j] =
sumb[i + 1][j] + sumb[i][j - 1] - sumb[i + 1][j - 1] + a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
f[i][j] = 1e18;
for (int i = 1; i < n; i++) {
f[i][0] = getsum(0, 0, i);
ans = min(ans, f[i][0] + getsum(0, i, n));
for (int j = 1; j < i; j++) {
for (int k = 0; k < j; k++)
f[i][j] = min(f[i][j], f[j][k] + getsum(k, j, i));
ans = min(ans, f[i][j] + getsum(j, i, n));
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int n, a[maxn][maxn];
long long suma[maxn][maxn], sumb[maxn][maxn], f[maxn][maxn], ans = 1e18;
inline long long getsum(int a, int b, int c) {
return sumb[b + 1][c] + suma[n][b] - suma[n][a] + suma[c][a] - suma[c][b];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if (i ^ j)
scanf("%d", &a[i][j]);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
suma[i][j] =
suma[i - 1][j] + suma[i][j - 1] - suma[i - 1][j - 1] + a[i][j];
for (int j = 1; j <= n; j++)
for (int i = j; i >= 1; i--)
sumb[i][j] =
sumb[i + 1][j] + sumb[i][j - 1] - sumb[i + 1][j - 1] + a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
f[i][j] = 1e18;
for (int i = 1; i < n; i++) {
f[i][0] = getsum(0, 0, i);
ans = min(ans, f[i][0] + getsum(0, i, n));
for (int j = 1; j < i; j++) {
for (int k = 0; k < j; k++)
f[i][j] = min(f[i][j], f[j][k] + getsum(k, j, i));
ans = min(ans, f[i][j] + getsum(j, i, n));
}
}
cout << ans << endl;
} | [
"variable_declaration.type.primitive.change",
"variable_declaration.type.widen.change"
] | 772,254 | 772,255 | u177525366 | cpp |
p02969 | #include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.141592653589793
// vector < vector<int>>a(0, vector<int>(0));二次元配列宣言
int main() {
int r;
cout << 3 * r * r << endl;
} | #include "bits/stdc++.h"
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.141592653589793
// vector < vector<int>>a(0, vector<int>(0));二次元配列宣言
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
} | [] | 772,256 | 772,257 | u477156071 | cpp |
p02969 | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pf(n) printf("%d\n", n)
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1001001001;
const double PI = acos(-1);
int main() {
int r;
cin >> r;
cout << r * r * r * 3 << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pf(n) printf("%d\n", n)
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1001001001;
const double PI = acos(-1);
int main() {
int r;
cin >> r;
cout << r * r * 3 << endl;
return 0;
} | [
"expression.operation.binary.remove"
] | 772,272 | 772,273 | u770486670 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long int ll;
typedef unsigned long long int ull;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c;
string s, t;
cin >> a;
cout << 3 * a * a * a;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
typedef long long int ll;
typedef unsigned long long int ull;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a, b, c;
string s, t;
cin >> a;
cout << 3 * a * a;
} | [
"expression.operation.binary.remove"
] | 772,276 | 772,277 | u906199847 | cpp |
p02968 | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(2 * N), R(2 * N);
for (int i = 0; i < 2 * N; ++i) {
while (L[i] * L[i] + i * i < N * N)
++L[i];
while (R[i] < 2 * N && R[i] * R[i] + i * i <= 4 * N * N)
++R[i];
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
vector<vector<int>> dp(N + 1, vector<int>(i + 1));
dp[N][0] = 1;
int ptr = 2 * N, anti = 0;
for (int j = N - 1; j >= 0; --j) {
while (R[ptr - 1] < L[j]) {
--ptr;
for (int k = 0; k <= j && k <= i; ++k) {
dp[j + 1][k] = 1LL * dp[j + 1][k] * max(R[ptr] - (k + anti), 0) % M;
}
++anti;
}
for (int k = 0; k <= N - j - 1 && k <= i; ++k) {
if (k != i)
dp[j][k + 1] =
(dp[j][k + 1] + 1LL * dp[j + 1][k] * max(L[j] - (k + anti), 0)) %
M;
dp[j][k] = (dp[j][k] + 1LL * dp[j + 1][k] *
max(R[j] - (2 * N - j + (i - k) - 1), 0)) %
M;
}
}
int sub = dp[0][i];
while (ptr > N) {
--ptr;
sub = 1LL * sub * max(R[ptr] - (i + anti), 0) % M;
++anti;
}
if (i % 2 == 0)
ans = (ans + sub) % M;
else
ans = (ans - sub + M) % M;
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(2 * N), R(2 * N);
for (int i = 0; i < 2 * N; ++i) {
while (L[i] * L[i] + i * i < N * N)
++L[i];
while (R[i] < 2 * N && R[i] * R[i] + i * i <= 4 * N * N)
++R[i];
}
int ans = 0;
for (int i = 0; i <= N; ++i) {
vector<vector<int>> dp(N + 1, vector<int>(i + 1));
dp[N][0] = 1;
int ptr = 2 * N, anti = 0;
for (int j = N - 1; j >= 0; --j) {
while (R[ptr - 1] < L[j]) {
--ptr;
for (int k = 0; k <= N - j - 1 && k <= i; ++k) {
dp[j + 1][k] = 1LL * dp[j + 1][k] * max(R[ptr] - (k + anti), 0) % M;
}
++anti;
}
for (int k = 0; k <= N - j - 1 && k <= i; ++k) {
if (k != i)
dp[j][k + 1] =
(dp[j][k + 1] + 1LL * dp[j + 1][k] * max(L[j] - (k + anti), 0)) %
M;
dp[j][k] = (dp[j][k] + 1LL * dp[j + 1][k] *
max(R[j] - (2 * N - j + (i - k) - 1), 0)) %
M;
}
}
int sub = dp[0][i];
while (ptr > N) {
--ptr;
sub = 1LL * sub * max(R[ptr] - (i + anti), 0) % M;
++anti;
}
if (i % 2 == 0)
ans = (ans + sub) % M;
else
ans = (ans - sub + M) % M;
}
cout << ans << endl;
return 0;
}
| [
"control_flow.loop.condition.change",
"control_flow.loop.for.condition.change",
"misc.off_by_one"
] | 772,290 | 772,291 | u837745858 | cpp |
p02969 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long int;
using namespace std;
ll mod = 1e9 + 7;
int main() {
ll r;
cout << 3 * r * r << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using ll = long long int;
using namespace std;
ll mod = 1e9 + 7;
int main() {
ll r;
cin >> r;
cout << 3 * r * r << endl;
} | [] | 772,313 | 772,314 | u167245594 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
cout << 2 * pow(a, 2) << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long long a;
cin >> a;
cout << 3 * pow(a, 2) << endl;
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 772,320 | 772,321 | u319965179 | cpp |
p02969 | #include <bits/stdc++.h>
#define MOD (long long)(1E9 + 7)
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n;
cin >> n;
cout << 4 * n * n << endl;
} | #include <bits/stdc++.h>
#define MOD (long long)(1E9 + 7)
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int n;
cin >> n;
cout << 3 * n * n << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 772,324 | 772,325 | u503170128 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int R;
cin >> R;
cout << 3 * R + 3 * R << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int R;
cin >> R;
cout << 3 * R * R << endl;
}
| [
"expression.operation.binary.remove"
] | 772,326 | 772,327 | u237390401 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define lli long long
#define mp make_pair
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define ok return 0;
#define MOAE \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
int main() {
MOAE;
ll r;
cout << 3 * r * r << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define lli long long
#define mp make_pair
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define allr(v) (v).rbegin(), (v).rend()
#define ok return 0;
#define MOAE \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
int main() {
MOAE;
ll r;
cin >> r;
cout << 3 * r * r << endl;
}
| [] | 772,330 | 772,331 | u595501523 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cout << 3 * r * r << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
} | [] | 772,334 | 772,335 | u422692699 | cpp |
p02969 | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * pow(r, 3) << endl;
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * pow(r, 2) << endl;
} | [
"literal.number.change",
"io.output.change"
] | 772,336 | 772,337 | u395356317 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int r;
cout << 3 * r * r << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
int r;
cin >> r;
cout << 3 * r * r << '\n';
return 0;
} | [] | 772,349 | 772,350 | u194015723 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define uli unsigned long long int
#define INF 999999999999999999
#define rep(i, m, n) for (lli i = m; i < n; i++)
#define rrep(i, m, n) for (lli i = m - 1; i >= n; i--)
#define pb(n) push_back(n)
#define UE(N) N.erase(unique(N.begin(), N.end()), N.end());
#define Sort(n) sort(n.begin(), n.end())
#define Rev(n) reverse(n.begin(), n.end())
#define Out(S) cout << S << endl
#define NeOut(S) cout << S
#define HpOut(S) cout << setprecision(25) << S << endl
#define Vec(K, L, N, S) vector<L> K(N, S)
#define DV(K, L, N, M, S) vector<vector<L>> K(N, vector<L>(M, S))
#define TV(K, L, N, M, R, S) \
vector<vector<vector<L>>> K(N, vector<vector<L>>(M, vector<L>(R, S)))
#define pint pair<lli, lli>
#define paf(L, R) pair<L, R>
#define mod 1000000007
#define MAX 10000000
#define ALL(a) a.begin(), a.end()
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int 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;
}
}
lli nCr(lli n, lli r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % mod) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
lli A, B, C, D, E, F, N, M, K, L, R, X, Y, Z, W, H, sum = 0, num = 0,
flag = 0;
string S, T;
cin >> N;
Out(3 * N * N * N);
} | #include <bits/stdc++.h>
using namespace std;
#define lli long long int
#define uli unsigned long long int
#define INF 999999999999999999
#define rep(i, m, n) for (lli i = m; i < n; i++)
#define rrep(i, m, n) for (lli i = m - 1; i >= n; i--)
#define pb(n) push_back(n)
#define UE(N) N.erase(unique(N.begin(), N.end()), N.end());
#define Sort(n) sort(n.begin(), n.end())
#define Rev(n) reverse(n.begin(), n.end())
#define Out(S) cout << S << endl
#define NeOut(S) cout << S
#define HpOut(S) cout << setprecision(25) << S << endl
#define Vec(K, L, N, S) vector<L> K(N, S)
#define DV(K, L, N, M, S) vector<vector<L>> K(N, vector<L>(M, S))
#define TV(K, L, N, M, R, S) \
vector<vector<vector<L>>> K(N, vector<vector<L>>(M, vector<L>(R, S)))
#define pint pair<lli, lli>
#define paf(L, R) pair<L, R>
#define mod 1000000007
#define MAX 10000000
#define ALL(a) a.begin(), a.end()
#define chmax(a, b) a = (((a) < (b)) ? (b) : (a))
#define chmin(a, b) a = (((a) > (b)) ? (b) : (a))
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int 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;
}
}
lli nCr(lli n, lli r) {
if (n < r)
return 0;
if (n < 0 || r < 0)
return 0;
return fac[n] * (finv[r] * finv[n - r] % mod) % mod;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
lli A, B, C, D, E, F, N, M, K, L, R, X, Y, Z, W, H, sum = 0, num = 0,
flag = 0;
string S, T;
cin >> N;
Out(3 * N * N);
}
| [
"expression.operation.binary.remove"
] | 772,357 | 772,358 | u618604643 | cpp |
p02969 | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#if defined(_MSC_VER) || defined(ONLINE_JUDGE)
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#endif
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
#define dump(x) cerr << #x << " = " << (x) << endl;
using LL = long long;
using VI = vector<int>;
using VL = vector<LL>;
using VS = vector<string>;
using VD = vector<double>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
const int inf = (int)1e9;
const double pi = acos(-1.0);
const LL MOD = 1000000007;
const string Snum = "0123456789";
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1},
dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
template <class T> void Sort(T &a) { sort(all(a)); }
template <class T> void ReSort(T &a) { sort(a.rbegin(), a.rend()); }
template <class T> void Reverse(T &a) { reverse(all(a)); }
template <class T> void Unique(T &a) { a.erase(unique(all(a)), a.end()); }
template <class T> auto Max(const T &a) { return *max_element(all(a)); }
template <class T> auto Min(const T &a) { return *min_element(all(a)); }
template <class T> int MaxPos(const T &a) {
return max_element(all(a)) - a.begin();
}
template <class T> int MinPos(const T &a) {
return min_element(all(a)) - a.begin();
}
template <class T, class U> int Count(const T &a, U v) {
return count(all(a), v);
}
template <class T, class U> U Sum(const T &a, U v) {
return accumulate(all(a), v);
}
template <class T, class U> int Lower(const T &a, U v) {
return lower_bound(all(a), v) - a.begin();
}
template <class T, class U> int Upper(const T &a, U v) {
return upper_bound(all(a), v) - a.begin();
}
template <class T, class P> void RemoveIf(T &a, P f) {
a.erase(remove_if(all(a), f), a.end());
}
template <class T> T Age(T n, T m) { return (n + m - 1) / m; }
template <class T> T Gcd(T n, T m) { return m == 0 ? n : Gcd(m, n % m); }
template <class T> T Lcm(T n, T m) { return n / Gcd(n, m) * m; }
template <class T> T Pow(T a, T n) {
T r = 1;
while (n > 0) {
if (n & 1)
r *= a;
a *= a;
n /= 2;
}
return r;
}
template <class T> T Powmod(T a, T n, T m = MOD) {
T r = 1;
while (n > 0) {
if (n & 1)
r = r * a % m, n--;
else
a = a * a % m, n /= 2;
}
return r;
}
/* INPUT */
template <class T> T InputF() {
T o;
cin >> o;
return o;
}
template <> char InputF() {
char ret = '\0', c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret = c;
c = getchar_unlocked();
}
return ret;
}
template <> string InputF() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
template <> int InputF() {
int ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10 + (c - '0');
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> LL InputF() {
LL ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10LL + (LL(c) - LL('0'));
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> double InputF() {
double ret = 0, dp = 1;
bool neg = false, adp = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while (('0' <= c && c <= '9') || c == '.') {
if (c == '.') {
adp = true;
} else if (adp) {
dp *= 0.1;
ret += (c - '0') * dp;
} else {
ret = ret * 10.0 + (c - '0');
}
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
string GetLine() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
template <class T> T StoT(string s) { return s; }
template <> char StoT(string s) { return s.front(); }
template <> string StoT(string s) { return s; }
template <> int StoT(string s) { return stoi(s); }
template <> LL StoT(string s) { return stoll(s); }
template <> double StoT(string s) { return stod(s); }
VS InputB;
template <class T> struct InputC {
operator T() { return InputF<T>(); }
vector<T> operator[](int h) {
vector<T> ret(h);
rep(i, h) ret[i] = InputF<T>();
return ret;
}
vector<vector<T>> operator[](PII p) {
int h, w;
tie(h, w) = p;
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = InputF<T>();
return ret;
}
T at(int n) {
while (sz(InputB) <= n)
InputB.pb(InputF<string>());
return StoT<T>(InputB[n]);
}
vector<T> at(int n, int h) {
vector<T> ret(h);
rep(i, h) ret[i] = at(i + n);
return ret;
}
vector<vector<T>> at(int n, int h, int w) {
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = at(n + i * w + j);
return ret;
}
};
InputC<char> inc;
InputC<string> ins;
InputC<int> ini;
InputC<LL> inl;
InputC<double> ind;
/* OUTPUT */
class ostreamfbuff : public basic_streambuf<char, char_traits<char>> {
protected:
int overflow(int nCh = EOF) {
putchar_unlocked(nCh);
return 0;
}
};
class ostreamf : public basic_iostream<char, char_traits<char>> {
public:
ostreamf(void)
: basic_iostream<char, char_traits<char>>(new ostreamfbuff()) {}
};
ostreamf coutf;
ostream &operator<<(ostream &ostr, InputC<string> i) {
ostr << string(i);
return ostr;
}
struct BoolStr {
string t, f;
BoolStr(string tr, string fa) : t(tr), f(fa) {}
} yes("yes", "no"), Yes("Yes", "No"), YES("YES", "NO"), Yay("Yay!", ":(");
struct Divizer {
string s;
Divizer(string s_) : s(s_) {}
} spc(" "), nosp(""), comma(","), lin("\n");
struct Output {
bool flag = false;
BoolStr bs;
Divizer di;
Output(bool f, BoolStr b, Divizer d) : flag(f), bs(b), di(d) {}
template <class T> void print(T o) { coutf << o; }
void print(double o) { printf("%.20f", o); }
void print(bool o) { coutf << (o ? bs.t : bs.f); }
template <class T, class U> void print(const pair<T, U> &o) {
print(o.first);
coutf << di.s;
print(o.second);
}
template <class T> void print(const vector<T> &o) {
for (int i = 0; i < (int)o.size(); ++i) {
if (i != 0)
coutf << di.s;
print(o[i]);
}
}
template <class T, class U> void print(const map<T, U> &o) {
coutf << "Map";
for (auto a : o) {
coutf << " {";
print(a);
coutf << "},";
}
coutf << "\n";
}
template <class T> void print(const set<T> &o) {
coutf << "Set {";
for (auto a : o) {
print(a);
coutf << ",";
}
coutf << "}\n";
}
template <class T> Output operator,(T o) {
if (flag)
coutf << di.s;
print(o);
Output t(true, bs, di);
return t;
}
Output operator,(Output o) {
coutf << '\n';
return o;
}
Output operator,(BoolStr b) {
Output t(flag, b, di);
return t;
}
Output operator,(Divizer d) {
Output t(flag, bs, d);
return t;
}
} out(false, Yes, spc);
/* ANSWER */
struct Answer {
int mini = INT_MAX, maxi = INT_MIN, sumi = 0;
LL minl = LLONG_MAX, maxl = LLONG_MIN, suml = 0;
double mind = DBL_MAX, maxd = DBL_MIN, sumd = 0;
int cnt = 0;
void operator=(int n) {
mini = min(mini, n);
maxi = max(maxi, n);
sumi += n;
cnt++;
}
void operator=(LL n) {
minl = min(minl, n);
maxl = max(maxl, n);
suml += n;
cnt++;
}
void operator=(double n) {
mind = min(mind, n);
maxd = max(maxd, n);
sumd += n;
cnt++;
}
} ans;
int main() {
int r = ini;
out, 3 * r *r *r, out;
} | #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
#if defined(_MSC_VER) || defined(ONLINE_JUDGE)
#define getchar_unlocked _getchar_nolock
#define putchar_unlocked _putchar_nolock
#endif
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define mp make_pair
#define pb push_back
#define dump(x) cerr << #x << " = " << (x) << endl;
using LL = long long;
using VI = vector<int>;
using VL = vector<LL>;
using VS = vector<string>;
using VD = vector<double>;
using VVI = vector<VI>;
using VVL = vector<VL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
const int inf = (int)1e9;
const double pi = acos(-1.0);
const LL MOD = 1000000007;
const string Snum = "0123456789";
const int dx[] = {-1, 0, 1, 0, -1, -1, 1, 1},
dy[] = {0, 1, 0, -1, -1, 1, -1, 1};
template <class T> void Sort(T &a) { sort(all(a)); }
template <class T> void ReSort(T &a) { sort(a.rbegin(), a.rend()); }
template <class T> void Reverse(T &a) { reverse(all(a)); }
template <class T> void Unique(T &a) { a.erase(unique(all(a)), a.end()); }
template <class T> auto Max(const T &a) { return *max_element(all(a)); }
template <class T> auto Min(const T &a) { return *min_element(all(a)); }
template <class T> int MaxPos(const T &a) {
return max_element(all(a)) - a.begin();
}
template <class T> int MinPos(const T &a) {
return min_element(all(a)) - a.begin();
}
template <class T, class U> int Count(const T &a, U v) {
return count(all(a), v);
}
template <class T, class U> U Sum(const T &a, U v) {
return accumulate(all(a), v);
}
template <class T, class U> int Lower(const T &a, U v) {
return lower_bound(all(a), v) - a.begin();
}
template <class T, class U> int Upper(const T &a, U v) {
return upper_bound(all(a), v) - a.begin();
}
template <class T, class P> void RemoveIf(T &a, P f) {
a.erase(remove_if(all(a), f), a.end());
}
template <class T> T Age(T n, T m) { return (n + m - 1) / m; }
template <class T> T Gcd(T n, T m) { return m == 0 ? n : Gcd(m, n % m); }
template <class T> T Lcm(T n, T m) { return n / Gcd(n, m) * m; }
template <class T> T Pow(T a, T n) {
T r = 1;
while (n > 0) {
if (n & 1)
r *= a;
a *= a;
n /= 2;
}
return r;
}
template <class T> T Powmod(T a, T n, T m = MOD) {
T r = 1;
while (n > 0) {
if (n & 1)
r = r * a % m, n--;
else
a = a * a % m, n /= 2;
}
return r;
}
/* INPUT */
template <class T> T InputF() {
T o;
cin >> o;
return o;
}
template <> char InputF() {
char ret = '\0', c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret = c;
c = getchar_unlocked();
}
return ret;
}
template <> string InputF() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n' && c != '\t' && c != ' ') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
template <> int InputF() {
int ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10 + (c - '0');
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> LL InputF() {
LL ret = 0;
bool neg = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while ('0' <= c && c <= '9') {
ret = ret * 10LL + (LL(c) - LL('0'));
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
template <> double InputF() {
double ret = 0, dp = 1;
bool neg = false, adp = false;
char c = getchar_unlocked();
if (c == '-') {
neg = true;
c = getchar_unlocked();
}
while (('0' <= c && c <= '9') || c == '.') {
if (c == '.') {
adp = true;
} else if (adp) {
dp *= 0.1;
ret += (c - '0') * dp;
} else {
ret = ret * 10.0 + (c - '0');
}
c = getchar_unlocked();
}
return neg ? -ret : ret;
}
string GetLine() {
string ret;
char c = getchar_unlocked();
while (c != '\0' && c != '\n') {
ret.push_back(c);
c = getchar_unlocked();
}
return ret;
}
template <class T> T StoT(string s) { return s; }
template <> char StoT(string s) { return s.front(); }
template <> string StoT(string s) { return s; }
template <> int StoT(string s) { return stoi(s); }
template <> LL StoT(string s) { return stoll(s); }
template <> double StoT(string s) { return stod(s); }
VS InputB;
template <class T> struct InputC {
operator T() { return InputF<T>(); }
vector<T> operator[](int h) {
vector<T> ret(h);
rep(i, h) ret[i] = InputF<T>();
return ret;
}
vector<vector<T>> operator[](PII p) {
int h, w;
tie(h, w) = p;
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = InputF<T>();
return ret;
}
T at(int n) {
while (sz(InputB) <= n)
InputB.pb(InputF<string>());
return StoT<T>(InputB[n]);
}
vector<T> at(int n, int h) {
vector<T> ret(h);
rep(i, h) ret[i] = at(i + n);
return ret;
}
vector<vector<T>> at(int n, int h, int w) {
vector<vector<T>> ret(h, vector<T>(w));
rep(i, h) rep(j, w) ret[i][j] = at(n + i * w + j);
return ret;
}
};
InputC<char> inc;
InputC<string> ins;
InputC<int> ini;
InputC<LL> inl;
InputC<double> ind;
/* OUTPUT */
class ostreamfbuff : public basic_streambuf<char, char_traits<char>> {
protected:
int overflow(int nCh = EOF) {
putchar_unlocked(nCh);
return 0;
}
};
class ostreamf : public basic_iostream<char, char_traits<char>> {
public:
ostreamf(void)
: basic_iostream<char, char_traits<char>>(new ostreamfbuff()) {}
};
ostreamf coutf;
ostream &operator<<(ostream &ostr, InputC<string> i) {
ostr << string(i);
return ostr;
}
struct BoolStr {
string t, f;
BoolStr(string tr, string fa) : t(tr), f(fa) {}
} yes("yes", "no"), Yes("Yes", "No"), YES("YES", "NO"), Yay("Yay!", ":(");
struct Divizer {
string s;
Divizer(string s_) : s(s_) {}
} spc(" "), nosp(""), comma(","), lin("\n");
struct Output {
bool flag = false;
BoolStr bs;
Divizer di;
Output(bool f, BoolStr b, Divizer d) : flag(f), bs(b), di(d) {}
template <class T> void print(T o) { coutf << o; }
void print(double o) { printf("%.20f", o); }
void print(bool o) { coutf << (o ? bs.t : bs.f); }
template <class T, class U> void print(const pair<T, U> &o) {
print(o.first);
coutf << di.s;
print(o.second);
}
template <class T> void print(const vector<T> &o) {
for (int i = 0; i < (int)o.size(); ++i) {
if (i != 0)
coutf << di.s;
print(o[i]);
}
}
template <class T, class U> void print(const map<T, U> &o) {
coutf << "Map";
for (auto a : o) {
coutf << " {";
print(a);
coutf << "},";
}
coutf << "\n";
}
template <class T> void print(const set<T> &o) {
coutf << "Set {";
for (auto a : o) {
print(a);
coutf << ",";
}
coutf << "}\n";
}
template <class T> Output operator,(T o) {
if (flag)
coutf << di.s;
print(o);
Output t(true, bs, di);
return t;
}
Output operator,(Output o) {
coutf << '\n';
return o;
}
Output operator,(BoolStr b) {
Output t(flag, b, di);
return t;
}
Output operator,(Divizer d) {
Output t(flag, bs, d);
return t;
}
} out(false, Yes, spc);
/* ANSWER */
struct Answer {
int mini = INT_MAX, maxi = INT_MIN, sumi = 0;
LL minl = LLONG_MAX, maxl = LLONG_MIN, suml = 0;
double mind = DBL_MAX, maxd = DBL_MIN, sumd = 0;
int cnt = 0;
void operator=(int n) {
mini = min(mini, n);
maxi = max(maxi, n);
sumi += n;
cnt++;
}
void operator=(LL n) {
minl = min(minl, n);
maxl = max(maxl, n);
suml += n;
cnt++;
}
void operator=(double n) {
mind = min(mind, n);
maxd = max(maxd, n);
sumd += n;
cnt++;
}
} ans;
int main() {
int r = ini;
out, 3 * r *r, out;
} | [
"expression.operation.binary.remove"
] | 772,359 | 772,360 | u172873334 | cpp |
p02969 | #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 2 * r * r << endl;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 772,369 | 772,370 | u342703951 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * 3 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
}
| [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 772,386 | 772,387 | u037563046 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << 3 * N * N * N << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << 3 * N * N << endl;
}
| [
"expression.operation.binary.remove"
] | 772,388 | 772,389 | u889173297 | cpp |
p02969 | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
int main() {
int s;
cout << s * s * 3 << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
int main() {
int s;
cin >> s;
cout << s * s * 3 << endl;
return 0;
}
| [] | 772,406 | 772,407 | u201553784 | cpp |
p02969 | #pragma gcc optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort(ALL(V)) //小さい方からソート
#define REV(V) reverse(ALL(V)) //リバース
#define RSORT(V) REV(SORT(V)) //大きい方からソート
#define NPN(V) next_permutation(ALL(V)) //順列
#define pb(n) push_back(n)
#define endl '\n'
#define Endl '\n'
#define DUMP(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define RAPID \
cin.tie(0); \
ios::sync_with_stdio(false)
#define IN(n) cin >> n
#define IN2(a, b) cin >> a >> b
#define IN3(a, b, c) cin >> a >> b >> c
#define VIN(V) \
for (int i = 0; i < (V).size(); i++) { \
cin >> (V).at(i); \
}
#define OUT(n) cout << n << endl
#define VOUT(V) \
REP(i, (V).size()) { cout << (V)[i] << endl; }
#define VOUT2(V) \
REP(i, (V).size()) { cout << (V)[i] << " "; } \
cout << endl;
// 型マクロ定義
#define int long long
#define P pair<ll, ll>
#define Vi vector<ll>
#define Vd vector<double>
#define Vs vector<string>
#define Vc vector<char>
#define M map<ll, ll>
#define S set<ll>
#define PQ priority_queue<ll>
#define PQG priority_queue < ll, V, greater<ll>
//
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最小公倍数
// デフォルト変数定義
int n, m, a, b, c, x, y, z, r;
double d, e, f;
string s, t;
//
signed main() {
RAPID;
IN(r);
OUT((3 * a * a));
} | #pragma gcc optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(V) (V).begin(), (V).end()
#define SORT(V) sort(ALL(V)) //小さい方からソート
#define REV(V) reverse(ALL(V)) //リバース
#define RSORT(V) REV(SORT(V)) //大きい方からソート
#define NPN(V) next_permutation(ALL(V)) //順列
#define pb(n) push_back(n)
#define endl '\n'
#define Endl '\n'
#define DUMP(x) cout << #x << " = " << (x) << endl
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define RAPID \
cin.tie(0); \
ios::sync_with_stdio(false)
#define IN(n) cin >> n
#define IN2(a, b) cin >> a >> b
#define IN3(a, b, c) cin >> a >> b >> c
#define VIN(V) \
for (int i = 0; i < (V).size(); i++) { \
cin >> (V).at(i); \
}
#define OUT(n) cout << n << endl
#define VOUT(V) \
REP(i, (V).size()) { cout << (V)[i] << endl; }
#define VOUT2(V) \
REP(i, (V).size()) { cout << (V)[i] << " "; } \
cout << endl;
// 型マクロ定義
#define int long long
#define P pair<ll, ll>
#define Vi vector<ll>
#define Vd vector<double>
#define Vs vector<string>
#define Vc vector<char>
#define M map<ll, ll>
#define S set<ll>
#define PQ priority_queue<ll>
#define PQG priority_queue < ll, V, greater<ll>
//
const int MOD = 1000000007;
const int INF = 1061109567;
const double EPS = 1e-10;
const double PI = acos(-1.0);
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; } //最小公倍数
// デフォルト変数定義
int n, m, a, b, c, x, y, z, r;
double d, e, f;
string s, t;
//
signed main() {
RAPID;
IN(r);
OUT((3 * r * r));
} | [
"identifier.change",
"call.arguments.change",
"expression.operation.binary.change"
] | 772,410 | 772,411 | u154645927 | cpp |
p02969 | // include
//------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define fore(i, a) for (auto &i : a)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
}
int main() {
long long r;
cin >> r;
long long A = 3 * pow(2, r);
cout << A;
} | // include
//------------------------------------------
#include <algorithm>
#include <bits/stdc++.h>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define fore(i, a) for (auto &i : a)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
// clear memory
#define CLR(a) memset((a), 0, sizeof(a))
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
}
int main() {
long long r;
cin >> r;
long long A = 3 * r * r;
cout << A;
} | [
"call.remove",
"call.arguments.change",
"expression.operation.binary.change"
] | 772,413 | 772,414 | u266763028 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define priq priority_queue<int>
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (int)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (int)(key)))
#define tii tuple<int, int, int>
signed main() {
int N;
cin >> N;
int ans = N * N * N * 3;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, n) for (int i = (int)(j); i < (int)(n); i++)
#define REP(i, j, n) for (int i = (int)(j); i <= (int)(n); i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(), (a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int, int>
#define priq priority_queue<int>
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (int)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (int)(key)))
#define tii tuple<int, int, int>
signed main() {
int N;
cin >> N;
int ans = N * N * 3;
cout << ans << endl;
}
| [
"expression.operation.binary.remove"
] | 772,441 | 772,442 | u347057617 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, long long>
#define double long double
#define INF 1e10
#define MOD 1e9 + 7
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;
}
using Graph = vector<vector<int>>;
signed main() {
int a;
cout << 3 * a * a;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define rep2(i, n) for (int i = 0; i <= n; i++)
#define repr(i, a, n) for (int i = a; i < n; i++)
#define all(a) a.begin(), a.end()
#define P pair<long long, long long>
#define double long double
#define INF 1e10
#define MOD 1e9 + 7
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;
}
using Graph = vector<vector<int>>;
signed main() {
int a;
cin >> a;
cout << 3 * a * a;
} | [] | 772,443 | 772,444 | u341447450 | cpp |
p02969 | #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 4 * r * r;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r;
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 772,445 | 772,446 | u641500793 | cpp |
p02969 | #include <bits/stdc++.h>
#define rep(var, cnt) for (int(var) = 0; (var) < (int)(cnt); ++(var))
#define Rep(var, init, cnt) for (int(var) = (init); (var) < (int)(cnt); ++(var))
#define REP(var, init, cnt) \
for (int(var) = (init); (var) <= (int)(cnt); ++(var))
#define ran(var, vec) for (auto &(var) : (vec))
#define bet(min, var, max) (min) <= (var) && (var) <= (max)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define SORT(v) sort(all(v))
#define RSORT(v) sort(rall(v))
#define SUM(v) accumulate(all(v), 0)
#define tget(tp, idx) get<idx>(tp)
#define TF(flag) ((flag) ? 1 : 0)
#define YN(flag) cout << (flag ? "YES" : "NO") << endl;
#define Yn(flag) cout << (flag ? "Yes" : "No") << endl;
#define yn(flag) cout << (flag ? "yes" : "no") << endl;
#define Cout(v) cout << (v)
#define COUT(v) cout << (v) << endl
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using ti = tuple<int, int, int>;
using tl = tuple<ll, ll, ll>;
template <typename T> using vec = vector<T>;
template <typename T> using mat = vector<vec<T>>;
template <typename T> using cub = vector<mat<T>>;
template <typename T> using val = valarray<T>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using rpq = priority_queue<T, vec<T>, greater<T>>;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << " ";
}
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const valarray<T> &v) {
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << " ";
}
return os;
}
template <typename T> istream &operator>>(istream &is, valarray<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
} else {
return false;
}
};
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
} else {
return false;
}
};
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; }
};
// Usual Template End ===================
// Template End =========================
constexpr int MOD = 1e9 + 7;
using mint = ModInt<MOD>;
locale LOCATE = locale::classic();
int main(void) {
int r;
Cout(3 * r * r);
}
| #include <bits/stdc++.h>
#define rep(var, cnt) for (int(var) = 0; (var) < (int)(cnt); ++(var))
#define Rep(var, init, cnt) for (int(var) = (init); (var) < (int)(cnt); ++(var))
#define REP(var, init, cnt) \
for (int(var) = (init); (var) <= (int)(cnt); ++(var))
#define ran(var, vec) for (auto &(var) : (vec))
#define bet(min, var, max) (min) <= (var) && (var) <= (max)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define SORT(v) sort(all(v))
#define RSORT(v) sort(rall(v))
#define SUM(v) accumulate(all(v), 0)
#define tget(tp, idx) get<idx>(tp)
#define TF(flag) ((flag) ? 1 : 0)
#define YN(flag) cout << (flag ? "YES" : "NO") << endl;
#define Yn(flag) cout << (flag ? "Yes" : "No") << endl;
#define yn(flag) cout << (flag ? "yes" : "no") << endl;
#define Cout(v) cout << (v)
#define COUT(v) cout << (v) << endl
using namespace std;
using ll = long long;
using ull = unsigned long long;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using ti = tuple<int, int, int>;
using tl = tuple<ll, ll, ll>;
template <typename T> using vec = vector<T>;
template <typename T> using mat = vector<vec<T>>;
template <typename T> using cub = vector<mat<T>>;
template <typename T> using val = valarray<T>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using rpq = priority_queue<T, vec<T>, greater<T>>;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << " ";
}
return os;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const valarray<T> &v) {
for (int i = 0; i < (int)v.size(); ++i) {
os << v[i] << " ";
}
return os;
}
template <typename T> istream &operator>>(istream &is, valarray<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
} else {
return false;
}
};
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
} else {
return false;
}
};
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; }
};
// Usual Template End ===================
// Template End =========================
constexpr int MOD = 1e9 + 7;
using mint = ModInt<MOD>;
locale LOCATE = locale::classic();
int main(void) {
int r;
cin >> r;
Cout(3 * r * r);
}
| [] | 772,447 | 772,448 | u143572112 | cpp |
p02969 | #include <iostream>
#include <string>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * 4 * 4 << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
} | [
"identifier.replace.add",
"literal.replace.remove",
"io.output.change"
] | 772,449 | 772,450 | u542474460 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int r;
cin >> r;
cout << 4 * r * r << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
}
| [
"literal.number.change",
"io.output.change"
] | 772,451 | 772,452 | u417563928 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * pow(r, 3);
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * pow(r, 2);
} | [
"literal.number.change",
"io.output.change"
] | 772,462 | 772,463 | u901813121 | cpp |
p02969 | #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * (r * r * r);
} | #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * (r * r);
} | [
"expression.operation.binary.remove"
] | 772,479 | 772,480 | u904019018 | cpp |
p02969 | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
int main() {
int a;
cout << 3 * a * a;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
int main() {
int a;
cin >> a;
cout << 3 * a * a;
}
| [] | 772,485 | 772,486 | u154833883 | cpp |
p02969 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
int r;
cout << 3 * r * r << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
} | [] | 772,494 | 772,495 | u108484707 | cpp |
p02969 | #include <stdio.h>
int main() {
int a = 0;
scanf("%d", &a);
printf("%d", 3 * a * a * a);
}
| #include <stdio.h>
int main() {
int a = 0;
scanf("%d", &a);
printf("%d", 3 * a * a);
}
| [
"expression.operation.binary.remove"
] | 772,511 | 772,512 | u505466816 | cpp |
p02969 | #include <stdio.h>
int main() {
int a = 0;
scanf("%d", &a);
printf("%d", a * a * a);
}
| #include <stdio.h>
int main() {
int a = 0;
scanf("%d", &a);
printf("%d", 3 * a * a);
}
| [
"identifier.replace.remove",
"literal.replace.add",
"call.arguments.change",
"expression.operation.binary.change",
"io.output.change"
] | 772,513 | 772,512 | u505466816 | cpp |
p02969 | #include <bits/stdc++.h> //C++の標準ライブラリを一行で一括でインクルードする
#include <math.h> //数学関数と数学定数を利用する
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
int gcd(int a, int b) { //ユークリッドの互除法
if (a < b)
gcd(b, a); // aの方がbよりでかいのが前提
if (b == 0)
return a; // aをbで割り切れたらreturn
else
gcd(b, a % b);
}
int main() {
int r;
cin >> r;
cout << 3 * r * r * r << endl;
return 0;
} | #include <bits/stdc++.h> //C++の標準ライブラリを一行で一括でインクルードする
#include <math.h> //数学関数と数学定数を利用する
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
int gcd(int a, int b) { //ユークリッドの互除法
if (a < b)
gcd(b, a); // aの方がbよりでかいのが前提
if (b == 0)
return a; // aをbで割り切れたらreturn
else
gcd(b, a % b);
}
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
return 0;
}
| [
"expression.operation.binary.remove"
] | 772,514 | 772,515 | u014967455 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int a;
cin >> a;
cout << 3 * pow(a, 3) << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
cout << 3 * pow(a, 2) << endl;
} | [
"literal.number.change",
"io.output.change"
] | 772,521 | 772,522 | u770009793 | cpp |
p02969 | #include <iostream>
using namespace std;
int main() {
int n;
cout << 3 * n * n << endl;
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << 3 * n * n << endl;
return 0;
} | [] | 772,525 | 772,526 | u522506260 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vd = vector<double>;
using vc = vector<char>;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) x.begin(), x.end()
int main() {
int r;
cin >> r;
cout << r * r * r * 3 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vd = vector<double>;
using vc = vector<char>;
#define REP(i, x, n) for (int i = x; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) x.begin(), x.end()
int main() {
int r;
cin >> r;
cout << r * r * 3 << endl;
}
| [
"expression.operation.binary.remove"
] | 772,527 | 772,528 | u688825490 | cpp |
p02969 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << 4 * n * n;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << 3 * n * n;
return 0;
} | [
"literal.number.change",
"io.output.change"
] | 772,535 | 772,536 | u391340825 | cpp |
p02969 | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define REP(i, x) for (int i{0}; i < (int)(x); i++)
#define REPC(i, x) for (int i{0}; i <= (int)(x); i++)
#define RREP(i, x) for (int i{(int)(x)-1}; i >= 0; i--)
#define RREPC(i, x) for (int i{(int)(x)}; i >= 0; i--)
#define REP1O(i, x) for (int i{1}; i < (int)(x); i++)
#define REP1C(i, x) for (int i{1}; i <= (int)(x); i++)
#define REPIT(i, x) for (auto i{(x).begin()}; i != (x).end(); i++)
#define PB push_back
#define MP make_pair
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef int64_t ll;
typedef double dbl;
typedef vector<bool> Vb;
typedef vector<char> Vc;
typedef vector<double> Vd;
typedef vector<int> Vi;
typedef vector<ll> Vl;
typedef vector<string> Vs;
typedef vector<vector<int>> VVi;
typedef vector<vector<ll>> VVl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
inline void swap(ll &a, ll &b) {
a ^= b;
b ^= a;
a ^= b;
}
inline void swap(int &a, int &b) {
a ^= b;
b ^= a;
a ^= b;
}
inline void YES() { cout << "YES" << endl; }
inline void Yes() { cout << "Yes" << endl; }
inline void NO() { cout << "NO" << endl; }
inline void No() { cout << "No" << endl; }
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const int MOD = 1000000007;
int main() {
int r;
cout << 3 * r * r << endl;
}
| #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
#define REP(i, x) for (int i{0}; i < (int)(x); i++)
#define REPC(i, x) for (int i{0}; i <= (int)(x); i++)
#define RREP(i, x) for (int i{(int)(x)-1}; i >= 0; i--)
#define RREPC(i, x) for (int i{(int)(x)}; i >= 0; i--)
#define REP1O(i, x) for (int i{1}; i < (int)(x); i++)
#define REP1C(i, x) for (int i{1}; i <= (int)(x); i++)
#define REPIT(i, x) for (auto i{(x).begin()}; i != (x).end(); i++)
#define PB push_back
#define MP make_pair
#define SZ(x) ((int)(x).size())
#define ALL(x) (x).begin(), (x).end()
using namespace std;
typedef int64_t ll;
typedef double dbl;
typedef vector<bool> Vb;
typedef vector<char> Vc;
typedef vector<double> Vd;
typedef vector<int> Vi;
typedef vector<ll> Vl;
typedef vector<string> Vs;
typedef vector<vector<int>> VVi;
typedef vector<vector<ll>> VVl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
template <class T> inline bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
inline void swap(ll &a, ll &b) {
a ^= b;
b ^= a;
a ^= b;
}
inline void swap(int &a, int &b) {
a ^= b;
b ^= a;
a ^= b;
}
inline void YES() { cout << "YES" << endl; }
inline void Yes() { cout << "Yes" << endl; }
inline void NO() { cout << "NO" << endl; }
inline void No() { cout << "No" << endl; }
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const int MOD = 1000000007;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
}
| [] | 772,537 | 772,538 | u815659544 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int r;
cout << 3 * r * r << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
}
| [] | 772,548 | 772,549 | u610579155 | cpp |
p02969 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int r;
cin >> r;
int ans = 0;
ans = 3 * 3 * r;
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;
int main() {
int r;
cin >> r;
int ans = 0;
ans = 3 * r * r;
cout << ans << endl;
return 0;
}
| [
"assignment.value.change",
"identifier.replace.add",
"literal.replace.remove",
"expression.operation.binary.change"
] | 772,550 | 772,551 | u625522718 | cpp |
p02969 | #include "bits/stdc++.h"
using namespace std;
int main() {
cin.tie();
ios_base::sync_with_stdio(0);
int r;
cin >> r;
cout << 3 * r * r * r;
}
| #include "bits/stdc++.h"
using namespace std;
int main() {
cin.tie();
ios_base::sync_with_stdio(0);
int r;
cin >> r;
cout << 3 * r * r;
}
| [
"expression.operation.binary.remove"
] | 772,559 | 772,560 | u022827845 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int r;
cin >> r;
cout << 3 * r * r * r;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int r;
cin >> r;
cout << 3 * r * r;
return 0;
}
| [
"expression.operation.binary.remove"
] | 772,572 | 772,573 | u891061025 | cpp |
p02969 | #include <iostream>
#include <string>
using namespace std;
int main() {
int a;
int b = 0;
b = 3 * a * a;
cout << b << endl;
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int a;
int b = 0;
cin >> a;
b = 3 * a * a;
cout << b << endl;
}
| [] | 772,585 | 772,586 | u479202791 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r * r << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
} | [
"expression.operation.binary.remove"
] | 772,596 | 772,597 | u677149659 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define sz(x) ((int)(x).size())
#define whole(x) (x).begin(), (x).end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int N = int(2e5) + 2;
const int LG = 20;
const ll mod = (int)1e9 + 7;
const int INF = (int)1e9 + 7;
const ll linf = 1e18;
const ld pi = acos(-1);
const int base = 10;
const ld EPS = 1e-9;
int a;
int main() {
scanf("%d", &a);
printf("%d\n", 3 * (a * a * a));
} | #include <bits/stdc++.h>
using namespace std;
#define mp make_pair
#define fi first
#define se second
#define pb push_back
#define sz(x) ((int)(x).size())
#define whole(x) (x).begin(), (x).end()
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int N = int(2e5) + 2;
const int LG = 20;
const ll mod = (int)1e9 + 7;
const int INF = (int)1e9 + 7;
const ll linf = 1e18;
const ld pi = acos(-1);
const int base = 10;
const ld EPS = 1e-9;
int a;
int main() {
scanf("%d", &a);
printf("%d\n", 3 * (a * a));
} | [
"expression.operation.binary.remove"
] | 772,612 | 772,613 | u829956284 | cpp |
p02969 | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 999999999999
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef vector<llong> LV;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
int main() {
int r;
cin >> r;
cout << 3 * pow(r, 3) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define FORR(i, m, n) for (int i = m; i >= n; i--)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define llong long long
#define pb(a) push_back(a)
#define INF 999999999999
#define MOD 1000000007
using namespace std;
typedef pair<int, int> P;
typedef pair<llong, llong> LP;
typedef pair<int, P> PP;
typedef pair<llong, LP> LPP;
typedef vector<llong> LV;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
int main() {
int r;
cin >> r;
cout << 3 * pow(r, 2) << endl;
return 0;
}
| [
"literal.number.change",
"io.output.change"
] | 772,614 | 772,615 | u186359321 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << r * r * 2 << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int r;
cin >> r;
cout << r * r * 3 << endl;
} | [
"literal.number.change",
"io.output.change"
] | 772,616 | 772,617 | u932319885 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cout << 3 * a * a << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
cout << 3 * a * a << endl;
}
| [] | 772,624 | 772,625 | u018807058 | cpp |
p02969 | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
int main() {
int r;
cin >> r;
cout << 3 * (r ^ 2) << endl;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, N) for (int(i) = 0; (i) < (N); (i)++)
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
} | [] | 772,626 | 772,627 | u091665287 | cpp |
p02969 | #include <bits/stdc++.h>
#include <cmath>
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define SUBL \
freopen("/home/ajinkya/Desktop/input.txt", "r", stdin); \
freopen("/home/ajinkya/Desktop/output.txt", "w", stdout);
#define ll long long
#define ull unsigned long long
#define FI(i, a, n) for (int i = a; i <= n; i++)
#define RFI(i, n, a) for (int i = n; i >= a; i--)
#define FLL(i, a, n) for (ll i = a; i <= n; i++)
#define RFLL(i, n, a) for (ll i = n; i >= a; i--)
#define vi vector<int>
#define vll vector<ll>
#define all(v) v.begin(), v.end()
#define pll pair<ll, ll>
#define pi pair<int, int>
#define GCD(a, b) __gcd(a, b)
#define MP make_pair
#define PB push_back
#define PF push_front
#define LB lower_bound
#define UB upper_bound
#define debug(x) cout << x << endl
#define MOD 1000000007
#define INF LLONG_MAX
#define PI 3.14159265359
using namespace std;
int main() {
fastio SUBL ll a;
cin >> a;
cout << 3 * a * a;
return 0;
} | #include <bits/stdc++.h>
#include <cmath>
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define SUBL \
freopen("/home/ajinkya/Desktop/input.txt", "r", stdin); \
freopen("/home/ajinkya/Desktop/output.txt", "w", stdout);
#define ll long long
#define ull unsigned long long
#define FI(i, a, n) for (int i = a; i <= n; i++)
#define RFI(i, n, a) for (int i = n; i >= a; i--)
#define FLL(i, a, n) for (ll i = a; i <= n; i++)
#define RFLL(i, n, a) for (ll i = n; i >= a; i--)
#define vi vector<int>
#define vll vector<ll>
#define all(v) v.begin(), v.end()
#define pll pair<ll, ll>
#define pi pair<int, int>
#define GCD(a, b) __gcd(a, b)
#define MP make_pair
#define PB push_back
#define PF push_front
#define LB lower_bound
#define UB upper_bound
#define debug(x) cout << x << endl
#define MOD 1000000007
#define INF LLONG_MAX
#define PI 3.14159265359
using namespace std;
int main() {
fastio
// SUBL
ll a;
cin >> a;
cout << 3 * a * a;
return 0;
} | [] | 772,639 | 772,640 | u851831516 | cpp |
p02969 | #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 4 * r * r << endl;
} | #include <iostream>
using namespace std;
int main() {
int r;
cin >> r;
cout << 3 * r * r << endl;
} | [
"literal.number.change",
"io.output.change"
] | 772,645 | 772,646 | u981388291 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A;
cout << 4 * A * A;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A;
cout << 3 * A * A;
}
| [
"literal.number.change",
"io.output.change"
] | 772,649 | 772,650 | u383166010 | cpp |
p02969 | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << 2 * (n * n);
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
cin >> n;
cout << 3 * (n * n);
} | [
"literal.number.change",
"io.output.change"
] | 772,651 | 772,652 | u488087935 | cpp |
p02969 | /*
1. I'm the Future Red Coder :)
2. Hopefully, I'll be Yellow Soon.
*/
#include <bits/stdc++.h>
#define mod 998244353 // 1000000007
#define lim 1000000000000000007
#define lim1 18446744073709551615 // Unsigned
#define sq(a) ((a) * (a))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define mms(v, i) memset(v, i, sizeof(v))
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define REPN(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> PL;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<int, pair<int, int>> pii;
ll power(ll a, ll b, ll m = mod) {
if (b == 0)
return 1;
ll c = power(a, b >> 1, m);
c = (c * c) % m;
if (b & 1)
return (c * a) % m;
return c;
}
ll gcdll(ll a, ll b) {
if (b == 0)
return a;
return gcdll(b, a % b);
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*struct node {
int l,r,nq;
};
bool compare(const node& a,const node& b) {
if (a.r != b.r) return a.r<b.r;
return a.l<b.l;
}*/
/* ******* DSU START ****** */
/*
const int dsusize = (int)1e5+5;
struct node {
int data;
int rk,pn;
}dsu[dsusize];
//ll fans;
void initialize(int n) {
REP(i,1,n) {
dsu[i].data = 1;
dsu[i].rk = 0;
dsu[i].pn = i;
}
}
int fnd(int i) {
if (dsu[i].pn != i) dsu[i].pn = fnd(dsu[i].pn);
return dsu[i].pn;
}
void unn(int i,int j) {
i = fnd(i);
j = fnd(j);
if (i!=j) {
//fans -= dsu[i].data*dsu[j].data;
if (dsu[i].rk>dsu[j].rk) {
dsu[j].pn = i;
dsu[i].data += dsu[j].data;
}
else {
dsu[i].pn = j;
dsu[j].data += dsu[i].data;
if (dsu[i].rk==dsu[j].rk) {
dsu[j].rk++;
}
}
}
}
*/
/* ******* DSU END****** */
const int N = (int)2e5 + 5;
const int Q = 250;
void solve() {
int r;
cin >> r;
cout << (3 * r * r);
}
int main() {
// freopen("class_treasurer.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
cin >> T;
REP(TC, 1, T) {
// cout<<"Case #"<<TC<<": ";
solve();
cout << "\n";
}
}
| /*
1. I'm the Future Red Coder :)
2. Hopefully, I'll be Yellow Soon.
*/
#include <bits/stdc++.h>
#define mod 998244353 // 1000000007
#define lim 1000000000000000007
#define lim1 18446744073709551615 // Unsigned
#define sq(a) ((a) * (a))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define mms(v, i) memset(v, i, sizeof(v))
#define pb push_back
#define pf push_front
#define ppb pop_back
#define ppf pop_front
#define REP(i, a, b) for (int i = a; i <= b; i++)
#define REPN(i, a, b) for (int i = a; i >= b; i--)
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> PL;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<int, pair<int, int>> pii;
ll power(ll a, ll b, ll m = mod) {
if (b == 0)
return 1;
ll c = power(a, b >> 1, m);
c = (c * c) % m;
if (b & 1)
return (c * a) % m;
return c;
}
ll gcdll(ll a, ll b) {
if (b == 0)
return a;
return gcdll(b, a % b);
}
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
/*struct node {
int l,r,nq;
};
bool compare(const node& a,const node& b) {
if (a.r != b.r) return a.r<b.r;
return a.l<b.l;
}*/
/* ******* DSU START ****** */
/*
const int dsusize = (int)1e5+5;
struct node {
int data;
int rk,pn;
}dsu[dsusize];
//ll fans;
void initialize(int n) {
REP(i,1,n) {
dsu[i].data = 1;
dsu[i].rk = 0;
dsu[i].pn = i;
}
}
int fnd(int i) {
if (dsu[i].pn != i) dsu[i].pn = fnd(dsu[i].pn);
return dsu[i].pn;
}
void unn(int i,int j) {
i = fnd(i);
j = fnd(j);
if (i!=j) {
//fans -= dsu[i].data*dsu[j].data;
if (dsu[i].rk>dsu[j].rk) {
dsu[j].pn = i;
dsu[i].data += dsu[j].data;
}
else {
dsu[i].pn = j;
dsu[j].data += dsu[i].data;
if (dsu[i].rk==dsu[j].rk) {
dsu[j].rk++;
}
}
}
}
*/
/* ******* DSU END****** */
const int N = (int)2e5 + 5;
const int Q = 250;
void solve() {
int r;
cin >> r;
cout << (3 * r * r);
}
int main() {
// freopen("class_treasurer.txt","r",stdin);
// freopen("output.txt","w",stdout);
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
// cin>>T;
REP(TC, 1, T) {
// cout<<"Case #"<<TC<<": ";
solve();
cout << "\n";
}
}
| [] | 772,673 | 772,674 | u921940646 | cpp |
p02969 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cout << (3 * n * n) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (3 * n * n) << endl;
return 0;
}
| [] | 772,699 | 772,700 | u379904287 | cpp |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.