text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, k, q, inv[N], sum[N];
map<int, int> cnt;
void divide(int l, int r, int k) {
if (l == r || k <= 1) {
++cnt[r - l + 1];
return;
}
int mid = (l + r) >> 1;
divide(l, mid, k - 1);
divide(mid + 1, r, k - 1);
}
int ans;
int calc(int x, int y) {
int res = 1ll * x * y % q * inv[2] % q;
for (int i = 1; i <= x; ++i) res = (res - sum[i + y] + sum[i]) % q;
return res;
}
int main() {
scanf("%d %d %d", &n, &k, &q);
inv[1] = sum[1] = 1;
for (int i = 2; i < N; ++i)
inv[i] = 1ll * inv[q % i] * (q - q / i) % q,
sum[i] = (sum[i - 1] + inv[i]) % q;
divide(1, n, k);
for (auto i : cnt) {
int l = i.first, c = i.second;
ans += 1ll * l * (l - 1) % q * inv[4] % q * c % q;
ans %= q;
ans += 1ll * c * (c - 1) % q * inv[2] % q * calc(l, l) % q;
ans %= q;
}
for (auto i : cnt)
for (auto j : cnt) {
int x = i.first, y = j.first, nx = i.second, ny = j.second;
if (x >= y) continue;
ans += 1ll * nx * ny % q * calc(x, y) % q;
ans %= q;
}
printf("%d\n", (ans + q) % q);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2,Ofast,inline,unroll-all-loops,-ffast-math")
#pragma GCC target("popcnt")
using namespace std;
int n, k;
long long inv[100010], sum[100010], p, ans = 0;
map<int, int> M;
template <class T>
void read(T &x) {
char ch = x = 0;
bool fl = false;
while (!isdigit(ch)) fl |= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x = fl ? -x : x;
}
long long calc(int l, int r) { return (sum[r] - sum[l - 1] + p) % p; }
long long Calc(int A, int B) {
long long ret = 1LL * A * B % p * inv[2] % p;
for (int i = 1; i <= A; i++) {
ret = (ret - calc(i + 1, i + B) + p) % p;
}
return ret;
}
void solve(int l, int r, int h) {
if (h == 1 || l == r)
return ans = (ans + 1LL * (r - l + 1) * (r - l) % p * inv[4]) % p,
M[r - l + 1]++, void();
int mid = l + r >> 1;
solve(l, mid, h - 1), solve(mid + 1, r, h - 1);
}
void init() {
inv[1] = 1;
for (int i = 2; i < 100010; i++) {
inv[i] = (p - p / i) * inv[p % i] % p;
}
for (int i = 1; i < 100010; i++) {
sum[i] = (sum[i - 1] + inv[i]) % p;
}
}
int main() {
read(n), read(k), read(p), init();
solve(1, n, k);
for (auto &x : M) {
ans = (ans + Calc(x.first, x.first) * x.second % p * (x.second - 1) % p *
inv[2]) %
p;
for (auto &y : M) {
if (x.first < y.first)
ans = (ans + Calc(x.first, y.first) * x.second % p * y.second) % p;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int MOD;
struct modnum {
int v;
modnum() : v(0) {}
modnum(ll _v) : v(_v % MOD) {
if (v < 0) v += MOD;
}
explicit operator int() const { return v; }
friend ostream& operator<<(ostream& o, const modnum& n) { return o << n.v; }
friend istream& operator<<(istream& i, modnum& n) {
ll v;
i >> v;
n = modnum(v);
return i;
}
friend bool operator==(const modnum& a, const modnum& b) {
return a.v == b.v;
}
friend bool operator!=(const modnum& a, const modnum& b) {
return a.v != b.v;
}
modnum& operator+=(const modnum& o) {
v += o.v;
if (v >= MOD) v -= MOD;
return *this;
}
modnum& operator-=(const modnum& o) {
v -= o.v;
if (v < 0) v += MOD;
return *this;
}
modnum& operator*=(const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum operator-() {
modnum res;
if (v) res.v = MOD - v;
return res;
}
friend modnum operator+(const modnum& a, const modnum& b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum& a, const modnum& b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum& a, const modnum& b) {
return modnum(a) *= b;
}
modnum pow(int e) const {
if (e == 0) return 1;
if (e & 1) return *this * this->pow(e - 1);
return (*this * *this).pow(e / 2);
}
modnum& operator/=(const modnum& o) { return (*this) *= o.pow(MOD - 2); }
friend modnum operator/(const modnum& a, const modnum& b) {
return modnum(a) /= modnum(b);
}
};
using mn = modnum;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int N, K;
cin >> N >> K >> MOD;
if (K >= 20 || (1 << (K - 1)) >= N) {
cout << 0 << endl;
return 0;
}
int ct = 1 << (K - 1);
int ctB = N % ct;
int ctA = ct - ctB;
int szA = N / ct;
int szB = szA + 1;
vector<mn> recip(N + 1), pref(N + 1);
for (int i = 1; i <= N; i++) {
recip[i] = mn(1) / i;
pref[i] = pref[i - 1] + recip[i];
}
auto comb = [&](int a, int b) {
mn res = 0;
for (int i = 1; i <= a; i++) {
res += mn(b) / 2 - (pref[i + b] - pref[i]);
}
return res;
};
mn ans = 0;
ans += mn(ctA) * szA * (szA - 1) / 4;
if (ctA > 1) ans += mn(ctA) * (ctA - 1) / 2 * comb(szA, szA);
ans += mn(ctB) * szB * (szB - 1) / 4;
if (ctB > 1) ans += mn(ctB) * (ctB - 1) / 2 * comb(szB, szB);
if (ctA > 0 && ctB > 0) ans += mn(ctA) * ctB * comb(szA, szB);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void proc_status() {
ifstream t("/proc/self/status");
cerr << string(istreambuf_iterator<char>(t), istreambuf_iterator<char>())
<< endl;
}
template <typename T>
inline bool chkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline T read() {
register T sum(0), fg(1);
register char ch(getchar());
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fg = -1;
for (; isdigit(ch); ch = getchar()) sum = sum * 10 - '0' + ch;
return sum * fg;
}
const int MAXN = (int)1e5;
int MOD;
inline int fpm(int x, int y) {
int res = 1;
for (; y; y >>= 1, x = (long long)x * x % MOD)
if (y & 1) res = (long long)res * x % MOD;
return res;
}
int n, k;
inline void input() { n = read<int>(), k = read<int>(), MOD = read<int>(); }
map<int, int> cnt;
inline void merge_sort(int l, int r, int dep) {
if (l == r || dep == 1) {
++cnt[r - l + 1];
return;
}
int mid = (l + r) / 2;
merge_sort(l, mid, dep - 1);
merge_sort(mid + 1, r, dep - 1);
}
int pre[MAXN * 2 + 5];
inline int calc(int p, int q) {
int sum = (long long)p * q % MOD * ((MOD + 1) / 2) % MOD;
for (int i = 1; i <= p; ++i) (sum -= (pre[i + q] - pre[i]) % MOD) %= MOD;
return sum;
}
inline void solve() {
merge_sort(1, n, k);
pre[0] = 0;
for (int i = 1; i <= 2 * n; ++i)
pre[i] = (pre[i - 1] + fpm(i, MOD - 2)) % MOD;
int ans = 0;
for (auto i : cnt) {
(ans += (long long)i.first * (i.first - 1) / 2 % MOD * ((MOD + 1) / 2) %
MOD * i.second % MOD) %= MOD;
(ans += (long long)calc(i.first, i.first) *
(i.second * (i.second - 1) / 2 % MOD) % MOD) %= MOD;
}
for (auto i : cnt)
for (auto j : cnt)
if (i.first < j.first)
(ans += (long long)calc(i.first, j.first) * i.second % MOD * j.second %
MOD) %= MOD;
printf("%d\n", (ans + MOD) % MOD);
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
map<int, int> st;
int n, h, mod, inv[maxn];
int qpow(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) ans = 1ll * ans * a % mod;
return ans;
}
void sol(int l, int r, int h) {
if (r - l + 1 <= 1 || h <= 1) {
st[r - l + 1]++;
} else {
int mid = l + r >> 1;
sol(l, mid, h - 1);
sol(mid + 1, r, h - 1);
}
}
int cal(int x, int y) {
int ret = 1ll * x * y % mod * (mod + 1) / 2 % mod;
for (int i = 1; i <= x; ++i) ret -= inv[i + y] - inv[i], ret %= mod;
return (ret % mod + mod) % mod;
}
int main() {
scanf("%d%d%d", &n, &h, &mod);
sol(1, n, h);
inv[0] = inv[1] = 1;
for (int i = 2; i <= n; ++i)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i <= n; ++i) inv[i] = (inv[i - 1] + inv[i]) % mod;
int ans = 0;
for (auto c : st)
ans =
(ans +
1ll * (c.first) * (c.first - 1) % mod * qpow(4, mod - 2) % mod *
c.second +
1ll * (c.second) * (c.second - 1) / 2 % mod * cal(c.first, c.first)) %
mod;
for (auto c : st)
for (auto d : st)
if (c.first < d.first)
ans =
(ans + 1ll * (c.second) * d.second % mod * cal(c.first, d.first)) %
mod;
printf("%d", ans);
}
|
#include <bits/stdc++.h>
int q, I[200010];
long long inv(int a, int p) {
return a == 1 ? 1 : (1 + p * (a - inv(p % a, a))) / a % p;
}
int f(int a, int b) {
int s = 0;
for (int i = 0; i < a + b - 1; i++)
s = (s + ((i + 1 < a ? i + 1 : a) - (i - b + 1 > 0 ? i - b + 1 : 0)) * 1ll *
i % q * I[i + 2]) %
q;
return (q + 1ll) / 2 * s % q;
}
int main() {
int n, k;
scanf("%d%d%d", &n, &k, &q);
--k;
if (k > 18) k = 18;
int a = n >> k, b = a + 1, x, y;
if (a)
x = (b << k) - n, y = (1 << k) - x;
else
x = 0, y = n;
for (int i = *I = 1; i <= b * 2; i++) I[i] = I[i - 1] * 1ll * i % q;
long long P = inv(I[b * 2], q);
for (int i = b * 2; i; i--) I[i] = I[i - 1] * P % q, P = P * i % q;
int s = (x * (x - 1ll) / 2 % q * f(a, a) + 1ll * x * y % q * f(a, b) +
y * (y - 1ll) / 2 % q * f(b, b) +
a * (a - 1ll) / 2 % q * (q + 1 >> 1) % q * x +
b * (b - 1ll) / 2 % q * (q + 1 >> 1) % q * y) %
q;
printf("%d\n", s);
}
|
#include <bits/stdc++.h>
const int N = 2e5 + 5;
int n, k, mo, ans, inv[N], i, cnt[N], mn = N;
void dfs(int l, int r, int h) {
if (l == r || h <= 1) {
++cnt[r - l + 1];
mn = std::min(mn, r - l + 1);
return;
}
int m = l + r >> 1;
dfs(l, m, h - 1);
dfs(m + 1, r, h - 1);
}
inline int calc(int x, int y) {
int ans = 0;
for (i = 2; i <= x + y; ++i)
ans = (ans + 1ll * inv[i] * (std::min(i - 1, x) - std::max(i - y, 1) + 1)) %
mo;
return (1ll * x * y % mo * inv[2] + mo - ans) % mo;
}
int main() {
scanf("%d%d%d", &n, &k, &mo);
for (i = 2, inv[1] = 1; i < N; ++i)
inv[i] = 1ll * (mo - mo / i) * inv[mo % i] % mo;
dfs(1, n, k);
ans = (1ll * mn * (mn - 1) % mo * cnt[mn] +
1ll * (mn + 1) * mn % mo * cnt[mn + 1]) %
mo * inv[4] % mo;
ans = (ans + 1ll * cnt[mn] * (cnt[mn] - 1) / 2 % mo * calc(mn, mn)) % mo;
ans = (ans + 1ll * cnt[mn + 1] * (cnt[mn + 1] - 1) / 2 % mo *
calc(mn + 1, mn + 1)) %
mo;
ans = (ans + 1ll * cnt[mn] * cnt[mn + 1] % mo * calc(mn, mn + 1)) % mo;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
char ch;
bool fs;
void re(int& x) {
while (ch = getchar(), ch < 33)
;
if (ch == '-')
fs = 1, x = 0;
else
fs = 0, x = ch - 48;
while (ch = getchar(), ch > 33) x = x * 10 + ch - 48;
if (fs) x = -x;
}
using namespace std;
int n, k, mod, ans, inv[200001], sum[200001];
map<int, int> s;
void divide(int l, int r, int h) {
if (h <= 1 || l == r)
++s[r - l + 1];
else
divide(l, l + r >> 1, h - 1), divide((l + r >> 1) + 1, r, h - 1);
}
int calc(int x, int y) {
int res = 1ll * inv[2] * x % mod * y % mod;
for (int i = 1; i <= x; ++i) res = (res - (sum[i + y] - sum[i])) % mod;
return (res + mod) % mod;
}
int main() {
re(n), re(k), re(mod);
divide(1, n, k);
sum[1] = inv[1] = 1;
for (int i = 2; i < 200001; ++i)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod,
sum[i] = (sum[i - 1] + inv[i]) % mod;
for (auto i : s) {
ans =
(ans + 1ll * inv[4] * i.first % mod * (i.first - 1) % mod * i.second) %
mod;
ans = (ans + 1ll * inv[2] * i.second % mod * (i.second - 1) % mod *
calc(i.first, i.first)) %
mod;
}
for (auto i : s)
for (auto j : s)
if (i.first < j.first)
ans = (ans + 1ll * i.second * j.second % mod * calc(i.first, j.first)) %
mod;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
int mod;
struct modint {
int x;
modint(int o = 0) { x = o; }
modint &operator=(int o) { return x = o, *this; }
modint &operator+=(modint o) {
return x = x + o.x >= mod ? x + o.x - mod : x + o.x, *this;
}
modint &operator-=(modint o) {
return x = x - o.x < 0 ? x - o.x + mod : x - o.x, *this;
}
modint &operator*=(modint o) { return x = 1ll * x * o.x % mod, *this; }
modint &operator^=(int b) {
modint a = *this, c = 1;
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return x = c.x, *this;
}
modint &operator/=(modint o) { return *this *= o ^= mod - 2; }
modint &operator+=(int o) {
return x = x + o >= mod ? x + o - mod : x + o, *this;
}
modint &operator-=(int o) {
return x = x - o < 0 ? x - o + mod : x - o, *this;
}
modint &operator*=(int o) { return x = 1ll * x * o % mod, *this; }
modint &operator/=(int o) { return *this *= ((modint(o)) ^= mod - 2); }
template <class I>
friend modint operator+(modint a, I b) {
return a += b;
}
template <class I>
friend modint operator-(modint a, I b) {
return a -= b;
}
template <class I>
friend modint operator*(modint a, I b) {
return a *= b;
}
template <class I>
friend modint operator/(modint a, I b) {
return a /= b;
}
friend modint operator^(modint a, int b) { return a ^= b; }
friend bool operator==(modint a, int b) { return a.x == b; }
friend bool operator!=(modint a, int b) { return a.x != b; }
bool operator!() { return !x; }
modint operator-() { return x ? mod - x : 0; }
};
inline modint qpow(modint a, int b) { return a ^ b; }
int n, k;
map<int, int> mp;
modint iv[100005], sum[100005];
void div(int l, int r, int k) {
if (k <= 1 || l == r) return mp[r - l + 1]++, void();
int mid = l + r >> 1;
div(l, mid, k - 1), div(mid + 1, r, k - 1);
}
modint getprob(int x, int y) {
modint res = modint(x) * y;
for (register int i = (1); i <= (x); ++i) res -= 2 * (sum[i + y] - sum[i]);
return res;
}
signed main() {
n = read(), k = read(), mod = read();
iv[1] = 1;
for (register int i = (2); i <= (max(4, n)); ++i)
iv[i] = iv[mod % i] * (mod - mod / i);
for (register int i = (1); i <= (n); ++i) sum[i] = sum[i - 1] + iv[i];
div(1, n, k);
modint res = 0;
for (auto it1 : mp)
for (auto it2 : mp) {
if (it1.first == it2.first) {
int cnt = it1.second, len = it1.first;
res += iv[2] * len * (len - 1) * cnt;
res += modint(cnt) * (cnt - 1) * iv[2] * getprob(len, len);
} else if (it1.first < it2.first) {
int l1 = it1.first, l2 = it2.first, c1 = it1.second, c2 = it2.second;
res += getprob(l1, l2) * c1 * c2;
}
}
res *= iv[2];
cout << res.x;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200010;
int moder;
int inv[N];
int cnt[N];
int pre[N];
int ans;
void init() {
inv[1] = 1;
for (int i = 2; i < N; ++i) {
inv[i] = moder - 1ll * (moder / i) * inv[moder % i] % moder;
}
for (int i = 1; i < N; ++i) {
pre[i] = (pre[i - 1] + inv[2] - inv[i]) % moder;
pre[i] += pre[i] < 0 ? moder : 0;
}
}
void mergesort(int l, int r, int h) {
if (h <= 1) {
if (r >= l) {
++cnt[r - l + 1];
ans = (ans + 1ll * (r - l + 1) * (r - l) % moder * inv[4]) % moder;
}
return;
}
int mid = (l + r) >> 1;
mergesort(l, mid, h - 1);
mergesort(mid + 1, r, h - 1);
}
int main() {
int n, k;
scanf("%d%d%d", &n, &k, &moder);
init();
if (k >= 20) {
puts("0");
return 0;
}
mergesort(1, n, k);
for (int i = 0; i <= n; ++i) {
if (!cnt[i]) continue;
for (int j = i; j <= n; ++j) {
if (!cnt[j]) continue;
int coe = i == j ? 1ll * cnt[i] * (cnt[i] - 1) / 2 % moder
: 1ll * cnt[i] * cnt[j] % moder;
for (int k = 1; k <= i; ++k) {
ans = (ans + 1ll * coe * (pre[k + j] - pre[k])) % moder;
}
}
}
ans += ans < 0 ? moder : 0;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
const int n = read(), m = read(), mod = read();
const int inv2 = (mod + 1) / 2;
int ans, inv[200020], s[200020];
vector<pair<int, int> > vec;
void Solve(int l, int r, int h) {
if (h == 1 || l == r) {
int len = (r - l + 1);
ans = (ans + 1LL * len * (len - 1) / 2 % mod * inv2 % mod) % mod;
for (int i = 0; i < (int)vec.size(); ++i) {
if (vec[i].first == len) {
++vec[i].second;
return;
}
}
vec.push_back(make_pair(len, 1));
return;
}
int mid = (l + r) >> 1;
Solve(l, mid, h - 1);
Solve(mid + 1, r, h - 1);
}
int main() {
inv[1] = s[1] = 1;
for (int i = 2; i <= n << 1; ++i) {
inv[i] = 1LL * (mod - mod / i) * inv[mod % i] % mod;
s[i] = (s[i - 1] + inv[i]) % mod;
}
Solve(1, n, m);
for (int x = 0; x < (int)vec.size(); ++x) {
for (int y = x; y < (int)vec.size(); ++y) {
int A = vec[x].first, B = vec[y].first, cA = vec[x].second,
cB = vec[y].second;
int sum = 0;
for (int i = 1; i <= A; ++i) {
sum = (sum + (s[i + B] - s[i] + mod) % mod) % mod;
}
int tot = (x == y ? 1LL * cA * (cA - 1) / 2 % mod : 1LL * cA * cB % mod);
ans = (ans + 1LL * tot * (1LL * A * B % mod * inv2 % mod - sum)) % mod;
}
}
printf("%d\n", (ans + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
char ch;
x = 0;
bool fl = false;
while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
;
(fl == true) && (x = -x);
}
template <class T>
inline void output(T x) {
if (x / 10) output(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void ot(T x) {
if (x < 0) putchar('-'), x = -x;
output(x);
putchar(' ');
}
template <class T>
inline void prt(T a[], int st, int nd) {
for (register int i = st; i <= nd; ++i) ot(a[i]);
putchar('\n');
}
namespace Modulo {
int mod;
inline int ad(int x, int y) { return x + y >= mod ? x + y - mod : x + y; }
inline int sub(int x, int y) { return ad(x, mod - y); }
inline int mul(int x, int y) { return (long long)x * y % mod; }
inline void inc(int &x, int y) { x = ad(x, y); }
inline void inc2(int &x, int y) { x = mul(x, y); }
inline int qm(int x, int y = mod - 2) {
int ret = 1;
while (y) {
if (y & 1) ret = mul(x, ret);
x = mul(x, x);
y >>= 1;
}
return ret;
}
template <class... Args>
inline int ad(const int a, const int b, const Args &...args) {
return ad(ad(a, b), args...);
}
template <class... Args>
inline int mul(const int a, const int b, const Args &...args) {
return mul(mul(a, b), args...);
}
} // namespace Modulo
using namespace Modulo;
namespace Miracle {
const int N = 1e5 + 5;
int n, k;
int iv[N], s[N];
int l1, l2, c1, c2;
void divi(int l, int r, int d) {
if (d == k || l == r) {
if (!l1) {
l1 = r - l + 1;
++c1;
} else if (r - l + 1 == l1)
++c1;
else if (!l2)
l2 = r - l + 1, ++c2;
else
++c2;
return;
}
int mid = (l + r) >> 1;
divi(l, mid, d + 1);
divi(mid + 1, r, d + 1);
}
int calc(int l1, int l2) {
if (!l1 || !l2) return 0;
int ret = mul(l1, l2, qm(2));
for (register int i = 1; i <= l1; ++i) {
ret = sub(ret, sub(s[i + l2], s[i]));
}
return ret;
}
int main() {
rd(n);
rd(k);
rd(mod);
iv[1] = 1;
for (register int i = 2; i <= n; ++i) {
iv[i] = mul(mod - mod / i, iv[mod % i]);
}
for (register int i = 1; i <= n; ++i) s[i] = ad(s[i - 1], iv[i]);
divi(1, n, 1);
int ans = ad(mul(c1, l1, (l1 - 1), qm(4)), mul(c2, l2, (l2 - 1), qm(4)));
inc(ans, mul(c1, c1 - 1, qm(2), calc(l1, l1)));
inc(ans, mul(c2, c2 - 1, qm(2), calc(l2, l2)));
inc(ans, mul(c1, c2, calc(l1, l2)));
ot(ans);
return 0;
}
} // namespace Miracle
signed main() {
Miracle::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 100000 + 10;
int mod, inv2, inv4;
int qpow(int a, int b) {
int c = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) c = 1ll * c * a % mod;
return c;
}
int n, k;
int inv[N], sum[N], o[N];
vector<int> l;
void divide(int l, int r, int d) {
if (d == k || l == r) {
++o[r - l + 1];
return;
}
int mid = (l + r) >> 1;
divide(l, mid, d + 1), divide(mid + 1, r, d + 1);
}
int calc(int x, int y) {
int res = 1ll * x * y % mod * inv2 % mod;
for (int i = 1; i <= x; ++i)
res = (res - (sum[i + y] - sum[i] + mod) % mod + mod) % mod;
return res;
}
int main() {
n = read(), k = read(), mod = read(), inv2 = qpow(2, mod - 2),
inv4 = qpow(4, mod - 2);
inv[1] = 1;
for (int i = 2; i <= n; ++i)
inv[i] = mod - 1ll * inv[mod % i] * (mod / i) % mod;
for (int i = 1; i <= n; ++i) sum[i] = (sum[i - 1] + inv[i]) % mod;
divide(1, n, 1);
for (int i = 1; i <= n; ++i)
if (o[i]) l.emplace_back(i);
int ans = 0;
for (int i : l)
ans = (ans + 1ll * i * (i - 1) % mod * inv4 % mod * o[i]) % mod;
for (int i : l)
ans = (ans + 1ll * o[i] * (o[i] - 1) / 2 % mod * calc(i, i)) % mod;
if (l.size() > 1)
ans = (ans + 1ll * o[l[0]] * o[l[1]] % mod * calc(l[0], l[1])) % mod;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, k, p, ans, inv4, cnt[N], inv[N];
void divide(int x, int k) {
if (k == 1 || x == 1)
return (void)(++cnt[x],
ans = (ans + (long long)x * (x - 1) % p * inv4) % p);
divide(x / 2, k - 1), divide(x - x / 2, k - 1);
}
inline int calc(int x, int y) {
int ans = (long long)x * y % p * (p + 1) / 2 % p;
for (int i = 2; i <= x + y; ++i)
ans = (ans + (min(x, i - 1) - max(1, i - y) + 1ll) * (p - inv[i])) % p;
return ans;
}
int main() {
scanf("%d%d%d", &n, &k, &p), inv4 = (p + 1ll) * (p + 1) / 4 % p;
inv[1] = 1;
for (int i = 2; i <= n; ++i) inv[i] = (long long)(p - p / i) * inv[p % i] % p;
divide(n, k);
int x = 0;
for (int i = 1; i <= n; ++i)
if (cnt[i]) {
x = i;
break;
}
ans = (ans + (long long)cnt[x] * (cnt[x] - 1) / 2 % p * calc(x, x)) % p;
if (cnt[x + 1])
ans = (ans + (long long)cnt[x] * cnt[x + 1] % p * calc(x, x + 1) +
(long long)cnt[x + 1] * (cnt[x + 1] - 1) / 2 % p *
calc(x + 1, x + 1)) %
p;
return printf("%d", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2E5 + 10;
int P;
template <typename T1, typename T2>
void Inc(T1 &a, T2 b) {
a += b;
if (a >= P) a -= P;
}
template <typename T1, typename T2>
void Dec(T1 &a, T2 b) {
a -= b;
if (a < 0) a += P;
}
template <typename T1, typename T2>
T1 Add(T1 a, T2 b) {
a += b;
return a >= P ? a - P : a;
}
template <typename T1, typename T2>
T1 Sub(T1 a, T2 b) {
a -= b;
return a < 0 ? a + P : a;
}
long long ksm(long long a, long long b) {
long long ret = 1;
for (; b; b >>= 1, (a *= a) %= P)
if (b & 1) (ret *= a) %= P;
return ret;
}
int n, k, inv2, inv4;
long long Ans, sum[MAXN << 1];
map<int, int> M;
long long calc(int len1, int len2) {
long long ret = 1ll * len1 * len2 % P * inv2 % P;
for (int i = 1; i <= len1; i++)
Dec(ret, 1ll * Sub(sum[i + len2], sum[i]) % P);
return ret;
}
void solve(int l, int r, int d) {
if (l == r || d == k) {
int len = r - l + 1;
M[len]++;
Inc(Ans, 1ll * len * (len - 1) % P * inv4 % P);
return;
}
int mid = (l + r) >> 1;
solve(l, mid, d + 1);
solve(mid + 1, r, d + 1);
}
int main() {
scanf("%d%d%d", &n, &k, &P);
inv2 = ksm(2, P - 2);
inv4 = ksm(4, P - 2);
for (int i = 1; i <= 2 * n; i++) sum[i] = (sum[i - 1] + ksm(i, P - 2)) % P;
solve(1, n, 1);
for (auto p1 : M) {
Inc(Ans, 1ll * p1.second * (p1.second - 1) % P * inv2 % P *
calc(p1.first, p1.first) % P);
for (auto p2 : M)
if (p1.first < p2.first)
Inc(Ans,
1ll * p1.second * p2.second % P * calc(p1.first, p2.first) % P);
}
printf("%lld\n", Ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long read() {
long long s = 0;
char c = getchar(), lc = '+';
while (c < '0' || '9' < c) lc = c, c = getchar();
while ('0' <= c && c <= '9') s = s * 10 + c - '0', c = getchar();
return lc == '-' ? -s : s;
}
void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10)
putchar(x + '0');
else {
write(x / 10);
putchar(x % 10 + '0');
}
}
void print(long long x, char c = '\n') {
write(x);
putchar(c);
}
long long sum[N], ans, p;
long long power(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = ret * a % p;
a = a * a % p;
b /= 2;
}
return ret;
}
long long calc(long long x, long long y) {
long long ret = 0;
for (long long i = 1; i <= x; i++) ret = (ret + sum[i + y] - sum[i] + p) % p;
return ret;
}
long long tot[N][2];
void Count(long long l, long long r, long long h, long long Min) {
if (r - l + 1 == Min)
tot[h][0]++;
else
tot[h][1]++;
if (h == 1)
return void(ans = (ans + (r - l + 1) * (r - l) % p * power(4, p - 2) % p) %
p);
if (l == r) return;
long long mid = (l + r) / 2;
Count(l, mid, h - 1, Min / 2);
Count(mid + 1, r, h - 1, Min / 2);
}
void merge_sort(long long h, long long Min) {
if (h <= 0) return;
if (h == 1)
ans = (ans + tot[h][0] * (tot[h][0] - 1) / 2 % p * calc(Min, Min) % p +
tot[h][1] * (tot[h][1] - 1) / 2 % p * calc(Min + 1, Min + 1) % p +
tot[h][0] * tot[h][1] % p * calc(Min, Min + 1) % p) %
p;
merge_sort(h - 1, Min / 2);
}
signed main() {
memset(tot, 0, sizeof(tot));
long long n = read(), k = read();
p = read();
for (long long i = 1; i <= n * 2; i++)
sum[i] = (sum[i - 1] + power(2, p - 2) - power(i, p - 2) + p) % p;
Count(1, n, k, n);
merge_sort(k, n);
print(ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
using namespace std;
namespace ywy {
unordered_map<int, int> mp;
long long inv[200001], ans = 0;
int p;
inline void solve(int a, int b) {
long long cjr = a;
cjr *= b;
cjr %= p;
cjr *= mp[a];
cjr %= p;
cjr *= mp[b];
cjr %= p;
ans = (ans + cjr * inv[2]) % p;
for (register int i = 2; i <= a + b; i++) {
long long l = max(1, i - b), r = min(i - 1, a);
if (l > r) continue;
cjr = p - inv[i];
cjr *= (r - l + 1);
cjr %= p;
cjr *= mp[a];
cjr %= p;
cjr *= mp[b];
ans = (ans + cjr) % p;
}
}
void digui(int l, int r, int h) {
if (h <= 1) {
mp[r - l + 1]++;
return;
}
if (l == r) return;
int mid = (l + r) >> 1;
digui(l, mid, h - 1);
digui(mid + 1, r, h - 1);
}
void ywymain() {
int n, k;
cin >> n >> k >> p;
inv[0] = inv[1] = 1;
for (register int i = 2; i <= 100000; i++)
inv[i] = (inv[p % i] * (p - p / i)) % p;
digui(1, n, k);
for (unordered_map<int, int>::iterator i = mp.begin(); i != mp.end(); i++) {
long long cjr = i->first - 1;
cjr *= i->first;
cjr %= p;
cjr *= i->second;
cjr %= p;
ans = (ans + cjr * inv[4]) % p;
cjr = inv[2];
cjr *= (i->second - 1);
cjr %= p;
cjr *= i->second;
cjr %= p;
for (register int j = 2; j <= i->first * 2; j++) {
long long l = max(1, j - i->first), r = min(j - 1, i->first);
if (l > r) continue;
long long h = p - inv[j];
h *= cjr;
h %= p;
h *= (r - l + 1);
h %= p;
ans = (ans + h) % p;
}
cjr *= inv[2];
cjr %= p;
cjr *= i->first;
cjr %= p;
cjr *= i->first;
ans = (ans + cjr) % p;
}
for (unordered_map<int, int>::iterator i = mp.begin(); i != mp.end(); i++) {
unordered_map<int, int>::iterator j = i;
j++;
for (; j != mp.end(); j++) solve(i->first, j->first);
}
cout << ans << endl;
}
} // namespace ywy
int main() {
ywy::ywymain();
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
long long P;
const int maxn = 110000;
long long rec[maxn];
long long deg(long long x, long long d) {
if (d < 0) d += P - 1;
long long y = 1;
while (d) {
if (d & 1) (y *= x) %= P;
(x *= x) %= P;
d /= 2;
}
return y;
}
map<int, long long> cnt;
void merge(int l, int k) {
if (k <= 1 || l == 1) {
++cnt[l];
return;
}
merge(l / 2, k - 1);
merge(l - l / 2, k - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int n, k;
cin >> n >> k >> P;
merge(n, k);
long long ans = 0;
for (auto w1 : cnt) {
int n = w1.first;
long long q = w1.second;
(ans += q * n % P * (n - 1) % P * deg(4, -1)) %= P;
}
for (auto w1 : cnt)
for (auto w2 : cnt) {
int n = w1.first, m = w2.first;
if (m < n) continue;
long long coef;
if (n == m)
coef = w1.second * (w1.second - 1) / 2 % P;
else
coef = w1.second * w2.second % P;
long long R = 1LL * n * m % P * (P + 1) / 2 % P;
for (int s = 1; s <= (int)(n + m); ++s) {
int l = max(1, s - m), r = min(n, s - 1);
(R -= 1LL * (r - l + 1) * deg(s, -1)) %= P;
}
(ans += coef * R) %= P;
}
if (ans < 0) ans += P;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using ll = long long;
const int N = 100005;
int n, kk, P;
ll ans, inv[N], sum[N];
map<int, int> cnt;
ll qpow(ll a, ll b) {
ll ret = 1;
while (b) {
if (b & 1) ret = ret * a % P;
a = a * a % P;
b >>= 1;
}
return ret;
}
void proc(int l, int r, int dep) {
if (dep <= 1 || l == r) {
cnt[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
proc(l, mid, dep - 1);
proc(mid + 1, r, dep - 1);
}
int calc(int x, int y) {
ll ret = ll(x) * y % P;
for (int i = 1; i <= x; i++)
ret = (ret + P - (sum[i + y] - sum[i]) * 2 % P) % P;
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> kk >> P;
for (int i = 1; i < N; i++)
inv[i] = qpow(i, P - 2), sum[i] = (sum[i - 1] + inv[i]) % P;
proc(1, n, kk);
for (auto &i : cnt) {
ll t = i.first, s = i.second;
ans = (ans + t * (t - 1) % P * inv[2] % P * s % P +
s * (s - 1) % P * inv[2] % P * calc(t, t) % P) %
P;
}
for (auto &i : cnt)
for (auto &j : cnt)
if (i.first < j.first)
ans =
(ans + calc(i.first, j.first) * 1ll * i.second % P * j.second % P) %
P;
cout << ans * inv[2] % P << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
inline int read() {
int x = 0;
char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while ('0' <= ch && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x;
}
int n, k, mod;
long long inv[N], sum[N], ans;
map<long long, long long> m;
void solve(int l, int r, int dep) {
if (l == r || !dep) {
m[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
solve(l, mid, dep - 1), solve(mid + 1, r, dep - 1);
}
void init() {
inv[0] = inv[1] = 1;
for (register int i = 2; i <= n; i++)
inv[i] = (mod - mod / i) * inv[mod % i] % mod,
sum[i] = (sum[i - 1] + inv[i]) % mod;
}
long long cal(long long x, long long y) {
long long res = x * y;
for (register int i = 1; i <= x; i++)
(res += mod - (sum[i + y] - sum[i] + mod) % mod * 2 % mod) %= mod;
return res;
}
void work() {
for (map<long long, long long>::iterator it = m.begin(); it != m.end();
it++) {
long long len = it->first, cnt = it->second;
(ans += len * (len - 1) % mod * inv[2] % mod * cnt % mod) %= mod;
(ans += cnt * (cnt - 1) % mod * inv[2] % mod * cal(len, len)) %= mod;
}
for (map<long long, long long>::iterator it1 = m.begin(); it1 != m.end();
it1++) {
for (map<long long, long long>::iterator it2 = m.begin(); it2 != m.end();
it2++) {
long long x = it1->first, y = it2->first;
if (x < y)
(ans += cal(x, y) * it1->second % mod * it2->second % mod) %= mod;
}
}
}
int main() {
n = read(), k = read() - 1, mod = read();
init();
solve(1, n, k);
work();
printf("%lld", ans * inv[2] % mod);
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod, inv2;
vector<pair<long long, long long> > vec;
long long inv[20000005], ans, sum;
long long calc(long long len) { return len * (len - 1) % mod * inv2 % mod; }
void merge(long long l, long long r, long long h) {
if (h == 1 || l == r) {
long long len = r - l + 1;
ans += calc(len) * inv2 % mod;
ans %= mod;
for (long long i = 0; i < (long long)vec.size(); ++i)
if (vec[i].first == len) {
++vec[i].second;
return;
}
return vec.push_back(make_pair(len, 1)), void(0);
}
long long mid = (l + r) >> 1;
merge(l, mid, h - 1);
merge(mid + 1, r, h - 1);
}
void init(long long n) {
inv[1] = 1;
for (long long i = 2; i <= n; ++i)
inv[i] = 1ll * (mod - (mod / i)) * inv[mod % i] % mod;
for (long long i = 1; i <= n; ++i) inv[i] = (inv[i] + inv[i - 1]) % mod;
}
signed main() {
long long n, K;
cin >> n >> K >> mod;
inv2 = (mod + 1) / 2;
init(n + n);
merge(1, n, K);
for (long long i = 0; i < (long long)vec.size(); ++i)
for (long long j = i; j < (long long)vec.size(); ++j) {
long long lenA = vec[i].first, lenB = vec[j].first;
long long cntA = vec[i].second, cntB = vec[j].second;
sum = 0;
for (long long k = 1; k <= lenA; ++k)
sum = (sum + inv[k + lenB] - inv[k] + mod) % mod;
long long tot = (i == j ? calc(cntA) : cntA * cntB) % mod;
ans += tot * ((lenA * lenB % mod * inv2 % mod - sum + mod) % mod) % mod;
ans %= mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
std::map<long long, long long> mp;
long long p, inv[200005], sum[200005];
inline long long read() {
register long long x = 0, f = 1;
register char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline long long max(const long long &x, const long long &y) {
return x > y ? x : y;
}
inline void simulate(long long l, long long r, long long k) {
if (k == 1 || l == r) {
std::map<long long, long long>::iterator it = mp.find(r - l + 1);
if (it != mp.end())
++it->second;
else
mp.insert(std::make_pair(r - l + 1, 1));
return;
}
long long mid = l + r >> 1;
simulate(l, mid, k - 1);
simulate(mid + 1, r, k - 1);
}
inline long long calc(long long len1, long long len2) {
long long res = 0;
for (register long long i = 1; i <= len1; ++i) {
(res += (inv[2] * len2 % p - (sum[i + len2] - sum[i]) % p) % p) %= p;
}
return res;
}
signed main() {
long long ans = 0;
long long n = read(), k = read();
p = read();
inv[1] = 1;
for (register long long i = 2; i <= max(n, 4); ++i)
inv[i] = (p - (p / i)) * 1ll * inv[p % i] % p;
for (register long long i = 1; i <= n; ++i)
sum[i] = (sum[i - 1] + inv[i]) % p;
simulate(1, n, k);
for (std::map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it) {
long long len = it->first, cnt = it->second;
(ans += cnt * ((len - 1) * 1ll * len % p) % p * inv[4] % p) %= p;
}
for (std::map<long long, long long>::iterator it1 = mp.begin();
it1 != mp.end(); ++it1) {
for (std::map<long long, long long>::iterator it2 = mp.begin();
it2 != mp.end(); ++it2) {
if (it1->first == it2->first) {
long long len = it1->first,
cnt = (it1->second - 1) * 1ll * (it1->second) / 2 % p;
(ans += cnt * 1ll * calc(len, len) % p) %= p;
} else if (it1->first < it2->first) {
long long cnt = (it2->second) * (it1->second) % p;
(ans += cnt * 1ll * calc(it1->first, it2->first) % p) %= p;
}
}
}
printf("%lld\n", (ans + p) % p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, k, mod, ans;
int inv[N], sum[N];
map<int, int> cnt;
map<int, int>::iterator it1, it2;
int read() {
int ret = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 0;
c = getchar();
}
while (isdigit(c)) ret = ret * 10 + (c ^ 48), c = getchar();
return f ? ret : -ret;
}
void up(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
int qpow(int x, int y) {
int res = 1;
x %= mod;
for (; y; y >>= 1, x = (long long)x * x % mod)
if (y & 1) res = (long long)res * x % mod;
return res;
}
void init() {
n = read();
k = read();
mod = read();
for (int i = 1; i < N; ++i)
sum[i] = inv[i] = qpow(i, mod - 2), up(sum[i], sum[i - 1]);
}
void divide(int l, int r, int dp) {
if (dp <= 1 || l == r) {
cnt[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
divide(l, mid, dp - 1);
divide(mid + 1, r, dp - 1);
}
int calc(int x, int y) {
int res = (long long)x * y % mod;
for (int i = 1; i <= x; ++i) up(res, -(sum[i + y] - sum[i]) * 2 % mod);
return res;
}
void solve() {
for (it1 = cnt.begin(); it1 != cnt.end(); ++it1) {
int t = it1->first, s = it1->second;
up(ans, (long long)t * (t - 1) % mod * inv[2] % mod * s % mod);
up(ans, (long long)s * (s - 1) % mod * inv[2] % mod * calc(t, t) % mod);
}
for (it1 = cnt.begin(); it1 != cnt.end(); ++it1)
for (it2 = cnt.begin(); it2 != cnt.end(); ++it2) {
int x = it1->first, y = it2->first;
if (x >= y) continue;
up(ans, (long long)calc(x, y) * it1->second % mod * it2->second % mod);
}
printf("%d\n", (long long)ans * inv[2] % mod);
}
int main() {
init();
divide(1, n, k);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
int mod = 1e9 + 7;
long long power(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
long long INV(long long a) { return power(a, mod - 2); }
mt19937 Rand(123456);
int Range(int l, int r) { return l + Rand() % (r - l + 1); }
map<long long, long long> mp;
void work(int l, int r, int k) {
if (k == 1 || l == r) {
++mp[r - l + 1];
return;
}
int mid = (l + r) / 2;
work(l, mid, k - 1);
work(mid + 1, r, k - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k >> mod;
vector<long long> inv(2 * n), inv_sum;
for (int i = 0; i <= 2 * n - 1; i++) inv[i] = INV(i);
inv_sum = inv;
for (int i = 1; i <= 2 * n - 1; i++) inv_sum[i] += inv_sum[i - 1];
for (auto& I : inv_sum) I %= mod;
auto merge = [&](int l, int r, const vector<long long>& inv_sum) {
long long res = (long long)l * r % mod * INV(2) % mod;
for (int i = 1; i <= l; i++) res -= inv_sum[i + r] - inv_sum[i];
res %= mod;
res += mod;
return res % mod;
};
work(1, n, k);
long long res = 0;
for (auto I : mp)
res += (I.first * (I.first - 1) % mod * INV(4) % mod) * I.second % mod,
res += I.second * (I.second - 1) % mod * INV(2) % mod *
merge(I.first, I.first, inv_sum) % mod;
for (auto I : mp)
for (auto J : mp)
if (I.first < J.first)
res +=
merge(I.first, J.first, inv_sum) * I.second % mod * J.second % mod;
res %= mod;
res += mod;
res %= mod;
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, k, mod, ans;
int inv[N], sum[N];
map<int, int> cnt;
map<int, int>::iterator it1, it2;
int read() {
int ret = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = 0;
c = getchar();
}
while (isdigit(c)) ret = ret * 10 + (c ^ 48), c = getchar();
return f ? ret : -ret;
}
void up(int &x, int y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
int Pow(int b, int k) {
int r = 1;
for (; k; k >>= 1, b = 1ll * b * b % mod)
if (k & 1) r = 1ll * r * b % mod;
return r;
}
void divide(int l, int r, int dp) {
if (dp <= 1 || l == r) {
cnt[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
divide(l, mid, dp - 1);
divide(mid + 1, r, dp - 1);
}
int calc(int x, int y) {
int res = (long long)x * y % mod;
for (int i = 1; i <= x; ++i) up(res, -(sum[i + y] - sum[i]) * 2 % mod);
return res;
}
int main() {
n = read();
k = read();
mod = read();
for (int i = 1; i < N; ++i)
sum[i] = inv[i] = Pow(i, mod - 2), up(sum[i], sum[i - 1]);
divide(1, n, k);
for (it1 = cnt.begin(); it1 != cnt.end(); ++it1) {
int t = it1->first, s = it1->second;
up(ans, (long long)t * (t - 1) % mod * inv[2] % mod * s % mod);
up(ans, (long long)s * (s - 1) % mod * inv[2] % mod * calc(t, t) % mod);
}
for (it1 = cnt.begin(); it1 != cnt.end(); ++it1)
for (it2 = cnt.begin(); it2 != cnt.end(); ++it2) {
int x = it1->first, y = it2->first;
if (x >= y) continue;
up(ans, (long long)calc(x, y) * it1->second % mod * it2->second % mod);
}
printf("%d\n", (long long)ans * inv[2] % mod);
}
|
#include <bits/stdc++.h>
using namespace std;
int MOD;
int inv[200005];
void gen_inv(int maxa) {
inv[1] = 1;
for (int i = 2; i <= maxa; i++)
inv[i] = MOD - 1LL * inv[MOD % i] * (MOD / i) % MOD;
}
int getans(int u, int v) {
int ans = 0;
for (int i = 2; i <= u + v; i++)
ans = (ans + 1LL * (min(u, i - 1) - max(1, i - v) + 1) * inv[i]) % MOD;
return ans;
}
int main() {
int n, k;
scanf("%d%d%d", &n, &k, &MOD);
k--;
gen_inv(2 * n);
int ans = 1LL * n * (n - 1) / 2 % MOD * inv[2] % MOD;
if (k <= 20 && (n >> k)) {
int c0 = n >> k, c1 = c0 + 1;
int tot1 = n & (1 << k) - 1, tot0 = (1 << k) - tot1;
ans =
(ans - 1LL * tot0 * (tot0 - 1) / 2 % MOD * getans(c0, c0) % MOD + MOD) %
MOD;
ans =
(ans - 1LL * tot1 * (tot1 - 1) / 2 % MOD * getans(c1, c1) % MOD + MOD) %
MOD;
ans = (ans - 1LL * tot0 * tot1 % MOD * getans(c0, c1) % MOD + MOD) % MOD;
} else
ans = 0;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
bool f = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = 1;
for (; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
if (f) x = -x;
}
template <typename F>
inline void write(F x, char ed = '\n') {
static short st[30];
short tp = 0;
if (x < 0) putchar('-'), x = -x;
do st[++tp] = x % 10, x /= 10;
while (x);
while (tp) putchar('0' | st[tp--]);
putchar(ed);
}
template <typename T>
inline void Mx(T &x, T y) {
x < y && (x = y);
}
template <typename T>
inline void Mn(T &x, T y) {
x > y && (x = y);
}
const int N = 500005;
long long inv[N];
int n, k, P;
long long L1, L2, C1, C2;
long long calc(int L1, int L2) {
long long ans = 0;
for (int i = 1; i <= L1; i++) ans = ans + inv[i + L2] - inv[i];
return (ans % P + P) % P;
}
void solve(int l, int r, int k) {
if (k <= 1 || l == r) {
int len = r - l + 1;
(!L1 || len == L1) ? L1 = len : !L2 && (L2 = len);
len == L1 ? C1++ : C2++;
return;
}
int mid = (l + r) >> 1;
solve(l, mid, k - 1), solve(mid + 1, r, k - 1);
}
int main() {
read(n), read(k), read(P);
inv[0] = inv[1] = 1;
long long inv2 = (P + 1) >> 1;
for (int i = 2; i <= n; i++) inv[i] = (P - P / i) * inv[P % i] % P;
for (int i = 2; i <= n; i++) inv[i] = inv[i - 1] + inv[i] % P;
solve(1, n, k);
long long ans = (long long)n * (n - 1) % P * inv2 % P * inv2 % P;
ans =
(ans - C1 * (C1 - 1) / 2 % P * calc(L1, L1) -
C2 * (C2 - 1) / 2 % P * calc(L2, L2) % P - C1 * C2 % P * calc(L1, L2)) %
P;
write((ans % P + P) % P);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n, k, mod, ans, inv[N], s[N];
map<int, int> c;
int ksm(int a, int b) {
int r = 1;
while (b) {
if (b & 1) r = 1ll * r * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return r;
}
void pre(int l, int r, int k) {
if (k <= 1 || l == r) {
c[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
pre(l, mid, k - 1);
pre(mid + 1, r, k - 1);
}
int clc(int x, int y) {
int r = 1ll * x * y % mod;
for (int i = 1; i <= x; i++) r = (r - 2ll * (s[i + y] - s[i]) % mod) % mod;
return r;
}
int main() {
scanf("%d%d%d", &n, &k, &mod);
for (int i = 1; i <= 1e5; i++)
inv[i] = ksm(i, mod - 2), s[i] = (s[i - 1] + inv[i]) % mod;
pre(1, n, k);
for (map<int, int>::iterator i = c.begin(); i != c.end(); i++) {
ans = (ans + 1ll * i->first * (i->first - 1) % mod * inv[2] % mod *
i->second % mod) %
mod;
ans = (ans + 1ll * i->second * (i->second - 1) % mod * inv[2] % mod *
clc(i->first, i->first) % mod) %
mod;
}
for (map<int, int>::iterator i = c.begin(); i != c.end(); i++)
for (map<int, int>::iterator j = c.begin(); j != c.end(); j++)
if (i->first < j->first)
ans = (ans + 1ll * clc(i->first, j->first) * i->second % mod *
j->second % mod) %
mod;
printf("%lld\n", (1ll * ans * inv[2] % mod + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
char buf[1 << 12], *pp1 = buf, *pp2 = buf, nc;
int ny;
inline char gc() {
return pp1 == pp2 &&
(pp2 = (pp1 = buf) + fread(buf, 1, 1 << 12, stdin), pp1 == pp2)
? EOF
: *pp1++;
}
inline int read() {
int x = 0;
for (ny = 1; nc = gc(), (nc < 48 || nc > 57) && nc != EOF;)
if (nc == 45) ny = -1;
if (nc < 0) return nc;
for (x = nc - 48; nc = gc(), 47 < nc && nc < 58 && nc != EOF;
x = (x << 3) + (x << 1) + (nc ^ 48))
;
return x * ny;
}
int n, k, Mod, Fac[MAXN], iFac[MAXN], ans, t[MAXN], bel[MAXN], cnt, len[MAXN],
inv[MAXN], sum[MAXN];
inline int C(int n, int m) {
return n < 0 || m < 0 || n < m
? 0
: 1ll * Fac[n] * iFac[m] % Mod * iFac[n - m] % Mod;
}
inline int Fp(int x, int k) {
int ans = 1;
for (; k; k >>= 1, x = 1ll * x * x % Mod)
if (k & 1) ans = 1ll * ans * x % Mod;
return ans;
}
int t1, t2;
inline int calc(int len1, int len2) {
int ans = 0;
for (int i = (0); i <= (len1 - 1); i++)
ans = (ans + 1ll * i * (sum[i + len2 + 1] - sum[i + 1] + Mod) % Mod) % Mod;
return 1ll * ans * (Mod + 1 >> 1) % Mod;
}
inline void Div(int l, int r, int h) {
if (h == k || l == r) {
len[++cnt] = r - l + 1;
return;
}
int mid = l + r >> 1;
Div(l, mid, h + 1), Div(mid + 1, r, h + 1);
}
int main() {
n = read(), k = read() - 1, Mod = read(), Div(1, n, 0);
if (k > 20) return puts("0"), 0;
Fac[0] = 1;
for (int i = (1); i <= (n); i++) Fac[i] = 1ll * Fac[i - 1] * i % Mod;
iFac[n] = Fp(Fac[n], Mod - 2);
for (int i = (n); i >= (1); i--) iFac[i - 1] = 1ll * iFac[i] * i % Mod;
for (int i = (1); i <= (n); i++)
inv[i] = 1ll * iFac[i] * Fac[i - 1] % Mod,
sum[i] = (sum[i - 1] + inv[i]) % Mod;
if (k) {
for (int i = (1); i <= (cnt); i++)
if (len[i] == ((n >> k)))
t1++;
else
t2++;
ans = (calc(n >> k, n >> k) * (1ll * t1 * (t1 - 1) % Mod) +
(calc(n >> k, (n >> k) + 1) + calc((n >> k) + 1, n >> k)) *
(1ll * t1 * t2 % Mod) +
calc((n >> k) + 1, (n >> k) + 1) * (1ll * t2 * (t2 - 1) % Mod)) %
Mod;
}
for (int i = (1); i <= (cnt); i++)
ans =
(ans + (1ll * len[i] * (len[i] - 1) / 2 % Mod) * (Mod + 1 >> 1) % Mod) %
Mod;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
long long MOD, f[N];
long long qpow(long long x, long long y) {
long long z = 1;
while (y > 0) {
if (y % 2) z = z * x % MOD;
x = x * x % MOD;
y /= 2;
}
return z;
}
map<int, int> ma;
pair<int, int> a[10];
void dfs(int x, int k) {
if (k == 1 || x == 1) {
ma[x]++;
return;
}
dfs((x + 1) / 2, k - 1);
dfs(x / 2, k - 1);
}
int main() {
int n, k;
scanf("%d%d%lld", &n, &k, &MOD);
dfs(n, k);
for (int i = 1; i <= n * 2; i++)
f[i] = (f[i - 1] - qpow(i, MOD - 2) + qpow(2, MOD - 2) + MOD) % MOD;
int cnt = 0;
for (auto p : ma) {
a[++cnt] = p;
}
long long ans = 0;
for (int i = 1; i <= cnt; i++) {
ans += 1LL * a[i].second * a[i].first % MOD * (a[i].first - 1) % MOD *
qpow(4, MOD - 2) % MOD;
long long sum = 0;
for (int j = 1; j <= a[i].first; j++) {
sum = (sum + f[j + a[i].first] - f[j] + MOD) % MOD;
}
ans += sum * a[i].second % MOD * (a[i].second - 1) % MOD *
qpow(2, MOD - 2) % MOD;
}
if (cnt == 2) {
long long sum = 0;
for (int j = 1; j <= a[1].first; j++) {
sum = (sum + f[j + a[2].first] - f[j] + MOD) % MOD;
}
ans += sum * a[1].second % MOD * a[2].second % MOD;
}
printf("%lld", ans % MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 220000;
map<int, int> H;
int inv[N];
void build(int st, int en, int k) {
if (k == 1) {
int len = en - st + 1;
if (H.count(len))
H[len]++;
else
H[len] = 1;
return;
}
if (st == en) return;
int mid = st + en >> 1;
build(st, mid, k - 1);
build(mid + 1, en, k - 1);
}
int main() {
ios_base::sync_with_stdio(0);
int n, k, mod;
cin >> n >> k >> mod;
build(1, n, k);
if (!H.size() || (H.size() == 1 && H.begin()->first == 1)) {
cout << 0 << endl;
return 0;
}
inv[1] = 1;
for (int i = 2; i < N; i++)
inv[i] = (long long)inv[mod % i] * (mod - mod / i) % mod;
int ans = 0;
if (H.size() == 1) {
int len = H.begin()->first, cnt = H.begin()->second;
ans = (long long)len * (len - 1) % mod * inv[4] % mod * cnt % mod;
if (cnt > 1) {
int now = 0, nn = 0;
for (int sum = 2; sum <= len + len; sum++) {
int st = max(1, sum - len), en = min(len, sum - 1);
nn = en - st + 1;
now += (long long)((inv[2] - inv[sum] + mod) % mod) * nn % mod;
if (now >= mod) now -= mod;
}
now = (long long)now * cnt % mod * (cnt - 1) % mod * inv[2] % mod;
(ans += now) >= mod && (ans -= mod);
}
} else {
int len = H.begin()->first, cnt = H.begin()->second;
ans = (long long)len * (len - 1) % mod * inv[4] % mod * cnt % mod;
if (cnt > 1) {
int now = 0, nn = 0;
for (int sum = 2; sum <= len + len; sum++) {
int st = max(1, sum - len), en = min(len, sum - 1);
nn = en - st + 1;
now += (long long)((inv[2] - inv[sum] + mod) % mod) * nn % mod;
if (now >= mod) now -= mod;
}
now = (long long)now * cnt % mod * (cnt - 1) % mod * inv[2] % mod;
(ans += now) >= mod && (ans -= mod);
}
map<int, int>::iterator it = H.begin();
it++;
len = it->first, cnt = it->second;
ans += (long long)len * (len - 1) % mod * inv[4] % mod * cnt % mod;
if (ans >= mod) ans -= mod;
if (cnt > 1) {
int now = 0, nn = 0;
for (int sum = 2; sum <= len + len; sum++) {
int st = max(1, sum - len), en = min(len, sum - 1);
nn = en - st + 1;
now += (long long)((inv[2] - inv[sum] + mod) % mod) * nn % mod;
if (now >= mod) now -= mod;
}
now = (long long)now * cnt % mod * (cnt - 1) % mod * inv[2] % mod;
(ans += now) >= mod && (ans -= mod);
}
int len1 = H.begin()->first, len2 = it->first;
int cnt1 = H.begin()->second, cnt2 = it->second;
int now = 0, nn = 0;
for (int sum = 2; sum <= len1 + len2; sum++) {
int st = max(1, sum - len2), en = min(len1, sum - 1);
nn = en - st + 1;
now += (long long)((inv[2] - inv[sum] + mod) % mod) * nn % mod;
if (now >= mod) now -= mod;
}
now = (long long)now * cnt1 % mod * cnt2 % mod;
(ans += now) >= mod && (ans -= mod);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, mod, sum[200005], inv[200005], ans, s1, s2, num1, num2;
void split(long long l, long long r, long long dep) {
if (l > r) return;
if (dep == 1 || l == r) {
if (!s1) s1 = r - l + 1;
if (s1 == r - l + 1)
num1++;
else {
if (!s2) s2 = r - l + 1;
if (s2 == r - l + 1) num2++;
}
ans = (ans + (r - l + 1) * (r - l) % mod * inv[4]) % mod;
return;
}
long long mid = l + r >> 1;
split(l, mid, dep - 1);
split(mid + 1, r, dep - 1);
}
int main() {
scanf("%lld%lld%lld", &n, &m, &mod);
inv[0] = inv[1] = 1;
for (long long i = 2; i <= n + 10; i++)
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
for (long long i = 1; i <= n + 10; i++) sum[i] = (sum[i - 1] + inv[i]) % mod;
split(1, n, m);
if (s1 && s2) {
long long nw = 0;
for (long long i = 1; i <= s1; i++) {
nw = (nw + inv[2] * s1 - sum[i + s1] + sum[i] + mod) % mod;
}
ans = (ans + num1 * (num1 - 1) % mod * inv[2] % mod * nw) % mod;
nw = 0;
for (long long i = 1; i <= s1; i++) {
nw = (nw + inv[2] * s2 - sum[i + s2] + sum[i] + mod) % mod;
}
ans = (ans + num1 * num2 % mod * nw) % mod;
nw = 0;
for (long long i = 1; i <= s2; i++) {
nw = (nw + inv[2] * s2 - sum[i + s2] + sum[i] + mod) % mod;
}
ans = (ans + num2 * (num2 - 1) % mod * inv[2] % mod * nw) % mod;
} else {
long long nw = 0;
for (long long i = 1; i <= s1; i++) {
nw = (nw + inv[2] * s1 - sum[i + s1] + sum[i] + mod) % mod;
}
ans = (ans + num1 * (num1 - 1) % mod * inv[2] % mod * nw) % mod;
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
int mod, n, h;
inline void Add(int &a, int b) { a = a + b >= mod ? a + b - mod : a + b; }
int inv[maxn], sum[maxn];
inline int Qsum(int l, int r) { return (sum[r] - sum[l - 1] + mod) % mod; }
int cnt[maxn], S, L;
int ans;
inline void getblock(int l, int r, int dep) {
if (dep >= h || l == r) {
int size = r - l + 1;
cnt[size]++;
if (L == 0)
L = size;
else if (L != size)
S = size;
if (S > L) swap(S, L);
Add(ans, 1ll * size * (size - 1) % mod * inv[4] % mod);
return;
}
int mid = (l + r) >> 1;
getblock(l, mid, dep + 1);
getblock(mid + 1, r, dep + 1);
}
inline int getans(int size1, int size2) {
int ans = 1ll * size1 * size2 * inv[2] % mod;
for (int i = 1; i <= size1; i++) Add(ans, mod - Qsum(i + 1, i + size2));
return ans;
}
int main() {
scanf("%d%d%d", &n, &h, &mod);
inv[1] = 1;
for (int i = 2; i < maxn; i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = 1; i < maxn; i++) sum[i] = (sum[i - 1] + inv[i]) % mod;
getblock(1, n, 1);
if (S == 0) S = L, L = 0;
Add(ans,
1ll * getans(S, S) * cnt[S] % mod * (cnt[S] - 1) % mod * inv[2] % mod);
if (L)
Add(ans,
1ll * getans(L, L) * cnt[L] % mod * (cnt[L] - 1) % mod * inv[2] % mod);
if (L) Add(ans, 1ll * getans(S, L) * cnt[S] % mod * cnt[L] % mod);
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int inv[N], n, k, mo, ans;
map<int, int> mp;
void get(int n, int k) {
if (k == 1 || n == 1)
mp[n]++;
else
get(n / 2, k - 1), get(n - n / 2, k - 1);
}
int calc(int x, int y) {
int ans = 1ll * x * y % mo * (mo + 1) / 2 % mo;
for (int i = (int)(1); i <= (int)(y); i++)
ans = (ans + mo + 1ll * inv[i] - inv[i + x]) % mo;
return ans;
}
int main() {
scanf("%d%d%d", &n, &k, &mo);
inv[0] = inv[1] = 1;
for (int i = (int)(2); i <= (int)(n); i++)
inv[i] = 1ll * inv[mo % i] * (mo - mo / i) % mo;
for (int i = (int)(1); i <= (int)(n); i++)
inv[i] = (inv[i] + inv[i - 1]) % mo;
get(n, k);
for (auto a : mp) {
ans = (ans + 1ll * a.first * (a.first - 1) / 2 % mo * (mo + 1) / 2 % mo *
a.second) %
mo;
if (a.second >= 2)
ans = (ans + 1ll * a.second * (a.second - 1) / 2 % mo *
calc(a.first, a.first)) %
mo;
for (auto b : mp)
if (a.first < b.first)
ans = (ans + 1ll * calc(a.first, b.first) * a.second % mo * b.second) %
mo;
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAXN = (int)1e5 + 3;
const int infint = (int)1e9 + 3;
const long long inf = (long long)1e12;
int n, k, q;
vector<int> v;
int add(int a, int b) {
int c = a + b;
if (c >= q) c -= q;
if (c < 0) c += q;
return c;
}
int mul(int a, int b) {
int c = (1LL * a * b) % q;
return c;
}
int pwr(int a, int b) {
if (b == 0) return 1;
int c = pwr(a, b >> 1);
c = mul(c, c);
if (b & 1) c = mul(c, a);
return c;
}
int inv(int a) { return pwr(a, q - 2); }
void solve(int n, int k) {
if (k <= 1 || n == 1) {
v.push_back(n);
return;
}
solve(n / 2, k - 1);
solve((n + 1) / 2, k - 1);
}
int div2;
int inversion(int n) { return mul(n, mul(n - 1, inv(4))); }
int sum(int a, int b) {
if (a > b) return 0;
a--;
int s1 = mul(a, mul(a + 1, div2)), s2 = mul(b, mul(b + 1, div2));
s1 = add(s2, -s1);
s1 = add(s1, a - b);
return s1;
}
int ted[MAXN];
int f(int n1, int n2) {
int cur = 0;
for (int dem = 2; dem <= n1 + n2; dem++) {
int num = sum(max(1, dem - n2), min(n1, dem - 1));
cur = add(cur, mul(num, inv(dem)));
}
return mul(cur, div2);
}
int debug(int n1, int n2) {
int cur = 0;
for (int i = 1; i <= n1; i++)
for (int j = 1; j <= n2; j++) cur = add(cur, mul(i - 1, inv(i + j)));
return mul(cur, inv(2));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> q;
solve(n, k);
sort(v.begin(), v.end());
div2 = inv(2);
int ans = 0;
for (auto u : v) ans = add(ans, inversion(u)), ted[u]++;
vector<int> diff = v;
diff.resize(unique(diff.begin(), diff.end()) - diff.begin());
for (int i = 0; i < diff.size(); i++)
for (int j = 0; j < diff.size(); j++) {
int zarib;
if (i != j)
zarib = mul(ted[diff[i]], ted[diff[j]]);
else
zarib = mul(ted[diff[i]], ted[diff[j]] - 1);
ans = add(ans, mul(zarib, f(diff[i], diff[j])));
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD;
long long powmod(long long a, long long n) {
if (n == 0) return 1;
if (n % 2) return (a * powmod(a, n - 1)) % MOD;
long long c = powmod(a, n / 2);
return (c * c) % MOD;
}
long long inv(long long a) { return powmod(a, MOD - 2); }
long long fact[110000];
long long invfact[110000];
long long ncr(long long n, long long r) {
if (r < 0 || n < 0) return 0;
if (n < r) return 0;
long long a = fact[n];
a = (a * invfact[r]) % MOD;
a = (a * invfact[n - r]) % MOD;
return a;
}
long long get(long long a, long long b) {
long long ans = 0;
for (long long q = 2; q <= a + b; q++) {
long long f = min(a, q - 1) - max(1LL, q - b) + 1;
ans += f * inv(q);
ans %= MOD;
}
return ans;
}
int main() {
long long n, k, q;
cin >> n >> k >> q;
MOD = q;
map<long long, long long> r;
r[n] = 1;
for (int j = 1; j < k; j++) {
map<long long, long long> rr;
for (auto x : r) {
if (x.first == 1) {
rr[x.first] += x.second;
} else {
rr[x.first / 2] += x.second;
rr[(x.first + 1) / 2] += x.second;
}
}
r = rr;
if (rr.count(1) && rr[1] == n) break;
}
long long avg = n * (n - 1) / 2;
avg %= MOD;
avg = (avg * inv(2)) % MOD;
if (r.size() == 1) {
auto x = *r.begin();
long long freq = x.second;
long long g = x.first;
avg -= (freq * (freq - 1) / 2) % MOD * get(g, g);
avg %= MOD;
} else if (r.size() == 2) {
vector<pair<int, int> > x;
for (auto b : r) x.push_back(b);
long long freq0 = x[0].second;
long long freq1 = x[1].second;
avg -= (freq0 * (freq0 - 1) / 2) % MOD * get(x[0].first, x[0].first);
avg %= MOD;
avg -= (freq1 * (freq1 - 1) / 2) % MOD * get(x[1].first, x[1].first);
avg %= MOD;
avg -= (freq0 * freq1) % MOD * get(x[0].first, x[1].first);
avg %= MOD;
}
avg %= MOD;
if (avg < 0) avg += MOD;
cout << avg << '\n';
}
|
#include <bits/stdc++.h>
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = x * 10 + (c ^ 48), c = getchar();
}
using namespace std;
int n, K, P;
long long inv[201000], isum[201000];
inline void init() {
inv[1] = 1;
for (int i = 2; i <= max(n, 20); ++i)
inv[i] = ((P - inv[P % i] * (P / i)) % P + P) % P;
for (int i = 1; i <= max(n, 20); ++i) isum[i] = (isum[i - 1] + inv[i]) % P;
}
int tmp, cnt[201000];
void dfs_find(int L, int R, int nwk) {
if (nwk == 1) {
++cnt[R - L + 1];
tmp = R - L + 1;
return;
}
if (L == R) {
++cnt[1];
tmp = 1;
return;
}
int mid = (L + R) >> 1;
dfs_find(L, mid, nwk - 1);
dfs_find(mid + 1, R, nwk - 1);
}
inline long long sol(int t, int tt) {
long long res = 0;
for (int i = 1; i <= t; ++i) {
res += isum[i + tt] - isum[i];
}
return (res % P + P) % P;
}
int main() {
read(n), read(K), read(P);
init();
if (K >= 30) {
puts("0");
return 0;
}
dfs_find(1, n, K);
int jzp, zzz;
if (cnt[tmp - 1]) {
jzp = tmp, zzz = tmp - 1;
} else {
jzp = tmp + 1, zzz = tmp;
}
int inv2 = inv[2];
long long ans = sol(jzp, jzp) * cnt[jzp] % P * (cnt[jzp] - 1) % P * inv2 % P;
ans =
(ans + sol(zzz, zzz) * cnt[zzz] % P * (cnt[zzz] - 1) % P * inv2 % P) % P;
ans = (ans + sol(jzp, zzz) * cnt[jzp] % P * cnt[zzz] % P) % P;
ans = 1ll * n * (n - 1) % P * inv[4] % P - ans;
printf("%lld\n", (ans % P + P) % P);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, mod, c[N], inv[N], s[N];
void dfs(int d, int l, int r) {
if (d <= 1 || l == r) {
++c[r - l + 1];
return;
}
int m = (l + r) >> 1;
dfs(d - 1, l, m);
dfs(d - 1, m + 1, r);
}
int solve(int n, int m) {
int res = (long long)inv[2] * n % mod * m % mod;
for (int i = 1; i <= n; ++i) (res += s[i] - s[i + m]) %= mod;
return (res + mod) % mod;
}
int main() {
scanf("%d%d%d", &n, &k, &mod);
inv[1] = 1;
for (int i = 2; i <= max(4, n); ++i)
inv[i] = (mod - mod / i) * (long long)inv[mod % i] % mod;
for (int i = 1; i <= n; ++i) s[i] = (s[i - 1] + inv[i]) % mod;
dfs(k, 1, n);
int l = 0;
for (int i = 1; i <= n; ++i)
if (c[i]) {
l = i;
break;
}
int res =
((c[l] * (l - 1ll) + c[l + 1] * (l + 1ll)) % mod * l % mod * inv[4] +
c[l] * (c[l] - 1ll) % mod * inv[2] % mod * solve(l, l) +
(long long)c[l] * c[l + 1] % mod * solve(l, l + 1) +
c[l + 1] * (c[l + 1] - 1ll) % mod * inv[2] % mod * solve(l + 1, l + 1)) %
mod;
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const int N = 100005;
int ycl[N], tong[N], mod, inv;
void solve(int l, int r, int dep) {
if (l == r || dep == 1) {
tong[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
solve(l, mid, dep - 1);
solve(mid + 1, r, dep - 1);
}
long long get(long long len) { return len * (len - 1) / 2 % mod * inv % mod; }
inline long long ksm(long long a, int b) {
int ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
}
return ans;
}
int n, k;
long long get(long long a, long long b) {
if (a + b > n) return 0;
long long ans = 0;
for (int i = 1; i <= a; i++) {
ans = (ans + inv * b - ycl[i + b] + ycl[i]) % mod;
}
return (ans + mod) % mod;
}
int main() {
cin >> n >> k >> mod;
inv = (mod + 1) / 2;
for (int i = 1; i <= n; i++) ycl[i] = (ycl[i - 1] + ksm(i, mod - 2)) % mod;
solve(1, n, k);
for (int i = 1; i <= n; i++)
if (tong[i]) {
cout << (get(i) * tong[i] + get(i + 1) * tong[i + 1] +
get(i, i + 1) * tong[i] % mod * tong[i + 1] +
tong[i] * (tong[i] - 1) / 2 % mod * get(i, i) +
tong[i + 1] * (tong[i + 1] - 1) / 2 % mod * get(i + 1, i + 1)) %
mod
<< endl;
return 0;
}
}
|
#include <bits/stdc++.h>
const int MAXN = 100010;
int mod = 998244353;
void reduce(int& x) { x += x >> 31 & mod; }
int mul(int a, int b) { return (long long)a * b % mod; }
int pow(int a, int b, int res = 1) {
for (; b; b >>= 1, a = mul(a, a))
if (b & 1) res = mul(res, a);
return res;
}
void mma(int& x, int y, int z) { x = (x + (long long)y * z) % mod; }
int remod(long long x) {
x %= mod;
return x + (x >> 63 & mod);
}
std::map<int, int> hav;
void solve(int l, int r, int dep) {
if (l == r || dep <= 1) return (void)(++hav[r - l + 1]);
int mid = l + r >> 1;
solve(l, mid, dep - 1);
solve(mid + 1, r, dep - 1);
}
inline int calc1(int x) {
return (long long)pow(4, mod - 2, x * (x - 1ll) % mod);
}
inline int coef(std::pair<int, int> x, std::pair<int, int> y) {
int t = x.second;
if (x.first == y.first) return (long long)t * (t - 1) / 2 % mod;
return mul(t, y.second);
}
int n, K;
const int MAXS = MAXN << 1;
int inv[MAXS];
inline int calc2(int x, int y) {
int res = pow(2, mod - 2, mul(x, y));
for (int i = 1; i <= x; ++i)
reduce(res -= inv[i + y]), reduce(res += inv[i] - mod);
return res;
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> K >> mod;
inv[0] = inv[1] = 1;
for (int i = 2; i != MAXS; ++i) inv[i] = mul(inv[mod % i], mod - mod / i);
for (int i = 1; i != MAXS; ++i) reduce(inv[i] += inv[i - 1] - mod);
solve(1, n, K);
int ans = 0;
for (auto t : hav) mma(ans, t.second, calc1(t.first));
for (auto x : hav)
for (auto y : hav)
if (x.first <= y.first) mma(ans, coef(x, y), calc2(x.first, y.first));
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, k, P, inv[N], ans, f[2], c[2];
inline void upd(int &x, int y) { ((x += y) > P) && (x -= P); }
void sol(int l, int r, int k) {
if (!k || l == r) {
int len = r - l + 1;
c[len & 1] = len;
f[len & 1]++;
return;
}
int mid = (l + r) >> 1;
sol(l, mid, k - 1);
sol(mid + 1, r, k - 1);
}
inline int C0(int n) { return 1ll * n * (n - 1) / 2 % P * inv[2] % P; }
inline int C1(int n) {
int ans = 1ll * n * (1ll * n * inv[2] % P - inv[n + 1] + P) % P;
for (int i = (2); i <= (n); ++i)
upd(ans, P - 1ll * (i - 1) * (inv[i] + inv[2 * n + 2 - i]) % P);
return ans;
}
inline int C2(int x, int y) {
if (x < y) swap(x, y);
int ans = 1ll * x * y % P * inv[2] % P;
for (int i = (2); i <= (x); ++i)
upd(ans, P - 1ll * (i - 1) * (inv[i] + inv[x + y + 2 - i]) % P);
return ans;
}
int main() {
scanf("%d%d%d", &n, &k, &P);
inv[1] = 1;
for (int i = (2); i <= (2 * n); ++i)
inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
sol(1, n, k - 1);
for (int i = (0); i <= (1); ++i)
upd(ans, 1ll * f[i] * C0(c[i]) % P),
upd(ans, 1ll * f[i] * (f[i] - 1) / 2 % P * C1(c[i]) % P);
upd(ans, 1ll * f[0] * f[1] % P * C2(c[0], c[1]) % P);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, M, I2;
map<int, int> cnt;
long long inv[200050];
void divide(int m, int l, int r) {
if (m == 1 || l == r)
++cnt[r - l + 1];
else {
int mid = (l + r) >> 1;
divide(m - 1, l, mid);
divide(m - 1, mid + 1, r);
}
}
long long pw(long long a, long long k) {
long long ans = 1;
for (; k; k >>= 1) {
if (k & 1) ans = ans * a % M;
a = a * a % M;
}
return ans;
}
void init() {
scanf("%d%d%d", &n, &m, &M);
divide(m, 1, n);
I2 = (M + 1) >> 1;
for (int i = 1; i < 200050; ++i) inv[i] = (inv[i - 1] + pw(i, M - 2)) % M;
}
long long C2(int x) { return 1LL * x * (x - 1) / 2 % M; }
long long calc(int a, int b) {
long long ans = 1LL * a * b % M * I2 % M;
for (int i = 1; i <= a; ++i) ans += M - inv[i + b] + inv[i];
return ans % M;
}
void solve() {
int ans = 0;
for (auto p : cnt) ans += 1LL * C2(p.first) * I2 % M * p.second % M, ans %= M;
for (auto p : cnt) {
ans += calc(p.first, p.first) * C2(p.second) % M, ans %= M;
for (auto q : cnt)
if (p.first < q.first)
ans += calc(p.first, q.first) * (p.second * q.second % M) % M, ans %= M;
}
printf("%d\n", ans);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, q, A[N], num[2], Min, mod, ans, I4;
namespace {
int add(int x) { return (x >= mod) ? x - mod : x; }
int sub(int x) { return (x < 0) ? x + mod : x; }
void Add(int &x, int y) { x = add(x + y); }
void Sub(int &x, int y) { x = sub(x - y); }
int Pow(int x, int y = mod - 2) {
int res = 1;
for (; y; y >>= 1, x = 1LL * x * x % mod) {
if (y & 1) res = 1LL * res * x % mod;
}
return res;
}
} // namespace
vector<int> L;
void solve(int l, int r, int k) {
if (l > r) return;
if (k <= 1 || l == r) {
int Len = r - l + 1;
Min = min(Min, Len);
L.push_back(Len);
Add(ans, 1LL * Len * (Len - 1) % mod * I4 % mod);
return;
}
int mid = (l + r) >> 1;
solve(l, mid, k - 1);
solve(mid + 1, r, k - 1);
}
int inv[N];
int calc(int Sum, int x, int y) {
int L = max(Sum - y, 1), R = min(Sum - 1, x);
return max(R - L + 1, 0);
}
int main() {
cin >> n >> k >> mod;
Min = 1e9;
I4 = Pow(4);
inv[0] = 0;
for (int i = 1; i <= n * 2; ++i) inv[i] = Pow(i);
solve(1, n, k);
for (int i = 0; i < (int)L.size(); ++i) ++num[L[i] - Min];
for (int i = 1; i <= 2 * (Min + 1); ++i) {
int tot = 0;
Add(tot, 1LL * num[0] * (num[0] - 1) % mod * inv[2] % mod *
calc(i, Min, Min) % mod);
Add(tot, 1LL * num[1] * (num[1] - 1) % mod * inv[2] % mod *
calc(i, Min + 1, Min + 1) % mod);
Add(tot, 1LL * num[0] * num[1] % mod * calc(i, Min + 1, Min) % mod);
Add(ans, 1LL * tot * inv[2] % mod * sub(1 - 2LL * inv[i] % mod) % mod);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
std::map<long long, long long> mp;
long long p, inv[200005], sum[200005];
inline long long read() {
register long long x = 0, f = 1;
register char s = getchar();
while (s > '9' || s < '0') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
return x * f;
}
inline long long max(const long long &x, const long long &y) {
return x > y ? x : y;
}
inline void simulate(long long l, long long r, long long k) {
if (k == 1 || l == r) {
std::map<long long, long long>::iterator it = mp.find(r - l + 1);
if (it != mp.end())
++it->second;
else
mp.insert(std::make_pair(r - l + 1, 1));
return;
}
long long mid = l + r >> 1;
simulate(l, mid, k - 1);
simulate(mid + 1, r, k - 1);
}
inline long long calc(long long len1, long long len2) {
long long res = 0;
for (register long long i = 1; i <= len1; ++i) {
(res += (inv[2] * 1ll * len2 % p - (sum[i + len2] - sum[i]) % p) % p) %= p;
}
return res;
}
signed main() {
long long ans = 0;
long long n = read(), k = read();
p = read();
inv[1] = 1;
for (register long long i = 2; i <= max(n, 4); ++i)
inv[i] = (p - (p / i)) * 1ll * inv[p % i] % p;
for (register long long i = 1; i <= n; ++i)
sum[i] = (sum[i - 1] + inv[i]) % p;
simulate(1, n, k);
for (std::map<long long, long long>::iterator it = mp.begin(); it != mp.end();
++it) {
long long len = it->first, cnt = it->second;
(ans += cnt * ((len - 1) * 1ll * len % p) % p * inv[4] % p) %= p;
}
for (std::map<long long, long long>::iterator it1 = mp.begin();
it1 != mp.end(); ++it1) {
for (std::map<long long, long long>::iterator it2 = mp.begin();
it2 != mp.end(); ++it2) {
if (it1->first == it2->first) {
long long len = it1->first,
cnt = (it1->second - 1) * 1ll * (it1->second) / 2 % p;
(ans += cnt * 1ll * calc(len, len) % p) %= p;
} else if (it1->first < it2->first) {
long long cnt = (it2->second) * 1ll * (it1->second) % p;
(ans += cnt * 1ll * calc(it1->first, it2->first) % p) %= p;
}
}
}
printf("%lld\n", (ans + p) % p);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
uint MD;
struct ModInt {
using M = ModInt;
uint v;
ModInt() : v{0} {}
ModInt(ll _v) { set_v(_v % MD + MD); }
M& set_v(uint _v) {
v = (_v < MD) ? _v : _v - MD;
return *this;
}
explicit operator bool() const { return v != 0; }
M operator-() const { return M(0) - *this; }
M operator+(const M& r) const { return M().set_v(v + r.v); }
M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
M operator*(const M& r) const { return M().set_v(ull(v) * r.v % MD); }
M operator/(const M& r) const { return *this * r.inv(); }
M& operator+=(const M& r) { return *this = *this + r; }
M& operator-=(const M& r) { return *this = *this - r; }
M& operator*=(const M& r) { return *this = *this * r; }
M& operator/=(const M& r) { return *this = *this / r; }
M pow(ll n) const {
M x = *this, r = 1;
while (n) {
if (n & 1) r *= x;
x *= x;
n >>= 1;
}
return r;
}
M inv() const { return (*this).pow(MD - 2); }
friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};
using Mint = ModInt;
const int B = 200200;
V<Mint> fact(B), iFac(B), inv(B), inv_sm(B);
void first() {
fact[0] = Mint(1);
for (int i = 1; i < B; i++) fact[i] = fact[i - 1] * Mint(i);
for (int i = 0; i < B; i++) iFac[i] = fact[i].inv();
for (int i = 1; i < B; i++) inv[i] = Mint(i).inv();
for (int i = 1; i < B; i++) inv_sm[i] = inv_sm[i - 1] + inv[i];
}
Mint C(int n, int k) {
if (n < k || k < 0) return 0;
return fact[n] * iFac[k] * iFac[n - k];
}
map<int, int> mp;
void dfs(int l, int r, int h) {
if (l == r) {
mp[1]++;
return;
}
if (h <= 1) {
mp[r - l + 1]++;
return;
}
int md = (l + r) / 2;
dfs(l, md, h - 1);
dfs(md + 1, r, h - 1);
}
int main() {
int n, h;
cin >> n >> h >> MD;
first();
dfs(0, n - 1, h);
auto two = [&](int l1, int l2) {
Mint ans = 0;
for (int i = 1; i <= l1; i++) {
ans += Mint(i - 1) * (inv_sm[i + l2] - inv_sm[i]);
}
return ans / Mint(2);
};
using P = pair<int, int>;
V<P> ps;
for (auto p : mp) {
ps.push_back(p);
}
int k = int(ps.size());
Mint ans = 0;
for (int i = 0; i < k; i++) {
int c1, f1;
tie(c1, f1) = ps[i];
ans += Mint(f1) * Mint(c1) * Mint(c1 - 1) / Mint(4);
ans += Mint(f1) * Mint(f1 - 1) * two(c1, c1);
for (int j = i + 1; j < k; j++) {
int c2, f2;
tie(c2, f2) = ps[j];
ans += Mint(f1) * Mint(f2) * (two(c1, c2) + two(c2, c1));
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const long long Inf = 1e18;
const int N = 1e5 + 10;
int n, k, mod, inv[N], sinv[N], ans = 0;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
template <typename T>
bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
};
template <typename T>
bool chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
};
int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
void inc(int &a, int b) { a = (a + b >= mod ? a + b - mod : a + b); }
void dec(int &a, int b) { a = (a - b < 0 ? a - b + mod : a - b); }
vector<int> seg;
map<int, int> cnt;
void solve(int l, int r, int d) {
if (d <= 1 || l == r) {
seg.push_back(r - l + 1);
return;
}
int mid = (l + r) >> 1;
solve(l, mid, d - 1), solve(mid + 1, r, d - 1);
}
int calc(int a, int b) {
int ret = 1ll * a * b % mod;
for (int i = 1; i <= a; i++) dec(ret, 2ll * sub(sinv[i + b], sinv[i]) % mod);
return ret;
}
int main() {
n = gi(), k = gi(), mod = gi();
inv[1] = 1;
for (int i = 2; i <= max(n, 2); i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
sinv[1] = 1;
for (int i = 2; i <= n; i++) sinv[i] = add(sinv[i - 1], inv[i]);
solve(1, n, k);
for (auto i : seg) inc(ans, (1ll * i * (i - 1) / 2) % mod), ++cnt[i];
for (auto i : cnt)
if (i.second >= 2)
inc(ans, 1ll * calc(i.first, i.first) *
((1ll * i.second * (i.second - 1) / 2) % mod) % mod);
for (auto i : cnt)
for (auto j : cnt)
if (i.first < j.first)
inc(ans,
1ll * calc(i.first, j.first) * i.second % mod * j.second % mod);
ans = 1ll * ans * inv[2] % mod, cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inv[100010], s[100010], num[100010], n, k, MOD, ans;
void work(int l, int r, int h) {
if (h <= 1 || l == r) {
num[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
work(l, mid, h - 1);
work(mid + 1, r, h - 1);
}
int basic(int x) { return 1ll * x * (x - 1) % MOD * inv[4] % MOD; }
int cal(int x, int y) {
int tans = 0;
for (int i = 1; i <= x; i++)
tans = (0ll + tans + s[i + y] - s[i] + MOD) % MOD;
return (1ll * x * y % MOD * inv[2] - tans + MOD) % MOD;
}
int mypow(int x, int n) {
int tans = 1;
for (; n; n >>= 1, x = 1ll * x * x % MOD)
if (n & 1) tans = 1ll * tans * x % MOD;
return tans;
}
int main() {
scanf("%d%d%d", &n, &k, &MOD);
inv[4] = mypow(4, MOD - 2);
for (int i = 1; i <= n; i++) inv[i] = mypow(i, MOD - 2);
for (int i = 1; i <= n; i++) s[i] = (s[i - 1] + inv[i]) % MOD;
work(1, n, k);
for (int i = 1; i <= n; i++)
if (num[i]) {
ans = (ans + 1ll * num[i] * basic(i)) % MOD;
ans =
(ans + 1ll * num[i] * (num[i] - 1) % MOD * inv[2] % MOD * cal(i, i)) %
MOD;
if (num[i + 1]) {
ans = (ans + 1ll * num[i + 1] * basic(i + 1)) % MOD;
ans = (ans + 1ll * num[i + 1] * (num[i + 1] - 1) % MOD * inv[2] % MOD *
cal(i + 1, i + 1)) %
MOD;
ans = (ans + 1ll * num[i] * num[i + 1] % MOD * cal(i, i + 1)) % MOD;
}
break;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 1e5 + 5;
int n, k, q;
map<int, int> cnt;
long long ans;
long long js[N], inv[N];
int mo;
void build(int l, int r, int h) {
if (l == r || h <= 1) {
cnt[r - l + 1]++;
return;
}
int mid = (l + r) / 2;
build(l, mid, h - 1);
build(mid + 1, r, h - 1);
}
long long calc(int la, int lb) {
long long ret = inv[2] * la % mo * lb % mo;
for (int i = 2; i <= la + lb; i++) {
int l = 1, r = la;
l = max(l, i - lb);
r = min(r, i - 1);
ret = (ret + mo - 1ll * (r - l + 1) * inv[i] % mo) % mo;
}
return ret;
}
int main() {
n = get();
k = get();
mo = q = get();
build(1, n, k);
inv[0] = inv[1] = 1;
for (int i = 2; i <= 1e5; i++) inv[i] = 1ll * (q - q / i) * inv[q % i] % q;
for (map<int, int>::iterator h = cnt.begin(); h != cnt.end(); h++) {
int s = (*h).first, c = (*h).second;
ans = (ans + 1ll * s * (s - 1) * inv[4] % q * c % q) % q;
map<int, int>::iterator p = h;
ans = (ans + inv[2] * c * (c - 1) % mo * calc(s, s) % mo) % mo;
p++;
for (; p != cnt.end(); p++)
ans = (ans + 1ll * c * (*p).second % mo * calc(s, (*p).first)) % mo;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int n, k, q;
void dfs(int l, int r, int dep) {
if (dep <= 1 || l == r) {
mp[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
dfs(l, mid, dep - 1);
dfs(mid + 1, r, dep - 1);
}
int ADD(int x, int y) { return (x += y) >= q ? x - q : x; }
int SUB(int x, int y) { return (x -= y) < 0 ? x + q : x; }
int MUL(int x, int y) { return (long long)x * y % q; }
int HALF(int x) { return x & 1 ? (x + q >> 1) : (x >> 1); }
const int N = 100010;
int inv[N], invs[N];
int calc(int x, int y) {
int ret = MUL(x, y);
for (int i = 1; i <= x; ++i) {
ret = SUB(ret, MUL(SUB(invs[i + y], invs[i]), 2));
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &k, &q);
dfs(1, n, k);
inv[0] = inv[1] = 1;
invs[0] = invs[1] = 1;
for (int i = 2; i <= n; ++i) {
inv[i] = MUL(inv[q % i], q - q / i);
invs[i] = ADD(invs[i - 1], inv[i]);
}
int ans = 0;
for (auto i : mp)
for (auto j : mp)
if (i.first <= j.first) {
if (i.first == j.first) {
int ret = calc(i.first, i.first);
ans = ADD(ans, MUL(ret, HALF(MUL(i.second, i.second - 1))));
ans = ADD(ans, MUL(i.second, HALF(MUL(i.first, i.first - 1))));
} else {
int ret = calc(i.first, j.first);
ans = ADD(ans, MUL(ret, MUL(i.second, j.second)));
}
}
cout << HALF(ans);
}
|
#include <bits/stdc++.h>
const int MAXN = 1e5 + 20;
int n, k, M;
int inv[MAXN], pre_inv[MAXN];
void math_pre() {
inv[1] = 1;
for (int i = 2; i <= ((n < 4) ? 4 : n); ++i)
inv[i] = 1ll * (M - M / i) * inv[M % i] % M;
for (int i = 1; i <= n; ++i) pre_inv[i] = (pre_inv[i - 1] + inv[i]) % M;
}
struct map {
static const int MAXMap = 2;
int tot;
struct pad {
int key, val;
pad() {}
pad(const int &KEY, const int &VAL) : key(KEY), val(VAL) {}
} node[MAXMap + 1];
map() { tot = 0; }
pad *find(const int &key) {
pad *ret = node;
while (ret - node < tot && ret->key != key) ++ret;
return ret;
}
void insert(const pad &new_element) { node[tot++] = new_element; }
pad *begin() { return &node[0]; }
pad *end() { return &node[tot]; }
} Map;
void solve(const int &l, const int &r, const int &h) {
if (l >= r || h <= 1) {
int len = r - l + 1;
map::pad *it = Map.find(len);
if (it == Map.end())
Map.insert(map::pad(len, 1));
else
++it->val;
return;
}
int mid = (l + r) >> 1;
solve(l, mid, h - 1), solve(mid + 1, r, h - 1);
}
int calc(const int &len1, const int &len2) {
int ret = 0;
for (int i = 1; i <= len1; ++i)
ret = ((ret + 1ll * inv[2] * len2 % M -
(pre_inv[i + len2] - pre_inv[i + 1 - 1])) %
M +
M) %
M;
return ret;
}
int main() {
scanf("%d%d%d", &n, &k, &M);
math_pre();
solve(1, n, k);
int ans = 0;
for (map::pad *it = Map.begin(); it != Map.end(); ++it) {
int len = it->key, cnt = it->val;
ans = (ans + 1ll * cnt * len % M * (len - 1) % M * inv[4] % M) % M;
}
for (map::pad *it1 = Map.begin(); it1 != Map.end(); ++it1)
for (map::pad *it2 = Map.begin(); it2 != Map.end(); ++it2) {
if (it1 == it2) {
int len = it1->key, cnt = 1ll * (0 + (it1->val - 1)) * it1->val / 2 % M;
ans = (ans + 1ll * cnt * calc(len, len) % M) % M;
} else if (it1->key < it2->key) {
int len1 = it1->key, len2 = it2->key,
cnt = 1ll * it1->val * it2->val % M;
ans = (ans + 1ll * cnt * calc(len1, len2) % M) % M;
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, p, inv[N], res[2][2];
vector<int> segs, tmp;
void dfs(int l, int r, int k) {
if (l == r || k == 1) {
segs.emplace_back(r - l + 1);
tmp.emplace_back(r - l + 1);
return;
}
int mid = (l + r) >> 1;
dfs(l, mid, k - 1);
dfs(mid + 1, r, k - 1);
}
int calc(int a, int b) {
int ans = 0;
for (int i = 3; i <= a + b; ++i) {
int inf = max(i - b, 1), suf = min(a, i - 1);
assert(inf <= suf);
ans = (ans + 1ll * (suf - inf + 1) * (i - 2) % p * inv[i]) % p;
}
return 1ll * ans * inv[2] % p;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
inv[0] = inv[1] = 1;
for (int i = 2; i < N; ++i) inv[i] = 1ll * (p - p / i) * inv[p % i] % p;
dfs(1, n, k);
sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
int ans = 0, m = tmp.size();
assert(m <= 2);
for (int i = 0; i < m; ++i)
for (int j = 0; j < m; ++j) res[i][j] = calc(tmp[i], tmp[j]);
int cnt[2] = {0, 0};
for (int i = int(segs.size()) - 1; ~i; --i) {
int cur = segs[i], ind = (cur != tmp[0]) ? 1 : 0;
ans = (ans + 1ll * cur * (cur - 1) % p * inv[4]) % p;
for (int j = 0; j < m; ++j) ans = (ans + 1ll * res[ind][j] * cnt[j]) % p;
++cnt[ind];
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int Maxn = 100000;
int n, k, Mod;
int sum[Maxn + 5];
int inv[Maxn + 5];
void init() {
inv[1] = 1;
for (int i = 2; i <= Maxn; i++) {
inv[i] = 1ll * (Mod - Mod / i) * inv[Mod % i] % Mod;
}
for (int i = 1; i <= Maxn; i++) {
sum[i] = (sum[i - 1] + inv[i]) % Mod;
}
}
int cnt[Maxn + 5];
void merge_sort(int l, int r, int k) {
if (k == 1 || l == r) {
cnt[r - l + 1]++;
return;
}
int mid = (l + r) >> 1;
merge_sort(l, mid, k - 1);
merge_sort(mid + 1, r, k - 1);
}
int calc(int len_1, int len_2) {
int ans = 0;
for (int i = 1; i <= len_1; i++) {
ans = (ans + 1ll * len_2 * inv[2]) % Mod;
int now = (sum[i + len_2] - sum[i] + Mod) % Mod;
ans = (ans - now + Mod) % Mod;
}
return ans;
}
int lis[Maxn + 5], lis_len;
int solve() {
int ans = 0;
for (int i = 1; i <= n; i++) {
if (cnt[i]) {
lis[++lis_len] = i;
ans = (ans + 1ll * cnt[i] * i * (i - 1) % Mod * inv[4]) % Mod;
if (cnt[i] > 1) {
ans = (ans +
1ll * cnt[i] * (cnt[i] - 1) % Mod * inv[2] % Mod * calc(i, i)) %
Mod;
}
}
}
for (int i = 1; i <= lis_len; i++) {
for (int j = i + 1; j <= lis_len; j++) {
ans =
(ans + 1ll * cnt[lis[i]] * cnt[lis[j]] % Mod * calc(lis[i], lis[j])) %
Mod;
}
}
return ans;
}
int main() {
scanf("%d%d%d", &n, &k, &Mod);
init();
merge_sort(1, n, k);
printf("%d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T>
void dprintln(const T &t) {
cout << t << endl;
}
template <typename T, typename... Args>
void dprintln(const T &t, const Args &...rest) {
cout << t << ' ';
dprintln(rest...);
}
template <typename T>
void println(const T &t) {
cout << t << '\n';
}
template <typename T, typename... Args>
void println(const T &t, const Args &...rest) {
cout << t << ' ';
println(rest...);
}
template <typename T>
void print(const T &t) {
cout << t << ' ';
}
template <typename T, typename... Args>
void print(const T &t, const Args &...rest) {
cout << t << ' ';
print(rest...);
}
template <class T>
void scan(T &t) {
cin >> t;
}
template <class T, class... Args>
void scan(T &a, Args &...rest) {
cin >> a;
scan(rest...);
}
using ll = long long;
using vl = vector<ll>;
using vi = vector<int>;
using pii = pair<int, int>;
using vb = vector<bool>;
using vpii = vector<pii>;
auto bet = [](const ll x, const ll y, const ll i) { return x <= i && i <= y; };
template <typename T1, typename T2>
T1 ceil(T1 x, T2 y) {
return (x + y - 1) / y;
}
inline int h_bit(unsigned int x) { return 31 - __builtin_clz(x); }
inline int h_bitll(unsigned long long x) { return 63 - __builtin_clzll(x); }
template <typename T>
struct bit {
vector<T> a;
explicit bit(int n, int v = 0) {
a.resize(n + 1);
if (v != 0) {
for (int i = 1; i <= n; ++i) a[i] = v;
}
}
T sum(T x) {
T res = 0;
while (x) {
res += a[x];
x -= x & -x;
}
return res;
}
T sum(int l, int r) {
if (l > r) return 0;
return sum(r) - sum(l - 1);
}
void add(int x, T v) {
while (x < a.size()) {
a[x] += v;
x += x & -x;
}
}
void clear() { fill(a.begin(), a.end(), 0); }
};
vi get_prime(int n) {
vi minp(n + 1), p;
for (int i = 2; i <= n; i++) {
if (!minp[i]) {
minp[i] = i;
p.push_back(i);
}
for (auto &x : p) {
if (x <= minp[i] && x * i <= n)
minp[x * i] = x;
else
break;
}
}
return p;
}
const int mod = 998244353;
inline void add_mod(ll &x, const ll &y) {
x += y;
if (x >= mod) x -= mod;
}
inline ll submod(ll x, ll y) { return x >= y ? x - y : x - y + mod; }
void sub_mod(ll &x, const ll y) {
x -= y;
if (x < 0) x += mod;
}
template <typename T>
using vv = vector<vector<T>>;
template <typename T1, typename T2 = T1>
using vp = vector<pair<T1, T2>>;
template <typename T, int n>
using va = vector<array<T, n>>;
struct UF {
vi par;
explicit UF(int n) {
par.assign(n + 1, 0);
for (int i = (1); i < (n + 1); ++i) par[i] = i;
}
int find(int x) { return x == par[x] ? x : par[x] = find(par[x]); }
void unite(int x, int y) { par[find(x)] = find(y); }
};
vi get_popcnt(int n) {
vi res(n + 1);
for (int i = (0); i < (n); ++i) {
if (i * 2 <= n) res[i * 2] = res[i];
if ((i & 1) == 0) res[i + 1] = res[i] + 1;
}
return res;
}
const int N = 30, M = 1005;
int l1 = 0, l2 = 0;
int c1, c2;
void dfs(int a, int h) {
if (a == 0) return;
if (h == 1 || a == 1) {
if (l1 == 0) {
l1 = a;
++c1;
} else if (a == l1)
++c1;
else {
if (l2 == 0) l2 = a;
++c2;
}
return;
}
dfs(a / 2, h - 1), dfs(a - a / 2, h - 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, q;
scan(n, k, q);
vl inv(max(4, n) + 1);
inv[1] = 1;
for (int i = (2); i < (max(4, n) + 1); ++i)
inv[i] = q - ll(q / i) * inv[q % i] % q;
dfs(n, k);
ll ans = 0;
if (c1 > 0) ans += 1LL * c1 * (l1 - 1) % q * l1 % q * inv[4] % q;
if (c2 > 0) ans += 1LL * c2 * (l2 - 1) % q * l2 % q * inv[4] % q;
if (c1 > 1) {
ll sum = 0;
for (int i = (2); i < (2 * l1 + 1); ++i) {
int mi = max(1, i - l1);
int ma = min(l1, i - 1);
sum += 1LL * (ma - mi + 1) * (inv[2] - inv[i] + q) % q;
}
ans += 1LL * c1 * (c1 - 1) / 2 % q * sum % q;
}
if (c2 > 1) {
ll sum = 0;
for (int i = (2); i < (2 * l2 + 1); ++i) {
int mi = max(1, i - l2);
int ma = min(l2, i - 1);
sum += 1LL * (ma - mi + 1) * (inv[2] - inv[i] + q) % q;
}
ans += 1LL * c2 * (c2 - 1) / 2 % q * sum % q;
}
if (c1 > 0 && c2 > 0) {
ll sum = 0;
for (int i = (2); i < (l1 + l2 + 1); ++i) {
int mi = max(1, i - l2);
int ma = min(l1, i - 1);
sum += 1LL * (ma - mi + 1) * (inv[2] - inv[i] + q) % q;
}
ans += 1LL * c1 * c2 % q * sum % q;
}
println(ans % q);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int i, j, n, k, mo, rev[N], a[N], num, d[N], s[N], l, r;
long long ans;
void work(int l, int r, int k) {
if (k <= 1 || l == r) {
a[++num] = r - l + 1;
return;
}
int m = (l + r) >> 1;
work(l, m, k - 1), work(m + 1, r, k - 1);
}
int calc(int a, int b) {
int i;
long long S = (long long)a * b % mo;
for (i = 1; i <= a; i++) S -= s[i + b] - s[i];
return S % mo;
}
int main() {
scanf("%d%d%d", &n, &k, &mo);
rev[0] = rev[1] = 1;
for (i = 2; i <= n; i++) rev[i] = (long long)(mo - mo / i) * rev[mo % i] % mo;
for (i = 1; i <= n; i++) s[i] = (s[i - 1] + rev[i]) % mo;
for (i = 1; i <= n; i++) s[i] <<= 1;
work(1, n, k);
for (i = 1; i <= num; i++) d[a[i]]++;
for (i = 1; i <= n; i++)
if (d[i]) l = !l ? i : l, r = i;
for (i = l; i <= r; i++)
ans += ((long long)i * (i - 1) / 2 % mo * d[i] +
(long long)d[i] * (d[i] - 1) / 2 % mo * calc(i, i)) %
mo;
if (l != r) ans += (long long)d[l] * d[r] % mo * calc(l, r) % mo;
ans = ans % mo * (mo + 1) / 2 % mo;
printf("%lld\n", (ans + mo) % mo);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, k, mod, q1, q2, ans;
int inv[N], cnt[N];
void solve(int l, int r, int d) {
if (d == 1 || l == r) {
int len = r - l + 1;
q1&& q1 != len ? q2 = len : q1 = len;
ans = (ans + 1ll * len * (len - 1) / 2 % mod * (mod + 1) / 2) % mod;
cnt[len]++;
return;
}
int mid = (l + r) / 2;
solve(l, mid, d - 1);
solve(mid + 1, r, d - 1);
}
int main() {
scanf("%d%d%d", &n, &k, &mod);
inv[0] = inv[1] = 1;
for (int i = (int)(2); i <= (int)(N - 1); i++)
inv[i] = 1ll * inv[mod % i] * (mod - mod / i) % mod;
for (int i = (int)(1); i <= (int)(N - 1); i++)
inv[i] = (inv[i] + inv[i - 1]) % mod;
solve(1, n, k);
for (int i = (int)(1); i <= (int)(q1); i++) {
int val = 1ll * (i - 1) * cnt[q1] % mod * (mod + 1) / 2 % mod;
ans =
(ans + 1ll * (cnt[q1] - 1) * (inv[i + q1] + mod - inv[i]) % mod * val) %
mod;
ans =
(ans + 1ll * (cnt[q2] - 0) * (inv[i + q2] + mod - inv[i]) % mod * val) %
mod;
}
for (int i = (int)(1); i <= (int)(q2); i++) {
int val = 1ll * (i - 1) * cnt[q2] % mod * (mod + 1) / 2 % mod;
ans =
(ans + 1ll * (cnt[q1] - 0) * (inv[i + q1] + mod - inv[i]) % mod * val) %
mod;
ans =
(ans + 1ll * (cnt[q2] - 1) * (inv[i + q2] + mod - inv[i]) % mod * val) %
mod;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
long long n, k, gs, ans, mod, len[N], jc[N], inv[N], sum[N], ycl[2005][2005];
inline long long read() {
long long res = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
res = res * 10 + c - 48;
c = getchar();
}
return res * f;
}
void build(long long l, long long r, long long h) {
if (h <= 1 || l == r) {
len[++gs] = r - l + 1;
return;
}
long long mid = (l + r) / 2;
build(l, mid, h - 1);
build(mid + 1, r, h - 1);
}
long long C(long long n, long long m) {
if (n < 0 || m < 0 || n < m) return 0;
return jc[n] * inv[m] % mod * inv[n - m] % mod;
}
signed main() {
n = read();
k = read();
mod = read();
jc[0] = jc[1] = inv[0] = inv[1] = 1;
for (long long i = 2; i <= 100000; i++) jc[i] = jc[i - 1] * i % mod;
for (long long i = 2; i <= 100000; i++)
inv[i] = (mod - mod / i) * inv[mod % i] % mod;
build(1, n, k);
for (long long i = 1; i <= gs; i++) {
ans = (ans + len[i] * (len[i] - 1) % mod * inv[4] % mod) % mod;
}
sort(len + 1, len + gs + 1);
long long x = 0;
for (long long i = 1; i <= gs; i++)
if (len[i] == len[i - 1])
sum[x]++;
else {
len[++x] = len[i];
sum[x] = 1;
}
gs = x;
for (long long i = 1; i <= gs; i++)
for (long long j = 1; j <= i; j++) {
long long res = 0;
res = len[i] * len[j] % mod * inv[2] % mod;
for (long long a = 1; a <= len[i] + len[j]; a++) {
long long l = max(1ll, a - len[j]), r = min(a - 1, len[i]);
res = (res - inv[a] * (r - l + 1) % mod + mod) % mod;
}
if (i == j)
ans = (ans +
res * sum[i] % mod * (sum[i] - 1 + mod) % mod * inv[2] % mod) %
mod;
else
ans = (ans + res * sum[i] % mod * sum[j] % mod) % mod;
}
cout << ans % mod;
return 0;
}
|
#include <bits/stdc++.h>
long long n, k, q, t1, t2, cnt1, cnt2, inv4, inv2, inv[200001];
long long ans;
inline long long mul(const long long &a, const long long &b) {
return 1ll * a * b % q;
}
inline long long qsm(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = mul(ans, a);
a = mul(a, a);
b >>= 1;
}
return ans;
}
void merge(long long l, long long r, long long k) {
if (l < r) {
if (k <= 1) {
if (t1 == r - l + 1)
++cnt1;
else if (t2 == r - l + 1)
++cnt2;
else if (!t1)
t1 = r - l + 1, cnt1 = 1;
else
t2 = r - l + 1, cnt2 = 1;
(ans += mul(mul(r - l + 1, r - l), inv4)) %= q;
return;
}
merge(l, (l + r) >> 1, k - 1);
merge(((l + r) >> 1) + 1, r, k - 1);
} else {
{
if (t1 == r - l + 1)
++cnt1;
else if (t2 == r - l + 1)
++cnt2;
else if (!t1)
t1 = r - l + 1, cnt1 = 1;
else
t2 = r - l + 1, cnt2 = 1;
(ans += mul(mul(r - l + 1, r - l), inv4)) %= q;
return;
}
}
}
long long getans(long long n, long long m) {
long long ans = 0;
(ans += mul(inv2, mul(n, m))) %= q;
for (long long i = 1; i <= n; i++) (ans += (inv[i] - inv[i + m] + q)) %= q;
return ans;
}
signed main() {
scanf("%I64d%I64d%I64d", &n, &k, &q);
inv4 = qsm(4, q - 2);
inv2 = (q + 1) >> 1;
inv[0] = inv[1] = 1;
for (long long i = 2; i <= n; i++) inv[i] = mul(q - q / i, inv[q % i]);
for (long long i = 1; i <= n; i++) (inv[i] += inv[i - 1]) %= q;
merge(1, n, k);
(ans += mul(getans(t1, t1), mul(mul(cnt1, cnt1 - 1), inv2))) %= q;
(ans += mul(getans(t2, t2), mul(mul(cnt2, cnt2 - 1), inv2))) %= q;
(ans += mul(getans(t1, t2), mul(cnt1, cnt2))) %= q;
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
void Freopen() {
freopen(
"title"
".in",
"r", stdin);
freopen(
"title"
".out",
"w", stdout);
}
int read() {
int g = 0, f = 1;
char ch = getchar();
while (ch < '0' || '9' < ch) {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
g = g * 10 + ch - '0';
ch = getchar();
}
return g * f;
}
const int N = 1e5 + 5;
int n, k, mod, l1, l2, c1, c2, inv[N], s[N];
int ksm(int x, int y) {
int re = 1;
for (; y; y >>= 1, x = 1ll * x * x % mod)
if (y & 1) re = 1ll * re * x % mod;
return re;
}
void solve(int l, int r, int h) {
if (h == k || l == r) {
if (!l1)
l1 = r - l + 1, c1++;
else if (r - l + 1 == l1)
c1++;
else if (!l2)
l2 = r - l + 1, c2++;
else
c2++;
return void();
}
int mid = l + r >> 1;
solve(l, mid, h + 1), solve(mid + 1, r, h + 1);
}
int calc(int l1, int l2) {
if (!l1 || !l2) return 0;
int re = 1ll * l1 * l2 % mod * inv[2] % mod;
for (int i = (1); i <= (l1); i++)
re = (1ll * re + mod - (s[i + l2] + mod - s[i]) % mod) % mod;
return re;
}
signed main() {
n = read(), k = read(), mod = read();
inv[1] = 1;
for (int i = (2); i <= ((int)1e5); i++)
inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
for (int i = (1); i <= (n); i++) s[i] = (s[i - 1] + inv[i]) % mod;
solve(1, n, 1);
int ans = (1ll * c1 * l1 % mod * (l1 - 1) % mod * inv[4] % mod +
1ll * c2 * l2 % mod * (l2 - 1) % mod * inv[4] % mod) %
mod;
ans = (ans + 1ll * c1 * (c1 - 1) % mod * inv[2] % mod * calc(l1, l1) % mod) %
mod;
ans = (ans + 1ll * c2 * (c2 - 1) % mod * inv[2] % mod * calc(l2, l2) % mod) %
mod;
ans = (ans + 1ll * c1 * c2 % mod * calc(l1, l2) % mod) % mod;
return cout << ans, signed();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K, P, inv[200003], cnt[200003], mn = 1e9, ans;
void solve(int l, int r, int dep) {
if (dep == 1 || l == r) {
++cnt[r - l + 1], mn = min(mn, r - l + 1);
return;
}
int mid = (l + r) >> 1;
solve(l, mid, dep - 1), solve(mid + 1, r, dep - 1);
}
int calc(int A, int B) {
int res = 0;
for (int i = 2; i <= A + B; ++i)
res = (res + 1ll * (min(i - 1, A) - max(1, i - B) + 1) * (i - 2) % P *
inv[i] % P) %
P;
return 1ll * res * inv[2] % P;
}
int main() {
cin >> n >> K >> P;
solve(1, n, K);
inv[1] = 1;
for (int i = 2; i <= 2 * n; ++i) inv[i] = P - 1ll * P / i * inv[P % i] % P;
ans = 1ll * inv[2] *
(1ll * (1ll * (mn) * ((mn)-1) / 2 % P) * cnt[mn] % P +
1ll * (1ll * (mn + 1) * ((mn + 1) - 1) / 2 % P) * cnt[mn + 1] % P) %
P;
ans = (ans +
1ll * (1ll * (cnt[mn]) * ((cnt[mn]) - 1) / 2 % P) * calc(mn, mn) % P) %
P;
ans = (ans + 1ll * (1ll * (cnt[mn + 1]) * ((cnt[mn + 1]) - 1) / 2 % P) *
calc(mn + 1, mn + 1) % P) %
P;
ans = (ans + 1ll * cnt[mn] * cnt[mn + 1] % P * calc(mn, mn + 1) % P) % P;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "-O3"
using namespace std;
long long MOD;
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
while (!(b & 1)) b >>= 1, a = (a * a) % MOD;
ans = (ans * a) % MOD, --b;
}
return ans;
}
map<int, int> mm;
void run(int n, int k) {
if (n <= 0) return;
if (n == 1) {
++mm[1];
return;
}
if (k <= 1) {
++mm[n];
return;
}
int n2 = n / 2;
run(n2, k - 1);
run(n - n2, k - 1);
}
long long n, k;
long long get(int a, int b) {
if (a > b) swap(a, b);
long long ans = 0;
for (int i = 0; i <= (a - 1) + (b - 1); ++i) {
long long cnt = 0;
if (i < a)
cnt = i + 1;
else if (i < b)
cnt = a;
else
cnt = i + 1 - (i + 1 - a) - (i + 1 - b);
ans = (ans + cnt * pw(i + 2, MOD - 2)) % MOD;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k >> MOD;
run(n, k);
vector<pair<int, long long>> vv;
for (auto x : mm) vv.push_back(x);
long long ans = n * (n - 1) * pw(4, MOD - 2);
long long sum = 0;
for (int i = 0; i < vv.size(); ++i) {
long long go = get(vv[i].first, vv[i].first);
sum = (sum + go * vv[i].second % MOD * (vv[i].second - 1) % MOD *
pw(2, MOD - 2)) %
MOD;
for (int j = i + 1; j < vv.size(); ++j)
sum = (sum + get(vv[i].first, vv[j].first) * vv[i].second % MOD *
vv[j].second) %
MOD;
}
ans = (ans - sum + MOD) % MOD;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
char ch;
int fu = 1;
while ((ch = getchar()) <= 32)
;
x = 0;
if (ch == '-')
fu = -1;
else
x = ch - 48;
while ((ch = getchar()) > 32) x = x * 10 + ch - 48;
x *= fu;
}
void read(long long &x) {
char ch;
int fu = 1;
while ((ch = getchar()) <= 32)
;
x = 0;
if (ch == '-')
fu = -1;
else
x = ch - 48;
while ((ch = getchar()) > 32) x = x * 10 + ch - 48;
x *= fu;
}
const double pi = acos(-1);
void upmax(int &a, int b) {
if (a < b) a = b;
}
void upmin(int &a, int b) {
if (a > b) a = b;
}
const int N = 200220, inf = 1000000000;
int n, k, p, ans;
int a[N], inv[N], s[N];
void get(int n, int k) {
if (k == 1 || n == 1) {
a[n]++;
return;
}
get(n / 2, k - 1);
get((n + 1) / 2, k - 1);
}
int calc(int n, int m) {
int res = 1LL * n * m % p * inv[2] % p;
for (int i = 1; i <= m; i++) res = (0LL + res - s[n + i] + s[i]) % p;
return res;
}
int main() {
scanf("%d%d%d", &n, &k, &p);
inv[1] = 1;
for (int i = 2; i <= max(n * 2, 4); i++)
inv[i] = -1LL * inv[p % i] * (p / i) % p;
for (int i = 1; i <= n * 2; i++) s[i] = (s[i - 1] + inv[i]) % p;
get(n, k);
for (int i = 1; i <= n; i++)
if (a[i]) {
ans = (ans + 1LL * i * (i - 1) % p * inv[4] % p * a[i]) % p;
}
ans = (ans + p) % p;
for (int i = 1; i <= n; i++)
if (a[i])
ans = (ans + 1LL * a[i] * (a[i] - 1) % p * inv[2] % p * calc(i, i)) % p;
for (int i = 1; i <= n; i++)
if (a[i])
for (int j = i + 1; j <= n; j++)
if (a[j]) ans = (ans + 1LL * a[i] * a[j] % p * calc(i, j)) % p;
ans = (ans + p) % p;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p, to[210000], pre[210000], ans, inv[2100000], inv2;
vector<int> V;
int Pow(int x, int y) {
int ans = 1;
for (int i = 1; i <= y; i *= 2, x = 1LL * x * x % p)
if (i & y) ans = 1LL * ans * x % p;
return ans;
}
void dfs(int l, int r, int h) {
if (l < r) {
if (h <= 1) {
ans = (ans + 1LL * (r - l + 1) * (r - l) / 2 % p * Pow(2, p - 2)) % p;
V.push_back(r - l + 1);
} else {
int m = (l + r) / 2;
dfs(l, m, h - 1);
dfs(m + 1, r, h - 1);
}
} else {
V.push_back(1);
}
}
int main() {
scanf("%d%d%d", &n, &k, &p);
dfs(1, n, k);
map<int, int> M;
for (auto y : V) {
M[y] += 1;
}
inv2 = Pow(2, p - 2);
for (int i = 1; i <= n; i++) inv[i] = Pow(i, p - 2);
for (auto it : M)
for (auto it2 : M) {
int fac;
if (it.first == it2.first)
fac = 1LL * it.second * (it.second - 1) % p;
else
fac = 1LL * it.second * it2.second % p;
int tmp = 0;
for (int l = 2; l <= it.first + it2.first; l++) {
int low = max(l - it2.first, 1) - 1;
int hi = min(l - 1, it.first) - 1;
tmp = (tmp +
1LL * (low + hi) * (hi - low + 1) / 2 % p * inv[l] % p * inv2) %
p;
}
ans = (ans + 1LL * tmp * fac) % p;
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[1000001];
long long pow(long long a, long long b, long long MOD) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > MOD) x %= MOD;
}
y = (y * y);
if (y > MOD) y %= MOD;
b /= 2;
}
return x;
}
long long InverseEuler(long long n, long long MOD) {
return pow(n, MOD - 2, MOD);
}
long long C(long long n, long long r, long long MOD) {
return (f[n] *
((InverseEuler(f[r], MOD) * InverseEuler(f[n - r], MOD)) % MOD)) %
MOD;
}
int main() {
int q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
long long ans1 = d;
long long y = r / d;
long long ans2 = (y + 1) * d;
if (d >= l)
cout << ans2 << endl;
else
cout << ans1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int l, r, d, n;
int main() {
ios::sync_with_stdio(false);
cin >> n;
while (n--) {
cin >> l >> r >> d;
if (d > r || d < l) {
cout << d << endl;
continue;
}
cout << d * (r / d + 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5, N2 = 2e5, N1 = 1e6, M = 1e2;
long long binpow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans *= a;
a *= a;
n >>= 1;
}
return ans;
}
string s, s1, s2;
long long n, m, t, x, y, z;
long long k, k1, k2, g, g1, g2, ans, kol, kol1;
char c;
long long mxx = 0, mxy = 0;
int main() {
cin.tie(0);
cin >> t;
while (t--) {
long long l, r, d;
cin >> l >> r >> d;
long long d1 = d;
if (d < l)
cout << d << endl;
else if (r % d == 0)
cout << r + d << endl;
else {
cout << d * (r / d + 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool com(long long a, long long b) { return a < b; }
int main() {
long long t;
cin >> t;
while (t--) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l)
cout << d << "\n";
else {
if (r % d == 0)
cout << r + d << "\n";
else
cout << r + d - (r % d) << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
int q;
cin >> q;
while (q--) {
long long a, b, c;
cin >> a >> b >> c;
long long ans;
if (b % c == 0)
ans = b + c;
else {
ans = ((b / c) + 1) * c;
}
if (c < a && c > 0) ans = min(ans, c);
cout << ans << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long int l, r, d;
cin >> l >> r >> d;
if (l / d == 0) {
long long int x = r / d;
cout << (x + 1) * d << endl;
} else if (l / d == 1 && l % d == 0) {
cout << (r / d + 1) * d << endl;
} else
cout << d << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
scanf("%d", &q);
while (q--) {
int l, r, d;
scanf("%d %d %d", &l, &r, &d);
if (d < l)
printf("%d\n", d);
else if (d > r)
printf("%d\n", d);
else {
int res = r - d;
res = res % d;
printf("%d\n", r + d - res);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long int l, r, d;
cin >> l >> r >> d;
long long int ans, i, flag = 1;
if (d < l)
ans = d;
else if (r % d == 0) {
ans = (ceil((long double)r / d) + 1) * d;
} else {
ans = ceil((long double)r / d) * d;
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
while (n--) {
long long l, r, k;
cin >> l >> r >> k;
if (r - k <= r - l && k <= r) {
cout << r + k - (r % k) << endl;
} else {
cout << k << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int num, l, r, d, x;
x = 0;
cin >> num;
for (int i = 0; i < num; i++) {
cin >> l >> r >> d;
x = d;
while (true) {
if (x <= r && x >= l) {
x = ceil((double)r / d) * d;
if (x == r) x += d;
break;
} else
break;
}
cout << x << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int q, l, r, d;
int main() {
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &l, &r, &d);
if (l > d)
printf("%d\n", d);
else
printf("%d\n", r / d * d + d);
}
}
|
#include <bits/stdc++.h>
int main() {
int a1, b, c, d, n, k = 4;
std::cin >> n;
int a[n];
int i, i1, j;
for (i = 1; i <= n; i++) {
std::cin >> a1 >> b >> c;
if (a1 > c) {
std::cout << c << '\n';
} else {
std::cout << c * (b / c + 1) << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int solve(int l, int r, int d) {
if (d >= l) {
return (r / d + 1) * d;
} else {
return d;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r, d;
cin >> l >> r >> d;
cout << solve(l, r, d) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (T e : v) {
os << e << ' ';
}
return os;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
ll l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << '\n';
} else {
ll candidate = (r / d) * d;
candidate += d;
cout << candidate << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, l, r, d, i, f = 0, j;
cin >> x;
int* Arr = (int*)malloc(3 * x * sizeof(int));
int z;
for (z = 0; z < 3 * x; z++) {
cin >> Arr[z];
}
int mod;
for (i = 0; i < x; i++) {
l = Arr[i * 3];
r = Arr[3 * i + 1];
d = Arr[3 * i + 2];
n = d;
f = 0;
if (n < l || n > r)
cout << d << endl;
else {
mod = r % n;
n = n + r - mod;
cout << n << endl;
}
}
free(Arr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long q, a, b, d;
int main() {
cin >> q;
while (q--) {
cin >> a >> b >> d;
if (d < a)
cout << d << endl;
else
cout << ((b / d) + 1) * d << endl;
}
}
|
#include <bits/stdc++.h>
const double pi = 4.0 * atan(1.0);
const double e = exp(1.0);
using namespace std;
const int N = 3e6 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
while (n--) {
long long a, b, c;
cin >> a >> b >> c;
if (a > c) {
cout << c << endl;
continue;
}
long long x = b / c;
x++;
cout << c * x << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int l, r, d, i, x, y, z;
cin >> l >> r >> d;
if (l > d) {
cout << d << endl;
} else if (r % d == d) {
cout << d << endl;
} else {
x = r / d;
y = (x * d);
z = y + d;
cout << z << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modexpo(long long x, long long p) {
long long res = 1;
x = x % 1000000007;
while (p) {
if (p % 2) res = res * x;
p >>= 1;
x = x * x % 1000000007;
res %= 1000000007;
}
return res;
}
long long max(long long a, long long b) { return (a > b ? a : b); }
long long min(long long a, long long b) { return (a < b ? a : b); }
struct edge {
long long u, v, w;
edge(long long a, long long b, long long c) {
u = a;
v = b;
w = c;
}
};
struct compare {
bool operator()(const edge a, const edge b) const {
if (a.u == b.u) {
if (a.v == b.v) {
return a.w < b.w;
}
return a.v < b.v;
}
return a.u < b.u;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << "\n";
} else if (r % d == 0) {
cout << r + d << "\n";
} else {
long long x = ceil((long double)r / (long double)d);
cout << x * d << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long INF = 1e18;
const long long MAXN = 25;
long long l, r, d, n;
long long myceil(long long x, long long y) {
if ((x % y) == 0) {
return x / y + 1;
} else {
return x / y + 1;
}
}
int main() {
{
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld %lld %lld", &l, &r, &d);
if (l <= d && d <= r) {
long long be = myceil(r, d);
printf("%lld\n", (be)*d);
} else {
printf("%lld\n", d);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[1000100];
int c[1000010];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int l, r, d;
scanf("%d%d%d", &l, &r, &d);
if (d < l) {
printf("%d\n", d);
} else {
long long x2 = r / d;
while (x2 * d <= r) {
x2++;
}
printf("%lld\n", x2 * d);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int q, i, j, ans, l, r, d;
cin >> q;
while (q--) {
cin >> l >> r >> d;
if (d < l || d > r)
cout << d << endl;
else {
ans = 1 + r / d;
cout << ans * d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
long long int l, r, d;
cin >> l >> r >> d;
if (l > d)
cout << d << "\n";
else if (r % d == 0)
cout << d + r << "\n";
else
cout << (r / d) * d + d << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
void fastIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve() {
long long int l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << "\n";
return;
} else {
long long int rem = r % d;
rem = d - rem;
cout << r + rem << "\n";
return;
}
return;
}
int main() {
fastIO();
int q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long l, r, d;
cin >> l >> r >> d;
long long q = r / d;
long long ans = d * (q + 1);
if (d * 1 < l) {
ans = d;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long l, r, d, q;
cin >> q;
for (long long i = 0; i < q; i++) {
cin >> l >> r >> d;
if (l > d)
cout << d << "\n";
else
cout << (r / d + 1) * d << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int d, l, r;
cin >> l;
cin >> r;
cin >> d;
bool a = false;
bool b = false;
if (int(ceil(float(l) / float(d))) == l / d) a = true;
if (int(ceil(float(r) / float(d))) == r / d) b = true;
if (a && b) {
if (l / d > 1) {
printf("%d\n", d);
} else
printf("%d\n", r + d);
} else if (!a && !b) {
if (ceil(float(l) / float(d)) > 1) {
printf("%d\n", d);
} else
printf("%d\n", int(ceil(float(r) / float(d))) * d);
} else if (!a && b) {
if (ceil(float(l) / float(d)) > 1) {
printf("%d\n", d);
} else
printf("%d\n", r + d);
} else {
if (l / d > 1) {
printf("%d\n", d);
} else
printf("%d\n", int(ceil(float(r) / float(d))) * d);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const int N = 200005;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int l, r, d;
cin >> l >> r >> d;
if (d < l)
cout << d << "\n";
else if (r % d == 0)
cout << r + d << "\n";
else
cout << (r / d + 1) * d << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long MAXN = 1e5 + 3;
const long long inf = 2e9;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
long long min(long long a, long long b) {
if (a < b)
return a;
else
return b;
}
long long dx[] = {1, -1, 0, 0};
long long dy[] = {0, 0, -1, 1};
bool cmp(pair<long long, long long> p1, pair<long long, long long> p2) {
if (p1.first < p2.first)
return true;
else if (p1.first == p2.first) {
if (p1.second < p2.second) return true;
return false;
}
return false;
}
void solve() {
long long n;
cin >> n;
long long li, ri, di;
for (long long i = (long long)0; i < (long long)n; ++i) {
cin >> li >> ri >> di;
long long t1 = li / di;
long long t2 = ri / di;
if (li % di == 0) t1--;
t2++;
if (t1 >= 1)
cout << di << "\n";
else
cout << t2 * di << "\n";
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long nT = 1;
for (long long i = (long long)1; i <= (long long)nT; ++i) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int a, b, c;
while (cin >> n) {
int cnt;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (a <= c) {
if (b >= c) {
cnt = b / c + 1;
} else {
cnt = 1;
}
} else {
cnt = 1;
}
cout << cnt * c << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int l, r, d;
cin >> l >> r >> d;
if (d < l)
cout << d << endl;
else {
if (r % d == 0)
cout << (r + d) << endl;
else
cout << (d - r % d) + r << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int l, r, d;
cin >> l >> r >> d;
int x = (l - 1) / d;
int y = r / d;
if (x == 0) {
cout << (y + 1) * d << endl;
} else {
cout << d << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long q, l, r, d;
cin >> q;
for (long long i = 0; i < q; i += 1) {
cin >> l >> r >> d;
long long ans1 = d;
if (ans1 > 0 && ans1 < l) {
cout << ans1 << endl;
continue;
}
long long ans = (r / d) * d;
ans += d;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int x, y, a, b, c;
int main() {
cin >> x;
for (int i = 0; i < x; i++) {
cin >> a >> b >> c;
y = a % c;
if (a <= c) {
y = b % c;
cout << b + c - y;
} else {
cout << c;
}
if (i < x - 1) {
cout << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << endl;
} else {
cout << (r / d + 1) * d << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long l, r, d;
cin >> l >> r >> d;
if (l <= d && d <= r) {
cout << (r / d + 1) * d << endl;
} else if (d > r)
cout << d << endl;
else if (d < l)
cout << d << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long inf = 0x3f3f3f3f;
const long long llinf = 1e18;
const long long nax = 0;
void solve() {
long long l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << '\n';
return;
}
cout << d * (r / d + 1) << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie();
cout.tie();
int t;
cin >> t;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long q;
cin >> q;
while (q--) {
long long l, r, d;
cin >> l >> r >> d;
if (l > d) {
cout << d << endl;
} else {
long long x = r / d;
cout << d * (x + 1) << endl;
}
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.