結果
| 問題 | No.1685 One by One |
| ユーザー |
 NyaanNyaan
|
| 提出日時 | 2021-09-17 22:52:25 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 483 ms / 3,000 ms |
| コード長 | 21,341 bytes |
| コンパイル時間 | 2,798 ms |
| コンパイル使用メモリ | 267,440 KB |
| 実行使用メモリ | 66,944 KB |
| 最終ジャッジ日時 | 2024-06-29 21:39:49 |
| 合計ジャッジ時間 | 12,158 ms |
|
ジャッジサーバーID （参考情報） |
judge3 / judge4 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 77 ms
66,816 KB |
| testcase_01 | AC | 76 ms
66,688 KB |
| testcase_02 | AC | 78 ms
66,688 KB |
| testcase_03 | AC | 95 ms
66,688 KB |
| testcase_04 | AC | 86 ms
66,944 KB |
| testcase_05 | AC | 254 ms
66,688 KB |
| testcase_06 | AC | 114 ms
66,772 KB |
| testcase_07 | AC | 174 ms
66,688 KB |
| testcase_08 | AC | 80 ms
66,688 KB |
| testcase_09 | AC | 87 ms
66,680 KB |
| testcase_10 | AC | 181 ms
66,816 KB |
| testcase_11 | AC | 83 ms
66,816 KB |
| testcase_12 | AC | 80 ms
66,768 KB |
| testcase_13 | AC | 197 ms
66,816 KB |
| testcase_14 | AC | 83 ms
66,688 KB |
| testcase_15 | AC | 307 ms
66,796 KB |
| testcase_16 | AC | 84 ms
66,816 KB |
| testcase_17 | AC | 85 ms
66,800 KB |
| testcase_18 | AC | 82 ms
66,904 KB |
| testcase_19 | AC | 80 ms
66,780 KB |
| testcase_20 | AC | 79 ms
66,816 KB |
| testcase_21 | AC | 77 ms
66,772 KB |
| testcase_22 | AC | 81 ms
66,816 KB |
| testcase_23 | AC | 96 ms
66,688 KB |
| testcase_24 | AC | 246 ms
66,688 KB |
| testcase_25 | AC | 408 ms
66,816 KB |
| testcase_26 | AC | 212 ms
66,688 KB |
| testcase_27 | AC | 427 ms
66,688 KB |
| testcase_28 | AC | 319 ms
66,696 KB |
| testcase_29 | AC | 480 ms
66,688 KB |
| testcase_30 | AC | 217 ms
66,688 KB |
| testcase_31 | AC | 483 ms
66,688 KB |
| testcase_32 | AC | 474 ms
66,688 KB |
| testcase_33 | AC | 480 ms
66,688 KB |
| testcase_34 | AC | 76 ms
66,816 KB |
| testcase_35 | AC | 78 ms
66,816 KB |
| testcase_36 | AC | 77 ms
66,816 KB |
| testcase_37 | AC | 77 ms
66,816 KB |
| testcase_38 | AC | 77 ms
66,688 KB |
| testcase_39 | AC | 76 ms
66,688 KB |
| testcase_40 | AC | 76 ms
66,764 KB |
| testcase_41 | AC | 75 ms
66,812 KB |
| testcase_42 | AC | 76 ms
66,816 KB |
| testcase_43 | AC | 75 ms
66,768 KB |
| testcase_44 | AC | 77 ms
66,688 KB |
| testcase_45 | AC | 77 ms
66,688 KB |
| testcase_46 | AC | 147 ms
66,688 KB |
| testcase_47 | AC | 174 ms
66,796 KB |
| testcase_48 | AC | 115 ms
66,688 KB |
| testcase_49 | AC | 178 ms
66,688 KB |
ソースコード
/**
* date : 2021-09-17 22:52:21
*/
#define NDEBUG
// HELP !!
using namespace std;
// intrinstic
#include <immintrin.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfenv>
#include <cfloat>
#include <chrono>
#include <cinttypes>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <tuple>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// utility
namespace Nyaan {
using ll = long long;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
template <typename T>
using V = vector<T>;
template <typename T>
using VV = vector<vector<T>>;
using vi = vector<int>;
using vl = vector<long long>;
using vd = V<double>;
using vs = V<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<long long>>;
template <typename T, typename U>
struct P : pair<T, U> {
template <typename... Args>
P(Args... args) : pair<T, U>(args...) {}
using pair<T, U>::first;
using pair<T, U>::second;
T &x() { return first; }
const T &x() const { return first; }
U &y() { return second; }
const U &y() const { return second; }
P &operator+=(const P &r) {
first += r.first;
second += r.second;
return *this;
}
P &operator-=(const P &r) {
first -= r.first;
second -= r.second;
return *this;
}
P &operator*=(const P &r) {
first *= r.first;
second *= r.second;
return *this;
}
P operator+(const P &r) const { return P(*this) += r; }
P operator-(const P &r) const { return P(*this) -= r; }
P operator*(const P &r) const { return P(*this) *= r; }
};
using pl = P<ll, ll>;
using pi = P<int, int>;
using vp = V<pl>;
constexpr int inf = 1001001001;
constexpr long long infLL = 4004004004004004004LL;
template <typename T>
int sz(const T &t) {
return t.size();
}
template <typename T, typename U>
inline bool amin(T &x, U y) {
return (y < x) ? (x = y, true) : false;
}
template <typename T, typename U>
inline bool amax(T &x, U y) {
return (x < y) ? (x = y, true) : false;
}
template <typename T>
inline T Max(const vector<T> &v) {
return *max_element(begin(v), end(v));
}
template <typename T>
inline T Min(const vector<T> &v) {
return *min_element(begin(v), end(v));
}
template <typename T>
inline long long Sum(const vector<T> &v) {
return accumulate(begin(v), end(v), 0LL);
}
template <typename T>
int lb(const vector<T> &v, const T &a) {
return lower_bound(begin(v), end(v), a) - begin(v);
}
template <typename T>
int ub(const vector<T> &v, const T &a) {
return upper_bound(begin(v), end(v), a) - begin(v);
}
constexpr long long TEN(int n) {
long long ret = 1, x = 10;
for (; n; x *= x, n >>= 1) ret *= (n & 1 ? x : 1);
return ret;
}
template <typename T, typename U>
pair<T, U> mkp(const T &t, const U &u) {
return make_pair(t, u);
}
template <typename T>
vector<T> mkrui(const vector<T> &v, bool rev = false) {
vector<T> ret(v.size() + 1);
if (rev) {
for (int i = int(v.size()) - 1; i >= 0; i--) ret[i] = v[i] + ret[i + 1];
} else {
for (int i = 0; i < int(v.size()); i++) ret[i + 1] = ret[i] + v[i];
}
return ret;
};
template <typename T>
vector<T> mkuni(const vector<T> &v) {
vector<T> ret(v);
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
template <typename F>
vector<int> mkord(int N, F f) {
vector<int> ord(N);
iota(begin(ord), end(ord), 0);
sort(begin(ord), end(ord), f);
return ord;
}
template <typename T>
vector<int> mkinv(vector<T> &v) {
int max_val = *max_element(begin(v), end(v));
vector<int> inv(max_val + 1, -1);
for (int i = 0; i < (int)v.size(); i++) inv[v[i]] = i;
return inv;
}
} // namespace Nyaan
// bit operation
namespace Nyaan {
__attribute__((target("popcnt"))) inline int popcnt(const u64 &a) {
return _mm_popcnt_u64(a);
}
inline int lsb(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int ctz(const u64 &a) { return a ? __builtin_ctzll(a) : 64; }
inline int msb(const u64 &a) { return a ? 63 - __builtin_clzll(a) : -1; }
template <typename T>
inline int gbit(const T &a, int i) {
return (a >> i) & 1;
}
template <typename T>
inline void sbit(T &a, int i, bool b) {
if (gbit(a, i) != b) a ^= T(1) << i;
}
constexpr long long PW(int n) { return 1LL << n; }
constexpr long long MSK(int n) { return (1LL << n) - 1; }
} // namespace Nyaan
// inout
namespace Nyaan {
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename T, typename U>
istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
int s = (int)v.size();
for (int i = 0; i < s; i++) os << (i ? " " : "") << v[i];
return os;
}
template <typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
void in() {}
template <typename T, class... U>
void in(T &t, U &... u) {
cin >> t;
in(u...);
}
void out() { cout << "\n"; }
template <typename T, class... U, char sep = ' '>
void out(const T &t, const U &... u) {
cout << t;
if (sizeof...(u)) cout << sep;
out(u...);
}
void outr() {}
template <typename T, class... U, char sep = ' '>
void outr(const T &t, const U &... u) {
cout << t;
outr(u...);
}
struct IoSetupNya {
IoSetupNya() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
cerr << fixed << setprecision(7);
}
} iosetupnya;
} // namespace Nyaan
// debug
namespace DebugImpl {
template <typename U, typename = void>
struct is_specialize : false_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, typename U::iterator, void>::type>
: true_type {};
template <typename U>
struct is_specialize<
U, typename conditional<false, decltype(U::first), void>::type>
: true_type {};
template <typename U>
struct is_specialize<U, enable_if_t<is_integral<U>::value, void>> : true_type {
};
void dump(const char& t) { cerr << t; }
void dump(const string& t) { cerr << t; }
void dump(const bool& t) { cerr << (t ? "true" : "false"); }
template <typename U,
enable_if_t<!is_specialize<U>::value, nullptr_t> = nullptr>
void dump(const U& t) {
cerr << t;
}
template <typename T>
void dump(const T& t, enable_if_t<is_integral<T>::value>* = nullptr) {
string res;
if (t == Nyaan::inf) res = "inf";
if constexpr (is_signed<T>::value) {
if (t == -Nyaan::inf) res = "-inf";
}
if constexpr (sizeof(T) == 8) {
if (t == Nyaan::infLL) res = "inf";
if constexpr (is_signed<T>::value) {
if (t == -Nyaan::infLL) res = "-inf";
}
}
if (res.empty()) res = to_string(t);
cerr << res;
}
template <typename T, typename U>
void dump(const pair<T, U>&);
template <typename T>
void dump(const pair<T*, int>&);
template <typename T>
void dump(const T& t,
enable_if_t<!is_void<typename T::iterator>::value>* = nullptr) {
cerr << "[ ";
for (auto it = t.begin(); it != t.end();) {
dump(*it);
cerr << (++it == t.end() ? "" : ", ");
}
cerr << " ]";
}
template <typename T, typename U>
void dump(const pair<T, U>& t) {
cerr << "( ";
dump(t.first);
cerr << ", ";
dump(t.second);
cerr << " )";
}
template <typename T>
void dump(const pair<T*, int>& t) {
cerr << "[ ";
for (int i = 0; i < t.second; i++) {
dump(t.first[i]);
cerr << (i == t.second - 1 ? "" : ", ");
}
cerr << " ]";
}
void trace() { cerr << endl; }
template <typename Head, typename... Tail>
void trace(Head&& head, Tail&&... tail) {
cerr << " ";
dump(head);
if (sizeof...(tail) != 0) cerr << ",";
trace(forward<Tail>(tail)...);
}
} // namespace DebugImpl
#ifdef NyaanDebug
#define trc(...) \
do { \
cerr << "## " << #__VA_ARGS__ << " = "; \
DebugImpl::trace(__VA_ARGS__); \
} while (0)
#else
#define trc(...) (void(0))
#endif
// macro
#define each(x, v) for (auto&& x : v)
#define each2(x, y, v) for (auto&& [x, y] : v)
#define all(v) (v).begin(), (v).end()
#define rep(i, N) for (long long i = 0; i < (long long)(N); i++)
#define repr(i, N) for (long long i = (long long)(N)-1; i >= 0; i--)
#define rep1(i, N) for (long long i = 1; i <= (long long)(N); i++)
#define repr1(i, N) for (long long i = (N); (long long)(i) > 0; i--)
#define reg(i, a, b) for (long long i = (a); i < (b); i++)
#define regr(i, a, b) for (long long i = (b)-1; i >= (a); i--)
#define fi first
#define se second
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
long long __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__)
#define in2(s, t) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i]); \
}
#define in3(s, t, u) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i]); \
}
#define in4(s, t, u, v) \
for (int i = 0; i < (int)s.size(); i++) { \
in(s[i], t[i], u[i], v[i]); \
}
#define die(...) \
do { \
Nyaan::out(__VA_ARGS__); \
return; \
} while (0)
namespace Nyaan {
void solve();
}
int main() { Nyaan::solve(); }
//
template <uint32_t mod>
struct LazyMontgomeryModInt {
using mint = LazyMontgomeryModInt;
using i32 = int32_t;
using u32 = uint32_t;
using u64 = uint64_t;
static constexpr u32 get_r() {
u32 ret = mod;
for (i32 i = 0; i < 4; ++i) ret *= 2 - mod * ret;
return ret;
}
static constexpr u32 r = get_r();
static constexpr u32 n2 = -u64(mod) % mod;
static_assert(r * mod == 1, "invalid, r * mod != 1");
static_assert(mod < (1 << 30), "invalid, mod >= 2 ^ 30");
static_assert((mod & 1) == 1, "invalid, mod % 2 == 0");
u32 a;
constexpr LazyMontgomeryModInt() : a(0) {}
constexpr LazyMontgomeryModInt(const int64_t &b)
: a(reduce(u64(b % mod + mod) * n2)){};
static constexpr u32 reduce(const u64 &b) {
return (b + u64(u32(b) * u32(-r)) * mod) >> 32;
}
constexpr mint &operator+=(const mint &b) {
if (i32(a += b.a - 2 * mod) < 0) a += 2 * mod;
return *this;
}
constexpr mint &operator-=(const mint &b) {
if (i32(a -= b.a) < 0) a += 2 * mod;
return *this;
}
constexpr mint &operator*=(const mint &b) {
a = reduce(u64(a) * b.a);
return *this;
}
constexpr mint &operator/=(const mint &b) {
*this *= b.inverse();
return *this;
}
constexpr mint operator+(const mint &b) const { return mint(*this) += b; }
constexpr mint operator-(const mint &b) const { return mint(*this) -= b; }
constexpr mint operator*(const mint &b) const { return mint(*this) *= b; }
constexpr mint operator/(const mint &b) const { return mint(*this) /= b; }
constexpr bool operator==(const mint &b) const {
return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
}
constexpr bool operator!=(const mint &b) const {
return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
}
constexpr mint operator-() const { return mint() - mint(*this); }
constexpr mint pow(u64 n) const {
mint ret(1), mul(*this);
while (n > 0) {
if (n & 1) ret *= mul;
mul *= mul;
n >>= 1;
}
return ret;
}
constexpr mint inverse() const { return pow(mod - 2); }
friend ostream &operator<<(ostream &os, const mint &b) {
return os << b.get();
}
friend istream &operator>>(istream &is, mint &b) {
int64_t t;
is >> t;
b = LazyMontgomeryModInt<mod>(t);
return (is);
}
constexpr u32 get() const {
u32 ret = reduce(a);
return ret >= mod ? ret - mod : ret;
}
static constexpr u32 get_mod() { return mod; }
};
template <typename T>
struct Binomial {
vector<T> f, g, h;
Binomial(int MAX = 0) : f(1, T(1)), g(1, T(1)), h(1, T(1)) {
while (MAX >= (int)f.size()) extend();
}
void extend() {
int n = f.size();
int m = n * 2;
f.resize(m);
g.resize(m);
h.resize(m);
for (int i = n; i < m; i++) f[i] = f[i - 1] * T(i);
g[m - 1] = f[m - 1].inverse();
h[m - 1] = g[m - 1] * f[m - 2];
for (int i = m - 2; i >= n; i--) {
g[i] = g[i + 1] * T(i + 1);
h[i] = g[i] * f[i - 1];
}
}
T fac(int i) {
if (i < 0) return T(0);
while (i >= (int)f.size()) extend();
return f[i];
}
T finv(int i) {
if (i < 0) return T(0);
while (i >= (int)g.size()) extend();
return g[i];
}
T inv(int i) {
if (i < 0) return -inv(-i);
while (i >= (int)h.size()) extend();
return h[i];
}
T C(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
return fac(n) * finv(n - r) * finv(r);
}
inline T operator()(int n, int r) { return C(n, r); }
template <typename I>
T multinomial(const vector<I>& r) {
static_assert(is_integral<I>::value == true);
int n = 0;
for (auto& x : r) {
if(x < 0) return T(0);
n += x;
}
T res = fac(n);
for (auto& x : r) res *= finv(x);
return res;
}
template <typename I>
T operator()(const vector<I>& r) {
return multinomial(r);
}
T C_naive(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
T ret = T(1);
r = min(r, n - r);
for (int i = 1; i <= r; ++i) ret *= inv(i) * (n--);
return ret;
}
T P(int n, int r) {
if (n < 0 || n < r || r < 0) return T(0);
return fac(n) * finv(n - r);
}
T H(int n, int r) {
if (n < 0 || r < 0) return T(0);
return r == 0 ? 1 : C(n + r - 1, r);
}
};
// Prime Sieve {2, 3, 5, 7, 11, 13, 17, ...}
vector<int> prime_enumerate(int N) {
vector<bool> sieve(N / 3 + 1, 1);
for (int p = 5, d = 4, i = 1, sqn = sqrt(N); p <= sqn; p += d = 6 - d, i++) {
if (!sieve[i]) continue;
for (int q = p * p / 3, r = d * p / 3 + (d * p % 3 == 2), s = 2 * p,
qe = sieve.size();
q < qe; q += r = s - r)
sieve[q] = 0;
}
vector<int> ret{2, 3};
for (int p = 5, d = 4, i = 1; p <= N; p += d = 6 - d, i++)
if (sieve[i]) ret.push_back(p);
while (!ret.empty() && ret.back() > N) ret.pop_back();
return ret;
}
struct divisor_transform {
template <typename T>
static void zeta_transform(vector<T> &a) {
int N = a.size() - 1;
auto sieve = prime_enumerate(N);
for (auto &p : sieve)
for (int k = 1; k * p <= N; ++k) a[k * p] += a[k];
}
template <typename T>
static void mobius_transform(T &a) {
int N = a.size() - 1;
auto sieve = prime_enumerate(N);
for (auto &p : sieve)
for (int k = N / p; k > 0; --k) a[k * p] -= a[k];
}
template <typename T>
static void zeta_transform(map<long long, T> &a) {
for (auto p = rbegin(a); p != rend(a); p++)
for (auto &x : a) {
if (p->first == x.first) break;
if (p->first % x.first == 0) p->second += x.second;
}
}
template <typename T>
static void mobius_transform(map<long long, T> &a) {
for (auto &x : a)
for (auto p = rbegin(a); p != rend(a); p++) {
if (x.first == p->first) break;
if (p->first % x.first == 0) p->second -= x.second;
}
}
};
struct multiple_transform {
template <typename T>
static void zeta_transform(vector<T> &a) {
int N = a.size() - 1;
auto sieve = prime_enumerate(N);
for (auto &p : sieve)
for (int k = N / p; k > 0; --k) a[k] += a[k * p];
}
template <typename T>
static void mobius_transform(vector<T> &a) {
int N = a.size() - 1;
auto sieve = prime_enumerate(N);
for (auto &p : sieve)
for (int k = 1; k * p <= N; ++k) a[k] -= a[k * p];
}
template <typename T>
static void zeta_transform(map<long long, T> &a) {
for (auto &x : a)
for (auto p = rbegin(a); p->first != x.first; p++)
if (p->first % x.first == 0) x.second += p->second;
}
template <typename T>
static void mobius_transform(map<long long, T> &a) {
for (auto p1 = rbegin(a); p1 != rend(a); p1++)
for (auto p2 = rbegin(a); p2 != p1; p2++)
if (p2->first % p1->first == 0) p1->second -= p2->second;
}
};
/**
* @brief 倍数変換・約数変換
* @docs docs/multiplicative-function/divisor-multiple-transform.md
*/
//
using namespace Nyaan;
// using mint = LazyMontgomeryModInt<998244353>;
using mint = LazyMontgomeryModInt<1000000007>;
using vm = vector<mint>;
using vvm = vector<vm>;
Binomial<mint> C;
using namespace Nyaan;
mint rui[4040][4040];
mint pw[4040];
void Nyaan::solve() {
for (int i = 0; i <= 4010; i++) {
rui[i][0] = C(i, 0);
for (int j = 1; j <= 4010; j++) {
rui[i][j] = rui[i][j - 1] + C(i, j);
}
}
pw[0] = 1;
rep1(i, 4010) pw[i] = pw[i - 1] * 2;
inl(N, M);
// N - 1 間 使わないとすると？
// (全体 -1/+1 で調整)
// 微調整 考察すべし
// 偶数 -> 偶奇弄れないのでオーケー
// 奇数
// N-1個決める + 0 を全体 -1/+1すると
// ++++0---- 的なのが最小
// かつ ++++0---- が存在する時 1ずらせば 回数 1回増やせる
// いやこれ嘘だな +++000--- の場合がある
// polya やるべきなんじゃないか？
// 長さLの列 +の個数 floor(L/2)個以下 絶対値の和m f(L,m)とおく
// g(L,m) : 反復を許さないバーゾｙン
// L=2のとき -> f(L,m)=g(L/2,m/2)+g(L,m) 的な -> オーケー
// 1,2,...からなる 長さs 和t の列数え上げ
// -> binomやんけ t-s個のボールをs-1個の衝立で区切る... C(t-1,s-1)
// binomで上手いこと高速に解けるのを信じる
// +がi個 -がj個あるとする
// k:=max(i,j)とする
// -> ずらすと N-2k ずれる
// 絶対値の和をtとして t+N-2k <= M のときオーケー
// 0の個数を固定して考えると？
// 長さ L 非0がu個 sum v
// -> v-u個のボール u-1個の衝立 C(L,u) * C(v-1,u-1)
// ここからさらに L-u個に +/- をつけていく
mint ans = 0;
for (int t = 0; t <= M; t++) {
trc(t);
// uku
if (N % 2 == 0 && t % 2 != M % 2) continue;
vi ds;
int g = __gcd<int>(t, N);
for (int i = 1; i <= g; i++)
if (g % i == 0) ds.push_back(i);
map<long long, mint> mp;
for (auto& d : ds) {
// 長さL := N/d
int L = N / d;
// 和 v := t/d
int v = t / d;
// +/- は floor(L/2)個以下
// 正規形を吟味する必要がある
// L 奇数の場合 -> 中央が必ず0 とすれば 1通りに定まる
// L 偶数の場合 -> +++++0---- としよう！
int bu, bl;
if (L % 2 == 0) {
bu = L / 2;
bl = (L - 1) / 2;
} else {
bu = bl = L / 2;
}
// 長さ L 非0がu個 sum v
// -> v-u個のボール u-1個の衝立 C(L,u) * C(v-1,u-1)
// ここからさらに L-u個に +/- をつけていく
mint sm = 0;
for (int u = 0; u <= L; u++) {
if (u == 0 && v != 0) continue;
if (u > bl + bu) break;
mint cur = C(L, u) * C(v - 1, u - 1);
if (v == 0) cur = u == 0 ? 1 : 0;
// u個を2色に塗りわける / 各色はb個以下
// sum_{u-b <= i <= b} C(u,i)
// = 2^u - 2 * sum_{0 <= i < u-b} C(u,i)
mint cur2 = pw[u];
if (u - bu > 0) cur2 -= rui[u][u - bu - 1];
if (u - bl > 0) cur2 -= rui[u][u - bl - 1];
//trc(u, cur, cur2);
sm += cur * cur2;
}
trc(d, L, v, bu, bl, sm);
// t % 2 != M % 2 のとき -> 微調整
if (t % 2 != M % 2) {
// k := max(+の個数, -の個数)
// 絶対値の和をtとして t+N-2k <= M のときオーケー
// 2k >= t+N-M
// k >= (t + N - M + 1) / 2
// -> bu < k, bl < k の場合を引く
int k2 = t+N-M+1;
amin(bu, k2 / 2 - 1);
amin(bl, k2 / 2 - 1);
for (int u = 0; u <= L; u++) {
if (u == 0 && v != 0) continue;
if (u > bl + bu) break;
mint cur = C(L, u) * C(v - 1, u - 1);
if (v == 0) cur = u == 0 ? 1 : 0;
// u個を2色に塗りわける / 各色はb個以下
// sum_{u-b <= i <= b} C(u,i)
// = 2^u - 2 * sum_{0 <= i < u-b} C(u,i)
mint cur2 = pw[u];
if (u - bu > 0) cur2 -= rui[u][u - bu - 1];
if (u - bl > 0) cur2 -= rui[u][u - bl - 1];
sm -= cur * cur2;
}
}
trc(d, L, v, bu, bl, sm);
mp[d] = sm;
}
trc(mp);
multiple_transform::mobius_transform(mp);
trc(mp);
for (auto& [_, v] : mp) ans += v;
}
out(ans);
}