text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long long int maxi;
map<pair<long long int, long long int>, long long int> dp;
long long int recur(long long int a, long long int b) {
if (dp.find(make_pair(a, b)) != dp.end()) return dp[make_pair(a, b)];
long long int sum = 1;
for (long long int i = 0; i < ((long long int)b); i++) {
sum *= a;
if (maxi <= sum) return dp[make_pair(a, b)] = 1;
}
if (a == 1) {
sum = 1;
for (long long int i = 0; i < ((long long int)b); i++) {
sum *= 2;
if (maxi <= sum) return dp[make_pair(a, b)] = 0;
}
}
if (b == 1 && maxi <= a * a)
return dp[make_pair(a, b)] = ((maxi - a) % 2) ? -1 : 1;
dp[make_pair(a, b)] = -1;
dp[make_pair(a, b)] = max(dp[make_pair(a, b)], -recur(a + 1, b));
dp[make_pair(a, b)] = max(dp[make_pair(a, b)], -recur(a, b + 1));
return dp[make_pair(a, b)];
}
int main() {
long long int a, b;
cin >> a >> b >> maxi;
long long int sum = 1;
for (long long int i = 0; i < ((long long int)b); i++) {
sum *= a;
if (maxi <= sum) {
cout << "Missing" << endl;
return 0;
}
}
if (recur(a, b) == 1) {
cout << "Masha" << endl;
} else if (recur(a, b) == 0) {
cout << "Missing" << endl;
} else {
cout << "Stas" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using li = long long;
using ld = long double;
using pii = pair<int, int>;
const int N = 1e5 + 13;
const int INF = 1e9;
const int MAXA = 10011;
const int MAXB = 32;
int dp[MAXA][MAXB];
vector<pii> g[MAXA][MAXB];
void dfs(int a, int b) {
if (dp[a][b] != 0) return;
int mx = 1;
for (auto p : g[a][b]) {
dfs(p.first, p.second);
mx = max(mx, dp[p.first][p.second]);
}
dp[a][b] = 4 - mx;
}
int main() {
int a, b, n;
cin >> a >> b >> n;
dp[1][MAXB - 1] = 2;
dp[MAXA - 1][1] = ((n - MAXA) % 2 != 0 ? 1 : 3);
for (int i = 0; i < MAXA; i++) {
for (int j = 0; j < MAXB; j++) {
li pw = 1;
for (int l = 0; l < j; l++) {
pw *= i;
if (pw >= n) {
dp[i][j] = 1;
break;
}
}
if (i < MAXA - 1) {
g[i][j].emplace_back(i + 1, j);
}
if (j < MAXB - 1) {
g[i][j].emplace_back(i, j + 1);
}
}
}
dfs(a, b);
if (dp[a][b] == 3)
cout << "Stas";
else if (dp[a][b] == 1)
cout << "Masha";
else
cout << "Missing";
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void R(T &xx) {
xx = 0;
char ch = getchar();
bool F = 0;
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') F = 1, ch = getchar();
while (ch >= '0' && ch <= '9')
xx = xx + xx + (xx << 3) + ch - 48, ch = getchar();
if (F) xx = -xx;
}
template <class T>
inline void add(int &x, T y) {
for (x += y; x >= 51123987; x -= 51123987)
;
}
int f[111111][33], x, y, z;
int dp(int x, int y) {
int &t = f[x][y];
if (~t) return t;
if (pow(x, y) + .5 > z) return 2;
if (y > 31) return 1;
if (y == 1 && x * x >= z) return t = ((z - x + 1) & 1) << 1;
return t = 2 - min(dp(x + 1, y), dp(x, y + 1));
}
int main() {
memset(f, -1, sizeof(f));
R(x), R(y), R(z);
int tmp = dp(x, y);
puts((!tmp) ? "Stas" : ((tmp == 1) ? "Missing" : "Masha"));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 40005;
int n, a, b, ans;
bool f[N][35], vis[N][35];
inline long long fast_pow(long long x, int y) {
long long ret = 1;
for (; y; y >>= 1) {
if (y & 1) ret = ret * x;
x = x * x;
}
return ret;
}
bool dfs(int x, int y) {
if (vis[x][y]) return f[x][y];
vis[x][y] = 1;
int now;
if (fast_pow(1ll * x, y) >= n) return f[x][y] = 1;
now = (dfs(x + 1, y) ^ 1) | (dfs(x, y + 1) ^ 1);
if (now) return f[x][y] = 1;
return f[x][y] = 0;
}
int one(int a, int b) {
int ret = 0, tmp = 0;
while (fast_pow(2, b) < n) {
if (!dfs(2, b)) {
if (!tmp)
ret = 1;
else
ret = 2;
break;
}
tmp ^= 1;
b++;
}
return ret;
}
int two(int a, int b) {
int tmp = 0, ret = 0, pre = a;
while (fast_pow(a, 2) < n) {
if (!dfs(a, 2)) {
if (!tmp)
ret = 1;
else
ret = 2;
break;
}
tmp ^= 1;
a++;
}
if (!ret) {
if ((n - 1 - pre) & 1)
ret = 1;
else
ret = 2;
}
return ret;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
if (a == 1 && b == 1) {
int now1 = one(a, b + 1);
if (now1 != 0) now1 = 3 - now1;
int now2 = two(a + 1, b);
now2 = 3 - now2;
if (now1 == 1 || now2 == 1)
puts("Masha");
else if (now1 == 2 && now2 == 2)
puts("Stas");
else
puts("Missing");
return 0;
} else if (a == 1) {
ans = one(a, b);
if (ans == 1)
puts("Masha");
else if (ans == 2)
puts("Stas");
else
puts("Missing");
return 0;
} else if (b == 1) {
ans = two(a, b);
if (ans == 1)
puts("Masha");
else if (ans == 2)
puts("Stas");
return 0;
}
if (dfs(a, b))
puts("Masha");
else
puts("Stas");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n, i, j, k, tot;
int all, dl[2000011], st[111], x[2000011], d[2000011], y[2000011];
bool win[2000011];
bool quick(int a, int b) {
long long x;
x = 1;
while (b) {
x *= a;
b--;
if (x >= n) return false;
}
return true;
}
int calc(int x, int y) {
if (x < a || y < b) return 0;
return st[y] + x - a;
}
int main() {
cin >> a >> b >> n;
if (!quick(a, b + 1) && !quick(a + 1, b)) {
cout << "Stas";
return 0;
}
for (i = max(2, b); quick(max(a, 2), i); i++) {
st[i] = tot + 1;
for (j = a; quick(j, i); j++) {
x[++tot] = j;
y[tot] = i;
k = calc(j, i - 1);
if (k) d[k]++;
k = calc(j - 1, i);
if (k) d[k]++;
}
}
for (i = 1; i <= tot; i++)
if (d[i] == 0) dl[++all] = i;
for (i = 1; i <= all; i++) {
k = calc(x[dl[i]] - 1, y[dl[i]]);
if (k) {
d[k]--;
if (d[k] == 0) dl[++all] = k;
if (!win[dl[i]]) win[k] = true;
}
k = calc(x[dl[i]], y[dl[i]] - 1);
if (k) {
d[k]--;
if (d[k] == 0) dl[++all] = k;
if (!win[dl[i]]) win[k] = true;
}
}
if (a > 1 && b > 1) {
if (win[calc(a, b)])
cout << "Masha";
else
cout << "Stas";
return 0;
}
bool A = false, CA = false;
bool B = false, CB = false;
if (b == 1) {
for (i = max(2, a); (long long)i * i < n; i++)
if (quick(i, 2) && !win[calc(i, 2)]) {
CA = true;
A = (((i - a) & 1) == 0);
break;
}
if (!CA) CA = true, A = ((n - a - 1) & 1);
}
if (a == 1)
for (i = max(2, b); quick(2, i); i++)
if (!win[calc(2, i)]) {
CB = true;
B = (((i - b) & 1) == 0);
break;
}
if (a + b != 2 && a == 1 && quick(2, b) && !win[calc(2, b)]) {
cout << "Masha";
return 0;
}
if (CA && A) {
cout << "Masha";
return 0;
}
if (CB && B) {
cout << "Masha";
return 0;
}
if (a == 1 && !CB) {
cout << "Missing";
return 0;
}
cout << "Stas";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
int f[100020][32];
bool check(int x, int y) {
long long aug = 1;
for (int i = 1; i <= y; ++i) {
aug *= x;
if (aug >= n) return true;
}
return false;
}
void dfs(int x, int y) {
if (f[x][y] >= 0) return;
if (check(x, y)) {
f[x][y] = 1;
return;
}
if (x == 100000) {
f[x][y] = ((n - x) % 2);
f[x][y] ^= 1;
return;
}
if (y == 30) {
f[x][y] = 2;
return;
}
dfs(x + 1, y);
dfs(x, y + 1);
if (f[x + 1][y] == 0 || f[x][y + 1] == 0) {
f[x][y] = 1;
return;
}
if (f[x + 1][y] == 2 || f[x][y + 1] == 2) {
f[x][y] = 2;
return;
}
f[x][y] = 0;
return;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
memset(f, -1, sizeof(f));
dfs(a, b);
if (f[a][b] == 0)
printf("Stas\n");
else if (f[a][b] == 1)
printf("Masha\n");
else
printf("Missing\n");
return 0;
}
|
#include <bits/stdc++.h>
int f[50000][40], g[50000][40];
long long a, b, n;
long long fgm(long long a, long long b) {
long long sum = 1;
for (; b; b--) sum *= a;
return sum;
}
void dfs(int a, int b) {
g[a][b] = 1;
if (fgm(a, b) >= n) {
f[a][b] = 1;
return;
}
if (1 == a) {
if (fgm(a + 1, b) >= n) {
f[a][b] = -1;
return;
}
if (!g[a + 1][b]) dfs(a + 1, b);
if (!g[a][b + 1]) dfs(a, b + 1);
f[a][b] = (f[a + 1][b] == 0 || f[a][b + 1] == 0) ? 1
: (f[a][b + 1] == -1) ? -1
: 0;
return;
}
if (1 == b)
if (fgm(a, b + 1) >= n) {
f[a][b] = (n - a + 1) & 1;
return;
}
if (!g[a + 1][b]) dfs(a + 1, b);
if (!g[a][b + 1]) dfs(a, b + 1);
f[a][b] = (f[a + 1][b] == 0 || f[a][b + 1] == 0) ? 1 : 0;
}
void init() {
scanf(
"%I64d%I64d%I64d"
"\n",
&a, &b, &n);
dfs(a, b);
if (f[a][b] > 0)
printf("Masha");
else if (!f[a][b])
printf("Stas");
else
printf("Missing");
}
int main() {
init();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow(long long x, int n) {
long long ans = 1;
while (n--) ans *= x;
return ans;
}
const int N = 4e4, B = 30;
long long n;
int M[N][B + 1];
int DP(long long a, int b) {
if (M[a][b] != -1) return M[a][b];
if (pow(a, b) >= n) return M[a][b] = 2;
if (a == 1 && pow(2LL, b) >= n) return M[a][b] = 1;
return M[a][b] = max(2 - DP(a + 1, b), 2 - DP(a, b + 1));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long a, b;
cin >> a >> b >> n;
if (a * a >= n) {
long long k = n - a;
cout << (k % 2 == 0 ? "Masha\n" : "Stas\n");
return 0;
}
for (int i = 0; i < N; ++i)
for (int j = 0; j <= B; ++j) M[i][j] = -1;
switch (DP(a, b)) {
case 2:
cout << "Masha\n";
break;
case 1:
cout << "Missing\n";
break;
case 0:
cout << "Stas\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[31000][50];
long long n;
string s[3] = {"Stas", "Missing", "Masha"};
int dp(int a, int b) {
if (f[a][b] != -1)
return f[a][b];
else if (a == 1 && (1 << b) >= n)
return f[a][b] = 1;
else if (a * a >= n && b == 1)
return f[a][b] = 2 - 2 * ((n - a) & 1);
else if (pow(a, b) + 1e-6 >= n)
return f[a][b] = 2;
else
return f[a][b] = 2 - min(dp(a + 1, b), dp(a, b + 1));
}
int a, b;
int main() {
memset(f, -1, sizeof f);
cin >> a >> b >> n;
cout << s[dp(a, b)] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_BUF_SIZE = 16384;
char BUFOR[MAX_BUF_SIZE];
int BUF_SIZE, BUF_POS;
char ZZZ;
int _MINUS;
const int MXN = 2000010;
const int C = 262144;
const int INF = 1000000001;
map<pair<int, int>, int> M;
int n;
int licz(int a, int b) {
if (a == 1) {
if (pow(2.0, b) >= n) return -1;
}
if (M.count(make_pair(a, b))) return M[make_pair(a, b)];
if (pow((double)a, b) >= n) {
return 1;
}
if (b == 1 && licz(a, b + 1) == 1) {
if ((long long int)a * a >= n) {
M[make_pair(a, b)] = !((n - a) % 2);
return !((n - a) % 2);
}
}
int wyn1 = licz(a + 1, b);
int wyn2 = licz(a, b + 1);
if (wyn1 == 0 || wyn2 == 0) {
M[make_pair(a, b)] = 1;
return 1;
}
if (wyn1 == -1 || wyn2 == -1) {
M[make_pair(a, b)] = -1;
return -1;
}
M[make_pair(a, b)] = 0;
return 0;
}
int main() {
int a, b;
scanf("%d %d %d", &a, &b, &n);
int wyn = licz(a, b);
if (wyn == -1)
printf("Missing\n");
else if (wyn == 1)
printf("Masha\n");
else
printf("Stas\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[100010][70];
long long a, b, n;
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long x = binpow(a, b >> 1);
long long ans = x * x;
if (b & 1) ans = ans * a;
return ans;
}
int dfs(long long a, long long b) {
if (binpow(a, b) >= n) return 0;
if (dp[a][b] != -1) return dp[a][b];
if (a == 1) {
if (b >= 40 || b * b >= n) return dp[a][b] = 2;
if (dfs(a + 1, b) == 1) return dp[a][b] = 0;
if (dfs(a, b + 1) == 0) return dp[a][b] = 1;
if (dfs(a, b + 1) == 2) return dp[a][b] = 2;
}
if (b == 1) {
for (int i = 0; (i + a) * (i + a) < n; i++) {
if (i % 2 == 0 && dfs(i + a, 2) == 1) return dp[a][b] = 0;
if (i % 2 == 1 && dfs(i + a, 2) == 1) return dp[a][b] = 1;
}
if ((n - a) % 2 == 1)
return dp[a][b] = 1;
else
return dp[a][b] = 0;
}
if (dfs(a + 1, b) == 1 || dfs(a, b + 1) == 1)
return dp[a][b] = 0;
else
return dp[a][b] = 1;
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> a >> b >> n;
if (b * log(a) >= log(double(n)))
cout << "Stas" << endl;
else if (dfs(a, b) == 0)
cout << "Masha" << endl;
else if (dfs(a, b) == 2)
cout << "Missing" << endl;
else if (dfs(a, b) == 1)
cout << "Stas" << endl;
return 0;
}
|
#include <bits/stdc++.h>
int a, b, n;
bool wins[100005][35];
inline bool exceeds(int a, int b) {
if (a >= n) return true;
long long num = 1;
for (int i = 0; i < b; i++) {
num *= (long long)a;
if (num >= n) return true;
}
return false;
}
int main() {
scanf("%d %d %d", &a, &b, &n);
if (a == 1 && exceeds(2, b)) {
printf("Missing\n");
return 0;
}
wins[100003][1] = !exceeds(100003, 1) && n % 2;
for (int i = 100002; i >= 1; i--)
for (int k = 32; k >= 1; k--)
if (!exceeds(i, k))
wins[i][k] = (!exceeds(i + 1, k) && !wins[i + 1][k]) ||
(!exceeds(i, k + 1) && !wins[i][k + 1]);
printf("%s\n", !wins[a][b] ? "Stas" : "Masha");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
bool leq(int a, int b) {
long long s = 1;
for (int i = 0; i < (b); ++i) {
s *= a;
if (s >= n) return true;
}
return false;
}
char dp[50000][32];
int Dp(int a, int b) {
char &res = dp[a][b];
if (res != -1) return res;
if (leq(a, b)) return res = 1;
if (b == 1 && a >= 40000) {
char s = Dp(a, b + 1);
if (!s) return res = 1;
return res = char((n - a) % 2 == 0);
}
char s1 = Dp(a + 1, b), s2 = Dp(a, b + 1);
if (!s1 || !s2) return res = 1;
return res = 0;
}
int main(void) {
cin >> a >> b >> n;
if (a == 1 && leq(2, b)) {
puts("Missing");
return 0;
}
memset(dp, -1, sizeof dp);
puts(Dp(a, b) ? "Masha" : "Stas");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[10050][35];
int n;
bool check(int a, int b) {
long long int sum = 1;
for (int i = 1; i <= b; i++) {
sum *= a;
if (sum >= n) return true;
}
return false;
}
int dfs(int a, int b) {
if (dp[a][b] != -2) return dp[a][b];
if (a == 1 && check(2, b)) return dp[a][b] = -1;
if (b == 1 && check(a, 2)) {
if ((n - a) % 2 == 0)
return dp[a][b] = 1;
else
return dp[a][b] = 0;
}
if (check(a, b)) return dp[a][b] = 1;
int u = dfs(a + 1, b), v = dfs(a, b + 1);
if (u == 1 && v == 1) return dp[a][b] = 0;
if (u == 0) v = dfs(a, b + 1);
if (v == 0) u = dfs(a + 1, b);
if (u == 0 || v == 0) return dp[a][b] = 1;
if (u == -1 && v == -1) return dp[a][b] = -1;
}
int main() {
int a, b;
while (cin >> a >> b >> n) {
for (int i = 0; i < 10050; i++) {
for (int j = 0; j < 35; j++) {
dp[i][j] = -2;
}
}
if (check(a + 1, b) && check(a, b + 1)) {
puts("Stas");
continue;
}
if (b == 1 && check(a, 2)) {
if ((n - a) % 2 == 0)
puts("Masha");
else
puts("Stas");
continue;
}
int res = dfs(a, b);
if (res == -1)
puts("Missing");
else if (res == 0)
puts("Stas");
else
puts("Masha");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 40005;
int dp[N][40], n, a, b;
int kissme(int x, int y) {
if (!y) return 1;
long long res = kissme(x, y / 2);
res = res * res;
if (res >= n) return n;
if (y % 2 == 1) res = res * x;
if (res >= n) return n;
return res;
}
int dfs(int x, int y) {
if (dp[x][y] != -1) return dp[x][y];
if (x == 1 && (1 << y) >= n) return 1;
if (x * x >= n && y == 1) return 2 * ((n - x) % 2 == 0);
if (kissme(x, y) >= n) return dp[x][y] = 2;
dp[x][y] = 2 - min(dfs(x + 1, y), dfs(x, y + 1));
return dp[x][y];
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> a >> b >> n;
if (dfs(a, b) == 0) {
cout << "Stas\n";
} else if (dfs(a, b) == 1) {
cout << "Missing\n";
} else
cout << "Masha\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, maxn = 100001;
int a, b, n;
map<pair<int, int>, int> m;
bool check(int x, int y) {
long long ans = 1;
for (int i = 1; i <= y; i++) {
ans *= (long long)x;
if (ans >= n) return 1;
}
return 0;
}
int dfs(int x, int y) {
if (m.find(pair<int, int>(x, y)) != m.end()) return m[pair<int, int>(x, y)];
if (x == 1 && check(2, y)) return m[pair<int, int>(x, y)] = 2;
if (y == 1 && check(x, 2)) {
if ((n - x) & 1)
return m[pair<int, int>(x, y)] = 0;
else
return m[pair<int, int>(x, y)] = 1;
}
if (check(x, y)) return m[pair<int, int>(x, y)] = 1;
int t1 = check(x + 1, y), t2 = check(x, y + 1);
if (t1 && t2) return m[pair<int, int>(x, y)] = 0;
if (t1 == 0) t1 = dfs(x + 1, y);
if (t2 == 0) t2 = dfs(x, y + 1);
if (t1 == 0 || t2 == 0) return m[pair<int, int>(x, y)] = 1;
if (t1 == 2 || t2 == 2) return m[pair<int, int>(x, y)] = 2;
return m[pair<int, int>(x, y)] = 0;
}
int main() {
while (~scanf("%d%d%d", &a, &b, &n)) {
if (check(a + 1, b) && check(a, b + 1))
printf("Stas\n");
else if (b == 1 && check(a, 2)) {
if ((n - a) & 1)
printf("Stas\n");
else
printf("Masha\n");
} else {
m.clear();
int ans = dfs(a, b);
if (ans == 0)
printf("Stas\n");
else if (ans == 1)
printf("Masha\n");
else
printf("Missing\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void cmax(T& x, T y) {
if (x < y) x = y;
}
template <typename T>
void cmin(T& x, T y) {
if (x > y) x = y;
}
inline int read() {
int f = 1, x = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return f * x;
}
int a, b, n;
map<pair<int, int>, int> S;
inline bool bp(int x, int y) {
long long res = 1;
for (int i = (1), iend = (y); i <= iend; i++) {
res = res * x;
if (res >= n) return 1;
}
return 0;
}
inline int dfs(int x, int y) {
if (bp(x, y)) return 2;
if (S.count(make_pair(x, y))) return S[make_pair(x, y)];
if (x == 1 && bp(2, y)) return 1;
if (y == 1 && x * x >= n) {
if ((n - x) % 2 == 1)
return 0;
else
return 2;
}
int t = min(dfs(x + 1, y), dfs(x, y + 1));
S.insert(make_pair(make_pair(x, y), 2 - t));
return 2 - t;
}
int main() {
a = read(), b = read(), n = read();
if (dfs(a, b) == 0)
printf("Stas");
else if (dfs(a, b) == 2)
printf("Masha");
else
printf("Missing");
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int a, b, n;
map<pair<int, int>, int> Map;
int go(int a, int b) {
if (Map.count(make_pair(a, b))) return Map[make_pair(a, b)];
if (a == 1) {
if ((1LL << b) >= n) return Map[make_pair(a, b)] = 0;
}
if (b == 1) {
if (a * a >= n) {
if ((a ^ n) & 1)
return Map[make_pair(a, b)] = -1;
else
return Map[make_pair(a, b)] = 1;
}
}
int res = -1;
long long x = 1;
for (int i = 0; i < b + 1; ++i) x *= a;
if (x < n) res = max(res, -go(a, b + 1));
x = 1;
for (int i = 0; i < b; ++i) x *= a + 1;
if (x < n) res = max(res, -go(a + 1, b));
return Map[make_pair(a, b)] = res;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
int res = go(a, b);
if (res == 1) puts("Masha");
if (res == 0) puts("Missing");
if (res == -1) puts("Stas");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow(long long x, int n) {
long long ans = 1;
while (n--) ans *= x;
return ans;
}
const int N = 4e4, B = 30;
long long n;
int M[N][B + 1];
int DP(long long a, int b) {
if (M[a][b] != -1) return M[a][b];
if (pow(a, b) >= n) return M[a][b] = 2;
if (a == 1 && pow(2LL, b) >= n) return M[a][b] = 1;
return M[a][b] = max(2 - DP(a + 1, b), 2 - DP(a, b + 1));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long a, b;
cin >> a >> b >> n;
if (a * a >= n) {
long long k = n - a;
cout << (k % 2 == 0 ? "Masha\n" : "Stas\n");
return 0;
}
for (int i = 0; i < N; ++i)
for (int j = 0; j <= B; ++j) M[i][j] = -1;
switch (DP(a, b)) {
case 2:
cout << "Masha\n";
break;
case 1:
cout << "Missing\n";
break;
case 0:
cout << "Stas\n";
}
return 0;
}
|
#include <bits/stdc++.h>
const int MOD = 1e9 + 7;
const int MAX = 1e9 + 7;
const int MIN = -1e9 + 7;
using namespace std;
int a, b, n;
long long power(long long x, long long y) {
if (y == 0) return 1;
long long s = power(x, y / 2);
s *= s;
if (y % 2 == 1) s *= x;
return s;
}
int dp[100005][35][2];
bool solve(int asas, int as, int flag) {
if (power(asas, as) >= n && flag == 1) return 0;
if (power(asas, as) >= n && flag == 0) return 1;
if (dp[asas][as][flag] + 1) return dp[asas][as][flag];
if (flag && asas <= 100000)
dp[asas][as][flag] =
solve(asas + 1, as, flag ^ 1) & solve(asas, as + 1, flag ^ 1);
else if (flag)
dp[asas][as][flag] = solve(asas, as + 1, flag ^ 1);
if (!flag && asas <= 100000)
dp[asas][as][flag] =
solve(asas + 1, as, flag ^ 1) | solve(asas, as + 1, flag ^ 1);
else if (!flag)
dp[asas][as][flag] = solve(asas, as + 1, flag ^ 1);
return dp[asas][as][flag];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> n;
memset(dp, -1, sizeof dp);
if (a == 1)
if (power(a + 1, b) >= n) {
cout << "Missing";
return 0;
}
if (solve(a, b, 0))
cout << "Masha";
else
cout << "Stas";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long power(int a, int b) {
if (b == 0) return 1;
long long temp = power(a, b / 2);
if (b & 1)
return temp * temp * a;
else
return temp * temp;
}
int DFS(int a, int b) {
if (a == 1 && 1 << b >= n) {
return 0;
}
if (power(a, b) >= n) {
return 2;
}
int t1 = DFS(a, b + 1);
if (t1 == 1) {
return 2;
}
int t2 = DFS(a + 1, b);
if (t2 == 1) {
return 2;
}
if (t1 == 0 || t2 == 0) {
return 0;
} else {
return 1;
}
}
int main() {
long long a, b;
cin >> a >> b >> n;
int state = DFS(a, b);
if (state == 2) {
printf("Masha\n");
} else if (state == 1) {
printf("Stas\n");
} else {
printf("Missing\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000LL;
long long n;
long long POW(long long x, long long y) {
long long tmp = 1;
if (y == 1) return x;
if (y % 2) tmp = x;
long long ans = POW(x, y / 2);
if (ans >= MAX) return MAX;
return ans * ans * tmp > MAX ? MAX : ans * ans * tmp;
}
int dp[60000][100];
int dfs(int a, int b) {
if (POW(a + 1, b) >= n && POW(a, b + 1) >= n) return 0;
if (b == 1 && a * a >= n) return (n - a + 1) % 2;
if (a < 60000 && b < 100 && dp[a][b] != -1) return dp[a][b];
if (((POW(a + 1, b) < n) && !dfs(a + 1, b)) ||
(POW(a, b + 1) < n && !dfs(a, b + 1)))
return (a < 60000 && b < 100) ? dp[a][b] = 1 : 1;
return (a < 60000 && b < 100) ? dp[a][b] = 0 : 0;
}
int main() {
long long a, b;
while (cin >> a >> b >> n) {
memset(dp, -1, sizeof(dp));
if (a == 1 && POW(2, b) >= n) {
cout << "Missing" << endl;
} else {
if (!dfs(a, b))
cout << "Stas" << endl;
else
cout << "Masha" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
bool Lose(long long x, long long y) {
long long tmp = 1;
for (int i = 0; i < y; ++i) {
tmp *= x;
if (tmp >= n) return true;
}
return false;
}
map<pair<long long, long long>, long long> mp;
long long dfs(long long x, long long y) {
if (mp.find(pair<long long, long long>(x, y)) != mp.end()) {
return mp[pair<long long, long long>(x, y)];
}
if (x == 1 && Lose(x + 1, y)) {
return mp[pair<long long, long long>(x, y)] = -1;
}
if (y == 1 && Lose(x, y + 1)) {
if ((n - x) & 1) return mp[pair<long long, long long>(x, y)] = 0;
return mp[pair<long long, long long>(x, y)] = 1;
}
if (Lose(x, y)) return mp[pair<long long, long long>(x, y)] = 1;
long long u = Lose(x + 1, y);
long long v = Lose(x, y + 1);
if (u && v) {
return mp[pair<long long, long long>(x, y)] = 0;
}
if (!u) u = dfs(x + 1, y);
if (!v) v = dfs(x, y + 1);
if (u == 0 || v == 0) {
return mp[pair<long long, long long>(x, y)] = 1;
}
if (u == -1 || v == -1) return mp[pair<long long, long long>(x, y)] = -1;
return mp[pair<long long, long long>(x, y)] = 0;
}
int main() {
long long a, b;
while (cin >> a >> b >> n) {
mp.clear();
if (Lose(a + 1, b) && Lose(a, b + 1)) {
cout << "Stas" << endl;
continue;
}
if (b == 1 && Lose(a, b + 1)) {
if ((n - a) & 1)
cout << "Stas" << endl;
else
cout << "Masha" << endl;
continue;
}
long long tmp = dfs(a, b);
if (tmp < 0)
cout << "Missing" << endl;
else if (tmp)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> DP;
long long n;
long long poww(int a, int b) {
long long p = 1;
while (b--) {
p *= a;
}
return p;
}
int calc(long long a, int b) {
if (DP[a][b] != -1) return DP[a][b];
if (b == 1 && a * a >= n) return DP[a][b] = ((n - a) % 2 == 1 ? 0 : 2);
if (poww(a, b) >= n) {
return DP[a][b] = 2;
}
if (a == 1 && poww(2, b) >= n) {
return DP[a][b] = 1;
}
return DP[a][b] = max(2 - calc(a + 1, b), 2 - calc(a, b + 1));
}
int main() {
long long a, b;
cin >> a >> b >> n;
if (a * a >= n) {
cout << (((a * a) - n) % 2 == 1 ? "Stas" : "Masha") << "\n";
} else {
DP.assign(4e4, vector<int>(31, -1));
long long ans = calc(a, b);
if (ans == 2)
cout << "Masha\n";
else if (ans == 0)
cout << "Stas\n";
else
cout << "Missing\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int was[40000][100];
int res[40000][100];
int a, b;
int check(int a, int b, int n) {
if (a == 1) return 0;
long long c = 1;
for (int i = 0; i < b; i++) {
c *= a;
if (c >= n) return 1;
}
return 0;
}
int go(int a, int b, int n) {
if (check(a, b, n)) return 1;
if (a >= 40000) return ((n - a) & 1) ? -1 : 1;
if (was[a][b]) return res[a][b];
if (b >= 100) return 0;
was[a][b] = 1;
return res[a][b] = max(-go(a + 1, b, n), -go(a, b + 1, n));
}
int main() {
scanf("%d%d%d", &a, &b, &n);
int tmp = go(a, b, n);
if (tmp == 1)
printf("Masha\n");
else if (tmp == -1)
printf("Stas\n");
else
printf("Missing\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 35000;
const int M = 31;
int a, b, k;
int f[N][M];
bool judge(int a, int b) {
long long res = 1ll;
for (int i = 0; i < b; i++) {
res = res * a;
if (res <= 0 || res >= k) return true;
}
return false;
}
int dfs(int x, int y) {
if (f[x][y] != -1) return f[x][y];
if (judge(x, y)) return f[x][y] = 1;
int res = 0;
res |= !dfs(x + 1, y);
res |= !dfs(x, y + 1);
return f[x][y] = res;
}
int A(int c) {
if (judge(1, c)) return 0;
int as = 0;
for (; !judge(2, c); c++) {
if (f[2][c] == 0) {
if (as == 0)
return 1;
else
return -1;
}
as = 1 - as;
}
return 0;
}
int B(int c) {
int al = sqrt(k - 0.0000001), as = 0;
while (c <= al) {
if (f[c][2] == 0) return as == 0;
c++;
as = 1 - as;
}
as = (as + k - c - 1) % 2;
return as;
}
int main() {
memset(f, -1, sizeof(f));
scanf("%d%d%d", &a, &b, &k);
if (judge(a, b)) {
printf("Masha\n");
return 0;
}
for (int i = 2; i < N; i++)
for (int j = 2; j < M; j++) f[i][j] = dfs(i, j);
if (a != 1 && b != 1) {
if (f[a][b])
printf("Masha\n");
else
printf("Stas\n");
return 0;
}
if (a == 1 && b == 1) {
int x = A(b + 1), y = B(a + 1);
if (x < 0 || y == 0)
printf("Masha\n");
else if (x == 0)
printf("Missing\n");
else
printf("Stas\n");
} else if (a == 1) {
int x = A(b);
if (x == 0)
printf("Missing\n");
else if (x == 1)
printf("Masha\n");
else
printf("Stas\n");
} else if (b == 1) {
if (B(a))
printf("Masha\n");
else
printf("Stas\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n, sqrt_a, f[40000][40], g[40];
bool over(int a, int b) {
long long s = 1;
for (int i = 0; i < b; ++i) {
s *= (long long)(a);
if (s >= n) return true;
}
return false;
}
int solve(int a, int b) {
if (a >= sqrt_a && b == 1) return (n - 1 - a) & 1;
if (f[a][b] == -1) {
f[a][b] = 0;
if (!over(a + 1, b) && !solve(a + 1, b)) f[a][b] = 1;
if (!over(a, b + 1) && !solve(a, b + 1)) f[a][b] = 1;
}
return f[a][b];
}
int main() {
scanf("%d%d%d", &a, &b, &n);
memset(f, -1, sizeof(f));
sqrt_a = (int)ceil(sqrt(n));
if (a == 1) {
g[39] = 2;
for (int i = 38; i >= b; --i) {
g[i] = (g[i + 1] == 2) ? 2 : 0;
if (!g[i + 1]) g[i] = 1;
if (!over(2, i) && !solve(2, i)) g[i] = 1;
}
if (g[b] == 2)
printf("Missing\n");
else
printf(g[b] == 1 ? "Masha\n" : "Stas\n");
} else
printf(solve(a, b) == 1 ? "Masha\n" : "Stas\n");
return 0;
}
|
#include <bits/stdc++.h>
int n, f[40000][30];
bool check(int a, int b) {
long long res = 1;
for (int i = 1; i <= b; i++)
if ((res *= a) >= n) return 0;
return 1;
}
bool work(int a, int b) {
if (b == 1 && a * a >= n) return (n - a) & 1;
if (f[a][b] != -1) return f[a][b];
if (a == 1 && !check(2, b)) return -1;
f[a][b] = 1;
if (check(a + 1, b) && work(a + 1, b)) f[a][b] = 0;
if (check(a, b + 1) && work(a, b + 1)) f[a][b] = 0;
return f[a][b];
}
int a, b;
int main() {
scanf("%d%d%d", &a, &b, &n);
if (a == 1 && !check(2, b)) return puts("Missing"), 0;
memset(f, -1, sizeof f);
puts(work(a, b) ? "Stas" : "Masha");
}
|
#include <bits/stdc++.h>
using namespace std;
int sg[200010][50];
int n;
bool power(long long x, int y) {
long long res = 1;
for (int i = 1; i <= y; i++) {
res *= x;
if (res >= n) return 0;
}
return 1;
}
int dfs(int a, int b) {
if (a > 200000 || b > 40) return 0;
if (sg[a][b] != -1) return sg[a][b];
if (!power(a, b)) return sg[a][b] = 0;
if (!dfs(a + 1, b) && !dfs(a, b + 1))
return sg[a][b] = 1;
else
return sg[a][b] = 0;
}
int main() {
int a, b;
cin >> a >> b >> n;
memset(sg, -1, sizeof sg);
if (a == 1 && !power(a + 1, b)) {
printf("Missing\n");
return 0;
}
if (b == 1 && a * a >= n) {
if ((n - a) & 1)
printf("Stas\n");
else
printf("Masha\n");
return 0;
}
dfs(a, b);
if (sg[a][b] == 0)
printf("Masha\n");
else
printf("Stas\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s[] = {"Stas", "Missing", "Masha"};
int n, dp[10005][40];
int f(int a, int b) {
if (~dp[a][b]) return dp[a][b];
if (a == 1 && (1ll << b) >= n) return dp[a][b] = 1;
if (b == 1 && (long long)a * a >= n) return dp[a][b] = (n - a) & 1 ? 0 : 2;
if (pow(a, b) + 1e-6 >= n) return dp[a][b] = 2;
return dp[a][b] = 2 - min(f(a + 1, b), f(a, b + 1));
}
int main() {
int a, b;
memset(dp, -1, sizeof(dp));
cin >> a >> b >> n;
cout << s[f(a, b)] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using std::vector;
const int M = 30;
vector<int> f[M + 1];
int c;
void init() {
long long j;
int k;
for (int i = 0; i * i < c; ++i)
for (j = i * i, k = 2; j < c && k <= M; j *= i, ++k) f[k].push_back(0);
for (int i = 0; i < f[2].size(); ++i) f[1].push_back(0);
}
int dfs(int a, int b) {
if (b == 1 && a >= f[2].size()) return (c - a) & 1 ? 1 : -1;
if (a >= f[b].size()) return -1;
if (f[b][a]) return f[b][a];
return f[b][a] = dfs(a + 1, b) > 0 || dfs(a, b + 1) > 0 ? -1 : 1;
}
int main() {
int a, b;
scanf("%d%d%d", &a, &b, &c);
init();
if ((a == 1 && b == 1 && c == 2) || (a == 1 && b > 1 && f[b].size() <= 2))
puts("Missing");
else
puts(dfs(a, b) > 0 ? "Stas" : "Masha");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
const double eps = 1e-8;
map<pair<int, int>, int> dp;
int gao(int a, int b, int n) {
if (pow(1.0 * a, 1.0 * b) + eps >= n) {
return dp[make_pair(a, b)] = 1;
}
if (dp.count(make_pair(a, b)) == 0) {
if (a == 1 && pow(2.0, b) + eps >= n)
dp[make_pair(a, b)] = 0;
else if (b == 1 && pow(a, 2.0) + eps >= n) {
dp[make_pair(a, b)] = (n - a) % 2 ? -1 : 1;
} else {
dp[make_pair(a, b)] = max(-gao(a + 1, b, n), -gao(a, b + 1, n));
}
}
return dp[make_pair(a, b)];
}
int main() {
int a, b, n;
while (cin >> a >> b >> n) {
dp.clear();
int ret = gao(a, b, n);
if (ret == 0)
cout << "Missing" << endl;
else if (ret == 1)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n;
vector<vector<bool> > vis(32, vector<bool>((long long int)ceil(sqrt(1e9)) + 1));
vector<vector<long long int> > dp(
32, vector<long long int>((long long int)ceil(sqrt(1e9)) + 1));
long long int sub(long long int b, long long int a) {
if (vis[b][a]) {
return dp[b][a];
}
vis[b][a] = true;
if (pow(a, b) >= n) {
dp[b][a] = 0;
return dp[b][a];
}
long long int right, down, draw, win, loss;
draw = win = loss = 0;
right = sub(b, a + 1);
down = sub(b + 1, a);
if (right == -1) {
draw++;
} else if (right == 1) {
win++;
} else if (right == 0) {
loss++;
}
if (down == -1) {
draw++;
} else if (down == 1) {
win++;
} else if (down == 0) {
loss++;
}
if (win) {
dp[b][a] = 0;
} else if (draw) {
dp[b][a] = -1;
} else {
dp[b][a] = 1;
}
return dp[b][a];
}
void solve() {
long long int a, b;
cin >> a >> b >> n;
vis[31][1] = true;
dp[31][1] = -1;
long long int ans = sub(b, a);
if (ans == 0) {
cout << "Masha" << '\n';
;
} else if (ans == 1) {
cout << "Stas" << '\n';
;
} else {
cout << "Missing" << '\n';
;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
tc = 1;
for (int i = 1; i <= tc; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e4 + 9;
long long a, b, n;
map<pair<int, int>, int> mp;
long long pow(long long a, long long b) {
if (!b) return 1;
long long l = 1, r = 1;
if (b & 1) l = a;
r = pow(a, b / 2);
long long res = r * r;
res = min(res, n);
return min(res * l, n);
}
long long rec(long long a, long long b) {
if (mp.find({a, b}) != mp.end()) return mp[{a, b}];
if (pow(a, b) >= n) return 10;
if (a == 1 && b >= 33333) return 5;
if (a >= 33333 && b == 1) {
if ((n - a) % 2 == 0)
return 10;
else
return 0;
}
long long res;
long long l = rec(a + 1, b), r = rec(a, b + 1);
if (l == 0 || r == 0)
res = 10;
else if (l == 10 && r == 10)
res = 0;
else
res = 5;
mp[{a, b}] = res;
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> a >> b >> n;
long long ans = rec(a, b);
if (ans == 0)
cout << "Stas";
else if (ans == 10)
cout << "Masha";
else
cout << "Missing";
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[40005][31];
bool vis[40005][31];
int a, b;
long long n;
inline long long qpow(int a, int b) {
long long res = 1ll, tp = a;
while (b) {
if (b & 1) {
res *= tp;
}
tp *= tp;
b >>= 1;
}
return res;
}
int cal(int a, int b) {
if (qpow(a, b) >= n) {
return 1;
}
if (a == 1 && qpow(2, b) >= n) return 2;
if (b == 1 && qpow(a, 2) >= n) {
long long t = n - ((long long)(a));
if (t & 1ll) return 0;
return 1;
}
if (vis[a][b]) return dp[a][b];
vis[a][b] = 1;
if (cal(a + 1, b) == 0) {
return dp[a][b] = 1;
}
if (cal(a, b + 1) == 0) {
return dp[a][b] = 1;
}
if (cal(a + 1, b) == 2) {
return dp[a][b] = 2;
}
if (cal(a, b + 1) == 2) {
return dp[a][b] = 2;
}
return dp[a][b] = 0;
}
int main() {
scanf("%d%d%lld", &a, &b, &n);
int tp = cal(a, b);
if (tp == 0) {
puts("Stas");
return 0;
}
if (tp == 1) {
puts("Masha");
return 0;
}
if (tp == 2) {
puts("Missing");
return 0;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:64000000")
using namespace std;
template <typename first>
inline first abs(const first& a) {
return a < 0 ? -a : a;
}
template <typename first>
inline first sqr(const first& a) {
return a * a;
}
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
const int INF = 1000 * 1000 * 1000;
const int N = 32000 + 13;
int a, b, n;
vector<long long> g[N];
int z[N][35];
int solve(int a, int b) {
int& res = z[a][b];
if (res != -1) return res;
if (a == 1) {
if (int((g[a + 1]).size()) > b && g[a + 1][b] >= n) return res = 2;
if (solve(a + 1, b) == 0) return res = 1;
int t = solve(a, b + 1);
if (t == 1)
return res = 0;
else if (t == 0)
return res = 1;
else
return res = 2;
}
if (b == 1 && int((g[a]).size()) > b + 1 && g[a][b + 1] >= n)
return res = 1 - (n - a) % 2;
if (int((g[a + 1]).size()) > b && g[a + 1][b] < n && solve(a + 1, b) == 0)
return res = 1;
if (int((g[a]).size()) > b + 1 && g[a][b + 1] < n && solve(a, b + 1) == 0)
return res = 1;
return res = 0;
}
int main() {
for (int i = 0; i < int(35); i++) g[1].push_back(1);
for (int i = 2; i < N; i++) {
long long cur = 1;
while (cur < INF) g[i].push_back(cur), cur *= i;
g[i].push_back(cur);
}
cin >> a >> b >> n;
memset(z, -1, sizeof(z));
int t = solve(a, b);
if (t == 0)
cout << "Stas";
else if (t == 1)
cout << "Masha";
else
cout << "Missing";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
int T, m, k;
long long n, c;
inline long long pow(long long a, int k) {
register long long w = 1;
while (k-- && w < c) w *= a;
return w;
}
inline int cal(long long n, int m) {
bool v[2] = {false, false};
while (pow(n + 1, m + 1) < c) ++n, ++m;
if (pow(n, m + 1) < c) {
register int k = m + 1;
for (register long long x = pow(n, m + 2); x < c; x *= n, ++k)
;
v[((k - m) & 1) ^ 1] = true;
}
if (pow(n + 1, m) < c) {
register long long l = n + 1, r = c - 1, w, x;
while (l <= r) pow(w = (l + r) >> 1, m) < c ? l = (x = w) + 1 : r = w - 1;
v[((x - n) & 1) ^ 1] = true;
}
register int g = 0;
while (g < 2 && v[g]) ++g;
return g;
}
int main() {
T = 1;
while (T--) {
scanf(
"%lld"
"%d"
"%lld",
&n, &m, &c);
if (n > 1)
puts(cal(n, m) ? "Masha" : "Stas");
else {
for (n = 1LL << m, k = 1; n < c && cal(2, m); n <<= 1, k ^= 1, ++m)
;
puts(n >= c ? "Missing" : k ? "Masha" : "Stas");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
const int A_MAX = 50000;
const int B_MAX = 50;
int A, B, N;
int dp[A_MAX][B_MAX];
int solve(int a, int b) {
if (pow((long double)a, (long double)b) > N - 0.5) return 2;
if (b >= B_MAX) return 1;
if (a >= A_MAX) return (A - a) % 2 * 2;
int &ans = dp[a][b];
if (ans >= 0) return ans;
int x = solve(a + 1, b);
int y = solve(a, b + 1);
if (x == 0 || y == 0)
return ans = 2;
else if (x == 1 || y == 1)
return ans = 1;
else
return ans = 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> A >> B >> N;
memset(dp, -1, sizeof(dp));
int ans = solve(A, B);
if (ans == 2)
cout << "Masha" << '\n';
else if (ans == 1)
cout << "Missing" << '\n';
else
cout << "Stas" << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(long long &x) {
x = 0;
long long f = 1;
char ch = getchar();
while (ch != 45 && (ch > '9' || ch < '0')) ch = getchar();
if (ch == 45) {
f = -1, ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - 48;
ch = getchar();
}
x *= f;
}
const long long N = 1e5 + 10, M = 35;
long long i, j, k, n, s, t, m;
long long pd[N][M];
long long check(long long x, long long y) {
long long now = 1;
for (long long i = 1; i <= y; i++) {
now *= x;
if (now >= n) return 0;
}
return 1;
}
long long solve(long long x, long long y) {
if (pd[x][y] != -1) return pd[x][y];
if (x > 1e5) return pd[x][y] = (n - x - 1) % 2;
if (y > 32) return pd[x][y] = 2;
if ((solve(x, y + 1) == 0 && check(x, y + 1)) ||
(solve(x + 1, y) == 0 && check(x + 1, y)))
return pd[x][y] = 1;
if ((solve(x, y + 1) == 2 && check(x, y + 1)) ||
(solve(x + 1, y) == 2 && check(x + 1, y)))
return pd[x][y] = 2;
return pd[x][y] = 0;
}
signed main() {
memset(pd, -1, sizeof(pd));
long long a, b;
read(a), read(b), read(n);
if (solve(a, b) == 2) printf("Missing\n");
if (solve(a, b) == 1) printf("Masha\n");
if (solve(a, b) == 0) printf("Stas\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n, t1, dp[100005][31];
int getans_dp(const int a, const int b, const int n) {
if (dp[a][b]) return dp[a][b];
long long a1 = a;
if (a1 >= n) return dp[a][b] = 1;
for (int i = 2; i <= b; ++i) {
a1 *= a;
if (a1 >= n) return dp[a][b] = 1;
}
if (a * a >= n && b == 1) return dp[a][b] = (n - a) % 2 ? -1 : 1;
if (getans_dp(a + 1, b, n) == -1 || getans_dp(a, b + 1, n) == -1)
dp[a][b] = 1;
else
dp[a][b] = -1;
return dp[a][b];
}
int getans(const int a, const int b, const int n) {
if (a == 1) {
for (int i = b; (1 << i) < n; ++i) {
if (getans_dp(a + 1, i, n) == -1) return (i - b) % 2 ? -1 : 1;
}
return 0;
} else {
return getans_dp(a, b, n);
}
}
int main() {
scanf("%d %d %d", &a, &b, &n);
t1 = getans(a, b, n);
if (t1 == 0) {
puts("Missing");
} else if (t1 == 1) {
puts("Masha");
} else {
puts("Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void remax(T &A, T B) {
if (A < B) A = B;
}
template <class T>
inline void remin(T &A, T B) {
if (A > B) A = B;
}
string ToString(long long num) {
string ret;
bool neg = false;
if (num < 0) num *= ~0, neg = true;
do {
ret += ((num % 10) + '0');
num /= 10;
} while (num);
if (neg) ret += '-';
reverse(ret.begin(), ret.end());
return ret;
}
long long ToNumber(string s) {
long long r = 0, p = 1;
int e = (s[0] == '-');
for (int i = (int)s.size() - 1; i >= e; --i) r += (s[i] - '0') * p, p *= 10;
if (e) r *= ~0;
return r;
}
long long Gcd(long long a, long long b) {
while (a %= b ^= a ^= b ^= a)
;
return b;
}
long long Power(long long base, unsigned long long power) {
long long ret = 1;
while (power) {
if (power & 1) ret *= base;
power >>= 1;
base *= base;
}
return ret;
}
long long PowerMod(long long base, unsigned long long power, long long mod) {
if (!power) return 1 % mod;
if (power & 1) return (base * PowerMod(base, power - 1, mod)) % mod;
return PowerMod((base * base) % mod, power >> 1, mod);
}
int Log(long long num, long long base) {
int ret = 0;
while (num) {
++ret;
num /= base;
}
return ret;
}
int memo[10000 + 1250][5];
int n;
int f(int a, int b) {
int &ret = memo[a][b];
if (~ret) return ret;
long long apb = 1;
for (int i = 0; i < b && apb < n; ++i) apb *= a;
if (apb >= n)
ret = 1;
else if (b == 1 && (long long)a * a >= n)
ret = 1 - ((n - a) & 1);
else if (a == 1 && (1LL << b) >= n)
ret = 2;
else if (!f(a + 1, b) || !f(a, b + 1))
ret = 1;
else
ret = 0;
return ret;
}
inline void run() {
int a, b, ans;
scanf("%d%d%d", &a, &b, &n);
memset(memo, ~0, sizeof memo);
ans = f(a, b);
if (!ans)
puts("Stas");
else if (ans == 1)
puts("Masha");
else
puts("Missing");
}
int main() {
FILE *input = stdin;
FILE *output = stdout;
while (!feof(input)) {
run();
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[50000][35];
int c;
long long pow(int a, int b) {
if (!b) return 1;
long long tmp = pow(a, b >> 1);
tmp *= tmp;
if (b & 1) return tmp * a;
return tmp;
}
int work(int n, int m) {
if (pow(n, m) >= c) return 2;
if (n == 1 && (1ll << m) >= c) return 1;
if (m == 1 && (long long)n * n >= c) return (~(c - n) & 1) << 1;
if (~f[n][m]) return f[n][m];
return f[n][m] = 2 - min(work(n + 1, m), work(n, m + 1));
}
int main() {
int n, m;
cin >> n >> m >> c;
memset(f, -1, sizeof(f));
switch (work(n, m)) {
case 0:
cout << "Stas" << endl;
break;
case 1:
cout << "Missing" << endl;
break;
case 2:
cout << "Masha" << endl;
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double eps = 1e-9;
vector<long long> forbid;
long long xpow(long long a, long long n) {
if (n == 0) return 1;
long long r = xpow(a, n / 2);
r *= r;
if (n & 1) r *= a;
return r;
}
map<pair<int, int>, int> f;
long long n;
int go(int a, int b) {
if (f.count(make_pair(a, b))) return f[make_pair(a, b)];
int &res = f[make_pair(a, b)];
if (b == 1) {
if (forbid[b + 1] <= a) {
if ((n - a) % 2 == 1)
return res = -1;
else
return res = 1;
}
}
if (a == 1 && forbid[b] == 2) return 0;
if (forbid[b] < a) return -1;
int r1 = 1;
if (forbid[b] > a + 1) r1 = go(a + 1, b);
int r2 = 1;
if (forbid[b + 1] > a) r2 = go(a, b + 1);
if (r1 == -1 || r2 == -1) return res = 1;
if (r1 == 0 || r2 == 0) return res = 0;
return res = -1;
}
int main() {
long long a, b;
cin >> a >> b >> n;
forbid.resize(40);
forbid[1] = n;
for (int i = 2; i < forbid.size(); ++i) {
long long r = 1;
long long v = xpow(r, i);
while (v < n) {
r++;
v = xpow(r, i);
}
forbid[i] = r;
}
int x = go(a, b);
if (x == -1)
cout << "Stas" << endl;
else if (x == 1)
cout << "Masha" << endl;
else
cout << "Missing" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000 * 1000 * 1000;
const int MOD = 1000 * 1000 * 1000 + 7;
long long a, b, n;
vector<vector<int> > DP;
long long Pow(long long a, long long b) {
if (b == 0) return 1;
if (b == 1) return a;
if (b & 1) return a * Pow(a * a, b / 2);
return Pow(a * a, b / 2);
}
int f(long long a, long long b) {
if (Pow(a, b) >= n) return 1;
vector<int> u(3, 0);
if (a >= 100000) {
long long t = n - a;
return !(t & 1);
}
if (DP[a][b] == -1) {
u[f(a + 1, b)] = 1;
u[f(a, b + 1)] = 1;
int k = 0;
for (; u[k]; ++k)
;
DP[a][b] = (k > 0);
}
return DP[a][b];
}
int F(int a, int b, int tt) {
if (a == 1 && b >= 30) return 2;
if (a == 1) {
if (Pow(2, b) >= n)
return 2;
else {
int t = f(a + 1, b) ^ 1;
if (t == 0)
return F(a, b + 1, tt ^ 1);
else
return t == 2 ? 2 : t ^ tt;
}
}
return f(a, b);
}
string RES[3] = {"Stas", "Masha", "Missing"};
int main() {
DP.resize(100100, vector<int>(100, -1));
scanf("%lld%lld%lld", &a, &b, &n);
printf("%s", RES[F(a, b, 0)].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> dp;
int ia, ib, n;
inline int modpow(long long a, int b) {
long long res = 1;
while (b) {
if (b & 1) res *= a;
if (res >= n) return n;
a = a * a;
if (a >= n) a = n;
b >>= 1;
}
return (int)res;
}
inline int solve(int a, int b) {
if (modpow(a, b) >= n) return 1;
pair<int, int> z = pair<int, int>(a, b);
if (dp.find(z) != dp.end()) return dp[z];
if (a == 1 && b >= ib + 100) return dp[z] = -1;
int r;
if (b == 1 && a >= ia + 100)
r = ((n - a) & 1);
else
r = solve(a + 1, b);
if (!r) return dp[z] = 1;
r = solve(a, b + 1);
if (r == -1) return dp[z] = -1;
return dp[z] = r ^ 1;
}
int main() {
int a, b;
cin >> a >> b >> n;
ia = a, ib = b;
int res = solve(a, b);
if (res == 1)
cout << "Masha\n";
else if (res == 0)
cout << "Stas\n";
else
cout << "Missing\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long pow(int a, int b) {
if (b == 0) return 1;
long long ans = pow(a, b / 2);
if (b % 2 == 0)
return ans * ans;
else
return ans * ans * a;
}
int per(int a, int b) {
if (a == 1 && 1 << b >= n) {
return 0;
}
if (pow(a, b) >= n) {
return 2;
}
int t1 = per(a, b + 1);
if (t1 == 1) {
return 2;
}
int t2 = per(a + 1, b);
if (t2 == 1) {
return 2;
}
if (t1 == 0 || t2 == 0) {
return 0;
} else {
return 1;
}
}
int main() {
int a, b;
cin >> a >> b >> n;
int t = per(a, b);
if (t == 2)
cout << "Masha\n";
else if (t == 1)
cout << "Stas\n";
else
cout << "Missing\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read(int& n) {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
n = x * f;
}
int outputarray[20];
inline void write(int k) {
int num = 0;
if (k < 0) putchar('-'), k = -k;
do {
outputarray[++num] = k % 10, k /= 10;
} while (k);
while (num) putchar(outputarray[num--] + '0');
puts("");
}
int a, b, n;
int f[35005][35];
inline int pw(int a, int b) {
int ans = 1;
for (int i = 1; i <= b; i++) ans *= a;
return ans;
}
inline bool pd(int a, int b) {
long long tmp = 1;
for (int i = 1; i <= b; i++) {
tmp *= a;
if (tmp >= n) return 1;
}
return 0;
}
int main() {
read(a), read(b), read(n);
if (pd(a, b)) {
puts("Masha");
return 0;
}
if (a == 1 && pw(2, b) >= n) {
puts("Missing");
return 0;
}
for (int i = 35000; i >= 1; i--)
for (int j = 30; j >= 1; j--) {
if (pd(i, j)) {
f[i][j] = 1;
continue;
}
if (i * i >= n && j == 1)
f[i][j] = !f[i + 1][j];
else
f[i][j] = (!f[i + 1][j]) | (!f[i][j + 1]);
}
if (f[a][b])
puts("Masha");
else
puts("Stas");
return 0;
}
|
#include <bits/stdc++.h>
int a, b, n;
bool licz(long long c, int d) {
long long wyn = 1;
for (int i = 0; i < d; i++) {
wyn *= c;
if (wyn >= (long long)(n)) return 0;
}
return 1;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
bool zm = 0;
while (licz(a + 1, b + 1)) {
a++;
b++;
}
int i = 1;
if (a != 1)
while (licz(a, b + i)) i++;
int p = 1, k = 1000000010;
while (p + 1 != k) {
if (licz((p + k) / 2, b))
p = (p + k) / 2;
else
k = (p + k) / 2;
}
if (a == 1 && (k - a) % 2 == 1)
printf("Missing\n");
else
printf("%s\n", ((k - a) % 2 == 1 && (i % 2) == 1) ? "Stas" : "Masha");
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
void __print(int first) { cerr << first; }
void __print(long first) { cerr << first; }
void __print(unsigned first) { cerr << first; }
void __print(unsigned long first) { cerr << first; }
void __print(unsigned long long first) { cerr << first; }
void __print(float first) { cerr << first; }
void __print(double first) { cerr << first; }
void __print(long double first) { cerr << first; }
void __print(char first) { cerr << '\'' << first << '\''; }
void __print(const char *first) { cerr << '\"' << first << '\"'; }
void __print(const string &first) { cerr << '\"' << first << '\"'; }
void __print(bool first) { cerr << (first ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &first) {
cerr << '{';
__print(first.first);
cerr << ',';
__print(first.second);
cerr << '}';
}
template <typename T>
void __print(const T &first) {
int f = 0;
cerr << '{';
for (auto &i : first) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
const int N = 80008;
int MX;
int dp[80000][32];
int go(int a, int b) {
if (b == 1 && a * a >= MX) {
return (MX - a) % 2 == 0 ? 1 : 2;
}
if (a == 1 && b > 30) return 0;
if (pow(a, b) + (1e-3) >= (double)MX) {
return 1;
}
int &r = dp[a][b];
if (r == -1) {
int win = 0;
int draw = 0;
if (go(a + 1, b) == 2) win = 1;
if (go(a + 1, b) == 0) draw = 1;
if (go(a, b + 1) == 2) win = 1;
if (go(a, b + 1) == 0) draw = 1;
if (win)
r = 1;
else if (draw)
r = 0;
else
r = 2;
}
return r;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
long long a, b;
cin >> a >> b >> MX;
memset(dp, -1, sizeof(dp));
if (go(a, b) == 1) {
cout << "Masha";
} else if (go(a, b) == 2)
cout << "Stas";
else
cout << "Missing";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[40400][40], n;
int dp(int a, int b) {
if (f[a][b] != -1) return f[a][b];
if (a == 1 && (1 << b) >= n) return 1;
if (a * a >= n && b == 1) return 2 - 2 * ((n - a) & 1);
if (pow(a, b) + 1e-6 >= n) return f[a][b] = 2;
return f[a][b] = 2 - min(dp(a + 1, b), dp(a, b + 1));
}
int a, b;
int main() {
cin >> a >> b >> n;
memset(f, -1, sizeof(f));
int ans = dp(a, b);
if (ans == 0)
cout << "Stas" << endl;
else if (ans == 1)
cout << "Missing" << endl;
else
cout << "Masha" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, int> dp;
long long n;
long long ksm(long long a, long long p) {
if (p == 0) {
return 1;
}
long long t = ksm(a, p / 2);
t = t * t;
if (p % 2) {
t = t * a;
}
return t;
}
int dfs(long long a, long long b) {
if (dp.count(make_pair(a, b))) {
return dp[make_pair(a, b)];
}
if (ksm(a, b) >= n) {
return dp[make_pair(a, b)] = 0;
}
if (a == 1 && ksm(2, b) >= n) {
return dp[make_pair(a, b)] = 1;
}
if (b == 1 && ksm(a, 2) >= n) {
if (a % 2 == n % 2) {
return dp[make_pair(a, b)] = 0;
} else {
return dp[make_pair(a, b)] = 2;
}
}
if (dfs(a + 1, b) == 2 || dfs(a, b + 1) == 2) {
return dp[make_pair(a, b)] = 0;
} else {
return dp[make_pair(a, b)] = 2;
}
}
long long a, b;
int main() {
scanf("%lld%lld%lld", &a, &b, &n);
int res = dfs(a, b);
if (res == 0) {
printf("Masha\n");
} else if (res == 1) {
printf("Missing\n");
} else {
printf("Stas\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long val[40010][32];
int dp[40010][32];
long long n;
int dfs(int a, int b) {
if (val[a][b] >= n) return 1;
if (a >= 40000) {
if ((n - a) % 2 == 0)
return 1;
else
return -1;
}
if (b >= 32) return 0;
if (dp[a][b] != -2) return dp[a][b];
if (dfs(a + 1, b) == -1 || dfs(a, b + 1) == -1)
dp[a][b] = 1;
else if (dfs(a + 1, b) == 0 || dfs(a, b + 1) == 0)
dp[a][b] = 0;
else
dp[a][b] = -1;
return dp[a][b];
}
int main() {
int a, b;
cin >> a >> b >> n;
for (int i = 1; i < 40010; i++)
for (int j = 1; j < 32; j++) {
if (j == 1)
val[i][j] = i;
else
val[i][j] = val[i][j - 1] * i;
if (val[i][j] >= n) val[i][j] = n;
dp[i][j] = -2;
}
long long now = 1;
for (int i = 0; i < b; i++) now *= a;
int flag = dfs(a, b);
if (flag == 1)
printf("Masha\n");
else if (flag == 0)
printf("Missing\n");
else
printf("Stas\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> M;
int a, b, n, sv;
int chk(int a, int b, int c) {
for (int i = 0, x = 1; i < b; i++) {
if (x >= (c + a - 1) / a)
return 1;
else
x *= a;
}
return 0;
}
int dfs(int a, int b, int n, int pl) {
if (M.count(pair<int, int>(a, b))) return M[pair<int, int>(a, b)];
int u = chk(a, b, n);
if (u == 1)
M[pair<int, int>(a, b)] = pl;
else if (b == 1 && a * a >= n)
M[pair<int, int>(a, b)] = pl ^ ((n - a) % 2);
else if (a == 1 && chk(a + 1, b, n) == 1)
M[pair<int, int>(a, b)] = pl + 2, sv = 1;
else if (dfs(a + 1, b, n, pl ^ 1) == pl || dfs(a, b + 1, n, pl ^ 1) == pl)
M[pair<int, int>(a, b)] = pl;
else
M[pair<int, int>(a, b)] = pl ^ 1;
return M[pair<int, int>(a, b)];
}
int main() {
scanf("%d%d%d", &a, &b, &n);
int x = dfs(a, b, n, 0);
if (sv == 1)
printf("Missing");
else
printf(x == 0 ? "Masha" : "Stas");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int isLoose(int a, int b, int n) {
long long p = 1;
while (b-- && p < n) {
p *= a;
}
return p >= n;
}
map<pair<int, int>, int> memo;
int solve(int a, int b, int n, int d) {
if (memo.count(make_pair(a, b))) return memo[make_pair(a, b)];
if (b > 1 && d > 600000 || (a == 1) && d > 9000 || b == 1 && d > 300000) {
return memo[make_pair(a, b)] = 2;
}
if (isLoose(a, b, n)) return memo[make_pair(a, b)] = 1;
int res1 = solve(a + 1, b, n, d + 1);
int res2 = solve(a, b + 1, n, d + 1);
if (res1 == 2 && res2 == 2) return memo[make_pair(a, b)] = 2;
if (res1 == 2) {
if (res2 != 0) return memo[make_pair(a, b)] = 2;
return memo[make_pair(a, b)] = !res2;
}
if (res2 == 2) {
if (res1 != 0) return memo[make_pair(a, b)] = 2;
return memo[make_pair(a, b)] = !res1;
}
return memo[make_pair(a, b)] = !(res1 && res2);
}
int main() {
int a, b, n;
cin >> a >> b >> n;
int result = solve(a, b, n, 0);
if (result == 0)
cout << "Stas\n";
else if (result == 1)
cout << "Masha\n";
else
cout << "Missing\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 35000;
const int M = 31;
int a, b, n, dp[N][M];
bool check(int a, int b, int n) {
long long ret = 1LL;
for (int i = 0; i < b; i++) {
ret = ret * a;
if (ret <= 0 || ret >= n) return true;
}
return false;
}
int dfs(int a, int b) {
if (dp[a][b] != -1) return dp[a][b];
if (check(a, b, n)) {
return dp[a][b] = 1;
}
int ret = 0;
ret |= !dfs(a + 1, b);
ret |= !dfs(a, b + 1);
return dp[a][b] = ret;
}
bool b_is_one(int a, int b = 1) {
int up = sqrt(n - 0.0000001);
int turn = 0;
while (a <= up) {
if (dp[a][b + 1] == 0) {
return turn == 0;
}
a++;
turn = 1 - turn;
}
int remain = n - 1 - a;
turn = (turn + remain) % 2;
return turn;
}
int a_is_one(int b, int a = 1) {
if (check(a, b, n))
return 0;
else {
int turn = 0;
for (; !check(2, b, n); b++) {
if (dp[a + 1][b] == 0) {
if (turn == 0)
return 1;
else
return -1;
}
turn = 1 - turn;
}
return 0;
}
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> a >> b >> n;
if (check(a, b, n)) {
puts("Masha");
return 0;
}
for (int i = 2; i < N; i++) {
for (int j = 2; j < M; j++) {
dp[i][j] = dfs(i, j);
}
}
if (a != 1 && b != 1) {
puts(dp[a][b] ? "Masha" : "Stas");
return 0;
}
if (a == 1 && b == 1) {
int c = a_is_one(b + 1), d = b_is_one(a + 1);
if (c < 0 || d == 0)
puts("Masha");
else if (c == 0)
puts("Missing");
else
puts("Stas");
} else if (b == 1) {
puts(b_is_one(a) ? "Masha" : "Stas");
} else if (a == 1) {
int c = a_is_one(b);
if (c == 0)
puts("Missing");
else if (c == 1)
puts("Masha");
else
puts("Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, bool> p;
int n;
bool count(pair<int, int> a) {
long long w = 1;
for (int i = 0; i < a.second; i++) {
w *= a.first;
if (w >= n) return false;
}
return true;
}
bool dfs(pair<int, int> a) {
if (p.find(a) != p.end()) {
return p[a];
}
if (a.second == 1) {
pair<int, int> w;
w = a;
w.second = 2;
if (!count(w)) {
p[a] = ((n - a.first) % 2 == 0);
return p[a];
}
}
if (!count(a)) {
p[a] = true;
return true;
}
pair<int, int> w1, w2;
w1 = a;
w2 = a;
w1.first++;
w2.second++;
p[a] = !(dfs(w1) && dfs(w2));
return p[a];
}
int main() {
int a, b;
scanf("%d%d%d", &a, &b, &n);
pair<int, int> A;
A.first = a;
A.second = b;
if (a == 1) {
pair<int, int> w;
w.first = 1;
w.second = b;
pair<int, int> w1 = w;
w1.first = 2;
for (; count(w1); w.second++, w1.second++) {
if (!dfs(w1)) {
if ((w.second - b) % 2 == 0)
cout << "Masha";
else
cout << "Stas";
return 0;
}
}
cout << "Missing";
return 0;
}
if (dfs(A))
cout << "Masha";
else
cout << "Stas";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void remax(T &A, T B) {
if (A < B) A = B;
}
template <class T>
inline void remin(T &A, T B) {
if (A > B) A = B;
}
string ToString(long long num) {
string ret;
bool neg = false;
if (num < 0) num *= ~0, neg = true;
do {
ret += ((num % 10) + '0');
num /= 10;
} while (num);
if (neg) ret += '-';
reverse(ret.begin(), ret.end());
return ret;
}
long long ToNumber(string s) {
long long r = 0, p = 1;
int e = (s[0] == '-');
for (int i = (int)s.size() - 1; i >= e; --i) r += (s[i] - '0') * p, p *= 10;
if (e) r *= ~0;
return r;
}
long long Gcd(long long a, long long b) {
while (a %= b ^= a ^= b ^= a)
;
return b;
}
long long Power(long long base, unsigned long long power) {
long long ret = 1;
while (power) {
if (power & 1) ret *= base;
power >>= 1;
base *= base;
}
return ret;
}
long long PowerMod(long long base, unsigned long long power, long long mod) {
if (!power) return 1 % mod;
if (power & 1) return (base * PowerMod(base, power - 1, mod)) % mod;
return PowerMod((base * base) % mod, power >> 1, mod);
}
int Log(long long num, long long base) {
int ret = 0;
while (num) {
++ret;
num /= base;
}
return ret;
}
int memo[10000 + 31622 + 1][29];
int n;
int f(int a, int b) {
int &ret = memo[a][b];
if (~ret) return ret;
long long apb = 1;
for (int i = 0; i < b && apb < n; ++i) apb *= a;
if (apb >= n)
ret = 1;
else if (b == 1 && (long long)a * a >= n)
ret = 1 - ((n - a) & 1);
else if (a == 1 && (1LL << b) >= n)
ret = 2;
else if (!f(a + 1, b) || !f(a, b + 1))
ret = 1;
else
ret = 0;
return ret;
}
inline void run() {
int a, b, ans;
scanf("%d%d%d", &a, &b, &n);
memset(memo, ~0, sizeof memo);
ans = f(a, b);
if (!ans)
puts("Stas");
else if (ans == 1)
puts("Masha");
else
puts("Missing");
}
int main() {
FILE *input = stdin;
FILE *output = stdout;
while (!feof(input)) {
run();
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long power(int a, int b) {
if (b == 0) {
return 1;
}
long long ret = power(a, b / 2);
if (b & 1) {
return ret * ret * a;
} else {
return ret * ret;
}
}
int DFS(int a, int b) {
if (a == 1 && 1 << b >= n) {
return 0;
}
if (power(a, b) >= n) {
return 2;
}
int t1 = DFS(a, b + 1);
if (t1 == 1) {
return 2;
}
int t2 = DFS(a + 1, b);
if (t2 == 1) {
return 2;
}
if (t1 == 0 || t2 == 0) {
return 0;
} else {
return 1;
}
}
int main() {
int a, b;
while (scanf("%d%d%lld", &a, &b, &n) != EOF) {
int t = DFS(a, b);
if (t == 2) {
puts("Masha");
} else if (t == 0) {
puts("Missing");
} else {
puts("Stas");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[100010][32];
long long n;
int Dp(int a, int b) {
if (f[a][b] > -1) return f[a][b];
if (pow(a / 1.0, b / 1.0) + 1e-10 >= n) return f[a][b] = 1;
if (b == 1 && a * a >= n) return f[a][b] = 1 - (n - a) % 2;
int u = Dp(a + 1, b), v = Dp(a, b + 1);
if (u * v > 0)
f[a][b] = 0;
else if ((u + v) == 1)
f[a][b] = 2;
else
f[a][b] = 1;
return f[a][b];
}
int main() {
int a, b;
for (int i = 0; i < 100010; i++)
for (int j = 0; j < 32; j++) f[i][j] = -1;
scanf("%d%d%d", &a, &b, &n);
if (a == 1) {
Dp(a + 1, b);
bool miss = 1;
int i;
for (i = b; pow((a + 1) / 1.0, i / 1.0) < n; i++)
if (f[2][i] == 0) {
miss = 0;
break;
}
if (miss)
puts("Missing\n");
else {
f[1][i] = 1;
f[1][b] = 1 - (i - b) % 2;
puts(f[1][b] ? "Masha\n" : "Stas\n");
}
} else {
if (Dp(a, b))
puts("Masha\n");
else
puts("Stas\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool checkmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline bool checkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
enum { MISS, LOST, WIN };
long long n;
long long power(int a, int b) {
if (b == 0) {
return 1;
}
long long ret = power(a, b / 2);
if (b & 1) {
return ret * ret * a;
} else {
return ret * ret;
}
}
int DFS(int a, int b) {
if (a == 1 && 1 << b >= n) {
return MISS;
}
if (power(a, b) >= n) {
return WIN;
}
int t1 = DFS(a, b + 1);
if (t1 == LOST) {
return WIN;
}
int t2 = DFS(a + 1, b);
if (t2 == LOST) {
return WIN;
}
if (t1 == MISS || t2 == MISS) {
return MISS;
} else {
return LOST;
}
}
int main() {
int a, b;
while (scanf("%d%d%lld", &a, &b, &n) != EOF) {
int t = DFS(a, b);
if (t == WIN) {
puts("Masha");
} else if (t == MISS) {
puts("Missing");
} else {
puts("Stas");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
int dp[N][40], a, b, n;
long long qpow(int a, int b) {
long long ret = 1;
for (int i = (0); i < (b); ++i) ret *= a;
return ret;
}
int gao(int a, int b) {
int &ret = dp[a][b];
if (~ret)
return ret;
else
ret = 0;
if (qpow(a, b) >= n) return ret = 2;
if (a <= b) {
if (gao(a + 1, b) == 0) return ret = 2;
} else {
if (gao(a, b + 1) == 0) return ret = 2;
}
if (a <= b) {
if (a == 1 && qpow(a + 1, b) >= n) return ret = 1;
return ret = 2 - gao(a, b + 1);
} else {
if (b == 1 && qpow(a, b + 1) >= n) return ret = 2 * ((n - a) % 2 == 0);
return ret = 2 - gao(a + 1, b);
}
}
int main() {
while (~scanf("%d%d%d", &a, &b, &n)) {
memset(dp, -1, sizeof(dp));
int ret = gao(a, b);
puts(ret == 1 ? "Missing" : ret ? "Masha" : "Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643l;
void solve();
int main() {
solve();
return 0;
}
long long n;
long long st(long long a, long long b) {
long long res = 1;
for (long long i = 0; i < b; i++) {
if (res >= n) return 1;
res *= a;
}
if (res < n) return 0;
return 1;
}
long long qwerty(long long s, long long l, long long r) {
if (l == 1 && st(1, s)) return -1;
if (l + 1 == r) return l;
if (st((l + r) / 2, s))
return qwerty(s, l, (l + r) / 2);
else
return qwerty(s, (l + r) / 2, r);
}
vector<vector<long long> > x(41);
long long mas[50];
long long cnt(long long a, long long b) {
if (a > mas[b]) return 2;
if (a > 1 && b > 1 && x[b][a] != -1) return x[b][a];
if (b == 1 && a != 1) {
if (a <= mas[2]) {
if (cnt(a + 1, b) == 1 || cnt(a, b + 1) == 1) return x[b][a] = 2;
return x[b][a] = 1;
} else {
if ((n - a) % 2) return 1;
return 2;
}
}
if (a == 1) {
if (b >= 30) {
return 0;
}
long long z = cnt(a, b + 1), t = cnt(a + 1, b);
if (t == 1 || z == 1) return x[b][a] = 2;
if (z == 0) return x[b][a] = 0;
if (z == 2) return x[b][a] = 1;
}
long long z = cnt(a, b + 1), t = cnt(a + 1, b);
if (z == 1 || t == 1) return x[b][a] = 2;
return x[b][a] = 1;
}
void solve() {
long long a, b;
cin >> a >> b;
cin >> n;
for (long long i = 1; i <= 30; i++) mas[i] = qwerty(i, 1, n);
x[1].resize(mas[2] + 2);
for (long long i = 2; i <= 30; i++) x[i].resize(mas[i] + 2);
for (long long i = 0; i <= 30; i++)
for (long long j = 0; j < x[i].size(); j++) x[i][j] = -1;
long long f = cnt(a, b);
if (f == 2)
cout << "Masha";
else if (f == 0)
cout << "Missing";
else if (f == 1)
cout << "Stas";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream& operator<<(ostream& os, const pair<A, B>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename C>
ostream& operator<<(ostream& os, const vector<C>& v) {
for (__typeof((v).begin()) __it = (v).begin(); __it != (v).end(); __it++)
os << *(__it) << ' ';
return os;
}
const int inf = 0x3f3f3f3f;
const double eps = 1e-5;
const int maxa = 100500;
const int maxb = 33;
int dp[maxa][maxb];
int n;
int pw(long long val, int p) {
long long res = 1;
for (; p; p >>= 1) {
if (val >= n) return inf;
if (p & 1) {
res *= val;
if (res >= n) return inf;
}
val *= val;
}
return int(res);
}
int dfs(int a, int b) {
if (pw(a, b) >= n) return 3;
if (b > 30) return 2;
if (a >= maxa) {
if ((n - a) % 2)
return 1;
else
return 3;
}
if (dp[a][b]) return dp[a][b];
int ap = 4 - dfs(a + 1, b);
int bp = 4 - dfs(a, b + 1);
return dp[a][b] = max(ap, bp);
}
int main() {
int a, b;
cin >> a >> b >> n;
int res = dfs(a, b);
if (res == 3)
puts("Masha");
else if (res == 1)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
map<pair<long long, long long>, int> mp;
long long pw(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) {
res *= x;
}
y >>= 1;
x *= x;
}
return res;
}
int work(long long x, long long y) {
pair<long long, long long> p = make_pair(x, y);
if (mp.count(p)) {
return mp[p];
}
if (pw(x, y) >= n) {
mp[p] = 2;
return mp[p];
}
if (y >= 31) {
mp[p] = 1;
return mp[p];
}
if (y == 1 && x * x >= n) {
mp[p] = (n - x + 1) % 2 * 2;
} else {
mp[p] = 2 - min(work(x + 1, y), work(x, y + 1));
}
return mp[p];
}
int main() {
scanf("%lld%lld%lld", &a, &b, &n);
int x = work(a, b);
if (x == 0) {
puts("Stas");
} else if (x == 1) {
puts("Missing");
} else {
puts("Masha");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, long long> dp;
long long A, B, N, win = -1;
bool larger_n(long long x, long long y) {
long long res = 1;
while (y--) {
res *= x;
if (res >= N) return 1;
}
return 0;
}
long long dfs(long long a, long long b) {
if (dp[make_pair(a, b)])
return dp[make_pair(a, b)];
else if (larger_n(a, b))
return dp[make_pair(a, b)] = 1;
else if (larger_n(a + 1, b) && larger_n(a, b + 1))
return dp[make_pair(a, b)] = 1;
else {
if (a > 100000) {
if ((N - a + 1) % 2 == 1)
return dp[make_pair(a, b)] = 2;
else
return dp[make_pair(a, b)] = 1;
}
if (dfs(a + 1, b) == 1 && larger_n(a + 1, b) == 0)
return dp[make_pair(a, b)] = 2;
if (dfs(a, b + 1) == 1 && larger_n(a, b + 1) == 0)
return dp[make_pair(a, b)] = 2;
return dp[make_pair(a, b)] = 1;
}
}
signed main() {
cin >> A >> B >> N;
if (A == 1) {
if (larger_n(A + 1, B)) {
puts("Missing");
return 0;
}
}
if (B == 1) {
if (A * A >= N) {
long long now = N - A + 1;
if (now % 2 == 0)
puts("Stas");
else
puts("Masha");
return 0;
}
}
win = dfs(A, B);
if (win == 2)
puts("Masha");
else
puts("Stas");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void remax(T &A, T B) {
if (A < B) A = B;
}
template <class T>
inline void remin(T &A, T B) {
if (A > B) A = B;
}
string ToString(long long num) {
string ret;
bool neg = false;
if (num < 0) num *= ~0, neg = true;
do {
ret += ((num % 10) + '0');
num /= 10;
} while (num);
if (neg) ret += '-';
reverse(ret.begin(), ret.end());
return ret;
}
long long ToNumber(string s) {
long long r = 0, p = 1;
int e = (s[0] == '-');
for (int i = (int)s.size() - 1; i >= e; --i) r += (s[i] - '0') * p, p *= 10;
if (e) r *= ~0;
return r;
}
long long Gcd(long long a, long long b) {
while (a %= b ^= a ^= b ^= a)
;
return b;
}
long long Power(long long base, unsigned long long power) {
long long ret = 1;
while (power) {
if (power & 1) ret *= base;
power >>= 1;
base *= base;
}
return ret;
}
long long PowerMod(long long base, unsigned long long power, long long mod) {
if (!power) return 1 % mod;
if (power & 1) return (base * PowerMod(base, power - 1, mod)) % mod;
return PowerMod((base * base) % mod, power >> 1, mod);
}
int Log(long long num, long long base) {
int ret = 0;
while (num) {
++ret;
num /= base;
}
return ret;
}
int memo[10000 + 31620][5];
int n;
int f(int a, int b) {
int &ret = memo[a][b];
if (~ret) return ret;
long long apb = 1;
for (int i = 0; i < b && apb < n; ++i) apb *= a;
if (apb >= n)
ret = 1;
else if (b == 1 && (long long)a * a >= n)
ret = 1 - ((n - a) & 1);
else if (a == 1 && (1LL << b) >= n)
ret = 2;
else if (!f(a + 1, b) || !f(a, b + 1))
ret = 1;
else
ret = 0;
return ret;
}
inline void run() {
int a, b, ans;
scanf("%d%d%d", &a, &b, &n);
memset(memo, ~0, sizeof memo);
ans = f(a, b);
if (!ans)
puts("Stas");
else if (ans == 1)
puts("Masha");
else
puts("Missing");
}
int main() {
FILE *input = stdin;
FILE *output = stdout;
while (!feof(input)) {
run();
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n, maxB[100010], a1;
bool spr[100010][50];
long long p(int a, int b) {
long long res = 1;
for (int i = 0; i < b; i++) {
res *= a;
if (res >= n) break;
}
return res;
}
void dfs(int x, int y) {
if (x == a1) {
spr[x - a][y] = 1;
return;
}
if (y == maxB[x - a]) {
spr[x - a][y] = 1;
return;
}
dfs(x + 1, y);
dfs(x, y + 1);
if (!spr[x + 1 - a][y] || !spr[x - a][y + 1]) spr[x - a][y] = 1;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
for (a1 = max(a, 2); true; a1++) {
for (int i = max(b, 2); true; i++)
if (p(a1, i) >= n) {
maxB[a1 - a] = i;
break;
}
if (maxB[a1 - a] == max(b, 2)) break;
}
a1 = min(a1, n);
for (int i = max(a, 2); i <= a1; i++) spr[i - a][maxB[i - a]] = 1;
for (int i = a1; i >= max(a, 2); i--)
for (int j = maxB[i - a] - 1; j >= max(b, 2); j--)
if ((p(i, j + 1) < n && !spr[i - a][j + 1]) ||
(p(i + 1, j) < n && !spr[i - a + 1][j]))
spr[i - a][j] = 1;
if (!spr[0][b]) {
if ((p(a, b + 1) < n && !spr[0][b + 1] && a != 1) ||
(p(a + 1, b) < n && !spr[1][b] && b != 1)) {
printf("Masha\n");
return 0;
}
if (b == 1) {
bool ok = 1;
int pom = a + 1;
while (ok) {
if (pom >= n) {
ok = 0;
break;
}
if (pom >= a1) break;
if (p(pom, 2) < n && !spr[pom - a][2]) {
ok = 0;
break;
}
if (pom + 1 >= n) {
printf("Masha\n");
return 0;
}
pom++;
if (p(pom, 2) < n && !spr[pom - a][2]) {
printf("Masha\n");
return 0;
}
pom++;
}
if (ok) {
if (!((n - a) % 2)) {
printf("Masha\n");
return 0;
}
}
}
if (a == 1) {
int pom = b + 1;
while (true) {
if (p(2, pom) >= n) break;
if (p(2, pom) < n && !spr[1][pom]) {
printf("Stas\n");
return 0;
}
pom++;
if (p(2, pom) < n && !spr[1][pom]) {
printf("Masha\n");
return 0;
}
pom++;
}
printf("Missing\n");
return 0;
}
printf("Stas\n");
} else
printf("Masha\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[40005][45], a, b, n;
int calc(int a, int b) {
if (~dp[a][b]) return dp[a][b];
if (a == 1 && (1 << b) >= n) return 1;
if (a * a >= n && b == 1) return 2 - 2 * ((n - a) & 1);
if (pow(a, b) + 1e-6 >= n) return dp[a][b] = 2;
return dp[a][b] = 2 - min(calc(a, b + 1), calc(a + 1, b));
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d%d%d", &a, &b, &n);
int res = calc(a, b);
puts(res == 1 ? "Missing" : (res == 2 ? "Masha" : "Stas"));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e12;
const long long mod = 1e9 + 7;
void faster() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const long long MAXN = 1000 * 1000 + 10;
const long long N = 1000 * 100 + 10;
long long n;
long long dp[N][50];
long long find_pow(long long b, long long a) {
long long k = 1;
for (int i = 0; i < a; i++) k *= b;
return k;
}
bool r = 1;
long long solve(long long a, long long b, int t) {
if (find_pow(a, b) >= n) {
return dp[a][b] = 1;
}
if (dp[a][b] != -1) return dp[a][b];
long long k = max(1 - solve(a + 1, b, 1 - t), 1 - solve(a, b + 1, 1 - t));
return dp[a][b] = k;
}
int main() {
faster();
long long a, b;
cin >> a >> b >> n;
if (a == 1 && find_pow(a + 1, b) >= n) {
cout << "Missing\n";
return 0;
}
for (int i = 1; i <= 100000; i++) {
for (int j = 1; j <= 40; j++) {
if (find_pow(i, j) >= n) break;
dp[i][j] = -1;
}
}
if (solve(a, b, 0) == 1) {
cout << "Masha\n";
} else
cout << "Stas\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
map<pair<long long, long long>, int> dp;
long long ksm(long long x, long long y) {
if (y == 0) return 1;
long long t = ksm(x, y / 2);
if (t > n) return t;
t = t * t;
if (y & 1) t = t * x;
return t;
}
int solve(long long x, long long y) {
if (dp.count(make_pair(x, y))) return dp[make_pair(x, y)];
if (ksm(x, y) >= n) return dp[make_pair(x, y)] = 2;
if (y > 31) return 1;
if (y == 1 && x * x >= n) return dp[make_pair(x, y)] = (n - x + 1) % 2 * 2;
return dp[make_pair(x, y)] = 2 - min(solve(x + 1, y), solve(x, y + 1));
}
int main() {
cin >> a >> b >> n;
int p = solve(a, b);
if (p == 0) {
puts("Stas");
} else if (p == 2) {
puts("Masha");
} else {
puts("Missing");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
bool h[100100][40], u[100100][40];
bool big(long long a, long long b) {
long long ans = 1;
for (long long i = 0; i < b; ++i) {
ans *= a;
if (ans >= n) return 1;
}
return 0;
}
bool win(long long a, long long b) {
if (b == 1 && a > 100100 - 10) return (n - a) % 2 == 0;
if (u[a][b]) return h[a][b];
u[a][b] = 1;
if (big(a, b)) return h[a][b] = 1;
if (!win(a + 1, b) || !win(a, b + 1)) return h[a][b] = 1;
return h[a][b] = 0;
}
bool miss(long long a, long long b) {
for (long long i = b; i < 40; ++i)
if (!win(a + 1, i)) {
if ((i - b) % 2 == 0)
cout << "Masha";
else
cout << "Stas";
return 0;
}
cout << "Missing";
return 1;
}
int main() {
long long a, b;
cin >> a >> b >> n;
if ((a > 1))
if (win(a, b))
cout << "Masha";
else
cout << "Stas";
if (a == 1) miss(a, b);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10010, M = 40, WIN = 1, LOSE = 2, TIE = 0;
int f[N * 5][M * 2], vis[N * 5][M * 2];
int limit, n, m;
long long pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
if (ans > limit || ans < 0) return limit + 1;
a = a * a;
b >>= 1;
}
return ans;
}
int dp(int x, int y) {
if (vis[x][y]) return f[x][y];
vis[x][y] = 1;
int &r = f[x][y];
if (x == 1 && pow(2, y) >= limit) return r = TIE;
if (x * x >= limit && y == 1) return r = limit - x & 1 ? LOSE : WIN;
if (pow(x, y) >= limit) return r = WIN;
int r1 = dp(x + 1, y), r2 = dp(x, y + 1);
if (r1 == LOSE || r2 == LOSE) return r = WIN;
if (r1 == TIE || r2 == TIE) return r = TIE;
return r = LOSE;
}
int main() {
scanf("%d %d %d", &n, &m, &limit);
int ans = dp(n, m);
if (ans == LOSE)
puts("Stas");
else if (ans == WIN)
puts("Masha");
else
puts("Missing");
}
|
#include <bits/stdc++.h>
int a, b, c, d, e, g, h, i, j, ok;
int F[50005][105], G[50005][105];
long long Mi(int x, int y) {
long long ii;
if (y == 0) return 1LL;
if (y == 1) return (long long)x;
ii = Mi(x, y >> 1);
ii = ii * ii;
if (ii >= c) {
ok = 0;
}
if (y & 1) ii = ii * x;
if (ii >= c) {
ok = 0;
}
return ii;
}
int DP(int x, int y) {
int ii, jj, kk;
int u, v;
e++;
if (x == 1 && 1LL << y >= c) return 0;
if (y == 1 && x * x >= c) {
if ((c - x) % 2 == 1) return -1;
return 1;
}
if (G[x][y] != 0) return F[x][y];
ok = 1;
if (Mi(x, y) >= c || ok == 0) {
G[x][y] = 1;
F[x][y] = 1;
return 1;
}
u = DP(x + 1, y);
v = DP(x, y + 1);
if (u == 1 && v == 1) {
G[x][y] = 1;
F[x][y] = -1;
return -1;
}
if ((u == 1 && v == 0) || (u == 0 && v == 1) || (u == 0 && v == 0))
return 0;
else {
G[x][y] = 1;
F[x][y] = 1;
return 1;
}
}
int main() {
scanf("%d%d%d", &a, &b, &c);
if ((a != 1 || 1LL << b < c) && (b != 1 || a * a < c)) {
if (DP(a, b) == 1) {
printf("Masha\n");
return 0;
} else {
printf("Stas\n");
return 0;
}
}
if (a == 1) {
if (1LL << b >= c) {
printf("Missing\n");
return 0;
}
}
if (b == 1) {
if ((c - a) % 2 == 1) {
printf("Stas\n");
return 0;
} else {
printf("Masha\n");
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e4 + 10, M = 32, INF = 1e9 + 10;
int a, b, n;
int dp[N][M];
long long mypw(long long a, int b) {
double ans = pow(a, b);
if (ans > INF) {
return INF;
}
long long ret = 1;
while (b--) ret = ret * a;
return ret;
}
int check(int a, int b) {
if (a < N && b < M && dp[a][b] != -1) return dp[a][b];
if (a == 1 && mypw(a + 1, b) >= n) {
return 2;
}
if (b == 1 && a >= N && mypw(a, b + 1) >= n) {
return !((n - a) & 1);
}
if (mypw(a, b) >= n) return dp[a][b] = 1;
int a1 = check(a + 1, b);
int a2 = check(a, b + 1);
if (a1 == 0 || a2 == 0) return dp[a][b] = 1;
if (a1 == 2 || a2 == 2) return dp[a][b] = 2;
return dp[a][b] = 0;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
memset(dp, -1, sizeof(dp));
int t = check(a, b);
if (t == 1)
puts("Masha");
else if (t == 0)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 35000;
const int M = 31;
int a, b, n, dp[N][M];
bool check(int a, int b, int n) {
long long ret = 1LL;
for (int i = 0; i < b; i++) {
ret = ret * a;
if (ret <= 0 || ret >= n) return true;
}
return false;
}
int dfs(int a, int b) {
if (dp[a][b] != -1) return dp[a][b];
if (check(a, b, n)) {
return dp[a][b] = 1;
}
int ret = 0;
ret |= !dfs(a + 1, b);
ret |= !dfs(a, b + 1);
return dp[a][b] = ret;
}
bool b_is_one(int a, int b = 1) {
int up = sqrt(n - 0.0000001);
int turn = 0;
while (a <= up) {
if (dp[a][b + 1] == 0) {
return turn == 0;
}
a++;
turn = 1 - turn;
}
int remain = n - 1 - a;
turn = (turn + remain) % 2;
return turn;
}
int a_is_one(int b, int a = 1) {
if (n <= 1)
return 0;
else {
int turn = 0;
for (; !check(2, b, n); b++) {
if (dp[a + 1][b] == 0) {
if (turn == 0)
return 1;
else
return -1;
}
turn = 1 - turn;
}
return 0;
}
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> a >> b >> n;
if (check(a, b, n)) {
puts("Masha");
return 0;
}
for (int i = 2; i < N; i++) {
for (int j = 2; j < M; j++) {
dp[i][j] = dfs(i, j);
}
}
if (a != 1 && b != 1) {
puts(dp[a][b] ? "Masha" : "Stas");
return 0;
}
if (a == 1 && b == 1) {
int c = a_is_one(b + 1), d = b_is_one(a + 1);
if (c < 0 || d == 0)
puts("Masha");
else if (c == 0)
puts("Missing");
else
puts("Stas");
} else if (b == 1) {
puts(b_is_one(a) ? "Masha" : "Stas");
} else if (a == 1) {
int c = a_is_one(b);
if (c == 0)
puts("Missing");
else if (c == 1)
puts("Masha");
else
puts("Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double powld(long double base, long double exp) {
long double result = base;
while (exp > 1) {
result *= base;
exp--;
}
return result;
}
vector<vector<int> > DP;
int juego(int a, int b) {
if (DP[a][b] != -1) return DP[a][b];
int opt1 = juego(a + 1, b);
int opt2 = juego(a, b + 1);
if (opt1 == 0 || opt2 == 0)
return DP[a][b] = 1;
else if (opt1 == 2 || opt2 == 2)
return DP[a][b] = 2;
return DP[a][b] = 0;
}
int main() {
int a, b, n;
scanf("%d %d %d", &a, &b, &n);
int A = (int)ceil(sqrt(1e9)) + 1;
int B = 31;
DP = vector<vector<int> >(A, vector<int>(B, -1));
for (int i = 1; i < (int)A; ++i)
for (int j = 1; j < (int)B; ++j)
if (powld(i, j) >= n) DP[i][j] = 1;
for (int j = 1; j < (int)B; ++j)
if (powld(2, j) >= n) DP[1][j] = 2;
for (int i = 1; i < (int)A; ++i)
if (i < n && powld(i, 2) >= n) {
if ((n - i) % 2 == 0)
DP[i][1] = 1;
else
DP[i][1] = 0;
}
int result = juego(a, b);
if (result == 0) printf("Stas\n");
if (result == 1) printf("Masha\n");
if (result == 2) printf("Missing\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long exp(long long a, int p) {
if (p == 0) return 1;
long long ans = exp(a, p / 2);
ans = ans * ans;
if (p % 2) ans = ans * a;
return ans;
}
long long tar;
map<pair<int, int>, int> dp;
int type(int box, int item) {
pair<int, int> pr(box, item);
if (dp.count(pr)) return dp[pr];
long long ways = exp(box, item);
if (ways >= tar) return dp[pr] = 1;
if (box == 1 && item > 32) return dp[pr] = -1;
if (item == 1 && box * box > tar) {
int rem = tar - box;
return dp[pr] = 1 - rem % 2;
}
int t1 = type(box + 1, item);
int t2 = type(box, item + 1);
if (t1 == 0 || t2 == 0) return dp[pr] = 1;
if (t1 == -1 || t2 == -1) return dp[pr] = -1;
return dp[pr] = 0;
}
int main() {
int box, item;
cin >> box >> item >> tar;
int ans = type(box, item);
if (ans == 1) cout << "Masha" << endl;
if (ans == 0) cout << "Stas" << endl;
if (ans == -1) cout << "Missing" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
const int MAXA = 31700;
const int MAXB = 31;
long long pow(int a, int b) {
if (b == 0) return 1;
long long ans = pow(a, b / 2);
if (b % 2 == 0)
return ans * ans;
else
return ans * ans * a;
}
int DFS(int a, int b) {
if (a == 1 && 1 << b >= n) {
return 0;
}
if (pow(a, b) >= n) {
return 2;
}
int t1 = DFS(a, b + 1);
if (t1 == 1) {
return 2;
}
int t2 = DFS(a + 1, b);
if (t2 == 1) {
return 2;
}
if (t1 == 0 || t2 == 0) {
return 0;
} else {
return 1;
}
}
int main() {
int a, b;
scanf("%d%d%I64d", &a, &b, &n);
int t = DFS(a, b);
if (t == 2)
printf("Masha\n");
else if (t == 1)
printf("Stas\n");
else
printf("Missing\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long llINF = 1e18;
const int MAXN = 4e4 + 5;
const int MAXM = 35;
const long double eps = 1e-10;
int a, b, n;
int f[MAXN][MAXM], vis[MAXN][MAXM];
bool check(long double x, long double y) {
return log2(n) - y * log2(x) >= eps;
}
int dfs(int x, int y) {
if (vis[x][y]) return f[x][y];
vis[x][y] = 1;
if (x == 1) {
if (!check(2, y)) return f[x][y] = -1;
if (!dfs(2, y)) return f[x][y] = 1;
return f[x][y] = dfs(x, y + 1) ^ 1;
}
if (y == 1) {
if (!check(x, 2)) return !((n - x) & 1);
}
if (check(x + 1, y) && !dfs(x + 1, y)) return f[x][y] = 1;
if (check(x, y + 1) && !dfs(x, y + 1)) return f[x][y] = 1;
return f[x][y] = 0;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
int ans = dfs(a, b);
if (ans == 1)
puts("Masha");
else if (ans == 0)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
int bs(int a, int b) {
long long sum = 1;
for (int i = 1; i <= b; ++i) {
sum *= a;
if (sum >= n) return 1;
}
return 0;
}
int bbbaboven(int b) {
long long sum = 1;
for (int i = 1; i <= b; ++i) {
sum *= 2;
if (sum >= n) return 1;
}
return 0;
}
int deal(int a, int b) {
if (bs(a, b)) return 1;
if (a == 1) {
int k = deal(a + 1, b);
if (k == -1)
return 1;
else {
if (bbbaboven(b))
return 0;
else
return -deal(a, b + 1);
}
}
if (b == 1) {
int k = deal(a, b + 1);
if (k == -1)
return 1;
else {
if (a * a >= n) {
int k = n - a;
if (k % 2 == 0)
return 1;
else
return -1;
} else
return -deal(a + 1, b);
}
}
int k1 = deal(a, b + 1);
int k2 = deal(a + 1, b);
if (k1 == -1 || k2 == -1) return 1;
if (k1 == 1 && k2 == 1) return -1;
return 0;
}
int main() {
int a, b;
cin >> a >> b >> n;
int k = deal(a, b);
if (k == 1)
cout << "Masha";
else if (k == 0)
cout << "Missing";
else
cout << "Stas";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool **dyn;
long long a, b;
long long n;
bool isp(long long a1, long long b1) {
long long ans = 1;
for (long long i = 0; i < b1; i++) {
ans *= a1;
if (ans >= n) return true;
}
return false;
}
int main() {
cin >> a >> b >> n;
long long a1 = a, b1 = b;
a = 500000;
b = 63;
dyn = new bool *[a + 2];
for (long long i = 0; i <= a + 1; i++) {
dyn[i] = new bool[b + 2];
}
long long *last = new long long[a + 1];
for (long long i = 1; i <= a + 1; i++) {
bool flag = false;
for (long long j = 1; j <= b + 1; j++) {
dyn[i][j] = 0;
if (isp(i, j)) {
if (!flag) {
last[i] = j;
flag = true;
}
dyn[i][j] = 1;
}
}
}
for (long long i = a; i >= 2; i--) {
for (long long j = last[i] - 1; j >= 1; j--) {
if ((!dyn[i][j + 1]) || (!dyn[i + 1][j])) {
dyn[i][j] = 1;
} else {
dyn[i][j] = 0;
}
}
}
if (a1 == 1) {
if (!dyn[a1 + 1][b1]) {
cout << "Masha" << endl;
} else {
for (long long i = b1 + 1; i <= b; i++) {
if (dyn[2][i] == 0) {
if ((i - b1) % 2 == 1) {
cout << "Stas" << endl;
} else {
cout << "Masha" << endl;
}
return 0;
}
}
cout << "Missing" << endl;
}
return 0;
}
if (dyn[a1][b1] == 1) {
cout << "Masha" << endl;
} else {
cout << "Stas" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e4 + 10, M = 32, INF = 1e9 + 10;
int a, b, n;
int dp[N][M];
long long mypw(long long a, int b) {
double ans = pow(a, b);
if (ans > INF) {
return INF;
}
long long ret = 1;
while (b--) ret = ret * a;
return ret;
}
int check(int a, int b) {
if (a < N && b < M && dp[a][b] != -1) return dp[a][b];
if (a == 1 && mypw(a + 1, b) >= n) {
return 2;
}
if (b == 1 && mypw(a, b + 1) >= n) {
return !((n - a) & 1);
}
if (mypw(a, b) >= n) return dp[a][b] = 1;
int a1 = check(a + 1, b);
int a2 = check(a, b + 1);
if (a1 == 0 || a2 == 0) return dp[a][b] = 1;
if (a1 == 2 || a2 == 2) return dp[a][b] = 2;
return dp[a][b] = 0;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
memset(dp, -1, sizeof(dp));
int t = check(a, b);
if (t == 1)
puts("Masha");
else if (t == 0)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 7;
struct Mat {
int buf[16][16];
Mat(int _ = 0) {
for (int i = 0; i < 16; i++)
for (int j = 0; j < 16; j++) buf[i][j] = (i == j) ? _ : 0;
}
const int* operator[](int x) const { return buf[x]; }
int* operator[](int x) { return buf[x]; }
Mat operator*(const Mat& r) const {
Mat ret;
for (int i = 0; i < 16; i++)
for (int j = 0; j < 16; j++)
for (int k = 0; k < 16; k++) ret[i][k] += buf[i][j] * r[j][k];
return ret;
}
} B;
int num;
void Brute() {
int x[4];
for (int i = 0; i < 256; i++) {
int tmp = i;
for (int j = 0; j < 4; j++) {
x[j] = tmp & 3;
tmp = tmp >> 2;
}
if (x[0] != x[1] && x[0] != x[2] && x[1] != x[3] && x[2] != x[3]) {
B[x[0] * 4 + x[1]][x[2] * 4 + x[3]]++;
}
}
}
void Bruteans() {
int x[4];
for (int i = 0; i < 256; i++) {
int tmp = i;
for (int j = 0; j < 4; j++) {
x[j] = tmp & 3;
tmp = tmp >> 2;
}
if (x[0] != x[1] && x[0] != x[2] && x[1] != x[3] && x[2] != x[3]) {
num += B[x[0] * 4 + x[1]][x[2] * 4 + x[3]];
}
}
}
int main1(void) {
Brute();
B = B * B * B * B * B * B;
Bruteans();
cout << num << endl;
return 0;
}
string str[3] = {"Stas", "Missing", "Masha"};
int f[31700][32], a, b, n;
int dp(int a, int b) {
if (f[a][b] != -1) return f[a][b];
if (a == 1 && 1 << b >= n) return 1;
if (b == 1 && a * a >= n) return n - a & 1 ? 0 : 2;
if (pow(a, b) + 1e-6 > n) return f[a][b] = 2;
return f[a][b] = 2 - min(dp(a + 1, b), dp(a, b + 1));
}
int main() {
memset(f, -1, sizeof(f));
cin >> a >> b >> n;
cout << str[dp(a, b)] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> x, y;
bool f[50000][200];
int g[50000][200];
long long n;
long long grade(int a, int b) {
long long res = 1, mul = a;
while (b != 0) {
if (b % 2) res *= mul;
mul *= mul;
b /= 2;
}
return res;
}
void tryGo(int xCur, int yCur) {
if (f[xCur][yCur]) return;
long long res = grade(xCur, yCur);
if (xCur == 40000) {
if ((n - xCur) % 2 == 1)
g[xCur][yCur] = -1;
else
g[xCur][yCur] = 1;
f[xCur][yCur] = true;
return;
}
if (res >= n) {
g[xCur][yCur] = 1;
f[xCur][yCur] = true;
return;
}
f[xCur][yCur] = true;
x.push_back(xCur);
y.push_back(yCur);
}
void bfs(int xs, int ys) {
int xCur, yCur, i;
x.push_back(xs);
y.push_back(ys);
int cur = 0;
while (cur < x.size()) {
xCur = x[cur];
yCur = y[cur];
tryGo(xCur + 1, yCur);
if (yCur < 50) tryGo(xCur, yCur + 1);
cur++;
}
for (i = x.size() - 1; i > -1; i--) {
if (g[x[i]][y[i]] == 0) {
if (g[x[i] + 1][y[i]] == -1 || g[x[i]][y[i] + 1] == -1)
g[x[i]][y[i]] = 1;
else {
if (g[x[i] + 1][y[i]] == 0 || g[x[i]][y[i] + 1] == 0)
g[x[i]][y[i]] = 0;
else
g[x[i]][y[i]] = -1;
}
}
}
if (g[xs][ys] == 1) {
printf("Masha");
return;
}
if (g[xs][ys] == 0)
printf("Missing");
else
printf("Stas");
}
int main() {
int xs, ys;
scanf("%d%d%I64d", &xs, &ys, &n);
bfs(xs, ys);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50010;
const long long inf = 1e18;
int vis[maxn][35];
long long my_pow(long long a, long long b) {
long long ans = 1;
for (int i = 0; i < b; i++) {
ans *= a;
}
return ans;
}
int dfs(long long a, long long b, long long n, int p) {
if (vis[a][b]) return vis[a][b];
if (a == 1) {
if (my_pow(2, b) >= n) return vis[a][b] = 3;
if (dfs(a + 1, b, n, 3 - p) == 3 - p) return vis[a][b] = 3 - p;
return vis[a][b] = dfs(a, b + 1, n, 3 - p);
}
if (b == 1 && my_pow(a, b + 1) >= n) {
return vis[a][b] = (n - a + p) % 2 + 1;
}
if (my_pow(a, b + 1) < n && dfs(a, b + 1, n, 3 - p) == 3 - p) {
return vis[a][b] = 3 - p;
}
if (my_pow(a + 1, b) < n && dfs(a + 1, b, n, 3 - p) == 3 - p) {
return vis[a][b] = 3 - p;
}
return vis[a][b] = p;
}
int main() {
ios::sync_with_stdio(false);
long long a, b, n, ans;
cin >> a >> b >> n;
ans = dfs(a, b, n, 1);
if (ans == 1) {
cout << "Stas\n";
} else if (ans == 2) {
cout << "Masha\n";
} else {
cout << "Missing\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
int dp[maxn][40];
long long pw[maxn][40];
long long n;
int dfs(int a, int b) {
if (dp[a][b]) return dp[a][b];
if (pw[a][b] >= n) return dp[a][b] = 1;
if (pw[a][2] >= n) {
if ((n - a) % 2 == 0)
return dp[a][b] = 1;
else
return dp[a][b] = 2;
}
if (dfs(a + 1, b) == 2 || dfs(a, b + 1) == 2) return dp[a][b] = 1;
return dp[a][b] = 2;
}
long long a, b;
int main() {
scanf("%lld%lld%lld", &a, &b, &n);
for (int i = 1; i < maxn; i++) {
pw[i][0] = 1;
for (int j = 1; j <= 35; j++) {
pw[i][j] = pw[i][j - 1] * i;
if (pw[i][j] >= n) {
for (int k = j; k <= 35; k++) pw[i][k] = n;
break;
}
}
}
dfs(a, b);
if (a == 1) {
for (int i = b; i <= 36; i++) {
if (i > 35) {
printf("Missing\n");
break;
}
if (dp[2][i] == 2) {
if ((i - b) % 2 == 0)
printf("Masha\n");
else
printf("Stas\n");
break;
}
}
} else {
if (dp[a][b] == 1)
printf("Masha\n");
else
printf("Stas\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
map<long long, map<long long, long long[3]>> mp;
map<long long, map<long long, bool[3]>> mpb;
int go(long long a, long long b, bool g = 1) {
if (mpb[a][b][g]) return mp[a][b][g];
mpb[a][b][g] = true;
long long r = 1;
if (b > 32) {
return mp[a][b][g] = 2;
}
if (b == 1 && a > 100000) {
if ((n - a) % 2) return mp[a][b][g] = 0;
return mp[a][b][g] = 1;
}
for (int i = b; i >= 1; i--) {
r *= a;
if (r >= n) break;
}
if (r >= n) return mp[a][b][g] = g;
if (g) {
long long x2 = go(a, b + 1, 0);
long long x1 = go(a + 1, b, 0);
if (x1 == 1 || x2 == 1)
return mp[a][b][g] = 1;
else if (x1 == 2 || x2 == 2)
return mp[a][b][g] = 2;
else
return mp[a][b][g] = 0;
} else {
long long x2 = go(a, b + 1, 1);
long long x1 = go(a + 1, b, 1);
if (x1 == 0 || x2 == 0)
return mp[a][b][g] = 0;
else if (x1 == 2 || x2 == 2)
return mp[a][b][g] = 2;
else
return mp[a][b][g] = 1;
}
}
int main() {
long long a, b;
cin >> a >> b >> n;
cout << (go(a, b) == 2 ? "Missing" : (go(a, b) == 1 ? "Masha" : "Stas"));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[3][20] = {"Stas", "Missing", "Masha"};
int f[31700][32], a, b, n;
int dp(int a, int b) {
if (f[a][b] != -1) return f[a][b];
if (a == 1 && 1 << b >= n) return 1;
if (b == 1 && a * a >= n) return n - a & 1 ? 0 : 2;
if (pow(a, b) + 1e-6 > n) return f[a][b] = 2;
return f[a][b] = 2 - min(dp(a + 1, b), dp(a, b + 1));
}
int main() {
memset(f, -1, sizeof(f));
scanf("%d%d%d", &a, &b, &n);
printf("%s\n", str[dp(a, b)]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
ifstream fin("input.txt");
ofstream fout("output.txt");
const long long mod = 1000000000 + 7;
const int maxn = 100000 + 10;
const int inf = 1000000000;
long long a, b, n, gm[50003][66];
string out[3] = {"Stas", "Missing", "Masha"};
int f(long long x, long long y) {
if (gm[x][y] != -1) return gm[x][y];
if (x == 1 && 1 << y >= n) return 1;
if (y == 1 && x * x >= n) return n - x & 1 ? 0 : 2;
if (pow(x, y) + 1e-6 > n) return gm[x][y] = 2;
return gm[x][y] = 2 - min((f(x + 1, y)), (f(x, y + 1)));
}
int main() {
memset(gm, -1, sizeof gm);
cin >> a >> b >> n;
cout << out[f(a, b)] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[40000][40], n, a, b;
int dp(int a, int b) {
if (f[a][b] != -1) return f[a][b];
if (pow(double(a), b) + 0.1 > n) return f[a][b] = 2;
if (b > 30) return f[a][b] = 1;
if (b == 1 && a * a > n) return f[a][b] = 2 - 2 * ((n - a) % 2);
return f[a][b] = 2 - min(dp(a + 1, b), dp(a, b + 1));
}
int main() {
scanf("%d%d%d", &a, &b, &n);
memset(f, 255, sizeof f);
dp(a, b);
if (f[a][b] == 2)
puts("Masha");
else if (f[a][b] == 1)
puts("Missing");
else
puts("Stas");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 5e3 + 5;
const long long Mod = 1e9 + 7;
const long long inf = 0x3f3f3f3f3f3f3f;
int sg[35000][40] = {};
int main() {
long long a, b, n;
cin >> a >> b >> n;
for (int i = 33334; i >= 1; i--)
for (int j = 31; j >= 1; j--) sg[i][j] = 1;
for (int i = 33333; i >= 1; i--)
for (int j = 30; j >= 1; j--) {
long long x = 1;
for (int k = 1; k <= j && x < n; k++) x *= i;
if (x < n) sg[i][j] = 1 - (sg[i + 1][j] & sg[i][j + 1]);
}
if (a == 1 && pow(a + 1, b) + 1e-8 > n)
cout << "Missing" << endl;
else if (b == 1 && a * a >= n) {
if ((n - a + 1) & 1)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
} else if (sg[a][b])
cout << "Masha" << endl;
else
cout << "Stas" << endl;
return 0;
}
|
#include <bits/stdc++.h>
void Get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int Max[33005];
int F[33005][35];
int A, B, N, M;
void Init() {
Get(A);
Get(B);
Get(N);
N--;
for (int i = 2; (i - 2) * (i - 2) <= N; i++) {
Max[i] = logl(N) / logl(i);
M = i;
}
Max[M + 1] = Max[M + 2] = 1;
Max[1] = Max[2];
}
void Work() {
F[M + 2][1] = (((N - M)) & 1);
for (int i = M + 1; i >= 1; i--) {
for (int j = 30; j >= 1; j--) {
if (Max[i] < j)
F[i][j] = 1;
else
F[i][j] = (F[i + 1][j] == 0) || (F[i][j + 1] == 0);
}
}
}
void Output() {
if (A == 1 && B > Max[1]) {
puts("Missing");
} else if (B == 1 && A > M)
puts(((A - N) & 1) ? "Masha" : "Stas");
else {
puts((F[A][B]) ? "Masha" : "Stas");
}
}
int main() {
Init();
Work();
Output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power[40111][44];
int a, b, n;
int f[40111][44];
int main() {
while (cin >> a >> b >> n) {
for (int i = (2), _b = (40000); i <= _b; i++) {
power[i][0] = 1;
for (int j = (1), _b = (40); j <= _b; j++) {
power[i][j] = power[i][j - 1] * i;
if (power[i][j] > n) {
power[i][j] = n + 1;
}
}
}
for (int i = (40000), _b = (1); i >= _b; i--)
for (int j = (40), _b = (1); j >= _b; j--) {
if (i == 1) {
if (j == 40) {
if (f[2][j] == -1)
f[i][j] = 1;
else
f[i][j] = 0;
} else {
if (f[i + 1][j] == -1 || f[i][j + 1] == -1)
f[i][j] = 1;
else if (f[i + 1][j] == 0 || f[i][j + 1] == 0)
f[i][j] = 0;
else
f[i][j] = -1;
}
} else {
if (power[i][j] >= n)
f[i][j] = 1;
else if (j == 1 && i == 40000) {
if (f[i][j + 1] < 0)
f[i][j] = 1;
else if ((n - i) % 2 == 0)
f[i][j] = 1;
else if (f[i][j + 1] == 0)
f[i][j] = 0;
else
f[i][j] = -1;
} else {
if (f[i + 1][j] == -1 || f[i][j + 1] == -1)
f[i][j] = 1;
else if (f[i + 1][j] == 0 || f[i][j + 1] == 0)
f[i][j] = 0;
else
f[i][j] = -1;
}
}
}
if (f[a][b] > 0)
cout << "Masha";
else if (f[a][b] < 0)
cout << "Stas";
else
cout << "Missing";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
long long a, b, n, base[N][50];
int dp[N][50];
int dfs(long long x, long long y) {
if (dp[x][y]) return dp[x][y];
if (base[x][y] >= n) return dp[x][y] = 1;
if (x * x >= n) {
if ((n - x) % 2 == 0)
return dp[x][y] = 1;
else
return dp[x][y] = 2;
}
if (dfs(x + 1, y) == 2 || dfs(x, y + 1) == 2) {
return dp[x][y] = 1;
}
return dp[x][y] = 2;
}
int main() {
scanf("%lld%lld%lld", &a, &b, &n);
for (int i = 1; i < N; i++) {
base[i][0] = 1;
for (int j = 1; j <= 40; j++) {
base[i][j] = base[i][j - 1] * i;
if (base[i][j] >= n) {
for (int k = j; k <= 40; k++) base[i][k] = n;
break;
}
}
}
if (a == 1 && base[a + 1][b] >= n) {
printf("Missing\n");
} else {
if (dfs(a, b) == 1)
printf("Masha\n");
else
printf("Stas\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007, dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
const double eps = 1e-8;
void read(int &k) {
k = 0;
char x = getchar();
while (x < '0' || x > '9') x = getchar();
while (x >= '0' && x <= '9') {
k = k * 10 - 48 + x;
x = getchar();
}
}
int dp[32010][33], a, b, n;
int main() {
cin >> a >> b >> n;
dp[1][31] = 2;
for (int i = 1; i <= 32000; i++) {
long long tmp = 1;
for (int j = 1; j <= 31; j++) {
tmp *= i;
if (tmp >= n) dp[i][j] = 1, tmp = n;
}
}
for (int i = 31999; i; i--)
for (int j = 30; j; j--)
if (dp[i][j] == 0) dp[i][j] = 4 - max(dp[i + 1][j], dp[i][j + 1]);
if (dp[a][b] == 1)
puts("Masha");
else if (dp[a][b] == 3)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long NR = 5e5 + 10, oo = 2e9 + 10, MOD = 1e9 + 7;
const long double pi = 2 * acos(0.0);
short dp[100002][32];
long long a, b, c;
long long find_(long long i, long long j) {
if (dp[i][j]) return dp[i][j];
long long x, y;
x = 1;
if (j == 30) {
dp[i][j] = 3;
return dp[i][j];
}
if (i == 100000) {
if ((c - i) % 2) {
dp[i][j] = 2;
} else {
dp[i][j] = 1;
}
return dp[i][j];
}
for (y = 1; y <= j; ++y) {
x *= i;
if (x >= c) {
dp[i][j] = 1;
return dp[i][j];
}
}
x = find_(i + 1, j);
y = find_(i, j + 1);
if (x == 1 && y == 1) {
dp[i][j] = 2;
}
if (x == 1 && y == 3) {
dp[i][j] = 3;
}
if (x == 3 && y == 1) {
dp[i][j] = 3;
}
if (x == 2 || y == 2) {
dp[i][j] = 1;
}
return dp[i][j];
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> c;
a = find_(a, b);
if (a == 1) {
cout << "Masha\n";
}
if (a == 2) {
cout << "Stas\n";
}
if (a == 3) {
cout << "Missing\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 3;
const int NN = 35;
long long mm[N + 10][NN + 10];
int dp[N + 10][NN + 10];
long long n;
bool control1, control2;
void build() {
memset(dp, -1, sizeof(dp));
bool here = false;
for (int i = int(1); i < int(N); ++i)
for (int j = int(1); j < int(NN); ++j) {
if (j == 1)
mm[i][j] = i, here = false;
else
mm[i][j] = mm[i][j - 1] * i;
if (mm[i][j] >= n) here = true;
if (here) dp[i][j] = 1;
}
}
bool ziggy(int a, int b) {
if (a == 1 && b == NN) control1 = true;
if (a == N && b == 1) control2 = true;
if (dp[a][b] != -1) return dp[a][b];
return dp[a][b] = 1 - (ziggy(a + 1, b) && ziggy(a, b + 1));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b;
bool first = (a + b) & 1;
scanf("%lld%lld%lld", &a, &b, &n);
build();
dp[1][NN] = 1;
dp[N][1] = 1;
bool f = ziggy(a, b);
if (control1) {
printf("Missing\n");
return 0;
}
if (control2) {
if ((a & 1) != (n & 1))
printf("Stas\n");
else
printf("Masha\n");
return 0;
}
if (f)
printf("Masha\n");
else
printf("Stas\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int N = 35000;
const int M = 31;
int a, b, n, dp[N][M];
bool check(int a, int b, int n) {
long long ret = 1LL;
for (int i = 0; i < b; i++) {
ret = ret * a;
if (ret <= 0 || ret >= n) return true;
}
return false;
}
int dfs(int a, int b) {
if (dp[a][b] != -1) return dp[a][b];
if (check(a, b, n)) {
return dp[a][b] = 1;
}
int ret = 0;
ret |= !dfs(a + 1, b);
ret |= !dfs(a, b + 1);
return dp[a][b] = ret;
}
bool b_is_one(int a, int b = 1) {
int up = sqrt(n - 0.0000001);
int turn = 0;
while (a <= up) {
if (dp[a][b + 1] == 0) {
return turn == 0;
}
a++;
turn = 1 - turn;
}
int remain = n - 1 - a;
turn = (turn + remain) % 2;
return turn;
}
int a_is_one(int b, int a = 1) {
if (check(a, b, n))
return 0;
else {
int turn = 0;
for (; !check(2, b, n); b++) {
if (dp[a + 1][b] == 0) {
if (turn == 0)
return 1;
else
return -1;
}
turn = 1 - turn;
}
return 0;
}
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> a >> b >> n;
if (check(a, b, n)) {
puts("Masha");
return 0;
}
for (int i = 2; i < N; i++) {
for (int j = 2; j < M; j++) {
dp[i][j] = dfs(i, j);
}
}
if (a != 1 && b != 1) {
puts(dp[a][b] ? "Masha" : "Stas");
return 0;
}
if (a == 1 && b == 1) {
int c = a_is_one(b + 1), d = b_is_one(a + 1);
if (c < 0 || d == 0)
puts("Masha");
else if (c == 0)
puts("Missing");
else
puts("Stas");
} else if (b == 1) {
puts(b_is_one(a) ? "Masha" : "Stas");
} else if (a == 1) {
int c = a_is_one(b);
if (c == 0)
puts("Missing");
else if (c == 1)
puts("Masha");
else
puts("Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, n;
long long SG[33000][32];
long long quick_pow(long long aa, long long bb) {
long long ret = 1;
while (bb) {
if (bb & 1) ret = ret * aa;
aa = aa * aa;
bb >>= 1;
}
return ret;
}
long long qsg(long long aa, long long bb) {
long long& ret = SG[aa][bb];
if (ret != -1) return ret;
if (quick_pow(aa, bb) >= n) return ret = 1;
if (aa == 1) {
if (quick_pow(2, bb) >= n) return ret = 2;
if (qsg(2, bb) == 0) return ret = 1;
if (qsg(1, bb + 1) == 0) return ret = 1;
if (qsg(1, bb + 1) == 2) return ret = 2;
}
if (bb == 1) {
if (qsg(aa, bb + 1) == 0) return ret = 1;
if (qsg(aa + 1, bb) == 1)
return ret = 0;
else if (qsg(aa + 1, bb) == 0)
return ret = 1;
}
if (qsg(aa + 1, bb) == 0 || qsg(aa, bb + 1) == 0) return ret = 1;
return ret = 0;
}
int main() {
cin >> a >> b >> n;
memset(SG, -1, sizeof(SG));
if (qsg(a, b) == 1)
puts("Masha");
else if (qsg(a, b) == 0)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, j, k, l, i, o, p, __t;
long long maxi;
int f[32020][40];
char ch;
void read(int &a) {
for (ch = getchar(); (ch < '0' || ch > '9') && (ch != '-'); ch = getchar())
;
if (ch == '-')
a = 0, __t = -1;
else
a = ch - '0', __t = 1;
for (ch = getchar(); ch >= '0' && ch <= '9'; ch = getchar())
a = a * 10 + ch - '0';
a *= __t;
}
long long exp(long long a, long long t) {
long long ret = 1;
for (long long i = 1; i <= t; i *= 2LL, a = a * a)
if (t & i) ret = ret * a;
return ret;
}
int DFS(int a, int b) {
if (f[a][b] != -1) return f[a][b];
if (b == 33 && a == 1) return 2;
if (exp(a, b) >= maxi) return 1;
if (b == 1 && exp(a, b + 1) >= maxi) return (maxi - a + 1) % 2;
int f1 = DFS(a + 1, b);
int f2 = DFS(a, b + 1);
if ((f1 == 2 && f2 == 1) || (f1 == 1 && f2 == 2)) return f[a][b] = 2;
if (f1 == 0 || f2 == 0) return f[a][b] = 1;
return f[a][b] = 0;
}
int main() {
cin >> m >> n >> maxi;
memset(f, -1, sizeof f);
int t = DFS(m, n);
if (t == 1)
printf("Masha\n");
else if (t == 0)
printf("Stas\n");
else
printf("Missing\n");
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.