text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 41;
int n;
char T[kMaxN][kMaxN];
int dp[kMaxN][1 << 20];
bool vs[kMaxN][1 << 20];
int inline cost(char c) {
switch (c) {
case 'a':
return 1;
case 'b':
return -1;
default:
return 0;
}
}
int dfs(int m, int s) {
int best;
int c;
int mask[26];
if (s == 2 * n - 2) {
return cost(T[n][n]);
}
if (vs[s][m]) return dp[s][m];
for (int i = 0; i <= min(n - 1, s); ++i) {
if (1 << i & m) {
c = cost(T[i + 1][s - i + 1]);
break;
}
}
fill_n(mask, 26, 0);
for (int i = 0; i <= min(n - 1, s); ++i) {
if (1 << i & m) {
if (i < n - 1) {
mask[T[i + 2][s - i + 1] - 'a'] |= 1 << i + 1;
}
if (s - i < n - 1) {
mask[T[i + 1][s - i + 2] - 'a'] |= 1 << i;
}
}
}
if (s % 2 == 0) {
best = 1000;
for (int i = 0; i < 26; ++i) {
if (mask[i]) {
best = min(best, dfs(mask[i], s + 1));
}
}
} else {
best = -1000;
for (int i = 0; i < 26; ++i) {
if (mask[i]) {
best = max(best, dfs(mask[i], s + 1));
}
}
}
best += c;
dp[s][m] = best;
vs[s][m] = true;
return best;
}
int main(void) {
int ret;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", T[i] + 1);
}
for (int i = 1; i <= 2 * n - 1; ++i) {
for (int j = 1; j <= 1 << 20; ++j) {
vs[i][j] = false;
}
}
ret = dfs(1, 0);
if (ret > 0) {
printf("FIRST\n");
} else if (ret == 0) {
printf("DRAW\n");
} else {
printf("SECOND\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<vector<pair<int, int> >, int> vst;
char s[22][22];
vector<pair<int, int> > pos;
int n;
bool cmp(pair<int, int> u, pair<int, int> v) {
return s[u.first][u.second] < s[v.first][v.second];
}
int solve(vector<pair<int, int> > pos) {
if (vst.count(pos)) return vst[pos];
if (pos[0].first == n && pos[0].second == n)
return (s[n][n] == 'a') - (s[n][n] == 'b');
vector<pair<int, int> > tmp;
for (int i = 0; i < pos.size(); i++) {
if (pos[i].first != n)
tmp.push_back(pair<int, int>(pos[i].first + 1, pos[i].second));
if (pos[i].second != n)
tmp.push_back(pair<int, int>(pos[i].first, pos[i].second + 1));
}
sort(tmp.begin(), tmp.end());
tmp.erase(unique(tmp.begin(), tmp.end()), tmp.end());
sort(tmp.begin(), tmp.end(), cmp);
int flag = (pos[0].first + pos[0].second) & 1;
int mx = -1000, mn = 1000;
for (int i = 0; i < tmp.size();) {
int j = i;
vector<pair<int, int> > put;
while (j < tmp.size() &&
s[tmp[i].first][tmp[i].second] == s[tmp[j].first][tmp[j].second]) {
put.push_back(pair<int, int>(tmp[j].first, tmp[j].second));
j++;
}
i = j;
if (flag)
mx = max(mx, solve(put));
else
mn = min(mn, solve(put));
}
int ans;
if (flag)
ans = mx;
else
ans = mn;
ans += (s[pos[0].first][pos[0].second] == 'a') -
(s[pos[0].first][pos[0].second] == 'b');
return vst[pos] = ans;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
pos.push_back(pair<int, int>(1, 1));
int flag = solve(pos);
if (flag < 0)
puts("SECOND");
else if (flag > 0)
puts("FIRST");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kInf = 100;
int N;
char P[22][22];
vector<char> C;
int f[41][1 << 20], dcn[22][22];
vector<pair<int, int> > dps[41];
void read();
void solve();
int dp(int, int);
int main() {
read();
solve();
return 0;
}
void read() {
cin >> N;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) cin >> P[i][j], C.push_back(P[i][j]);
}
void solve() {
stable_sort((C).begin(), (C).end());
C.erase(unique((C).begin(), (C).end()), C.end());
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= N; ++j) {
dcn[i][j] = int((dps[i + j - 1]).size());
dps[i + j - 1].push_back(make_pair(i, j));
}
for (int i = 1; i <= 2 * N - 1; ++i)
fill(&f[i][0], &f[i + 1][0], i % 2 == 1 ? kInf : -kInf);
int res = dp(1, 1) + (P[1][1] == 'a' ? 1 : (P[1][1] == 'b' ? -1 : 0));
if (res > 0)
cout << "FIRST\n";
else if (res < 0)
cout << "SECOND\n";
else
cout << "DRAW\n";
}
int dp(int i, int j) {
if (i % 2 == 1 && f[i][j] != kInf) return f[i][j];
if (i % 2 == 0 && f[i][j] != -kInf) return f[i][j];
if (j == 0) return i % 2 == 0 ? kInf + 10 : -kInf - 10;
if (i == 2 * N - 1) return 0;
for (int k = 0; k < int((C).size()); ++k) {
int nj = 0;
for (int t = 0; t < int((dps[i]).size()); ++t) {
if ((j & (1 << t)) == 0) continue;
if (P[dps[i][t].first + 1][dps[i][t].second] == C[k])
nj |= 1 << dcn[dps[i][t].first + 1][dps[i][t].second];
if (P[dps[i][t].first][dps[i][t].second + 1] == C[k])
nj |= 1 << dcn[dps[i][t].first][dps[i][t].second + 1];
}
int nf = dp(i + 1, nj) + (C[k] == 'a' ? 1 : (C[k] == 'b' ? -1 : 0));
if (i % 2 == 1) f[i][j] = min(f[i][j], nf);
if (i % 2 == 0) f[i][j] = max(f[i][j], nf);
}
return f[i][j];
}
|
#include <bits/stdc++.h>
using namespace std;
const int Inf = 1e9;
int n;
int cd[40];
char Map[22][22];
bool done[40][1 << 20];
int dp[40][1 << 20];
vector<pair<int, int> > G[40];
void dfs(int cur, int code) {
if (cur == n + n - 2) {
dp[cur][code] = 0;
return;
}
dp[cur][code] = cur & 1 ? -Inf : Inf;
int xcode = (code << 1) | code;
if (cur >= n - 1) {
xcode &= (((1 << n) - 1) ^ ((1 << cur - n + 2) - 1));
}
for (int i = 0; i < G[cur + 1].size(); i++) {
int cost = G[cur + 1][i].first, ncode = G[cur + 1][i].second;
ncode &= xcode;
if (ncode == 0) continue;
cost = (cost == 0) - (cost == 1);
if (!done[cur + 1][ncode]) {
done[cur + 1][ncode] = 1;
dfs(cur + 1, ncode);
}
dp[cur][code] = cur & 1 ? max(dp[cur][code], cost + dp[cur + 1][ncode])
: min(dp[cur][code], cost + dp[cur + 1][ncode]);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", Map[i]);
for (int i = 0; i < n - 1 + n; i++) {
for (int j = 0; j < 26; j++) cd[j] = 0;
for (int sx = 0, sy = i; sx < n; sx++, sy--) {
if (sy >= 0 && sy < n) {
cd[Map[sx][sy] - 'a'] |= (1 << sx);
}
}
for (int j = 0; j < 26; j++)
if (cd[j]) G[i].push_back(pair<int, int>(j, cd[j]));
}
done[0][1] = 1;
dfs(0, 1);
dp[0][1] += (Map[0][0] == 'a') - (Map[0][0] == 'b');
if (dp[0][1] > 0)
puts("FIRST");
else if (dp[0][1] == 0)
puts("DRAW");
else
puts("SECOND");
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int N = 41;
int dp[N][1 << 20];
char c[N][N];
int a[N][N];
int n;
int dfs(int x, int y) {
if (dp[x][y] != INF) return dp[x][y];
int w = (y | (y << 1));
int s[26] = {0};
for (int h = 0, x1 = x, y1 = 1; h < n; ++h, x1--, y1++)
if ((y & (1 << h)) && x1 >= 1 && y1 <= n) {
dp[x][y] = a[x1][y1];
break;
}
if (x == 2 * n - 1) return dp[x][y];
for (int h = 0, x1 = x + 1, y1 = 1; h < n; ++h, x1--, y1++)
if ((w & (1 << h)) && x1 >= 1 && y1 <= n) {
int t = c[x1][y1] - 'a';
s[t] = (s[t] | (1 << h));
}
int k0 = -INF, k1 = INF;
for (int i = 0; i < 26; ++i)
if (s[i] > 0) {
k0 = max(k0, dfs(x + 1, s[i]));
k1 = min(k1, dfs(x + 1, s[i]));
}
if ((x & 1))
dp[x][y] += k1;
else
dp[x][y] += k0;
return dp[x][y];
}
int main() {
while (cin >> n) {
int m = (1 << n);
for (int i = 0; i < N; ++i)
for (int j = 0; j < m; ++j) dp[i][j] = INF;
memset(c, 0, sizeof(c));
memset(a, 0, sizeof(a));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) {
cin >> c[i][j];
if (c[i][j] == 'a') a[i][j] = 1;
if (c[i][j] == 'b') a[i][j] = -1;
}
int k = dfs(1, 1);
if (k > 0) cout << "FIRST" << endl;
if (k < 0) cout << "SECOND" << endl;
if (k == 0) cout << "DRAW" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int n, rmh[22 * 2][30], flag[44];
char s[22][22];
map<pair<int, int>, int> mp;
int dfs(int k, int cur) {
if (k == 2 * n - 2) return 0;
if (mp.count(make_pair(k, cur))) return mp[make_pair(k, cur)];
int rlt, that = (cur | (cur << 1));
if (k % 2) {
rlt = -INF;
for (int c = 0, now; c < 26; c++) {
now = that & rmh[k + 1][c];
if (!now) continue;
rlt = max(rlt, flag[c] + dfs(k + 1, now));
}
} else {
rlt = INF;
for (int c = 0, now; c < 26; c++) {
now = that & rmh[k + 1][c];
if (!now) continue;
rlt = min(rlt, flag[c] + dfs(k + 1, now));
}
}
mp[make_pair(k, cur)] = rlt;
return rlt;
}
int main() {
scanf("%d\n", &n);
flag[0] = 1;
flag[1] = -1;
for (int i = 0; i < n; i++) gets(s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) s[i][j] -= 'a';
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) rmh[i + j][s[i][j]] |= (1 << i);
int ans = flag[s[0][0]] + dfs(0, 1);
if (ans > 0)
puts("FIRST");
else if (ans < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[22][22];
int v[22][22];
int mask[26][42];
int f[40][1 << 20];
bool bio[40][1 << 20];
int n;
int solve(int k, int s) {
if (bio[k][s]) return f[k][s];
bio[k][s] = true;
bool player = (k + 1) & 1;
f[k][s] = player ? 10000 : -10000;
int ns = 0;
for (int j = 0; j < (n); ++j)
if (s & (1 << j)) {
if (j + 1 < n) ns |= (1 << (j + 1));
if (k - j + 1 < n) ns |= (1 << j);
}
for (int j = 0; j < (n); ++j)
if (s & (1 << j)) {
int i = k - j;
if (i + 1 < n) {
int score = v[i + 1][j] + solve(k + 1, ns & mask[a[i + 1][j]][k + 1]);
if (player)
f[k][s] = min(f[k][s], score);
else
f[k][s] = max(f[k][s], score);
}
if (j + 1 < n) {
int score = v[i][j + 1] + solve(k + 1, ns & mask[a[i][j + 1]][k + 1]);
if (player)
f[k][s] = min(f[k][s], score);
else
f[k][s] = max(f[k][s], score);
}
}
return f[k][s];
}
int main(void) {
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
scanf("%s", a[i]);
for (int j = 0; j < (n); ++j) {
a[i][j] -= 'a';
if (a[i][j] == 0)
v[i][j] = 1;
else if (a[i][j] == 1)
v[i][j] = -1;
}
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) mask[a[i][j]][i + j] |= 1 << j;
bio[2 * n - 2][1 << (n - 1)] = 1;
f[2 * n - 2][1 << (n - 1)] = 0;
int ans = solve(0, 1) + v[0][0];
if (ans > 0)
puts("FIRST");
else if (ans < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXL = 0x3f3f3f3f;
const int mxn = 20;
int n;
int val[26] = {+1, -1};
int msk[26][mxn * 2 + 1];
string a[mxn];
int f[mxn * 2 + 1][1 << mxn];
bool v[mxn * 2 + 1][1 << mxn];
int dfs(int x, int s) {
if (x == (n - 1) * 2) return 0;
if (v[x][s]) return f[x][s];
if (x & 1) {
int re = -MXL;
int m;
for (int i = 0; i < 26; ++i)
if (m = x < n - 1 ? ((s | s << 1) & msk[i][x + 1])
: ((s | s >> 1) & msk[i][x + 1]))
re = max(re, dfs(x + 1, m) + val[i]);
return v[x][s] = true, f[x][s] = re;
} else {
int re = MXL;
int m;
for (int i = 0; i < 26; ++i)
if (m = x < n - 1 ? ((s | s << 1) & msk[i][x + 1])
: ((s | s >> 1) & msk[i][x + 1]))
re = min(re, dfs(x + 1, m) + val[i]);
return v[x][s] = true, f[x][s] = re;
}
}
void EXEC() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int c = 0; c < 26; ++c)
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (a[i][j] - 'a' == c) msk[c][i + j] |= 1 << min(n - 1 - i, j);
int ans = dfs(0, 1) + val[a[0][0] - 'a'];
if (ans < 0)
cout << "SECOND" << endl;
else if (ans > 0)
cout << "FIRST" << endl;
else
cout << "DRAW" << endl;
}
int main() {
EXEC();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
char mp[25][25];
int n;
int a[45][26];
int dp[45][(1 << 20)];
int dfs(int dep, int sta) {
int num = 0;
if (dp[dep][sta] != inf) return dp[dep][sta];
for (int i = 0, k = dep; i < n; i++, k--) {
if (sta >> i & 1) {
if (mp[k][i] == 'a')
num++;
else if (mp[k][i] == 'b')
num--;
break;
}
}
if (dep >= 2 * n - 2) return dp[dep][sta] = num;
int &tmp = dp[dep][sta];
if (dep % 2 != 0) {
tmp = -inf;
for (int i = 0; i < 26; i++) {
int next = a[dep + 1][i] & (sta | (sta << 1));
if (next == 0) continue;
tmp = max(tmp, dfs(dep + 1, next) + num);
}
} else {
for (int i = 0; i < 26; i++) {
int next = a[dep + 1][i] & (sta | (sta << 1));
if (next == 0) continue;
tmp = min(tmp, dfs(dep + 1, next) + num);
}
}
return tmp;
}
void pre() {
for (int i = 0; i < 2 * n - 1; i++) {
int k = i;
for (int j = 0; j < n; j++) {
if (k < 0) break;
a[i][mp[k][j] - 'a'] |= (1 << j);
k--;
}
}
}
int main() {
while (cin >> n) {
for (int i = 0; i < n; i++) cin >> mp[i];
pre();
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < (1 << n); j++) dp[i][j] = inf;
int res = dfs(0, 1);
if (res > 0) {
puts("FIRST");
continue;
}
if (res < 0) {
puts("SECOND");
continue;
}
puts("DRAW");
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool f = 0;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return f ? -x : x;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
void writep(long long x) {
write(x);
putchar(' ');
}
const int N = 45, M = (1 << 20) + 5, inf = 1 << 30;
int n, m, f[N][M], pos[N][N], a[N][N];
char s[N][N];
vector<pair<int, int> > v[N];
bool used[N][M];
int dfs(int u, int s) {
if (u == 2 * n - 1) return 0;
if (used[u][s]) return f[u][s];
int res = ((u & 1) ? inf : -inf);
for (int k = (int)(0); k <= (int)(25); k++) {
int t = 0, alb = 0;
if (k == 0) t = 1;
if (k == 1) t = -1;
for (int i = (int)(0); i <= (int)((int)v[u].size() - 1); i++) {
if ((s >> i) & 1) {
int x = v[u][i].first, y = v[u][i].second;
if (x + 1 <= n && a[x + 1][y] == k) alb |= (1 << pos[x + 1][y]);
if (y + 1 <= n && a[x][y + 1] == k) alb |= (1 << pos[x][y + 1]);
}
}
if (alb == 0) continue;
if (u & 1)
res = min(res, t + dfs(u + 1, alb));
else
res = max(res, t + dfs(u + 1, alb));
}
used[u][s] = 1;
return f[u][s] = res;
}
int main() {
n = read();
for (int i = (int)(1); i <= (int)(n); i++) {
scanf("%s", s[i] + 1);
for (int j = (int)(1); j <= (int)(n); j++) a[i][j] = s[i][j] - 'a';
}
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(1); j <= (int)(n); j++) {
pos[i][j] = v[i + j - 1].size();
v[i + j - 1].push_back(make_pair(i, j));
}
int ans = dfs(1, 1);
if (s[1][1] == 'a') ans++;
if (s[1][1] == 'b') ans--;
if (ans == 0)
puts("DRAW");
else if (ans > 0)
puts("FIRST");
else
puts("SECOND");
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
T abs(T x) {
return x < 0 ? -x : x;
}
template <typename T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
const int INF = (int)1e+9 + 7;
const int MAXN = 55;
string s[MAXN];
int n;
map<pair<int, int>, int> M;
int get(int l, int m) {
pair<int, int> p = make_pair(l, m);
if (M.find(p) != M.end()) return M[p];
int &r = M[p];
if (l == 2 * n - 2) {
r = 0;
} else {
if (l & 1)
r = -INF;
else
r = INF;
l += 1;
int msk[26], ind = 0;
memset(msk, 0, sizeof(msk));
for (int i = 0; i <= l; i++) {
int x = l - i;
int y = i;
if (x >= n || y >= n) continue;
msk[s[x][y] - 'a'] |= 1 << ind;
ind += 1;
}
l -= 1;
for (int i = 0; i < 26; i++)
if (msk[i]) {
int x;
if (l + 1 < n)
x = (m | (m << 1)) & msk[i];
else
x = (m | (m >> 1)) & msk[i];
if (x == 0) continue;
int d = i == 0 ? 1 : (i == 1 ? -1 : 0);
if (l & 1)
r = max(r, get(l + 1, x) + d);
else
r = min(r, get(l + 1, x) + d);
}
}
if (l == 0) {
if (s[0][0] == 'a')
r += 1;
else if (s[0][0] == 'b')
r -= 1;
}
return r;
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
while (cin >> n) {
M.clear();
for (int i = 0; i < n; i++) cin >> s[i];
int r = get(0, 1);
if (r > 0)
cout << "FIRST" << endl;
else if (r < 0)
cout << "SECOND" << endl;
else
cout << "DRAW" << endl;
break;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
const int INF = 100000;
const int N = 22;
char st[N][N];
int n, dp[2 * N][1 << 20];
bool mark[2 * N][1 << 20];
int cnt, x[N], y[N];
int minimize(int d, int m);
int maximize(int d, int m) {
if (d == 2 * n - 2) return 0;
if (mark[d][m]) return dp[d][m];
int &cur = dp[d][m];
cur = -INF;
mark[d][m] = true;
cnt = 0;
int neig = 0;
for (int j = 0; j < n; ++j) {
if ((m >> j) & 1) {
x[cnt] = j;
y[cnt] = d - j;
int yy = d + 1 - j;
if (yy >= 0 && yy < n) neig |= (1 << j);
yy = d - j;
if (j != n - 1 && yy >= 0 && yy < n) neig |= (1 << (j + 1));
++cnt;
}
}
int mask[26];
memset(mask, 0, sizeof mask);
for (int x = 0; x <= d + 1; ++x) {
if (x >= n) break;
int y = d + 1 - x;
if (y < 0 || y >= n) continue;
mask[st[x][y] - 'a'] |= (1 << x);
}
for (int c = 0; c < 26; ++c) {
int to = (neig & mask[c]);
if (!to) continue;
if (c == 0)
cur = max(cur, minimize(d + 1, to) + 1);
else if (c == 1)
cur = max(cur, minimize(d + 1, to) - 1);
else
cur = max(cur, minimize(d + 1, to));
}
return cur;
}
int minimize(int d, int m) {
if (d == 2 * n - 2) return 0;
if (mark[d][m]) return dp[d][m];
int &cur = dp[d][m];
cur = INF;
mark[d][m] = true;
cnt = 0;
int neig = 0;
for (int j = 0; j < n; ++j) {
if ((m >> j) & 1) {
x[cnt] = j;
y[cnt] = d - j;
int yy = d + 1 - j;
if (yy >= 0 && yy < n) neig |= (1 << j);
yy = d - j;
if (j != n - 1 && yy >= 0 && yy < n) neig |= (1 << (j + 1));
++cnt;
}
}
int mask[26];
memset(mask, 0, sizeof mask);
for (int x = 0; x <= d + 1; ++x) {
if (x >= n) break;
int y = d + 1 - x;
if (y < 0 || y >= n) continue;
mask[st[x][y] - 'a'] |= (1 << x);
}
for (int c = 0; c < 26; ++c) {
int to = (neig & mask[c]);
if (!to) continue;
if (c == 0)
cur = min(cur, maximize(d + 1, to) + 1);
else if (c == 1)
cur = min(cur, maximize(d + 1, to) - 1);
else
cur = min(cur, maximize(d + 1, to));
}
return cur;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> st[i];
int coef = 0;
if (st[0][0] == 'a') coef = 1;
if (st[0][0] == 'b') coef = -1;
int res = minimize(0, 1) + coef;
if (res > 0)
puts("FIRST");
else if (res == 0)
puts("DRAW");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int n;
char g[N][N + 1];
int dp[N + N][1 << N];
bool was[N + N][1 << N];
inline int value(char c) {
if (c == 'a')
return 1;
else if (c == 'b')
return -1;
else
return 0;
}
inline bool test(int m, int i) { return (m >> i) & 1; }
int solve(int diagonal, int mask) {
if (diagonal == n + n - 2) return 0;
int &res = dp[diagonal][mask];
if (was[diagonal][mask]) return res;
was[diagonal][mask] = 1;
vector<int> newMask(26, 0);
for (int i = 0; i < n; ++i) {
if (test(mask, i) || (i > 0 && test(mask, i - 1))) {
int j = diagonal + 1 - i;
if (0 <= j && j < n) {
newMask[g[i][j] - 'a'] |= 1 << i;
}
}
}
bool first = diagonal % 2;
res = first ? -N : N;
for (int c = 0; c < 26; ++c) {
if (newMask[c] == 0) continue;
int ret = solve(diagonal + 1, newMask[c]) + value(c + 'a');
if (first)
res = max(res, ret);
else
res = min(res, ret);
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%s", g[i]);
}
int ans = solve(0, 1) + value(g[0][0]);
if (ans == 0)
puts("DRAW");
else if (ans > 0)
puts("FIRST");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:640000000")
using namespace std;
const double eps = 1e-9;
const double pi = acos(-1.0);
const int inf = (int)1e9;
map<int, int> d[44];
string s[22];
int n;
int get(int r, int mask) {
if (r == 2 * n - 2) return 0;
if (d[r].count(mask)) return d[r][mask];
int res;
if (r % 2 == 1) {
res = -inf;
} else {
res = inf;
}
if (r < n - 1) {
for (int i = 0; i < 26; i++) {
int sub = 0;
for (int j = 0; j <= r; j++)
if (mask & (1 << j)) {
int x = r - j;
int y = j;
if (s[x + 1][y] == i) {
sub |= (1 << j);
}
if (s[x][y + 1] == i) {
sub |= (1 << (j + 1));
}
}
if (sub == 0) continue;
if (r % 2 == 1) {
res = max(res, get(r + 1, sub) + (i == 0) - (i == 1));
} else {
res = min(res, get(r + 1, sub) + (i == 0) - (i == 1));
}
}
} else {
for (int i = 0; i < 26; i++) {
int sub = 0;
for (int j = 0; j <= 2 * n - 2 - r; j++)
if (mask & (1 << j)) {
int x = n - 1 - j;
int y = j + r - (n - 1);
if (x + 1 < n && s[x + 1][y] == i) {
sub |= (1 << (j - 1));
}
if (y + 1 < n && s[x][y + 1] == i) {
sub |= (1 << j);
}
}
if (sub == 0) continue;
if (r % 2 == 1) {
res = max(res, get(r + 1, sub) + (i == 0) - (i == 1));
} else {
res = min(res, get(r + 1, sub) + (i == 0) - (i == 1));
}
}
}
return d[r][mask] = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < n; j++) {
s[i][j] -= 'a';
}
}
int res = get(0, 1) + (s[0][0] == 0) - (s[0][0] == 1);
if (res > 0) {
cout << "FIRST" << endl;
} else if (res < 0) {
cout << "SECOND" << endl;
} else {
cout << "DRAW" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int n;
int dp[40][1 << 20], f[N][N];
char g[N][N];
bool u[40][1 << 20];
int dfs(int c, int zt, int t) {
if (c == n + n - 2) {
if (g[n - 1][n - 1] == 'a') return 1;
if (g[n - 1][n - 1] == 'b') return -1;
return 0;
}
if (u[c][zt]) return dp[c][zt];
u[c][zt] = true;
int tmp = 0, rt, i, j;
if (t > 0)
rt = 100;
else
rt = -100;
int d = c + 1;
if (d > n) d = n - (d - n);
for (i = 0; i < d; i++)
if (zt & (1 << i)) {
int x, y;
if (c < n) {
x = i;
y = c - x;
} else {
x = n - 1 - i;
y = c - x;
}
if (g[x][y] == 'a') tmp = 1;
if (g[x][y] == 'b') tmp = -1;
if (x + 1 < n) {
int nt = 0;
for (j = 0; j < d; j++)
if (zt & (1 << j)) {
int px, py;
if (c < n) {
px = j;
py = c - px;
} else {
px = n - 1 - j;
py = c - px;
}
if (px + 1 < n) {
if (g[px + 1][py] == g[x + 1][y]) nt |= (1 << f[px + 1][py]);
}
if (py + 1 < n) {
if (g[px][py + 1] == g[x + 1][y]) nt |= (1 << f[px][py + 1]);
}
}
int tp = dfs(c + 1, nt, -t);
if (t > 0)
rt = ((rt) < (tp) ? (rt) : (tp));
else
rt = ((rt) > (tp) ? (rt) : (tp));
}
if (y + 1 < n) {
int nt = 0;
for (j = 0; j < d; j++)
if (zt & (1 << j)) {
int px, py;
if (c < n) {
px = j;
py = c - px;
} else {
px = n - 1 - j;
py = c - px;
}
if (px + 1 < n) {
if (g[px + 1][py] == g[x][y + 1]) nt |= (1 << f[px + 1][py]);
}
if (py + 1 < n) {
if (g[px][py + 1] == g[x][y + 1]) nt |= (1 << f[px][py + 1]);
}
}
int tp = dfs(c + 1, nt, -t);
if (t > 0)
rt = ((rt) < (tp) ? (rt) : (tp));
else
rt = ((rt) > (tp) ? (rt) : (tp));
}
}
dp[c][zt] = tmp + rt;
return dp[c][zt];
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i + j < n)
f[i][j] = i;
else {
f[i][j] = n - 1 - i;
}
}
}
for (i = 0; i < n; i++) scanf("%s", g[i]);
int rt = dfs(0, 1, 1);
if (rt > 0)
puts("FIRST");
else if (rt < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string T[22];
int s[22][22];
int dy[] = {0, 1};
int dx[] = {1, 0};
int score[128];
vector<int> dp[40];
vector<int> Y[40], X[40];
int f(int yx, int mask) {
int& res = dp[yx][mask];
if (res != 1070000000LL) return res;
if (yx == 2 * n - 2) return res = 0;
if (yx & 1)
res = -1070000000LL;
else
res = 1070000000LL;
int ok[22][22];
memset(ok, 0, sizeof(ok));
for (int i = 0; i < (((int)(Y[yx]).size())); i++) {
if (mask >> i & 1) {
ok[Y[yx][i]][X[yx][i]] = 1;
}
}
for (int ch = 'a'; ch < ('z' + 1); ch++) {
int nmask = 0;
for (int i = 0; i < (((int)(Y[yx + 1]).size())); i++) {
int y = Y[yx + 1][i], x = X[yx + 1][i];
if (T[y][x] == ch) {
int OK = 0;
for (int dir = 0; dir < (2); dir++) {
int py = y - dy[dir], px = x - dx[dir];
if (py == -1 || px == -1) continue;
if (ok[py][px]) {
OK = 1;
break;
}
}
if (OK) nmask |= 1 << i;
}
}
if (nmask != 0) {
if (yx & 1)
res = max(res, score[ch] + f(yx + 1, nmask));
else
res = min(res, score[ch] + f(yx + 1, nmask));
}
}
return res;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < (n); i++) cin >> T[i];
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) {
s[i][j] = (T[i][j] == 'a' ? 1 : (T[i][j] == 'b' ? -1 : 0));
}
for (int i = 0; i < (n); i++) dp[i].resize(1 << (i + 1), 1070000000LL);
for (int i = 0; i < (n - 1); i++)
dp[2 * n - 2 - i].resize(1 << (i + 1), 1070000000LL);
for (int i = 0; i < (n); i++)
for (int j = 0; j < (n); j++) {
Y[i + j].push_back(i);
X[i + j].push_back(j);
}
score['a'] = 1;
score['b'] = -1;
int res = s[0][0] + f(0, 1);
cout << (res > 0 ? "FIRST" : (res < 0 ? "SECOND" : "DRAW")) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int T = 40;
int d[T][T];
int ans, n, i, j;
char fix[T][1 << 20];
int dp[T][1 << 20];
int MASK[30];
int F(int x) {
if (x == 0) return 1;
if (x == 1) return -1;
return 0;
}
int go(int id, int mask) {
if (fix[id][mask] == 1) {
return dp[id][mask];
}
fix[id][mask] = 1;
if (id == 2 * n - 2) {
return (dp[id][mask] = F(d[n - 1][n - 1]));
}
for (int i = 0; i < n; i++) {
if (id - i >= 0 && id - i < n)
if (mask & (1 << i)) {
dp[id][mask] = F(d[i][id - i]);
break;
}
}
vector<int> MASK(26, 0);
int x, y;
for (int i = 0; i < n; i++) {
if (id - i >= 0 && id - i < n && ((mask & (1 << i)) > 0)) {
x = i + 1;
y = id - i;
if ((x >= 0 && x < n && y >= 0 && y < n)) MASK[d[x][y]] |= (1 << x);
x = i;
y = id - i + 1;
if ((x >= 0 && x < n && y >= 0 && y < n)) MASK[d[x][y]] |= (1 << x);
}
}
int have;
if ((id + 1) & 1)
have = 1000000500ll;
else
have = -1000000500ll;
for (int c = 0; c < 26; c++) {
if (!MASK[c]) continue;
int h = go(id + 1, MASK[c]);
if ((id + 1) & 1)
have = (have < h ? have : h);
else
have = (have > h ? have : h);
}
return (dp[id][mask] = have + dp[id][mask]);
}
int main() {
scanf("%d\n", &n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) d[i][j] = getchar() - 'a';
getchar();
}
ans = go(0, 1);
if (ans > 0)
puts("FIRST");
else if (ans < 0)
puts("SECOND");
else
puts("DRAW");
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const double eps = 1e-9;
map<vector<pair<int, int> >, int> mm;
int N;
string f[128];
void prv(vector<pair<int, int> > v) {
for (__typeof__((v).begin()) it = (v).begin(); it != (v).end(); it++)
cout << "(" << it->first << "," << it->second << ")";
}
int rek(vector<pair<int, int> > pos) {
int r = pos[0].first, c = pos[0].second;
int pm = 0;
if (f[r][c] == 'a')
++pm;
else if (f[r][c] == 'b')
--pm;
if (r == N - 1 && c == N - 1) return pm;
if (mm.find(pos) == mm.end()) {
map<char, set<pair<int, int> > > next;
for (__typeof__((pos).begin()) it = (pos).begin(); it != (pos).end();
it++) {
r = it->first, c = it->second;
if (r < N - 1) next[f[r + 1][c]].insert(make_pair(r + 1, c));
if (c < N - 1) next[f[r][c + 1]].insert(make_pair(r, c + 1));
}
int res = oo;
bool first = true;
for (__typeof__((next).begin()) it = (next).begin(); it != (next).end();
it++) {
vector<pair<int, int> > npos =
vector<pair<int, int> >((it->second).begin(), (it->second).end());
int cres = rek(npos);
if (first) {
first = false;
res = cres;
} else {
if ((r + c) & 1)
res = max(res, cres);
else
res = min(res, cres);
}
}
mm[pos] = res + pm;
}
return mm[pos];
}
int main() {
cin >> N;
for (int i = (0); i < (N); i++) cin >> f[i];
int res = rek(vector<pair<int, int> >(1, pair<int, int>(0, 0)));
if (res > 0)
cout << "FIRST\n";
else if (res < 0)
cout << "SECOND\n";
else
cout << "DRAW\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long gcd(long long a, long long b) {
return (b == 0 ? a : gcd(b, a % b));
}
const int MAXN = 200005;
const char INF = 100;
string T[55];
int n;
char pd[2][40][1 << 20];
int G[50][22];
char solve(int p, int k, int mask) {
if (k == 2 * n - 1) return 0;
if (pd[p][k][mask] == INF) {
char ans = INF;
int v[26] = {0};
int aux = n - abs(n - k);
for (int i = 0; i < aux; ++i) {
if ((1 << i) & mask) {
int a = i, b = i + 1;
if (k >= n) a--, b--;
if (a >= 0) v[G[k + 1][a]] |= 1 << a;
if (k < n || i < aux - 1) v[G[k + 1][b]] |= 1 << b;
}
}
for (int i = 0; i < 26; ++i) {
if (!v[i]) continue;
char tmp = solve(p ^ 1, k + 1, v[i]);
if (i == 0) tmp++;
if (i == 1) tmp--;
if (p) {
if (ans == INF || tmp < ans) ans = tmp;
} else {
if (ans == INF || tmp > ans) ans = tmp;
}
}
pd[p][k][mask] = ans;
}
return pd[p][k][mask];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
while (cin >> n) {
for (int i = 0; i < n; ++i) cin >> T[i];
for (int i = 1; i < 2 * n; ++i) {
int x, y;
if (i >= n) {
x = n - 1, y = i - n;
} else {
x = i - 1, y = 0;
}
int j = 0;
while (x >= 0) G[i][j++] = T[x--][y++] - 'a';
}
for (int i = 0; i < 40; ++i)
for (int j = 0; j < 1 << 20; ++j) pd[0][i][j] = pd[1][i][j] = INF;
int res = solve(1, 1, 1);
if (T[0][0] == 'a') res++;
if (T[0][0] == 'b') res--;
if (res > 0) {
cout << "FIRST" << endl;
} else if (res < 0) {
cout << "SECOND" << endl;
} else {
cout << "DRAW" << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 25;
const int MAXM = 55;
int n, dp[2][1 << 20];
char g[MAXN][MAXN];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", g[i]);
int m = 2 * n - 2;
for (int i = m; i >= 0; i--) {
int st = max(0, i - n + 1);
int en = min(n - 1, i);
for (int mask = 0; mask < (1 << (en - st + 1)); mask++) {
if (i == m) {
dp[i & 1][mask] = 0;
} else {
int ms[26] = {0};
for (int k = st; k <= en; k++)
if (mask & (1 << (k - st))) {
int j = i - k;
if (j < 0 || j >= n) continue;
if (k + 1 < n) {
if (i >= n - 1)
ms[g[k + 1][j] - 'a'] |= 1 << (k - st);
else
ms[g[k + 1][j] - 'a'] |= 1 << (k - st + 1);
}
if (j + 1 < n) {
if (i >= n - 1)
ms[g[k][j + 1] - 'a'] |= 1 << (k - st - 1);
else
ms[g[k][j + 1] - 'a'] |= 1 << (k - st);
}
}
if (i % 2 == 1) {
dp[i & 1][mask] = -1 << 20;
for (int c = 0; c < 26; c++)
if (ms[c])
dp[i & 1][mask] =
max(dp[i & 1][mask],
(c == 0) - (c == 1) - dp[(i + 1) & 1][ms[c]]);
} else {
dp[i & 1][mask] = -1 << 20;
for (int c = 0; c < 26; c++)
if (ms[c])
dp[i & 1][mask] =
max(dp[i & 1][mask],
-(c == 0) + (c == 1) - dp[(i + 1) & 1][ms[c]]);
}
}
}
}
int res = -dp[0][1] + (g[0][0] == 'a') - (g[0][0] == 'b');
if (res > 0)
printf("FIRST\n");
else if (res < 0)
printf("SECOND\n");
else
printf("DRAW\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char M[20][20 + 1];
bool done[2 * 20 - 1][(1 << 20)];
int memo[2 * 20 - 1][(1 << 20)];
int solve(int diag, int mask) {
if (diag == 2 * n - 2) return 0;
int &ret = memo[diag][mask];
if (!done[diag][mask]) {
done[diag][mask] = true;
int p = (diag & 1);
ret = (p == 0 ? 100 : -100);
for (char to = 'a'; to <= 'z'; ++to) {
int mask2 = 0;
for (int r = 0, c = diag; r < n; ++r, --c) {
if (c < n && (mask & (1 << r))) {
if (r + 1 < n && M[r + 1][c] == to) mask2 |= (1 << r + 1);
if (c + 1 < n && M[r][c + 1] == to) mask2 |= (1 << r);
}
}
if (mask2) {
int aux = solve(diag + 1, mask2);
if (to == 'a')
++aux;
else if (to == 'b')
--aux;
if (p == 0)
ret = min(ret, aux);
else
ret = max(ret, aux);
}
}
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%s", M[i]);
memset(done, false, sizeof done);
int ret = solve(0, 1);
if (M[0][0] == 'a')
++ret;
else if (M[0][0] == 'b')
--ret;
if (ret == 0)
puts("DRAW");
else if (ret > 0)
puts("FIRST");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = int(1e9);
const double eps = 1e-9;
const double pi = 4 * atan(double(1));
const int N = 20;
int n;
char a[N + 10][N + 10];
int used[30][N + 10][N + 10];
int num[N + 10][N + 10];
int x[2 * N + 10], y[2 * N + 10], sz[2 * N + 10];
int d[(1 << N) + 10], nd[(1 << N) + 10];
vector<pair<int, int> > lst[30];
inline bool good(int x, int y) { return x >= 0 && x < n && y >= 0 && y < n; }
int main() {
scanf("%d", &n);
gets(a[0]);
for (int i = 0; i < n; i++) {
gets(a[i]);
for (int j = 0; j < n; j++) {
a[i][j] -= 'a';
}
}
int cx = 0, cy = 0;
for (int i = 0; i < 2 * n - 1; i++) {
x[i] = cx;
y[i] = cy;
sz[i] = 0;
int ix = cx, iy = cy;
while (good(ix, iy)) {
num[ix][iy] = sz[i]++;
ix++;
iy--;
}
cy++;
if (cy >= n) {
cy = n - 1;
cx++;
}
}
int step = 0;
for (int i = 2 * n - 3; i >= 0; i--) {
for (int j = 1; j < (1 << sz[i]); j++) {
for (int z = 0; z < 26; z++) {
lst[z].clear();
}
int cx = x[i], cy = y[i];
step++;
for (int z = 0; z < sz[i]; z++) {
if ((j & (1 << z)) != 0) {
if (good(cx, cy + 1) && used[a[cx][cy + 1]][cx][cy] != step) {
used[a[cx][cy + 1]][cx][cy] = step;
lst[a[cx][cy + 1]].push_back(make_pair(cx, cy));
}
if (good(cx + 1, cy) && used[a[cx + 1][cy]][cx][cy] != step) {
used[a[cx + 1][cy]][cx][cy] = step;
lst[a[cx + 1][cy]].push_back(make_pair(cx, cy));
}
}
cx++;
cy--;
}
if (i % 2 != 0) {
nd[j] = -inf;
} else {
nd[j] = inf;
}
for (int z = 0; z < 26; z++) {
int nj = 0;
for (int h = 0; h < int((lst[z]).size()); h++) {
cx = lst[z][h].first;
cy = lst[z][h].second;
if (good(cx, cy + 1) && a[cx][cy + 1] == z) {
nj |= (1 << num[cx][cy + 1]);
}
if (good(cx + 1, cy) && a[cx + 1][cy] == z) {
nj |= (1 << num[cx + 1][cy]);
}
}
if (nj == 0) {
continue;
}
int res = d[nj];
if (z == 0) {
res++;
}
if (z == 1) {
res--;
}
if (i % 2 != 0) {
nd[j] = max(nd[j], res);
} else {
nd[j] = min(nd[j], res);
}
}
}
for (int j = 1; j < (1 << sz[i]); j++) {
d[j] = nd[j];
}
}
int res = d[1];
if (a[0][0] == 0) {
res++;
}
if (a[0][0] == 1) {
res--;
}
if (res == 0) {
puts("DRAW");
return 0;
}
if (res > 0) {
puts("FIRST");
return 0;
}
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
char mp[25][25];
int n;
int a[45][26];
int dp[45][(1 << 20)];
int dfs(int dep, int sta) {
int num = 0;
if (dp[dep][sta] != inf) return dp[dep][sta];
for (int i = 0, k = dep; i < n; i++, k--) {
if (sta >> i & 1) {
if (mp[k][i] == 'a')
num++;
else if (mp[k][i] == 'b')
num--;
break;
}
}
if (dep >= 2 * n - 2) return dp[dep][sta] = num;
int &tmp = dp[dep][sta];
if (dep % 2 != 0) {
tmp = -inf;
for (int i = 0; i < 26; i++) {
int next = a[dep + 1][i] & (sta | (sta << 1));
if (next == 0) continue;
tmp = max(tmp, dfs(dep + 1, next) + num);
}
} else {
for (int i = 0; i < 26; i++) {
int next = a[dep + 1][i] & (sta | (sta << 1));
if (next == 0) continue;
tmp = min(tmp, dfs(dep + 1, next) + num);
}
}
return tmp;
}
void pre() {
for (int i = 0; i < 2 * n - 1; i++) {
int k = i;
for (int j = 0; j < n; j++) {
if (k < 0) break;
a[i][mp[k][j] - 'a'] |= (1 << j);
k--;
}
}
}
int main() {
ios::sync_with_stdio(false);
while (cin >> n) {
for (int i = 0; i < n; i++) cin >> mp[i];
pre();
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < (1 << n); j++) dp[i][j] = inf;
int res = dfs(0, 1);
if (res > 0) {
puts("FIRST");
continue;
}
if (res < 0) {
puts("SECOND");
continue;
}
puts("DRAW");
}
}
|
#include <bits/stdc++.h>
using namespace std;
char s[22][22];
map<int, int> Map[50];
int Next[50][26], n;
int dfs(int id, int value) {
if (Map[id].count(value)) return Map[id][value];
int &res = Map[id][value];
if (id == 2 * n - 1) return res;
res = -10000000;
int con;
for (int i = 0; i < 26; i++) {
int tmp = !value ? 1 : (value | (value << 1));
tmp &= Next[id][i];
if (tmp) {
con = -dfs(id + 1, tmp);
if (id & 1) {
if (i == 1)
con++;
else if (i == 0)
con--;
} else {
if (i == 0)
con++;
else if (i == 1)
con--;
}
res = max(res, con);
}
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) Next[i + j][s[i][j] - 'a'] |= (1 << (j));
int re = dfs(0, 0);
if (!re)
puts("DRAW");
else if (re > 0)
puts("FIRST");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char S[20][20];
int dp[2][((1 << 20) + 1)];
int dr[] = {1, 0};
int dc[] = {0, 1};
int N;
int size_row(int r) {
if (r <= (N - 1))
return r + 1;
else
return 2 * N - 2 - r + 1;
}
int row(int r, int x) {
if (r <= (N - 1))
return r - x;
else
return (N - 1) - x;
}
int col(int r, int x) {
if (r <= (N - 1))
return x;
else
return x + r - (N - 1);
}
int pos(int i, int j) {
return j + min(0, N - 1 - (i + j));
int r = (i + j);
if (r <= N - 1)
return j;
else
return j + (N - 1) - r;
}
int bits[(2 * 20)][300];
int nbrs[(2 * 20)][((1 << 20) + 1)];
int main() {
cin >> N;
for (int i = 0; i < (N); ++i) scanf("%s", S[i]);
for (int r = 0; r < (2 * N - 1); ++r) {
int M = size_row(r);
for (int x = 0; x < (M); ++x) {
int i = row(r, x);
int j = col(r, x);
assert(i < N && j < N && i >= 0 && j >= 0);
bits[r][(int)S[i][j]] |= (1 << x);
}
int maxS = (1 << M);
int i, j, i2, j2;
for (int s = 0; s < (maxS); ++s) {
for (int x = 0; x < (M); ++x) {
if (!(s & (1 << x))) continue;
i = row(r, x), j = col(r, x);
for (int mv = 0; mv < (2); ++mv) {
i2 = i + dr[mv];
j2 = j + dc[mv];
if (i2 < 0 || j2 < 0 || i2 >= N || j2 >= N) continue;
nbrs[r][s] |= (1 << (pos(i2, j2)));
}
}
}
}
int prev = 0, next = 1;
for (int s = 0; s < (((1 << 20) + 1)); ++s) dp[prev][s] = 10000;
dp[prev][1] = 0;
for (int r = ((2 * N - 3)); r >= (0); --r) {
int p = r % 2;
int M = size_row(r);
int maxS = (1 << M);
for (int s = 0; s < (maxS); ++s) {
if (p == 1)
dp[next][s] = -10000;
else
dp[next][s] = 10000;
}
int news;
for (int s = 0; s < (maxS); ++s) {
for (int chr = ('a'); chr <= ('z'); ++chr) {
news = nbrs[r][s] & bits[r + 1][chr];
if (!news) continue;
if (dp[prev][news] == 10000 || dp[prev][news] == -10000) continue;
int result = dp[prev][news] + ((int)(chr == 'a') - (int)(chr == 'b'));
if (p == 1)
dp[next][s] = max(dp[next][s], result);
else if (p == 0)
dp[next][s] = min(dp[next][s], result);
else
assert(false);
}
}
swap(next, prev);
}
int ans = dp[prev][1] + ((int)(S[0][0] == 'a')) - ((int)(S[0][0] == 'b'));
printf("%s\n", (ans == 0 ? "DRAW" : ans > 0 ? "FIRST" : "SECOND"));
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 20;
const int MVAL = 1000000000;
int dp[2 * MN][1 << MN];
char grid[MN][MN];
int a[2 * MN][26];
int n;
int dfs(int d, int mask) {
if (dp[d][mask] != MVAL) return dp[d][mask];
int ans = 0, i;
for ((i) = 0; (i) < (int)(n); ++(i)) {
if ((mask >> i) & 1) {
if (grid[i][d - i] == 'a') ++ans;
if (grid[i][d - i] == 'b') --ans;
break;
}
}
if (d == 2 * n - 2) return dp[d][mask] = ans;
if (d % 2) {
dp[d][mask] = -MVAL;
for ((i) = 0; (i) < (int)(26); ++(i)) {
int nmask = a[d + 1][i] & (mask | (mask << 1));
if (nmask == 0) continue;
dp[d][mask] = max(dp[d][mask], dfs(d + 1, nmask) + ans);
}
} else {
for ((i) = 0; (i) < (int)(26); ++(i)) {
int nmask = a[d + 1][i] & (mask | (mask << 1));
if (nmask == 0) continue;
dp[d][mask] = min(dp[d][mask], dfs(d + 1, nmask) + ans);
}
}
return dp[d][mask];
}
int main() {
int i, j;
scanf("%d", &n);
for ((i) = 0; (i) < (int)(n); ++(i)) scanf("%s", grid[i]);
for ((i) = 0; (i) < (int)(2 * n); ++(i))
for ((j) = 0; (j) < (int)(n); ++(j)) {
if (i - j < 0 || i - j >= n) continue;
a[i][grid[j][i - j] - 'a'] |= 1 << j;
}
for ((i) = 0; (i) < (int)(2 * n); ++(i))
for ((j) = 0; (j) < (int)(1 << n); ++(j)) dp[i][j] = MVAL;
dfs(0, 1);
if (dp[0][1] > 0)
puts("FIRST");
else if (dp[0][1] < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char s[22][22];
bool used[40][1 << 20];
int dp[40][1 << 20];
inline int val(char c) {
if (c == 'a') return 1;
if (c == 'b') return -1;
return 0;
}
int f(int sum, int mask) {
if (sum == 2 * n - 2) return 0;
if (used[sum][mask]) return dp[sum][mask];
pair<int, int> t[100];
int ct = 0;
for (int i = (0); i <= (int(n) - 1); i++)
if (mask & (1 << i)) {
t[ct].first = i;
t[ct++].second = sum - i;
}
int nmask[26];
for (int i = (0); i <= (int(26) - 1); i++) nmask[i] = 0;
for (int i = (0); i <= (int(ct) - 1); i++) {
for (int dx = 0; dx <= 1; dx++) {
pair<int, int> q = t[i];
q.first += dx;
q.second += 1 ^ dx;
if (q.first >= n || q.second >= n) continue;
nmask[s[q.first][q.second] - 'a'] |= 1 << q.first;
}
}
int res = 0;
if (sum % 2 == 1) {
res = -1000000000;
} else {
res = 1000000000;
}
for (int i = (0); i <= (int(26) - 1); i++) {
if (!nmask[i]) continue;
int v = f(sum + 1, nmask[i]) + val('a' + i);
if (sum % 2 == 1) {
res = max(res, v);
} else {
res = min(res, v);
}
}
used[sum][mask] = true;
return dp[sum][mask] = res;
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for (int i = (0); i <= (int(n) - 1); i++) scanf("%s", s[i]);
int first = f(0, 1);
first += val(s[0][0]);
if (first == 0) {
cout << "DRAW" << endl;
} else if (first > 0) {
cout << "FIRST" << endl;
} else {
cout << "SECOND" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T Mul(T x, T y, T P) {
T F1 = 0;
while (y) {
if (y & 1) {
F1 += x;
if (F1 < 0 || F1 >= P) F1 -= P;
}
x <<= 1;
if (x < 0 || x >= P) x -= P;
y >>= 1;
}
return F1;
}
template <class T>
T Pow(T x, T y, T P) {
T F1 = 1;
x %= P;
while (y) {
if (y & 1) {
F1 = Mul(F1, x, P);
}
x = Mul(x, x, P);
y >>= 1;
}
return F1;
}
template <class T>
T Gcd(T x, T y) {
if (y == 0) return x;
T z;
while (z = x % y) {
x = y, y = z;
}
return y;
}
template <class T>
void UpdateMin(T &x, T y) {
if (y < x) {
x = y;
}
}
template <class T>
void UpdateMax(T &x, T y) {
if (x < y) {
x = y;
}
}
template <class T>
T Sqr(const T x) {
return x * x;
}
template <class T>
T Abs(const T x) {
return x < 0 ? -x : x;
}
class ReadBuffer {
private:
char buff[20000000];
char *buf;
public:
void init(int size = 20000000) {
fread(buff, 1, size, stdin);
buf = buff;
}
template <class T>
bool readInteger(T &x) {
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag;
flag = 0;
if (*buf == '-')
flag = true;
else
x = *buf - '0';
while (isdigit(*++buf)) x = x * 10 + *buf - '0';
if (flag) x = -x;
return true;
}
template <class T>
bool readFloat(T &x) {
long double nowpos = 0.1;
x = 0;
while (*buf && isspace(*buf)) ++buf;
if (*buf == 0) return false;
static bool flag, decimal;
decimal = flag = 0;
if (*buf == '-')
flag = true, ++buf;
else if (*buf == '.')
decimal = true;
while (isdigit(*buf) || *buf == '.') {
if (*buf == '.')
decimal = true;
else {
if (decimal) {
x += nowpos * (*buf - '0');
nowpos *= 0.1;
} else {
x = x * 10 + *buf - '0';
}
}
++buf;
}
return true;
}
bool readChar(char c) {
if (*buf == 0) return 0;
return c = *buf++, 1;
}
bool readString(char *s) {
while (*buf && isspace(*buf)) ++buf;
if (!*buf) return false;
while (!isspace(*buf)) *s++ = *buf++;
*s++ = 0;
return true;
}
int countSpacetonext() {
int total = 0;
while (*buf && *buf == ' ') ++total, ++buf;
return total;
}
bool splitBycharactor(char *s, char Split = '\n') {
while (*buf && *buf != Split) *s++ = *buf++;
*s++ = 0;
return *buf != 0;
}
};
struct EDGE {
int T;
EDGE *Nxt;
};
int dp[43][1048580];
char s[30][30];
inline int change(char s, int np) {
if (s == 'a') return np ? -1 : 1;
if (s == 'b') return np ? 1 : -1;
return 0;
}
int n;
bool fix[43][1048580];
bool ban[30][30];
bool correct[30][30];
int solve(int i, int j, char pos, char neg, int deep, int opt) {
fix[deep][opt] = 1;
dp[deep][opt] = s[i][j] == pos ? 1 : (s[i][j] == neg ? -1 : 0);
int fans = ~0U >> 1;
if (i == n && j == n) return dp[deep][opt];
for (int k = 1; k <= n; ++k) {
int l = i + j + 1 - k;
if (l > 0 && l <= n) ban[k][l] = correct[k][l] = 0;
}
for (int k = 1; k <= n; ++k) {
int l = i + j - k;
if (l > 0 && l <= n) {
if (correct[k][l]) ban[k + 1][l] = ban[k][l + 1] = 1;
}
}
for (int k = 1; k <= n; ++k) {
int l = i + j + 1 - k;
if (l > 0 && l <= n) {
if (ban[k][l]) {
int nopt = 0;
for (int x = 1; x <= n; ++x) {
int y = i + j + 1 - x;
if (y > 0 && y <= n) {
if (ban[x][y] && s[x][y] == s[k][l]) {
nopt |= 1 << (x - 1);
ban[x][y] = 0;
correct[x][y] = 1;
} else
correct[x][y] = 0;
}
}
if (!fix[deep + 1][nopt]) solve(k, l, neg, pos, deep + 1, nopt);
UpdateMin(fans, dp[deep + 1][nopt]);
}
}
}
return dp[deep][opt] -= fans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
}
correct[1][1] = 1;
int ans = solve(1, 1, 'b', 'a', 0, 1);
printf("%s\n", ans < 0 ? "FIRST" : (ans > 0 ? "SECOND" : "DRAW"));
scanf("%d", &n);
return 0;
}
|
#include <bits/stdc++.h>
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
using namespace std;
const int MAXN = 20;
const int INF = 1e8;
string T[MAXN];
int n;
int memo[2 * MAXN][1 << MAXN];
int dfs(int step, int mask) {
int& ret = memo[step][mask];
if (ret != -INF) return ret;
if (step == 2 * n - 2) return ret = 0;
if (step % 2)
ret = -INF;
else
ret = INF;
for (char c = 'a'; c <= 'z'; c++) {
int nmask = 0;
for (int y = 0; y < n; y++) {
if ((mask & (1 << y)) == 0) continue;
int x = step - y;
if (x < 0 || x >= n) continue;
int ny = y + 1, nx = x + 1;
if (ny < n && T[ny][x] == c) nmask |= 1 << ny;
if (nx < n && T[y][nx] == c) nmask |= 1 << y;
}
if (nmask) {
int tmp = dfs(step + 1, nmask);
if (c == 'a')
tmp++;
else if (c == 'b')
tmp--;
if (step % 2)
ret = max(ret, tmp);
else
ret = min(ret, tmp);
}
}
return ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> T[i];
for (int i = 0; i < 2 * MAXN; i++)
for (int j = 0; j < (1 << MAXN); j++) memo[i][j] = -INF;
int ans = dfs(0, 1);
if (T[0][0] == 'a')
ans++;
else if (T[0][0] == 'b')
ans--;
if (ans > 0)
cout << "FIRST" << endl;
else if (ans == 0)
cout << "DRAW" << endl;
else
cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 50;
const int MSZ = (1 << 20) + 100;
const int INF = 1e9 + 10;
int n;
int dp[MN][MSZ];
char ch[MN][MN];
bool seen[MN][MSZ];
void input() {
cin >> n;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) cin >> ch[i][j];
}
bool valid(int r, int c) {
if (min(r, c) < 0 || max(r, c) >= n) return false;
return true;
}
int make(int dia, int msk) {
if (seen[dia][msk]) return dp[dia][msk];
seen[dia][msk] = true;
if (dia == 2 * n - 2) return 0;
int m[30];
memset(m, 0, sizeof m);
for (int i = 0; i < n; ++i)
if (msk & (1 << i)) {
int c = dia - i;
int r = i;
if (valid(r, c + 1)) m[ch[r][c + 1] - 'a'] |= (1 << i);
if (valid(r + 1, c)) m[ch[r + 1][c] - 'a'] |= (1 << (i + 1));
}
int ans;
if (dia % 2 == 0) {
ans = INF;
for (int i = 0; i < 26; ++i)
if (m[i]) {
ans = min(ans, make(dia + 1, m[i]) + int(i == 0) - int(i == 1));
}
} else {
ans = -INF;
for (int i = 0; i < 26; ++i)
if (m[i]) {
ans = max(ans, make(dia + 1, m[i]) + int(i == 0) - int(i == 1));
}
}
return dp[dia][msk] = ans;
}
int main() {
input();
int t = make(0, 1);
t += int(ch[0][0] == 'a') - int(ch[0][0] == 'b');
if (!t)
cout << "DRAW" << endl;
else if (t > 0)
cout << "FIRST" << endl;
else
cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, g[45][26], f[45][1 << 20];
char a[25][25];
int dfs(int t, int s, int c) {
if (f[t][s] != -1) return f[t][s];
if (t == 2 * N - 1) return f[t][s] = !c ? 1 : c == 1 ? -1 : 0;
int x = t & 1 ? 1e9 : -1e9, ss = s;
for (int i = 0; i < N; i++)
if ((s >> i) & 1) ss |= 1 << i + 1;
for (int i = 0, k; i < 26; i++)
if (k = ss & g[t + 1][i])
if (t & 1)
x = min(x, dfs(t + 1, k, i));
else
x = max(x, dfs(t + 1, k, i));
x += !c ? 1 : c == 1 ? -1 : 0;
return f[t][s] = x;
}
void doit() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%s", a[i] + 1);
for (int i = 1; i < 2 * N; i++)
for (int j = 0; j < 26; j++)
for (int x = i < N ? 1 : i - N + 1, y = i < N ? i : N, k = 0,
t = i < N ? i : 2 * N - i;
k < t; k++)
if (a[x + k][y - k] == j + 97) g[i][j] |= 1 << y - k - 1;
memset(f, -1, sizeof(f));
int ans = dfs(1, 1, a[1][1] - 97);
puts(ans > 0 ? "FIRST" : ans < 0 ? "SECOND" : "DRAW");
}
int main() {
doit();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 22, ALPHA = 26, oo = 1 << 20;
int n;
char s[MAX][MAX];
int mask[MAX << 1][ALPHA];
int dp[MAX << 1][1 << 20];
bool used[MAX << 1][1 << 20];
int solve(int diag, int m, int c) {
int ret = -oo;
if (used[diag][m]) return dp[diag][m];
if (diag == 2 * n - 2)
ret = 0;
else {
for (int i = 0, _n = ALPHA; i < _n; ++i) {
int newmask = (m | (m << 1)) & mask[diag + 1][i];
if (newmask) ret = max(ret, -solve(diag + 1, newmask, i));
}
}
if ((diag & 1) == 0)
ret += (c == 1 ? 1 : c == 0 ? -1 : 0);
else
ret += (c == 1 ? -1 : c == 0 ? 1 : 0);
used[diag][m] = true;
return dp[diag][m] = ret;
}
int main() {
scanf("%d", &n);
for (int i = 0, _n = n; i < _n; ++i) scanf("%s", s[i]);
for (int i = 0, _n = 2 * n - 1; i < _n; ++i)
for (int j = 0, _n = ALPHA; j < _n; ++j)
for (int k = 0, _n = n; k < _n; ++k) {
int x = k, y = i - x;
if (y >= 0 && y < n && s[x][y] == j + 'a') mask[i][j] |= 1 << k;
}
int ret = solve(0, 1, s[0][0] - 'a');
if (ret < 0) puts("FIRST");
if (ret == 0) puts("DRAW");
if (ret > 0) puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> e[40][26];
int n, pow2[25], dp[40][1 << 20];
char a[25][25];
int f(int x) {
if (x == 0) return 1;
if (x == 1) return -1;
return 0;
}
int calc(int x, int y) {
if (x == 2 * n - 2) return 0;
if (dp[x][y] != -100) return dp[x][y];
if (!(x & 1)) dp[x][y] = 100;
for (int c = 0; c < 26; c++) {
int t = 0;
for (vector<int>::iterator p = e[x + 1][c].begin(); p != e[x + 1][c].end();
p++)
if ((y & pow2[*p]) || ((*p) > 0 && (y & pow2[(*p) - 1]))) t |= pow2[*p];
if (!t) continue;
if (x & 1)
dp[x][y] = max(dp[x][y], f(c) + calc(x + 1, t));
else
dp[x][y] = min(dp[x][y], f(c) + calc(x + 1, t));
}
return dp[x][y];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
pow2[0] = 1;
for (int i = 1; i <= n; i++) pow2[i] = pow2[i - 1] << 1;
for (int i = 0; i < 2 * n; i++)
for (int j = 0; j < pow2[n]; j++) dp[i][j] = -100;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) e[i + j][a[i][j] - 97].push_back(i);
int ans = f(a[0][0] - 97) + calc(0, 1);
if (ans > 0) puts("FIRST");
if (ans < 0) puts("SECOND");
if (!ans) puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 1, -1};
int dy[] = {1, 0, 0, 0};
template <class T>
inline void smin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void smax(T &a, T b) {
if (a < b) a = b;
}
pair<int, int> pos[55][55];
bool vst[55][(1 << 20) + 10];
int best[55][(1 << 20) + 10], can[55][33];
int id[55][22][22], cnt[55];
char grid[22][22];
int N;
int calc(int sum, int b) {
if (sum == 2 * N - 2) return 0;
if (vst[sum][b]) return best[sum][b];
int i, bb, res, k, add;
int r, c, rr, cc;
bb = 0;
for (i = 0; i < cnt[sum]; i++) {
if (b & (1 << i)) {
r = pos[sum][i].first;
c = pos[sum][i].second;
for (k = 0; k < 2; k++) {
rr = r + dx[k];
cc = c + dy[k];
if ((rr < 0 || cc < 0 || rr >= N || cc >= N)) continue;
bb |= (1 << id[sum + 1][rr][cc]);
}
}
}
if (sum % 2 == 0)
res = 0x3f3f3f3f;
else
res = -0x3f3f3f3f;
for (k = 0; k < 26; k++) {
if (can[sum + 1][k] & bb) {
add = 0;
if (k == 0) add = 1;
if (k == 1) add = -1;
if (sum % 2 == 0)
smin(res, add + calc(sum + 1, can[sum + 1][k] & bb));
else
smax(res, add + calc(sum + 1, can[sum + 1][k] & bb));
}
}
vst[sum][b] = 1;
return best[sum][b] = res;
}
int main() {
int i, j, r, c;
scanf("%d", &N);
for (i = 0; i < N; i++) scanf("%s", grid[i]);
for (i = 0; i < 2 * N - 1; i++) {
for (r = 0; r < N; r++) {
c = i - r;
if (c >= 0 && c < N) {
int k = grid[r][c] - 'a';
can[i][k] += (1 << cnt[i]);
id[i][r][c] = cnt[i];
pos[i][cnt[i]++] = pair<int, int>(r, c);
}
}
}
int s = 0;
if (grid[0][0] == 'a') s = 1;
if (grid[0][0] == 'b') s = -1;
s += calc(0, 1);
if (s > 0)
puts("FIRST");
else if (s < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
const int N = 25, M = 45;
int n, ans, f[M][1 << 20], f1[M][N + 1];
char s1[N][N];
inline int read() {
int x = 0, k = 1;
char c = getchar();
for (; c < 48 || c > 57; c = getchar()) k ^= (c == '-');
for (; c >= 48 && c <= 57; c = getchar()) x = x * 10 + (c ^ 48);
return k ? x : -x;
}
int dfs(int u, int v, int fl) {
if (f[u][v] != -1) return f[u][v];
if (u == 2 * n - 1) return f[u][v] = !fl ? 1 : fl == 1 ? -1 : 0;
int x = u & 1 ? 1e9 : -1e9, v1 = v;
for (int i = 0; i < n; i++)
if ((v >> i) & 1) v1 |= 1 << i + 1;
for (int i = 0, k; i < 26; i++)
if (k = v1 & f1[u + 1][i])
if (u & 1)
x = std::min(x, dfs(u + 1, k, i));
else
x = std::max(x, dfs(u + 1, k, i));
x += !fl ? 1 : fl == 1 ? -1 : 0;
return f[u][v] = x;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) scanf("%s", s1[i] + 1);
for (int i = 1; i < 2 * n; i++)
for (int j = 0; j < N + 1; j++)
for (int x = i < n ? 1 : i - n + 1, y = i < n ? i : n, k = 0,
u = i < n ? i : 2 * n - i;
k < u; k++)
if (s1[x + k][y - k] == j + 97) f1[i][j] |= 1 << y - k - 1;
std::memset(f, -1, sizeof(f));
ans = dfs(1, 1, s1[1][1] - 97);
puts(ans > 0 ? "FIRST" : ans < 0 ? "SECOND" : "DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
char s[30][30];
int dp[42][(1 << 20) + 10];
int n;
int lmasks[40][30];
int go(int sum, int mask) {
if (mask == 0) return inf;
int& res = dp[sum][mask];
if (res > -10 * n) return res;
if (sum == 2 * n - 2) return res = 0;
mask = (mask | (mask << 1));
if (sum >= n - 1) {
mask >>= 1;
mask &= ~(1 << (n - (sum - n) - 1));
}
res = -inf;
for (int i = 0; i < 26; i++) {
int cres = -go(sum + 1, mask & lmasks[sum + 1][i]);
if (i == !(sum % 2)) cres++;
if (i == (sum % 2)) cres--;
res = max(res, cres);
}
return res;
}
int main() {
memset(dp, 0x80, sizeof(dp));
scanf("%d", &n);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) scanf(" %c", &s[i][j]);
for (int sum = 0; sum <= 2 * n - 2; sum++)
for (int c = 0; c < 26; c++) {
int& mask = lmasks[sum][c];
mask = 0;
for (int i = n - 1; i >= 0; i--) {
int j = sum - i;
if (j < 0 || j >= n) continue;
mask = (mask << 1);
if (s[i][j] == c + 'a') mask |= 1;
}
}
int bal = -go(0, 1);
if (s[0][0] == 'a') bal++;
if (s[0][0] == 'b') bal--;
if (bal > 0)
puts("FIRST");
else if (bal == 0)
puts("DRAW");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[25 * 2][1 << 20];
int n, Log[1 << 20], dp[25 * 2][1 << 20];
char str[25][25];
int score(char a) {
if (a == 'a') return 1;
if (a == 'b') return -1;
return 0;
}
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%s", str[i] + 1);
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; ++i) Log[1 << i] = i;
}
int Dp(int p, int S) {
if (p == 2 * n - 1) vis[p][S] = true, dp[p][S] = score(str[n][n]);
if (vis[p][S]) return dp[p][S];
vis[p][S] = true;
int ta = 1 << 30, tb = -1 << 30, c;
for (char go = 'a'; go <= 'z'; ++go) {
int nextS = 0;
for (int i = S; i; i -= (i & -i)) {
int y = Log[(i & -i)] + 1, x = p + 1 - y, t = y;
if (p > n) y = p - n + y, x = p + 1 - y;
c = score(str[x][y]);
if (p < n) {
if (x < n && str[x + 1][y] == go) nextS = nextS | (1 << (t - 1));
if (y < n && str[x][y + 1] == go) nextS = nextS | (1 << t);
} else {
if (x < n && str[x + 1][y] == go) nextS = nextS | (1 << (t - 2));
if (y < n && str[x][y + 1] == go) nextS = nextS | (1 << (t - 1));
}
}
if (p % 2 == 1 && nextS) ta = min(ta, Dp(p + 1, nextS));
if (p % 2 == 0 && nextS) tb = max(tb, Dp(p + 1, nextS));
}
if (p & 1)
dp[p][S] = ta + c;
else
dp[p][S] = tb + c;
return dp[p][S];
}
void print() {
Dp(1, 1);
if (dp[1][1] > 0) printf("FIRST\n");
if (dp[1][1] == 0) printf("DRAW\n");
if (dp[1][1] < 0) printf("SECOND\n");
}
int main() {
read();
print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
static inline int Rint() {
struct X {
int dig[256];
X() {
for (int i = '0'; i <= '9'; ++i) dig[i] = 1;
dig['-'] = 1;
}
};
static X fuck;
int s = 1, v = 0, c;
for (; !fuck.dig[c = getchar()];)
;
if (c == '-')
s = 0;
else if (fuck.dig[c])
v = c ^ 48;
for (; fuck.dig[c = getchar()]; v = v * 10 + (c ^ 48))
;
return s ? v : -v;
}
template <typename T>
static inline void cmax(T& a, const T& b) {
if (b > a) a = b;
}
template <typename T>
static inline void cmin(T& a, const T& b) {
if (b < a) a = b;
}
const int maxn = 100005;
char mat[25][25];
int mask[50][30];
int dp[40][1 << 20];
int n;
int dfs(int level, int m, int take) {
int& ret = dp[level][m];
if (ret != -inf) return ret;
int now = -inf;
if (level == n * 2 - 2) {
now = 0;
} else {
for (int letter = 0; letter < 26; ++letter) {
int next = level + 1;
int f = mask[next][letter] & (m | m << 1);
if (f) {
int t = -dfs(next, f, letter);
cmax(now, t);
}
}
}
if (level % 2 == 0) {
if (take == 0)
--now;
else if (take == 1)
++now;
} else {
if (take == 0)
++now;
else if (take == 1)
--now;
}
return ret = now;
}
int main() {
const int n = Rint();
::n = n;
for (int i = (0); i < (n); ++i) scanf("%s", mat[i]);
for (int i = 0; i <= n * 2 - 2; ++i)
for (int letter = 0; letter < 26; ++letter)
for (int r = 0; r < n; ++r) {
const int c = i - r;
if (c >= 0 && c < n && mat[r][c] - 'a' == letter) {
mask[i][letter] |= 1 << r;
}
}
for (int i = 0; i <= n * 2 - 2; ++i) fill(dp[i], dp[i] + (1 << n), -inf);
int ans = dfs(0, 1, mat[0][0] - 'a');
if (ans < 0) puts("FIRST");
if (ans == 0) puts("DRAW");
if (ans > 0) puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
char a[20][25];
int dp[42][1 << 20], n;
int gao(int l, int s) {
if (l == n + n - 1) return 0;
if (dp[l][s] > -INF) return dp[l][s];
int hi = min(n - 1, l), lo = max(l - n + 1, 0), v[26] = {};
for (int r = lo; r <= hi; r++) {
int c = l - r;
v[a[r][c] - 'a'] = 1;
}
int m = s | s << 1;
for (int o = 'a'; o <= 'z'; o++)
if (v[o - 'a']) {
int t = 0;
for (int r = lo; r <= hi; r++)
if (m & 1 << r) {
int c = l - r;
if (a[r][c] == o) t |= 1 << r;
}
if (!t) continue;
int ret = -gao(l + 1, t);
if (o == 'a') ret += l & 1 ? -1 : 1;
if (o == 'b') ret += l & 1 ? 1 : -1;
dp[l][s] = max(dp[l][s], ret);
}
return dp[l][s];
}
int main() {
memset(dp, 192, sizeof(dp));
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
int ans = -gao(1, 1);
if (a[0][0] == 'a') ans++;
if (a[0][0] == 'b') ans--;
puts(ans ? ans > 0 ? "FIRST" : "SECOND" : "DRAW");
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int INF = (int)2e9, M = 1024 * 1024 + 5;
char z[25][25];
string przek[45];
int n, licz;
int dp[45][M], pot[25];
bool o[45][M];
pair<int, int> nowa(int x, int nr) {
int wyn = 0;
if (nr < n) {
x <<= 1;
for (int i = nr; i >= 1; i--)
if (x & pot[i]) {
wyn |= pot[i];
wyn |= pot[i - 1];
}
nr++;
} else {
nr = 2 * n - nr;
if (pot[nr - 1] & x) wyn |= pot[nr - 2];
if (pot[0] & x) wyn |= pot[0];
for (int i = nr - 2; i >= 1; i--)
if (x & pot[i]) {
wyn |= pot[i];
wyn |= pot[i - 1];
}
}
return {wyn, nr};
}
void zrob(int stan, int nr) {
if (nr != 2 * n - 1) {
if (nr % 2 == 0)
dp[nr][stan] = -INF;
else
dp[nr][stan] = INF;
}
int tab[30];
for (int i = 0; i < 26; i++) tab[i] = 0;
pair<int, int> nast = nowa(stan, nr);
int kolDL = nast.second;
int kolSTAN = nast.first;
for (int i = 0; i < kolDL; i++) tab[przek[nr + 1][i] - 'a'] |= pot[i];
int dodaj = 0;
for (int i = 0; i < 20; i++) {
if (pot[i] & stan) {
if (przek[nr][i] == 'a')
dodaj = 1;
else if (przek[nr][i] == 'b')
dodaj = -1;
break;
}
}
for (int i = 0; i < 26; i++) {
int s1 = tab[i] & kolSTAN;
if (s1 == 0) continue;
if (!o[nr + 1][s1] and nr < 2 * n - 1) {
o[nr + 1][s1] = true;
zrob(s1, nr + 1);
}
if (nr == 2 * n - 1) continue;
if (nr % 2 == 0)
dp[nr][stan] = max(dp[nr][stan], dp[nr + 1][s1] + dodaj);
else
dp[nr][stan] = min(dp[nr][stan], dp[nr + 1][s1] + dodaj);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int y = 0; y < n; y++) {
string s;
cin >> s;
for (int x = 0; x < n; x++) z[x][y] = s[x];
}
for (int x = 0; x < n; x++) {
int y = 0;
licz++;
for (int i = x; i >= 0; i--) {
przek[licz] += z[i][y];
y++;
}
}
for (int y = 1; y < n; y++) {
int x = n - 1;
licz++;
for (int i = y; i < n; i++) {
przek[licz] += z[x][i];
x--;
}
}
pot[0] = 1;
for (int i = 1; i < n; i++) pot[i] = 2 * pot[i - 1];
o[1][1] = true;
int dodaj = 0;
if (przek[2 * n - 1][0] == 'a')
dodaj = 1;
else if (przek[2 * n - 1][0] == 'b')
dodaj = -1;
dp[2 * n - 1][1] = dodaj;
zrob(1, 1);
if (dp[1][1] == 0)
cout << "DRAW";
else if (dp[1][1] < 0)
cout << "SECOND";
else
cout << "FIRST";
}
|
#include <bits/stdc++.h>
using namespace std;
char a[25][25];
int dp[40][1 << 20], n;
bool vis[40][1 << 20];
int f(int xx, int st) {
if (vis[xx][st]) return dp[xx][st];
int &res = dp[xx][st];
vis[xx][st] = true;
if (xx == n * 2 - 2) {
res = 0;
} else {
if (xx & 1)
res = -0x3f3f3f3f;
else
res = 0x3f3f3f3f;
int mask[30];
memset(mask, 0, sizeof(mask));
int cnt = 0;
for (int j = 0; j <= xx + 1; ++j) {
int x = xx + 1 - j;
int y = j;
if (x >= n || y >= n) continue;
mask[a[x][y] - 'a'] |= (1 << cnt);
cnt++;
}
for (int i = 0; i < 26; ++i) {
if (mask[i]) {
int xt;
if (xx + 1 < n)
xt = (st | (st << 1)) & mask[i];
else
xt = (st | (st >> 1)) & mask[i];
if (xt == 0) continue;
int tmp = 0;
if (i == 0)
tmp = 1;
else if (i == 1)
tmp = -1;
if (xx & 1)
res = max(res, tmp + f(xx + 1, xt));
else
res = min(res, tmp + f(xx + 1, xt));
}
}
}
if (xx == 0) {
if (a[0][0] == 'a')
res += 1;
else if (a[0][0] == 'b')
res -= 1;
}
return res;
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; ++i) scanf("%s", a[i]);
memset(vis, 0, sizeof(vis));
int res = f(0, 1);
if (res == 0)
printf("DRAW\n");
else if (res > 0)
printf("FIRST\n");
else
printf("SECOND\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, enc[45][45], decx[45][45], decy[45][45];
char s[45][45], ss[45], len[45];
short int dp[42][(1 << 20) + 5];
short int dfs(int step, int S) {
if (dp[step][S] != 999) return dp[step][S];
if (step == n + n - 2) {
return dp[step][S] =
(s[n - 1][n - 1] == 'a' ? 1 : (s[n - 1][n - 1] == 'b' ? -1 : 0));
}
short int *val = &dp[step][S], curs = 0;
if (step & 1) *val = -999;
for (char c = 'a'; c <= 'z'; ++c) {
int T = 0, x, y;
for (int j = (0); j < (len[step]); j++)
if (S & (1 << j)) {
x = decx[step][j];
y = decy[step][j];
curs = (s[x][y] == 'a' ? 1 : (s[x][y] == 'b' ? -1 : 0));
if (x + 1 < n && s[x + 1][y] == c) T |= (1 << enc[x + 1][y]);
if (y + 1 < n && s[x][y + 1] == c) T |= (1 << enc[x][y + 1]);
}
if (!T) continue;
if (step & 1)
*val = max(*val, dfs(step + 1, T));
else
*val = min(*val, dfs(step + 1, T));
}
*val = *val + curs;
return *val;
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) scanf("%s", s[i]);
for (int i = (0); i < (42); i++)
for (int j = (0); j < ((1 << n)); j++) dp[i][j] = 999;
for (int i = (0); i < (n + n - 1); i++) {
int x, y;
if (i < n)
x = i, y = 0;
else
x = n - 1, y = i - n + 1;
len[i] = 0;
while (x >= 0 && y < n) {
decx[i][len[i]] = x;
decy[i][len[i]] = y;
enc[x][y] = len[i]++;
--x, ++y;
}
}
int ret = dfs(0, 1);
if (!ret)
puts("DRAW");
else
puts(ret > 0 ? "FIRST" : "SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, same[41][31], dp[41][1000010];
char num[41][41];
bool flag[41][1000010];
void Init() {
scanf("%d\n", &n);
for (int i = 0; i < n; i++) scanf("%s\n", num[i]);
}
void prepare() {
for (int i = 0; i < (n << 1) - 1; i++)
for (int j = 0; j < 26; j++) {
int ll = max(0, i - n + 1), rr = min(i, n - 1);
for (int k = ll; k <= rr; k++)
if (j + 'a' == num[k][i - k]) same[i][j] |= (1 << k);
}
}
int min_max(int d, int s, int c) {
if (d == 2 * n - 2) return c == 0 ? 1 : c == 1 ? -1 : 0;
if (!flag[d][s]) {
int ss = s, cc;
flag[d][s] = 1;
for (int i = 0; i < n; i++)
if (s & (1 << i)) ss |= (1 << (i + 1));
dp[d][s] = (d & 1) ? -0x7fffffff : 0x7fffffff;
for (int i = 0; i < 26; i++) {
int nxt = (ss & same[d + 1][i]);
if (nxt) {
if (d & 1)
dp[d][s] = max(dp[d][s], min_max(d + 1, nxt, i));
else
dp[d][s] = min(dp[d][s], min_max(d + 1, nxt, i));
}
}
dp[d][s] += (c == 0 ? 1 : c == 1 ? -1 : 0);
}
return dp[d][s];
}
void solve() {
prepare();
int x = min_max(0, 1, num[0][0] - 'a');
printf("%s\n", x > 0 ? "FIRST" : x < 0 ? "SECOND" : "DRAW");
}
int main() {
Init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
int f[maxn * 2 + 5][1 << maxn], n, res;
char str[maxn + 5][maxn + 5];
int dfs(int k, int s) {
if (f[k][s] < 1e9) return f[k][s];
int &res = f[k][s], tmp[26], x, y, cnt = 0, Next;
if (k < 2 * n - 2) {
memset(tmp, 0, sizeof tmp);
for (int i = 0; i <= k + 1; i++) {
x = k + 1 - i;
y = i;
if (x >= n || y >= n) continue;
tmp[str[x][y] - 'a'] |= 1 << (cnt++);
}
for (int i = 0; i < 26; i++) {
if (k + 1 < n)
Next = (s | (s << 1)) & tmp[i];
else
Next = (s | (s >> 1)) & tmp[i];
if (!Next) continue;
res = min(res, -dfs(k + 1, Next));
}
} else
res = 0;
for (int i = 0; i <= k; i++)
if (s >> i & 1) {
x = min(n - 1, k) - i, y = k - x;
if (str[x][y] == 'a') res += (k & 1 ? -1 : 1);
if (str[x][y] == 'b') res += (k & 1 ? 1 : -1);
break;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n - 1; i++) scanf("%s", str[i]);
memset(f, 0x3f, sizeof f);
res = dfs(0, 1);
if (!res)
puts("DRAW");
else if (res > 0)
puts("FIRST");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22, S = 1 << 20, C = 26, Inf = 1 << 30;
int n, a[N + N][C] = {};
unordered_map<int, int> f[N + N], g[N + N];
char ch[N][N] = {};
void init() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> (ch[i] + 1);
for (int i = 1; i <= n + n - 1; ++i)
for (int x = 1; x <= i; ++x) {
int y = i - x + 1;
if (n < x || y <= 0 || n < y) continue;
a[i][ch[x][y] - 'a'] |= 1 << x;
}
}
int calc(int d, int s, int t) {
if (d == n + n) return 0;
if (t) {
if (g[d].count(s)) return g[d][s];
g[d][s] = Inf;
for (int c = 0; c < 26; ++c) {
int v = c == 0 ? 1 : c == 1 ? -1 : 0;
int ns = (s & a[d][c]) | ((s << 1) & a[d][c]);
if (ns) g[d][s] = min(calc(d + 1, ns, !t) + v, g[d][s]);
}
return g[d][s];
} else {
if (f[d].count(s)) return f[d][s];
f[d][s] = -Inf;
for (int c = 0; c < 26; ++c) {
int v = c == 0 ? 1 : c == 1 ? -1 : 0;
int ns = (s & a[d][c]) | ((s << 1) & a[d][c]);
if (ns) f[d][s] = max(calc(d + 1, ns, !t) + v, f[d][s]);
}
return f[d][s];
}
}
void work() {
calc(1, 2, 0);
puts(f[1][2] > 0 ? "FIRST" : f[1][2] == 0 ? "DRAW" : "SECOND");
}
int main() {
init();
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const B = 20, N = B + 3, M = 2 * B + 3, MASK = (1 << B) + 20,
alpha = 26 + 4;
int INF = 2e9;
int n, have[M][alpha], dp[2][MASK];
string s[N];
inline bool in(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < n); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
int m = 2 * n - 1;
for (int q = m - 1; q >= 0; q--)
for (int i = 0; i < n; i++) {
int j = q - i;
if (in(i, j)) have[q][s[i][j] - 'a'] += (1 << i);
}
for (int q = m - 2; q >= 0; q--) {
int t = 0;
for (int i = 0; i < n; i++) {
int j = q - i;
if (in(i, j)) t += (1 << i);
}
bool now = q & 1, prv = !now;
if (now)
for (int mask = 0; mask < (1 << n); mask++) dp[now][mask] = -INF;
else
for (int mask = 0; mask < (1 << n); mask++) dp[now][mask] = INF;
for (int mask = 0; mask < (1 << n); mask++) {
if ((mask & t) != mask) continue;
for (int nextL = 0; nextL < 26; nextL++) {
int ok = (mask | (mask << 1)) & have[q + 1][nextL];
if (!ok) continue;
int k = dp[prv][ok] + (nextL == 0) - (nextL == 1);
if (now)
dp[now][mask] = max(dp[now][mask], k);
else
dp[now][mask] = min(dp[now][mask], k);
}
}
}
if (s[0][0] == 'a') dp[0][1]++;
if (s[0][0] == 'b') dp[0][1]--;
cout << (dp[0][1] ? dp[0][1] > 0 ? "FIRST" : "SECOND" : "DRAW") << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
string board[30];
int mask[42][30];
int dp[42][1 << 20];
int func(int i, int j, int c, bool first) {
if (dp[i][j] != 10000) return dp[i][j];
int next;
int ans = -(1 << 29);
if (i == 2 * (N - 1)) {
ans = 0;
} else {
for ((next) = 0; (next) < (int)(26); (next)++) {
int i2 = i + 1;
int j2 = (mask[i + 1][next] & (j | (j << 1)));
if (j2 != 0) ans = max(ans, -func(i2, j2, next, !first));
}
}
if (first) {
if (c == 0)
ans++;
else if (c == 1)
ans--;
} else {
if (c == 0)
ans--;
else if (c == 1)
ans++;
}
return dp[i][j] = ans;
}
string calc() {
int i, j, k;
for ((i) = 0; (i) < (int)(2 * N); (i)++)
for ((j) = 0; (j) < (int)(26); (j)++)
for ((k) = 0; (k) < (int)(N); (k)++) {
int x = k;
int y = i - x;
if (y >= 0 && y < N && board[x][y] - 'a' == j) mask[i][j] |= (1 << k);
}
for ((i) = 0; (i) < (int)(2 * N); (i)++)
for ((j) = 0; (j) < (int)((1 << N)); (j)++) dp[i][j] = 10000;
int ans = func(0, 1, board[0][0] - 'a', false);
if (ans < 0) return "FIRST";
if (ans > 0) return "SECOND";
return "DRAW";
}
void solve(istream &in, ostream &out) {
in >> N;
for (int i = 0; i < N; i++) in >> board[i];
out << calc() << endl;
}
int main() {
solve(cin, cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int F[42][1 << 20], M[42][26], N;
string T[45];
int f(int d, int m, int c, int p) {
if (F[d][m] != 99999) return F[d][m];
int ret = d < 2 * N - 2 ? -99999 : 0;
for (int next_c = 0; next_c < 26; next_c++) {
int next_m = M[d + 1][next_c] & (m | (2 * m));
if (next_m > 0) ret = max(ret, -f(d + 1, next_m, next_c, 1 - p));
}
if (p == c) ret++;
if ((p == 0 && c == 1) || (p == 1 && c == 0)) ret--;
return F[d][m] = ret;
}
int main() {
cin >> N;
for (int i = 0; i < N; i++) cin >> T[i];
for (int d = 0; d < 2 * N - 1; d++)
for (int i = 0; i < N; i++)
for (int c = 0; c < 26; c++) {
int j = d - i;
if (j >= 0 && j < N && T[i][j] - 'a' == c) M[d][c] |= (1 << i);
}
for (int d = 0; d < 42; d++)
for (int m = 0; m < (1 << 20); m++) F[d][m] = 99999;
if (f(0, 1, T[0][0] - 'a', 1) == 0)
cout << "DRAW";
else if (f(0, 1, T[0][0] - 'a', 1) > 0)
cout << "SECOND";
else
cout << "FIRST";
}
|
#include <bits/stdc++.h>
using namespace std;
int const MID = 30;
int const INF = 1 << 30;
int n;
char bord[25][100];
int dp[50][1100000];
char getChar(int dig, int mask) {
int kel = 0;
while ((mask & 1) == 0) {
mask = mask >> 1;
kel++;
}
if (dig - kel > 0)
return bord[1 + kel][MID + dig - kel];
else
return ' ';
}
int fun(int dig, int mask) {
if (dp[dig][mask] == INF) {
int ats = 0;
bool call = false;
int minmax = dig & 1 ? 10000 : -10000;
int nextMask;
for (char m = 'a'; m <= 'z'; m++) {
nextMask = 0;
for (int i = 0; i < n; i++) {
int now = 1 << i;
if (mask & now) {
if (getChar(dig + 1, now) == m) nextMask = nextMask | now;
if (getChar(dig + 1, now << 1) == m) nextMask = nextMask | (now << 1);
}
}
int ans;
if (nextMask != 0) {
call = true;
ans = fun(dig + 1, nextMask);
if ((dig & 1) == 1) {
minmax = min(minmax, ans);
} else {
minmax = max(minmax, ans);
}
}
}
char nowChar = getChar(dig, mask);
if (nowChar == 'a')
ats++;
else if (nowChar == 'b')
ats--;
if (call)
dp[dig][mask] = minmax + ats;
else
dp[dig][mask] = ats;
}
return dp[dig][mask];
}
int main() {
for (int i = 0; i < 50; i++)
for (int j = 0; j < 1100000; j++) dp[i][j] = INF;
cin >> n;
for (int i = 1; i <= n; i++) {
for (int j = MID + 1; j <= MID + n; j++) cin >> bord[i][j];
}
int ans = fun(1, 1);
if (ans > 0)
cout << "FIRST";
else if (ans < 0)
cout << "SECOND";
else
cout << "DRAW";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NS = 20;
const int MS = 40;
const int AL = 26;
const int INF = 1 << 30;
int n;
int p[MS][AL];
char s[NS][NS], c[MS][NS];
int dp[MS][1 << NS];
bool vis[MS][1 << NS];
int judge(char ch) {
if (ch == 'a') return 1;
if (ch == 'b') return -1;
return 0;
}
void print2(int x) {
for (; x; x >>= 1) printf("%d", x & 1);
puts("");
}
int dfs(int dep, int st) {
if (vis[dep][st]) return dp[dep][st];
vis[dep][st] = 1;
int next = st, ret, w = 0;
if (dep & 1)
ret = -INF;
else
ret = INF;
if (dep < n - 1)
next |= (st << 1);
else
next |= (st >> 1);
for (int i = 0; i < AL; i++)
if (next & p[dep + 1][i]) {
int tmp = dfs(dep + 1, next & p[dep + 1][i]);
if (dep & 1)
ret = max(ret, tmp);
else
ret = min(ret, tmp);
}
for (; (st & (1 << w)) == 0; w++)
;
return dp[dep][st] = ret + judge(c[dep][w]);
}
int main() {
while (~scanf("%d", &n)) {
memset(p, 0, sizeof(p));
memset(vis, 0, sizeof(vis));
int x, y;
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int j, i = 0; i < n + n - 1; i++) {
if (i < n)
x = i, y = 0;
else
x = n - 1, y = i - n + 1;
for (j = 0; x >= 0 && y < n; x--, y++, j++)
c[i][j] = s[x][y], p[i][c[i][j] - 'a'] |= 1 << j;
}
vis[n + n - 2][1] = 1;
dp[n + n - 2][1] = judge(s[n - 1][n - 1]);
int ans = dfs(0, 1);
if (ans == 0) printf("DRAW\n");
if (ans > 0) printf("FIRST\n");
if (ans < 0) printf("SECOND\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 21;
int funk(char x) {
if (x == 'a') return 1;
if (x == 'b') return -1;
return 0;
}
char a[N][N];
int d[2 * N][(1 << 20) + 10];
int y[N][N];
struct abc {
int x, y, s;
};
abc w[N + N];
int main() {
int n, m, i, j;
cin >> n;
for (i = 1; i <= n; i++)
for (j = 1; j <= n; j++) cin >> a[i][j];
int t = 2;
d[n + n - 1][1] = funk(a[n][n]);
for (i = n; i >= 1; i--) {
w[n + i - 1].x = i;
w[n + i - 1].y = n;
w[n + i - 1].s = n - i + 1;
}
for (i = n; i >= 1; i--) {
w[i].x = 1;
w[i].y = i;
w[i].s = i;
}
int id = n + n - 2;
for (i = n - 1; i >= 1; i--) {
t = w[id].s;
m = (1 << t) - 1;
int x = w[id].x;
int y = w[id].y;
for (j = 1; j <= m; j++) {
char b = '0';
bool ok = 1;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
if (a[x + k][y - k] == b || b == '0') {
b = a[x + k][y - k];
} else {
ok = 0;
break;
}
}
}
if (ok) {
map<char, int> mp;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
int xx = x + k;
int yy = y - k;
yy++;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
xx++;
yy--;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
}
}
int ans;
if (id % 2 == 0) {
ans = -1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = max(ans, d[id + 1][(*k).second] + funk(b));
} else {
ans = 1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = min(ans, d[id + 1][(*k).second] + funk(b));
}
d[id][j] = ans;
}
}
id--;
}
for (i = n - 1; i >= 1; i--) {
t = w[id].s;
m = (1 << t) - 1;
int x = w[id].x;
int y = w[id].y;
for (j = 1; j <= m; j++) {
char b = '0';
bool ok = 1;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
if (a[x + k][y - k] == b || b == '0') {
b = a[x + k][y - k];
} else {
ok = 0;
break;
}
}
}
if (ok) {
map<char, int> mp;
for (int k = 0; k < t; k++) {
if (((1 << k) & j)) {
int xx = x + k;
int yy = y - k;
yy++;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
xx++;
yy--;
if (xx <= n && xx >= 1 && yy >= 1 && yy <= n) {
mp[a[xx][yy]] |= (1 << (xx - w[id + 1].x));
}
}
}
int ans;
if (id % 2 == 0) {
ans = -1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = max(ans, d[id + 1][(*k).second] + funk(b));
} else {
ans = 1e9;
for (map<char, int>::iterator k = mp.begin(); k != mp.end(); k++)
ans = min(ans, d[id + 1][(*k).second] + funk(b));
}
d[id][j] = ans;
}
}
id--;
}
if (d[1][1] > 0) puts("FIRST");
if (d[1][1] == 0) puts("DRAW");
if (d[1][1] < 0) puts("SECOND");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int M = N + 7;
const int MOD = 1e9 + 7;
const long long INF = 1e16 + 17;
const int K = 26;
int c[M][M];
int dp[2][1 << N];
int nxMask[K];
bool p[K];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("\n");
for (int j = 1; j <= n; ++j) {
char x;
scanf("%c", &x);
c[i][j] = x - 'a';
}
}
dp[1][1] = (c[n][n] == 0) - (c[n][n] == 1);
for (int diag = n + n - 2; diag >= 1; --diag) {
int m = n - abs(n - diag);
int id = diag % 2;
int par = id ^ 1;
for (int mask = 1; mask < (1 << m); ++mask) {
int cnt = 0;
bool flag = true;
memset(p, false, sizeof p);
int last = -1;
for (int i = 0; i < m; ++i) {
if (mask & (1 << i)) {
int x = min(diag, n) - i;
int y = diag - x + 1;
if (last != -1 && last != c[x][y]) {
flag = false;
break;
}
last = c[x][y];
p[x] = 1;
}
}
if (!flag) continue;
memset(nxMask, 0, sizeof nxMask);
int x = min(diag, n);
int y = diag - x + 2;
if (x + 1 <= n && y - 1 >= 1) {
++x;
--y;
}
int k = 0;
while (x >= 1 && y <= n) {
if (p[x] || p[x - 1]) {
nxMask[c[x][y]] += 1 << k;
}
--x;
++y;
++k;
}
dp[id][mask] = MOD;
for (int k = 0; k < K; ++k) {
if (nxMask[k]) {
dp[id][mask] = min(dp[id][mask], -dp[par][nxMask[k]]);
}
}
int curVal = (last == 0) - (last == 1);
dp[id][mask] += (id ? curVal : -curVal);
}
}
if (dp[1][1] > 0) {
printf("FIRST\n");
} else if (dp[1][1] < 0) {
printf("SECOND\n");
} else {
printf("DRAW\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 20, INF = 1000;
int n;
string ch[MAXN];
int f[2 * MAXN][1 << 20], pos[MAXN][MAXN];
vector<pair<int, int> > diag[2 * MAXN];
int score(char c) {
if (c == 'a') return 1;
if (c == 'b') return -1;
return 0;
}
int Cal(int s, int mask) {
if (f[s][mask] > -INF) return f[s][mask];
if (s == 2 * (n - 1)) return f[s][mask] = 0;
int t[26];
memset(t, 0, sizeof t);
for (int i = 0; i < diag[s].size(); i++) {
if (!(mask & (1 << i))) continue;
int x = diag[s][i].first, y = diag[s][i].second;
if (x < n - 1) {
int p = pos[x + 1][y];
int l = ch[x + 1][y] - 'a';
t[l] |= (1 << p);
}
if (y < n - 1) {
int p = pos[x][y + 1];
int l = ch[x][y + 1] - 'a';
t[l] |= (1 << p);
}
}
int p = s % 2;
int res = (p) ? -INF : INF;
for (int i = 0; i < 26; i++) {
if (t[i] == 0) continue;
int r = score(i + 'a') + Cal(s + 1, t[i]);
if ((p && r > res) || (!p && r < res)) res = r;
}
return (f[s][mask] = res);
}
int main() {
scanf("%d\n", &n);
for (int i = 0; i < n; i++) cin >> ch[i];
for (int i = 0; i < 2 * n - 1; i++)
for (int j = 0; j < 1 << n; j++) f[i][j] = -INF;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i == n - 1 || j == 0) {
int p = 0;
int x = i, y = j;
while (x >= 0 && y < n) {
diag[x + y].push_back(pair<int, int>(x, y));
pos[x][y] = p++;
x--, y++;
}
}
int res = score(ch[0][0]) + Cal(0, 1);
if (res < 0)
puts("SECOND");
else if (res > 0)
puts("FIRST");
else
puts("DRAW");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
int f[maxn * 2 + 5][1 << maxn], n, res;
char str[maxn + 5][maxn + 5];
int dfs(int k, int s) {
if (f[k][s] < 1e9) return f[k][s];
int &res = f[k][s], tmp[26], x, y, cnt = 0, Next;
if (k < 2 * n - 2) {
memset(tmp, 0, sizeof tmp);
for (int i = 0; i <= k + 1; i++) {
x = k + 1 - i;
y = i;
if (x >= n || y >= n) continue;
tmp[str[x][y] - 'a'] |= 1 << (cnt++);
}
for (int i = 0; i < 26; i++) {
if (k + 1 < n)
Next = (s | (s << 1)) & tmp[i];
else
Next = (s | (s >> 1)) & tmp[i];
if (!Next) continue;
res = min(res, -dfs(k + 1, Next));
}
} else
res = 0;
for (int i = 0; i <= k; i++)
if (s >> i & 1) {
x = min(n - 1, k) - i, y = k - x;
if (str[x][y] == 'a') res += (k & 1 ? -1 : 1);
if (str[x][y] == 'b') res += (k & 1 ? 1 : -1);
break;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n - 1; i++) scanf("%s", str[i]);
memset(f, 0x3f, sizeof f);
res = dfs(0, 1);
if (!res)
puts("DRAW");
else if (res > 0)
puts("FIRST");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace {
template <class T>
void initvv(vector<vector<T> > &v, int a, int b, const T &t = T()) {
v.assign(a, vector<T>(b, t));
}
template <class F, class T>
void convert(const F &f, T &t) {
stringstream ss;
ss << f;
ss >> t;
}
const int INF = 1010101010;
int n;
char tbl[50][50];
vector<int> chs[50];
vector<vector<int> > G[50];
int num[50][50];
vector<int> memo[50];
int dfs(int d, int S) {
int &r = memo[d][S];
if (r != INF) {
return r;
}
int c = G[d].size();
if (d == 2 * n - 2) {
r = 0;
} else {
if (d & 1) {
r = -INF;
}
int to[26] = {};
for (int i = 0; i < c; ++i)
if (S >> i & 1) {
for (int u : G[d][i]) {
to[chs[d + 1][u]] |= 1 << u;
}
}
for (int i = 0; i < 26; ++i) {
if (to[i]) {
int q = dfs(d + 1, to[i]);
if (d & 1) {
r = max(r, q);
} else {
r = min(r, q);
}
}
}
}
for (int i = 0; i < c; ++i)
if (S >> i & 1) {
if (chs[d][i] == 0) {
++r;
} else if (chs[d][i] == 1) {
--r;
}
break;
}
return r;
}
void mainmain() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> tbl[i];
}
for (int i = 0; i < 2 * n - 1; ++i) {
int c = 0;
for (int y = 0; y < n; ++y) {
int x = i - y;
if (x >= 0) {
chs[i].push_back(tbl[y][x] - 'a');
num[y][x] = c++;
}
}
G[i].resize(c);
memo[i].assign(1 << c, INF);
}
for (int y = 0; y < n; ++y)
for (int x = 0; x < n; ++x) {
int p = num[y][x];
int d = y + x;
if (y != n - 1) {
G[d][p].push_back(num[y + 1][x]);
}
if (x != n - 1) {
G[d][p].push_back(num[y][x + 1]);
}
}
int res = dfs(0, 1);
if (res > 0) {
puts("FIRST");
} else if (res < 0) {
puts("SECOND");
} else {
puts("DRAW");
}
}
} // namespace
int main() try {
cout << fixed << setprecision(10);
cerr << fixed << setprecision(4);
mainmain();
} catch (...) {
}
|
#include <bits/stdc++.h>
using namespace std;
const int INIT = 1 << 30;
const int INF = 1 << 25;
int dp[40][1 << 20];
char T[20][21];
int n;
int solve(int turn, int bit) {
int &ret = dp[turn][bit];
if (ret != INIT) return ret;
if (turn == 2 * n - 2) return ret = 0;
if (turn & 1)
ret = -INF;
else
ret = INF;
for (char ch = 'a'; ch <= 'z'; ch++) {
int nxt = 0;
for (int r = 0; r < n; r++) {
if ((bit & (1 << r)) == 0) continue;
int c = turn - r;
if (c < 0 || c >= n) continue;
int nc = c + 1;
int nr = r + 1;
if (nc < n && T[r][nc] == ch) nxt |= (1 << r);
if (nr < n && T[nr][c] == ch) nxt |= (1 << nr);
}
if (nxt) {
int tmp = solve(turn + 1, nxt);
if (ch == 'a')
tmp++;
else if (ch == 'b')
tmp--;
if (turn & 1)
ret = max(ret, tmp);
else
ret = min(ret, tmp);
}
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%s", T[i]);
}
fill((int *)dp, (int *)(dp + 40), INIT);
int tmp = solve(0, 1);
if (T[0][0] == 'a')
tmp++;
else if (T[0][0] == 'b')
tmp--;
if (tmp > 0) {
printf("FIRST\n");
} else if (tmp < 0) {
printf("SECOND\n");
} else {
printf("DRAW\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[44][1 << 20];
int a[44][26], n;
char ch[22][22];
bool chk[44][1 << 20];
int solve(int x, int t) {
if (x == 2 * n - 1) return 0;
if (chk[x][t]) return dp[x][t];
int i, ret = (x & 1) ? 1e9 : -1e9;
int s = 1;
if (t) s = t | (t << 1);
for (i = 0; i < 26; i++) {
int r = a[x][i] & s;
if (!r) continue;
if (x & 1)
ret = min(ret, (i != 0 ? i != 1 ? 0 : -1 : 1) + solve(x + 1, r));
else
ret = max(ret, (i != 0 ? i != 1 ? 0 : -1 : 1) + solve(x + 1, r));
}
chk[x][t] = 1;
return dp[x][t] = ret;
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%s", ch[i]);
for (int p = 0; p < 26; p++) {
for (i = 0; i < 2 * n - 1; i++) {
for (j = max(0, i - n + 1); j < min(n, i + 1); j++)
if (ch[i - j][j] == p + 'a') a[i][p] |= (1 << j);
}
}
int t = solve(0, 0);
printf("%s", t >= 0 ? t == 0 ? "DRAW" : "FIRST" : "SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
char M[20][20 + 1];
bool done[2 * 20][(1 << 20)];
int memo[2 * 20][(1 << 20)];
int solve(int diag, int mask) {
if (diag == 2 * n - 2) return 0;
int &ret = memo[diag][mask];
if (!done[diag][mask]) {
done[diag][mask] = true;
int p = (diag & 1);
ret = (p == 0 ? 100 : -100);
for (char to = 'a'; to <= 'z'; ++to) {
int mask2 = 0;
for (int r = 0, c = diag; r < n; ++r, --c) {
if (c < n && (mask & (1 << r))) {
if (r + 1 < n && M[r + 1][c] == to) mask2 |= (1 << r + 1);
if (c + 1 < n && M[r][c + 1] == to) mask2 |= (1 << r);
}
}
if (mask2) {
int aux = solve(diag + 1, mask2);
if (to == 'a')
++aux;
else if (to == 'b')
--aux;
if (p == 0)
ret = min(ret, aux);
else
ret = max(ret, aux);
}
}
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%s", M[i]);
memset(done, false, sizeof done);
int ret = solve(0, 1);
if (M[0][0] == 'a')
++ret;
else if (M[0][0] == 'b')
--ret;
if (ret == 0)
puts("DRAW");
else if (ret > 0)
puts("FIRST");
else
puts("SECOND");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 20;
const int NLetter = 26;
template <class T>
inline void tension(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
inline void relax(T &a, const T &b) {
if (b > a) a = b;
}
int main() {
int n;
static char a[MaxN][MaxN];
cin >> n;
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++)
while (a[x][y] = getchar(), 'a' > a[x][y] || a[x][y] > 'z')
;
static int available[MaxN * 2 - 1][NLetter];
for (int x = 0; x < n; x++)
for (int y = 0; y < n; y++)
available[x + y][a[x][y] - 'a'] |= 1 << min(x, n - 1 - y);
static int f[MaxN * 2 - 1][1 << MaxN];
f[n * 2 - 2][1] = 0;
for (int s = n * 2 - 3; s >= 0; s--) {
int l = min(s + 1, n * 2 - 1 - s);
for (int status = 0; status < (1 << l); status++) {
int t = status;
if (s < n - 1)
t |= status << 1;
else
t |= status >> 1;
if (s & 1)
f[s][status] = INT_MIN;
else
f[s][status] = INT_MAX;
for (int c = 0; c < NLetter; c++)
if (t & available[s + 1][c]) {
int delta = (c == 0) - (c == 1);
if (s & 1)
relax(f[s][status], f[s + 1][t & available[s + 1][c]] + delta);
else
tension(f[s][status], f[s + 1][t & available[s + 1][c]] + delta);
}
}
}
int res = (a[0][0] == 'a') - (a[0][0] == 'b') + f[0][1];
if (res > 0)
cout << "FIRST" << endl;
else if (res < 0)
cout << "SECOND" << endl;
else
cout << "DRAW" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
int n, cnt;
char g[25][25];
int dp[55][(1 << 20) + 10], M[50][26];
inline void ckmax(int &a, int b) {
if (a < b) a = b;
}
inline void ckmin(int &a, int b) {
if (a > b) a = b;
}
inline int getm(int k, int x, int y) {
if (k <= n) return x - 1;
return n - y;
}
inline int gnxtmask(int k, int mask) {
if (k < n) return mask | (mask << 1);
return mask | (mask >> 1);
}
int gao(int k, int mask) {
int &res = dp[k][mask];
if (res != -inf) return res;
if (k + 1 == n + n) {
return res = 0;
}
int len = k <= n ? k : (n - (k - n)), sx = k <= n ? 1 : 1 + k - n,
sy = k <= n ? k : n;
if (~k & 1)
res = -inf;
else
res = inf;
for (int(c) = 0; (c) < (int)(26); ++(c)) {
int m = gnxtmask(k, mask) & M[k + 1][c];
if (!m) continue;
int t = (int)(c == 0) - (int)(c == 1);
if (~k & 1)
ckmax(res, t + gao(k + 1, m));
else
ckmin(res, t + gao(k + 1, m));
}
return res;
}
int main(int argc, char const *argv[]) {
scanf("%d", &n);
for (int(i) = (int)(1); (i) <= (int)(n); ++(i)) scanf("%s", g[i] + 1);
for (int(k) = (int)(1); (k) <= (int)(n + n); ++(k))
for (int(j) = 0; (j) < (int)(26); ++(j)) {
int len = k <= n ? k : (n - (k - n)), sx = k <= n ? 1 : 1 + k - n,
sy = k <= n ? k : n;
for (int i = 0; i < len; ++i, ++sx, --sy) {
if (g[sx][sy] == 'a' + j) {
M[k][j] |= 1 << i;
}
}
}
for (int(i) = (int)(1); (i) <= (int)(n + n); ++(i)) {
int len = i <= n ? i : (n + n - i);
for (int(j) = 0; (j) < (int)(1 << len); ++(j)) dp[i][j] = -inf;
}
int t = g[1][1] == 'a' ? 1 : g[1][1] == 'b' ? -1 : 0;
int r = t + gao(1, 1);
if (r < 0) puts("SECOND");
if (r > 0) puts("FIRST");
if (r == 0) puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_ = 25;
int N;
char D[N_][N_];
int Table[40][1 << 20];
bool Chk[40][1 << 20];
int wh[26][N_ + N_];
int cst[2][2] = {{1, -1}, {-1, 1}};
int solve(int x, int state) {
if (x == N + N - 1) return 0;
if (Chk[x][state]) return Table[x][state];
int &ret = Table[x][state];
ret = (int)-1e9;
int state_s = state | (state << 1);
if (!state) state_s = 1;
for (int c = 0; c < 26; c++) {
int nxt = state_s & wh[c][x];
if (nxt != 0) {
int nxtret = ((c > 1) ? 0 : cst[x & 1][c]) - solve(x + 1, nxt);
ret = max(ret, nxtret);
}
}
Chk[x][state] = 1;
return ret;
}
int main() {
int i, j, k;
scanf("%d", &N);
for (i = 0; i < N; i++) scanf("%s", D[i]);
for (int c = 0; c < 26; c++)
for (i = 0; i < 2 * N - 1; i++) {
for (j = max(i - N + 1, 0); j < N && j <= i; j++)
if (D[i - j][j] == c + 'a') wh[c][i] |= 1 << j;
}
int ret = solve(0, 0);
puts((ret == 0) ? "DRAW" : ((ret > 0) ? "FIRST" : "SECOND"));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
long long tmp;
asm("rdtsc" : "=A"(tmp));
return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1e9 + 1;
const long double EPS = 1e-9;
void precalc() {}
const int maxn = 20;
char table[maxn][maxn + 1];
int n;
bool read() {
if (scanf("%d", &n) < 1) {
return 0;
}
assert(n <= maxn);
for (int i = 0; i < n; ++i) {
scanf("%s", table[i]);
}
return 1;
}
int dp[2 * maxn][1 << maxn];
const int maxc = 26;
int solve(int sum, int mask) {
assert(mask);
if (sum == 2 * n - 2) {
return 0;
}
if (dp[sum][mask] != -INF) {
return dp[sum][mask];
}
int go[maxc];
for (int c = 0; c < maxc; ++c) {
go[c] = 0;
}
int maxpos = n - abs(n - 1 - sum);
int maxnpos = n - abs(n - 1 - (sum + 1));
int nx0 = min(n - 1, sum + 1), ny0 = sum + 1 - nx0;
for (int i = 0; i < maxpos; ++i) {
if (!((mask >> i) & 1)) {
continue;
}
for (int g = 0; g < 2; ++g) {
int npos = (i + g);
if (sum >= n - 1) {
--npos;
}
if (npos < 0 || npos >= maxnpos) {
continue;
}
go[table[nx0 - npos][ny0 + npos] - 'a'] |= (1 << npos);
}
}
int res = -INF;
for (int c = 0; c < maxc; ++c) {
int nmask = go[c];
if (nmask == 0) {
continue;
}
int value = solve(sum + 1, nmask) + (!c ? 1 : c == 1 ? -1 : 0);
if (res == -INF || ((sum & 1) ? (res < value) : (res > value))) {
res = value;
}
}
assert(res != -INF);
return dp[sum][mask] = res;
}
void solve() {
for (int sum = 0; sum <= 2 * n - 2; ++sum) {
for (int mask = 0; mask < (1 << (n - abs(n - 1 - sum))); ++mask) {
dp[sum][mask] = -INF;
}
}
int res = solve(0, 1) + (table[0][0] == 'a' ? 1
: table[0][0] == 'b' ? -1
: 0);
if (res > 0) {
printf("FIRST\n");
} else {
if (res < 0) {
printf("SECOND\n");
} else {
printf("DRAW\n");
}
}
}
int main() {
srand(rdtsc());
precalc();
while (1) {
if (!read()) {
break;
}
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 20 + 10;
const int INF = 1000000000 + 10;
int n;
char g[MAX][MAX];
int f[2][1 << 21];
pair<int, int> id[MAX][MAX];
int to[MAX * 2], go[30];
pair<int, int> is[MAX * 3][MAX * 3];
int main() {
int i, j, k;
scanf("%d", &n);
for ((i) = (1); (i) <= (n); ++(i)) scanf("%s", g[i] + 1);
for ((i) = (1); (i) <= (n); ++(i))
for ((j) = (1); (j) <= (n); ++(j)) {
id[i][j] = make_pair(i + j - 1, to[i + j - 1]);
is[i + j - 1][to[i + j - 1]] = make_pair(i, j);
to[i + j - 1]++;
}
int last = 0, now = 1;
int inf = INF;
for ((i) = (0); (i) != (1 << n); ++(i)) f[now][i] = inf;
if (g[n][n] == 'a')
f[now][1] = 1;
else if (g[n][n] == 'b')
f[now][1] = -1;
else
f[now][1] = 0;
for (i = n + n - 2; i >= 1; --i) {
inf *= -1;
swap(now, last);
int num = (i <= n ? i : 2 * n - i);
for ((j) = (0); (j) != (1 << num); ++(j)) f[now][j] = inf;
for ((j) = (1); (j) != (1 << num); ++(j)) {
int &p = f[now][j];
for ((k) = (0); (k) != (26); ++(k)) go[k] = 0;
int ll = -1;
for ((k) = (0); (k) != (num); ++(k))
if ((j >> k) & 1) {
int ni = is[i][k].first;
int nj = is[i][k].second;
if (ll != -1 && g[ni][nj] != ll) {
ll = -2;
break;
}
ll = g[ni][nj];
go[g[ni][nj + 1] - 'a'] |= 1 << id[ni][nj + 1].second;
go[g[ni + 1][nj] - 'a'] |= 1 << id[ni + 1][nj].second;
}
if (ll == -2) continue;
for ((k) = (0); (k) != (26); ++(k))
if (go[k] != 0 && f[last][go[k]] != -inf) {
if (i % 2 == 0)
p = max(p, f[last][go[k]]);
else
p = min(p, f[last][go[k]]);
}
if (ll == 'a')
++p;
else if (ll == 'b')
--p;
}
}
if (f[now][1] > 0)
cout << "FIRST" << endl;
else if (f[now][1] == 0)
cout << "DRAW" << endl;
else
cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[42][1 << 20], a[42][42];
char s[22][22];
int n;
int dfs(int step, int sta) {
int i, num = 0;
if (dp[step][sta] != 1e9) return dp[step][sta];
for (i = 0; i < n; i++) {
if (sta & (1 << i)) {
if (s[step - i][i] == 'a')
num++;
else if (s[step - i][i] == 'b')
num--;
break;
}
}
if (step == 2 * n - 2) return dp[step][sta] = num;
if (step % 2 != 0) {
dp[step][sta] = -1e9;
for (i = 0; i < 26; i++) {
int next = a[step + 1][i] & (sta | (sta << 1));
if (next == 0) continue;
dp[step][sta] = max(dp[step][sta], dfs(step + 1, next) + num);
}
return dp[step][sta];
} else {
for (i = 0; i < 26; i++) {
int next = a[step + 1][i] & (sta | (sta << 1));
if (next == 0) continue;
dp[step][sta] = min(dp[step][sta], dfs(step + 1, next) + num);
}
return dp[step][sta];
}
}
int main() {
int i, j;
scanf("%d", &n);
for (i = 0; i < n; i++) cin >> s[i];
for (i = 0; i < 2 * n - 1; i++) {
for (j = 0; j < n; j++) {
if (i - j < 0 || i - j >= n) continue;
a[i][s[i - j][j] - 'a'] |= (1 << j);
}
}
for (i = 0; i < 2 * n; i++)
for (j = 0; j < (1 << n); j++) dp[i][j] = 1e9;
int ans = dfs(0, 1);
if (ans > 0)
puts("FIRST");
else if (ans < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
int main() {
int n;
cin >> n;
vector<string> s(n);
for (auto &si : s) cin >> si;
int sz = (n - 1) * 2;
vector<vector<int>> mask(n * 2, vector<int>(26));
for (int diag = 0; diag <= sz; diag++)
for (int c = 0; c < 26; c++) {
for (int i = 0; i < n; i++) {
if (s[i][diag - i] - 'a' == c) mask[diag][c] |= 1 << i;
}
}
vector<vector<int>> dp(sz + 1, vector<int>(1 << n, INF));
function<int(int, int, int, bool)> dfs = [&](int d, int i, int c,
bool is_first) {
if (dp[d][i] != INF) return dp[d][i];
int add = 0;
if (is_first) {
if (c == 0) add++;
if (c == 1) add--;
} else {
if (c == 0) add--;
if (c == 1) add++;
}
if (d == sz) {
return dp[d][i] = add;
} else {
int res = -INF;
for (int nc = 0; nc < 26; nc++) {
int ni = mask[d + 1][nc] & (i | i << 1);
if (ni) res = max(res, add - dfs(d + 1, ni, nc, !is_first));
}
return dp[d][i] = res;
}
};
int res = -dfs(0, 1 << 0, s[0][0] - 'a', false);
if (res > 0) cout << "FIRST" << endl;
if (res == 0) cout << "DRAW" << endl;
if (res < 0) cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000005;
const long long INFLL = 1000000000000000002ll;
const long long MOD = 1000000007;
inline long long min(long long a, long long b, long long c) {
return min(min(a, b), c);
}
inline long long min(long long a, long long b, long long c, long long d) {
return min(min(min(a, b), c), d);
}
inline long long max(long long a, long long b, long long c) {
return max(max(a, b), c);
}
inline long long max(long long a, long long b, long long c, long long d) {
return max(max(max(a, b), c), d);
}
char B[25][25];
int DP[39][1048577], N;
string mask(int m) {
string ret = "";
for (int i = (0); i <= (N - 1); i++) {
if (m & (1 << i))
ret += '1';
else
ret += '0';
}
return ret;
}
int dp(int diag, int m) {
if (DP[diag][m] > -INF) return DP[diag][m];
if (diag == 2 * N - 2) return 0;
int ret = diag & 1 ? -INF : INF;
for (int c = ('a'); c <= ('z'); c++) {
int nm = 0;
for (int i = (0); i <= (N - 1); i++)
if (m & (1 << i)) {
int j = diag - i;
if (j < 0 || j >= N) continue;
if (i < N - 1 && B[i + 1][j] == c) nm |= (1 << (i + 1));
if (j < N - 1 && B[i][j + 1] == c) nm |= (1 << i);
}
int add = 0;
if (c == 'a') add = 1;
if (c == 'b') add = -1;
if (nm > 0) {
int q = add + dp(diag + 1, nm);
if (diag & 1)
ret = max(ret, q);
else
ret = min(ret, q);
}
}
return DP[diag][m] = ret;
}
int main() {
for (int i = (0); i <= (38); i++)
for (int m = (0); m <= (1048576); m++) DP[i][m] = -INF;
cin >> N;
for (int i = (0); i <= (N - 1); i++) {
string s;
cin >> s;
for (int j = (0); j <= (N - 1); j++) B[i][j] = s[j];
}
int add = 0;
if (B[0][0] == 'a') add = 1;
if (B[0][0] == 'b') add = -1;
int q = add + dp(0, 1);
if (q > 0)
cout << "FIRST";
else if (q < 0)
cout << "SECOND";
else
cout << "DRAW";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
const int INF = 16843009;
int n;
char a[N][N];
int memo[N + N][1 << N];
int dp(int d, int mask) {
if (d == n + n - 1) return 0;
int &ret = memo[d][mask];
if (ret != INF) return ret;
ret = d & 1 ? INF : -INF;
for (char c = 'a'; c <= 'z'; ++c) {
int newMask = 0;
for (int i = 0; i <= d; ++i) {
int j = d - i;
if (j >= n || a[i][j] != c || !((mask >> i) & 1)) continue;
newMask |= 1 << i;
if (i + 1 < n) newMask |= 1 << (i + 1);
}
if (!newMask) continue;
int score = (c == 'a') - (c == 'b');
if (d & 1)
ret = min(ret, dp(d + 1, newMask) + score);
else
ret = max(ret, dp(d + 1, newMask) + score);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf(" %c", &a[i][j]);
}
}
memset(memo, 1, sizeof memo);
int ans = dp(0, 1);
if (ans > 0)
puts("FIRST");
else if (ans < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9 + 7;
int main() {
int n;
cin >> n;
vector<string> s(n);
for (auto &si : s) cin >> si;
int sz = (n - 1) * 2;
vector<vector<int>> mask(n * 2, vector<int>(26));
for (int diag = 0; diag <= sz; diag++)
for (int c = 0; c < 26; c++) {
for (int i = 0; i < n; i++) {
if (s[i][diag - i] - 'a' == c) mask[diag][c] |= 1 << i;
}
}
vector<vector<int>> dp(sz + 1, vector<int>(1 << n, INF));
function<int(int, int, int, bool)> dfs = [&](int d, int i, int c,
bool is_first) {
if (dp[d][i] != INF) return dp[d][i];
int res = INF;
if (d == sz) {
res = 0;
} else {
for (int nc = 0; nc < 26; nc++) {
int ni = mask[d + 1][nc] & (i | i << 1);
if (ni) res = min(res, -dfs(d + 1, ni, nc, !is_first));
}
}
if (is_first) {
if (c == 0) res++;
if (c == 1) res--;
} else {
if (c == 0) res--;
if (c == 1) res++;
}
return dp[d][i] = res;
};
int res = dfs(0, 1 << 0, s[0][0] - 'a', true);
if (res > 0) cout << "FIRST" << endl;
if (res == 0) cout << "DRAW" << endl;
if (res < 0) cout << "SECOND" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 22;
const int inf = 100000000;
int n;
char Map[N][N];
vector<int> vecs[100];
map<pair<int, vector<int> >, int> f;
inline int val(char x) {
if (x == 'a') return 1;
if (x == 'b') return -1;
return 0;
}
int dfs(int len) {
if (len == 2 * n) return 0;
if (f.find(make_pair(len, vecs[len])) != f.end())
return f[make_pair(len, vecs[len])];
int ret = 0;
if (len % 2 == 1)
ret = -inf;
else
ret = inf;
for (char ch = 'a'; ch <= 'z'; ch++) {
vecs[len + 1].clear();
for (int i = 0; i < vecs[len].size(); i++) {
int x = vecs[len][i], y = len - x;
if (x < n && Map[x + 1][y] == ch) vecs[len + 1].push_back(x + 1);
if (y < n && Map[x][y + 1] == ch) vecs[len + 1].push_back(x);
}
if ((int)vecs[len + 1].size() == 0) continue;
sort(vecs[len + 1].begin(), vecs[len + 1].end());
vecs[len + 1].erase(unique(vecs[len + 1].begin(), vecs[len + 1].end()),
vecs[len + 1].end());
if (len % 2 == 1)
ret = max(ret, val(ch) + dfs(len + 1));
else
ret = min(ret, val(ch) + dfs(len + 1));
}
return f[make_pair(len, vecs[len])] = ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", Map[i] + 1);
f.clear();
vecs[2].push_back(1);
int result = dfs(2);
result += val(Map[1][1]);
if (result > 0)
printf("FIRST\n");
else if (result == 0)
printf("DRAW\n");
else
printf("SECOND\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 20, inf = 1e9 + 100;
char dp[max_n * 2 - 1][1 << max_n];
bool vis[max_n * 2 - 1][1 << max_n];
char f[max_n][max_n];
string s[max_n * 2];
int n;
void find_vis() {
vis[0][1] = 1;
for (int i = 0; i + 2 < 2 * n; ++i) {
int len = s[i].size();
int nlen = s[i + 1].size();
bool stepa = i % 2;
for (int mask = 1; mask < (1 << len); ++mask) {
if (!vis[i][mask]) continue;
for (char ns : s[i + 1]) {
int nxt_mask = 0;
for (int k = 0; k < s[i].size(); ++k) {
if ((mask & (1 << k)) == 0) continue;
if (s[i + 1].size() > s[i].size()) {
if (s[i + 1][k] == ns) {
nxt_mask |= (1 << k);
}
if (s[i + 1][k + 1] == ns) {
nxt_mask |= (1 << (k + 1));
}
} else {
if (k && s[i + 1][k - 1] == ns) {
nxt_mask |= (1 << (k - 1));
}
if (k + 1 < len && s[i + 1][k] == ns) {
nxt_mask |= (1 << k);
}
}
}
if (nxt_mask == 0) continue;
if (!vis[i + 1][nxt_mask]) {
vis[i + 1][nxt_mask] = 1;
}
}
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> f[i][j];
}
}
for (int j = 0; j < n; ++j) {
for (int i = 0; i < n; ++i) {
s[i + j] += f[i][j];
}
}
find_vis();
if (f[n - 1][n - 1] == 'a') {
dp[2 * n - 2][1] = 1;
} else if (f[n - 1][n - 1] == 'b') {
dp[2 * n - 2][1] = -1;
} else {
dp[2 * n - 2][1] = 0;
}
bool stepa = false;
for (int i = 2 * n - 3; i >= 0; --i) {
int len = s[i].size();
int nlen = s[i + 1].size();
stepa = !stepa;
for (int mask = 1; mask < (1 << len); ++mask) {
if (!vis[i][mask]) continue;
dp[i][mask] = stepa ? -inf : inf;
char cs;
for (int k = 0; k < len; ++k) {
if (mask & (1 << k)) {
cs = s[i][k];
}
}
for (char ns : s[i + 1]) {
int nxt_mask = 0;
for (int k = 0; k < len; ++k) {
if ((mask & (1 << k)) == 0) continue;
if (s[i + 1].size() > s[i].size()) {
if (s[i + 1][k] == ns) {
nxt_mask |= (1 << k);
}
if (s[i + 1][k + 1] == ns) {
nxt_mask |= (1 << (k + 1));
}
} else {
if (k && s[i + 1][k - 1] == ns) {
nxt_mask |= (1 << (k - 1));
}
if (k + 1 < len && s[i + 1][k] == ns) {
nxt_mask |= (1 << k);
}
}
}
if (!vis[i + 1][nxt_mask]) continue;
int val = dp[i + 1][nxt_mask];
if (cs == 'a')
++val;
else if (cs == 'b')
--val;
if (stepa) {
dp[i][mask] = max(dp[i][mask], (char)val);
} else {
dp[i][mask] = min(dp[i][mask], (char)val);
}
}
}
}
if (dp[0][1] > 0) {
cout << "FIRST";
} else if (dp[0][1] < 0) {
cout << "SECOND";
} else {
cout << "DRAW";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string T[20];
bool comp[40][1 << 20];
int res[40][1 << 20];
int pts(char c, int d) {
if (c == 'a') return 1 * (1 - 2 * (d % 2));
if (c == 'b') return -1 * (1 - 2 * (d % 2));
return 0;
}
int go(int d, int bitmask) {
if (bitmask == 0) {
return -100;
}
if (comp[d][bitmask]) return res[d][bitmask];
comp[d][bitmask] = true;
if (d == 2 * n - 2) {
res[d][bitmask] = 0;
} else if (d + 1 < n) {
int best = 100;
for (char x = 'a'; x <= 'z'; x++) {
int nbitmask = 0;
for (int j = 0; j <= d + 1; j++) {
if (T[j][d + 1 - j] != x) continue;
if ((1 << j) & bitmask) nbitmask |= (1 << j);
if ((j != 0) && ((1 << (j - 1)) & bitmask)) nbitmask |= (1 << j);
}
best = min(best, pts(x, d) - go(d + 1, nbitmask));
}
res[d][bitmask] = best;
} else {
int best = 100;
for (char x = 'a'; x <= 'z'; x++) {
int nbitmask = 0;
for (int j = 0; j < 2 * n - 2 - d; j++) {
if (T[2 - n + d + j][n - 1 - j] != x) continue;
if ((1 << j) & bitmask) nbitmask |= (1 << j);
if (((1 << (j + 1)) & bitmask)) nbitmask |= (1 << j);
}
best = min(best, pts(x, d) - go(d + 1, nbitmask));
}
res[d][bitmask] = best;
}
return res[d][bitmask];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> T[i];
int x = pts(T[0][0], 0) + go(0, 1);
if (x > 0) {
printf("FIRST\n");
} else if (x == 0) {
printf("DRAW\n");
} else {
printf("SECOND\n");
}
}
|
#include <bits/stdc++.h>
int h[20];
char s[20][20];
int i, j, n, m;
int p[20 * 2][1 << 20];
bool checked[20 * 2][1 << 20];
int mymin(int a, int b) { return a < b ? a : b; }
int mymax(int a, int b) { return a > b ? a : b; }
int f(char a) {
if (a == 'a') return 1;
if (a == 'b') return -1;
return 0;
}
int make(int a, int mask, char nowc) {
if (checked[a][mask]) return p[a][mask];
char b;
int next, i;
for (b = 'a'; b <= 'z'; b++) {
next = 0;
for (i = 0; i < n; i++)
if (h[i] & mask) {
if (i < n - 1 && s[i + 1][a - i] == b) {
next |= h[i + 1];
}
if (a - i < n - 1 && s[i][a - i + 1] == b) {
next |= h[i];
}
}
if (next == 0) continue;
if (a & 1) {
if (!checked[a][mask]) {
checked[a][mask] = 1;
p[a][mask] = make(a + 1, next, b);
} else {
p[a][mask] = mymax(p[a][mask], make(a + 1, next, b));
}
} else {
if (!checked[a][mask]) {
checked[a][mask] = 1;
p[a][mask] = make(a + 1, next, b);
} else {
p[a][mask] = mymin(p[a][mask], make(a + 1, next, b));
}
}
}
p[a][mask] += f(nowc);
return p[a][mask];
}
int main() {
h[0] = 1;
for (i = 1; i < 20; i++) h[i] = h[i - 1] * 2;
scanf("%d", &n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) scanf(" %c", &s[i][j]);
}
checked[n + n - 2][h[n - 1]] = 1;
p[n + n - 2][h[n - 1]] = f(s[n - 1][n - 1]);
int ans = make(0, 1, s[0][0]);
if (ans > 0) {
printf("FIRST\n");
} else if (ans < 0) {
printf("SECOND\n");
} else
printf("DRAW\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ci[] = {1, 0};
int cj[] = {0, 1};
int dp[40][1 << 20];
int n;
char a[20][20];
inline int bit(int n, int i) { return (n >> i) & 1; }
inline bool inside(int i, int j) { return min(i, j) >= 0 && max(i, j) < n; }
int DP(int d, int t) {
if (dp[d][t] > 1e9) {
int ok[26];
int i = d;
int j = 0;
char c;
memset(ok, 0, sizeof ok);
for (int k = 0; k < n; k++)
if (bit(t, k)) {
c = a[i - k][j + k];
for (int kk = 0; kk < 2; kk++) {
int ii = i - k + ci[kk];
int jj = j + k + cj[kk];
if (inside(ii, jj)) ok[a[ii][jj] - 'a'] |= 1 << (k + kk);
}
}
if (d < 2 * n - 2) {
for (char c = 0; c < 26; c++)
if (ok[c]) dp[d][t] = min(dp[d][t], -DP(d + 1, ok[c]));
} else
dp[d][t] = 0;
if (d & 1) {
if (c == 'a') dp[d][t]--;
if (c == 'b') dp[d][t]++;
} else {
if (c == 'b') dp[d][t]--;
if (c == 'a') dp[d][t]++;
}
}
return dp[d][t];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", a[i]);
memset(dp, 63, sizeof dp);
int ret = DP(0, 1);
if (ret > 0)
printf("FIRST");
else if (ret < 0)
printf("SECOND");
else
printf("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 25;
int n, val[255];
char str[N][N];
vector<int> v[N << 1];
map<pair<int, vector<int> >, int> dp;
int dfs(int l) {
if (l == 2 * n) return 0;
if (dp.find(make_pair(l, v[l])) != dp.end()) return dp[make_pair(l, v[l])];
int ret;
if (l % 2 == 0)
ret = (N * N);
else
ret = -(N * N);
for (char ch = 'a'; ch <= 'z'; ch++) {
v[l + 1].clear();
for (int i = 0; i < v[l].size(); i++) {
int x = v[l][i], y = l - x;
if (x < n && str[x + 1][y] == ch) v[l + 1].push_back(x + 1);
if (y < n && str[x][y + 1] == ch) v[l + 1].push_back(x);
}
if (v[l + 1].size() == 0) continue;
sort(v[l + 1].begin(), v[l + 1].end());
v[l + 1].resize(unique(v[l + 1].begin(), v[l + 1].end()) -
v[l + 1].begin());
if (l % 2 == 0)
ret = min(ret, val[ch] + dfs(l + 1));
else
ret = max(ret, val[ch] + dfs(l + 1));
}
return dp[make_pair(l, v[l])] = ret;
}
int main() {
val['a'] = 1;
val['b'] = -1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%s", str[i] + 1);
v[2].push_back(1);
int ret = dfs(2) + val[str[1][1]];
if (ret > 0)
puts("FIRST");
else if (ret < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int neigh[2][2] = {{0, 1}, {1, 0}};
char a[100][100];
short d[40][1 << 20][2];
int n;
int solve(int xx, int bit, int op) {
int i, j, k, ans, bit1, tmp, x, y;
vector<pair<int, int> > aa;
if (xx == n + n - 2) {
return 0;
}
if (d[xx][bit][op] != 20000) return d[xx][bit][op];
aa.clear();
for (i = 0; i < n; i++)
if (((1 << i) & bit) != 0) {
aa.push_back(make_pair(i, xx - i));
}
if (op == 0)
ans = -20000;
else
ans = 20000;
for (i = 0; i < 26; i++) {
bit1 = 0;
for (j = 0; j < aa.size(); j++)
for (k = 0; k < 2; k++) {
x = aa[j].first + neigh[k][0];
y = aa[j].second + neigh[k][1];
if ((x >= 0) && (x < n) && (y >= 0) && (y < n) &&
(a[x][y] == 'a' + i)) {
bit1 |= (1 << x);
}
}
if (bit1 == 0) continue;
tmp = solve(xx + 1, bit1, 1 - op);
if (i == 0)
tmp++;
else if (i == 1)
tmp--;
if (op == 0) {
if (tmp > ans) ans = tmp;
} else {
if (tmp < ans) ans = tmp;
}
}
d[xx][bit][op] = ans;
return ans;
}
int main() {
int i, j, k, tmp;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%s", a[i]);
for (i = 0; i < n + n; i++)
for (j = 0; j < (1 << n); j++)
for (k = 0; k < 2; k++) d[i][j][k] = 20000;
tmp = solve(0, 1, 1);
if (a[0][0] == 'a')
tmp++;
else if (a[0][0] == 'b')
tmp--;
if (tmp == 0)
printf("DRAW\n");
else if (tmp > 0)
printf("FIRST\n");
else
printf("SECOND\n");
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
const int inf = 100;
int alp[50][30];
string s[30];
int dp[42][(1 << 20) + 10];
int cost(char x) {
if (x == 'a') return 1;
if (x == 'b') return -1;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < n; j++) s[i] += '@';
}
for (int i = 0; i <= 2 * n - 2; i++) {
for (int c = 0; c < 26; c++) {
for (int j = 0; j <= min(i, n - 1); j++) {
int k = i - j;
if (s[j][k] == (char)(c + 'a')) alp[i][c] |= (1 << j);
}
}
}
for (int i = 2 * n - 3; i >= 0; i--) {
int len = min(i + 1, n);
for (int mask = 0; mask < (1 << len); mask++) {
if (i & 1)
dp[i][mask] = -inf;
else
dp[i][mask] = +inf;
int nex = (mask | (mask << 1));
for (int c = 0; c < 26; c++) {
int then = (alp[i + 1][c] & nex);
if (then == 0) continue;
if (i & 1)
dp[i][mask] =
max(dp[i][mask], dp[i + 1][then] + cost((char)(c + 'a')));
else
dp[i][mask] =
min(dp[i][mask], dp[i + 1][then] + cost((char)(c + 'a')));
}
}
}
int x = dp[0][1] + cost(s[0][0]);
if (x == 0) cout << "DRAW\n";
if (x < 0) cout << "SECOND\n";
if (x > 0) cout << "FIRST\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int D[40][1 << 20];
char A[20][21];
int dy(int s, int msk) {
int &ret = D[s][msk];
if (ret > -2e9) return ret;
int y;
for (y = 0; !(msk & (1 << y)); y++)
;
ret = (A[y][s - y] == 'b') - (A[y][s - y] == 'a');
if (s & 1) ret = -ret;
if (s == N + N - 2) return ret;
int best = -2e9;
for (char ch = 'a'; ch <= 'z'; ch++) {
int nmsk = 0, i;
for (i = 0; i < N; i++)
if (msk & (1 << i)) {
if (s - i + 1 < N && A[i][s - i + 1] == ch) nmsk |= (1 << i);
if (i + 1 < N && A[i + 1][s - i] == ch) nmsk |= (1 << (i + 1));
}
if (!nmsk) continue;
best = max(best, -dy(s + 1, nmsk));
}
ret += best;
return ret;
}
int main() {
int i, j, k;
scanf("%d", &N);
for (i = 0; i < N; i++) scanf("%s", A[i]);
for (i = 0; i < N + N; i++)
for (j = 0; j < (1 << N); j++) D[i][j] = -2e9;
k = -dy(0, 1);
if (k > 0)
puts("FIRST");
else if (!k)
puts("DRAW");
else
puts("SECOND");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 25, MAXMASK = (1 << 20) + 5, INF = 1000 * 1000 * 1000 + 5;
char t[MAXN][MAXN], used[2 * MAXN][MAXMASK];
int d[2 * MAXN][MAXMASK], n;
void dfs(int diag, int mask) {
if (used[diag][mask]) return;
used[diag][mask] = true;
if (diag == n + n - 2) return;
if (diag & 1)
d[diag][mask] = -INF;
else
d[diag][mask] = INF;
if (diag < n - 1)
for (char c = 'a'; c <= 'z'; c++) {
int mask1 = (mask & 1) && t[0][diag + 1] == c;
for (int i = 0; i < diag + 1; i++)
if ((mask & (1 << i)) || (mask & (1 << (i + 1))))
mask1 |= (int)(t[i + 1][diag - i] == c) << (i + 1);
if (mask1) {
dfs(diag + 1, mask1);
if (diag & 1)
d[diag][mask] =
max(d[diag][mask],
d[diag + 1][mask1] + (int)(c == 'a') - (int)(c == 'b'));
else
d[diag][mask] =
min(d[diag][mask],
d[diag + 1][mask1] + (int)(c == 'a') - (int)(c == 'b'));
}
}
else
for (char c = 'a'; c <= 'z'; c++) {
int mask1 = 0;
for (int i = 0; i < n + n - diag - 2; i++)
if ((mask & (1 << i)) || (mask & (1 << (i + 1))))
mask1 |= (int)(t[diag - n + 2 + i][n - 1 - i] == c) << i;
if (mask1) {
dfs(diag + 1, mask1);
if (diag & 1)
d[diag][mask] =
max(d[diag][mask],
d[diag + 1][mask1] + (int)(c == 'a') - (int)(c == 'b'));
else
d[diag][mask] =
min(d[diag][mask],
d[diag + 1][mask1] + (int)(c == 'a') - (int)(c == 'b'));
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) cin >> t[i][j];
dfs(0, 1);
int ans = d[0][1] + (int)(t[0][0] == 'a') - (int)(t[0][0] == 'b');
cout << (ans == 0 ? "DRAW\n" : (ans > 0 ? "FIRST\n" : "SECOND\n"));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int MIN(int a, int b) { return min(a, b); }
int MAX(int a, int b) { return max(a, b); }
int N, UP;
char in[25][25];
vector<vector<pair<int, int> > > base;
vector<vector<char> > cbase;
int go[45][30][25];
bool sosedi(pair<int, int> a, pair<int, int> b) {
return abs(a.first - b.first) + abs(a.second - b.second) == 1;
}
int* dp[45];
int main() {
scanf("%d", &N);
UP = 2 * N - 1;
for (int i = 0; i < N; ++i) {
scanf("%s", &in[i]);
}
for (int i = 0; i < N; ++i) {
base.push_back(vector<pair<int, int> >());
cbase.push_back(vector<char>());
for (int y = 0, x = i; x >= 0; --x, ++y)
base.back().push_back(make_pair(x, y)), cbase.back().push_back(in[x][y]);
}
for (int j = 1; j < N; ++j) {
base.push_back(vector<pair<int, int> >());
cbase.push_back(vector<char>());
for (int y = j, x = N - 1; y < N; --x, ++y)
base.back().push_back(make_pair(x, y)), cbase.back().push_back(in[x][y]);
}
for (int i = 0; i + 1 < ((int)(base).size()); ++i)
for (int j = 0; j < ((int)(base[i]).size()); ++j)
for (char c = 'a'; c <= 'z'; ++c)
for (int nbr = 0; nbr < ((int)(base[i + 1]).size()); ++nbr)
if (cbase[i + 1][nbr] == c && sosedi(base[i][j], base[i + 1][nbr]))
go[i][c - 'a'][j] |= (1 << nbr);
dp[((int)(base).size()) - 1] = new int[2];
dp[((int)(base).size()) - 1][1] = 0;
for (int cur = ((int)(base).size()) - 1; cur > 0; --cur) {
dp[cur - 1] = new int[1 << ((int)(base[cur - 1]).size())];
typeof(&MIN) relax;
if ((cur & 1) == 0) {
relax = &MAX;
fill(dp[cur - 1], dp[cur - 1] + (1 << ((int)(base[cur - 1]).size())),
-1000000000);
} else {
relax = &MIN;
fill(dp[cur - 1], dp[cur - 1] + (1 << ((int)(base[cur - 1]).size())),
1000000000);
}
int RS = ((int)(base[cur - 1]).size()), UPTO = (1 << RS);
for (int msk = 1; msk < UPTO; ++msk) {
int& VAL = dp[cur - 1][msk];
for (char put = 0; put < 26; ++put) {
int nmsk = 0, nval = 0;
if (put == 0)
++nval;
else if (put == 1)
--nval;
int cmsk = msk, i;
int* sft = go[cur - 1][put];
for (i = __builtin_ctz(cmsk); cmsk != 0;
cmsk ^= (1 << i), i = __builtin_ctz(cmsk))
nmsk |= sft[i];
if (nmsk != 0 && abs(dp[cur][nmsk]) != 1000000000)
VAL = relax(VAL, nval + dp[cur][nmsk]);
}
}
}
int val = dp[0][1];
if (in[0][0] == 'a') ++val;
if (in[0][0] == 'b') --val;
if (val > 0)
puts("FIRST");
else if (val < 0)
puts("SECOND");
else
puts("DRAW");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
const int INF = 0x3f3f3f3f;
template <class K, class V>
ostream& operator<<(ostream& out, const pair<K, V>& v) {
out << '(' << v.first << ',' << v.second << ')';
return out;
}
template <class C, class = typename C::iterator>
struct _cprint {
using type = void;
};
template <>
struct _cprint<string> {};
template <class C, class = typename _cprint<C>::type>
ostream& operator<<(ostream& out, const C& v) {
for (auto x : v) out << x << ' ';
return out;
}
template <class C>
inline void chmax(C& x, const C& a) {
if (x < a) x = a;
}
template <class C>
inline void chmin(C& x, const C& a) {
if (x > a) x = a;
}
template <class C>
inline C mod(C a, C b) {
return (a % b + b) % b;
}
int n, m, k;
vector<string> grid;
int di[] = {-1, 1, 0, 0};
int dj[] = {0, 0, -1, 1};
void dfs(int i, int j) {
if (k == 0) return;
if (i < 0 || i >= n || j < 0 || j >= m) return;
if (grid[i][j] != '.') return;
grid[i][j] = 'T';
for (int k = 0; k < 4; k++) dfs(i + di[k], j + dj[k]);
if (k) grid[i][j] = 'X', k--;
}
int main() {
cin >> n >> m >> k;
grid.resize(n);
for (int i = 0; i < n; i++) cin >> grid[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == '.') {
dfs(i, j);
goto stop;
}
stop:
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (grid[i][j] == 'T') grid[i][j] = '.';
for (int i = 0; i < n; i++) cout << grid[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int ct1, n, m, k, ct;
vector<string> a;
bool visited[501][501];
void dfs(int i, int j) {
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);
dfs(i + 1, j);
dfs(i, j - 1);
dfs(i, j + 1);
}
void solve() {
cin >> n >> m >> k;
ct = 0;
a.clear();
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);
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>
char a[1003][1000], a2[1003][1000];
int h[1002][1000], n, m, k, s, i, j;
void f(int i, int j) {
a2[i][j] = '#';
{
if (i + 1 >= 0 && j >= 0 && i + 1 < n && j < m && a2[i + 1][j] != '#' &&
a2[i + 1][j] != 'X')
f(i + 1, j);
};
{
if (i >= 0 && j + 1 >= 0 && i < n && j + 1 < m && a2[i][j + 1] != '#' &&
a2[i][j + 1] != 'X')
f(i, j + 1);
};
{
if (i - 1 >= 0 && j >= 0 && i - 1 < n && j < m && a2[i - 1][j] != '#' &&
a2[i - 1][j] != 'X')
f(i - 1, j);
};
{
if (i >= 0 && j - 1 >= 0 && i < n && j - 1 < m && a2[i][j - 1] != '#' &&
a2[i][j - 1] != 'X')
f(i, j - 1);
};
if (s >= k) return;
s++;
a[i][j] = 'X';
}
int main() {
scanf("%d %d %d", &n, &m, &k);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
scanf(" %c", &a[i][j]);
a2[i][j] = a[i][j];
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
if (a[i][j] == '.') f(i, j);
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) printf("%c", a[i][j]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e2 + 5;
char ch[maxn][maxn];
int vis[maxn][maxn];
int n, m, p;
void dfs(int a, int b) {
if (ch[a][b] == '#') return;
if (vis[a][b] == 1) return;
if (a < 0 || a >= n || b < 0 || b >= m) return;
vis[a][b] = 1;
dfs(a - 1, b);
dfs(a + 1, b);
dfs(a, b + 1);
dfs(a, b - 1);
if (p) {
ch[a][b] = 'X';
p--;
}
}
int main() {
memset(vis, 0, sizeof(vis));
scanf("%d%d%d\n", &n, &m, &p);
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
scanf("%c", &ch[i][k]);
}
getchar();
}
while (p) {
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
dfs(i, k);
}
}
}
for (int i = 0; i < n; i++) {
for (int k = 0; k < m; k++) {
printf("%c", ch[i][k]);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
string char_to_str(char c) {
string tem(1, c);
return tem;
}
long long max(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
long long min(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long n, m, k, res;
void dfs(char a[][501], long long x, long long y) {
if (res < 1) {
return;
}
res--;
a[x][y] = 'V';
if (x > 0 && a[x - 1][y] == '.') {
dfs(a, x - 1, y);
}
if (x < n - 1 && a[x + 1][y] == '.') {
dfs(a, x + 1, y);
}
if (y > 0 && a[x][y - 1] == '.') {
dfs(a, x, y - 1);
}
if (y < m - 1 && a[x][y + 1] == '.') {
dfs(a, x, y + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> n >> m >> k;
long long sum = 0;
char a[n][501];
long long b[2];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
if (a[i][j] == '.') {
b[0] = i;
b[1] = j;
sum++;
}
}
}
res = sum - k;
dfs(a, b[0], b[1]);
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (a[i][j] == 'V') {
cout << '.';
} else if (a[i][j] == '.') {
cout << 'X';
} else {
cout << a[i][j];
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
char maze[505][505];
bool vis[505][505];
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
void dfs(int r, int c) {
if (r >= n || r < 0 || c >= m || c < 0 || maze[r][c] == '#' || vis[r][c])
return;
vis[r][c] = 1;
for (int i = 0; i < 4; i++) dfs(r + dx[i], c + dy[i]);
if (k > 0) {
maze[r][c] = 'X';
k--;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
scanf("%d%d%d\n", &n, &m, &k);
int x = -1, y = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%c", &maze[i][j]);
if (maze[i][j] == '.') {
x = i, y = j;
}
}
char c;
scanf("%c", &c);
}
dfs(x, y);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
printf("%c", maze[i][j]);
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int d[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
char s[505][505];
void dfs(int x, int y, int &k, int n, int m) {
if (!k) return;
s[x][y] = '.';
k--;
for (int i = 0; i < 4; i++) {
int tx = x + d[i][0];
int ty = y + d[i][1];
if (tx >= 0 && tx < n && ty >= 0 && ty < m && s[tx][ty] == 'X')
dfs(tx, ty, k, n, m);
}
}
int main() {
int n, m, k, cnt = 0;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (s[i][j] == '.') {
s[i][j] = 'X';
cnt++;
}
}
k = cnt - k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (s[i][j] == 'X') dfs(i, j, k, n, m);
for (int i = 0; i < n; i++) printf("%s\n", s[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf = 2147483647;
const long long ll = 9223372036854775807;
int a, b, c;
char A[505][505] = {};
int now = 0;
int vis[505][505] = {};
queue<pair<int, int> > num;
vector<pair<int, int> > ans;
void bfs(int i1, int j1) {
if (now == c) {
return;
}
vis[i1][j1] = 1;
while (!num.empty()) {
pair<int, int> tmp = num.front();
num.pop();
int i = tmp.first, j = tmp.second;
int sum = 0;
if (i - 1 >= 0 && !vis[i - 1][j] && A[i - 1][j] == '.') {
num.push(make_pair(i - 1, j));
ans.push_back(make_pair(i - 1, j));
vis[i - 1][j] = 1;
}
if (i + 1 < a && !vis[i + 1][j] && A[i + 1][j] == '.') {
num.push(make_pair(i + 1, j));
ans.push_back(make_pair(i + 1, j));
vis[i + 1][j] = 1;
}
if (j - 1 >= 0 && !vis[i][j - 1] && A[i][j - 1] == '.') {
num.push(make_pair(i, j - 1));
ans.push_back(make_pair(i, j - 1));
vis[i][j - 1] = 1;
}
if (j + 1 < b && !vis[i][j + 1] && A[i][j + 1] == '.') {
num.push(make_pair(i, j + 1));
ans.push_back(make_pair(i, j + 1));
vis[i][j + 1] = 1;
}
}
}
int main() {
while (cin >> a >> b >> c) {
for (int i = 0; i < a; i++) {
cin >> A[i];
}
int ok = 0;
for (int i = 0; i < a && !ok; i++) {
for (int j = 0; j < b && !ok; j++) {
if (A[i][j] == '.') {
num.push(make_pair(i, j));
ans.push_back(make_pair(i, j));
bfs(i, j);
ok = 1;
}
}
}
for (int i = 0; i < c; i++) {
pair<int, int> tmp = ans.back();
A[tmp.first][tmp.second] = 'X';
ans.pop_back();
}
for (int i = 0; i < a; i++) {
cout << A[i] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, x[300000] = {}, y[300000] = {}, head = 0, tail = 0;
char ch[550][550] = {};
bool b[550][550] = {};
void init() {
scanf("%d %d %d\n", &n, &m, &k);
for (int i = 1; i <= n; ++i) gets(ch[i] + 1);
}
void bfs() {
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (ch[i][j] == '.') {
x[++tail] = i;
y[tail] = j;
b[i][j] = true;
goto out;
}
out:
const int x_[5] = {0, 1, 0, -1, 0};
const int y_[5] = {0, 0, 1, 0, -1};
while (head != tail) {
++head;
for (int i = 1; i <= 4; ++i) {
int _x = x[head] + x_[i], _y = y[head] + y_[i];
if (ch[_x][_y] == '.' && b[_x][_y] == false) {
++tail;
x[tail] = _x;
y[tail] = _y;
b[_x][_y] = true;
}
}
}
for (int i = tail; i >= tail - k + 1; --i) ch[x[i]][y[i]] = 'X';
for (int i = 1; i <= n; ++i) puts(ch[i] + 1);
}
int main() {
init();
bfs();
return 0;
}
|
#include <bits/stdc++.h>
const int INF = 0x7F7F7F7F;
const double EPS = 1e-10;
const long long mod7 = 1e9 + 7;
const long long mod9 = 1e9 + 9;
using namespace std;
inline long long rit() {
long long f = 0, key = 1;
char c;
do {
c = getchar();
if (c == '-') key = -1;
} while (c < '0' || c > '9');
do {
f = f * 10 + c - '0';
c = getchar();
} while (c >= '0' && c <= '9');
return f * key;
}
inline void fprt(double f) { printf("%.08lf", f); }
void init() {}
const int Z = 505;
int n, m, k, ct;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
char c[Z][Z];
int mk[Z][Z];
void dfs(int x, int y) {
if (ct >= k) return;
mk[x][y] = 1;
for (int i = 0; i < 4; ++i) {
if (mk[dx[i] + x][dy[i] + y] == 0 && c[dx[i] + x][dy[i] + y] == '.') {
dfs(dx[i] + x, dy[i] + y);
if (ct >= k) return;
}
}
if (ct < k) {
c[x][y] = 'X';
ct++;
}
if (ct >= k) return;
mk[x][y] = 0;
}
void read() {
n = rit(), m = rit(), k = rit();
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf(" %c", &c[i][j]);
}
void solve() {
while (1) {
if (ct >= k) {
for (int i2 = 1; i2 <= n; ++i2) {
for (int j2 = 1; j2 <= m; ++j2) printf("%c", c[i2][j2]);
printf("\n");
}
return;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (c[i][j] == '.') {
dfs(i, j);
if (ct >= k) {
for (int i2 = 1; i2 <= n; ++i2) {
for (int j2 = 1; j2 <= m; ++j2) printf("%c", c[i2][j2]);
printf("\n");
}
return;
}
}
}
}
}
int main() {
int nn = 1;
while (nn--) {
init(), read(), solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const MAXN = 1000000;
vector<int> g[MAXN];
int n;
vector<int> ans;
int main() {
ios_base::sync_with_stdio(false);
char A[502][502];
int N, M, K;
string s;
cin >> N >> M >> K;
for (int i = 0; i < N; ++i) {
cin >> s;
for (int j = 0; j < M; ++j) A[i][j] = s[j];
}
int res = 0;
int fuuu = 0;
for (int i = 0; i < N; ++i)
for (int j = 0; j < M; ++j) {
if (A[i][j] != '#') {
if (i > 0 && A[i - 1][j] != '#')
g[i * M + j].push_back((i - 1) * M + j);
if (i < N - 1 && A[i + 1][j] != '#')
g[i * M + j].push_back((i + 1) * M + j);
if (j > 0 && A[i][j - 1] != '#') g[i * M + j].push_back(i * M + j - 1);
if (j < M - 1 && A[i][j + 1] != '#')
g[i * M + j].push_back(i * M + j + 1);
} else
++res;
}
bool b = false;
for (int i = 0; i < N * M; ++i) {
if (b) break;
fuuu = i;
int x = fuuu / M;
int y = fuuu - x * M;
if (A[x][y] != '#') {
n = N * M;
if (K == 0) break;
int s = fuuu;
queue<int> q;
q.push(s);
vector<bool> used(n);
vector<int> d(n), p(n);
used[s] = true;
p[s] = -1;
int Z = n - K - 1 - res;
while (!q.empty()) {
if (!Z) break;
int v = q.front();
q.pop();
for (size_t i = 0; i < g[v].size(); ++i) {
int to = g[v][i];
if (!used[to]) {
if (!Z) break;
used[to] = true;
--Z;
q.push(to);
d[to] = d[v] + 1;
p[to] = v;
}
}
if (!Z) break;
}
ans.clear();
for (int i = 0; i < N * M; ++i)
if (!used[i]) {
ans.push_back(i);
}
break;
}
}
for (int i = 0; i < ans.size(); ++i) {
int f = ans[i];
int x = f / M;
int y = f - x * M;
if (A[x][y] != '#') A[x][y] = 'X';
}
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 N = 510;
const long long M = 2147483648ll;
const int MOD = 8191;
const int INF = 0x7fffffff;
const int dir[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
const double eps = 1e-16;
const double PI = acos(-1.0);
inline int sign(double x) { return (x > eps) - (x < -eps); }
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
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;
}
int n, m, k, sx, sy, cnt, tot;
char f[N][N];
int c[N][N], vis[N][N];
void dfs(int x, int y) {
int nx, ny;
for (int i = 0; i < 4; i++) {
nx = x + dir[i][0];
ny = y + dir[i][1];
if (nx < n && nx >= 0 && ny < m && ny >= 0 && f[nx][ny] == '.' &&
!vis[nx][ny]) {
if (tot - k < cnt) f[nx][ny] = 'X';
cnt++;
vis[nx][ny] = 1;
dfs(nx, ny);
}
}
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
int flag = 1;
tot = 0;
for (int i = 0; i < (n); i++) scanf("%s", (f[i]));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (f[i][j] == '.') {
if (flag == 1) {
sx = i;
sy = j;
flag = 0;
}
tot++;
}
}
}
cnt = 1;
(memset((vis), 0, sizeof(vis)));
dfs(sx, sy);
for (int i = 0; i < (n); i++) printf("%s\n", (f[i]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, -1, 0, 1};
char maze[501][501];
int n, m, k;
int vis[501][501];
bool valid(int r, int c) {
return r >= 0 && r < n && c >= 0 && c < m && maze[r][c] == '.';
}
void dfs(int r, int c) {
vis[r][c] = 1;
for (int i = 0; i < 4; i++) {
int nr = r + dy[i], nc = c + dx[i];
if (valid(nr, nc) && !vis[nr][nc]) dfs(nr, nc);
}
if (k) maze[r][c] = 'X', k--;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) scanf("%s", maze[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (!vis[i][j] && maze[i][j] == '.') dfs(i, j);
for (int i = 0; i < n; i++) printf("%s\n", maze[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, dotx, doty;
char t[502][502];
int vis[502][502];
int x[4] = {0, -1, 0, 1};
int y[4] = {1, 0, -1, 0};
void dfs(int r, int c) {
if (r >= n || r < 0 || c >= m || c < 0 || t[r][c] == '#' || vis[r][c]) return;
vis[r][c] = 1;
for (int i = 0; i < 4; i++) {
dfs(r + x[i], c + y[i]);
}
if (k > 0) {
k--;
t[r][c] = 'X';
}
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> t[i][j];
if (t[i][j] == '.') {
dotx = i;
doty = j;
}
}
dfs(dotx, doty);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << t[i][j];
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e2 + 17;
const int maxN = 3e5;
char a[maxn][maxn];
int n, m, k, first, cnt, x = 1;
bool mark[maxN], flg;
vector<int> g[maxN];
set<int> brg;
void dfs(int v) {
mark[v] = 1;
if (flg == true) brg.insert(v);
if (x == cnt - k) flg = true;
x++;
for (auto u : g[v])
if (!mark[u]) dfs(u);
}
void make_graph() {
int p = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p++;
if (a[i][j] == '#') continue;
first = p;
cnt++;
if (a[i][j - 1] != '#' && j != 1)
g[p].push_back(p - 1), g[p - 1].push_back(p);
if (a[i][j + 1] != '#' && j != m)
g[p].push_back(p + 1), g[p + 1].push_back(p);
int d1 = p - (m - j) - (j - 1) - 1, d2 = p + (m - j) + (j - 1) + 1;
if (d1 > 0 && a[i - 1][j] != '#' && i != 1)
g[p].push_back(d1), g[d1].push_back(p);
if (d2 > 0 && a[i + 1][j] != '#' && i != n)
g[p].push_back(d2), g[d2].push_back(p);
}
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
make_graph();
dfs(first);
int p = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
p++;
if (a[i][j] == '#')
cout << '#';
else {
if (brg.find(p) != brg.end())
cout << 'X';
else
cout << '.';
}
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int n, m, k, ct = 1;
char a[501][501];
vector<vector<long long int> > dir = {{1, 0}, {0, 1}, {0, -1}, {-1, 0}};
void dfs(long long int i, long long int j) {
if (ct > k) return;
a[i][j] = 'X';
for (auto d : dir) {
long long int p = i + d[0], q = j + d[1];
if (p < n && p > -1 && q < m && q > -1 && a[p][q] == '.') ++ct, dfs(p, q);
}
return;
}
void solve() {
cin >> n >> m >> k;
long long int dots = 0;
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == '.') ++dots;
}
}
k = (dots - k);
for (long long int i = 0; i < n; i++)
for (long long int j = 0; j < m; j++) {
if (a[i][j] == '.') {
dfs(i, j);
break;
}
}
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
if (a[i][j] == 'X')
cout << '.';
else if (a[i][j] == '.')
cout << 'X';
else
cout << a[i][j];
}
cout << '\n';
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int i = 0; i < t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool vis[510][510] = {{false}};
char a[510][510] = {0};
int k, m, n;
void dfs(int i, int j);
int main() {
cin >> m >> n >> k;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (a[i][j] == '.') {
dfs(i, j);
break;
}
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cout << a[i][j];
}
cout << endl;
}
}
void dfs(int i, int j) {
if (i < 0 || j < 0 || i >= m || j >= n) return;
if (vis[i][j] == true || a[i][j] == '#') return;
vis[i][j] = true;
dfs(i + 1, j);
dfs(i - 1, j);
dfs(i, j + 1);
dfs(i, j - 1);
if (k > 0) {
a[i][j] = 'X';
k--;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline void read_string_to_vector(vector<string> &vec) {
string str;
getline(cin, str);
vec.push_back(str);
}
template <typename T>
inline void read_digit_to_vector(vector<T> &vec) {
T t;
cin >> t;
vec.push_back(t);
}
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
long long n, m, k;
char mMas[504][504];
bool used[504][504];
bool li[504][504];
long long moff[4] = {-1, 1};
void DFSVisit(long long i, long long j) {
used[i][j] = true;
bool mli = false;
for (register long long mi = 0; mi < 2; ++mi) {
if (mMas[i][j + moff[mi]] == '.' && !used[i][j + moff[mi]]) {
DFSVisit(i, j + moff[mi]);
mli = !li[i][j + moff[mi]];
}
if (mMas[i + moff[mi]][j] == '.' && !used[i + moff[mi]][j]) {
DFSVisit(i + moff[mi], j);
mli = !li[i + moff[mi]][j];
}
}
if (!mli && k) {
--k;
mMas[i][j] = 'X';
li[i][j] = true;
}
}
void mDFS() {
for (register long long i = 0; i < 504; ++i)
for (register long long j = 0; j < 504; ++j)
if (mMas[i][j] == '.' && !used[i][j]) DFSVisit(i, j);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (register long long i = 0; i < n; ++i) cin >> &(mMas[i + 1][1]);
mDFS();
for (register long long i = 0; i < n; ++i) cout << (mMas[i + 1] + 1) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int m, n, vis[maxn][maxn], level[maxn][maxn], edges;
vector<pair<int, int> > v;
char c[maxn][maxn];
int dr[] = {1, 0, -1, 0};
int dc[] = {0, 1, 0, -1};
void reset() {
memset(vis, 0, sizeof(vis));
memset(level, 0, sizeof(level));
}
bool isValid(int x, int y) {
return !vis[x][y] && x >= 0 && y >= 0 && x < n && y < m && c[x][y] == '.';
}
void bfs(int x, int y) {
queue<pair<int, int> > q;
q.push(make_pair(x, y));
vis[x][y] = 1;
v.push_back(make_pair(x, y));
while (!q.empty()) {
x = q.front().first;
y = q.front().second;
q.pop();
for (int i = 0; i < 4; i++) {
int cx = x + dr[i];
int cy = y + dc[i];
if (isValid(cx, cy)) {
vis[cx][cy] = 1;
level[cx][cy] = level[x][y] + 1;
v.push_back(make_pair(cx, cy));
q.push(make_pair(cx, cy));
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
reset();
int a, b, k;
cin >> n >> m >> k;
pair<int, int> start = make_pair(-1, -1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> c[i][j];
if (c[i][j] == '.' && start.first == -1) {
start = make_pair(i, j);
}
}
}
bfs(start.first, start.second);
for (int i = 0; i < v.size(); i++) {
c[v[i].first][v[i].second] = '.';
if (i >= v.size() - k) c[v[i].first][v[i].second] = 'X';
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << c[i][j];
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 5e2 + 5;
char a[N][N];
int n, m, k;
int s = 0;
bool vaild(int i, int j) { return i >= 0 && j >= 0 && i < n && j < m; }
int mx[4] = {0, 0, -1, 1};
int my[4] = {-1, 1, 0, 0};
void dfs(int i, int j) {
if (!s) return;
a[i][j] = '.';
s--;
for (int k = 0; k < 4; k++) {
int u = i + mx[k];
int v = j + my[k];
if (vaild(u, v) && a[u][v] == 'X') {
dfs(u, v);
}
}
}
void solve() {
cin >> n >> m >> k;
int cnt = 0;
int idx = -1;
int idx2 = -1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] == '.') {
a[i][j] = 'X';
cnt++;
if (idx == -1) {
idx = i;
idx2 = j;
}
}
}
s = cnt - k;
dfs(idx, idx2);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << a[i][j];
cout << endl;
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void c_p_c() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long k;
char board[501][501];
long long dirA[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
void dfs(long long r, long long c, long long n, long long m) {
board[r][c] = '?';
for (long long d = 0; d < 4; d++) {
long long x = r + dirA[d][0];
long long y = c + dirA[d][1];
if (x >= 1 && y >= 1 && x <= n && y <= m && board[x][y] == '.') {
dfs(x, y, n, m);
}
}
if (k > 0) {
board[r][c] = 'X';
k--;
}
}
int32_t main() {
c_p_c();
long long n, m;
cin >> n >> m >> k;
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> board[i][j];
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (board[i][j] == '.') dfs(i, j, n, m);
}
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
if (board[i][j] == '?') board[i][j] = '.';
cout << board[i][j];
}
cout << endl;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.