text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
const int Max = 2048;
int F[Max];
int getFa(int x) { return F[x] == -1 ? x : F[x] = getFa(F[x]); }
void merge(int x, int y) {
x = getFa(x);
y = getFa(y);
if (x == y) return;
F[y] = x;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
memset(F, -1, sizeof(F));
for (int i = 0; i < n; i++) {
for (int j = k - 1, d = 0; j > 0; j -= 2, d++) {
if (i - d < 0) break;
if (i + j >= n) continue;
if (i + j + d >= n) continue;
merge(i, i + j);
}
}
long long R = 1;
for (int i = 0; i < n; i++)
if (F[i] == -1) R = R * m % Mod;
printf("%I64d\n", R);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
void file() {}
void fast() {
std::ios_base::sync_with_stdio(0);
cin.tie(NULL);
}
int mod = 1e9 + 7;
long long fpow(long long x, long long p) {
if (!p) return 1;
long long sq = fpow(x, p / 2);
sq *= sq;
sq %= mod;
if (p & 1) sq *= x;
return sq % mod;
}
const int N = 2e3 + 9;
int mem[N];
vector<int> adjL[N];
int n, m, k;
int solve(int idx) {
if (idx >= n) return 1;
if (mem[idx] == 2) return 0;
if (mem[idx]) return 1;
mem[idx] = 1;
int ch = 1;
for (auto& it : adjL[idx]) ch = min(ch, solve(it));
return ch;
}
int main() {
file();
fast();
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
if (i + k - 1 >= n) break;
for (int j = 0; j < k / 2; j++)
adjL[j + i].push_back(k - j - 1 + i),
adjL[k - j - 1 + i].push_back(j + i);
}
long long ans = 1;
for (int i = 0; i < n; i++) {
ans *= max(1, solve(i) * m);
ans %= mod;
for (int j = 0; j < n; j++) mem[j] = (mem[j] ? 2 : 0);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int po(int m, int n) {
long long int ans = 1;
long long int p = m;
while (n) {
if (n % 2) {
ans *= p;
if (ans >= mod) ans %= mod;
}
p *= p;
if (p >= mod) p %= mod;
n /= 2;
}
return ans;
}
void solve() {
int N, M, K;
ios::sync_with_stdio(false);
cin >> N >> M >> K;
if (K > N || K == 1) {
cout << po(M, N) << endl;
} else if (K == N) {
cout << po(M, (N + 1) / 2) << endl;
} else if (K % 2) {
cout << M * M << endl;
} else
cout << M << endl;
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 100500;
const int maxn = 100500;
const int mod = 1000000007;
int mmul(int x, int y) { return (long long)x * y % mod; }
int madd(int x, int y) { return (x + y) % mod; }
int mpow(int x, int k) {
if (k == 0) return 1;
return mmul(x, mpow(x, k - 1));
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k > n)
cout << mpow(m, n) << endl;
else if (k == 1)
cout << mpow(m, n) << endl;
else if (k == n) {
if (k % 2 == 0)
cout << mpow(m, n / 2) << endl;
else
cout << mpow(m, n / 2 + 1) << endl;
} else if (k % 2 == 0)
cout << m << endl;
else
cout << mpow(m, 2) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int t, f;
long long w;
bool operator<(const edge& e) const { return w > e.w; }
edge(int from, int to, int weight) {
t = to;
f = from;
w = weight;
}
};
const double EPS = (1e-5);
int dcmp(double a, double b) { return fabs(a - b) <= EPS ? 0 : a < b ? -1 : 1; }
struct Double {
double d;
Double() { d = 0.0; };
Double(double d) : d(d) {}
bool operator<(const Double& D) const { return dcmp(d, D.d) < 0; }
bool operator>(const Double& D) const { return dcmp(d, D.d) > 0; }
bool operator==(const Double& D) const { return dcmp(d, D.d) == 0; }
};
bool intersectSegments(complex<double> a, complex<double> b, complex<double> c,
complex<double> d, complex<double>& intersect) {
double d1 = ((conj(a - b) * (d - c)).imag()),
d2 = ((conj(a - c) * (d - c)).imag()),
d3 = ((conj(a - b) * (a - c)).imag());
if (fabs(d1) < EPS) return false;
double t1 = d2 / d1, t2 = d3 / d1;
intersect = a + (b - a) * t1;
if (t1 < -EPS || t2 < -EPS || t2 > 1 + EPS) return false;
return true;
}
class UnionFind {
public:
vector<int> p, rank, setSize;
int numSets;
UnionFind(int N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (int i = 0; i < N; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
long long root(long long x) {
long long l = 0, r = 1e9 + 1;
while (l < r - 1) {
long long m = (l + r) / 2;
if (m * m > x)
r = m;
else
l = m;
}
return l;
}
struct line {
double a, b, c;
};
long long binpowmod(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long binpow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
int findXOR(int n) {
switch (n % 4) {
case 0:
return n;
case 1:
return 1;
case 2:
return n + 1;
case 3:
return 0;
}
}
int rangeXOR(int l, int r) { return (findXOR(l - 1) ^ findXOR(r)); }
int getbit(int mask, int bit) { return (mask & (1 << bit)); }
void setbit(int& mask, int bit, int val) {
if (val)
mask |= (1 << bit);
else
mask &= ~(1 << bit);
}
const int N = 1e5 + 10;
const int M = 500 + 10;
const long long INF = 1e13 + 100;
const int MOD = 1e9 + 7;
class SegmentTree {
struct node {
int l, r, h;
node() {
l = 0;
r = 0;
h = 0;
}
node(int x) {
l = 0;
r = 0;
h = 0;
if (x == 1)
l = 1;
else
r = 1;
}
node(int _l, int _r, int _h) {
l = _l;
r = _r;
h = _h;
}
};
private:
vector<node> st;
vector<int> lp;
vector<int> A;
int n;
int left(int p) { return p << 1; }
int right(int p) { return (p << 1) + 1; }
node merge(node p1, node p2) {
int l = p1.l + p2.l;
int r = p1.r + p2.r;
int x = min(p1.l, p2.r);
l -= x;
r -= x;
return node(l, r, p1.h + p2.h + x);
}
node lazy(node x, int y) { return x; }
void build(int p, int L, int R) {
if (L == R) {
st[p] = node(A[L]);
} else {
build(left(p), L, (L + R) / 2);
build(right(p), (L + R) / 2 + 1, R);
node p1 = st[left(p)], p2 = st[right(p)];
st[p] = merge(p1, p2);
}
}
node rmq(int p, int L, int R, int i, int j) {
if (i > R || j < L) return node(-1, -1, -1);
if (L >= i && R <= j) return st[p];
node p1 = rmq(left(p), L, (L + R) / 2, i, j);
node p2 = rmq(right(p), (L + R) / 2 + 1, R, i, j);
if (p1.l == -1) return p2;
if (p2.l == -1) return p1;
return merge(p1, p2);
}
void update_point(int p, int L, int R, int idx, int v) {
int i = idx, j = idx;
if (i > R || j < L) return;
if (L == i && R == j) {
A[L] = v;
st[p] = node(v);
return;
}
node p1, p2;
update_point(left(p), L, (L + R) / 2, idx, v);
update_point(right(p), (L + R) / 2 + 1, R, idx, v);
p1 = st[left(p)];
p2 = st[right(p)];
st[p] = merge(p1, p2);
}
void update_range(int p, int L, int R, int i, int j, int mode) {
if (lp[p] != 0) {
st[p] = lazy(st[p], lp[p]);
if (L != R) {
lp[left(p)] += lp[p];
lp[right(p)] += lp[p];
}
lp[p] = 0;
}
if (i < L && j < L || i > R && j > R) return;
if (L >= i && R <= j) {
st[p] = lazy(st[p], mode);
if (L != R) {
lp[left(p)] += mode;
lp[right(p)] += mode;
}
return;
}
update_range(left(p), L, (L + R) / 2, i, j, mode);
update_range(right(p), (L + R) / 2 + 1, R, i, j, mode);
st[p] = merge(st[left(p)], st[right(p)]);
}
public:
SegmentTree(const vector<int>& _A) {
A = _A;
n = (int)A.size();
st.assign(4 * n, node());
lp.assign(4 * n, 0);
build(1, 0, n - 1);
}
node rmq(int i, int j) { return rmq(1, 0, n - 1, i, j); }
void update_point(int idx, int new_value) {
update_point(1, 0, n - 1, idx, new_value);
}
void update_range(int i, int j, int mode) {
update_range(1, 0, n - 1, i, j, mode);
}
};
vector<vector<long long>> pas;
void pascal(int n) {
pas.assign(n + 1, vector<long long>(n + 1));
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= i; ++j) {
if (i == j || !j)
pas[i][j] = 1;
else
pas[i][j] = (pas[i - 1][j - 1] + pas[i - 1][j]) % MOD;
}
}
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
long long ans = 0;
if (k > n || k == 1) {
ans = binpowmod(m, n, MOD);
} else if (k == n) {
ans = binpowmod(m, (n + 1) / 2, MOD);
} else {
ans = m;
if (k & 1) ans = (ans * ans) % MOD;
}
cout << ans << '\n';
}
int main(void) {
pascal(2000);
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int tc = 1;
while (tc--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
long long n, m, k;
cin >> n >> m >> k;
long long ans;
if (k == 1 || k > n) {
ans = 1;
for (int i = 0; i < n; i++) ans = (ans * m) % 1000000007;
} else if (n == k) {
ans = 1;
for (int i = 0; i < (n + 1) / 2; i++) ans = (ans * m) % 1000000007;
} else {
ans = (k % 2) ? m * m : m;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long POW(int m, int n) {
if (n == 1) return m;
long long t = POW(m, n / 2);
t = t * t % 1000000007;
if (n % 2) t = t * m % 1000000007;
return t;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k == 1 || k > n)
printf("%d\n", POW(m, n));
else if (k == n)
printf("%d\n", POW(m, (n + 1) / 2));
else if (k % 2)
printf("%d\n", m * m);
else
printf("%d\n", m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int ans = 1, p = 1e9 + 7;
int n, m, k;
cin >> n >> m >> k;
if (k > n || k == 1) {
for (int i = 1; i <= n; i++) ans *= m, ans %= p;
cout << ans;
return 0;
} else if (k == n) {
for (int i = 1; i <= (k + 1) / 2; i++) ans *= m, ans %= p;
cout << ans;
return 0;
}
if (k < n) {
cout << (k % 2 ? m * m : m);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
int n = 0, m = 0, k = 0;
int main() {
unsigned long long ans = 1;
cin >> n >> m >> k;
if (k == 1 || k > n) {
for (int i = 1; i <= n; ++i) {
ans = ans * m % 1000000007;
}
} else if (k == n) {
for (int i = 1; i <= (n + 1) / 2; ++i) {
ans = ans * m % 1000000007;
}
} else if (k % 2 == 0 && k != n && k != 1 && k < n) {
ans = m;
} else if (k % 2 == 1 && k != n && k != 1 && k < n) {
ans = m * m % 1000000007;
}
cout << ans << endl;
return 0;
}
|
#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;
int main() {
int n, m, k;
cin >> n >> m >> k;
long long ans = 0;
long long ret = 1000 * 1000 * 1000 + 7;
if (k > n || k == 1) {
ans = 1;
for (int i = 0; i < n; i++) ans = (ans * m) % ret;
cout << ans << endl;
return 0;
}
if (k == n) {
ans = 1;
for (int i = 0; i < (n + 1) / 2; i++) ans = (ans * m) % ret;
cout << ans << endl;
return 0;
}
if (k % 2 == 0) {
cout << m << endl;
return 0;
}
cout << m * m << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
long long int result;
if (n < k or k == 1) {
result = 1;
for (int i = 1; i <= n; i++) result = (result * m) % mod;
} else if (n > k) {
if (k % 2)
result = (m * m) % mod;
else
result = m % mod;
} else {
result = 1;
for (int i = 0; i < n / 2; i++) result = (result * m) % mod;
if (n % 2) result = (result * m) % mod;
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007LL;
long long n, m, k;
int main() {
cin >> n >> m >> k;
if (k == 1 || k > n) {
long long r = 1;
for (int i = 0; i < n; i++) r = (r * m) % mod;
cout << r << endl;
} else if (k == n) {
long long r = 1;
for (int i = 0; i < (n + 1) / 2; i++) r = (r * m) % mod;
cout << r << endl;
} else {
if (k % 2 == 0)
cout << m << endl;
else {
long long r = m * (m) % mod;
cout << r << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int mpow(long long a, int p) {
long long res = 1;
for (; p > 0; p >>= 1) {
if (p & 1) {
res = res * a % mod;
}
a = a * a % mod;
}
return res;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k > n || k == 1) {
cout << mpow(m, n);
} else if (k == n) {
cout << mpow(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() {
int n, m, k;
cin >> n >> m >> k;
long long ans = 1;
if (k > n || k == 1) {
for (int i = 0; i < n; i++) {
ans = (ans * m) % 1000000007;
}
} else if (k == n) {
for (int i = 0; i < ((n + 1) / 2); i++) {
ans = (ans * 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 main() {
long long 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 %= 1000000007;
}
} else if (k == n) {
for (int i = 1; i <= (n + 1) / 2; ++i) {
ans *= m;
ans %= 1000000007;
}
} else {
if (k % 2) {
ans = m * m;
} else {
ans = m;
}
}
cout << (ans % 1000000007) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2018, M = 1000000007;
int n, m, k, dsu[N];
int find(int x) { return dsu[x] == x ? x : dsu[x] = find(dsu[x]); }
void Union(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
dsu[x] = y;
}
int connect(int l, int r) {
while (l < r) {
Union(l, r);
++l;
--r;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) dsu[i] = i;
for (int i = 1; i <= n - k + 1; ++i) connect(i, i + k - 1);
int ans = 1;
for (int i = 1; i <= n; ++i)
if (dsu[i] == i) ans = (1LL * m * ans) % M;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, k, S = 1, M = 1000000007;
scanf("%lld %lld %lld", &n, &m, &k);
if (k == 1 | k > n) {
for (int i = 1; i <= n; i++) {
S = S * m;
S = S % M;
}
printf("%lld", S);
return 0;
}
if (k == n) {
for (int i = 1; i <= (n + 1) / 2; i++) {
S = S * m;
S = S % M;
}
printf("%lld", S);
return 0;
}
if (k % 2 == 1) {
if (n >= 2) {
S = m * m;
S = S % M;
}
if (n == 1) {
S = m;
}
printf("%lld", S);
} else {
printf("%lld", m);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k > n || k == 1) {
long long x = 1;
for (int i = 1; i <= n; i++) {
x *= m;
x %= 1000000007;
}
cout << x << endl;
return 0;
}
if (k == n) {
long long x = 1;
for (int i = 1; i <= (n + 1) / 2; i++) {
x *= m;
x %= 1000000007;
}
cout << x << endl;
return 0;
}
int ans;
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;
const int MOD = 1000000007;
long long Get(int power) {
if (power == 0) return 1;
if (power == 1) return m;
long long tmp = Get(power / 2);
tmp = (tmp * tmp) % MOD;
if (power % 2 == 1) tmp = (tmp * m) % MOD;
return tmp;
}
void Main(const int cas) {
if (n < k || k == 1)
cout << Get(n) << endl;
else if (n == k)
cout << Get((n + 1) / 2) << endl;
else if (n > k) {
if (k % 2 == 0)
cout << m << endl;
else if (k % 2 == 1)
cout << m * m << endl;
}
}
int main() {
int cas = 1;
while (scanf("%d%d%d", &n, &m, &k) != EOF && (n || m || k)) {
Main(cas++);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, d, dsu[2069], dv = 1e9 + 7;
long long fd(long long x) {
if (dsu[x] != x) {
dsu[x] = fd(dsu[x]);
}
return dsu[x];
}
int main() {
long long i, j, z = 1;
scanf("%lld%lld%lld", &n, &m, &d);
for (i = 1; i <= n; i++) {
dsu[i] = i;
}
for (i = 0; i <= n - d; i++) {
for (j = 1; j < d + 1 - j; j++) {
dsu[fd(i + d + 1 - j)] = fd(i + j);
}
}
for (i = 1; i <= n; i++) {
if (fd(i) == i) {
z = z * m % dv;
}
}
printf("%lld\n", z);
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
long long n, m, k;
long long binpow(long long n, long long m) {
if (m == 0) return 1;
if (m == 1) return n;
long long ret = binpow(n, m / 2) % 1000000007;
ret = ret * ret % 1000000007;
if (m % 2) ret *= n;
ret = ret % 1000000007;
return ret;
}
int main(int argc, char const *argv[]) {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
if (k > n or k == 1) {
cout << binpow(m, n) << endl;
} else if (k == n) {
long long ret = binpow(m, n / 2);
if (n % 2) ret *= m;
ret = ret % 1000000007;
cout << ret << endl;
} else if (k % 2) {
cout << binpow(m, 2) << endl;
} else {
cout << m << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pnt[4000];
int find(int x) {
if (x != pnt[x]) pnt[x] = find(pnt[x]);
return pnt[x];
};
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) pnt[i] = i;
for (int i = 0; i + k <= n; i++) {
for (int j = 0; j < k; j++) {
int t = i + j;
int rt = i + k - j - 1;
pnt[find(t)] = find(rt);
}
}
int ans = 1;
for (int i = 0; i < n; i++)
if (i == pnt[i]) {
ans = (long long)ans * m % 1000000007;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[2001];
bool vis[2001];
void dfs(long long x) {
vis[x] = 1;
for (int i = 0, sz = adj[x].size(); i < sz; i++) {
long long y = adj[x][i];
if (!vis[y]) dfs(y);
}
return;
}
int main() {
long long n, m, k, component, res;
while (scanf("%lld %lld %lld", &n, &m, &k) == 3) {
component = 0;
for (long long i = 1; i + k - 1 <= n; i++) {
long long x = k;
for (long long j = i; x > 1; j++, x -= 2) {
adj[j].push_back(j + x - 1);
adj[j + x - 1].push_back(j);
}
}
memset(vis, 0, sizeof vis);
for (long long i = 1; i <= n; i++)
if (!vis[i]) dfs(i), component++;
res = 1;
for (long long i = 0; i < component; i++) res = (res * m) % 1000000007;
printf("%lld\n", res);
for (long long i = 1; i <= n; i++) adj[i].clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const int maxN = 2e3;
int n, m, k;
int parent[maxN];
int root(int u) {
if (parent[u] < 0) return (u);
return (parent[u] = root(parent[u]));
}
void merge(int u, int v) {
u = root(u), v = root(v);
if (u == v) return;
if (parent[v] < parent[u]) swap(parent[u], parent[v]);
parent[u] += parent[v];
parent[v] = u;
}
int setSize(int u) { return (-1 * parent[root(u)]); }
long long int modPow(long long int x, long long int y) {
if (y == 0) return (1);
long long int ret = modPow(x, y >> 1);
ret = (ret * ret) % mod;
if (y & 1) ret = (ret * x) % mod;
return (ret);
}
int main() {
memset(parent, -1, sizeof(parent));
scanf("%d %d %d", &n, &m, &k);
if (k > n)
printf("%lld\n", modPow(m, n));
else {
for (int i = 0; i <= n - k; i++)
for (int u = i, v = i + k - 1; u < v; u++, v--) merge(u, v);
long long int ans = 1;
for (int i = 0; i < n; i++)
if (parent[i] < 0) ans = (ans * m) % mod;
printf("%lld\n", ans);
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(1e5) + 100;
long long n, m, k;
const long long mod = (int)(1e9) + 7;
long long bp(long long a, long long b) {
if (b == 0) return 1ll;
if (b == 1) return a;
long long x = bp(a, b / 2) % mod;
long long y = bp(a, b % 2) % mod;
return (((x * x) % mod) * y) % mod;
}
int main() {
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << bp(m, n) % mod;
else if (k == n)
cout << bp(m, (n + 1) / 2) % mod;
else if (k % 2 == 1)
cout << bp(m, 2) % mod;
else if (k % 2 == 0)
cout << m % mod;
return 0;
}
|
#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; }
vector<long long> g[N];
long long n, m, k, p;
void input() {
cin >> n >> m >> k;
p = k % 2;
}
void makeGraph() {
for (long long i = 1; i <= n; i++)
for (long long j = i + 1; j <= n; j++) {
long long diff = abs(j - i);
if (diff < k && diff % 2 != p && k <= n) {
int now = j - i + 1;
int go = (k - now) / 2;
int rmost = go + j;
int lmost = i - go;
if (rmost <= n && lmost >= 1) {
g[i].push_back(j);
g[j].push_back(i);
}
}
}
}
long long col[N];
void dfs(long long u) {
col[u] = 1;
for (long long i = 0; i < g[u].size(); i++)
if (!col[g[u][i]]) dfs(g[u][i]);
}
long long ccp() {
memset(col, 0, sizeof col);
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
if (!col[i]) {
cnt++;
dfs(i);
}
}
return cnt;
}
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() {
input();
makeGraph();
long long ans = POW(m, ccp());
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
using ll = long long;
template <typename T>
void DEBUG(string label, T value) {
cerr << "[" << label << " = " << value << "]\n";
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
const int MOD = 1e9 + 7;
if (k == 1 || k > n) {
ll ans = 1;
for (int i = 0; i < n; ++i) {
ans = ans * m % MOD;
}
cout << ans << '\n';
} else if (k == n) {
if (n % 2 == 0) {
ll ans = 1;
for (int i = 0; i < n / 2; ++i) {
ans = ans * m % MOD;
}
cout << ans << '\n';
} else {
ll ans = m;
for (int i = 0; i < (n - 1) / 2; ++i) {
ans = ans * m % MOD;
}
cout << ans << '\n';
}
} else if (k % 2 == 0) {
cout << m << '\n';
} else {
ll ans = (1LL * m * m) % MOD;
cout << ans << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[2345];
bool vis[2345];
void dfs(int u) {
for (int i = 0; i < adj[u].size(); i++) {
if (!vis[adj[u][i]]) {
vis[adj[u][i]] = true;
dfs(adj[u][i]);
}
}
}
int main() {
long long n, m, k;
long long M = 1000000007;
cin >> n >> m >> k;
for (int i = 0; i <= n - k; i++) {
int l = i, r = i + k - 1;
while (l <= r) {
adj[l].push_back(r);
adj[r].push_back(l);
l++;
r--;
}
}
long long cc = 0;
for (int i = 0; i < n; i++) {
if (!vis[i]) {
cc++;
dfs(i);
}
}
if (k > n) cc = n;
long long ans = 1;
for (int i = 0; i < cc; i++) {
ans = (ans * m) % M;
}
cout << ans << endl;
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;
while (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 mod = 1000000007;
int f[10000];
int s(int k) {
if (f[k] == k)
return k;
else
return f[k] = s(f[k]);
}
int n, m, k;
void unions(int p1, int p2) {
int f1 = s(p1), f2 = s(p2);
if (f1 > f2) swap(f1, f2);
f[f1] = f2;
}
long long ks(int k) {
if (k == 0) return 1;
if (k == 1) return m;
long long tmp = ks(k / 2);
tmp = (tmp * tmp) % mod;
if (k & 1)
return tmp * m % mod;
else
return tmp;
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) == 3) {
for (int i = 1; i <= n; ++i) f[i] = i;
for (int i = 1; i <= n - k + 1; ++i)
for (int j = 1; j <= k / 2; ++j) unions(i + j - 1, i + k - j);
int k = 0;
for (int i = 1; i <= n; ++i)
if (s(i) == i) ++k;
cout << ks(k) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2010, M = 1e9 + 7;
int n, m, k, cmp, par[N];
int root(int u) { return (par[u] == u) ? u : par[u] = root(par[u]); }
long long _pow(int a, int b) {
if (!b) return 1;
if (b == 1) return a;
return (b % 2) ? (1LL * _pow(a, b / 2) * _pow(a, b / 2) * a) % M
: (1LL * _pow(a, b / 2) * _pow(a, b / 2)) % M;
}
int main() {
ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
cin >> n >> m >> k;
cmp = n;
for (int i = 0; i < n; i++) par[i] = i;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i && (2 * j) + 1 < k; j++) {
if (i + k - j - 1 < n && root(i) != root(i + k - (2 * j + 1))) {
par[root(i)] = par[i + k - (2 * j + 1)];
cmp--;
}
}
}
long long ans = 1;
for (int i = 0; i < cmp; i++) {
ans *= m;
ans %= M;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
int main() {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
long long ret = 1;
if (c > a || c == 1) {
for (int i = 0; i < a; i++) ret = ret * b % mod;
} else if (c == a) {
for (int i = 0; i < (a + 1) / 2; i++) ret = ret * b % mod;
} else if (c % 2 == 1) {
ret = b * b;
} else
ret = b;
printf("%d\n", ret);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, num;
int father[3000];
long long ans;
int f(int x) { return father[x] == x ? x : father[x] = f(father[x]); }
void u(int x, int y) {
x = f(x);
y = f(y);
if (x != y) father[x] = y;
}
int main() {
while (cin >> n >> m >> k) {
num = 0, ans = 1;
for (int i = 1; i <= n; ++i) father[i] = i;
for (int i = 1; i + k - 1 <= n; ++i) {
int x = i, y = i + k - 1;
while (x < y) {
u(x, y);
x++, y--;
}
}
for (int i = 1; i <= n; ++i)
if (father[i] == i) num++;
for (int i = 0; i < num; ++i) ans *= m, ans %= 1000000007;
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1000000007;
long long Pow(long long b, long long s) {
long long ret = 1;
for (int i = 0; i < s; ++i) {
ret = (ret * b) % P;
}
return ret;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << Pow(m, n) << endl;
return 0;
}
if (n == k) {
cout << Pow(m, (n + 1) / 2) << endl;
return 0;
}
if (k & 1) {
cout << m * m << endl;
return 0;
}
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, u, v, n, c, d, m, q, l, r, ql, qr, x, k;
const int N = 1e5 + 5;
const long long mod = 1e9 + 7;
const bool JUDGE = false;
vector<int> adj[N];
bool vis[N];
void dfs(int x) {
if (vis[x]) return;
vis[x] = true;
for (long long i = 0; i < adj[x].size(); i++) {
dfs(adj[x][i]);
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (JUDGE) {
freopen("cf.txt", "r", stdin);
freopen("cf_out.txt", "w", stdout);
}
cin >> n >> m >> k;
if (k & 1) {
for (long long i = k / 2; i < n - k / 2; i++) {
for (long long j = 1; j < k / 2 + 1; j++) {
adj[i - j].push_back(i + j);
adj[i + j].push_back(i - j);
}
}
} else {
for (long long i = k / 2 - 1; i < n - k / 2; i++) {
for (long long j = 0; j < k / 2; j++) {
int v = i - j;
int u = i + j + 1;
adj[u].push_back(v);
adj[v].push_back(u);
}
}
}
int e = 0;
memset(vis, false, sizeof(vis));
for (long long i = 0; i < n; i++) {
if (!vis[i]) {
e++;
dfs(i);
}
}
long long ans = 1;
for (long long i = 0; i < e; i++) {
ans = (ans * m) % mod;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 + 5, mod = 1000000007;
int n, m, k;
bool vis[maxn];
inline void bfs(int st) {
queue<int> q;
q.push(st);
vis[st] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int l = max(u - k + 1, 1); l <= min(u, n - k + 1); ++l) {
int v = l + (k - (u - l + 1));
if (v <= n && !vis[v]) {
vis[v] = true;
q.push(v);
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
long long ans = 1;
for (int i = 1; i <= n; ++i)
if (!vis[i]) {
bfs(i);
ans = (ans * m) % mod;
}
printf("%d\n", (int)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2222;
vector<int> conn[N];
bitset<N> seen;
void dfs(int a) {
seen[a] = true;
for (int &b : conn[a]) {
if (!seen[b]) dfs(b);
}
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= min(n / 2, i); j++) {
int del = k - j;
int nj = i - j + 1 + del;
if (nj <= i or nj > n or i + del > n) continue;
conn[i].push_back(nj);
conn[nj].push_back(i);
}
}
int result = 1;
for (int i = 1; i <= n; i++) {
if (seen[i] == false) {
dfs(i);
result = result * 1LL * m % mod;
}
}
cout << result << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m, k;
int main() {
cin >> n >> m >> k;
if (n < k || k == 1) {
long long ans = 1;
for (int i = 1; i <= n; i++) {
ans = (ans * m) % mod;
}
cout << ans << endl;
} else if (n == k) {
long long ans = 1;
for (int i = 1; i <= (n + 1) / 2; i++) {
ans = (ans * m) % mod;
}
cout << ans << endl;
} else if (k % 2 == 1) {
cout << m * m % mod << endl;
} else {
cout << m << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
int n, m, k;
int main() {
int i;
while (~scanf("%d%d%d", &n, &m, &k)) {
long long ans = 1;
if (n < k) {
for (i = 1; i <= n; i++) ans = (ans * m) % mod;
printf("%I64d\n", ans);
} else if (n > k) {
if (k == 1) {
for (i = 1; i <= n; i++) ans = (ans * m) % mod;
printf("%I64d\n", ans);
} else
printf("%d\n", (k % 2) ? m * m : m);
} else {
int tmp = n / 2 + (n % 2 == 1);
for (i = 1; i <= tmp; i++) ans = (ans * m) % mod;
printf("%I64d\n", ans);
}
}
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int exp(int x, int y) {
int res = 1;
while (y) {
if (y % 2) res = 1LL * res * x % MOD;
x = 1LL * x * x % MOD;
y /= 2;
}
return res;
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k == 1 or k > n) {
cout << exp(m, n) << endl;
} else if (k == n) {
cout << exp(m, (1 + n) / 2) << endl;
} else {
if (k % 2)
cout << exp(m, 2) << endl;
else
cout << m << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
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 = ans * m;
ans %= MOD;
}
} else if (k == n) {
for (int i = 1; i <= (n + 1) / 2; ++i) {
ans = ans * m;
ans %= MOD;
}
} else if (k % 2) {
ans = m * m % MOD;
} else {
ans = m;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
const int mod = 1e9 + 7;
vector<int> node[maxn];
int n, m, k;
long long ans = 1;
bool mark[maxn];
void conect(int L, int R) {
while (L < R) {
node[L].push_back(R);
node[R].push_back(L);
L++;
R--;
}
}
void dfs(int root) {
mark[root] = true;
for (int i = 0; i < node[root].size(); i++)
if (!mark[node[root][i]]) dfs(node[root][i]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 1; i <= n - k + 1; i++) conect(i, i + k - 1);
int moal = 0;
for (int i = 1; i <= n; i++)
if (!mark[i]) {
dfs(i);
moal++;
}
while (moal > 0) {
ans = (ans * m) % mod;
moal--;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::map;
using std::max;
using std::min;
using std::numeric_limits;
using std::set;
using std::stack;
using std::string;
using std::stringstream;
using std::vector;
vector<int> parent;
vector<int> rank;
void make_set(int v) {
parent[v] = v;
rank[v] = 0;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (rank[a] < rank[b]) std::swap(a, b);
parent[b] = a;
if (rank[a] == rank[b]) ++rank[a];
}
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
rank.assign(n, 0);
parent.assign(n, 0);
for (int i = 0; i < n; ++i) make_set(i);
for (int i = 0; i + k - 1 < n; ++i)
for (int j = 0; j < k / 2; ++j) union_sets(i + j, i + k - j - 1);
set<int> a;
for (int i = 0; i < n; ++i) a.insert(find_set(i));
long long mod = 1000000007;
long long ans = 1;
for (int i = 0; i < a.size(); ++i) ans = (ans * m) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
string a, b, c;
int q, n, t, m, k;
int par[1000009];
int brr[1000009];
vector<int> adj[1000009];
int root(int v) { return par[v] < 0 ? v : (par[v] = root(par[v])); }
void merge(int x, int y) {
if ((x = root(x)) == (y = root(y))) return;
if (par[y] < par[x]) swap(x, y);
par[x] += par[y];
par[y] = x;
}
int main() {
cin >> n >> m >> k;
memset(par, -1, sizeof(par));
for (int i = 1; i <= n; i++) {
if (i + k - 1 > n) break;
;
for (int j = 0; j < (k / 2); j++) merge(i + j, i + k - 1 - j);
}
long long c = 0;
set<int> s;
s.clear();
for (int i = 1; i <= n; i++) s.insert(root(i));
cout << power(m, 1ll * (s.size()));
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 23;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
void mul(int &a, int b) { a = a * 1LL * b % MOD; }
int main() {
ios_base::sync_with_stdio(0);
int n, m, k;
cin >> n >> m >> k;
if (n < k || k == 1) {
int ans = 1;
for (int i = (0); i < (n); ++i) mul(ans, m);
cout << ans << "\n";
return 0;
}
if (n == k) {
int ans = 1;
for (int i = (0); i < ((n + 1) / 2); ++i) mul(ans, m);
cout << ans << "\n";
return 0;
}
if (k & 1) {
cout << m * m << "\n";
return 0;
}
cout << m << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long cal(int a, int b) {
long long ret = 1;
int i;
for (i = 1; i <= b; i++) {
ret = (ret * a) % mod;
}
return ret;
}
int main() {
int n, m, k;
int i, j;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
long long res = 1;
if (k == 1) {
res = cal(m, n);
} else if (k & 1) {
if (n > k) {
res = m * m;
} else if (k == n) {
res = cal(m, (n + 1) / 2);
} else {
res = cal(m, n);
}
} else {
if (n > k) {
res = m;
} else if (k == n) {
res = cal(m, n / 2);
} else {
res = cal(m, n);
}
}
printf("%I64d\n", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
const int MOD = 1000000007;
const int INF = 2000000000;
const long long DESPACITO = 1000000000000000000;
namespace minmax {
template <class T>
T max(T&& A) {
return A;
}
template <class T>
T min(T&& A) {
return A;
}
template <class T>
T max(T&& A, T&& B) {
return A > B ? A : B;
}
template <class T>
T chmin2(T&& A, T&& B) {
return A < B ? A : B;
}
template <class T, class... Ts>
T max(T&& A, Ts&&... ts) {
T B = max(ts...);
return A > B ? A : B;
}
template <class T, class... Ts>
T min(T&& A, Ts&&... ts) {
T B = min(ts...);
return A < B ? A : B;
}
template <class T, class... Ts>
T chmax(T&& A, Ts&&... ts) {
A = max(A, ts...);
return A;
}
template <class T, class... Ts>
T chmin(T&& A, Ts&&... ts) {
A = min(A, ts...);
return A;
}
template <class T1, class T2>
void chmin2(T1&& A, T2&& Aa, T1&& B, T2&& Bb) {
if (B < A) A = B, Aa = Bb;
}
template <class T1, class T2>
void chmax2(T1&& A, T2&& Aa, T1&& B, T2&& Bb) {
if (B > A) A = B, Aa = Bb;
}
} // namespace minmax
namespace input {
template <class T>
void re(T&& Xx) {
cin >> Xx;
}
template <class T1, class T2>
void re(pair<T1, T2>& Pp) {
re(Pp.first);
re(Pp.second);
}
template <class T>
void re(vector<T>& Aa) {
for (int i = 0; i < (int)(Aa).size(); i++) re(Aa[i]);
}
template <class T1, class T2>
void rea(T1&& Aa, T2 t) {
for (int i = 0; i < t; i++) re(Aa[i]);
}
template <class T1, class T2, class... Ts>
void rea(T1&& Aa, T2 t, Ts&&... ts) {
rea(Aa, t);
rea(ts...);
}
template <class T1, class T2>
void rea1(T1&& Aa, T2 t) {
for (int i = 1; i <= t; i++) re(Aa[i]);
}
template <class T1, class T2, class... Ts>
void rea1(T1&& Aa, T2 t, Ts&... ts) {
rea1(Aa, t);
rea1(ts...);
}
template <class T, class... Ts>
void re(T&& t, Ts&... ts) {
re(t);
re(ts...);
}
} // namespace input
namespace output {
void pr(int32_t Xx) { cout << Xx; }
void pr(bool Xx) { cout << Xx; }
void pr(long long Xx) { cout << Xx; }
void pr(long long unsigned Xx) { cout << Xx; }
void pr(double Xx) { cout << Xx; }
void pr(char Xx) { cout << Xx; }
void pr(const string& Xx) { cout << Xx; }
void pr(const char* Xx) { cout << Xx; }
void pr(const char* Xx, size_t len) { cout << string(Xx, len); }
void ps() { cout << "\n"; }
void pn() {}
void pw() { pr(" "); }
void pc() {
pr("]");
ps();
}
template <class T1, class T2>
void pr(const pair<T1, T2>& Xx) {
pr(Xx.first);
pw();
pr(Xx.second);
}
template <class T>
void pr(const T&);
bool parse(const char* t) {
if (t == "\n") return true;
return false;
}
template <class T>
bool parse(T&& t) {
return false;
}
template <class T1, class T2>
bool parsepair(const pair<T1, T2>& Xx) {
return true;
}
template <class T>
bool parsepair(T&& t) {
return false;
}
template <class T1, class T2>
void psa(T1&& Aa, T2 t) {
for (int i = 0; i < t; i++) pr(Aa[i]), pw();
ps();
}
template <class T1, class T2>
void pna(T1&& Aa, T2 t) {
for (int i = 0; i < t; i++) pr(Aa[i]), ps();
}
template <class T1, class T2>
void psa2(T1&& Aa, T2 t1, T2 t2) {
for (int i = 0; i < t1; i++) {
for (int j = 0; j < t2; j++) pr(Aa[i][j]), pw();
ps();
}
}
template <class T>
void pr(const T& Xx) {
if (!(int)(Xx).size()) return;
bool fst = 1;
bool op = 0;
if (parsepair(*Xx.begin())) op = 1;
for (const auto& Aa : Xx) {
if (!fst) pw();
if (op) pr("{");
pr(Aa), fst = 0;
if (op) pr("}");
}
}
template <class T, class... Ts>
void pr(const T& t, const Ts&... ts) {
pr(t);
pr(ts...);
}
template <class T, class... Ts>
void ps(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) {
if (!parse(t)) pw();
}
ps(ts...);
}
template <class T>
void pn(const T& t) {
for (const auto& Aa : t) ps(Aa);
}
template <class T, class... Ts>
void pw(const T& t, const Ts&... ts) {
pr(t);
if (sizeof...(ts)) pw();
pw(ts...);
}
template <class T, class... Ts>
void pc(const T& t, const Ts&... ts) {
bool op = 0;
if (parsepair(t)) op = 1;
if (op) pr("{");
pr(t);
if (op) pr("}");
if (sizeof...(ts)) pr(", ");
pc(ts...);
}
namespace trace {
template <class T1, class T2>
void __f(const char* name, const T1& Xx, const T2& y) {
pr("[", y, "] = ");
ps(Xx);
}
template <class T1, class T2, class... Ts>
void __f(const char* name, const T1& Xx, const T2& y, const Ts&... rest) {
const char* open = strchr(name, '[');
pr("[", y, "]");
__f(open + 1, Xx, rest...);
}
template <class T1, class T2, class... Ts>
void __f0(const char* name, const T1& Xx, const T2& y, const Ts&... rest) {
const char* open = strchr(name, '[');
pr(name, size_t(open - name));
__f(name, Xx, y, rest...);
}
template <class T>
void __fn(int n, const char* name, const T& Xx) {
for (int i = 0; i < n; i++) pr(name), __f(name, Xx[i], i);
}
} // namespace trace
} // namespace output
using namespace minmax;
using namespace input;
using namespace output;
using namespace output::trace;
const int N = 2e5 + 5;
const int NN = 2000 + 5;
namespace DSU {
int nn, par[NN], size_[NN], roots[NN], rootID[NN], rootcnt;
void build(int Q) {
nn = Q;
rootcnt = nn;
for (int i = 0; i < nn; i++) {
par[i] = i;
size_[i] = 1;
}
}
int getpar(int x) {
int pp = x;
while (par[pp] != pp) pp = par[pp];
while (par[x] != x) {
int z = par[x];
par[x] = pp;
x = z;
}
return pp;
}
bool merge(int x, int y) {
x = getpar(x);
y = getpar(y);
if (x == y) return false;
if (size_[x] < size_[y]) swap(x, y);
par[y] = x, size_[x] += size_[y];
rootcnt--;
return true;
}
bool same(int x, int y) { return getpar(x) == getpar(y); }
void getRoots() {
int cnt = 0;
for (int i = 0; i < nn; i++) {
if (par[i] != i) continue;
rootID[i] = cnt;
roots[cnt++] = i;
}
assert(cnt == rootcnt);
}
} // namespace DSU
using namespace DSU;
template <class T1, class T2>
int expo(T1 A, T2 B) {
if (B == 0) return 1;
if (B & 1) return (int)(1ll * A * expo(A, B - 1) % MOD);
A = expo(A, B / 2);
return (int)(1ll * A * A % MOD);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int i, n, m, k;
re(n, m, k);
build(n);
for (i = 0; i + k <= n; i++)
for (int l = i, r = i + k - 1; l <= r; l++, r--) merge(l, r);
getRoots();
ps(expo(m, rootcnt));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, total, m, qq, _inf = 1000000007;
int base[2101], gg[2101], gl, len;
void Bfs(int root) {
int i, u, v;
base[root] = ++len;
for (gl = 1, gg[1] = root, i = 1; i <= gl; ++i) {
u = gg[i];
for (int j = 1; j <= qq; ++j) {
if (u < j) break;
if (u > (j + m - 1)) continue;
v = j + j + m - 1 - u;
if (base[v] == 0) {
base[v] = len;
gg[++gl] = v;
}
}
}
}
int main() {
cin >> n >> total >> m;
if (m == 1) {
long long ans = 1;
for (int i = 1; i <= n; ++i) {
ans *= total;
if (ans >= _inf) ans %= _inf;
}
cout << ans << endl;
return 0;
}
if (m == 2) {
cout << total << endl;
return 0;
}
memset(base, 0, sizeof(base));
len = 0;
qq = n - m + 1;
for (int i = 1; i <= n; ++i)
if (base[i] == 0) Bfs(i);
long long ans = 1;
for (int i = 1; i <= len; ++i) {
ans *= total;
if (ans >= _inf) ans %= _inf;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPowerOfTwo(long long int x) { return x && (!(x & (x - 1))); }
long long int Modular_Exponentiation(long long int x, long long int n,
long long int M = 1000000007) {
if (n == 0) return 1;
if (n % 2)
return (x * Modular_Exponentiation((x * x) % M, n / 2, M)) % M;
else
return (Modular_Exponentiation((x * x) % M, n / 2, M)) % M;
}
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
if (k == 1 or k > n)
cout << Modular_Exponentiation(m, n);
else if (k == n)
cout << Modular_Exponentiation(m, (n + 1) / 2);
else if (k & 1)
cout << m * m;
else
cout << m;
}
int32_t main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
struct DisSet {
int fa[2005], nv;
void init(int n) {
nv = n;
for (int i = 0; i < n; i++) fa[i] = i;
}
int find(int x) {
if (fa[x] == x) return x;
return fa[x] = find(fa[x]);
}
void uni(int x, int y) { fa[find(x)] = find(y); }
};
int f[2005];
int M = 1000000007;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k > n) {
long long ans = 1;
for (int i = 0; i < n; i++) {
ans = (ans * m) % M;
}
printf("%I64d\n", ans);
return 0;
}
DisSet ds;
ds.init(n);
for (int i = 0; i < n - k + 1; i++) {
for (int j = i; j < i + k / 2; j++) {
ds.uni(j, i + k - 1 - (j - i));
}
}
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!f[ds.find(i)]) {
cnt++;
f[ds.find(i)] = 1;
}
}
long long ans = 1;
for (int i = 0; i < cnt; i++) {
ans = (ans * m) % M;
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long bigMod(long long x, long long y, long long m) {
if (y == 0) return 1 % m;
if (y % 2 == 0) {
long long temp = bigMod(x, y / 2, m);
return (temp * temp) % m;
}
return (x % m * bigMod(x, y - 1, m)) % m;
}
int main() {
ios::sync_with_stdio(false);
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << bigMod(m, n, mod) << endl;
return 0;
}
if (n == k) {
cout << bigMod(m, (n + 1) / 2, mod) << endl;
return 0;
}
if (k & 1)
cout << bigMod(m, 2, mod) << endl;
else
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int uf[2000];
int c;
int find(int x) {
if (uf[x] < 0) return x;
return uf[x] = find(uf[x]);
}
int uni(int x, int y) {
int xx = find(x), yy = find(y);
if (xx != yy) {
c--;
if (uf[xx] > uf[yy]) {
uf[yy] += uf[xx];
uf[xx] = yy;
} else {
uf[xx] += uf[yy];
uf[yy] = xx;
}
}
}
int main(void) {
long long int mod = 1000000007;
long long int answ;
long long int m;
int n, k;
cin >> n >> m >> k;
c = n;
memset(uf, -1, sizeof uf);
for (int i = 0; i + k - 1 < n; i++) {
for (int uu = 0; uu < k / 2; uu++) uni(i + uu, i + k - 1 - uu);
}
answ = 1;
for (int i = 0; i < c; i++) answ = (answ * m) % mod;
cout << answ << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
int fa[2010];
bool a[2010];
int n, m, k;
int Get(int x) {
if (fa[x] == x) return x;
fa[x] = Get(fa[x]);
return fa[x];
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) fa[i] = i;
for (int i = 1, j = k; j <= n; ++i, ++j) {
for (int ii = i, jj = j; ii < jj; ++ii, --jj) {
int fax = Get(ii);
int fay = Get(jj);
fa[fax] = fay;
}
}
memset(a, false, sizeof(a));
for (int i = 1; i <= n; ++i) a[Get(i)] = true;
long long res = 1;
for (int i = 1; i <= n; ++i)
if (a[i]) res = res * m % mo;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 1000000007;
int g[2005][2005];
int col[2005], cnt;
long long quick_power(long long a, long long b) {
long long r = 1;
for (; b; b >>= 1) {
if (b & 1) r = a * r % mod;
a = a * a % mod;
}
return r;
}
void dfs(int v, int f, int c, int n) {
col[v] = c;
for (int i = 1; i <= n; i++) {
if (!g[v][i] || i == f || col[i]) continue;
dfs(i, v, c, n);
}
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k > n) {
printf("%I64d\n", quick_power(m, n));
return 0;
}
for (int i = 1; i + k - 1 <= n; i++) {
for (int a = i, b = i + k - 1; a < b; a++, b--) {
g[a][b] = g[b][a] = 1;
}
}
for (int i = 1; i <= n; i++) {
if (!col[i]) {
cnt++;
dfs(i, -1, cnt, n);
}
}
printf("%I64d\n", quick_power(m, cnt));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007LL;
long long powmod(long long b, long long e) {
if (!e) return 1;
if (e & 1) return (b * powmod(b, e - 1)) % mod;
long long r = powmod(b, e / 2);
return (r * r) % mod;
}
bool vis[2001];
int n, k, m;
void dfs(int at) {
vis[at] = true;
for (int pos = 0; pos < k / 2; pos++) {
int nxt = at - 2 * pos + k - 1;
if (at - pos >= 0 && at - pos + k - 1 < n && !vis[nxt]) dfs(nxt);
}
for (int pos = 0; pos < k / 2; pos++) {
int nxt = at + 2 * pos - k + 1;
if (nxt - pos >= 0 && nxt - pos + k - 1 < n && !vis[nxt]) dfs(nxt);
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
int qtd = 0;
memset(vis, 0, sizeof vis);
for (int i = 0; i < n; i++) {
if (!vis[i]) {
qtd++;
dfs(i);
}
}
cout << powmod(m, qtd) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
res %= 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res % 1000000007;
}
int32_t main() {
long long 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 == 0)
cout << m << endl;
else
cout << (m * m) % 1000000007 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1000 * 1000 * 1000 + 7;
const double PI = 3.14159265358979323846264;
const pair<long long int, long long int> steps[] = {
{1, 0}, {0, 1}, {-1, 0}, {0, -1}, {1, -1}, {1, 1}, {-1, -1}, {-1, 1}};
template <typename... T>
void read(T&... args) {
((cin >> args), ...);
}
template <typename... T>
void write(T&&... args) {
((cout << args << " "), ...);
}
void fio() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void setUpLocal() {}
const long long int maxN = 2 * 1e3;
const long long int gp_size = maxN;
vector<long long int> gp[gp_size];
long long int vis[gp_size];
long long int cnt[gp_size];
void dfs(long long int i) {
vis[i] = 1;
for (long long int child : gp[i])
if (!vis[child]) dfs(child);
}
long long int modPow(long long int n, long long int k) {
long long int ret = 1;
while (k) {
if (k & 1) ret = ret * n % mod;
k >>= 1;
n = n * n % mod;
}
return ret;
}
void solve() {
long long int n, m, k;
cin >> n >> m >> k;
for (long long int i = 1; i <= n - k + 1; i++) {
for (long long int f = i, b = i + k - 1; f <= b; f++, b--) {
gp[f].push_back(b);
gp[b].push_back(f);
}
}
long long int cc = 0;
for (long long int i = 1; i <= n; i++) {
if (!vis[i]) {
cc++;
dfs(i);
}
}
cout << modPow(m, cc);
}
int32_t main() {
fio();
setUpLocal();
return solve(), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n, m, k;
const int maxn = 2e3 + 10;
int md[1002];
int ans[1002];
int arr[maxn];
int f[maxn];
void init() {
for (int i = 0; i < maxn; i++) f[i] = i;
};
int find(int x) { return x == f[x] ? x : f[x] = find(f[x]); }
void merge(int x, int y) { f[find(x)] = find(y); }
int rt[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long u, v, t, n, m, r, g, k, b;
cin >> n >> m >> k;
init();
for (int i = 1; i + k - 1 <= n; i++) {
for (int j = i; j <= (i + i + k - 1) / 2; j++) {
merge(j, (2 * i + k - 1 - j));
}
}
int cnt = 0;
for (int i = 1; i <= n; i++) rt[find(i)] = 1;
for (int i = 1; i <= n; i++) cnt += rt[i];
long long ans = 1;
long long mod = 1e9 + 7;
for (int i = 1; i <= cnt; i++) ans = ans * m % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[2000];
int b[2000];
int main() {
int temp1, temp2;
long long int ans;
memset(b, 0, 2000 * sizeof(int));
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++) a[i] = i;
for (int i = 0; i <= n - k; i++) {
for (int j = 0; j < k / 2; j++) {
temp1 = (a[i + j] < a[i + k - 1 - j]) ? a[i + j] : a[i + k - 1 - j];
temp2 = (a[i + j] > a[i + k - 1 - j]) ? a[i + j] : a[i + k - 1 - j];
a[i + j] = a[i + k - 1 - j] = temp1;
for (int l = 0; l < n; l++) {
if (a[l] == temp2) a[l] = temp1;
}
}
}
for (int i = 0; i < n; i++) b[a[i]] = 1;
ans = 1;
for (int i = 0; i < n; i++) {
if (b[i]) ans = (ans * m) % 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
const int maxn = 2021;
int ldr[maxn];
int mark[maxn];
int dgt(int v) { return (ldr[v] == v) ? v : ldr[v] = dgt(ldr[v]); }
void uni(int u, int v) {
u = dgt(u);
v = dgt(v);
if (u == v) return;
ldr[v] = u;
}
inline long long int pw(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) {
res = (res * a) % mod;
}
a = (a * a) % mod;
b /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i <= n; i++) {
ldr[i] = i;
}
for (int i = 0, j = k - 1; j < n; i++, j++) {
for (int ii = i, jj = j; ii < jj; ii++, jj--) {
uni(ii, jj);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
if (!mark[dgt(i)]) {
ans++;
mark[dgt(i)] = 1;
}
}
cout << pw(m, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
;
long long int n, m, k;
cin >> n >> m >> k;
long long int ans = 1;
if (k == 1 || k > n) {
for (int i = 1; i < n + 1; i++) ans = (ans * m) % 1000000007;
ans = (ans + 1000000007) % 1000000007;
cout << ans;
return 0;
}
if (k == n) {
for (int i = 0; i < n / 2; i++) ans = (ans * m) % 1000000007;
if (n % 2 == 1) ans = (ans * m) % 1000000007;
ans = (ans + 1000000007) % 1000000007;
cout << ans;
return 0;
}
if (k % 2 == 0)
cout << m;
else
cout << m * m;
return 0;
}
|
#include <bits/stdc++.h>
long long int powmod(int bs, int exp) {
if (exp == 0) return 1;
if (exp == 1) return bs % 1000000007;
if (exp == 2) return (bs * bs) % 1000000007;
if (exp % 2 == 0) {
long long int hf = powmod(bs, exp / 2) % 1000000007;
return (hf * hf) % 1000000007;
}
if (exp % 2 == 1) {
long long int hf = powmod(bs, exp / 2) % 1000000007;
return (((hf * hf) % 1000000007) * bs) % 1000000007;
}
}
int main() {
long long int ans;
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
if (k == 1)
ans = powmod(m, n);
else if (k == n)
ans = powmod(m, (n + 1) / 2);
else if (k % 2 == 1)
ans = m * m;
else
ans = m;
if (k > n) ans = powmod(m, n);
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void FAST_IO() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
template <class F, class S>
ostream& operator<<(ostream& os, pair<F, S>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T, class S>
ostream& operator<<(ostream& os, map<T, S>& v) {
os << "{";
for (auto& i : v) cout << "{" << i.first << "," << i.second << "}";
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, set<T>& v) {
os << "{";
for (auto& i : v) cout << i << ",";
os << "}";
return os;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& v) {
os << "[";
if (v.size()) os << v[0];
for (int i = 1; i < v.size(); ++i) os << "," << v[i];
os << "]";
return os;
}
class UF {
int *a, *sz;
int n;
public:
UF(int n) {
sz = new int[n];
a = new int[n];
this->n = n;
for (int i = 0; i < n; i++) a[i] = i, sz[i] = 1;
}
~UF() {
delete sz;
delete a;
}
int root(int p) {
while (a[p] != p) {
a[p] = a[a[p]];
p = a[p];
}
return p;
}
void merge(int p, int q) {
int i = root(p);
int j = root(q);
if (i == j) return;
if (sz[i] > sz[j])
a[j] = i, sz[i] += sz[j];
else
a[i] = j, sz[j] += sz[i];
}
bool find(int p, int q) { return root(p) == root(q); }
};
int main() {
long long n, m, k;
cin >> n >> m >> k;
UF uf(n);
for (int i = 0; i <= n - k; ++i) {
for (int j = 0; j < k / 2; ++j) {
uf.merge(i + j, (i + k - 1 - j));
}
}
set<int> groups;
for (int i = 0; i < n; ++i) groups.insert(uf.root(i));
long long resp = 1;
for (int i = 0; i < groups.size(); ++i) {
resp = (resp * m) % 1000000007LL;
}
cout << resp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int long long mod = 1000 * 1000 * 1000 + 7;
long long pow(long long x, long long k) {
if (k == 1) return x % mod;
if (k % 2 == 1) return (pow(x, k - 1) * x) % mod;
long long t = pow(x, k / 2);
return (t * t) % mod;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << pow(m, n);
else if (k == n)
cout << pow(m, (n + 1) / 2);
else if (k % 2 == 0)
cout << m;
else
cout << m * m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mm = 1000000007;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long long sol = 1;
if (k == 1 || k > n) {
for (int i = 1; i <= n; i++) sol = (sol * m) % mm;
} else if (k == n) {
for (int i = 1; i <= (n + 1) / 2; i++) sol = (sol * m) % mm;
} else if (n == 1 || k % 2 == 0) {
sol = m;
} else
sol = (m * m) % mm;
printf("%I64d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const long long mod = 1000000007LL;
long long my_pow(long long n, long long m) {
if (m == 0) return 1;
return (n * my_pow(n, m - 1)) % mod;
}
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << (my_pow(m, n) % mod) << endl;
exit(0);
}
if (k % 2 != 0) {
if (k == n) {
cout << (my_pow(m, n / 2 + 1) % mod) << endl;
} else {
cout << (m * m) % mod << endl;
}
} else {
if (k == n) {
cout << (my_pow(m, n / 2) % mod) << endl;
} else {
cout << m % mod << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void printArray(long long int arr[], long long int n) {
for (long long int i = 0; i < n; i++) cout << arr[i] << ' ';
}
void printMp(map<long long int, long long int> m) {
map<long long int, long long int>::iterator it;
for (it = m.begin(); it != m.end(); it++)
cout << it->first << ' ' << it->second << endl;
}
void printUmp(unordered_map<long long int, long long int> m) {
unordered_map<long long int, long long int>::iterator it;
for (it = m.begin(); it != m.end(); it++)
cout << it->first << ' ' << it->second << endl;
}
void printSt(set<long long int> s) {
set<long long int>::iterator it;
for (it = s.begin(); it != s.end(); it++) cout << *it << ' ';
}
void printMst(multiset<long long int> s) {
multiset<long long int>::iterator it;
for (it = s.begin(); it != s.end(); it++) cout << *it << ' ';
}
void printVec(vector<long long int> v) {
for (long long int i = 0; i < v.size(); i++) cout << v[i] << ' ';
}
void printVec2(vector<long long int> v[], long long int n) {
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < v[i].size(); j++) cout << v[i][j] << ' ';
cout << endl;
}
}
set<pair<long long int, long long int>> primeset;
void SieveOfEratosthenes(long long int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (prime[p]) primeset.insert(make_pair(p, 1));
}
long long int id[1000001], size[1000001];
long long int ans;
long long int root(long long int x) {
while (id[x] != x) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void Union(long long int x, long long int y) {
long long int p = root(x);
long long int q = root(y);
if (size[p] > size[q]) {
id[q] = id[p];
size[p] += size[q];
} else {
id[p] = id[q];
size[q] += size[p];
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int n;
cin >> n;
long long int m;
cin >> m;
long long int k;
cin >> k;
long long int mod = 1000000007;
for (long long int i = 1; i < n + 1; i++) {
size[i] = 1;
id[i] = i;
}
for (long long int i = 1; i < n - k + 2; i++) {
long long int start = i;
long long int end = i + k - 1;
while (start <= end) {
Union(start, end);
start++;
end--;
}
}
long long int product = 1;
for (long long int i = 1; i < n + 1; i++) {
if (id[i] == i) {
product = ((product % mod) * (m % mod)) % mod;
}
}
cout << product;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long power(long long x, long long y) {
long long res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
int32_t main() {
long long n, m, k;
cin >> n >> m >> k;
long long ans;
if (k == 1 || k > n)
ans = power(m, n);
else if (k == n)
ans = power(m, (n + 1) / 2);
else if (k % 2 == 0)
ans = m;
else
ans = m * m;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
long long cnt = 1;
for (int i = 1; i <= n; i++) cnt = (cnt * m) % 1000000007;
cout << cnt;
return 0;
}
if (k == n) {
long long cnt = 1;
for (int i = 1; i <= (n + 1) / 2; i++) cnt = (cnt * m) % 1000000007;
cout << cnt;
return 0;
}
if (k % 2 == 0) {
cout << m;
return 0;
}
cout << m * m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, M, K, ans;
long long quick(long long N, int K) {
if (!K) return 1;
long long t = quick(N, K / 2);
t = t * t % 1000000007;
if (K & 1) t = t * N % 1000000007;
return t;
}
int main() {
cin >> N >> M >> K;
if (K < N) {
if (K & 1) {
if (K > 1)
ans = M * M % 1000000007;
else
ans = quick(M, N);
} else
ans = M;
} else if (K == N) {
if (K & 1)
ans = quick(M, N / 2) * M % 1000000007;
else
ans = quick(M, N / 2);
} else
ans = quick(M, N);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long inf = 1e18 + 5;
const long long MX = 303030;
int cox[4] = {1, -1, 0, 0};
int coy[4] = {0, 0, 1, -1};
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a * b / gcd(a, b); }
long long leastbit(long long a) { return a & (-a); }
long long C(int a, int b) {
long long res = 1;
for (int i = 0; i < b; i++) res = res * (a - i) / (i + 1);
return res;
}
long long powmod(long long a, long long b) {
if (b == 0) return 1;
long long cnt = powmod(a, b / 2);
(cnt *= cnt) %= mod;
if (b & 1) {
(cnt *= a) %= mod;
}
return cnt;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long n, m, k;
cin >> n >> m >> k;
if (n == k)
cout << powmod(m, (n + 1) / 2) << endl;
else if (k == 1 || k > n)
cout << powmod(m, n) << endl;
else if ((k & 1))
cout << (m * m) % mod << endl;
else
cout << m << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long pow_mod(long long a, long long b, long long m) {
long long d, t;
d = 1;
t = a;
while (b > 0) {
if (b % 2 == 1) d = (d * t) % m;
b /= 2;
t = (t * t) % m;
}
return d;
}
int main() {
int n, m, k;
while (cin >> n >> m >> k) {
if (k == 1 || k > n) {
long long ans = pow_mod(m, n, mod) % mod;
cout << ans << endl;
continue;
}
if (k < n) {
long long ans;
if (k % 2)
ans = (long long)m * m % mod;
else
ans = m % mod;
cout << ans << endl;
continue;
}
if (k == n) {
long long ans;
if (k % 2)
ans = pow_mod(m, n / 2 + 1, mod) % mod;
else
ans = pow_mod(m, n / 2, mod) % mod;
cout << ans << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long big = 1000000007;
long long ans = 1;
int n, m, k, f[2001];
void debug(int a) { cout << a << " "; }
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void merge(int a, int b) {
if (a < b) swap(a, b);
f[find(a)] = find(b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
f[i] = i;
}
for (int i = 0; i + k <= n; i++)
for (int j = i + 1; j <= i + k; j++) {
int tmp = k + 2 * i - j + 1;
if (find(j) != find(tmp)) {
merge(j, tmp);
}
}
for (int i = 1; i <= n; i++) {
if (f[i] == i) {
ans = ans * m % big;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int M = 1e9 + 7;
const int MOD = 1e9 + 7;
const double PI = 3.141592653589793238460;
long long int power(long long int a, long long int b) {
long long int res = 1;
if (a == 0) return 0;
if (a == 1) return 1;
for (; b > 0; b >>= 1) {
if (b & 1) res = (res * a);
if (res > MOD) res %= MOD;
a = (a * a);
if (a > MOD) a = a % MOD;
}
return res;
}
bool isPrime[10001];
vector<int> prime;
void seive() {
isPrime[0] = isPrime[1] = 1;
for (int i = 2; i * i <= 10000; i++) {
if (!isPrime[i])
for (int j = i * i; j <= 10000; j += i) {
isPrime[j] = 1;
}
}
for (int i = 2; i <= 10000; i++)
if (!isPrime[i]) prime.push_back(i);
}
int main() {
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 == 0) {
cout << m;
} else
cout << m * m;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
if (k == n) {
long long res = 1;
int u;
if (k % 2)
u = (n + 1) / 2;
else
u = n / 2;
for (int i = 0; i < u; i++) res = (res * m) % 1000000007;
cout << res << endl;
} else {
if (k == 1 || k > n) {
long long res = 1;
for (int i = 0; i < n; i++) res = (res * m) % 1000000007;
cout << res << endl;
} else if (k % 2) {
long long res = m * (m - 1) % 1000000007;
res += (m);
res %= 1000000007;
cout << res << endl;
} else
cout << m % 1000000007 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(int a, int b) {
if (b == 0) return 1;
long long tmp = power(a, b / 2);
tmp = (tmp * tmp) % 1000000007;
if (b % 2) return (tmp * a) % 1000000007;
return tmp;
}
int main() {
int n, m, k;
cin >> n >> m >> k;
if (k > n || k == 1)
cout << power(m, n) << endl;
else if (k == n)
cout << power(m, (k + 1) / 2) << endl;
else {
if (k % 2)
cout << m * m << endl;
else
cout << m << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 2100;
vector<int> g[maxN];
int n, m, k;
bool used[maxN];
const long long P = 1000000007LL;
void dfs(int v) {
used[v] = true;
for (int i = 0; i < g[v].size(); ++i) {
if (!used[g[v][i]]) {
dfs(g[v][i]);
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) {
if (i + k - 1 <= n) {
for (int l = i, r = i + k - 1; l < r; ++l, --r) {
g[l].push_back(r);
g[r].push_back(l);
}
}
}
long long res = 1LL;
for (int i = 1; i <= n; ++i) {
if (!used[i]) {
dfs(i);
res *= (long long)(m);
res %= P;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long mod = 1000000007;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
if (k == 1) {
long long sol = 1;
for (int i = 1; i <= n; ++i) sol = (sol * m) % mod;
printf("%d\n", (int)sol);
} else if (k < n) {
if (k % 2 == 1)
printf("%d\n", m * m);
else
printf("%d\n", m);
} else if (k == n) {
long long sol = 1;
for (int i = 1; 2 * i <= n + 1; ++i) sol = (sol * m) % mod;
printf("%d\n", (int)sol);
} else {
long long sol = 1;
for (int i = 1; i <= n; ++i) sol = (sol * m) % mod;
printf("%d\n", (int)sol);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int adj[2500][2500];
bool used[2500];
long long int expo(long long int a, long long int b, long long int m) {
long long int y = a, x = 1;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y) % m;
}
y = (y * y) % m;
b = b / 2;
}
return x % m;
}
void DFS(int u) {
used[u] = true;
for (int i = 0; i < n; i++) {
if (adj[u][i] == 0) continue;
if (!used[i]) {
DFS(i);
}
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
memset(adj, 0, sizeof(adj));
for (int i = 0; i < n - k + 1; i++) {
for (int j = 0; j <= k / 2; j++) {
adj[i + j][i + k - 1 - j] = 1;
adj[i + k - 1 - j][i + j] = 1;
}
}
memset(used, false, sizeof(used));
int comp = 0;
for (int i = 0; i < n; i++) {
if (!used[i]) {
comp++;
DFS(i);
}
}
long long int res = expo(m, comp, 1000000007LL);
cout << res;
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> s[2000];
long long u[2000], cnt;
void dfs(long long l) {
u[l] = 1;
for (long long i = 0; i < s[l].size(); i++) {
if (u[s[l][i]]) continue;
dfs(s[l][i]);
}
}
const long long MOD = 1000000007;
signed main() {
long long n, m, k;
cin >> n >> m >> k;
for (long long i = 0; i <= n - k; i++) {
for (long long j = 0; j < k; j++) {
s[i + j].push_back(i + k - 1 - j);
}
}
for (long long i = 0; i < n; i++) {
if (u[i]) continue;
dfs(i);
cnt++;
}
long long y = 1;
for (long long i = 1; i <= cnt; i++) {
y = (y * m) % MOD;
}
cout << y;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long BM(long long b, long long p, long long mod) {
long long ret = 1;
while (p) {
if (p & 1) ret = (ret * b) % mod;
p /= 2;
b = (b * b) % mod;
}
return ret;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
long long ans;
if (k == 1 || k > n)
ans = BM(m, n, mod);
else if (k == n)
ans = BM(m, (n + 1) / 2, mod);
else if (k % 2 == 0)
ans = m;
else
ans = m * m;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
const long long mod = 1000 * 1000 * 1000 + 7;
int main() {
cin >> n >> m >> k;
if (k == 1 || k > n) {
long long ans = 1;
for (int i = 0; i < n; ++i) ans = (ans * m) % mod;
cout << ans << endl;
}
if (k != 1 && k == n) {
long long ans = 1;
for (int i = 0; i < (n + 1) / 2; ++i) ans = (ans * m) % mod;
cout << ans << endl;
}
if (k > 1 && k < n && k % 2 == 1) cout << (m * m) % mod << endl;
if (k > 1 && k < n && k % 2 == 0) cout << m % mod << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long x = 1000000007, m, n, k, s, i, j;
int main() {
cin >> n >> m >> k;
s = 1;
if (k == 1 || k > n) {
for (i = 0; i < n; i++) s = (s * m) % x;
} else if (k == n) {
if (n % 2 == 0) {
for (i = 0; i < n / 2; i++) s = (s * m) % x;
} else {
for (i = 0; i <= n / 2; i++) s = (s * m) % x;
}
} else if (k % 2 == 1)
s = m * m;
else
s = m;
if (s < 0) s += x;
cout << s << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int n, m, k;
cin >> n >> m >> k;
long long ans = 1;
if (n < k || k == 1)
for (int i = 0; i < n; i++) ans = (ans * m) % mod;
else if (n == k) {
if (n % 2 == 0)
for (int i = 0; i < n / 2; i++) ans = (ans * m) % mod;
else
for (int i = 0; i < n / 2 + 1; i++) ans = (ans * m) % mod;
} else if (k % 2 == 0)
ans = m;
else
ans = m * m;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fast_mod(long long int base, long long int exp) {
long long int res = 1;
while (exp > 0) {
if (exp & 1) res = (res * base) % 1000000007;
base = (base * base) % 1000000007;
exp = exp >> 1;
}
return res;
}
vector<long long int> parent(1000000), diff(1000000);
long long int find(long long int a) {
if (parent[a] == a)
return a;
else {
long long int temp = parent[a];
parent[a] = find(parent[a]);
diff[a] ^= diff[temp];
return parent[a];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int m, n, k;
cin >> n >> m >> k;
if (k == 1 || k > n)
cout << fast_mod(m, n) << "\n";
else if (k == n)
cout << fast_mod(m, (n + 1) / 2) << "\n";
else if (k % 2)
cout << fast_mod(m, 2) << "\n";
else
cout << m << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int main() {
long long n, m, k, pos;
cin >> n >> m >> k;
long long ans = 1;
if (k == 1 || k >= n) {
if (k == 1 || k > n) {
for (int i = 1; i <= n; i++) {
ans = (ans * m) % mod;
}
} else {
int p;
if (k % 2)
p = k / 2 + 1;
else
p = k / 2;
for (int i = 1; i <= p; i++) {
ans = (ans * m) % mod;
}
}
} else {
if (k % 2)
ans = m * m;
else
ans = m;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[31][31];
long long solve(int n, int r) {
if (n == r || r == 0) return 1;
if (n < r) return 0;
if (dp[n][r] != -1) {
return dp[n][r];
}
return dp[n][r] = solve(n - 1, r - 1) + solve(n - 1, r);
}
int main() {
int t = 1;
while (t--) {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1) {
long long ans = 1;
for (int i = 0; i < n; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans;
} else if (k == n) {
int s = n / 2;
if (n % 2) s++;
long long ans = 1;
for (int i = 0; i < s; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans;
} else if (k > n) {
long long ans = 1;
for (int i = 0; i < n; i++) {
ans = (ans * m) % 1000000007;
}
cout << ans;
} else {
if (k % 2 == 0) {
cout << m;
} else {
cout << m * m;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2500;
int pv[maxn];
int rk[maxn];
int findSet(int x) { return x == pv[x] ? x : pv[x] = findSet(pv[x]); }
void unionSets(int x, int y) {
x = findSet(x), y = findSet(y);
if (rk[x] < rk[y])
pv[x] = y;
else if (rk[y] < rk[x])
pv[y] = x;
else {
pv[x] = y;
++rk[y];
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
int i;
for (i = 0; i < n; ++i) {
pv[i] = i;
rk[i] = 0;
}
int j;
for (i = n - k; i >= 0; --i)
for (j = 0; j < k; ++j) unionSets(i + j, i + k - j - 1);
set<int> s;
for (i = 0; i < n; ++i) s.insert(findSet(i));
long long mod = 1000000007LL;
long long ans = 1;
for (i = 1; i <= s.size(); ++i) ans = (ans * m) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("in.in");
ofstream fout("out.out");
const int N = 2000 + 10, mod = 1000000007;
int n, m, k, cnt;
bool mark[N];
vector<int> adj[N];
long long res = 1;
inline void input() { cin >> n >> m >> k; }
void DFS(int v) {
mark[v] = true;
for (int i = 0; i < adj[v].size(); i++)
if (!mark[adj[v][i]]) DFS(adj[v][i]);
}
int main() {
input();
for (int i = 1; i <= n - k + 1; i++)
for (int j = i; j < i + k; j++) adj[j].push_back(2 * i + k - (j + 1));
for (int i = 1; i <= n; i++)
if (!mark[i]) {
DFS(i);
cnt++;
}
for (int i = 1; i <= cnt; i++) {
res *= m;
res %= mod;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve();
int main() {
cin.sync_with_stdio(false);
solve();
return 0;
}
const int mod = 1000000007;
int dsu[2222];
int get(int a) {
if (dsu[a] == a)
return a;
else
return dsu[a] = get(dsu[a]);
}
void ob(int a, int b) { dsu[get(a)] = get(b); }
long long binpow(long long a, long long b) {
if (!b) return 1;
if (b & 1) return (a * binpow(a, b - 1)) % mod;
return binpow((a * a) % mod, b >> 1);
}
void solve() {
int n, m, k;
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
dsu[i] = i;
}
for (int i = 0; i + k <= n; ++i) {
for (int j = 0; j < k; ++j) {
ob(i + j, i + k - 1 - j);
}
}
set<int> s;
for (int i = 0; i < n; ++i) {
s.insert(get(i));
}
cout << binpow(m, s.size());
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
signed main() {
long long t = 1;
while (t--) {
long long n, m, k;
cin >> n >> m >> k;
if (k == 1 || k > n) {
cout << power(m, n, mod) << '\n';
} else if (k == n) {
cout << power(m, (n + 1) / 2, mod) << '\n';
} else if (k % 2) {
cout << power(m, 2, mod) << '\n';
} else {
cout << m << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long Mod = 1000000007;
int n, m, k;
int main() {
scanf("%d%d%d", &n, &m, &k);
long long ans = 0;
if (n == k) {
k = k / 2;
if (n % 2) k++;
ans = 1;
for (int i = 1; i < (k + 1); i++) {
ans = ans * m;
ans = ans % Mod;
}
printf("%I64d\n", (ans % Mod + Mod) % Mod);
return 0;
}
if (n < k || k == 1) {
ans = 1;
for (int i = 1; i < (n + 1); i++) {
ans = ans * m;
ans = ans % Mod;
}
} else if (k % 2 == 1 && k != 1) {
ans = m * m;
} else
ans = m;
printf("%I64d\n", (ans % Mod + Mod) % Mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int modularExponentiation(long long int x, long long int n) {
if (n == 0)
return 1;
else if (n % 2 == 0)
return modularExponentiation((x * x) % 1000000007, n / 2);
else
return (x * modularExponentiation((x * x) % 1000000007, (n - 1) / 2)) %
1000000007;
}
int main() {
long long int n, m, k;
cin >> n >> m >> k;
long long int ans = 0;
if (k == 1 || k > n) {
ans = modularExponentiation(m, n);
} else if (k == n) {
ans = modularExponentiation(m, (n + 1) / 2);
} else if (k % 2 == 1) {
ans = modularExponentiation(m, 2);
} else {
ans = m % 1000000007;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void checkMin(T& a, T b) {
if (a > b) a = b;
}
template <typename T>
inline void checkMax(T& a, T b) {
if (a < b) a = b;
}
const int MAXN = 2005;
const int MOD = (int)(1E9 + 7);
int N, M, K, DS[MAXN];
int findDS(int u) { return DS[u] == u ? u : (DS[u] = findDS(DS[u])); }
int fpm(int a, int e) {
int ret = 1;
for (int i = 0; (1 << i) <= e; ++i) {
if ((1 << i) & e) {
ret = (long long)ret * a % MOD;
}
a = (long long)a * a % MOD;
}
return ret;
}
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i < int(MAXN); ++i) {
DS[i] = i;
}
for (int i = 0; i + K <= N; ++i) {
for (int j = 0; j < K - 1 - j; ++j) {
int u = findDS(i + j), v = findDS(i + K - 1 - j);
if (u != v) {
DS[u] = v;
}
}
}
set<int> is;
for (int i = 0; i < int(N); ++i) {
is.insert(findDS(i));
}
printf("%d\n", fpm(M, is.size()));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2000];
bool been[2000];
void visit(int node) {
been[node] = true;
for (int i = 0; i < g[node].size(); i++) {
if (!been[g[node][i]]) {
visit(g[node][i]);
}
}
}
int main(void) {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i + k - 1 < n; i++) {
for (int j = 0; j < k; j++) {
g[i + j].push_back(i + k - 1 - j);
}
}
int sol = 1;
for (int i = 0; i < n; i++) {
if (!been[i]) {
visit(i);
sol = ((long long)sol * m) % 1000000007;
}
}
printf("%d\n", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
int n = 0, m = 0, k = 0;
int main() {
long long ans = 1;
cin >> n >> m >> k;
if (k == 1 || k > n) {
for (int i = 1; i <= n; ++i) {
ans = ans * m % 1000000007;
}
} else if (k == n) {
for (int i = 1; i <= (n + 1) / 2; ++i) {
ans = ans * m % 1000000007;
}
} else if (k % 2 == 0 && k != n && k != 1 && k < n) {
ans = m;
} else if (k % 2 == 1 && k != n && k != 1 && k < n) {
ans = m * m % 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unsigned long long mulmod(unsigned long long a, unsigned long long b,
unsigned long long modulo) {
a %= modulo;
b %= modulo;
if (a <= 0xFFFFFFF && b <= 0xFFFFFFF) return (a * b) % modulo;
if (b > a) std::swap(a, b);
unsigned long long result = 0;
while (a > 0 && b > 0) {
if (b & 1) {
result += a;
if (result >= modulo) result -= modulo;
}
a <<= 1;
if (a >= modulo) a -= modulo;
b >>= 1;
}
return result;
}
unsigned long long powmod(unsigned long long base, unsigned long long exponent,
unsigned long long modulo) {
unsigned long long result = 1;
while (exponent > 0) {
if (exponent & 1) result = mulmod(result, base, modulo);
base = mulmod(base, base, modulo);
exponent >>= 1;
}
return result;
}
const long long mod = 1e9 + 7;
int main() {
long long n, m, k, ans;
cin >> n >> m >> k;
if (k > n || k == 1) {
ans = powmod(m, n, mod);
cout << ans;
} else if (k == n) {
if (n % 2) {
n = n / 2 + 1;
} else {
n = n / 2;
}
ans = powmod(m, n, mod);
cout << ans;
} else if (k % 2 == 0) {
cout << m << endl;
} else {
cout << m * m << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int lgput(int nr, int exp) {
long long sol = 1;
for (int i = 1; i <= exp; ++i) sol = (sol * nr) % 1000000007;
return sol;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
if (k == 1 || k > n) {
printf("%d\n", lgput(m, n));
return 0;
}
if (k == n) {
printf("%d\n", lgput(m, k / 2 + k % 2));
return 0;
}
if (k % 2 == 1) {
printf("%d\n", lgput(m, 2));
return 0;
}
printf("%d\n", m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2000;
const int INF = 1000000001;
vector<int> G[MAX];
bool vis[MAX];
int n, m, k;
void dfs(int v) {
vis[v] = true;
for (__typeof((G[v]).begin()) u = (G[v]).begin(); u != (G[v]).end(); ++u)
if (!vis[*u]) dfs(*u);
}
int main(int argc, char *argv[]) {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) {
int ii = i;
int j = i + k - 1;
if (j < n)
while (ii < j) {
G[ii].push_back(j);
G[j].push_back(ii);
++ii;
--j;
}
}
long long res = 1;
for (int i = 0; i < n; ++i)
if (!vis[i]) res = (res * m) % 1000000007, dfs(i);
printf("%d\n", (int)res);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.