text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
int n, m, k;
int uf[2001];
int getpa(int a) {
if (uf[a] == a) return a;
uf[a] = getpa(uf[a]);
return uf[a];
}
void comb(int a, int b) { uf[getpa(a)] = getpa(b); }
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) uf[i] = i;
for (int i = 0; i < n - k + 1; i++) {
for (int j = 0; j < k / 2; j++) {
comb(i + j, i + k - 1 - j);
}
}
int sol = 1;
for (int i = 0; i < n; i++)
if (getpa(i) == i) sol = (int)(((long long)sol * m) % 1000000007);
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> al[2345];
bool V[2345];
int n, m, k;
int md = 1000 * 1000 * 1000 + 7;
void dfs(int i) {
if (V[i]) return;
V[i] = true;
for (int j = 0; j < al[i].size(); j++) {
int next = al[i][j];
dfs(al[i][j]);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i <= n - k; i++) {
for (int j = 0; j < k; j++) {
al[j + i].push_back(i + k - j - 1);
}
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!V[i]) {
dfs(i);
cnt++;
}
}
long long a = 1;
for (int i = 0; i < cnt; i++) {
a *= m;
a %= md;
}
cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007;
long long n, m, k;
int main() {
cin >> n >> m >> k;
long long res = 0;
long long x;
if (k == 1 || k > n) {
x = 1;
for (int i = 0; i < n; i++) {
x = (x * m) % M;
}
res = x;
} else if (k == n) {
x = 1;
for (int i = 0; i < (n + 1) / 2; i++) {
x = (x * m) % M;
}
res = x;
} else if (k % 2 == 0) {
res = m;
} else {
res = m * m;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC opmize(2)
#pragma GCC opmize(3)
using namespace std;
const int N = 1e5 + 7;
long long M = 1e9 + 7;
long long n, m, k;
int main() {
ios::sync_with_stdio(0);
long long ans = 1;
cin >> n >> m >> k;
if (k < n && k % 2 == 0) {
cout << m << endl;
return 0;
}
if (k == 1 || k > n) {
for (int i = 1; i <= n; i++) ans = ans * m % M;
} else if (n == k) {
for (int i = 1; i <= k / 2; i++) ans = ans * m % M;
if (k % 2) ans *= m;
} else {
if (!n % 2)
ans = m;
else
ans = m * m;
}
ans %= M;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
long long ans = 0;
if (k == 1 || k > n) {
ans = 1;
int i;
for (i = 0; i < n; i++) {
ans *= m;
ans %= 1000000007;
}
} else if (k == n) {
ans = 1;
int i;
for (i = 1; i <= n + 1 - i; i++) {
ans *= m;
ans %= 1000000007;
}
} else {
if (k % 2 == 0) {
ans = m;
} else {
if (n == 1) {
ans = m;
} else {
ans = m * m;
}
}
}
ans %= 1000000007;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, INF = 0x3f3f3f3f, MOD = 1e9 + 7;
long long n, m, k;
long long ksm(long long x, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * x % MOD;
x = x * x % MOD;
n >>= 1;
}
return ret;
}
long long fac_2(long long x) {
long long ret = 1;
for (int i = x; i >= x - 1; --i) ret = ret * i % MOD;
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
while (cin >> n >> m >> k) {
if (k > n || k == 1) {
cout << ksm(m, n) << '\n';
} else if (k == n) {
cout << ksm(m, (k + 1) / 2) << '\n';
} else if (k & 1) {
long long ans = (m + fac_2(m)) % MOD;
cout << ans << '\n';
} else {
cout << m << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[2005];
const int inf = 1000000007;
int fin(int x) {
if (f[x] != x) {
f[x] = fin(f[x]);
}
return f[x];
}
void add(int x, int y) {
int i = fin(x), j = fin(y);
if (i == j) return;
f[i] = j;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
f[i] = i;
}
for (int i = 0; i <= n - k; i++) {
for (int j = i, d = k + i - 1; j < i + k; j++, d--) {
add(j, d);
}
}
long long ans = 1;
for (int i = 0; i < n; i++) {
if (f[i] == i) ans = (ans * m) % inf;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s2i(string s) {
istringstream iss(s);
long long x;
iss >> x;
return x;
}
string i2s(long long x) {
ostringstream oss;
oss << x;
return oss.str();
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int ans = 1;
if (k > n || k == 1) {
for (int(i) = 0; (i) < (n); (i)++) ans = (ans * (long long)m) % 1000000007;
} else if (n == k) {
for (int(i) = 0; (i) < ((n + 1) / 2); (i)++)
ans = (ans * (long long)m) % 1000000007;
} else {
if (k % 2 == 0) {
ans = m;
} else {
ans = m * m;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, f[2001];
const int p = 1000000007;
int gf(int i) {
if (f[i] == i) return (f[i]);
f[i] = gf(f[i]);
return (f[i]);
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= n - k + 1; i++)
for (int j = i; j <= i + k - 1; j++) f[gf(j)] = gf(i + i + k - 1 - j);
int cnt = 0;
for (int i = 1; i <= n; i++)
if (gf(f[i]) == i) ++cnt;
long long now = 1;
for (int i = 1; i <= cnt; i++) now *= m, now %= p;
printf("%d\n", now);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int ran[2005];
int par[2005];
long long modexp(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b % 2 == 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
int find_set(int x) {
if (par[x] != x) par[x] = find_set(par[x]);
return par[x];
}
void link(int x, int y) {
if (x != y) {
if (ran[x] > ran[y])
par[y] = x;
else
par[x] = y;
if (ran[x] == ran[y]) ran[y] = ran[y] + 1;
}
}
void unio(int x, int y) { link(find_set(x), find_set(y)); }
int main() {
scanf("%d %d %d", &n, &m, &k);
if (k > n) {
printf("%I64d", modexp(m, n));
return 0;
}
for (int i = 1; i <= n; i++) {
par[i] = i;
ran[i] = 1;
}
for (int i = 1; i + k - 1 <= n; i++) {
int st = i;
int en = i + k - 1;
while (st < en) {
unio(st, en);
st++;
en--;
}
}
set<int> s;
for (int i = 1; i <= n; i++) {
s.insert(find_set(i));
}
long long cnt = s.size();
cnt = modexp(m, cnt);
printf("%I64d", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
long long modex(long long a, long long b) {
long long ans = 1LL;
while (b > 0) {
if (b % 2) {
ans *= a;
ans %= MOD;
}
a *= a;
a %= MOD;
b /= 2LL;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
if (n < k || k == 1)
cout << modex(m, n) << "\n";
else if (n == k)
cout << modex(m, (n + 1) / 2) << "\n";
else if (k % 2)
cout << m * m << "\n";
else
cout << m << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
struct DSU {
vector<int> rank, parent, size;
int forsets;
DSU(int n) {
size = rank = parent = vector<int>(n + 1, 1);
forsets = n;
for (int i = 0; i <= n; i++) {
parent[i] = i;
}
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void link(int par, int node) {
parent[node] = par;
size[par] += size[node];
if (rank[par] == rank[node]) rank[par]++;
forsets--;
}
bool union_sets(int v, int u) {
v = find_set(v), u = find_set(u);
if (v == u) return false;
if (rank[v] < rank[u]) swap(v, u);
link(v, u);
return true;
}
bool same_set(int v, int u) { return find_set(v) == find_set(u); }
int size_set(int v) { return size[find_set(v)]; }
};
const int mod = 1e9 + 7;
long long power(long long x, long long y) {
if (y == 0) return 1;
if (y == 1) return x;
long long r = power(x, y >> 1);
return (((r * r) % mod) * power(x, y & 1)) % mod;
}
int main() {
run();
int n, m, k;
cin >> n >> m >> k;
DSU uf(n);
for (int i = 0; i <= n; i++) {
for (int pos = 0, nxt = k - 1; pos < nxt && pos <= i; pos++, nxt--) {
if (i + k - pos > n) continue;
int j = i - pos + nxt;
if (j < n) uf.union_sets(i, j);
}
}
cout << power(m, uf.forsets) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
int main() {
long long n, m, k;
cin >> n;
cin >> m;
cin >> k;
if (k == 1 || k > n) {
long long ans = 1ll;
for (int i = 0; i < n; i++) {
ans = (ans * m) % mod;
}
cout << (ans % mod) << endl;
return 0;
}
if (k == n) {
long long ans = 1ll;
long long cap = (k % 2ll) + k / 2ll;
for (int i = 0; i < cap; i++) {
ans = (ans * m) % mod;
}
cout << (ans % mod) << endl;
return 0;
}
if (k % 2 == 1) {
long long ans = (m * (m)) % mod;
cout << (ans % mod) << endl;
return 0;
}
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000;
const long long q = 1000000007;
int n, m, k;
long long cnt, w, res;
int p[maxn], h[maxn];
bool used[maxn];
int getp(int x) {
if (p[x] != x) p[x] = getp(p[x]);
return p[x];
}
void unite(int a, int b) {
a = getp(a);
b = getp(b);
if (a == b) return;
if (h[a] < h[b]) swap(a, b);
if (h[a] == h[b]) h[a]++;
p[b] = a;
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) {
p[i] = i;
h[i] = 0;
used[i] = false;
}
for (int i = 0; i + k <= n; i++) {
for (int j = 0; j < (k + 1) / 2; j++) {
unite(i + j, i + (k - j - 1));
}
}
cnt = 0;
for (int i = 0; i < n; i++) {
int w = getp(i);
if (!used[w]) {
cnt++;
used[w] = true;
}
}
w = m;
res = 1;
for (long long i = 0; i < cnt; i++) {
res = (res * w) % q;
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[2001];
int a[2001];
int find(int v) {
if (p[v] != v) p[v] = find(p[v]);
return p[v];
}
void merge(int u, int v) {
int pu = find(u);
int pv = find(v);
p[pu] = pv;
}
int main() {
int n, m, k, i, l, r;
cin >> n >> m >> k;
for (i = 0; i < n; i++) p[i] = i;
for (i = 0; i < n; i++) {
l = i;
r = i + k - 1;
if (r >= n) break;
while (l < r) {
merge(l, r);
l++;
r--;
}
}
for (i = 0; i < n; i++) {
p[i] = find(i);
a[p[i]]++;
}
long long re = 1;
for (i = 0; i < n; i++)
if (a[i] > 0) {
re *= m;
re %= 1000000007;
}
cout << re;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int mpow(long long a, int b) {
if (!b) return 1;
if (b & 1) return a * mpow(a, b - 1) % mod;
return mpow(a * a % mod, b / 2);
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k == 1 || k > n)
printf("%d\n", mpow(m, n));
else if (k == n)
printf("%d\n", mpow(m, (n + 1) / 2));
else if (n == 1 || (k & 1) == 0)
printf("%d\n", m);
else
printf("%d\n", mpow(m, 2));
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
int modExp(int a, int b) {
long long t = 1, y = a;
while (b) {
if (b & 1) t = t * y % MOD;
y = y * y % MOD;
b >>= 1;
}
return t;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (n < k || k == 1) {
printf("%d\n", modExp(m, n));
} else if (n == k) {
if (n & 1) {
printf("%d\n", modExp(m, n / 2 + 1));
} else {
printf("%d\n", modExp(m, n / 2));
}
} else {
if (k & 1) {
printf("%d\n", m * m);
} else {
printf("%d\n", m);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k > n) {
long long ans = 1;
for (int i = 1; i <= n; i++) ans = ans * m % mod;
cout << ans << endl;
return 0;
}
if (k == n) {
long long d = (n + 1) / 2;
long long ans = 1;
for (int i = 1; i <= d; i++) ans = ans * m % mod;
cout << ans << endl;
return 0;
}
if (k % 2 == 0) {
cout << m << endl;
return 0;
}
if (k == 1) {
long long ans = 1;
for (int i = 1; i <= n; i++) ans = ans * m % mod;
cout << ans << endl;
return 0;
}
if (k >= 3) {
long long ans = m * m;
cout << ans << endl;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
long long MOD(1e9 + 7);
long long first(long long x, long long m) {
long long ans = 1;
for (long long i = 1; i <= x; ++i) ans *= m, ans %= MOD;
return ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
long long n, m, k;
cin >> n >> m >> k;
if (k == n)
cout << first((n + 1) / 2, m) << endl;
else if (k == 1 || k > n)
cout << first(n, m) << endl;
else if (k & 1)
cout << m * m << endl;
else
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, mod = 1e9 + 7;
long long tav(long long a, long long b) {
long long ans = 1;
for (int i = 0; i < b; i++) {
ans *= (1ll * a);
ans %= mod;
}
return ans;
}
int main() {
cin >> n >> m >> k;
if (k > n || k == 1)
cout << tav(m, n) % mod;
else if (k == n)
cout << tav(m, (n + 1) / 2);
else if (k % 2)
cout << (m * m) % mod;
else
cout << m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int pow(long long int a, long long int b) {
long long int c = mod;
long long int x = 1, y = a % c;
while (b > 0) {
if (b % 2 == 1) x = (x * y) % c;
y = (y * y) % c;
b /= 2;
}
return x % c;
}
int main() {
long long int t, k = 0, i, j, c, m, n, h, w;
cin >> n >> m >> k;
if (n < k || k == 1) {
cout << pow(m, n);
return 0;
}
if (n == k) {
if (k % 2)
cout << pow(m, k / 2LL + 1);
else
cout << pow(m, k / 2LL);
return 0;
}
if (k % 2 == 0)
cout << m;
else
cout << (m * m) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
double _pow(double a, int n) {
double res = 1.0;
while (n) {
if (n % 2 == 1) {
res *= a;
n--;
} else {
a *= a;
n /= 2;
}
}
return res;
}
long long __pow(long long a, long long n) {
long long res = 1;
while (n) {
if (n % 2 == 1) {
res = (res * a) % (1000000007);
n--;
} else {
a = (a * a) % (1000000007);
n /= 2;
}
}
return res;
}
bool is_pr(long long a) {
for (long long i = 2; i * i <= a; ++i)
if (a % i == 0) return false;
return true;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1) {
cout << __pow(m, n);
return 0;
}
if (k == 2) {
cout << m;
return 0;
}
if (1 < k && k < n && k % 2 == 1) {
cout << m + m * (m - 1) % (1000000007);
return 0;
}
if (1 < k && k < n && k % 2 == 0) {
cout << m % (1000000007);
return 0;
}
if (k == n) {
if (n % 2 == 0)
cout << __pow(m, n / 2);
else
cout << __pow(m, n / 2 + 1);
return 0;
}
if (k > n) {
cout << __pow(m, n);
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2005;
const long long MOD = 1e9 + 7;
long long n, m, k;
long long pow(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << pow(m, n, MOD);
else if (k == n)
cout << pow(m, (n + 1) / 2, MOD);
else if (k % 2 == 0)
cout << m;
else
cout << pow(m, 2LL, MOD);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,avx,avx2")
const long long maxn = 1e5 + 10, N = 1e6 + 1, SQ = 600, base = 1999,
mod = 1e9 + 7, INF = 1e18, lg = 17;
long long n, m, k, par[maxn], sz;
long long root(long long v) {
return (v == par[v] ? v : par[v] = root(par[v]));
}
inline void merge(long long v, long long u) {
if ((v = root(v)) == (u = root(u))) {
return;
}
sz--;
par[v] = u;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> k;
sz = n;
for (long long i = 0; i < n; ++i) {
par[i] = i;
}
for (long long i = 0; i <= n - k; ++i) {
for (long long j = i; j < i + k; ++j) {
merge(j, i + k - (j - i + 1));
}
}
long long ans = 1;
for (long long i = 0; i < sz; ++i) {
ans = (ans * m) % mod;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
const long long MOD = 1000000007LL;
long long exp(int a, int b) {
long long ans = 1;
for (int i = 1; i <= b; i++) ans = (ans * a) % MOD;
return ans;
}
int main() {
int n, m, k;
while (scanf("%d%d%d", &n, &m, &k) == 3) {
if (k == 1 || k > n)
printf("%I64d\n", exp(m, n));
else if (k == n)
printf("%I64d\n", exp(m, (n + 1) / 2));
else if (k % 2 == 0)
printf("%d\n", m);
else
printf("%d\n", m * m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T By(T x, T y, T P) {
T F1 = 0;
while (y) {
if (y & 1) {
F1 += x;
if (F1 < 0 || F1 >= P) F1 -= P;
}
x <<= 1;
if (x < 0 || x >= P) x -= P;
y >>= 1;
}
return F1;
}
template <class T>
T Mul(T x, T y, T P) {
T F1 = 1;
x %= P;
while (y) {
if (y & 1) {
F1 = By(F1, x, P);
}
x = By(x, x, P);
y >>= 1;
}
return F1;
}
template <class T>
T Gcd(T x, T y) {
if (y == 0) return x;
T z;
while (z = x % y) {
x = y, y = z;
}
return y;
}
struct EDGE {
int T;
EDGE *Nxt;
};
int Fa[2001];
int N, M, K, i, j, k, l;
int FindFather(int x) {
if (x == Fa[x]) return x;
return Fa[x] = FindFather(Fa[x]);
}
int main() {
cin >> N >> M >> K;
for (int i = 0; i < (N); ++i) Fa[i] = i;
for (int i = 0; i < (N); ++i)
if (K & 1) {
if (i >= K / 2 && i + K / 2 < N) {
for (int j = 1; j <= (K / 2); ++j) {
Fa[FindFather(i - j)] = FindFather(j + i);
}
}
} else {
if (i >= K / 2 && i + K / 2 <= N) {
for (int j = 1; j <= (K / 2); ++j) {
Fa[FindFather(i - j)] = FindFather(j + i - 1);
}
}
}
for (int i = 0; i < (N); ++i) k += Fa[i] == i;
cout << Mul(M, k, 1000000007) << endl;
cin >> N;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int nxt() {
int a;
scanf("%d", &a);
return a;
}
inline long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
const int N = 2000;
int p[N];
int sz[N];
inline int get(int v) { return v == p[v] ? v : p[v] = get(p[v]); }
inline void unite(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
if (sz[a] < sz[b]) {
swap(a, b);
}
p[b] = a;
sz[a] += sz[b];
}
const long long mod = 1000 * 1000 * 1000 + 7;
long long pw(long long a, long long n) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
void solve() {
int n = nxt();
int m = nxt();
int k = nxt();
for (int i = 0; i < n; ++i) {
p[i] = i;
sz[i] = 1;
}
for (int i = 0; i + k <= n; ++i) {
for (int j = 0; j < k; ++j) {
unite(i + j, i + k - 1 - j);
}
}
char used[n];
memset((used), 0, sizeof((used)));
int cnt = 0;
for (int i = 0; i < n; ++i) {
int a = get(i);
if (!used[a]) {
++cnt;
used[a] = 1;
}
}
cout << pw(m, cnt) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
const int mod = (int)1e9 + 7;
int main() {
int n, m, k;
long long ans;
scanf("%d%d%d", &n, &m, &k);
if (k == 1 || k > n) {
ans = 1;
for (int(i) = 0; (i) < (int)(n); (i)++) ans = (m * ans) % mod;
} else if (k == n) {
ans = 1;
for (int i = 0; i < n - i; i++) ans = (m * ans) % mod;
} else if (k % 2)
ans = m * m % mod;
else
ans = m % mod;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> par;
int find(int a) {
if (par[a] == a) return a;
return par[a] = find(par[a]);
}
void join(int a, int b) {
int pa = find(a);
int pb = find(b);
if (pa == pb) return;
par[pa] = pb;
}
int main() {
int str_len, alphabet_char, substr_len;
cin >> str_len >> alphabet_char >> substr_len;
par = vector<int>(str_len);
for (int i = 0; i < str_len; i++) par[i] = i;
for (int st = 0; st < str_len - substr_len + 1; st++) {
for (int indx = 0; indx < substr_len / 2; indx++) {
if (st + indx >= str_len) continue;
if (st + substr_len - 1 - indx >= str_len) continue;
join(st + indx, st + substr_len - 1 - indx);
}
}
set<int> unique_components;
for (int i = 0; i < str_len; i++) unique_components.insert(find(i));
long long int ans = 1;
for (int i = 0; i < unique_components.size(); i++) {
ans = (ans * alphabet_char) % 1000000007;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 5 * (1e+8);
const long long int mod = 1e9 + 7;
vector<long long int> adj[500005];
vector<long long int> visited(500005, 0);
vector<long long int> t(500005, 0);
long long int flag = 1;
void nothing() {}
long long int powfn(long long int a, long long int b) {
long long int ans = 1;
for (long long int i = 1; i < b + 1; i++) {
ans = (ans * a) % mod;
}
return ans;
}
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
long long int i, j;
long long int res = 1;
if (k == 1)
res = powfn(m, n);
else if (k % 2) {
if (n > k)
res = m * m;
else if (k == n)
res = powfn(m, (n + 1) / 2);
else
res = powfn(m, n);
} else {
if (n > k)
res = m;
else if (k == n)
res = powfn(m, (n) / 2);
else
res = powfn(m, n);
}
cout << res << '\n';
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2001;
int pa[N], ra[N];
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res;
}
int find(int a) {
if (a == pa[a])
return a;
else
return pa[a] = find(pa[a]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a == b) return;
if (ra[a] > ra[b]) swap(a, b);
ra[b] += ra[a];
pa[a] = b;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) pa[i] = i, ra[i] = 1;
for (int i = 1; i <= n - k + 1; i++) {
int x = i;
int y = i + k - 1;
while (x < y) merge(x, y), x++, y--;
}
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (i == pa[i]) cnt++;
}
cout << powmod(m, cnt, 1e9 + 7);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long DP[2005];
int main() {
cin >> n;
cin >> m;
cin >> k;
if (n < k || k == 1) {
long long ans = 1;
for (int i = 0; i < n; i++) {
ans *= m;
ans %= 1000000007;
}
cout << ans;
return 0;
}
if (n > k) {
if (k % 2 == 0) {
cout << m;
} else {
cout << m * (m - 1) + m;
}
}
if (n == k) {
DP[0] = 1;
DP[1] = m;
for (int i = 2; i <= n; i++) {
DP[i] = (DP[i - 2] * m) % 1000000007;
}
cout << DP[n];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int por(long long int x, long long int y) {
long long int ans = 1, b = x;
while (y) {
if (y & 1) ans = (ans * b) % 1000000007;
b = (b * b) % 1000000007;
y >>= 1;
}
return ans;
}
int main() {
long long int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << por(m, n);
else if (m == 1)
cout << 1;
else if (n == k)
cout << por(m, (n + 1) / 2);
else if (k % 2 == 0)
cout << m;
else
cout << m * m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
long long ans = 1;
for (int i = 0; i < n; i++) ans = (ans * m) % 1000000007;
cout << ans << endl;
} else if (n == k) {
long long ans = 1;
for (int i = 0; i < (n + 1) / 2; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << endl;
} else if (k % 2 == 0)
cout << m << endl;
else
cout << m * m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
long long int me(long long int b, long long int p) {
if (p == 0) {
return 1;
} else if (p % 2 == 0) {
return me((b * b) % MOD, p / 2) % MOD;
} else {
return (b * (me((b * b) % MOD, (p - 1) / 2)) % MOD) % MOD;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << me(m, n) << "\n";
} else if (k == n) {
cout << me(m, (n + 1) / 2) << "\n";
} else if (k % 2 == 1) {
cout << (m * m) % MOD << "\n";
} else if (k % 2 == 0) {
cout << m << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long power(long long n, long long p) {
long long val = 1;
while (p > 0) {
if (p % 2 == 0) {
p /= 2;
n *= n;
n %= mod;
} else {
p--;
val *= n;
val %= mod;
}
}
return val;
}
int main() {
int n, m, f, g, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << power(m, n);
return 0;
}
if (k == n) {
cout << power(m, (n + 1) / 2);
return 0;
}
if (k % 2 == 0) {
cout << m;
return 0;
}
cout << m * m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[2010];
int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
int n, m, k;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) f[i] = i;
int cnt = n;
for (int i = 1; i <= n; i++) {
int l = i;
int r = l + k - 1;
if (r > n) break;
while (l < r) {
int x = find(l);
int y = find(r);
if (x != y) cnt--;
f[x] = y;
l++;
r--;
}
}
long long ans = 1ll;
for (int i = 1; i <= cnt; i++) ans = ans * (long long)m % 1000000007;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 1e9 + 7;
long long int inf = 1e18;
long long int n, m;
long long int binpow(long long int val, long long int deg) {
if (!deg) return 1 % M;
if (deg & 1) return binpow(val, deg - 1) * val % M;
long long int res = binpow(val, deg >> 1);
return (res * res) % M;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int i, j, t, k, x, y, z, N;
cin >> n >> m >> k;
long long int ans = 0;
if (k < n) {
if (k % 2 && k > 1) {
(ans += m * m) %= M;
} else if (k == 1) {
(ans += binpow(m, n)) %= M;
} else
ans += m;
} else if (k == n) {
x = n / 2;
if (n % 2) x++;
(ans += binpow(m, x)) %= M;
} else {
(ans += binpow(m, n)) %= M;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k, i, j, x, y, ans = 1;
scanf("%I64d%I64d%I64d", &n, &m, &k);
if (k == 1 || k > n) {
for (i = 0; i < n; ++i) ans = (ans * m) % 1000000007;
printf("%I64d", ans);
return 0;
}
if (k < n) {
if (k % 2 == 0)
printf("%I64d", m);
else
printf("%I64d", (m * m) % 1000000007);
return 0;
}
n = (n + 1) / 2;
for (i = 0; i < n; ++i) ans = (ans * m) % 1000000007;
printf("%I64d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long long ans = m;
if (k == 1 || k > n) {
ans = 1;
for (int i = 0; i < n; i++) ans = (ans % M * m % M) % M;
} else if (k == n) {
int sz = k / 2 + (k % 2);
ans = 1;
for (int i = 0; i < sz; i++) ans = (ans % M * m % M) % M;
} else if (k % 2) {
ans = (m % M * m % M) % M;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> root, rnk;
long long pmod(long long a, long long b) {
long long res = 1;
while (b) {
if (b % 2) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return res;
}
long long find_set(long long a) {
if (root[a] == a) return a;
root[a] = find_set(root[a]);
return root[a];
}
void make_union(long long a, long long b) {
long long x = find_set(a);
long long y = find_set(b);
if (x != y) {
if (rnk[x] < rnk[y])
swap(x, y);
else if (rnk[x] == rnk[y])
rnk[x]++;
root[y] = x;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n, m, k;
cin >> n >> m >> k;
root.resize(n);
rnk.resize(n, 1);
iota(root.begin(), root.end(), 0ll);
for (long long i = 0; i <= n - k; i++)
for (long long j = i; j < i + (k / 2); j++)
make_union(j, k - j + 2 * i - 1);
long long res = 0;
for (long long i = 0; i < n; i++)
if (root[i] == i) res++;
cout << pmod(m, res) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MX = 100000;
const long long MOD = 1000000007;
long long fast_exp(long long base, long long exp, long long mod) {
long long res = 1;
while (exp > 0) {
if (exp % 2 == 1) res = (res * base) % mod;
base = (base * base) % mod;
exp /= 2;
}
return res;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << fast_exp(m, n, MOD);
} else if (k == n) {
cout << fast_exp(m, (n + 1) / 2, MOD);
} else if (k < n) {
if (k % 2 == 0)
cout << m;
else
cout << m * m;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
bool flag[2003];
int coun;
int n, m, k;
void dfs(int x) {
int i;
flag[x] = true;
for (i = 0; i < g[x].size(); i++)
if (!flag[g[x][i]]) dfs(g[x][i]);
}
int main() {
int i, j;
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
g.resize(n);
for (j = k; j > 1; j -= 2)
for (i = (k - j) / 2; i + j - 1 < n - (k - j) / 2; i++) {
g[i].push_back(i + j - 1);
g[i + j - 1].push_back(i);
}
for (i = 0; i < n; i++)
if (!flag[i]) {
dfs(i);
coun++;
}
long long res = 1;
for (i = 0; i < coun; i++) {
res *= m;
res %= 1000000007;
}
printf("%I64d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
if (k < n && k % 2 == 0) {
printf("%d\n", m);
continue;
}
long long ans = 1;
if (k == n) {
if (n % 2) {
ans = m;
for (int i = 1; i <= k / 2; i++) ans = ans * m % 1000000007;
} else {
for (int i = 1; i <= k / 2; i++) ans = ans * m % 1000000007;
}
} else if (k == 1 || k > n) {
for (int i = 1; i <= n; i++) ans = ans * m % 1000000007;
} else {
if (!n % 2)
ans = m;
else
ans = m * m;
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxm = 2000 + 10;
int p[maxm];
int find(int v) {
if (v == p[v])
return v;
else
return find(p[v]);
}
void merge(int a, int b) {
a = find(a);
b = find(b);
if (a != b) p[b] = a;
}
bool used[maxm];
const long long module = 1000 * 1000 * 1000 + 7;
int main() {
int n, m, k;
cin >> n >> m >> k;
int now = 1;
for (int i = 0; i < n; ++i) p[i] = i;
for (int st = 0; st <= n - k; ++st)
for (int pos = 0; pos < k; ++pos) merge(st + pos, st + k - pos - 1);
int w = 0;
memset(used, 0, sizeof used);
for (int i = 0; i < n; ++i) {
int tmp = find(i);
if (!used[tmp]) {
++w;
used[tmp] = true;
}
}
long long ans = 1;
for (int i = 1; i <= w; ++i) ans = (ans * m) % module;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1E9 + 7;
int main() {
int n, m, k, i;
long long r = 1;
cin >> n >> m >> k;
if (k > n || k == 1) {
for (i = 0; i < n; i++) r = r * m % mod;
} else if (k == n) {
for (i = 0; i < (n + 1) / 2; i++) r = r * m % mod;
} else if (k & 1) {
r = m * m;
} else {
r = m;
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1e9 + 7;
inline long long int mul(long long int a, long long int b,
long long int mod = MOD) {
return ((a % mod) * (b % mod)) % mod;
}
inline long long int sum(long long int a, long long int b,
long long int mod = MOD) {
return ((a % mod) + (b % mod)) % mod;
}
long long int power(long long int a, long long int n, long long int mod = MOD) {
long long int ans = 1;
while (n) {
if (n & 1) ans = mul(ans, a, mod);
a = mul(a, a, mod);
n >>= 1;
}
return ans;
}
inline long long int sub(long long int a, long long int b,
long long int mod = MOD) {
return (((a) % mod) - ((b) % mod) + mod) % mod;
}
void solve();
const long long int N = 2 * 1e3 + 10;
struct DSU {
long long int totlst;
long long int link[N], sz[N];
DSU() {}
DSU(long long int n) {
for (long long int i = 1; i <= n; i++) {
link[i] = i;
sz[i] = 1;
}
totlst = n;
}
long long int find(long long int x) {
if (x == link[x]) {
return x;
}
return link[x] = find(link[x]);
}
bool same(long long int a, long long int b) { return (find(a) == find(b)); }
void unite(long long int a, long long int b) {
a = find(a);
b = find(b);
if (a == b) {
return;
}
totlst--;
if (sz[a] < sz[b]) {
sz[b] += sz[a];
sz[a] = 0;
link[a] = b;
} else {
sz[a] += sz[b];
sz[b] = 0;
link[b] = a;
}
}
long long int getSize(long long int k) { return sz[find(k)]; }
long long int getDisjointsets() { return totlst; }
};
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) solve();
return 0;
}
void solve() {
long long int i, j, cnt = 0;
bool flag = 0;
long long int n, m, k;
cin >> n >> m >> k;
DSU g(n);
for (i = 0; i <= n - k; i++) {
long long int s = i;
long long int d = i + k - 1;
while (s < d) {
g.unite(s, d);
s++;
d--;
}
}
long long int ans = power(m, g.getDisjointsets());
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
const double eps = 1e-8;
const double pi = 3.1415926535897932;
const long long I64M = 1000000LL * 1000000LL * 1000000LL;
const int IMax = 1000000000;
const int IMin = -IMax;
using namespace std;
ifstream in("input.txt", ifstream::in);
ofstream out("output.txt", ofstream::out);
long long fastpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) {
res *= a;
}
a *= a;
b >>= 1;
}
return res;
}
long long fastpowmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
while (b) {
if (b & 1) {
res *= a;
res %= mod;
}
a *= a;
a %= mod;
b >>= 1;
}
return res;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k > n || k == 1)
cout << fastpowmod(m, n, 1000000007);
else if (k == n)
cout << fastpowmod(m, ((n + 1) / 2), 1000000007);
else if (k % 2 == 1)
cout << fastpowmod(m, 2, 1000000007);
else if (k % 2 == 0)
cout << m % 1000000007;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ABS(int a) {
if (a < 0) return (-a);
return a;
}
char graph[1005][1005];
bool vis[1005][1005] = {0};
long long int power(long long int n, long long int m) {
if (m == 1) return n;
return (n * power(n, m - 1)) % 1000000007;
}
int main() {
long long int i, n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << power(m, n) << endl;
} else if (k == n) {
cout << power(m, (n + 1) / 2) << endl;
} else if (k % 2 == 1) {
cout << m * m << endl;
} else {
cout << m << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2020;
long long n, m, k, p[maxn];
long long getpa(long long x) {
if (p[x] == x)
return p[x];
else
return p[x] = getpa(p[x]);
}
long long Qpower(long long a, long long b) {
long long res = 1;
a %= 1000000007;
while (b) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
signed main() {
cin >> n >> m >> k;
for (register long long i = (1); i <= (n); ++i) p[i] = i;
for (long long i = 1; i + k - 1 <= n; i++) {
for (register long long j = (i); j <= (i + (k - 1) / 2); ++j) {
p[getpa(j)] = getpa(i * 2 + k - j - 1);
}
}
long long cnt = 0;
for (register long long i = (1); i <= (n); ++i)
if (p[i] == i) cnt++;
cout << Qpower(m, cnt) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const double PI = 3.141592653589793238463;
const int INF = 0x3f3f3f3f;
const int INFS = 1000000000;
const long long LLINF = 9223372036854775807;
const int M = 1000000007;
const double EPS = 1e-9;
const int p = 43;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
vector<long long> pows(2001);
pows[0] = 1;
for (long long i = 1; i < 2001; i++) pows[i] = (pows[i - 1] * m) % M;
if (k == 1 || n < k) {
cout << pows[n] << endl;
return 0;
}
if (k == n) {
cout << pows[(n + 1) / 2] << endl;
return 0;
}
if (k % 2)
cout << pows[2] << endl;
else
cout << pows[1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k, an;
long long int po(long long int a, long long int b) {
long long int tmp = 1;
while (b--) tmp = (tmp * a) % 1000000007;
return tmp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
scanf("%lld%lld%lld", &n, &m, &k);
if (k == 1 || k > n)
an = po(m, n);
else if ((k & 1LL) && k == n)
an = po(m, (k >> 1) + 1);
else if (k & 1LL)
an = po(m, 2);
else if (k == n)
an = po(m, k >> 1);
else
an = m;
printf("%lld\n", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (n < k) {
long long ret = 1;
for (int i = 0; i < n; i++) {
ret = (ret * m) % 1000000007;
}
cout << ret << endl;
return 0;
}
if (k == 1) {
long long ret = 1;
for (int i = 0; i < n; i++) {
ret = (ret * m) % 1000000007;
}
cout << ret << endl;
} else if (k & 1) {
if (n == k) {
long long ret = 1;
int tt = k / 2 + 1;
for (int i = 0; i < tt; i++) {
ret = (ret * m) % 1000000007;
}
cout << ret << endl;
} else {
cout << m * m << endl;
return 0;
}
} else {
if (n == k) {
int tt = n / 2;
long long ret = 1;
for (int i = 0; i < tt; i++) {
ret = (ret * m) % 1000000007;
}
cout << ret << endl;
} else {
cout << m << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
const int M = 1e9 + 7;
const int N = 2000 + 1;
vector<int> g[N];
vector<char> used(N);
void dfs(int v) {
used[v] = true;
for (auto i : g[v])
if (!used[i]) dfs(i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
int l = 0, r = k - 1;
while (r < n) {
for (int i = l; i <= r; i++) {
g[i].push_back(r - i + l);
}
l++;
r++;
}
int count = 0;
for (int i = 0; i < n; i++)
if (!used[i]) dfs(i), count++;
long long ans = 1;
while (count--) ans *= m, ans %= M;
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2010;
const double eps = 1e-9;
const int INF = 1000000000;
int n, m, k;
bool flag[MAXN][MAXN], exist[MAXN];
void dfs(int x) {
if (exist[x]) {
return;
}
exist[x] = true;
for (int i = 0; i < n; ++i)
if (!exist[i] && flag[x][i]) {
dfs(i);
}
}
int main() {
while (cin >> n >> m >> k) {
memset(flag, 0, sizeof(flag));
memset(exist, 0, sizeof(exist));
for (int st = 0; st + k - 1 < n; ++st) {
for (int i = 0; i < k; ++i) {
flag[st + i][st + k - 1 - i] = true;
}
}
int t = 0, ans = 1;
for (int i = 0; i < n; ++i)
if (!exist[i]) {
++t;
dfs(i);
}
for (int i = 0; i < t; ++i) {
ans = ((long long)ans * m) % 1000000007;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const double pi = acos(-1);
const long long MODPRIMA = (long long)1e9 + 7;
const long long MAXX = (long long)1e18;
const long long MINN = -(long long)1e18;
const double EPS = 1e-9;
const int MAXN = 2000;
int N, M, K;
int parent[MAXN + 4];
bool sudah[MAXN + 4];
int power(int a, int b) {
if (b == 0)
return 1;
else if (b == 1)
return a % MODPRIMA;
int tmp = power(a, b / 2);
tmp = ((tmp % MODPRIMA) * (tmp % MODPRIMA)) % MODPRIMA;
if (b % 2 == 0)
return tmp;
else
return ((a % MODPRIMA) * tmp) % MODPRIMA;
}
int cari(int x) { return (parent[x] == x ? x : cari(parent[x])); }
void gabung(int x, int y) {
int a = cari(x);
int b = cari(y);
parent[a] = b;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M >> K;
for (int i = 1; i <= N; i++) parent[i] = i;
if (K > N)
cout << power(M, N) << '\n';
else {
for (int i = 1; i <= N; i++) {
if (K + i - 1 > N) break;
int awal = i;
int akhir = i + K - 1;
while (awal < akhir) {
gabung(awal, akhir);
awal++;
akhir--;
}
}
int cnt = 0;
for (int i = 1; i <= N; i++) {
if (!sudah[cari(i)]) {
cnt++;
sudah[cari(i)] = true;
}
}
cout << power(M, cnt) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int OO = 0x3f3f3f3f, N = 3e3 + 5, mod = 1e9 + 7;
int n, m, k;
vector<int> adj[N];
bool vis[N];
long long ans = 1;
void dfs(int p) {
vis[p] = 1;
for (int ch : adj[p]) {
if (!vis[ch]) dfs(ch);
}
}
int main() {
cin >> n >> m >> k;
for (int u = 1; u + k - 1 <= n; ++u) {
for (int i = u, j = u + k - 1; i <= j; ++i, --j) {
adj[i].push_back(j);
adj[j].push_back(i);
}
}
for (int i = 1; i <= n; ++i) {
if (!vis[i]) {
ans = (ans * m) % mod;
dfs(i);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
enum STATE { IN, OUT, BOUNDRY };
void fast_in_out() {
std::ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
}
int dx[] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
int dy[] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
int lx[] = {2, 2, -1, 1, -2, -2, -1, 1};
int ly[] = {-1, 1, 2, 2, 1, -1, -2, -2};
const long double eps = 1e-3;
const int N = 1e6 + 100, M = 5e2 + 50, mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long fast_power(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power & 1) {
result = (result * base) % mod;
}
base = (base * base) % mod;
power >>= 1;
}
return result;
}
int main() {
fast_in_out();
int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << fast_power(m, n);
else if (k == n)
cout << fast_power(m, (n + 1) / 2);
else if (k & 1)
cout << m * m;
else
cout << m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, q, i, res, a[3000], j, z;
long long b[3000];
int main() {
cin >> n >> m >> k;
if (k == 1 || k > n)
q = n;
else if (k % 2 == 1) {
if (n == k)
q = n / 2 + n % 2;
else
q = 2;
} else if (k % 2 == 0) {
if (n == k)
q = n / 2;
else
q = 1;
}
res = 1;
for (i = 1; i <= q; i++) {
res = res * m;
res = res % 1000000007;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v[2005];
int vi[2005];
void dfs(int cu) {
int j, l = v[cu].size();
vi[cu] = 1;
for (j = 0; j < l; j++) {
if (!vi[v[cu][j]]) dfs(v[cu][j]);
}
}
int main() {
int n, m, k, cn = 0, i, j;
scanf("%d%d", &n, &m);
scanf("%d", &k);
long long an = 1;
for (i = 1; i + k - 1 <= n; i++) {
for (j = i; j < i + k / 2; j++) {
v[j].push_back(2 * i + k - 1 - j);
v[2 * i + k - 1 - j].push_back(j);
}
}
for (i = 1; i < n + 1; i++) {
if (!vi[i]) dfs(i), cn++;
}
for (i = 0; i < cn; i++) an = (an * m) % 1000000007LL;
printf("%lld", an);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000;
int pr[maxn];
int w[maxn];
bool used[maxn];
int get(int v) {
if (v == pr[v]) return v;
return pr[v] = get(pr[v]);
}
void fdjkalsdfkjasdlkfjhaslkjdhf(int s, int t) {
s = get(s), t = get(t);
if (s == t) return;
if (w[s] == w[t]) w[s]++;
if (w[s] > w[t])
pr[t] = s;
else
pr[s] = t;
}
const int MOD = (int)1e9 + 7;
int main() {
int n, m, k;
while (scanf("%d%d%d", &n, &m, &k) >= 1) {
for (int i = 0; i < n; i++) pr[i] = i, w[i] = 0;
for (int i = 0; i <= n - k; i++)
for (int j = 0; j < k; j++)
fdjkalsdfkjasdlkfjhaslkjdhf(i + j, i + k - 1 - j);
memset(used, 0, sizeof(used));
int ans = 0;
for (int i = 0; i < n; i++)
if (pr[i] == i) ans++;
long long res = 1;
for (int i = 0; i < ans; i++) res = (res * m) % MOD;
printf("%I64d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long power(long long x, long long y) {
long long ans = 1;
for (int i = 1; i <= y; i++) ans = ans * x % mod;
return ans;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long res;
if (k > n || k == 1)
res = power(m, n);
else if (k == n) {
if (k % 2 == 0)
res = power(m, n / 2);
else
res = power(m, n / 2 + 1);
} else {
if (k % 2 == 0)
res = m;
else
res = power(m, 2);
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2005;
const long long MOD = 1000 * 1000 * 1000 + 7;
long long mul(long long a, long long b) { return (a * b + MOD) % MOD; }
long long add(long long a, long long b) { return (a + b + MOD) % MOD; }
long long POW(long long a, long long lu) {
if (lu == 1) return a % MOD;
if (lu == 0) return 1;
long long mi = POW(a, lu / 2);
mi = mul(mi, mi);
if (lu & 1) mi = mul(mi, a);
return mi;
}
int main() {
long long m, n, k;
cin >> n >> m >> k;
if (k == 1 || n < k)
cout << POW(m, n);
else if (n == k)
cout << POW(m, (n + 1) / 2);
else if (k % 2 == 0)
cout << m << endl;
else if (k % 2 == 1)
cout << POW(m, 2) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n = 0, m = 0, k = 0;
cin >> n >> m >> k;
if (k == n) {
long long int ans = 1;
if (k % 2 == 0) {
for (int i = 0; i < k / 2; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << endl;
return 0;
} else {
for (int i = 0; i < k / 2 + 1; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << endl;
return 0;
}
} else if (k > n || k == 1) {
long long int ans = 1;
for (int i = 0; i < n; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << endl;
return 0;
}
int ans = m;
if (k % 2 == 1) {
ans *= m;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
if (k == 1 or k > n) {
long long ans = m;
for (int i = 1; i < n; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << '\n';
} else if (n == k) {
long long ans = m;
for (int i = 1; i < (n + 1) / 2; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans << '\n';
} else if (k % 2 == 0) {
cout << m << '\n';
} else {
cout << m * m << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
long long n, m, k, res = 1;
scanf("%lld %lld %lld", &n, &m, &k);
if (k > n || k == 1) {
while (n--) {
res *= m;
res %= 1000000007;
}
printf("%lld\n", res);
return 0;
} else if (k == n) {
k = k / 2 + k % 2;
while (k--) {
res *= m;
res %= 1000000007;
}
printf("%lld\n", res);
} else {
if (m == 1)
printf("%lld\n", m);
else if (n == 1)
printf("%lld\n", m);
else if (n == 2) {
if (k == 2)
printf("%lld\n", m);
else
printf("%lld\n", m * m);
} else {
if (k % 2)
printf("%lld\n", m * m);
else
printf("%lld\n", m);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res % 1000000007;
}
long long par[2005];
long long vis[2005][2005];
long long fint(long long x) {
if (par[x] == x)
return x;
else
return par[x] = fint(par[x]);
}
int main() {
long long i, j, k, l, m, n, t, ans, r, len, p, q, M, L, R;
cin >> n >> m >> k;
if (k > n || k == 1) {
cout << power(m, n) << '\n';
return 0;
}
for (i = 1; i <= n; i++) par[i] = i;
memset(vis, 0, sizeof vis);
M = n - k + 1;
l = 1;
r = l + k - 1;
while (M--) {
L = l, R = r;
while (L < R) {
if (vis[L][R]) break;
vis[L][R] = 1;
p = fint(L);
q = fint(R);
par[p] = q;
L++;
R--;
}
l++;
r++;
}
set<long long> total;
for (i = 1; i <= n; i++) {
total.insert(fint(i));
}
len = total.size();
cout << power(m, len) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
long long int parent[100005];
long long int siz[100005];
long long int find_parent(long long int v) {
if (v == parent[v]) return v;
return parent[v] = find_parent(parent[v]);
}
void make_set(long long int v) {
parent[v] = v;
siz[v] = 1;
}
void union_sets(long long int a, long long int b) {
long long int pa = find_parent(a);
long long int emplace_back = find_parent(b);
if (pa != emplace_back) {
if (siz[pa] < siz[emplace_back]) swap(pa, emplace_back);
parent[emplace_back] = pa;
siz[pa] += siz[emplace_back];
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int n, q, a, b, i, j, m, k;
cin >> n >> m >> k;
for (i = 1; i <= n; i++) make_set(i);
for (i = 0; i <= n - k + 2; i++) {
j = i + k - 1;
long long int x, y;
x = i;
y = j;
if (x >= 1 && x <= n && y >= 1 && y <= n) {
while (x < y) {
union_sets(x, y);
x++;
y--;
}
}
}
set<long long int> s;
for (i = 1; i <= n; i++) {
long long int pi = find_parent(i);
s.insert(pi);
}
long long int ans = 1, count = 0;
while (count < s.size()) {
ans *= m;
ans %= 1000000007;
count++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void split(const string &s, vector<string> &tokens, char delimiter) {
string token;
istringstream tokenStream(s);
while (getline(tokenStream, token, delimiter)) tokens.push_back(token);
}
template <typename T>
T modpow(T base, T exp, T modulus) {
base %= modulus;
T result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % modulus;
base = (base * base) % modulus;
exp >>= 1;
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << modpow(m, n, (long long)1000000007);
else if (k == n)
cout << modpow(m, (n + 1) / 2, (long long)1000000007);
else if (k % 2)
cout << m * m;
else
cout << m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
bool visited[2001];
long long compute(long long a, long long b) {
if (b == 0) return 1;
long long res = compute(a * a % MOD, b / 2);
if (b & 1) res = res * a % MOD;
return res;
}
void dfs(int x, int n, int k) {
if (!visited[x]) {
visited[x] = true;
for (int p = 0; p < k; p++) {
int b = x - p;
if (b >= 0 && b + k <= n) {
int q = k - p - 1;
int next = b + q;
dfs(next, n, k);
}
}
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
memset(visited, 0, sizeof(visited));
int comp = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
comp++;
dfs(i, n, k);
}
}
cout << compute((long long)m, (long long)comp) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const long long inf = (long long)1e18;
const int infint = (int)2e9;
const int MAXN = 1e6 + 7;
vector<int> G[MAXN];
bool visited[MAXN];
void dfs(int u) {
visited[u] = true;
for (auto v : G[u])
if (!visited[v]) dfs(v);
}
long long pwr(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a % MOD;
long long c = pwr(a, b / 2) % MOD;
c = (c * c) % MOD;
if (b % 2) c = (c * a) % MOD;
return c;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n - k + 1; i++) {
int first = i, last = i + k - 1;
for (int j = first; j < last; j++) {
G[j].push_back(last);
G[last].push_back(j);
last--;
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!visited[i]) {
ans++;
dfs(i);
}
}
cout << pwr(m, ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long pow1(long long n, long long p) {
long long res = 1, cur = n;
while (p) {
if (p & 1) (res *= cur) %= MOD;
p /= 2;
(cur *= cur) %= MOD;
}
return res;
}
int sz;
int par[2001];
int find_set(int u) { return u == par[u] ? u : par[u] = find_set(par[u]); }
void join(int u, int v) {
u = find_set(u);
v = find_set(v);
if (u == v) return;
if (rand() & 1) swap(u, v);
par[u] = v;
sz--;
}
void init() {
for (int i = 0; i < 2001; i++) par[i] = i;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
sz = n;
init();
for (int i = 0; i < n - k + 1; i++) {
for (int j = 0; j < k / 2; j++) {
join(i + j, i + k - 1 - j);
}
}
cout << pow1(m, sz);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long M = 1000000007, n, m, k;
long long mod(long long a) { return a % M; }
long long st(long long a, long long b) {
if (b == 0) return 1;
long long c = st(a, b / 2);
if (b % 2 != 0)
return mod(mod(a * c) * c);
else
return mod(c * c);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
if (n < k || k == 1) {
cout << st(m, n) << '\n';
return 0;
}
if (n == k) {
cout << st(m, (n + 1) / 2) << '\n';
return 0;
}
if (k % 2 != 0)
cout << m * m;
else
cout << m;
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
vector<int> v[2048];
int color[2048];
void dfs(int nod, int c) {
color[nod] = c;
int sz = v[nod].size();
for (int i = 0; i < sz; ++i) {
if (!color[v[nod][i]]) {
dfs(v[nod][i], c);
}
}
}
int main() {
int n, m, k, c = 1;
cin >> n >> m >> k;
;
for (int i = 1; i <= n; ++i) {
if (i + k - 1 <= n) {
for (int j = i; j <= i + k - 1; ++j) {
v[j].push_back(i + k - 1 - (j - i));
}
}
}
for (int i = 1; i <= n; ++i) {
if (!color[i]) {
dfs(i, c);
c++;
}
}
long long sol = 1;
for (int i = 1; i < c; ++i) {
sol *= m;
sol %= mod;
}
cout << sol << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int maxn = 1e+5;
int n, m, k;
int main(int argc, const char* argv[]) {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &k);
long long ans = 1;
if (k > n || k <= 1) {
for (int i = 0; i < n; i++) {
ans = (ans * m) % MOD;
}
} else if (k == n) {
for (int i = 0; i < (n + 1) / 2; ++i) {
ans = (ans * m) % MOD;
}
} else if (k % 2 == 1) {
ans = m * m;
} else
ans = m;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
int n, m, k;
cin >> n >> m >> k;
long long ans = 1;
if (k == 1 || k > n) {
for (int i = 1; i <= n; i++) {
ans *= m;
ans %= mod;
}
} else if (k == n) {
for (int i = 1; i <= ceil(n / 2.0); i++) {
ans *= m;
ans %= mod;
}
} else if (k % 2 == 0) {
ans *= m;
} else
ans *= m * m;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, n, m, k, p;
string s;
int pr[10000];
bool f[10000];
const long long mod = 1000000007;
int get(int x) {
if (pr[x] == x) return x;
int k = get(pr[x]);
return pr[x] = k;
}
void unionn(int i, int j) {
int a = get(i), b = get(j);
if (a == b) return;
if (rand() & 1)
pr[a] = b;
else
pr[b] = a;
}
int main() {
cin >> n >> m >> k;
long long ans = 1;
if (k > n) {
for (int i = 0; i < n; i++) ans = (ans * (long long)m) % mod;
cout << ans;
return 0;
}
if (m == 1) {
cout << 1;
return 0;
}
for (int i = 0; i <= n; i++) {
pr[i] = i;
f[i] = false;
}
for (int i = 0; i < n - k + 1; i++) {
for (int j = 0; j < k / 2; j++) unionn(i + j, i + k - j - 1);
}
for (int i = 0; i < n; i++) {
int k = get(i);
if (!f[k]) {
ans = (ans * (long long)m) % mod;
}
f[k] = true;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int main() {
int n, m, k;
cin >> n >> m >> k;
long long ans = 1;
if (k == 1 || k > n) {
ans = 1;
for (int i = 0; i < n; i++) {
ans = (long long)ans * m % mod;
}
cout << ans << endl;
} else if (k == n) {
if (k % 2 == 1) {
ans = 1;
for (int i = 1; i <= n / 2 + 1; i++) ans = ans * m % mod;
cout << ans << endl;
} else {
for (int i = 1; i <= n / 2; i++) {
ans = ans * m % mod;
}
cout << ans << endl;
}
} else if (k % 2 == 0) {
cout << m << endl;
} else {
cout << m * m % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = (int)1e9 + 7;
long long n, m, k;
int main() {
cin >> n >> m >> k;
if (k == 1) {
long long res = 1;
for (int i = 1; i <= n; i++) res = (res * m) % oo;
cout << res << endl;
return 0;
}
if (n < k) {
long long res = 1;
for (int i = 1; i <= n; i++) res = (res * m) % oo;
cout << res << endl;
return 0;
} else if (n == k) {
long long res = 1;
for (int i = 1; i <= k / 2 + (k % 2); i++) res = (res * m) % oo;
cout << res << endl;
return 0;
}
if (k % 2) {
long long res = 1;
for (int i = 1; i <= min(k, 2LL); i++) res = res * m;
cout << res << endl;
} else {
cout << m << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1000000007;
int main() {
long long n, m, k;
while (cin >> n >> m >> k) {
long long ans;
if (k == 1) {
ans = 1;
for (long long i = 1; i <= n; i++) ans = ans * m % Mod;
cout << ans << endl;
continue;
}
if (k > n) {
ans = 1;
for (long long i = 1; i <= n; i++) ans = ans * m % Mod;
} else if (k < n) {
if (k % 2 == 0)
ans = m;
else
ans = m * m % Mod;
} else {
ans = 1;
n = (n + 1) / 2;
for (long long i = 1; i <= n; i++) ans = ans * m % Mod;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0, -1, 1, 1, -1}, dy[] = {0, -1, 0, 1, -1, -1, 1, 1};
int kx[] = {2, 1, -1, -2, -2, -1, 1, 2}, ky[] = {1, 2, 2, 1, -1, -2, -2, -1};
template <class T>
T _pow(T N, T P) {
return (P == 0) ? 1 : N * _pow(N, P - 1);
}
template <class T>
T _max(T a, T b) {
return (!(a < b) ? a : b);
}
template <class T>
T _min(T a, T b) {
return (a < b ? a : b);
}
bool isVowel(char ch) {
ch = tolower(ch);
return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u';
}
long long bigmod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return R;
}
long long nCr(double n, double r) {
double ans = 1;
if (r > n - r) r = n - r;
for (int i = 1; i <= r; i++) {
ans *= (n - i + 1);
ans /= i;
}
return (long long)ans;
}
long long modmul(long long a, long long b, long long m) {
return ((a % m) * (b % m)) % m;
}
string toString(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << bigmod(m, n, 1000000007);
else if (k == n)
cout << bigmod(m, (n + 1) / 2, 1000000007);
else if (k & 1)
cout << m * m;
else
cout << m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int p = 1000000007;
long long int res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y >>= 1;
x = (x * x) % p;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << power(m, n);
else if (k == n)
cout << power(m, (n + 1) / 2);
else if (k % 2)
cout << m * m;
else
cout << m;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || n < k) {
long long ans = 1;
for (int i = 1; i <= n; i++) {
ans *= m;
ans %= 1000000007;
}
cout << (ans % 1000000007) << endl;
} else if (n == k) {
long long ans = 1;
for (int i = 1; i <= (k + 1) / 2; i++) {
ans *= m;
ans %= 1000000007;
}
cout << (ans % 1000000007) << endl;
} else if (k & 1)
cout << m * m << endl;
else
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct d3point {
long double x;
long double y;
long double z;
} d3point;
d3point make_d3point(long double arg1, long double arg2, long double arg3) {
d3point *p = new d3point;
p->x = arg1;
p->y = arg2;
p->z = arg3;
return *p;
}
const double eps = 1e-15;
const int maxN = 1 * 100000 + 10, mod = (int)1e9 + 7;
int lengthM(int, int);
void dijkstraM(int);
void dfsM(int);
long long chooseM(int, int);
void primeM(int);
long long powerM(int, int);
long double distanceM(d3point, d3point);
int gcdM(int, int);
int m, n, k;
int main(void) {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
if (k == 1)
cout << powerM(m, n);
else if (k < n)
if (k % 2 == 0)
cout << m;
else
cout << m * m;
else if (n < k)
cout << powerM(m, n);
else
cout << powerM(m, (k + 1) / 2);
return 0;
}
int lengthM(int n, int r) {
int p = 0;
while (n) {
n /= r;
++p;
}
return p;
}
void dijkstraM(int i) {
vector<pair<int, int> > v[maxN];
int prev[maxN];
int dis[maxN];
int n;
int q;
set<pair<int, int> > st;
dis[i] = 0;
for (int j = 0; j < n; ++j) {
if (i != j) dis[j] = INT_MAX;
prev[j] = -1;
st.insert(make_pair(dis[j], j));
}
while (!st.empty()) {
q = st.begin()->second;
st.erase(st.begin());
for (int j = 0; j < (int)v[q].size(); ++j)
if (dis[v[q][j].first] > dis[q] + v[q][j].second) {
st.erase(make_pair(dis[v[q][j].first], v[q][j].first));
dis[v[q][j].first] = dis[q] + v[q][j].second;
prev[v[q][j].first] = q;
st.insert(make_pair(dis[v[q][j].first], v[q][j].first));
}
}
}
void dfsM(int i) {
bool mark[maxN] = {};
vector<int> v[maxN];
int prev[maxN];
mark[i] = 1;
for (int j = 0; j < (int)v[i].size(); ++j)
if (!mark[v[i][j]]) {
dfsM(v[i][j]);
prev[v[i][j]] = i;
}
}
long long chooseM(int arg1, int arg2) {
long long tmp1 = 1, tmp2 = 1;
if (arg2 > arg1 / 2) arg2 = arg1 - arg2;
for (int i = 1; i <= arg2; ++i) {
tmp1 = (tmp1 * i) % mod;
tmp2 = (tmp2 * (arg1 - i + 1)) % mod;
}
return tmp2 * powerM((int)tmp1, mod - 2);
}
void primeM(int last) {
bool isNotPrime[maxN] = {};
int minPrime[maxN];
vector<int> prime;
for (int i = 2; i < last + 1; ++i)
if (!isNotPrime[i]) {
prime.push_back(i);
for (int j = 2; j < last / i + 1; ++j) {
isNotPrime[j * i] = 1;
minPrime[i * j] = i;
}
}
}
long double distanceM(d3point d1, d3point d2) {
return sqrt(pow(d1.x - d2.x, 2) + pow(d1.y - d2.y, 2) + pow(d1.z - d2.z, 2));
}
long long powerM(int arg1, int arg2) {
if (arg2 == 0) return 1;
long long pow = powerM(arg1, arg2 / 2);
pow = (pow * pow) % mod;
if (arg2 % 2 == 1) pow = (pow * arg1) % mod;
return pow;
}
int gcdM(int arg1, int arg2) {
if (arg1 < arg2) swap(arg1, arg2);
while (0 < arg2) {
arg1 -= (arg1 / arg2) * arg2;
swap(arg1, arg2);
}
return arg1;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long exp(long long base, long long expz) {
long long res = 1;
while (expz > 0) {
if (expz % 2 == 1) res = (res * base) % mod;
base = (base * base) % mod;
expz /= 2;
}
return res % mod;
}
long long inverse(long long a) { return exp(a, mod - 2); }
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n, m, k;
cin >> n >> m >> k;
if (k < n && k != 1) {
if (k % 2) {
cout << m * m << "\n";
} else {
cout << m << "\n";
}
} else if (k == n) {
long long by = (k + 1) / 2;
cout << exp(m, by) << "\n";
} else {
cout << exp(m, n) << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int power(int a, int n) {
long long result = 1;
while (n--) result = (result * a) % 1000000007;
return result;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << power(m, n) << endl;
else if (k == n)
cout << power(m, (n + 1) >> 1) << endl;
else if (k & 1)
cout << m * m << endl;
else
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long inv(long long a, long long b) {
return (a > 1 ? b - inv(b % a, a) * b / a : 1);
}
const long double e = 2.71828182845904523536028747;
const long double PI = 3.14159265359;
const long long inf = (1LL << 62);
const int iinf = (1 << 30);
const int mod = 1e9 + 7;
int n, m, k;
int lgput(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = (1LL * ans * x) % mod;
x = (1LL * x * x) % mod;
y >>= 1;
}
return ans;
}
int main() {
cin >> n >> m >> k;
if (k > n || k == 1) return cout << lgput(m, n), 0;
if (k == n) return cout << lgput(m, (n + 1) / 2), 0;
if (k & 1) return cout << m * m, 0;
return cout << m, 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 2005, mod = 1000000000 + 7;
int Add(int a, int b) {
a += b;
return a >= mod ? a - mod : a;
}
int Sub(int a, int b) {
a -= b;
return a < 0 ? a + mod : a;
}
int Mul(int a, int b) { return (long long)a * b % mod; }
void add(int &a, int b) {
a += b;
(a >= mod) && (a -= mod);
}
void sub(int &a, int b) {
a -= b;
(a < 0) && (a += mod);
}
void mul(int &a, int b) { a = (long long)a * b % mod; }
int qpow(int a, int b) {
int ans = 1;
while (b) {
if (b & 1) mul(ans, a);
mul(a, a);
b >>= 1;
}
return ans;
}
int n, m, k;
void init() {
read(n);
read(m);
read(k);
}
void solve() {
if (k == 1) {
printf("%d\n", qpow(m, n));
return;
}
if (k > n) {
printf("%d\n", qpow(m, n));
return;
}
if (k == n) {
printf("%d\n", qpow(m, (n + 1) / 2));
return;
}
if (k % 2 == 0) {
printf("%d\n", m);
return;
}
printf("%d\n", Mul(m, m));
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, inf = 1000000007;
int main() {
cin >> n >> m >> k;
if (n < k) {
long long l = m;
for (long long i = 1; i < n; i++) l = l * m % inf;
cout << l << endl;
} else if (n == k) {
long long l = 1;
for (long long i = 1; i <= (n + 1) / 2; i++) l = l * m % inf;
cout << l << endl;
} else if (k & 1) {
if (k == 1) {
long long l = 1;
for (long long i = 1; i <= n; i++) l = l * m % inf;
cout << l << endl;
} else
cout << m * m << endl;
} else
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int model = 1e9 + 7;
const int maxn = 3000;
bool exist[maxn];
int fa[maxn];
int n, m, k;
int get_ans(int n, int m) {
long long ans = 1;
long long x = n;
while (m) {
if (m & 1) ans = (ans * x) % model;
m /= 2;
x = (x * x) % model;
}
return ans;
}
int get_fa(int x) {
if (fa[x] == x) return x;
fa[x] = get_fa(fa[x]);
return fa[x];
}
int main() {
cin >> n >> m >> k;
int len = 0;
if (n < k)
cout << get_ans(m, n) << endl;
else {
for (int i = 1; i <= n; i++) fa[i] = i;
for (int i = k; i <= n; i++) {
for (int j = 1; j * 2 <= k; j++) {
int x = get_fa(i - k + j), y = get_fa(i - j + 1);
if (x != y) fa[x] = y;
}
}
int len = 0;
memset(exist, true, sizeof exist);
for (int i = 1; i <= n; i++) {
int x = get_fa(i);
if (exist[x]) {
len++;
exist[x] = false;
}
}
cout << get_ans(m, len) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow(long long a, long long b) {
long long ans = 1;
while (b--) {
ans = (ans * a) % 1000000007;
}
return ans;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long ans = 0;
if (k == 1 || k > n) {
ans = pow(m, n);
} else if (k == n) {
ans = pow(m, (n + 1) / 2);
} else if ((k & 1) == 0) {
ans = m;
} else if ((k & 1) == 1) {
ans = m * m;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long qiu(int m, int n) {
long long a = 1;
for (int s = 1; s <= n; s++) {
a *= m;
if (a >= 1000000007) a = a % 1000000007;
}
return a;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k > n)
cout << qiu(m, n) << endl;
else if (k == n)
cout << qiu(m, (n + 1) / 2) << endl;
else if (k % 2 == 0)
cout << m << endl;
else if (k == 1)
cout << qiu(m, n) << endl;
else
cout << m * m << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long fp(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power & 1) result = (result * base) % 1000000007;
base = (base * base) % 1000000007;
power >>= 1;
}
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << fp(m, n) << endl;
else if (k == n)
cout << fp(m, (n + 1) / 2) << endl;
else {
if (k % 2)
cout << m * m << endl;
else
cout << m << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const int mod = 1e9 + 7;
long long Pow(int m, int n) {
long long res = 1;
for (int i = 0; i < n; i++) res = (res * m) % mod;
return res;
}
int main() {
int m, n, k;
cin >> m >> n >> k;
if (k == 1 || k > m)
cout << Pow(n, m);
else if (k == m)
cout << Pow(n, (k + 1) / 2);
else if (!(k % 2))
cout << n;
else if (k % 2)
cout << (n * n) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e6, mod = 1e9 + 7, inf = 1e10;
long long int a[N], dp[N];
int main() {
long long int n, m, k, ans, cnt;
cin >> n >> m >> k;
ans = m;
if (k == 1 || k > n) {
ans = 1;
for (long long int i = 0; i < n; i++) ans = (ans % mod * m % mod) % mod;
} else if (k == n) {
cnt = k / 2 + (k % 2);
ans = 1;
for (long long int i = 0; i < cnt; i++) ans = (ans % mod * m % mod) % mod;
} else if (k % 2)
ans = (m % mod * m % mod) % mod;
return cout << (ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Q = 1e9 + 7;
long long poww(long long a, long long b) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > Q) x %= Q;
}
y = (y * y);
if (y > Q) y %= Q;
b /= 2;
}
return x;
}
long long C[52][52];
void binomialCoeff() {
long long i, j;
for (i = 0; i <= 50; i++) {
for (j = 0; j <= 50; j++) {
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long ans = 0;
if (m == 1) {
ans = 1;
} else if (k == 1 || k > n) {
ans = poww(m, n);
} else if (n == k) {
ans = poww(m, (k + 1) / 2);
ans %= Q;
} else if (k % 2 != 0) {
ans = m * m;
ans %= Q;
} else {
ans = m;
ans %= Q;
}
ans %= Q;
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int S[2010];
int Find(int a) { return (a == S[a] ? S[a] : S[a] = Find(S[a])); }
void Union(int a, int b) {
a = Find(a);
b = Find(b);
rand() & 1 ? S[a] = b : S[b] = a;
}
int main() {
unsigned long long int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) S[i] = i;
for (int i = 0, j = k - 1; j < n; i++, j++)
for (int l = i, r = j; l < r; l++, r--) Union(l, r);
int cnt = 0;
for (int i = 0; i < n; i++)
if (i == S[i]) cnt++;
unsigned long long int res = 1;
for (int i = 0; i < cnt; i++) {
res *= m;
res %= 1000000007ULL;
}
cout << res;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, res, i;
int main() {
cin >> n >> m >> k;
if (n < k || k == 1) {
res = 1;
for (i = 0; i < n; i++) res = (res * m) % 1000000007;
} else if (n == k) {
res = 1;
for (i = 0; 2 * i < n; i++) res = (res * m) % 1000000007;
} else if (k % 2 == 0)
res = m;
else
res = m * m;
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const long long INF = 1e18;
const long double PI = 4 * atan((long double)1);
const int INFTY = 1e7;
class UnionFind {
private:
vector<int> parent, rank;
public:
UnionFind(int n) {
parent.resize(n, 0);
rank.resize(n, 0);
for (int i = 0; i < n; ++i) parent[i] = i;
}
int findSet(int u) {
return (parent[u] == u ? u : parent[u] = findSet(parent[u]));
}
bool inSameSet(int u, int v) { return findSet(u) == findSet(v); }
void unionSet(int u, int v) {
int x = findSet(u), y = findSet(v);
if (x == y) {
return;
}
if (rank[x] > rank[y]) {
parent[y] = x;
return;
}
parent[x] = y;
rank[y] += (rank[x] == rank[y]);
}
};
long long binpow(long long a, long long b) {
a %= MOD;
long long res = 1;
while (b) {
if (b & 1) {
res = (res * a) % MOD;
}
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
UnionFind uf(n);
long long can = n;
for (int start = 0; start <= n - k; start++) {
for (int front = start, back = start + k - 1; front < back;
front++, back--) {
if (!uf.inSameSet(front, back)) {
uf.unionSet(front, back);
can--;
}
}
}
long long ans = binpow(m, can);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2000;
int id[maxN], sz[maxN];
void initialize(int n) {
for (int i = 0; i < n; i++) {
id[i] = i;
sz[i] = 1;
}
}
int root(int x) {
while (x != id[x]) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void unionxy(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (sz[x] > sz[y]) {
id[y] = x;
sz[x] += sz[y];
} else {
id[x] = y;
sz[y] += sz[x];
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
initialize(n);
long long ans = 1;
for (int i = 0; i + k - 1 < n; i++) {
int left = i, right = i + k - 1;
while (left < right) {
unionxy(left, right);
left++;
right--;
}
}
for (int i = 0; i < n; i++) {
if (root(i) == i) ans = (ans * m) % 1000000007;
}
cout << ans << "\n";
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.