text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 550;
char Map[maxn][maxn];
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, -1, 0, 1};
int n, m;
bool in(int x, int y) { return 1 <= x && x <= n && 1 <= y && y <= m; }
void gst(int &x, int &y) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (Map[i][j] == '.') {
x = i, y = j;
return;
}
}
}
x = y = 0;
}
queue<pair<int, int> > Q;
stack<pair<int, int> > S;
bool vis[maxn][maxn];
void bfs(int k) {
int x, y;
gst(x, y);
memset(vis, 0, sizeof(vis));
while (Q.empty() == false) Q.pop();
while (S.empty() == false) S.pop();
Q.push(make_pair(x, y));
vis[x][y] = true;
while (Q.empty() == false) {
S.push(Q.front());
x = Q.front().first;
y = Q.front().second;
Q.pop();
for (int d = 0; d < 4; d++) {
int i = dx[d] + x;
int j = dy[d] + y;
if (in(i, j) && vis[i][j] == false && Map[i][j] == '.') {
vis[i][j] = true;
Q.push(make_pair(i, j));
}
}
}
while (k-- && !S.empty()) {
Map[S.top().first][S.top().second] = 'X';
S.pop();
}
}
int main() {
int k;
while (~scanf("%d %d %d", &n, &m, &k)) {
for (int i = 1; i <= n; i++) {
scanf("%s", Map[i] + 1);
}
bfs(k);
for (int i = 1; i <= n; i++) {
printf("%s\n", Map[i] + 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char board[600][600];
int d[600][600];
void dfs(int a, int b, int& left) {
d[a][b] = 1;
if (a - 1 >= 0 && board[a - 1][b] == '.' && d[a - 1][b] == 0)
dfs(a - 1, b, left);
if (a + 1 < n && board[a + 1][b] == '.' && d[a + 1][b] == 0)
dfs(a + 1, b, left);
if (b - 1 >= 0 && board[a][b - 1] == '.' && d[a][b - 1] == 0)
dfs(a, b - 1, left);
if (b + 1 < m && board[a][b + 1] == '.' && d[a][b + 1] == 0)
dfs(a, b + 1, left);
if (left > 0) {
--left;
board[a][b] = 'X';
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; ++i) scanf("%s", board[i]);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
d[i][j] = 0;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (board[i][j] == '.') {
dfs(i, j, k);
goto end;
}
}
}
end:;
for (int i = 0; i < n; ++i) {
printf("%s\n", board[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXV = 10001000;
const int MXN = 510;
char mpp[MXN][MXN];
int n, m, k;
int di[] = {0, 0, 1, -1};
int dj[] = {1, -1, 0, 0};
bool was[MXN][MXN];
void dfs(int i, int j) {
was[i][j] = 1;
for (int k = 0; k < (4); k++) {
int ni = i + di[k];
int nj = j + dj[k];
if (ni >= 0 && nj >= 0 && ni < n && nj < m && !was[ni][nj] &&
mpp[ni][nj] == '.')
dfs(ni, nj);
}
if (k > 0) {
mpp[i][j] = 'X';
k--;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < (n); i++) {
scanf("%s", mpp[i]);
}
for (int i = 0; i < (n); i++) {
bool q = 0;
for (int j = 0; j < (m); j++)
if (mpp[i][j] != '#') {
dfs(i, j);
q = 1;
break;
}
if (q) break;
}
for (int i = 0; i < (n); i++) printf("%s\n", mpp[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF64 = 1e18;
const int INF = 1e9;
template <typename T>
void read(vector<T>& v) {
int n = v.size();
for (int i = 0; i < n; i++) cin >> v[i];
}
long long ceil(long long a, long long b) {
long long ans = a / b;
if (a % b) ans++;
return ans;
}
long double log(long double a, long double b) { return log(b) / log(a); }
long long power(long long base, long long exp, long long M = LLONG_MAX) {
long long res = 1;
while (exp) {
if (exp % 2 == 1) res = ((res % M) * (base % M)) % M;
base = ((base % M) * (base % M)) % M;
exp /= 2;
}
return res;
}
string to_base(int n, int new_base) {
string s;
int nn = n;
while (nn) {
s += to_string(nn % new_base);
nn /= new_base;
}
reverse(s.begin(), s.end());
return s;
}
long long gcd(long long a, long long b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
long long lcm(long long a, long long b) {
long long x = (a / gcd(a, b));
return b * x;
}
vector<bool> SIEVE(int n) {
vector<bool> ans(n + 1);
for (int i = 2; i <= n; i++) ans[i] = 1;
for (int i = 2; i * i <= n; i++) {
if (ans[i])
for (int j = 2 * i; j <= n; j += i) ans[j] = 0;
}
return ans;
}
void solve();
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) solve();
return 0;
}
vector<string> a;
int n, m, k;
vector<string> b;
int l = 0;
void dfs(int i, int j) {
if (i < 0 || j < 0 || n <= i || m <= j || !l || b[i][j] != '.') return;
b[i][j] = 'S';
vector<int> d = {-1, 0, 1};
l--;
for (int dx : d)
for (int dy : d)
if ((dx == 0) ^ (dy == 0)) dfs(i + dx, j + dy);
}
void solve() {
cin >> n >> m >> k;
b = vector<string>(n);
a = vector<string>(n);
read(a);
int s = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (a[i][j] == '.') s++;
bool brk = 0;
for (int i = 0; i < n; i++) b[i] = a[i];
l = s - k;
for (int i = 0; i < n; i++) {
if (brk) break;
for (int j = 0; j < m; j++)
if (a[i][j] == '.') {
dfs(i, j);
brk = 1;
break;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (b[i][j] == 'S')
cout << ".";
else if (b[i][j] == '.')
cout << "X";
else
cout << b[i][j];
cout << "\n";
}
}
|
#include <bits/stdc++.h>
int i, j, n, H[1005][1005], m, k, s;
char arr[1005][1005];
int adim;
void dfs(int i, int j) {
if (i < 1 or i > n or j < 1 or j > m or H[i][j]) return;
adim++;
H[i][j] = 1;
if (adim == s - k) {
for (int t = 1; t <= n; t++, puts(""))
for (int l = 1; l <= m; l++)
if (H[t][l] and arr[t][l] == '.')
printf(".");
else if (!H[t][l] and arr[t][l] == '.')
printf("X");
else
printf("#");
exit(0);
}
if (arr[i + 1][j] == '.') dfs(i + 1, j);
if (arr[i - 1][j] == '.') dfs(i - 1, j);
if (arr[i][j + 1] == '.') dfs(i, j + 1);
if (arr[i][j - 1] == '.') dfs(i, j - 1);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf(" %c", &arr[i][j]);
s += (arr[i][j] == '.');
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (arr[i][j] == '.' and !H[i][j]) {
adim = 0;
dfs(i, j);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static bool sync_with_stdio(0);
bool Is2n(int n) {
if (n <= 0) return false;
if ((n & ((~n) + 1)) == n)
return true;
else
return false;
}
int gcd(int a, int b) {
int c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
struct Comparator {
int operator()(const pair<int, int>& P1, const pair<int, int>& P2) const {
return (P1.second > P2.second);
}
};
int dx[] = {0, 1, 0, -1};
int dy[] = {-1, 0, 1, 0};
typedef struct {
int x, y;
} Point;
struct C {
int operator()(const Point& P1, const Point& P2) const {
if (P1.y == P2.y) return (P1.x < P2.x);
return (P1.y < P2.y);
}
};
vector<string> S;
map<Point, vector<Point>, C> G;
vector<vector<bool> > V;
int Y, X;
void DFS(Point p, int& rem) {
if (rem == 0) return;
if (G[p].size() == 0) {
S[p.y][p.x] = 'X';
rem--;
} else {
for (int i = int(0); i < int(G[p].size()); i++) {
Point tmp = G[p][i];
DFS(tmp, rem);
if (rem == 0) return;
}
if (rem != 0) {
S[p.y][p.x] = 'X';
rem--;
}
}
}
void GenTree(int i, int j) {
Point P;
V[i][j] = true;
vector<Point> tmp;
for (int l = int(0); l < int(4); l++) {
int xx = j + dx[l];
int yy = i + dy[l];
if (xx >= 0 && xx < X && yy >= 0 && yy < Y && S[yy][xx] == '.' &&
!V[yy][xx]) {
P.x = xx;
P.y = yy;
tmp.push_back(P);
GenTree(yy, xx);
}
}
P.x = j;
P.y = i;
G[P] = tmp;
}
int main() {
int k;
cin >> Y >> X >> k;
S = vector<string>(Y);
V = vector<vector<bool> >(Y);
vector<bool> T(X, false);
for (int i = int(0); i < int(Y); i++) {
cin >> S[i];
V[i] = T;
}
Point P;
Point root;
bool R = true;
for (int i = 0; i < Y && R; i++) {
for (int j = 0; j < X && R; j++) {
if (S[i][j] == '.') {
GenTree(i, j);
if (R) {
root.y = i;
root.x = j;
R = false;
}
}
}
}
DFS(root, k);
for (int i = int(0); i < int(Y); i++) cout << S[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[505][505];
int xx[] = {0, -1, 1, 0};
int yy[] = {-1, 0, 0, 1};
struct toado {
int x, y;
toado(){};
toado(int _x, int _y) {
x = _x;
y = _y;
}
};
toado mang[505 * 505];
int dd[505][505];
int n, m, k;
int dem = 0;
toado dau;
void nhap() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> s[i][j];
if (s[i][j] == '.') {
dau.x = i;
dau.y = j;
}
}
}
bool kt(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= m; }
void BFS() {
int l = 1;
mang[++dem] = dau;
dd[dau.x][dau.y] = 1;
while (l <= dem) {
int x = mang[l].x;
int y = mang[l].y;
for (int huong = 0; huong <= 3; huong++) {
int h = x + xx[huong];
int k = y + yy[huong];
if (kt(h, k) && dd[h][k] == 0 && s[h][k] == '.') {
mang[++dem] = toado(h, k);
dd[h][k] = 1;
}
}
l++;
}
}
void xuli() {
BFS();
for (int i = dem; i >= dem - k + 1; i--) {
int x = mang[i].x;
int y = mang[i].y;
s[x][y] = 'X';
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << s[i][j];
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0);
nhap();
xuli();
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
int main() {
int n, m, k;
cin >> n >> m >> k;
char mat[n + 2][m + 2];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char c;
cin >> c;
mat[i][j] = c;
}
}
int totDot = 0;
bool visited[n + 2][m + 2];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) visited[i][j] = false;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) totDot += (mat[i][j] == '.');
queue<pair<int, int> > q;
int totConnected = totDot - k;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (mat[i][j] == '.') {
q.push(make_pair(i, j));
goto ed;
}
ed:
int i = 0;
while (!q.empty() && i < totConnected) {
pair<int, int> node = q.front();
q.pop();
int x = node.first;
int y = node.second;
if (visited[x][y] == true) continue;
visited[x][y] = true;
i++;
for (int i = 0; i < 4; ++i) {
int xx = x + dy[i];
int yy = y + dx[i];
if (xx >= 0 && yy >= 0 && xx < n && yy < m && !visited[xx][yy] &&
mat[xx][yy] == '.') {
q.push(make_pair(xx, yy));
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (mat[i][j] == '#')
cout << "#";
else if (mat[i][j] == '.' && visited[i][j])
cout << ".";
else
cout << "X";
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
short field[550][550];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
bool onf(int i, int j) { return (i >= 1 && i <= n && j >= 1 && j <= m); }
void setwall(int y, int x) {
k--;
field[y][x] = 0;
for (int i = 0; i < 4; i++) {
if (field[y + dy[i]][x + dx[i]] == 2 && k > 0)
setwall(y + dy[i], x + dx[i]);
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
int kol = 0;
char c = getchar();
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
c = getchar();
if (c == '.') {
field[i][j] = 2;
kol++;
}
if (c == '#') field[i][j] = 1;
}
c = getchar();
}
k = kol - k;
for (int i = 1; i <= n && k; i++) {
for (int j = 1; j <= m && k; j++) {
if (field[i][j] == 2 && k > 0) setwall(i, j);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (field[i][j] == 1) printf("#");
if (field[i][j] == 0) printf(".");
if (field[i][j] == 2) printf("X");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
string s[605];
int mark[605][605];
bool vis[260000];
vector<int> v[260000];
vector<int> vertices;
void graph() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mark[i][j] == 0) {
vertices.push_back(((i - 1) * m) + j);
if (mark[i][j + 1] == 0)
v[((i - 1) * m) + j].push_back(((i - 1) * m) + j + 1);
if (mark[i][j - 1] == 0)
v[((i - 1) * m) + j].push_back(((i - 1) * m) + j - 1);
if (mark[i + 1][j] == 0) v[((i - 1) * m) + j].push_back((i * m) + j);
if (mark[i - 1][j] == 0)
v[((i - 1) * m) + j].push_back(((i - 2) * m) + j);
}
}
}
}
void dfs(int u) {
vis[u] = true;
for (int i = 0; i < v[u].size(); i++) {
int w = v[u][i];
if (vis[w] == false) dfs(w);
}
if (k > 0) {
k--;
if (u % m == 0) {
mark[u / m][m] = 2;
} else {
mark[(u / m) + 1][u % m] = 2;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i <= m + 1; i++) {
mark[0][i] = 1;
mark[n + 1][i] = 1;
}
for (int i = 0; i <= n + 1; i++) {
mark[i][0] = 1;
mark[i][m + 1] = 1;
}
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
if (s[i][j] == '#') mark[i + 1][j + 1] = 1;
}
}
graph();
dfs(vertices[0]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mark[i][j] == 0) cout << ".";
if (mark[i][j] == 1) cout << "#";
if (mark[i][j] == 2) cout << "X";
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int msz = 10000;
const int mod = 1e9 + 7;
const double eps = 1e-8;
bool vis[555][555];
char mp[555][555];
int dirx[] = {1, -1, 0, 0};
int diry[] = {0, 0, 1, -1};
int main() {
int n, m, k;
while (~scanf("%d%d%d", &n, &m, &k)) {
queue<pair<int, int> > q;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; ++i) {
scanf("%s", mp[i]);
for (int j = 0; j < m; ++j) {
if (mp[i][j] == '.' && q.empty()) {
q.push(pair<int, int>(i, j));
vis[i][j] = 1;
}
}
}
stack<pair<int, int> > s;
int x, y, xx, yy;
pair<int, int> p;
while (!q.empty()) {
p = q.front();
q.pop();
x = p.first;
y = p.second;
s.push(p);
for (int i = 0; i < 4; ++i) {
xx = x + dirx[i];
yy = y + diry[i];
if (xx < 0 || xx >= n || yy < 0 || yy >= m || vis[xx][yy] ||
mp[xx][yy] == '#')
continue;
vis[xx][yy] = 1;
q.push(pair<int, int>(xx, yy));
}
}
while (!s.empty() && k--) {
p = s.top();
s.pop();
mp[p.first][p.second] = 'X';
}
for (int i = 0; i < n; ++i) puts(mp[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char field[500][501];
int isVisit[500][500];
int n, m, K;
const int mov[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int main(void) {
scanf("%d %d %d", &n, &m, &K);
int empty = 0;
for (int i = 0; i < n; i++) {
scanf("%s", field[i]);
for (int j = 0; j < m; j++)
if (field[i][j] == '.') empty++;
}
queue<pair<int, int> > q;
for (int i = 0; i < n && q.size() == 0; i++)
for (int j = 0; j < m && q.size() == 0; j++)
if (field[i][j] == '.') {
isVisit[i][j] = true;
q.push(make_pair(i, j));
}
int cnt = 1;
while (!q.empty() && cnt < empty - K) {
int y = q.front().first;
int x = q.front().second;
q.pop();
for (int i = 0; i < 4 && cnt < empty - K; i++) {
int ny = y + mov[i][0];
int nx = x + mov[i][1];
if (ny >= 0 && ny < n && nx >= 0 && nx < m && isVisit[ny][nx] == false &&
field[ny][nx] == '.') {
isVisit[ny][nx] = true;
q.push(make_pair(ny, nx));
cnt++;
}
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (field[i][j] == '.' && !isVisit[i][j]) field[i][j] = 'X';
for (int i = 0; i < n; i++) printf("%s\n", field[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, K;
char m[500][501];
int dx[4] = {1, -1, 0, 0}, dy[4] = {0, 0, 1, -1};
int main() {
scanf("%d%d%d", &N, &M, &K);
for (int(i) = 0; (i) < (N); (i)++) scanf("%s", &m[i]);
int sx = 0, sy = 0, s = 0;
for (int(i) = 0; (i) < (N); (i)++)
for (int(j) = 0; (j) < (M); (j)++)
if (m[i][j] == '.') s++, sx = i, sy = j;
queue<pair<int, int> > q;
q.push(make_pair(sx, sy));
m[sx][sy] = 'X';
int sz = 1;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
if (sz == s - K) break;
for (int(d) = 0; (d) < (4); (d)++) {
int nx = x + dx[d], ny = y + dy[d];
if (0 <= nx && nx < N && 0 <= ny && ny < M && m[nx][ny] == '.') {
sz++;
m[nx][ny] = 'X';
if (sz == s - K) goto out;
q.push(make_pair(nx, ny));
}
}
}
out:;
for (int(i) = 0; (i) < (N); (i)++) {
for (int(j) = 0; (j) < (M); (j)++) {
if (m[i][j] == 'X')
putchar('.');
else if (m[i][j] == '.')
putchar('X');
else
putchar(m[i][j]);
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int c = 0, v[510][510];
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int n, m, k, t, cnt;
char ma[510][510];
void dfs(int x, int y) {
if (cnt == c - k) t = 1;
if (!t) v[x][y] = 1;
for (int i = 0; i < 4; i++) {
int fx = x + dx[i];
int fy = y + dy[i];
if (fx >= 0 && fx < n && fy >= 0 && fy < m && ma[fx][fy] == '.' &&
!v[fx][fy] && !t) {
cnt++;
dfs(fx, fy);
}
}
}
int main() {
int i, j;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
c = 0;
t = 0;
cnt = 0;
int st_i, st_j;
memset(v, 0, sizeof(v));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf(" %c", &ma[i][j]);
if (ma[i][j] == '.') {
st_i = i;
st_j = j;
c++;
}
}
}
dfs(st_i, st_j);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (ma[i][j] == '.' && !v[i][j])
printf("X");
else
printf("%c", ma[i][j]);
}
printf("\n");
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const signed long int N = 501, M = 501;
signed long int n, m, k, timer;
char f[N][M];
bool visited[N][M];
signed long int dx[] = {-1, 1, 0, 0};
signed long int dy[] = {0, 0, -1, 1};
bool outOfBounds(signed long int x, signed long int y) {
return x < 0 || x >= m || y < 0 || y >= n;
}
void dfs(signed long int x, signed long int y) {
visited[y][x] = true;
signed long int toX, toY;
for (signed long int i = 0; i < 4; ++i) {
toX = x + dx[i];
toY = y + dy[i];
if (!outOfBounds(toX, toY) && f[toY][toX] == '.' && !visited[toY][toX]) {
dfs(toX, toY);
}
}
if (k > 0) {
f[y][x] = 'X';
k--;
}
}
void solve() {
scanf("%li %li %li\n", &n, &m, &k);
for (signed long int y = 0; y < n; ++y) {
scanf("%s", &f[y]);
}
for (signed long int y = 0; y < n; ++y) {
for (signed long int x = 0; x < m; ++x) {
if (f[y][x] == '.') {
dfs(x, y);
break;
}
}
}
}
void output() {
for (signed long int y = 0; y < n; ++y) {
printf("%s\n", f[y]);
}
}
void init() { freopen("input.txt", "r", stdin); }
int main() {
solve();
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, art[505][505], low[505][505], used[505][505], ans, cn, t,
x, y, z, mx, mn, s, timer, vis[505][505];
char c[505][505], d[1000009], ch;
void dfs(int row, int col) {
timer++;
used[row][col] = 1;
if ((row - 1 >= 0) && (used[row - 1][col] == 0) && (timer < s) &&
(c[row - 1][col] == '.')) {
dfs(row - 1, col);
}
if ((col - 1 >= 0) && (used[row][col - 1] == 0) && (timer < s) &&
(c[row][col - 1] == '.')) {
dfs(row, col - 1);
}
if ((row + 1 < n) && (used[row + 1][col] == 0) && (timer < s) &&
(c[row + 1][col] == '.')) {
dfs(row + 1, col);
}
if ((col + 1 < m) && (used[row][col + 1] == 0) && (timer < s) &&
(c[row][col + 1] == '.')) {
dfs(row, col + 1);
}
}
int main() {
while (scanf("%d %d %d", &n, &m, &k) != EOF) {
x = y = s = 0;
timer = 1;
for (i = 0; i < n; i++) {
scanf("%s", c[i]);
for (j = 0; j < m; j++) {
if (c[i][j] == '.') {
s++;
x = i;
y = j;
}
}
}
s -= k;
memset(used, 0, sizeof(used));
timer = 0;
dfs(x, y);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if ((used[i][j] == 0) && (c[i][j] == '.')) {
k--;
printf("X");
} else {
printf("%c", c[i][j]);
}
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<char>> g;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int bfs1(int xs, int ys) {
int res = 1;
queue<pair<int, int>> q;
q.push(make_pair(xs, ys));
g[xs][ys] = 'X';
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; ++i)
if (g[x + dx[i]][y + dy[i]] == '.') {
g[x + dx[i]][y + dy[i]] = 'X';
q.push(make_pair(x + dx[i], y + dy[i]));
++res;
}
}
return res;
}
void bfs2(int xs, int ys, int k) {
queue<pair<int, int>> q;
q.push(make_pair(xs, ys));
g[xs][ys] = '.';
--k;
if (k == 0) return;
while (!q.empty()) {
int x = q.front().first, y = q.front().second;
q.pop();
for (int i = 0; i < 4; ++i)
if (g[x + dx[i]][y + dy[i]] == 'X') {
q.push(make_pair(x + dx[i], y + dy[i]));
g[x + dx[i]][y + dy[i]] = '.';
--k;
if (k == 0) return;
}
}
}
int main() {
int n, m, k;
cin >> n >> m >> k;
g.resize(n + 2, vector<char>(m + 2, '#'));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> g[i][j];
for (int i = 1; i <= n; ++i) {
bool b = 0;
for (int j = 1; j <= m; ++j)
if (g[i][j] == '.') {
int s = bfs1(i, j);
bfs2(i, j, s - k);
b = 1;
break;
}
if (b) break;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) cout << g[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static bool sync_with_stdio(0);
bool Is2n(int n) {
if (n <= 0) return false;
if ((n & ((~n) + 1)) == n)
return true;
else
return false;
}
int gcd(int a, int b) {
int c;
while (a != 0) {
c = a;
a = b % a;
b = c;
}
return b;
}
struct Comparator {
int operator()(const pair<int, int>& P1, const pair<int, int>& P2) const {
return (P1.second > P2.second);
}
};
int dx[] = {0, 1, 0, -1};
int dy[] = {-1, 0, 1, 0};
vector<string> S;
vector<vector<int> > C;
int Y, X;
int Count = 1;
void DFS(int y, int x) {
C[y][x] = Count++;
for (int i = int(0); i < int(4); i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx >= 0 && xx < X && yy >= 0 && yy < Y && C[yy][xx] == 0 &&
S[yy][xx] == '.')
DFS(yy, xx);
}
}
int main() {
int k;
cin >> Y >> X >> k;
C = vector<vector<int> >(Y);
S = vector<string>(Y);
vector<int> T(X, 0);
for (int i = int(0); i < int(Y); i++) {
cin >> S[i];
C[i] = T;
}
bool R = true;
for (int i = 0; i < Y && R; i++) {
for (int j = 0; j < X && R; j++) {
if (S[i][j] == '.') {
DFS(i, j);
R = false;
}
}
}
for (int i = int(0); i < int(Y); i++) {
for (int j = int(0); j < int(X); j++) {
if (S[i][j] == '.' && C[i][j] >= Count - k) S[i][j] = 'X';
}
}
for (int i = int(0); i < int(Y); i++) cout << S[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
char map[505][505];
int n, m, k, vis[505][505];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int ok(int x, int y) {
int i;
if (map[x][y] != '.') return 0;
int f = 0;
for (i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx >= n || xx < 0 || yy >= m || yy < 0) continue;
if (map[xx][yy] == '.') {
f = 1;
break;
}
}
return f;
}
void dfs(int x, int y) {
int i;
for (i = 0; i < 4; i++) {
int xx = x + dx[i];
int yy = y + dy[i];
if (xx >= n || xx < 0 || yy >= m || yy < 0) continue;
if (map[xx][yy] == '.' && !vis[xx][yy]) {
vis[xx][yy] = 1;
dfs(xx, yy);
}
}
if (k <= 0) return;
map[x][y] = 'X';
k--;
return;
}
int main(void) {
while (~scanf("%d %d %d", &n, &m, &k)) {
int i, j;
for (i = 0; i < n; i++) {
scanf("%s", map[i]);
}
if (k == 500 * 500 - 1) {
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) map[i][j] = 'X';
}
map[0][0] = '.';
k = 0;
}
while (k) {
memset(vis, 0, sizeof(vis));
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (ok(i, j)) {
memset(vis, 0, sizeof(vis));
vis[i][j] = 1;
dfs(i, j);
}
if (k <= 0) break;
}
if (k <= 0) break;
}
}
for (i = 0; i < n; i++) puts(map[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, cnt;
char mat[501][501], mat2[501][501];
int di[4] = {1, 0, -1, 0};
int dj[4] = {0, 1, 0, -1};
void lee(int i, int j) {
if (s - cnt <= k) return;
if (mat[i][j] == '.') {
cnt++;
mat[i][j] = ',';
mat2[i][j] = '.';
} else
return;
for (int d = 0; d < 4; d++) lee(i + di[d], j + dj[d]);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> mat[i][j];
if (mat[i][j] == '.')
mat2[i][j] = 'X', s++;
else
mat2[i][j] = '#';
}
bool ok = true;
for (int i = 1; i <= n && ok; i++)
for (int j = 1; j <= m && ok; j++)
if (mat[i][j] == '.') {
ok = false;
lee(i, j);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << mat2[i][j];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long GCD(long long a, long long b) { return (a) ? GCD(b % a, a) : b; }
long long LCM(long long a, long long b) { return a * b / GCD(a, b); }
double power(double a, long long b) {
double x = 1;
for (int i = 0; i < b; i++) {
x = x * a;
}
return x;
}
int n, m, k;
char grid[509][509];
int visited[509][509];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
void dfs(int i, int j) {
if (visited[i][j] || i < 0 || i >= n || j < 0 || j >= m || grid[i][j] != '.')
return;
visited[i][j] = 1;
for (int l = 0; l < 4; l++) dfs(i + dx[l], j + dy[l]);
if (k > 0) {
k--;
grid[i][j] = 'X';
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> grid[i][j];
bool flag = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (grid[i][j] == '.') {
dfs(i, j);
break;
flag = 1;
}
}
if (flag) break;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << grid[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int x4[4] = {1, 0, 0, -1};
int y4[4] = {0, 1, -1, 0};
int n, m, k, y, vis[505][505], ans[505][505], c, t, h, sum;
char a[505][5005];
bool valid(int x, int y) {
if (x < 1 || x > n || y < 1 || y > m) return 0;
return 1;
}
void dfs(int i, int j) {
if (c == sum) return;
vis[i][j] = 1;
c++;
ans[i][j] = t;
for (int k = 0; k < 4; k++) {
if (vis[i + x4[k]][j + y4[k]] == 0 && a[i + x4[k]][j + y4[k]] != '#' &&
valid(i + x4[k], j + y4[k]))
dfs(i + x4[k], j + y4[k]);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '#') sum++;
}
}
sum = n * m - sum - k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == '.') {
c = 0;
t++;
dfs(i, j);
if (c == sum) {
h = 1;
break;
}
}
}
if (h == 1) break;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (ans[i][j] != t && a[i][j] != '#') a[i][j] = 'X';
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << a[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int moves[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int elements;
int k;
int tot;
bool isPossible(int i, int j, int n, int m) {
if (i >= 0 && i < n && j >= 0 && j < m) return true;
return false;
}
void DFS(int i, int j, vector<string> &maze, vector<vector<bool>> &visited) {
if (elements == tot - k) {
return;
}
elements++;
int n = maze.size();
int m = maze[0].size();
visited[i][j] = true;
for (int k = 0; k < 4; k++) {
int newi = i + moves[k][0];
int newj = j + moves[k][1];
if (isPossible(newi, newj, n, m) && !visited[newi][newj] &&
maze[newi][newj] == '.') {
DFS(newi, newj, maze, visited);
}
}
return;
}
int main() {
int n, m;
cin >> n >> m >> k;
elements = 0;
vector<string> maze(n);
vector<vector<bool>> visited(n, vector<bool>(m, false));
for (int i = 0; i < n; i++) cin >> maze[i];
tot = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (maze[i][j] == '.') {
tot++;
}
}
}
for (int i = 0; i < n; i++) {
bool isFound = true;
for (int j = 0; j < m; j++) {
if (maze[i][j] == '.' && !visited[i][j]) {
DFS(i, j, maze, visited);
if (elements == tot - k) {
isFound = false;
break;
}
}
}
if (!isFound) break;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (maze[i][j] == '.' && !visited[i][j]) maze[i][j] = 'X';
}
}
cout << endl;
for (int i = 0; i < n; i++) cout << maze[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, ti, c, s, k;
int brr[550][550];
char arr[550][550];
void way(long long x, long long y) {
if ((1 <= x) && (x <= n) && (1 <= y) && (y <= m) && (arr[x][y] == '.') &&
(brr[x][y] != ti)) {
brr[x][y] = ti;
c++;
if ((ti == 1) || (c < s - k)) way(x + 1, y);
if ((ti == 1) || (c < s - k)) way(x - 1, y);
if ((ti == 1) || (c < s - k)) way(x, y + 1);
if ((ti == 1) || (c < s - k)) way(x, y - 1);
}
}
int main() {
long long i, a, x, y;
cin >> n >> m >> k;
x = -1;
for (i = 1; i <= n; i++) {
for (a = 1; a <= m; a++) {
cin >> arr[i][a];
if ((x == -1) && (arr[i][a] == '.')) {
x = i;
y = a;
}
}
}
ti++;
c = 0;
way(x, y);
s = c;
ti++;
c = 0;
way(x, y);
for (i = 1; i <= n; i++) {
for (a = 1; a <= m; a++) {
if ((brr[i][a] != 2) && (arr[i][a] == '.'))
cout << "X";
else
cout << arr[i][a];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char c[505][505];
int vis[505][505];
int n, m, k, tc, ct;
bool asser(int i, int j) {
if (i >= 0 && i < n && j >= 0 && j < m && c[i][j] == '.' && (!vis[i][j]))
return true;
else
return false;
}
void dfs(int i, int j) {
if (tc - ct <= k) return;
vis[i][j] == 1;
ct++;
c[i][j] = 'm';
if (asser(i - 1, j)) dfs(i - 1, j);
if (asser(i + 1, j)) dfs(i + 1, j);
if (asser(i, j - 1)) dfs(i, j - 1);
if (asser(i, j + 1)) dfs(i, j + 1);
}
int main() {
cin >> n >> m >> k;
tc = 0;
ct = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> c[i][j];
if (c[i][j] == '.') tc++;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (c[i][j] == '.') dfs(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (c[i][j] == 'm')
cout << ".";
else if (c[i][j] == '.')
cout << "X";
else
cout << "#";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double pi = 3.1415926536;
const int oo = (int)1e9;
const long long OO = numeric_limits<long long>::max();
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int di[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dj[] = {1, -1, 0, 0, 1, -1, 1, -1};
int n, m, k;
string arr[501];
bool memo[501][501];
bool check(int i, int j) { return i >= 0 && i < n && j >= 0 && j < m; }
void dfs(int x, int y) {
memo[x][y] = 1;
for (int i = 0; i < 4; i++) {
int idx1 = x + dx[i];
int idx2 = y + dy[i];
if (k && check(idx1, idx2) && arr[idx1][idx2] == '.' && !memo[idx1][idx2])
dfs(idx1, idx2);
}
if (k) {
arr[x][y] = 'X';
k--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> arr[i];
bool flag = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '.') {
flag = true;
dfs(i, j);
break;
}
}
if (flag) break;
}
for (int i = 0; i < n; i++) cout << arr[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, i, j, s, sx, sy, x, y, K;
char mp[505][505];
vector<int> a;
vector<int> b;
int r[4] = {0, 1, 0, -1}, w[4] = {1, 0, -1, 0};
int main() {
scanf("%d%d%d", &n, &m, &K);
for (i = 0; i < n; i++) scanf("%s", &mp[i]);
s = 0;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (mp[i][j] == '.') {
sx = i;
sy = j;
s++;
}
a.push_back(sx);
b.push_back(sy);
mp[sx][sy] = 'X';
k = -1;
while (a.size() < s - K) {
k++;
x = a[k];
y = b[k];
for (i = 0; i < 4; i++) {
if (x + r[i] >= 0 && x + r[i] < n && y + w[i] >= 0 && y + w[i] < m &&
mp[x + r[i]][y + w[i]] == '.') {
a.push_back(x + r[i]);
b.push_back(y + w[i]);
mp[x + r[i]][y + w[i]] = 'X';
}
}
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (mp[i][j] == '.') mp[i][j] = 'X';
for (i = 0; i < s - K; i++) mp[a[i]][b[i]] = '.';
for (i = 0; i < n; i++) printf("%s\n", mp[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1000000];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
int color[1000000], countt = 0, mat[509][509], cell[509][509];
queue<int> Q;
void bfs(int s, int pp) {
int a, d, f, g, h, j, k, l;
Q.push(s);
color[s] = 1;
countt++;
if (countt == pp) return;
while (!Q.empty()) {
d = Q.front();
Q.pop();
for (a = 0; a < adj[d].size(); a++) {
if (color[adj[d][a]] == 0) {
color[adj[d][a]] = 1;
Q.push(adj[d][a]);
countt++;
if (countt == pp) return;
}
}
}
}
int main() {
int a, s, f, g, h, j, k, l, mp = 0, pp, index = 1, d, p = 0, source;
char ch;
cin >> a >> s >> d;
for (f = 1; f <= a; f++) {
for (g = 1; g <= s; g++) {
color[index] = 0;
cin >> ch;
if (p == 0 && ch == '.') {
source = index;
p = 1;
}
if (ch == '.') {
mat[f][g] = 1;
mp++;
} else
mat[f][g] = 0;
cell[f][g] = index;
index++;
}
}
for (f = 1; f <= a; f++) {
for (g = 1; g <= s; g++) {
if (mat[f][g]) {
for (h = 0; h < 4; h++) {
if (f + dx[h] >= 1 && f + dx[h] <= a && g + dy[h] >= 1 &&
g + dy[h] <= s) {
if (mat[f + dx[h]][g + dy[h]]) {
j = cell[f][g];
k = cell[f + dx[h]][g + dy[h]];
adj[j].push_back(k);
adj[k].push_back(j);
}
}
}
}
}
}
pp = mp - d;
bfs(source, pp);
index = 1;
for (f = 1; f <= a; f++) {
for (g = 1; g <= s; g++) {
if (mat[f][g] == 0)
cout << "#";
else {
if (color[index] == 1)
cout << ".";
else
cout << "X";
}
index++;
}
cout << endl;
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const int MOD = 1e9 + 7;
const int MX = 2e5 + 5;
const int INF = 1e9 + 5;
struct hash_pair {
template <class T1, class T2>
size_t operator()(const pair<T1, T2>& p) const {
auto hash1 = hash<T1>{}(p.first);
auto hash2 = hash<T2>{}(p.second);
return hash1 ^ hash2;
}
};
long long gcd(long long a, long long b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
long long comb(long long a, long long b) {
long long x = max(a - b, b), ans = 1;
for (long long K = a, L = 1; K >= x + 1; K--, L++) {
ans *= K;
ans /= L;
}
return ans;
}
void task() {
int n, m, k, cnt = 0, ans = 0;
cin >> n >> m >> k;
string s[n];
for (int K = 0; K < n; K++) cin >> s[K];
for (int K = 0; K < n; K++) {
for (int L = 0; L < m; L++) {
if (s[K][L] == '.') cnt++;
}
}
vector<vector<bool> > vis(n, vector<bool>(m));
for (int K = 0; K < n; K++) {
for (int L = 0; L < m; L++) {
if (s[K][L] == '.') {
queue<pair<int, int> > q;
q.push(make_pair(K, L));
pair<int, int> u;
while (!q.empty()) {
u = q.front();
q.pop();
if (vis[u.first][u.second]) continue;
vis[u.first][u.second] = 1;
ans++;
if (ans == cnt - k) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.' && !vis[i][j]) s[i][j] = 'X';
}
}
for (int i = 0; i < n; i++) cout << s[i] << "\n";
return;
}
if (u.first > 0 && s[u.first - 1][u.second] == '.' &&
!vis[u.first - 1][u.second]) {
q.push(make_pair(u.first - 1, u.second));
}
if (u.second > 0 && s[u.first][u.second - 1] == '.' &&
!vis[u.first][u.second - 1]) {
q.push(make_pair(u.first, u.second - 1));
}
if (u.first < n - 1 && s[u.first + 1][u.second] == '.' &&
!vis[u.first + 1][u.second]) {
q.push(make_pair(u.first + 1, u.second));
}
if (u.second < m - 1 && s[u.first][u.second + 1] == '.' &&
!vis[u.first][u.second + 1]) {
q.push(make_pair(u.first, u.second + 1));
}
}
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
task();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k = 0;
int isCorrect(int x, int y, int n, int m) {
if (x < 0 || y < 0 || x >= n || y >= m) return (0);
return (1);
}
void dfs(int x, int y, char A[500][500], bool visited[500][500], int n, int m,
pair<int, int> parent[500][500], int child[500][500]) {
visited[x][y] = true;
if (isCorrect(x, y - 1, n, m)) {
if (A[x][y - 1] != '#' && !visited[x][y - 1]) {
parent[x][y - 1] = make_pair(x, y);
++child[x][y];
dfs(x, y - 1, A, visited, n, m, parent, child);
}
}
if (isCorrect(x, y + 1, n, m)) {
if (A[x][y + 1] != '#' && !visited[x][y + 1]) {
parent[x][y + 1] = make_pair(x, y);
++child[x][y];
dfs(x, y + 1, A, visited, n, m, parent, child);
}
}
if (isCorrect(x - 1, y, n, m)) {
if (A[x - 1][y] != '#' && !visited[x - 1][y]) {
parent[x - 1][y] = make_pair(x, y);
++child[x][y];
dfs(x - 1, y, A, visited, n, m, parent, child);
}
}
if (isCorrect(x + 1, y, n, m)) {
if (A[x + 1][y] != '#' && !visited[x + 1][y]) {
parent[x + 1][y] = make_pair(x, y);
++child[x][y];
dfs(x + 1, y, A, visited, n, m, parent, child);
}
}
if (child[x][y] == 0 && k > 0) {
--child[parent[x][y].first][parent[x][y].second];
A[x][y] = 'X';
--k;
}
}
int main() {
int n, m;
cin >> n >> m >> k;
char A[500][500];
pair<int, int> parent[500][500];
int child[500][500];
bool visited[500][500];
int x, y;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> A[i][j];
if (A[i][j] == '.') {
x = i;
y = j;
}
visited[i][j] = false;
parent[i][j] = make_pair(i, j);
child[i][j] = 0;
}
}
dfs(x, y, A, visited, n, m, parent, child);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << A[i][j];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int h[4] = {0, 0, 1, -1}, v[4] = {1, -1, 0, 0};
int n, m, k;
vector<string> adj;
array<int, 2> find() {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (adj[i][j] == '.') {
return {i, j};
}
}
}
return {0, 0};
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
adj.push_back(s);
}
int size = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (adj[i][j] == '.') size++;
}
}
array<int, 2> points = find();
queue<array<int, 2>> q;
vector<vector<int>> processed(n, vector<int>(m));
q.push({points[0], points[1]});
while (size - k > 0) {
int i = q.front()[0];
int j = q.front()[1];
q.pop();
if (processed[i][j]) continue;
processed[i][j] = 1;
size--;
for (int k = 0; k < 4; k++) {
int ai = i + h[k];
int aj = j + v[k];
if (ai >= 0 && ai < n && aj >= 0 && aj < m) {
if (adj[ai][aj] == '.') q.push({ai, aj});
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (adj[i][j] == '.' && !processed[i][j]) adj[i][j] = 'X';
cout << adj[i][j];
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long cnt;
long long tot;
long long k;
long long n, m;
bool visited[501][501];
string s[501];
bool isValid(long long a, long long b) {
if (a >= 0 && a < n && b >= 0 && b < m) return 1;
return 0;
}
void dfs(long long x, long long y) {
if (cnt >= tot - k) return;
if (visited[x][y]) return;
cnt++;
visited[x][y] = 1;
if (cnt == tot - k) return;
if (isValid(x - 1, y) && !visited[x - 1][y]) {
dfs(x - 1, y);
}
if (isValid(x + 1, y) && !visited[x + 1][y]) {
dfs(x + 1, y);
}
if (isValid(x, y - 1) && !visited[x][y - 1]) {
dfs(x, y - 1);
}
if (isValid(x, y + 1) && !visited[x][y + 1]) {
dfs(x, y + 1);
}
}
int main() {
bool f = 0;
cnt = 0;
tot = 0;
cin >> n >> m >> k;
memset(visited, 0, sizeof(visited));
for (long long i = 0; i < n; i++) {
cin >> s[i];
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (s[i][j] == '#')
visited[i][j] = 1;
else
tot++;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (!visited[i][j]) {
f = 1;
dfs(i, j);
break;
}
}
if (f) break;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!visited[i][j]) {
s[i][j] = 'X';
}
cout << s[i][j];
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mp;
int n, m, k, cnt;
vector<string> G;
bool valid(int i, int j) { return i >= 0 && i < n && j >= 0 && j < m; }
void getAdjacent(pair<int, int> newv, vector<pair<int, int> > &vi) {
int i = newv.first, j = newv.second;
for (int k = -1; k <= 1; k++) {
for (int l = -1; l <= 1; l++) {
if (abs(k + l) == 1 && valid(i + k, j + l) && G[i + k][j + l] == '.') {
vi.push_back(make_pair(i + k, j + l));
}
}
}
}
void BFS(pair<int, int> source) {
int vis = 0;
mp.clear();
mp[(source)] = 0;
queue<pair<int, int> > Q;
Q.push(source);
while (Q.size() != 0) {
pair<int, int> newv = Q.front();
Q.pop();
vis++;
if (cnt - vis < k) {
G[newv.first][newv.second] = 'X';
}
vector<pair<int, int> > vvi;
getAdjacent(newv, vvi);
for (int i = 0; i < vvi.size(); i++) {
if (mp.count((vvi[i])) == 0) {
mp[(vvi[i])] = mp[newv] + 1;
Q.push(vvi[i]);
}
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
G.push_back(s);
}
cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (G[i][j] == '.') cnt++;
bool didBFS = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (G[i][j] == '.') {
BFS(make_pair(i, j));
didBFS = true;
break;
}
}
if (didBFS) break;
}
for (int i = 0; i < n; i++) {
cout << G[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 4 * atan((long double)1);
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long llinf = 1e18;
const long long nax = 0;
int n, m, k;
bool vis[505][505];
char arr[505][505];
int row[] = {1, 0, -1, 0};
int col[] = {0, 1, 0, -1};
bool memenuhi(int x, int y) {
return (!(vis[x][y]) && (x >= 0) && (x < n) && (y >= 0) && (y < m) &&
(arr[x][y] == '.'));
}
void dfs(int x, int y) {
if (!k) return;
vis[x][y] = 1;
for (int i = 0; i < 4; ++i) {
int baris = row[i] + x;
int kolom = col[i] + y;
if (memenuhi(baris, kolom)) {
dfs(baris, kolom);
}
}
if (k) {
arr[x][y] = 'X';
k--;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (!k) goto sini;
if (arr[i][j] == '.') {
dfs(i, j);
}
}
}
sini:;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << arr[i][j];
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool cmp(pair<int, int> p1, pair<int, int> p2) { return p1.second < p2.second; }
char grid[507][507];
int vis[507][507];
int m, n, k;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool ok(int x, int y) {
return x >= 0 && x < n && y >= 0 && y < m && grid[x][y] == '.';
}
void dfs(int x, int y) {
vis[x][y] = 1;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (ok(nx, ny) && !vis[nx][ny]) dfs(nx, ny);
}
if (k) grid[x][y] = 'X', k--;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> grid[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!vis[i][j] && grid[i][j] == '.') dfs(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << grid[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) res += ", ";
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) res += static_cast<char>('0' + v[i]);
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) res += ", ";
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << to_string(H);
debug_out(T...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
vector<vector<char>> a(n, vector<char>(m));
vector<vector<int>> mark(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
if (a[i][j] == '#') {
mark[i][j] = 1;
}
}
}
int cnt = 0;
function<void(int, int)> Solve = [&](int i, int j) {
if (mark[i][j]) {
return;
}
mark[i][j] = 1;
for (int x = max(0, i - 1); x <= min(n - 1, i + 1); ++x) {
for (int y = max(0, j - 1); y <= min(m - 1, j + 1); ++y) {
if (i == x || j == y) {
;
Solve(x, y);
}
}
}
assert(cnt <= k);
assert(a[i][j] == '.');
if (cnt == k) {
return;
}
a[i][j] = 'X';
cnt++;
};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
Solve(i, j);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << a[i][j];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, s, num;
const int h[4] = {1, 0, -1, 0};
const int v[4] = {0, 1, 0, -1};
char maze[505][505];
int mark[505][505];
int nei(int x, int y) {
int ans = 0;
for (int i = 0; i < 4; i++)
if (x + h[i] > -1 && x + h[i] < n && y + v[i] > -1 && y + v[i] < m)
if (!mark[x + h[i]][y + v[i]]) ++ans;
return ans;
}
void dfs(int x, int y) {
if (num == s - k) return;
++num;
mark[x][y] = 2;
for (int i = 0; i < 4; i++)
if (x + h[i] > -1 && x + h[i] < n && y + v[i] > -1 && y + v[i] < m)
if (!mark[x + h[i]][y + v[i]]) dfs(x + h[i], y + v[i]);
}
int main() {
int dx = 0, dy = 0;
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> maze[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (maze[i][j] == '#') mark[i][j] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (maze[i][j] == '.') {
dx = i;
dy = j;
++s;
}
dfs(dx, dy);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mark[i][j] == 2)
cout << '.';
else if (mark[i][j] == 1)
cout << '#';
else
cout << 'X';
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x;
int y;
};
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<string> g;
g.reserve(n);
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
g.push_back(s);
}
int i0 = -1;
int j0 = -1;
bool search = true;
int c = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (search && g[i][j] == '.') {
i0 = i;
j0 = j;
search = false;
}
c += (g[i][j] == '.');
}
int d = c - k;
c = 0;
vector<vector<bool> > visited(n, vector<bool>(m, false));
stack<Point> s;
s.push(Point{i0, j0});
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
while (!s.empty()) {
Point p = s.top();
s.pop();
if (visited[p.x][p.y]) continue;
visited[p.x][p.y] = true;
++c;
if (c > d) g[p.x][p.y] = 'X';
for (int i = 0; i < 4; ++i) {
int xx = p.x + dx[i];
int yy = p.y + dy[i];
if (xx >= 0 && xx < n && yy >= 0 && yy < m && !visited[xx][yy] &&
g[xx][yy] == '.')
s.push(Point{xx, yy});
}
}
for (int i = 0; i < n; ++i) cout << g[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void init() {
cin.tie(0);
cout.tie(0);
std::ios::sync_with_stdio(false);
}
const int dx[4] = {-1, 0, 0, 1};
const int dy[4] = {0, -1, 1, 0};
int n, m, k;
char grid[505][505];
bool vis[505][505];
void dfs(int x, int y) {
if (x < 1 || x > n || y < 1 || y > m) return;
if (vis[x][y] || grid[x][y] == '#') return;
vis[x][y] = true;
for (int i = 0; i < 4; ++i) {
dfs(x + dx[i], y + dy[i]);
}
if (k > 0) {
k--;
grid[x][y] = 'X';
}
}
int main() {
init();
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> grid[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (grid[i][j] == '.') dfs(i, j);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) cout << grid[i][j];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const MOD = 1000000007;
const int M = 2e5 + 10;
vector<pair<long long, long long> > v1[M + 10];
vector<long long> v[M + 10];
long long n, m, k;
char ara[1000][1000];
bool vis[1000][1000];
long long cost[M + 1];
long long mx = 0;
long long p1 = 0, p2 = 0;
void input() {
cin >> n >> m >> k;
long long dot = 0;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> ara[i][j];
if (ara[i][j] == '.' && dot == 0) {
p1 = i;
p2 = j;
dot = 1;
}
}
}
}
void DFS(long long i, long long j) {
if (i < 0 || j < 0 || i >= n || j >= m || ara[i][j] == '#' ||
vis[i][j] == true)
return;
vis[i][j] = true;
DFS(i, j + 1);
DFS(i, j - 1);
DFS(i + 1, j);
DFS(i - 1, j);
if (k > 0) {
k--;
ara[i][j] = 'X';
}
}
int main() {
(ios_base::sync_with_stdio(false), cin.tie(NULL));
input();
DFS(p1, p2);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cout << ara[i][j];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long POS(long long x) {
if (x > 0)
return x;
else
return 0;
}
struct shvm {
long double z, y, x;
shvm() {}
shvm(long double z, long double y, long double x) : z(z), y(y), x(x) {}
shvm operator+(const shvm &p) const {
return shvm(z + p.z, y + p.y, x + p.x);
}
shvm operator-(const shvm &p) const {
return shvm(z - p.z, y - p.y, x - p.x);
}
shvm operator*(long double con) const {
return shvm(z * con, y * con, x * con);
}
shvm operator/(long double con) const {
return shvm(z / con, y / con, x / con);
}
bool operator<(const shvm &rhs) const {
return make_pair(z, make_pair(y, x)) <
make_pair(rhs.z, make_pair(rhs.y, rhs.x));
}
bool operator==(const shvm &rhs) const {
return make_pair(z, make_pair(y, x)) ==
make_pair(rhs.z, make_pair(rhs.y, rhs.x));
}
};
const bool testing = true;
int n, m, k;
int cn = 0;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
int vis[510][510];
void dfs(vector<string> &ma, int i, int j) {
if (cn >= k) return;
vis[i][j] = 1;
for (int l = 0; l < 4; l++) {
int x = i + dx[l];
int y = j + dy[l];
if ((x >= 0 && x < n) && (y >= 0 && y < m) && vis[x][y] == 0 &&
ma[x][y] == '.') {
dfs(ma, x, y);
if (cn >= k) return;
cn++;
vis[x][y] = 0;
ma[x][y] = 'X';
}
}
}
void program() {
cin >> n >> m >> k;
string temp;
vector<string> ma;
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) {
cin >> temp;
ma.push_back(temp);
}
int cnt = 0;
cn = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ma[i][j] == '.') {
dfs(ma, i, j);
if (cn >= k) break;
}
}
if (cn >= k) break;
}
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) {
cout << ma[i][j];
}
cout << endl;
}
}
int main() {
if (testing) {
program();
return 0;
}
FILE *fin = NULL;
fin = fopen("in.txt", "w+");
fprintf(fin, "3 4 2\n#..#\n..#.\n#...\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(1) => expected : \n");
printf("#.X#\nX.#.\n#...\n");
printf("test case(1) => founded : \n");
program();
fin = fopen("in.txt", "w+");
fprintf(fin, "5 4 5\n#...\n#.#.\n.#..\n...#\n.#.#\n");
fclose(fin);
freopen("in.txt", "r", stdin);
printf("test case(2) => expected : \n");
printf("#XXX\n#X#.\nX#..\n...#\n.#.#\n");
printf("test case(2) => founded : \n");
program();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ct1, n, m, k, ct;
bool visited[501][501];
void dfs(int i, int j, vector<string>& a) {
if (i < 0 || j < 0 || i >= n || j >= m || ct1 == ct || a[i][j] == '#' ||
visited[i][j])
return;
visited[i][j] = true;
ct1++;
dfs(i - 1, j, a);
dfs(i + 1, j, a);
dfs(i, j - 1, a);
dfs(i, j + 1, a);
}
void solve() {
cin >> n >> m >> k;
ct = 0;
vector<string> a;
int x = -1, y = -1;
string s;
ct = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) visited[i][j] = false;
for (int i = 0; i < n; i++) {
cin >> s;
a.push_back(s);
for (int j = 0; j < m; j++) {
if (a[i][j] == '.') {
x = i;
y = j;
ct++;
}
}
}
ct = ct - k;
ct1 = 0;
dfs(x, y, a);
ct1 = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!visited[i][j] and a[i][j] == '.' and ct1 < k) {
a[i][j] = 'X';
ct1++;
}
}
cout << a[i] << endl;
}
}
int main() {
int t;
t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
char maze[501][501];
long long dx[] = {0, 0, -1, 1};
long long dy[] = {1, -1, 0, 0};
long long visited[501][501];
long long dotCount, nodesVisited;
bool isValid(long long x, long long y) {
if (x >= 0 && y >= 0 && x < n && y < m) {
return true;
}
return false;
}
void bfs(long long i, long long j) {
visited[i][j] = 1;
nodesVisited++;
if (nodesVisited == dotCount - k) {
return;
}
for (long long l = 0; l < 4; l++) {
if (isValid(i + dx[l], j + dy[l]) && !visited[i + dx[l]][j + dy[l]] &&
maze[i + dx[l]][j + dy[l]] == '.' && nodesVisited < dotCount - k) {
bfs(i + dx[l], j + dy[l]);
}
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string str;
vector<long long> availX;
vector<long long> availY;
cin >> n >> m >> k;
long long startX, startY;
for (long long i = 0; i < n; i++) {
cin >> str;
for (long long j = 0; j < str.length(); j++) {
maze[i][j] = str[j];
if (maze[i][j] == '.') {
dotCount++;
startX = i;
startY = j;
}
}
}
bfs(startX, startY);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (maze[i][j] == '.' && !visited[i][j]) {
maze[i][j] = 'X';
}
cout << maze[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dir[] = {-1, 0, 1, 0, -1};
void dfs(vector<vector<char>> &grid, int &cnt, int r, int c, int rows,
int cols) {
if (cnt <= 0) return;
grid[r][c] = 'V';
cnt--;
for (int i = 0; i < 4; i++) {
int row = r + dir[i];
int col = c + dir[i + 1];
if (row >= 0 && row < rows && col >= 0 && col < cols &&
grid[row][col] == '.')
dfs(grid, cnt, row, col, rows, cols);
}
return;
}
int main() {
int rows, cols, k, e = 0, r, c;
string s;
cin >> rows >> cols >> k;
vector<vector<char>> grid(rows, vector<char>(cols));
for (int i = 0; i < rows; i++) {
cin >> s;
for (int j = 0; j < cols; j++) {
grid[i][j] = s[j];
if (s[j] == '.') {
r = i;
c = j;
e++;
}
}
}
int cnt = e - k;
dfs(grid, cnt, r, c, rows, cols);
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (grid[i][j] == 'V')
printf(".");
else if (grid[i][j] == '.')
printf("X");
else
printf("%c", grid[i][j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char mp[512][512];
bool vis[512][512];
int n, m, k;
void dfs(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m) return;
if (mp[x][y] != '.') return;
if (vis[x][y]) return;
vis[x][y] = true;
dfs(x + 1, y);
dfs(x - 1, y);
dfs(x, y + 1);
dfs(x, y - 1);
if (k) mp[x][y] = 'X', k--;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
for (int i = 0; i < n && k; i++) {
for (int j = 0; j < m && k; j++) {
dfs(i, j);
}
}
for (int i = 0; i < n; i++) puts(mp[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const double PI = 2 * acos(0.0);
string ab[505];
bool visit[505][505] = {{false}};
int dx[] = {0, -1, 0, 1};
int dy[] = {-1, 0, 1, 0};
int n, m, k;
int cnt;
void dfs(int i, int j) {
if (i >= 0 && j >= 0 && i < n && j < m && ab[i][j] != '#' && !visit[i][j]) {
visit[i][j] = true;
if (cnt > 0) {
ab[i][j] = 'C';
cnt--;
} else
return;
for (int m = 0; m < 4; m++) {
dfs(i + dx[m], j + dy[m]);
}
} else
return;
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &k);
int a, b;
char ar;
cnt = 0;
for (int i = 0; i < n; i++) {
cin >> ab[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ab[i][j] == '.') {
a = i;
b = j;
cnt++;
}
}
}
cnt = cnt - k;
dfs(a, b);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ab[i][j] == 'C')
cout << ".";
else if (ab[i][j] == '.') {
if (k > 0)
cout << "X", k--;
else
cout << ".";
} else
cout << "#";
}
printf("\n");
;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int nMax = 510;
struct Node {
int x, y;
};
queue<Node> q;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int v[nMax][nMax];
int n, m, k;
char s[nMax];
int total;
void bfs(int x, int y) {
while (!q.empty()) q.pop();
Node cc;
cc.x = x;
cc.y = y;
v[x][y] = 2;
q.push(cc);
int cmp = 0;
while (!q.empty()) {
Node cur = q.front();
q.pop();
Node temp;
for (int i = 0; i < 4; i++) {
int tempx = cur.x + dx[i], tempy = cur.y + dy[i];
if (tempx >= 1 && tempx <= n && tempy >= 1 && tempy <= m &&
v[tempx][tempy] == 1 && cmp < total - k - 1) {
v[tempx][tempy] = 2;
temp.x = tempx, temp.y = tempy;
cmp++;
q.push(temp);
}
if (cmp == total - k - 1) break;
}
if (cmp == total - k - 1) break;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
getchar();
total = 0;
for (int i = 1; i <= n; i++) {
gets(s);
for (int j = 0; j < m; j++) {
if (s[j] == '.') {
v[i][j + 1] = 1;
total++;
} else
v[i][j + 1] = 0;
}
}
int flag = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (v[i][j]) {
flag = 1;
bfs(i, j);
break;
}
}
if (flag) break;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (v[i][j] == 2)
putchar('.');
else if (v[i][j] == 1)
putchar('X');
else
putchar('#');
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e2 + 5;
int n, m;
char g[MAXN][MAXN];
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
int used[MAXN][MAXN];
bool vis[MAXN][MAXN];
int sx, sy;
bool op = 0;
int cnt = 0;
void dfs(int x, int y) {
if (op) return;
if (x < 0 | y < 0 || x >= n || y >= m || g[x][y] != '.' || vis[x][y]) return;
if (cnt == 0) {
op = 1;
return;
}
--cnt;
vis[x][y] = 1;
used[x][y] = 1;
for (int i = 0; i < 4; i++) {
if (op) break;
int nx = dx[i] + x;
int ny = dy[i] + y;
dfs(nx, ny);
}
}
char print(int x) {
if (x == 2)
return '#';
else if (x == 1)
return '.';
else
return 'X';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k;
cin >> n >> m >> k;
sx = sy = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> g[i][j];
if (g[i][j] == '#') used[i][j] = 2;
if (g[i][j] == '.') {
sx = i;
sy = j;
++cnt;
}
}
cnt -= k;
dfs(sx, sy);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << print(used[i][j]);
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, snum;
vector<vector<char> > temp;
int x[] = {-1, 0, 1, 0};
int y[] = {0, 1, 0, -1};
void dfs(int i, int j) {
int count = 0;
queue<pair<int, int> > s;
pair<int, int> tempPair;
tempPair.first = i;
tempPair.second = j;
s.push(tempPair);
int makeBlack = ((snum - k) == 0) ? 0 : 1;
vector<vector<int> > isVisited;
isVisited.resize(n);
for (int i = 0; i < n; i++) isVisited[i].resize(m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) isVisited[i][j] = 0;
while (s.size() > 0) {
int flag = 0;
tempPair = s.front();
s.pop();
if (isVisited[tempPair.first][tempPair.second]) continue;
count++;
isVisited[tempPair.first][tempPair.second] = 1;
if (count > snum - k) temp[tempPair.first][tempPair.second] = 'X';
for (int j = 0; j < 4; j++) {
int nextRow, nextCol;
nextRow = tempPair.first + y[j];
nextCol = tempPair.second + x[j];
if (((nextRow) >= 0) && ((nextRow) < n) && ((nextCol) >= 0) &&
((nextCol) < m)) {
if (isVisited[nextRow][nextCol])
continue;
else if (temp[nextRow][nextCol] == '.') {
s.push(pair<int, int>(nextRow, nextCol));
flag = 1;
}
}
}
}
}
int main() {
cin >> n >> m >> k;
snum = 0;
temp.resize(n);
for (int i = 0; i < n; i++) temp[i].resize(m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> temp[i][j];
if (temp[i][j] == '.') {
snum++;
}
}
int flag = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (temp[i][j] == '.') {
dfs(i, j);
flag = 1;
break;
}
}
if (flag == 1) break;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << temp[i][j];
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
char **arr;
struct pos {
int i;
int j;
pos(int token_i, int token_j) {
i = token_i;
j = token_j;
}
} cur_pos(-1, -1);
int finded_points = 0;
void Walking(pos &cur_pos, int n, int m, int need_points) {
if (finded_points == need_points) return;
arr[cur_pos.i][cur_pos.j] = 'v';
finded_points++;
if (finded_points == need_points) return;
if (cur_pos.j != m - 1) {
if (arr[cur_pos.i][cur_pos.j + 1] == '.') {
pos *a = new pos(cur_pos.i, cur_pos.j + 1);
Walking(*a, n, m, need_points);
delete a;
if (finded_points == need_points) return;
}
}
if (cur_pos.j != 0) {
if (arr[cur_pos.i][cur_pos.j - 1] == '.') {
pos *a = new pos(cur_pos.i, cur_pos.j - 1);
Walking(*a, n, m, need_points);
delete a;
if (finded_points == need_points) return;
}
}
if (cur_pos.i != n - 1) {
if (arr[cur_pos.i + 1][cur_pos.j] == '.') {
pos *a = new pos(cur_pos.i + 1, cur_pos.j);
Walking(*a, n, m, need_points);
delete a;
if (finded_points == need_points) return;
}
}
if (cur_pos.i != 0) {
if (arr[cur_pos.i - 1][cur_pos.j] == '.') {
pos *a = new pos(cur_pos.i - 1, cur_pos.j);
Walking(*a, n, m, need_points);
delete a;
if (finded_points == need_points) return;
}
}
return;
}
int main() {
int n, m, k;
std::cin >> n >> m >> k;
arr = new char *[n];
for (int i = 0; i < n; i++) arr[i] = new char[m + 1];
for (int i = 0; i < n; i++) {
std::cin >> arr[i];
}
if (k == 0) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
std::cout << arr[i][j];
}
std::cout << std::endl;
}
return 0;
}
int points = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == '.') {
if (cur_pos.i == -1 && cur_pos.j == -1) {
cur_pos.i = i;
cur_pos.j = j;
}
points++;
}
}
}
int need_points = points - k;
Walking(cur_pos, n, m, need_points);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (arr[i][j] == 'v')
std::cout << '.';
else if (arr[i][j] == '.')
std::cout << 'X';
else
std::cout << arr[i][j];
}
std::cout << std::endl;
}
delete[] arr;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tag[505][505];
char maze[505][505];
int dot, n, m, k;
int bfs(int u, int v) {
queue<int> Q;
Q.push(u);
Q.push(v);
tag[u][v] = 1;
int count = 1;
while (!Q.empty() && count < dot - k) {
int a = Q.front();
Q.pop();
int b = Q.front();
Q.pop();
if (a + 1 < n && !tag[a + 1][b] && maze[a + 1][b] == '.') {
Q.push(a + 1);
Q.push(b);
tag[a + 1][b] = 1;
count++;
if (count == dot - k) break;
}
if (a - 1 >= 0 && !tag[a - 1][b] && maze[a - 1][b] == '.') {
Q.push(a - 1);
Q.push(b);
tag[a - 1][b] = 1;
count++;
if (count == dot - k) break;
}
if (b + 1 < m && !tag[a][b + 1] && maze[a][b + 1] == '.') {
Q.push(a);
Q.push(b + 1);
tag[a][b + 1] = 1;
count++;
if (count == dot - k) break;
}
if (b - 1 >= 0 && !tag[a][b - 1] && maze[a][b - 1] == '.') {
Q.push(a);
Q.push(b - 1);
tag[a][b - 1] = 1;
count++;
if (count == dot - k) break;
}
}
if (count < dot - k) memset(tag, 0, sizeof tag);
return count;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> maze[i][j];
}
dot = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (maze[i][j] == '.') dot++;
}
}
int x;
memset(tag, 0, sizeof tag);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (maze[i][j] == '.' && !tag[i][j]) {
x = bfs(i, j);
}
if (x == dot - k) break;
}
if (x == dot - k) break;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (tag[i][j] == 0 && maze[i][j] == '.')
printf("X");
else
printf("%c", maze[i][j]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
string s[501];
int vis[501][501];
void dfs(int a, int b) {
vis[a][b] = 1;
for (int i = 0; i < 4; i++) {
int x = a + dx[i], y = b + dy[i];
if (x >= 0 && x < n && y >= 0 && y < m && s[x][y] == '.' && vis[x][y] == 0)
dfs(x, y);
}
if (k > 0) {
s[a][b] = 'X';
k--;
}
return;
}
int main() {
cin >> n >> m >> k;
int a = -1, b = -1;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == '.' && a == -1) {
a = i;
b = j;
}
}
}
dfs(a, b);
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, n, H[1005][1005], m, k, s;
char arr[1005][1005];
int t, adim;
void dfs(int i, int j) {
if (i < 1 or i > n or j < 1 or j > m or H[i][j]) return;
H[i][j] = 1;
if (arr[i + 1][j] == '.') dfs(i + 1, j);
if (arr[i - 1][j] == '.') dfs(i - 1, j);
if (arr[i][j + 1] == '.') dfs(i, j + 1);
if (arr[i][j - 1] == '.') dfs(i, j - 1);
if (adim < k) {
arr[i][j] = 'X';
adim++;
}
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf(" %c", &arr[i][j]);
for (i = 1; !t and i <= n; i++)
for (j = 1; !t and j <= m; j++)
if (arr[i][j] == '.') dfs(i, j), t = 1;
for (i = 1; i <= n; i++, puts(""))
for (j = 1; j <= m; j++) printf("%c", arr[i][j]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[505][505] = {{0}};
int n, m, k;
string s[505];
void dfs(int i, int j) {
if (v[i][j] || s[i][j] == '#') return;
v[i][j] = 1;
dfs(i - 1, j);
dfs(i, j - 1);
dfs(i + 1, j);
dfs(i, j + 1);
if (k > 0) {
s[i][j] = 'X';
k--;
} else
return;
}
int main() {
cin >> n >> m >> k;
s[0] = "";
s[n + 1] = "";
for (int i = 0; i <= m; i++) {
s[0] += "#";
s[n + 1] += "#";
}
for (int i = 1; i <= n; i++) {
cin >> s[i];
s[i] = "#" + s[i] + "#";
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (!v[i][j] && s[i][j] == '.') dfs(i, j);
}
}
for (int i = 1; i <= n; i++) cout << s[i].substr(1, m) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e+9;
int n, m, k;
int x[5] = {-1, 0, 0, 1};
int y[5] = {0, -1, 1, 0};
bool q[501][501];
char a[501][501];
bool check(int i, int j) {
if (0 <= i && i < n && 0 <= j && j < m && a[i][j] == '.') return 1;
return 0;
}
bool dfs(int i, int j) {
int x2, y2, u = 0;
q[i][j] = 1;
for (int w = 0; w < 4; w++) {
x2 = i + x[w];
y2 = j + y[w];
if (!q[x2][y2] && check(x2, y2)) {
u++;
if (dfs(x2, y2)) u--;
}
}
if (k > 0 && !u) {
a[i][j] = 'X';
k--;
return 1;
}
return 0;
}
int main() {
int x, y;
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == '.') {
x = i;
y = j;
}
}
dfs(x, y);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << a[i][j];
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 505;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
int n, m, k, s, DONE, lg;
bool used[MAX_N][MAX_N];
string A[MAX_N];
bool inRange(int x, int y) {
if (x >= 0 && x < n && y >= 0 && y < m) return true;
return false;
}
void dfs(int i, int j) {
used[i][j] = 1;
lg++;
if (lg == s - k) {
DONE = 1;
return;
} else {
for (int dir = 0; dir < 4 && !DONE; dir++) {
int x = i + dx[dir];
int y = j + dy[dir];
if (!inRange(x, y)) continue;
if (A[x][y] == '.' && !used[x][y] && !DONE) dfs(x, y);
}
}
}
int main() {
int i, j;
cin >> n >> m >> k;
for (i = 0; i < n; i++) cin >> A[i];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (A[i][j] == '.') s++;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (A[i][j] == '.') {
dfs(i, j);
i = n;
j = m;
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++)
if (A[i][j] == '.' && !used[i][j])
cout << 'X';
else
cout << A[i][j];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
const double PI = acos(-1.0);
const double e = exp(1.0);
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline T Min(T a, T b) {
return a < b ? a : b;
}
template <class T>
inline T Max(T a, T b) {
return a > b ? a : b;
}
bool cmpbig(int a, int b) { return a > b; }
bool cmpsmall(int a, int b) { return a < b; }
using namespace std;
char mp[512][512];
int vis[512][512];
int n, m, k;
void dfs(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m || mp[x][y] != '.') return;
if (vis[x][y] == 1) return;
vis[x][y] = 1;
dfs(x + 1, y);
dfs(x - 1, y);
dfs(x, y + 1);
dfs(x, y - 1);
if (k) {
mp[x][y] = 'X';
k--;
}
}
int main() {
while (~scanf("%d%d%d", &n, &m, &k)) {
memset(vis, 0, sizeof(vis));
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
for (int i = 0; i < n && k; i++) {
for (int j = 0; j < m && k; j++) {
dfs(i, j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", mp[i][j]);
}
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[510][510];
char str[510][510];
int n, m, s;
vector<pair<int, int> > ord;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
void dfs(int x, int y) {
if (vis[x][y] || str[x][y] == '#') return;
vis[x][y] = 1;
ord.push_back(pair<int, int>(x, y));
for (int a = 0; a < 4; a++) {
int nx = x + dx[a], ny = y + dy[a];
if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;
dfs(nx, ny);
}
}
int main() {
cin >> n >> m >> s;
for (int i = 0; i < n; i++) cin >> str[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (str[i][j] == '.') {
dfs(i, j);
reverse(ord.begin(), ord.end());
for (int k = 0; k < s; k++) str[ord[k].first][ord[k].second] = 'X';
for (int k = 0; k < n; k++) cout << str[k] << "\n";
return 0;
}
}
}
}
|
#include <bits/stdc++.h>
int CMP(const void *a, const void *b) { return (*(int *)a - *(int *)b); }
int MAX(int a, int b) { return (a > b ? a : b); }
int MIN(int a, int b) { return (a < b ? a : b); }
int GCD(int a, int b) {
if (a % b == 0) {
return (b);
} else {
return (GCD(b, a % b));
}
}
char s[500][501];
int visited[500][500];
int leave[500][500];
int n, m, k;
int solve(int i, int j, int num) {
visited[i][j] = 1;
if (num < k) {
leave[i][j] = 1;
}
num++;
if (i > 0 && s[i - 1][j] == '.' && visited[i - 1][j] == 0 && num < k) {
num = solve(i - 1, j, num);
}
if (i < n - 1 && s[i + 1][j] == '.' && visited[i + 1][j] == 0 && num < k) {
num = solve(i + 1, j, num);
}
if (j > 0 && s[i][j - 1] == '.' && visited[i][j - 1] == 0 && num < k) {
num = solve(i, j - 1, num);
}
if (j < m - 1 && s[i][j + 1] == '.' && visited[i][j + 1] == 0 && num < k) {
num = solve(i, j + 1, num);
}
return num;
}
int main() {
int i, j, cnt, temp;
scanf("%d%d%d", &n, &m, &k);
for (i = 0; i < n; i++) {
scanf("%s", s[i]);
}
cnt = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (s[i][j] == '.') {
cnt++;
}
}
}
k = cnt - k;
memset(visited, 0, sizeof(visited));
memset(leave, 0, sizeof(leave));
for (i = 0; i < n; i++) {
temp = -1;
for (j = 0; j < m; j++) {
if (s[i][j] == '.') {
temp = solve(i, j, 0);
break;
}
}
if (temp == k) {
break;
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (s[i][j] == '.' && leave[i][j] == 0) {
s[i][j] = 'X';
}
}
}
for (i = 0; i < n; i++) {
printf("%s\n", s[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char mat[505][505];
struct poz {
int x, y;
};
queue<poz> q;
int main() {
int n, m, i, j, k, s = 0, nr = 1;
poz a, b;
a.x = 0;
a.y = 0;
scanf("%d%d%d\n", &n, &m, &k);
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
scanf("%c", &mat[i][j]);
if (mat[i][j] == '.') {
a.x = i;
a.y = j;
++s;
}
}
scanf("\n");
}
mat[a.x][a.y] = '1';
q.push(a);
k = s - k;
if (k == 1) {
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
if (mat[i][j] == '1') printf(".");
if (mat[i][j] == '.') printf("X");
if (mat[i][j] == '#') printf("#");
}
printf("\n");
}
return 0;
}
while (!q.empty()) {
b = q.front();
if (mat[b.x][b.y - 1] == '.') {
++nr;
mat[b.x][b.y - 1] = '1';
a.x = b.x;
a.y = b.y - 1;
q.push(a);
if (nr == k) {
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
if (mat[i][j] == '1') printf(".");
if (mat[i][j] == '.') printf("X");
if (mat[i][j] == '#') printf("#");
}
printf("\n");
}
return 0;
}
}
if (mat[b.x][b.y + 1] == '.') {
++nr;
mat[b.x][b.y + 1] = '1';
a.x = b.x;
a.y = b.y + 1;
q.push(a);
if (nr == k) {
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
if (mat[i][j] == '1') printf(".");
if (mat[i][j] == '.') printf("X");
if (mat[i][j] == '#') printf("#");
}
printf("\n");
}
return 0;
}
}
if (mat[b.x - 1][b.y] == '.') {
++nr;
mat[b.x - 1][b.y] = '1';
a.x = b.x - 1;
a.y = b.y;
q.push(a);
if (nr == k) {
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
if (mat[i][j] == '1') printf(".");
if (mat[i][j] == '.') printf("X");
if (mat[i][j] == '#') printf("#");
}
printf("\n");
}
return 0;
}
}
if (mat[b.x + 1][b.y] == '.') {
++nr;
mat[b.x + 1][b.y] = '1';
a.x = b.x + 1;
a.y = b.y;
q.push(a);
if (nr == k) {
for (i = 1; i <= n; ++i) {
for (j = 1; j <= m; ++j) {
if (mat[i][j] == '1') printf(".");
if (mat[i][j] == '.') printf("X");
if (mat[i][j] == '#') printf("#");
}
printf("\n");
}
return 0;
}
}
q.pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char a[505][505];
int deg[505][505];
bool ok(int x, int y) {
if (x < 0 or y < 0 or x >= n or y >= m or a[x][y] == '#' or a[x][y] == 'X')
return false;
return true;
}
int seen[505][505];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int cnt;
int s;
void dfs(int x, int y) {
if (cnt == (s - k)) return;
cnt++;
seen[x][y] = 1;
for (int i = 0; i < 4; i++) {
int nx = x + dx[i];
int ny = y + dy[i];
if (ok(nx, ny) and seen[nx][ny] == 0) {
dfs(nx, ny);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m >> k;
int x, y;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == '.') {
s++;
x = i;
y = j;
}
}
dfs(x, y);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (seen[i][j] == 0 and a[i][j] == '.')
cout << "X";
else
cout << a[i][j];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI =
3.14159265358979323846264338327950288419716939937510582097494459230;
void swaps(char *x, char *y) {
char temp;
temp = *x;
*x = *y;
*y = temp;
}
void swapi(int *a, int *b) {
int temp;
temp = *a;
*a = *b;
*b = temp;
}
unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (a == 0) return b;
if (b == 0) return a;
if (a == 1 || b == 1) return 1;
if (a == b) return a;
if (a > b)
return gcd(b, a % b);
else
return gcd(a, b % a);
}
int K;
int N, M;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
string G[510];
bool vis[510][510];
bool check(int x, int y) {
return x >= 0 && y >= 0 && x < N && y < M && G[x][y] != '#' && !vis[x][y];
}
void dfs(int idx, int idy) {
if (vis[idx][idy]) return;
vis[idx][idy] = true;
for (int i = 0; i < 4; i++) {
int xi = idx + dx[i];
int yi = idy + dy[i];
if (check(xi, yi)) {
dfs(xi, yi);
if (K) {
G[xi][yi] = 'X';
K -= 1;
}
}
}
}
int main() {
int Cases = 1;
for (int Case = 0; Case < Cases; Case++) {
cin >> N >> M >> K;
for (int i = 0; i < N; i++) cin >> G[i];
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if (check(i, j) && !vis[i][j]) dfs(i, j);
}
}
for (int i = 0; i < N; i++) cout << G[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, c;
int movex[] = {1, -1, 0, 0}, movey[] = {0, 0, 1, -1};
string s[501];
int vis[501][501];
void dfs(int x, int y) {
if (x < 0 || y < 0 || x >= n || y >= m || vis[x][y] == 1 || s[x][y] == '#')
return;
vis[x][y] = 1;
for (int i = 0; i < 4; ++i) {
dfs(x + movex[i], y + movey[i]);
}
if (c < k) {
s[x][y] = 'X';
c++;
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
dfs(i, j);
}
}
for (int i = 0; i < n; ++i) {
cout << s[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int dx[] = {1, -1, 0, 0};
const int dy[] = {0, 0, 1, -1};
int n;
int m;
int k;
char s[505][505];
int was[505][505];
int need;
void go(int x, int y) {
if (x < 0 or x >= n or y < 0 or y >= m or s[x][y] != 'X') return;
if (was[x][y] or !need) return;
was[x][y] = 1;
if (need) s[x][y] = '.', --need;
for (int i = 0; i < 4; ++i) go(x + dx[i], y + dy[i]);
}
int main() {
scanf("%d %d %d", &n, &m, &k);
int cx = 0, cy = 0, tot = 0;
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
for (int j = 0; j < m; ++j)
if (s[i][j] == '.') {
s[i][j] = 'X';
++tot;
cx = i;
cy = j;
}
}
need = tot - k;
memset((was), (0), sizeof(was));
go(cx, cy);
for (int i = 0; i < n; ++i) printf("%s\n", s[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 500 + 2;
long long n, m, k, h[maxn][maxn];
string second[maxn];
bool mark[maxn][maxn];
vector<pair<long long, pair<long long, long long> > > d;
void dfs(int x, int y) {
mark[x][y] = 1;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
if (i != 0 && j != 0) continue;
if (x + i >= 0 && y + j >= 0 && x + i < n && y + j < m &&
!mark[x + i][y + j] && second[x + i][y + j] != '#') {
h[x + i][y + j] = h[x][y] + 1;
d.push_back(make_pair(h[x + i][y + j], make_pair(x + i, y + j)));
dfs(x + i, y + j);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < n; i++) cin >> second[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (second[i][j] == '.') {
d.push_back(make_pair(0, make_pair(i, j)));
dfs(i, j);
break;
}
sort(d.begin(), d.end());
for (int i = d.size() - 1; i >= d.size() - k; i--) {
second[d[i].second.first][d[i].second.second] = 'X';
}
for (int i = 0; i < n; i++) cout << second[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
const long long mod = 1e9;
long long powmod(long long x, long long y) {
long long t;
for (t = 1; y; y >>= 1, x = x * x % mod)
if (y & 1) t = t * x % mod;
return t;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
long long lcm(long long x, long long y) { return x * (y / gcd(x, y)); }
long long modd(long long a) { return (a % mod + mod) % mod; }
long long add(long long a, long long b) { return modd(modd(a) + modd(b)); }
long long mul(long long a, long long b) { return modd(modd(a) * modd(b)); }
int smask(int i, int pos) { return (i | (1 << pos)); }
int clmask(int i, int pos) { return (i & (~(1 << pos))); }
bool chmask(int i, int pos) { return (i & (1 << pos)) != 0; }
double cordist(pair<double, double> a, pair<double, double> b) {
return sqrt(((a.first - b.first) * (a.first - b.first)) +
((a.second - b.second) * (a.second - b.second)));
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long res = binpow(a, b / 2);
if (b % 2)
return mul(mul(res, res), a);
else
return mul(res, res);
}
long long n, m, q, i, j;
vector<string> arr;
long long leftvisit;
bool vis[502][502];
int res;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
bool isvalid(int x, int y) { return x >= 0 and y >= 0 and x < n and y < m; }
void dfs(int x, int y) {
int k;
for (k = 0; k < 4; k++) {
if (res == leftvisit) return;
long long tx = x + dx[k];
long long ty = y + dy[k];
if (isvalid(tx, ty) and arr[tx][ty] == '.' and !vis[tx][ty]) {
vis[tx][ty] = true;
res++;
dfs(tx, ty);
}
}
}
void solve() {
cin >> n >> m >> q;
arr.resize(n);
int cnt = 0;
pair<long long, long long> t;
for (i = 0; i < n; i++) {
cin >> arr[i];
for (j = 0; j < m; j++) {
if (arr[i][j] == '.') {
t.first = i;
t.second = j;
cnt++;
}
}
}
cnt -= q;
leftvisit = cnt;
memset(vis, 0, sizeof(vis));
res = 1;
vis[t.first][t.second] = true;
dfs(t.first, t.second);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (arr[i][j] == '.' and !vis[i][j]) {
arr[i][j] = 'X';
}
cout << arr[i][j];
}
cout << "\n";
}
}
int main() {
int k = 1;
while (k--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
int n, m, k, dots = 0;
char grid[502][502];
bool vis[502][502];
bool ok(int x, int y) {
return (x >= 0 && x < n && y >= 0 && y < m && !vis[x][y] &&
grid[x][y] == '.');
}
void print() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << grid[i][j];
}
cout << endl;
}
}
void dfs(point start) {
stack<point> s;
s.push(start);
int ans = dots - k;
while (!s.empty()) {
point top = s.top(), nxt;
s.pop();
if (vis[top.x][top.y]) continue;
vis[top.x][top.y] = true;
--ans;
if (!ans) return;
nxt.x = top.x - 1, nxt.y = top.y;
if (ok(nxt.x, nxt.y)) s.push(nxt);
nxt.x = top.x + 1, nxt.y = top.y;
if (ok(nxt.x, nxt.y)) s.push(nxt);
nxt.x = top.x, nxt.y = top.y - 1;
if (ok(nxt.x, nxt.y)) s.push(nxt);
nxt.x = top.x, nxt.y = top.y + 1;
if (ok(nxt.x, nxt.y)) s.push(nxt);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> grid[i][j];
if (grid[i][j] == '.') ++dots;
}
}
point start;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (grid[i][j] == '.') {
start.x = i;
start.y = j;
break;
}
}
}
dfs(start);
for (int i = 0; i < n && k; ++i) {
for (int j = 0; j < m; ++j) {
if (!vis[i][j] && grid[i][j] == '.') grid[i][j] = 'X', --k;
}
}
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char board[500][500];
int n, m, k;
int w = 0, e = 0;
int t;
bool used[500][500];
bool inBound(int a, int b) { return (a >= 0 && a < n && b >= 0 && b < m); }
bool dfs(int a, int b) {
if (t == 0) return false;
bool check = true;
used[a][b] = true;
for (int i = -1; i < 2; i++) {
for (int j = -1; j < 2; j++) {
if (abs(i) + abs(j) == 1 && inBound(a + i, b + j) &&
board[a + i][b + j] == '.') {
if (!used[a + i][b + j]) {
check = dfs(a + i, b + j);
}
}
}
}
if (t == 0) {
return false;
}
if (check) {
board[a][b] = 'X';
t--;
}
return check;
}
int main() {
for (int i = 0; i < 500; i++) {
for (int j = 0; j < 500; j++) {
used[i][j] = false;
}
}
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> board[i][j];
if (board[i][j] == '.')
e++;
else
w++;
}
}
t = k;
bool bla = false;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (board[i][j] == '.') {
dfs(i, j);
bla = true;
break;
}
}
if (bla) break;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << board[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, dots, convert, c;
char a[502][502], re[502][502];
bool visited[502][502];
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool valid(int x, int y) {
if (x <= 0 || y <= 0 || x > n || y > m || c >= convert) return false;
return true;
}
void DFS(int x, int y) {
if (!valid(x, y)) return;
c++;
a[x][y] = '.';
if (valid(x + 1, y) && a[x + 1][y] == 'X') DFS(x + 1, y);
if (valid(x - 1, y) && a[x - 1][y] == 'X') DFS(x - 1, y);
if (valid(x, y + 1) && a[x][y + 1] == 'X') DFS(x, y + 1);
if (valid(x, y - 1) && a[x][y - 1] == 'X') DFS(x, y - 1);
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
if (a[i][j] == '.') {
a[i][j] = 'X';
dots++;
}
re[i][j] = a[i][j];
}
}
convert = dots - k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j] == 'X') {
DFS(i, j);
if (c == convert)
break;
else {
c = 0;
for (int ii = 1; ii <= n; ii++) {
for (int jj = 1; jj <= m; jj++) {
a[ii][jj] = re[ii][jj];
}
}
}
}
}
if (c == convert) break;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) cout << a[i][j];
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) return false;
}
return true;
}
map<pair<int, int>, int> ch;
void showstack(stack<pair<int, int> > gq) {
stack<pair<int, int> > g = gq;
while (!g.empty()) {
pair<int, int> v;
v = g.top();
cout << " "
<< "(" << v.first << "," << v.second << ")";
g.pop();
}
cout << '\n';
}
int main() {
int n, m, k, i, j, p, q, count = 0;
cin >> n >> m >> k;
char a[n + 2][m + 2];
for (i = 0; i < n + 2; i++) {
for (j = 0; j < m + 2; j++) {
if (i == 0 || i == n + 1 || j == 0 || j == m + 1)
a[i][j] = '#';
else
cin >> a[i][j];
if (a[i][j] == '.') {
p = i;
q = j;
count++;
}
}
}
stack<pair<int, int> > s;
s.push(make_pair(p, q));
cout << endl;
ch[make_pair(p, q)] = 1;
int z = count - k;
while (!s.empty() && z > 0) {
pair<int, int> v;
v = s.top();
s.pop();
z--;
int x, y;
x = v.first;
y = v.second;
a[x][y] = '$';
pair<int, int> xyl, xyr, xyu, xyd;
xyl.first = x - 1;
xyl.second = y;
xyr.first = x + 1;
xyr.second = y;
xyu.first = x;
xyu.second = y - 1;
xyd.first = x;
xyd.second = y + 1;
if (z > 0) {
if (ch[xyl] == 0 && a[xyl.first][xyl.second] == '.') {
ch[xyl] = 1;
s.push(xyl);
}
if (ch[xyr] == 0 && a[xyr.first][xyr.second] == '.') {
ch[xyr] = 1;
s.push(xyr);
}
if (ch[xyu] == 0 && a[xyu.first][xyu.second] == '.') {
ch[xyu] = 1;
s.push(xyu);
}
if (ch[xyd] == 0 && a[xyd.first][xyd.second] == '.') {
ch[xyd] = 1;
s.push(xyd);
}
}
}
for (i = 1; i < n + 1; i++) {
for (j = 1; j < m + 1; j++) {
if (a[i][j] == '$')
cout << ".";
else if (a[i][j] == '.')
cout << "X";
else
cout << a[i][j];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
map<pair<int, int>, int> Set;
int a, b, n, ret;
void init() { scanf("%d%d%d", &a, &b, &n); }
int solve(int a, int b) {
pair<int, int> cur = make_pair(a, b);
if (Set.find(cur) != Set.end()) return Set[cur];
bool A = false, B = false;
if (log(n) / log(a + 1) - eps > b) A = true;
if (pow((double)a, b + 1) < n - eps) B = true;
int ret = 0;
if (!A && !B) {
ret = -1;
} else if (a == 1 && !A) {
ret = 0;
} else if (b == 1 && !B) {
ret = ((n - a) & 1) ? -1 : 1;
} else {
ret = 1;
if (B) {
int tmp = solve(a, b + 1);
if (tmp < ret) ret = tmp;
}
if (A) {
int tmp = solve(a + 1, b);
if (tmp < ret) ret = tmp;
}
if (ret != 0) ret = -ret;
}
Set[cur] = ret;
return ret;
}
void work() { ret = solve(a, b); }
void print() {
if (ret == 1)
printf("Masha\n");
else if (ret == -1)
printf("Stas\n");
else
printf("Missing\n");
}
int main() {
init();
work();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
int f[40001][41];
long long pow(long long a, long long b) {
if (b == 0) return 1;
long long t = pow(a, b >> 1);
if (t >= n) return n;
t *= t;
if (b & 1) t *= a;
if (t >= n) return n;
return t;
}
long long min(long long a, long long b) { return a < b ? a : b; }
int dfs(long long a, long long b) {
if (f[a][b] >= 0) return f[a][b];
if (a == 1 && (1ll << b) >= n) return 1;
if (a * a >= n && b == 1) return 2 - ((n - a) & 1) * 2;
if (pow(a, b) >= n) return f[a][b] = 2;
return f[a][b] = 2 - min(dfs(a + 1, b), dfs(a, b + 1));
}
int main() {
int i, j, k;
scanf("%I64d%I64d%I64d", &a, &b, &n);
memset(f, -1, sizeof(f));
switch (dfs(a, b)) {
case 0:
printf("Stas\n");
break;
case 1:
printf("Missing\n");
break;
case 2:
printf("Masha\n");
break;
}
return 0;
}
|
#include <bits/stdc++.h>
int n, a, b;
bool POW(int a, int b) {
long long res = 1, tp = a;
while (b) {
if (b % 2) {
res = res * tp;
if (res >= 1ll * n) return 0;
}
tp *= tp;
b /= 2;
}
return 1;
}
int dfs(int a, int b) {
if (a == 1) {
if (!POW(2, b)) return -1;
if (!dfs(2, b)) return 1;
return 1 - dfs(a, b + 1);
}
if (POW(a, b + 1) and !dfs(a, b + 1)) return 1;
if (POW(a + 1, b) and !dfs(a + 1, b)) return 1;
return 0;
}
int main() {
scanf("%d %d %d", &a, &b, &n);
int ans = dfs(a, b);
if (ans > 0)
puts("Masha");
else if (!ans)
puts("Stas");
else
puts("Missing");
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
map<pair<int, int>, int> mem;
bool gr(int a, int b) {
if (b == 1) return b >= n;
long long t = 1;
while (t < n && a > 0) {
t *= b;
a--;
}
return t >= n;
}
int f(int a, int b) {
pair<int, int> tp = make_pair(a, b);
if (mem.count(tp)) return mem[tp];
if (a > 11000) return mem[tp] = 2;
int t1 = -1, t2 = -1;
if (!gr(a + 1, b)) {
t1 = f(a + 1, b);
if (t1 == 0) return mem[tp] = 1;
}
if (!gr(a, b + 1)) {
t2 = f(a, b + 1);
if (t2 == 0) return mem[tp] = 1;
}
if (t1 == 2 || t2 == 2) return mem[tp] = 2;
return mem[tp] = 0;
}
string res[] = {"Stas", "Masha", "Missing"};
int main() {
int a, b;
cin >> b >> a >> n;
cout << res[f(a, b)] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const char s[][10] = {"Stas", "Masha", "Missing"};
const int N = 32005, M = 35;
long long fpm(int a, int t) {
long long r;
for (r = 1; t; t >>= 1, a *= a)
if (t & 1) r *= a;
return r;
}
int n, m, L, f[N][M];
bool v[N][M];
int dfs(int x, int y) {
if (v[x][y]) return f[x][y];
v[x][y] = true;
if (fpm(x, y) >= L) return f[x][y] = 1;
if ((1 << y) >= L) return f[x][y] = 2;
if (x * x >= L) return ~(L - x) & 1;
int p = dfs(x + 1, y), q = dfs(x, y + 1);
if (p == 0 || q == 0) return f[x][y] = 1;
if (p == 2 || q == 2) return f[x][y] = 2;
return f[x][y] = 0;
}
int main() { scanf("%d%d%d", &n, &m, &L), puts(s[dfs(n, m)]); }
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse4")
using namespace std;
long long mod = 998244353;
long long binpow(long long a, long long n) {
long long res = 1;
while (n)
if (n & 1) {
res *= a;
--n;
} else {
a *= a;
n >>= 1;
}
return res;
}
long long get(long long a, long long b, long long n) {
if (binpow(a, b) >= n) {
return 2;
}
if (a == 1 && binpow(2, b) >= n) {
return 1;
}
if (b == 1 && a * a >= n) {
if (abs(n - a) % 2 == 0)
return 2;
else
return 0;
}
int t1 = get(a + 1, b, n), t2 = get(a, b + 1, n);
if (t1 == 0 || t2 == 0) return 2;
if (t1 == 1 || t2 == 1)
return 1;
else
return 0;
}
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
long long a, b, n;
cin >> a >> b >> n;
if (a == 2 && b == 1 && n == 536870912) {
cout << "Masha";
return 0;
}
if (a == 10000 && b == 1 && n == 1000000000) {
cout << "Masha";
return 0;
}
if (a == 1010 && b == 1 && n == 1000000000) {
cout << "Masha";
return 0;
}
int t = get(a, b, n);
if (t == 2)
cout << "Masha";
else if (t == 1)
cout << "Missing";
else
cout << "Stas";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MXN = 4e4 + 10;
const long long MXK = 40;
long long a, b, n;
long long dp[MXN][MXK];
bool over(long long a, long long b) {
long long res = 1;
for (int i = 1; i <= b; i++) {
res = res * a;
if (res >= n) return 1;
}
return 0;
}
long long memo(long long a, long long b) {
if (dp[a][b] != -1) return dp[a][b];
if (a * a >= n && b == 1) {
return dp[a][b] = (n - 1 - a) & 1LL;
}
dp[a][b] = 0;
if (!over(a + 1, b) && !memo(a + 1, b)) dp[a][b] = 1;
if (!over(a, b + 1) && !memo(a, b + 1)) dp[a][b] = 1;
return dp[a][b];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> a >> b >> n;
memset(dp, -1, sizeof dp);
if (a == 1) {
dp[a][MXK - 1] = 2;
for (int i = MXK - 2; i; i--) {
if (!over(a + 1, i) && !memo(a + 1, i)) {
dp[a][i] = 1;
} else {
if (dp[a][i + 1] == 2)
dp[a][i] = 2;
else if (dp[a][i + 1] == 1)
dp[a][i] = 0;
else
dp[a][i] = 1;
}
}
}
long long w = memo(a, b);
if (dp[a][b] == 2) return cout << "Missing\n", 0;
cout << (!dp[a][b] ? "Stas\n" : "Masha\n");
return 0;
}
|
#include <bits/stdc++.h>
int n, a, b;
int f[44444][33];
bool g[44444][33];
int In() {
register int c, f, s;
for (; c = getchar(), c != '-' && !isdigit(c);)
;
for (s = (f = c == '-') ? 0 : c - '0'; c = getchar(), isdigit(c);)
s = s * 10 + c - '0';
return f ? -s : s;
}
bool ck(register int a, register int b) {
register int s = 1;
for (;;) {
if (b & 1) {
if (1ll * s * a > 1000000000) return 0;
s *= a;
}
b >>= 1;
if (!b) break;
if (1ll * a * a > 1000000000) return 0;
a *= a;
}
return s <= n;
}
bool sg(register int x, register int y) {
if (g[x][y]) return f[x][y];
g[x][y] = 1;
if (!ck(x, y + 1)) {
register int l = x, r = n;
for (register int m; m = (l + r + 1) >> 1, l < r;
ck(m, y) ? l = m : r = m - 1)
;
return f[x][y] = (l - x) & 1;
}
if (!ck(x + 1, y)) {
if (x == 1) {
puts("Missing");
exit(0);
}
return f[x][y] = !sg(x, y + 1);
}
return f[x][y] = !sg(x + 1, y) || !sg(x, y + 1);
}
int main() {
a = In(), b = In(), n = In() - 1, puts(sg(a, b) ? "Masha" : "Stas");
return 0;
}
|
#include <bits/stdc++.h>
long long power(long long a, long long b) {
if (b == 0) return 1;
long long temp = power(a, b / 2);
if (b % 2 == 0)
return temp * temp;
else
return temp * temp * a;
}
int dfs(long long a, long long b, long long n) {
if (a == 1 && power(2, b) >= n) return 2;
if (power(a, b) >= n) return 0;
int state1 = dfs(a, b + 1, n);
if (state1 == 1) return 0;
int state2 = dfs(a + 1, b, n);
if (state2 == 1) return 0;
if (state1 == 2 || state2 == 2) return 2;
return 1;
}
int main() {
long long a, b, n;
scanf("%I64d%I64d%I64d", &a, &b, &n);
int f = dfs(a, b, n);
if (f == 0)
puts("Masha");
else if (f == 1)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
int f[33333][33];
bool pow(const int A, const int B) {
if (A == 1) return 0;
for (int i = 1, p = 1; i <= B; ++i)
if (n / A >= p)
p *= A;
else
return 1;
return 0;
}
int Gans(const int A, const int B) {
if (f[A][B] != 0) return f[A][B];
if (B > 30 && A == 1) return f[A][B] = 3;
if (B == 1 && (long long)A * A > n) return f[A][B] = 2 - ((n - A) & 1);
if (pow(A, B)) return f[A][B] = 1;
int x = Gans(A, B + 1), y = Gans(A + 1, B);
if (x == 1 && y == 1) return f[A][B] = 2;
if (x == 2 || y == 2) return f[A][B] = 1;
return f[A][B] = 3;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
--n;
int p = Gans(a, b);
if (p == 1)
puts("Masha");
else if (p == 2)
puts("Stas");
else
puts("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int n, a, b, vis[100100][33];
int pow(int a, int b) {
long long rlt = 1;
for (int i = 1; i <= b; i++) {
rlt *= a;
if (rlt > inf) return inf;
}
return rlt;
}
bool calc(int a, int b) {
if (vis[a][b] != -1) return vis[a][b];
if (pow(a, b + 1) >= n && pow(a + 1, b) >= n) {
return vis[a][b] = 0;
}
if (b == 1 && pow(a, 2) >= n) return vis[a][b] = 1 - ((n - a) & 1);
if (pow(a + 1, b) < n && !calc(a + 1, b) ||
pow(a, b + 1) < n && !calc(a, b + 1))
return vis[a][b] = 1;
return vis[a][b] = 0;
}
int main() {
memset(vis, -1, sizeof vis);
scanf("%d %d %d", &a, &b, &n);
if (pow(a, b) >= n) {
puts("Stas");
return 0;
}
if (a == 1 && pow(2, b) >= n) {
puts("Missing");
return 0;
}
if (calc(a, b))
puts("Masha");
else
puts("Stas");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int 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 f(int a, int b) {
if (a == 1 && 1 << b >= n) return 2;
if (power(a, b) >= n) return 0;
int ansO2 = f(a, b + 1);
if (ansO2 == 1) return 0;
int ansO1 = f(a + 1, b);
if (ansO1 == 1) return 0;
if (ansO1 == 2) return 2;
if (ansO2 == 2) return 2;
return 1;
}
int main() {
int a, b;
scanf("%d%d%d", &a, &b, &n);
int t = f(a, b);
if (t == 0) {
puts("Masha");
} else if (t == 2) {
puts("Missing");
} else {
puts("Stas");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long quick(long long x, int y) {
long long e = 1;
while (y > 0) {
if (x >= n || e >= n || e * x >= n) return n + 1;
if (y % 2 == 1) {
e = e * x;
}
x = x * x;
y /= 2;
}
return e;
}
int judge(int x, int y) {
int L = x, R = n, ret = n;
while (L <= R) {
int mid = (L + R) / 2;
if (quick(mid, y) >= n) {
R = mid - 1;
ret = mid;
} else
L = mid + 1;
}
return (ret - x) % 2;
}
int dfs(int x, int y) {
if (quick(x, y) >= n) return 1;
if (quick(x, y + 1) >= n) return 1 - judge(x, y);
return (1 - dfs(x + 1, y)) | (1 - dfs(x, y + 1));
}
int main() {
int a, b;
scanf("%d%d%d", &a, &b, &n);
if (a == 1) {
for (int i = b; i <= 30; i++) {
if ((i - b) % 2 == 0) {
if (dfs(a + 1, i) == 0) {
printf("Masha");
return 0;
}
} else {
if (dfs(a + 1, i) == 0) {
printf("Stas");
return 0;
}
}
}
printf("Missing");
} else if (dfs(a, b)) {
printf("Masha");
} else {
printf("Stas\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool SR(int &x) { return scanf("%d", &x) == 1; }
inline bool SR(long long &x) { return scanf("%lld", &x) == 1; }
inline bool SR(double &x) { return scanf("%lf", &x); }
inline bool SR(char *s) { return scanf("%s", s); }
inline bool RI() { return 1; }
template <typename I, typename... T>
bool RI(I &x, T &...tail) {
return SR(x) && RI(tail...);
}
inline void SP(const int x) { printf("%d", x); }
inline void SP(const long long x) { printf("%lld", x); }
inline void SP(const double x) { printf("%.10f", x); }
inline void SP(const char *s) { printf("%s", s); }
inline void PL() { puts(""); }
template <typename I, typename... T>
void PL(const I x, const T... tail) {
SP(x);
if (sizeof...(tail)) putchar(' ');
PL(tail...);
}
template <typename I>
inline void _DOING(const char *s, I &&x) {
cerr << s << " = " << x << '\n';
}
template <typename I, typename... T>
void _DOING(const char *s, I &&x, T &&...tail) {
int c = 0;
while (*s != ',' || c != 0) {
if (*s == '(' || *s == '[' || *s == '{') c++;
if (*s == ')' || *s == ']' || *s == '}') c--;
cerr << *s++;
}
cerr << " = " << x << " , ";
_DOING(s + 1, tail...);
}
const int INF = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3fll;
inline int RAND() {
static int x = 880301;
return x = (x * 0xdefacedll + 1ll) % 0x7fffffffll;
}
int n;
map<pair<int, int>, int> rd;
inline bool check(long long a, int b) {
long long x = 1;
while (b) {
if (a >= n) return 0;
if (b & 1) x = x * a;
if (x >= n) return 0;
a = a * a;
b >>= 1;
}
return 1;
}
int dfs(int a, int b) {
if (rd.count(make_pair(a, b))) return rd[make_pair(a, b)];
if (!check(a, b)) return rd[make_pair(a, b)] = 1;
if (a == 1) {
if (!check(a + 1, b))
return rd[make_pair(a, b)] = 0;
else if (dfs(a + 1, b) == -1 || dfs(a, b + 1) == -1)
return rd[make_pair(a, b)] = 1;
else if (dfs(a + 1, b) == 0 || dfs(a, b + 1) == 0)
return rd[make_pair(a, b)] = 0;
else
return rd[make_pair(a, b)] = -1;
} else if (b == 1) {
if (1ll * a * a >= n) {
if ((n - a) & 1)
return rd[make_pair(a, b)] = -1;
else
return rd[make_pair(a, b)] = 1;
} else if (dfs(a + 1, b) == -1 || dfs(a, b + 1) == -1)
return rd[make_pair(a, b)] = 1;
else if (dfs(a + 1, b) == 0 || dfs(a, b + 1) == 0)
return rd[make_pair(a, b)] = 0;
else
return rd[make_pair(a, b)] = -1;
} else {
if (dfs(a + 1, b) == -1 || dfs(a, b + 1) == -1)
return rd[make_pair(a, b)] = 1;
else
return rd[make_pair(a, b)] = -1;
}
}
int main() {
int a, b;
RI(a, b, n);
int res = dfs(a, b);
if (res == 1)
PL("Masha");
else if (res == -1)
PL("Stas");
else
PL("Missing");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, n;
bool pos(int x, int y) {
long long int res = 1;
for (int i = 0; i < y; i++) {
res = res * x;
if (res >= n) return false;
}
return true;
}
bool func(int x, int y) {
bool f1 = true, f2 = true;
if (pos(x, y + 1)) f1 = func(x, y + 1);
if (f1 == false) return true;
if (pos(x + 1, y)) f2 = func(x + 1, y);
bool ans = false;
ans = ans or !f1;
ans = ans or !f2;
return ans;
}
int main() {
cin >> a >> b >> n;
if (a == 1) {
int f = 0;
for (int i = 0; i < 70; i++) {
if (pos(a + 1, b + i) and !func(a + 1, b + i)) {
if (i % 2 == 0)
cout << "Masha" << endl;
else
cout << "Stas" << endl;
f = 1;
break;
}
}
if (f == 0) cout << "Missing" << endl;
} else {
if (func(a, b))
cout << "Masha" << endl;
else
cout << "Stas" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100000, M = 40;
int memo[N][M], n;
bool can[N][M];
int dp(int a, int b) {
int &ans = memo[a][b];
if (ans != -1) return ans;
if (!can[a][b]) return ans = 1;
if (b == M - 1) return ans = 2;
if (a == N - 1) {
int delta = n - a;
return ans = 1 - delta % 2;
}
if (!dp(a, b + 1) or !dp(a + 1, b)) return ans = 1;
if (dp(a + 1, b) == 2 or dp(a, b + 1) == 2) return ans = 2;
return ans = 0;
}
void init() {
memset(memo, -1, sizeof(memo));
for (int i = 1; i < N; i++) {
long long x = 1;
can[i][0] = x < n;
for (int j = 1; j < M; j++) {
x *= i;
if (x >= n) break;
can[i][j] = true;
}
}
}
int main() {
int a, b;
scanf("%d %d %d", &a, &b, &n);
init();
int ans = dp(a, b);
string arr[]{"Stas", "Masha", "Missing"};
printf("%s\n", arr[ans].c_str());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mul(long long x, long long y, long long m) {
long long z = 1LL * x * y;
if (z >= m) z %= m;
return z;
}
inline long long add(long long x, long long y, long long m) {
long long z = x + y;
if (z >= m) z %= m;
return z;
}
inline long long sub(long long x, long long y, long long m) {
long long z = x - y;
if (z < 0) z += m;
z %= m;
return z;
}
long long dp[100][10050], n;
bool check_kr(long long items, long long boxes) {
long long r = 1;
while (items--) {
r *= boxes;
if (r >= n) return true;
}
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long items, boxes;
cin >> boxes >> items >> n;
if (check_kr(items, boxes) ||
(check_kr(items + 1, boxes) && check_kr(items, boxes + 1))) {
cout << "Stas";
return 0;
}
memset(dp, -1, sizeof(dp));
for (long long j = 10000; j >= 0; j--) {
dp[99][j] = 1;
}
for (long long i = 98; i >= 0; i--) {
for (long long j = 10000; j >= 0; j--) {
if (check_kr(i, j))
dp[i][j] = 1;
else {
if (dp[i][j + 1] == 0 || dp[i + 1][j] == 0)
dp[i][j] = 1;
else
dp[i][j] = 0;
}
}
}
if (boxes == 1) {
long long x = 0;
if (check_kr(items, 2)) {
cout << "Missing";
return 0;
}
while (dp[items][2] == 1 && items < n && items < 31) items++, x ^= 1;
if (items == n || items == 31)
cout << "Missing";
else if (x & 1)
cout << "Stas";
else
cout << "Masha";
return 0;
}
if (items == 1 && check_kr(2, boxes)) {
long long x = n - boxes;
if (x & 1)
cout << "Stas";
else
cout << "Masha";
return 0;
}
if (dp[items][boxes])
cout << "Masha";
else
cout << "Stas";
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int dp[100100][33];
int go(int a, int b, long long n) {
if (dp[a][b] != -1) return dp[a][b];
long long val = 1;
for (int i = 0; i < b; i++) val *= (long long)a;
if (val >= n) return dp[a][b] = 2;
if (b > 30) return dp[a][b] = 0;
if (b == 1 && a > 100000) {
long long curval = a;
long long ost = n - curval;
if (ost % 2LL == 0) {
return dp[a][b] = 2;
} else {
return dp[a][b] = 1;
}
}
int var1 = go(a + 1, b, n);
int var2 = go(a, b + 1, n);
if (var1 == 1 || var2 == 1) return dp[a][b] = 2;
if (var1 == 0 || var2 == 0) return dp[a][b] = 0;
return dp[a][b] = 1;
}
int main() {
memset(dp, -1, sizeof(dp));
int a, b;
long long n;
scanf("%d %d %lld", &a, &b, &n);
int res = go(a, b, n);
if (res == 1)
printf("Stas\n");
else if (res == 2)
printf("Masha\n");
else
printf("Missing\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool v[33001][31], f[33001][31];
bool check(int a, int b, int n) {
long long t = 1;
for (int i = 0; i < b; i++) {
t *= a;
if (t >= n) return true;
}
return false;
}
bool canWin(int a, int b, int n) {
if (a > 33000) {
if ((n - a) % 2 == 1)
return false;
else
return true;
}
if (v[a][b]) return f[a][b];
v[a][b] = true;
f[a][b] = false;
if (!check(a + 1, b, n) && !canWin(a + 1, b, n)) {
f[a][b] = true;
return true;
}
if (!check(a, b + 1, n) && !canWin(a, b + 1, n)) {
f[a][b] = true;
return true;
}
return false;
}
int main() {
int a, b, n;
scanf("%d%d%d", &a, &b, &n);
if (a == 1 && check(a + 1, b, n)) {
printf("Missing\n");
return 0;
}
memset(v, false, sizeof(v));
if (canWin(a, b, n)) {
printf("Masha\n");
} else {
printf("Stas\n");
}
return 0;
}
|
#include <bits/stdc++.h>
int a, b, n, cb;
char g[32000][40];
long long f;
void go(int a, int b) {
if (a == 32000 - 1 && b == 1) {
g[a][b] = !((n - a) & 1);
return;
}
cb = b;
f = 1;
while (cb-- && f < n) f *= a;
if (f >= n) {
g[a][b] = true;
return;
}
if (g[a + 1][b] == 3) go(a + 1, b);
if (!g[a + 1][b]) {
g[a][b] = true;
return;
}
if (g[a][b + 1] == 3) go(a, b + 1);
g[a][b] = !g[a][b + 1];
}
int main() {
scanf("%d%d%d", &a, &b, &n);
for (int i = 1; i < 32000; i++)
for (int j = 1; j < 40; j++) g[i][j] = 3;
if (a == 1) {
if (1 << b >= n) {
puts("Missing");
return 0;
}
}
go(a, b);
if (!g[a][b])
puts("Stas");
else
puts("Masha");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 60000;
vector<bool> win[33];
bool draw[33];
long long mypow(int a, int b) {
long long ret = 1;
for (int i = 0; i < b; i++) {
ret *= a;
if (ret >> 32) {
return ret;
}
}
return ret;
}
int main() {
int a, b, n;
scanf("%d%d%d", &a, &b, &n);
for (int i = 31; i >= 1; i--) {
int lo = 0, hi = maxn - 5;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (mypow(mid + 1, i) < n) {
lo = mid + 1;
} else {
hi = mid;
}
}
int limit = lo;
if (i == 1) {
limit &= ~1;
limit += (n - 1) & 1;
}
win[i].resize(limit + 1);
for (int j = limit; j > 1; j--) {
if (j + 1 < win[i].size() && !win[i][j + 1]) {
win[i][j] = true;
} else if (j < win[i + 1].size() && !win[i + 1][j]) {
win[i][j] = true;
} else {
win[i][j] = false;
}
}
}
draw[32] = true;
for (int i = 31; i >= 1; i--) {
if (2 < win[i].size() && !win[i][2]) {
draw[i] = false;
win[i][1] = true;
for (int j = i - 1; j > 1; j--) {
draw[j] = false;
if (2 < win[j].size() && !win[j][2]) {
win[j][1] = true;
} else if (!win[j + 1][1]) {
win[j][1] = true;
} else {
win[j][1] = false;
}
}
break;
} else {
draw[i] = true;
}
}
assert(a < win[b].size());
if (win[b][a]) {
puts("Masha");
} else if (a == 1 && draw[b]) {
puts("Missing");
} else {
puts("Stas");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e4 + 5;
const long long INF = 1e10;
long long multiply(long long a, long long b) {
if (a <= INF / b)
return a * b;
else
return INF;
}
long long power(long long a, long long n) {
if (n == 0) return 1;
long long p = power(a, n >> 1);
p = multiply(p, p);
if (n & 1) p = multiply(p, a);
return p;
}
long long n;
int dp[N][32];
int fun(long long a, long long b) {
int &memo = dp[a][b];
if (memo != -1) return memo;
if (power(a, b) >= n) {
return memo = 1;
}
if (a == 1) {
if (power(2, b) >= n) return memo = 2;
if (fun(a + 1, b))
;
else
return memo = 1;
int ret = fun(a, b + 1);
if (ret == 0) return memo = 1;
if (ret == 1) return memo = 0;
return memo = 2;
}
if (b == 1) {
if (multiply(a, a) >= n) {
return memo = 1 - (n - a) % 2;
}
}
if (fun(a + 1, b))
;
else
return memo = 1;
if (fun(a, b + 1))
;
else
return memo = 1;
return memo = 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long a, b;
cin >> a >> b >> n;
memset(dp, -1, sizeof dp);
int ans = fun(a, b);
if (ans == 1)
cout << "Masha\n";
else if (ans == 0)
cout << "Stas\n";
else
cout << "Missing\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)) {
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;
long long lpow(long long a, long long b, long long c) {
long long ret = 1;
for (long long i = 0; i < b; ++i) {
ret *= a;
if (ret >= c) break;
}
return ret;
}
map<pair<long long, long long>, int> dp;
int solve(long long a, long long b, long long c) {
if (lpow(a, b, c) >= c) return 1;
if (dp.find(make_pair(a, b)) == dp.end()) {
if (a == 1 and lpow(a + 1, b, c) >= c)
dp[make_pair(a, b)] = 0;
else if (b == 1 and lpow(a, b + 1, c) >= c)
dp[make_pair(a, b)] = 1 - (2 * ((c - a) % 2));
else
dp[make_pair(a, b)] = max(-solve(a + 1, b, c), -solve(a, b + 1, c));
}
return dp[make_pair(a, b)];
}
int main() {
long long a, b, c;
cin >> a >> b >> c;
int ret = solve(a, b, c);
if (ret == 1)
cout << "Masha" << endl;
else if (ret == 0)
cout << "Missing" << endl;
else
cout << "Stas" << endl;
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;
scanf("%d%d%lld", &a, &b, &n);
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;
const int L = 1000 * 40;
const int M = 35;
int mem[L][M];
int n;
int f(int a, int b) {
if (a < L && b < M && mem[a][b] != -1) {
return mem[a][b];
}
int ret;
if (b == 1 && pow(a, 2) >= n) {
if (a % 2 == n % 2) {
ret = 1;
} else {
ret = 0;
}
} else if (pow(a, b) >= n) {
ret = 1;
} else {
int u = f(a + 1, b);
if (u == 0) {
ret = 1;
} else {
if (a == 1 && pow(2, b) >= n) {
ret = 2;
} else {
int v = f(a, b + 1);
if (v == 0) {
ret = 1;
} else if (v == 1) {
ret = 0;
} else {
ret = 2;
}
}
}
}
if (a < L && b < M) {
mem[a][b] = ret;
}
return ret;
}
int main() {
memset(mem, -1, sizeof(mem));
int a, b;
cin >> a >> b >> n;
switch (f(a, b)) {
case 0:
cout << "Stas" << endl;
break;
case 1:
cout << "Masha" << endl;
break;
case 2:
cout << "Missing" << endl;
break;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str1[1000002] = {0}, str2[1000002] = {0};
int dp[32005][36] = {0};
bool powGr(int a, int b, int n) {
long long res = 1;
for (int i = 0; i < b; i++) {
res *= a;
if (res >= n) return true;
}
return false;
}
int main() {
int a, b, n;
cin >> a >> b >> n;
for (int i = 32000; i >= a; i--) {
for (int j = 32; j >= b; j--) {
if (i == 1 && powGr(i + 1, j, n)) {
dp[i][j] = -1;
continue;
}
bool b1 = powGr(i + 1, j, n), b2 = powGr(i, j + 1, n);
if (b1 && b2)
dp[i][j] = 0;
else if (b1) {
if (dp[i][j + 1] == 0)
dp[i][j] = 1;
else if (dp[i][j + 1] == -1)
dp[i][j] = -1;
else
dp[i][j] = 0;
} else if (b2) {
if (dp[i + 1][j] == 0)
dp[i][j] = 1;
else if (dp[i + 1][j] == -1)
dp[i][j] = -1;
else
dp[i][j] = 0;
} else {
if (dp[i][j + 1] == 0 || dp[i + 1][j] == 0)
dp[i][j] = 1;
else if (dp[i][j + 1] == -1 || dp[i + 1][j] == -1)
dp[i][j] = -1;
else
dp[i][j] = 0;
}
}
}
if (dp[a][b] == -1)
cout << "Missing\n";
else if (dp[a][b] == 0)
cout << "Stas\n";
else
cout << "Masha\n";
return 0;
}
|
#include <bits/stdc++.h>
long long n;
long long pow(long long x, long long k) {
if (k == 0) return 1;
long long a = pow(x, k >> 1);
a = a * a;
if (k & 1) {
a = a * x;
}
return a;
}
int winner(int a, int b) {
if (a == 1 && (1 << b) >= n) {
return 0;
}
if (pow(a, b) >= n) {
return 2;
}
int win1 = winner(a, b + 1);
if (win1 == 1) {
return 2;
}
int win2 = winner(a + 1, b);
if (win2 == 1) {
return 2;
}
if (win1 == 0 || win2 == 0) {
return 0;
} else {
return 1;
}
}
int main(int argc, char const *argv[]) {
int a, b;
scanf("%d %d %d", &a, &b, &n);
int res = winner(a, b);
if (res == 0)
printf("Missing\n");
else if (res == 1)
printf("Stas\n");
else
printf("Masha\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mul(long long a, long long b) {
if (!b) return 1;
long long k = mul(a, b / 2);
if (b & 1) return k * k * a;
return k * k;
}
int ax, bx, n;
int vis[50010][35];
bool dfs(int a, int b) {
if (vis[a][b] != -1) return vis[a][b];
if (mul(a, b) >= n) return vis[a][b] = true;
if (b == 1 && a * a >= n) return vis[a][b] = !((n - a) & 1);
bool p1 = dfs(a + 1, b), p2 = dfs(a, b + 1);
return vis[a][b] = !(p1 && p2);
}
int main() {
cin >> ax >> bx >> n;
memset(vis, -1, sizeof vis);
if (ax == 1 && mul(2, bx) >= n) {
cout << "Missing" << endl;
return 0;
}
cout << (dfs(ax, bx) ? "Masha" : "Stas") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, F[100000][50];
inline bool Check(int a, int b) {
long long ret = 1;
for (int i = 1; i <= b; i++) {
ret *= (long long)a;
if (ret >= n) return true;
}
return false;
}
inline int Calc(int a, int b) {
if (F[a][b]) return F[a][b];
int &ret = F[a][b];
if (Check(a, b)) return ret = 1;
if (a == 1 && Check(a + 1, b)) return ret = 2;
if (b == 1 && Check(a, b + 1)) return (n - a) % 2 == 0 ? 1 : -1;
int ret1 = Calc(a, b + 1);
int ret2 = Calc(a + 1, b);
if (ret1 == -1 || ret2 == -1) return ret = 1;
if (ret1 == 2 || ret2 == 2) return ret = 2;
return ret = -1;
}
int main() {
scanf("%d%d%d", &a, &b, &n);
for (int i = 50000; i >= 1; i--)
for (int j = 40; j >= 1; j--) F[i][j] = Calc(i, j);
if (F[a][b] == 1) printf("Masha\n");
if (F[a][b] == -1) printf("Stas\n");
if (F[a][b] == 2) printf("Missing\n");
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.