text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 404;
char s[N][N + N], ps[N];
bitset<N> G[26][N], ans[N];
int n, m;
bitset<N> shf(bitset<N> &x, int p) { return (x << (m - p)) | (x >> p); }
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
for (int i = 0; i < n; i++) ans[i] = ~ans[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) G[s[i][j] - 'a'][i].set(j);
int pn, pm;
scanf("%d%d", &pn, &pm);
for (int pi = 0; pi < pn; pi++) {
scanf("%s", ps);
for (int pj = 0; pj < pm; pj++)
if (ps[pj] != '?')
for (int i = 0; i < n; i++)
ans[i] &= shf(G[ps[pj] - 'a'][(i + pi) % n], pj % m);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", int(ans[i][j]));
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<405> ans[405], ok[26][405];
char maps1[405][405], maps2[405][405];
int main() {
int n, m, r, c;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%s", maps1[i]);
cin >> r >> c;
for (int i = 0; i < r; i++) scanf("%s", maps2[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
ans[i][j] = 1;
ok[maps1[i][j] - 'a'][i][j] = 1;
}
for (int y = 0; y < c; y++) {
for (int x = 0; x < r; x++) {
if (maps2[x][y] != '?') {
int now = maps2[x][y] - 'a';
for (int i = 0, xx = x % n; i < n; i++, xx++) {
if (xx >= n) xx -= n;
ans[i] &= ok[now][xx];
}
}
}
for (int i = 0; i < n; i++) {
for (int s = 0; s < 26; s++) {
ok[s][i][m] = ok[s][i][0];
ok[s][i] >>= 1;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ans[i][j])
printf("1");
else
printf("0");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 410;
std::bitset<MAXN> ans[MAXN], c[26][MAXN];
int n, m, R, C;
char S[MAXN][MAXN], T[MAXN];
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
std::cin >> n >> m;
for (int i = 0; i < n; ++i) std::cin >> S[i];
for (int i = 0; i < 26; ++i)
for (int j = 0; j < n; ++j)
for (int k = 0; k < m; ++k)
if (S[j][k] != 'a' + i) c[i][j].set(k);
std::cin >> R >> C;
for (int i = 0; i < R; ++i) {
std::cin >> T;
for (int j = 0; j < C; ++j)
if (T[j] != '?') {
int ch = T[j] - 'a';
for (int k = 0; k < n; ++k) {
int _k = (k - i + n) % n, _j = j % m;
ans[_k] |= c[ch][k] >> _j;
ans[_k] |= c[ch][k] << m - _j;
}
}
}
for (int i = 0; i < n; ++i, std::cout << '\n')
for (int j = 0; j < m; ++j) std::cout << (!ans[i][j]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
bitset<405> bt[26][405];
bitset<405> result[405];
bitset<405> one;
string s[405], p[405];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
one = ~one;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> s[i];
int r, c;
cin >> r >> c;
for (int i = 0; i < r; ++i) cin >> p[i];
for (int i = 0; i < n; ++i) result[i] = ~result[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
bt[s[i][j] - 'a'][i][j] = 1;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
char ch = p[i][j];
if (ch == '?') continue;
int idx = ch - 'a';
int shiftx = j % m;
int shifty = i % n;
for (int k = 0, z = shifty; k < n; ++k, z = (z + 1) % n) {
result[k] &= (bt[idx][z] >> shiftx) | ((bt[idx][z] << (m - shiftx)));
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << result[i][j];
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
int n, m, r, c;
char tab[(410)][(410)], pat[(410)][(410)];
std::bitset<(410)> res[(410)];
std::bitset<(410)> g[(26)][(410)];
std::bitset<(410)> shiftRight(const std::bitset<(410)> &b, int shift, int len) {
return (b >> shift) | (b << (len - shift));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", tab + i);
for (int j = 0; j < m; ++j) {
g[tab[i][j] - 'a'][i][j] = true;
}
res[i] = ~res[i];
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", pat + i);
for (int j = 0; j < c; ++j) {
if (pat[i][j] == '?') continue;
int ch = pat[i][j] - 'a';
for (int x = 0; x < n; ++x) {
res[(x - i + n) % n] &= shiftRight(g[ch][x], j % m, m);
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
putchar(res[i][j] ? '1' : '0');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
bitset<405> bt[26][405];
bitset<405> result[405];
bitset<405> one;
string s[405], p[405];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
one = ~one;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> s[i];
int r, c;
cin >> r >> c;
for (int i = 0; i < r; ++i) cin >> p[i];
for (int i = 0; i < n; ++i) result[i] = ~result[i];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
bt[s[i][j] - 'a'][i][j] = 1;
}
}
bitset<405> temp;
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
char ch = p[i][j];
if (ch == '?') continue;
int idx = ch - 'a';
int shiftx = j % m;
int shifty = i % n;
for (int k = 0, z = shifty; k < n; ++k, z = (z + 1) % n) {
temp = (bt[idx][z] >> shiftx) | ((bt[idx][z] << (m - shiftx)));
result[k] &= temp;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << result[i][j];
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int SZ = 400;
int main() {
int N, M;
scanf("%d %d", &N, &M);
vector<array<bitset<SZ>, 26>> positions(N);
vector<bitset<SZ>> ans(N);
for (auto &x : ans) x.set();
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) {
char c;
scanf(" %c", &c);
positions[i][c - 'a'].set(j);
}
int R, C;
scanf("%d %d", &R, &C);
for (int i = 0; i < R; i++)
for (int j = 0; j < C; j++) {
char c;
scanf(" %c", &c);
if (c == '?') continue;
for (int row = 0; row < N; row++) {
const auto &tmp = positions[row][c - 'a'];
ans[((row - i) % N + N) % N] &=
(tmp >> (j % M)) | (tmp << (M - (j % M)));
}
}
for (auto &x : ans) {
for (int j = 0; j < M; j++) printf("%c", x.test(j) ? '1' : '0');
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC target("sse4,avx")
constexpr double pi = 3.14159265358979323;
struct Solution {
int n, m;
std::vector<std::vector<std::complex<double>>> matrix1;
std::vector<std::vector<std::complex<double>>> matrix2;
void furier(std::vector<std::vector<std::complex<double>>>& matrix,
bool rev) {
std::vector<std::complex<double>> v1(n);
std::vector<std::complex<double>> v2(m);
for (int i = 0; i < n; i++) {
double angle = 2 * pi * i / n;
if (rev) angle = -angle;
v1[i].real(cos(angle));
v1[i].imag(sin(angle));
}
for (int i = 0; i < m; i++) {
double angle = 2 * pi * i / m;
if (rev) angle = -angle;
v2[i].real(cos(angle));
v2[i].imag(sin(angle));
}
std::vector<std::complex<double>> tmp(std::max(n, m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
tmp[j] = 0;
for (int k = 0; k < m; k++) {
tmp[j] += matrix[i][k] * v2[(j * k) % m];
}
}
for (int j = 0; j < m; j++) {
matrix[i][j] = tmp[j];
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
tmp[j] = 0;
for (int k = 0; k < n; k++) {
tmp[j] += matrix[k][i] * v1[(j * k) % n];
}
}
for (int j = 0; j < n; j++) {
matrix[j][i] = tmp[j];
}
}
}
bool isBig(std::complex<double> v) {
return std::abs(v.real()) > 1e-3 || std::abs(v.imag()) > 1e-3;
}
void run(std::istream& in, std::ostream& out) {
in >> n >> m;
matrix1.clear();
matrix1.resize(n);
for (int i = 0; i < n; i++) {
matrix1[i].resize(m);
}
for (int i = 0; i < n; i++) {
std::string s;
in >> s;
for (int j = 0; j < m; j++) {
double angle = 2 * pi * (s[j] - 'a') / 26.0;
matrix1[i][j].real(cos(angle));
matrix1[i][j].imag(sin(angle));
}
}
matrix2.clear();
matrix2.resize(n);
for (int i = 0; i < n; i++) {
matrix2[i].resize(m);
}
int r, c;
in >> r >> c;
int count = 0;
bool good = true;
for (int i = 0; i < r; i++) {
std::string s;
in >> s;
for (int j = 0; j < c; j++) {
if (s[j] != '?') {
int pix = (n - (i % n)) % n;
int pjx = (m - (j % m)) % m;
count++;
double angle = 2 * pi * -(s[j] - 'a') / 26.0;
std::complex<double> v(cos(angle), sin(angle));
if (isBig(matrix2[pix][pjx])) {
count--;
if (isBig(matrix2[pix][pjx] - v)) {
good = false;
continue;
}
}
matrix2[pix][pjx] = v;
}
}
}
furier(matrix1, false);
furier(matrix2, false);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
matrix1[i][j] *= matrix2[i][j];
}
}
furier(matrix1, true);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (matrix1[i][j].real() / (n * m) > count - 1e-3 && good) {
out << "1";
} else {
out << "0";
}
}
out << std::endl;
}
}
};
int main() {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
Solution().run(std::cin, std::cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char mat[405][405], pat[405][405];
int main() {
int n, m, r, c;
scanf("%d%d", &n, &m);
bitset<405> ans[n], G[30][n];
for (int i = 0; i < n; i++) scanf(" %s", mat[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf(" %s", pat[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
G[mat[i][j] - 'a'][i][m - 1 - j] = ans[i][j] = 1;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char x = pat[i][j];
if (x == '?') continue;
x -= 'a';
for (int k = 0; k < n; k++) {
int y = j % m;
ans[k] &= ((G[x][(k + i) % n] << y) | G[x][(k + i) % n] >> (m - y));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", (ans[i][m - j - 1] == 1 ? 1 : 0));
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, x, y;
std::bitset<810> ans[410];
std::bitset<810> g[810][26];
char s[410];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
ans[i].set();
for (int j = 0; j < m; j++) {
int d = s[j] - 'a';
for (int b = i; b <= 800; b += n)
for (int z = j; z <= 800; z += m) g[b][d].set(z);
}
}
scanf("%d%d", &x, &y);
for (int i = 0; i < x; i++) {
scanf("%s", s);
for (int j = 0; j < y; j++) {
if (s[j] == '?') continue;
int d = s[j] - 'a';
for (int k = 0; k < n; k++) ans[k] &= (g[(k + i) % n][d] >> j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", ans[i].test(j));
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 404;
int n, m, r, c, vis[N][N];
char a[N][N], b[N][N];
bitset<N> bs[26][N], ans[N];
int get(int x) { return (x % m + m - 1) % m + 1; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, iE = n; i <= iE; i++) scanf("%s", a[i] + 1);
for (int i = 1, iE = n; i <= iE; i++)
for (int j = 1, jE = m; j <= jE; j++) bs[a[i][j] - 'a'][i][j] = 1;
scanf("%d%d", &r, &c);
for (int i = 1, iE = r; i <= iE; i++) scanf("%s", b[i] + 1);
for (int i = 1, iE = n; i <= iE; i++)
for (int j = 1, jE = m; j <= jE; j++) ans[i][j] = 1;
for (int x = 1, xE = r; x <= xE; x++)
for (int y = 1, yE = c; y <= yE; y++)
if (b[x][y] != '?')
for (int i = 1, iE = n; i <= iE; i++)
ans[(i - x % n + n) % n + 1] &=
((bs[b[x][y] - 'a'][i] >> ((y - 1) % m)) |
(bs[b[x][y] - 'a'][i] << (m - (y - 1) % m)));
for (int i = 1, iE = n; i <= iE; i++)
for (int j = 1, jE = m; j <= jE; j++)
printf("%d%s", (int)ans[i][j], j == m ? "\n" : "");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
int n, m, r, c;
string s[N], t[N];
bitset<N> b[26][N];
bitset<N> good[N];
bitset<N> shift(bitset<N> bsa, int k) {
return (bsa >> (k % m)) | (bsa << (((m - k) % m + m) % m));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) b[s[i][j] - 'a'][i][j] = 1;
}
cin >> r >> c;
for (int i = 0; i < r; i++) cin >> t[i];
for (int i = 0; i < n; i++) good[i].set();
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (t[i][j] == '?') continue;
for (int k = 0; k < n; k++) {
good[k] &= shift(b[t[i][j] - 'a'][(k + i) % n], j);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << good[i][j];
cout << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, nn, mm, i, j, d, cc, dd, dda, ddb, da, db, dt;
unsigned long long ans[405][7], xx[26][405][7], one[65][65];
char x[405];
int main() {
memset(ans, -1, sizeof(ans));
for (int a = (0); a < (64); a++)
one[0][a + 1] = one[0][a] + (((unsigned long long)1) << a);
for (int a = (1); a < (65); a++)
for (int b = (0); b < (65); b++) one[a][b] = one[0][b] << a;
scanf("%d%d", &n, &m);
for (int a = (0); a < (n); a++) {
scanf("%s", x);
i = j = 0;
for (int b = (0); b < (m); b++) {
xx[x[b] - 'a'][a][i] |= (((unsigned long long)1) << j);
if (++j == 64) i++, j = 0;
}
}
scanf("%d%d", &nn, &mm);
for (int a = (0); a < (nn); a++) {
scanf("%s", x);
for (int b = (0); b < (mm); b++)
if (x[b] != '?') {
x[b] -= 'a';
cc = n - a % n;
if (cc == n) cc = 0;
for (int c = (0); c < (n); c++) {
d = da = db = 0;
dd = m - b % m;
if (dd == m) dd = 0;
dda = dd / 64;
ddb = dd % 64;
while (d != m) {
if (ddb > db)
dt = 64 - ddb;
else
dt = 64 - db;
if (dd + dt > m) dt = m - dd;
if (d + dt > m) dt = m - d;
if (ddb < db)
ans[cc][dda] &=
((xx[x[b]][c][da] >> (db - ddb)) | (~one[ddb][dt]));
else if (ddb > db)
ans[cc][dda] &=
((xx[x[b]][c][da] << (ddb - db)) | (~one[ddb][dt]));
else
ans[cc][dda] &= (xx[x[b]][c][da] | (~one[ddb][dt]));
dd += dt, d += dt;
if ((db += dt) == 64) da++, db = 0;
if ((ddb += dt) == 64) dda++, ddb = 0;
if (dd == m) dd = dda = ddb = 0;
}
if (++cc == n) cc = 0;
}
}
}
for (int a = (0); a < (n); a++) {
i = j = 0;
for (int b = (0); b < (m); b++) {
printf((ans[a][i] & (((unsigned long long)1) << j)) ? "1" : "0");
if (++j == 64) i++, j = 0;
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
bitset<405> ans[405];
bitset<405> pres[27][405];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) ans[i].set();
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
for (int j = 0; j <= m - 1; ++j) pres[s[j] - 'a' + 1][i].set(j);
}
cin >> r >> c;
for (int i = 1; i <= r; ++i) {
string s;
cin >> s;
for (int j = 0; j <= c - 1; ++j) {
if (s[j] == '?') continue;
for (int row = 1; row <= n; ++row) {
int cr = (row + i - 1) % n;
if (!cr) cr = n;
int ch = s[j] - 'a' + 1;
ans[row] &=
((pres[ch][cr] >> (j % m)) | (pres[ch][cr] << (m - (j % m))));
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= m - 1; ++j) {
if (ans[i].test(j))
cout << 1;
else
cout << 0;
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos((long double)-1);
namespace fft {
template <class T>
class comp {
public:
T real, img;
comp(T a = (T)0, T b = (T)0) : real(a), img(b) {}
comp conj() { return comp(this->real, -(this->img)); }
comp operator=(const comp& a) {
this->real = a.real, this->img = a.img;
return *this;
}
comp operator+(const comp& b) {
return comp(this->real + b.real, this->img + b.img);
}
comp operator-(const comp& b) {
return comp(this->real - b.real, this->img - b.img);
}
comp operator*(const T& num) {
return comp(this->real * num, this->img * num);
}
comp operator/(const T& num) {
return comp(this->real / num, this->img / num);
}
comp operator*(const comp& b) {
return comp(this->real * b.real - this->img * b.img,
this->img * b.real + this->real * b.img);
}
comp operator/(const comp& b) {
comp temp(b.real, -b.img);
comp n = (*this) * temp;
return n / (b.x * b.x + b.y * b.y);
}
};
vector<comp<long double> > w;
vector<int> rev;
void revbits(int newlim) {
static int lim = -1;
int t, j;
if (newlim == lim) return;
lim = newlim;
rev.resize(lim + 1);
int k = 0;
while ((1 << k) < newlim) ++k;
assert((1 << k) == newlim);
for (int i = 1; i <= (int)(lim); ++i) {
j = rev[i - 1];
t = k - 1;
while (t >= 0 && ((j >> t) & 1)) j ^= (1 << t), --t;
if (t >= 0) j ^= (1 << t), --t;
rev[i] = j;
}
}
void fft(vector<comp<long double> >& poly, int inv = false) {
int len, l;
revbits((int)(poly).size());
for (int i = 0; i < (int)((int)(poly).size()); ++i)
if (rev[i] > i) swap(poly[i], poly[rev[i]]);
comp<long double> u, v;
if ((int)(w).size() < (int)(poly).size()) w.resize((int)(poly).size());
for (len = 2, l = 1; len <= (int)(poly).size(); len += len, l += l) {
if (w[l].real == 0 && w[l].img == 0) {
long double ang = PI / l;
comp<long double> ww(cos(ang), sin(ang));
if (l > 1) {
for (int j = 0; j < l; ++j) {
if (j & 1)
w[l + j] = w[(l + j) >> 1] * ww;
else
w[l + j] = w[(l + j) >> 1];
}
} else
w[l] = comp<long double>(1.0, 0.0);
}
for (int i = 0; i < (int)(poly).size(); i += len)
for (int j = 0; j < (int)(l); ++j) {
u = poly[i + j],
v = poly[i + j + l] * (inv ? w[l + j].conj() : w[l + j]);
poly[i + j] = u + v, poly[i + j + l] = u - v;
}
}
if (inv)
for (auto& x : poly) x = x / (long double)(int)(poly).size();
}
void fft2d(vector<vector<comp<long double> > >& A, bool inv = false) {
for (auto& row : A) {
fft(row, inv);
}
vector<comp<long double> > col((int)(A).size());
for (int j = 0; j < (int)((int)(A.front()).size()); ++j) {
for (int i = 0; i < (int)((int)(A).size()); ++i) col[i] = A[i][j];
fft(col, inv);
for (int i = 0; i < (int)((int)(A).size()); ++i) A[i][j] = col[i];
}
}
vector<vector<comp<long double> > > multiply(
vector<vector<comp<long double> > >& x,
vector<vector<comp<long double> > >& y) {
int b_rows = 0, b_cols = 0;
while ((1 << b_rows) <= max((int)(x).size(), (int)(y).size())) ++b_rows;
++b_rows;
while ((1 << b_cols) <= max((int)(x.front()).size(), (int)(y.front()).size()))
++b_cols;
++b_cols;
x.resize(1 << b_rows);
y.resize(1 << b_rows);
for (auto& row : x) row.resize(1 << b_cols, 0);
for (auto& row : y) row.resize(1 << b_cols, 0);
fft2d(x), fft2d(y);
for (int i = 0; i < (int)((int)(x).size()); ++i)
for (int j = 0; j < (int)((int)(x[i]).size()); ++j)
x[i][j] = x[i][j] * y[i][j];
fft2d(x, 1);
return x;
}
const int L = 805;
string A[L], B[L];
int N, M, R, C, X, Y;
void read() {
cin >> N >> M;
for (int i = 0; i < (int)(N); ++i) cin >> A[i];
cin >> R >> C;
for (int i = 0; i < (int)(R); ++i) cin >> B[i];
}
void solve() {
X = N + R, Y = M + C;
vector<vector<comp<long double> > > a(X, vector<comp<long double> >(Y));
for (int i = 0; i < (int)(N); ++i)
for (int j = 0; j < (int)(M); ++j) {
a[i][j].real = cos(2 * PI * (A[i][j] - 'a') / 26.0),
a[i][j].img = sin(2 * PI * (A[i][j] - 'a') / 26.0);
for (int ii = i; ii < X; ii += N)
for (int jj = j; jj < Y; jj += M) a[ii][jj] = a[i][j];
}
vector<vector<comp<long double> > > b(R, vector<comp<long double> >(C));
int valid = 0;
for (int i = 0; i < (int)(R); ++i)
for (int j = 0; j < (int)(C); ++j) {
if (B[i][j] == '?') continue;
++valid;
b[R - i - 1][C - j - 1].real = cos(2 * PI * (B[i][j] - 'a') / 26.0),
b[R - i - 1][C - j - 1].img =
-sin(2 * PI * (B[i][j] - 'a') / 26.0);
}
vector<vector<comp<long double> > > c = multiply(a, b);
for (int i = 0; i < (int)(N); ++i) {
for (int j = 0; j < (int)(M); ++j)
cout << ((int)(c[R - 1 + i][C - 1 + j].real + 1e-5) == valid);
cout << "\n";
}
}
} // namespace fft
int main() {
std::ios::sync_with_stdio(false);
fft::read();
fft::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
bitset<2 * ((int)402)> a[26][((int)402)], ans[((int)402)];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
cin >> c;
a[c - 'a'][i][j] = a[c - 'a'][i][j + m] = 1;
ans[i][j] = 1;
}
cin >> r >> c;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
char c;
cin >> c;
if (c == '?') continue;
for (int p = 0; p < n; p++)
ans[p] &= (a[c - 'a'][(p + i) % n] >> (j % m));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << ans[i][j];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<2 * 411> arr[30][411], ans[411];
char str[411];
int main() {
int n, m, r, c;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", str);
for (int j = 0; j < m; j++) {
arr[str[j] - 'a'][i][j] = 1;
arr[str[j] - 'a'][i][j + m] = 1;
ans[i][j] = 1;
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) {
scanf("%s", str);
for (int j = 0; j < c; j++) {
if (str[j] == '?') continue;
for (int k = 0; k < n; k++)
ans[k] &= arr[str[j] - 'a'][(k + i) % n] >> (j % m);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", (int)ans[i][j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class cd {
double a, b;
public:
cd() { a = b = 0; }
cd(long long _a) { a = _a, b = 0; }
cd(double _a, double _b) { a = _a, b = _b; }
double real() { return a; }
double imag() { return b; }
void operator+=(cd& X) { a += X.a, b += X.b; }
void operator*=(cd& X) {
double _a = a, _b = b;
a = _a * X.a - _b * X.b, b = _b * X.a + _a * X.b;
}
void operator/=(long long n) { a /= (double)n, b /= (double)n; }
cd operator*(cd& X) { return cd(a * X.a - b * X.b, b * X.a + a * X.b); }
cd operator+(cd& X) { return cd(a + X.a, b + X.b); }
cd operator-(cd& X) { return cd(a - X.a, b - X.b); }
};
const double PI = acos(-1.0);
long long rev[3210], cur_len = 0;
cd W[3210];
void reverse(long long n) {
for (long long i = 0; i < n; ++i) {
rev[i] = rev[i >> 1] >> 1;
if (i & 1) rev[i] ^= (n >> 1);
}
}
void fft(vector<cd>& A, bool inv = 0) {
long long n = A.size();
if (cur_len != n) reverse(n), cur_len = n;
for (long long i = 0; i < n; ++i) {
if (i < rev[i]) swap(A[i], A[rev[i]]);
}
for (long long s = 1; s < n; s <<= 1) {
double x = (inv ? -1 : 1) * PI / s;
cd w(cos(x), sin(x));
W[0] = cd(1, 0);
for (long long i = 1; i < s; ++i) W[i] = W[i - 1] * w;
for (long long i = 0; i < n; i += 2 * s) {
for (long long j = 0; j < s; ++j) {
cd u = A[i + j], v = A[i + j + s] * W[j];
A[i + j] = u + v, A[i + j + s] = u - v;
}
}
}
if (inv)
for (long long i = 0; i < n; ++i) A[i] /= n;
}
string s[810], t[810];
void fft2(vector<vector<cd>>& A, long long inv = 0) {
for (auto& v : A) fft(v, inv);
for (long long j = 0; j < (long long)(A[0]).size(); ++j) {
vector<cd> tmp;
for (long long i = 0; i < (long long)(A).size(); ++i)
tmp.push_back(A[i][j]);
fft(tmp, inv);
for (long long i = 0; i < (long long)(A).size(); ++i) A[i][j] = tmp[i];
}
}
void mul(vector<vector<cd>>& A, vector<vector<cd>>& B) {
long long n = 1, m = 1;
while (n < max((long long)(A).size(), (long long)(B).size())) n <<= 1;
n <<= 1;
while (m < max((long long)(A[0]).size(), (long long)(B[0]).size())) m <<= 1;
m <<= 1;
A.resize(n), B.resize(n);
for (auto& v : A) v.resize(m);
for (auto& v : B) v.resize(m);
fft2(A), fft2(B);
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) A[i][j] = A[i][j] * B[i][j];
fft2(A, 1);
}
cd get(char c, long long y = 1) {
double x = 2 * PI * (c - 'a') * y / 26.00;
return cd(cos(x), sin(x));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; ++i) cin >> s[i];
long long r, c;
cin >> r >> c;
for (long long i = 0; i < r; ++i) cin >> t[i];
for (long long i = 0; i < n; ++i)
for (long long j = m; j < m + c; ++j) s[i] += s[i][j % m];
for (long long i = n; i < n + r; ++i) s[i] = s[i % n];
vector<vector<cd>> a(n + r, vector<cd>(m + c, 0));
for (long long i = 0; i < n + r; ++i)
for (long long j = 0; j < m + c; ++j) a[i][j] = get(s[i][j]);
vector<vector<cd>> b(r, vector<cd>(c, 0));
long long cnt = 0;
for (long long i = 0; i < r; ++i)
for (long long j = 0; j < c; ++j) {
if (t[i][j] == '?')
++cnt;
else
b[r - i - 1][c - j - 1] = get(t[i][j], -1);
}
mul(a, b);
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j)
cout << ((abs((long double)a[i + r - 1][j + c - 1].real() -
(long double)(r * c - cnt))) < (long double)(1e-4));
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace XDYIMCMI0LY {
const int N = 400 + 5;
int n;
int m;
int r;
int c;
char s[N][N];
char t[N][N];
bitset<N> b[26][N];
bitset<N> ans[N];
bitset<N> shift(bitset<N> x, int k) { return (x >> k) | (x << (m - k)); }
void solve() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int c = (int)s[i][j] - 'a';
b[c][i][j] = 1;
}
}
cin >> r >> c;
for (int i = 0; i < r; ++i) {
cin >> t[i];
}
for (int i = 0; i < n; ++i) {
ans[i] = ~ans[i];
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (t[i][j] == '?') {
continue;
}
int p = t[i][j] - 'a';
for (int k = 0; k < n; ++k) {
int x = (k + i) % n;
ans[k] &= shift(b[p][x], j % m);
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ans[i][j];
}
cout << endl;
}
}
} // namespace XDYIMCMI0LY
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
XDYIMCMI0LY::solve();
flush(cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
char str[500];
bitset<500> ans[500], mp[500][26];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", str);
for (int j = 0; j < m; ++j) {
mp[i][str[j] - 'a'][j] = ans[i][j] = true;
}
}
for (int i = 0; i < 499; ++i) str[i] = 0;
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", str);
for (int j = 0; j < c; ++j) {
if (str[j] == '?') continue;
for (int k = 0; k < n; ++k)
ans[(k - i % n + n) % n] &=
mp[k][str[j] - 'a'] >> j % m | mp[k][str[j] - 'a'] << m - j % m;
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) printf("%d", (int)ans[i][j]);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void runtime() {
cout << fixed << setprecision(5) << 1.0 * clock() / CLOCKS_PER_SEC << endl;
}
template <class T>
void read(vector<T> &a, int n) {
T x;
a.clear();
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
}
template <class T>
void write(vector<T> &a) {
for (T x : a) cout << x << ' ';
cout << '\n';
}
const int N = 404;
const double PI = acos(-1.0);
struct cd {
double real, imag;
cd(double _real = 0.0, double _imag = 0.0) : real(_real), imag(_imag) {}
};
cd operator+(const cd &a, const cd &b) {
return cd(a.real + b.real, a.imag + b.imag);
}
cd operator-(const cd &a, const cd &b) {
return cd(a.real - b.real, a.imag - b.imag);
}
cd operator*(const cd &a, const cd &b) {
return cd(a.real * b.real - a.imag * b.imag,
a.real * b.imag + a.imag * b.real);
}
cd operator/(const cd &a, const int &b) { return cd(a.real / b, a.imag / b); }
vector<cd> prec_w;
int lg;
void precomp(int need_lg) {
int need_sz = (1 << need_lg) + 1;
if (prec_w.size() >= need_sz) return;
prec_w.clear();
cd w(1, 0);
double ang = 2 * PI / (1 << need_lg);
cd wlen(cos(ang), sin(ang));
lg = need_lg;
while (prec_w.size() != need_sz) {
prec_w.push_back(w);
w = w * wlen;
}
}
void fft(vector<cd> &a, bool invert = 0) {
int n = (int)a.size();
for (int i = 1, j = 0; i < n; i++) {
int bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (int cur_lg = 1; (1 << cur_lg) <= n; cur_lg++)
for (int i = 0; i < n; i += (1 << cur_lg))
for (int j = 0; j < (1 << (cur_lg - 1)); j++) {
int pos = (1 << (lg - cur_lg)) * j;
if (invert) pos = ((1 << lg) - (1 << (lg - cur_lg)) * j);
cd u = a[i + j];
cd v = a[i + j + (1 << (cur_lg - 1))] * prec_w[pos];
a[i + j] = u + v;
a[i + j + (1 << (cur_lg - 1))] = u - v;
}
if (invert)
for (int i = 0; i < n; i++) a[i] = a[i] / n;
}
vector<cd> mult(vector<cd> &a, vector<cd> &b) {
vector<cd> res;
vector<cd> fa(a.begin(), a.end());
vector<cd> fb(b.begin(), b.end());
int n = 1;
while (n < (int)a.size() + (int)b.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
res.resize(n);
fft(fa);
fft(fb);
for (int i = 0; i < n; i++) fa[i] = fa[i] * fb[i];
fft(fa, 1);
for (int i = 0; i < fa.size(); i++) res[i] = (int)(fa[i].real + 1e-4);
return res;
}
vector<cd> get_scalar(vector<cd> &a, vector<cd> &b) {
reverse(b.begin(), b.end());
vector<cd> res = mult(a, b);
vector<cd> ans(res.begin() + (int)b.size() - 1, res.begin() + a.size());
return ans;
}
vector<cd> get(string second, string t) {
vector<cd> a, b;
for (int i = 0; i < second.size(); i++) {
double alp = PI * (second[i] - 'a') / 26;
a.push_back(cd(cos(alp), sin(alp)));
}
for (int i = 0; i < t.size(); i++) {
if (t[i] >= 'a' && t[i] <= 'z') {
double alp = PI * (t[i] - 'a') / 26;
b.push_back(cd(cos(alp), -sin(alp)));
} else
b.push_back(cd(0, 0));
}
return get_scalar(a, b);
}
int n, m, r, c;
string a[N], b[N];
string second, t;
vector<string> v;
int cnt;
int main() {
ios_base::sync_with_stdio(0);
precomp(20);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
cin >> r >> c;
for (int i = 0; i < r; i++) {
cin >> b[i];
for (int j = 0; j < b[i].size(); j++)
if (b[i][j] == '?') cnt++;
}
for (int i = 0; i < v.size(); i++) {
string ss = v[i];
while (v[i].size() < m + c) v[i] += ss;
}
int pos = 0;
while (v.size() < n + r) {
v.push_back(v[pos % n]);
pos++;
}
int w = (int)v[0].size();
for (string x : v) second += x;
for (int i = 0; i < r; i++) {
t += b[i];
for (int j = (int)b[i].size(); j < w; j++) t += "#";
}
vector<cd> kilk = get(second, t);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (kilk[i * w + j].real + cnt == r * c)
cout << 1;
else
cout << 0;
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 900;
int n, m, r, c;
bitset<N> vis[26][N], ans[N];
char s[N][N], p[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]), ans[i].set();
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < n + 400; ++j) {
for (int k = 0; k < m + 400; ++k) {
vis[i][j][k] = s[j % n][k % m] == i + 'a';
}
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) scanf("%s", p[i]);
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j)
if (p[i][j] != '?') {
bitset<N>* b = vis[p[i][j] - 'a'];
for (int x = 0; x < n; ++x) {
ans[x] &= b[x + i] >> j;
}
}
}
for (int i = 0; i < n; ++i, putchar('\n'))
for (int j = 0; j < m; ++j) printf("%d", (bool)ans[i][j]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const double pi = acos(-1);
const double EPS = 1e-5;
void iter(vector<cd> &a, bool invert) {
int n = a.size();
for (int i = 1, j = 0; i < n; i++) {
int bit = n >> 1;
for (; j & bit; bit >>= 1) j ^= bit;
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
double ang = 2 * pi / len * (invert ? -1 : 1);
cd wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
cd w(1);
for (int j = 0; j < len / 2; j++) {
cd u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (cd &x : a) x /= n;
}
void iter2d(vector<vector<cd>> &a, bool invert) {
for (auto &it : a) iter(it, invert);
for (int j = 0; j < a[0].size(); j++) {
vector<cd> col(a.size());
for (int i = 0; i < a.size(); i++) col[i] = a[i][j];
iter(col, invert);
for (int i = 0; i < a.size(); i++) a[i][j] = col[i];
}
}
vector<vector<int>> mult(vector<vector<cd>> &a, vector<vector<cd>> &b) {
int nr = 1;
while (nr < a.size() + b.size()) nr <<= 1;
a.resize(nr);
b.resize(nr);
int nc = 1;
while (nc < a[0].size() + b[0].size()) nc <<= 1;
for (auto &it : a) it.resize(nc, 0);
for (auto &it : b) it.resize(nc, 0);
iter2d(a, 0);
iter2d(b, 0);
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++) a[i][j] *= b[i][j];
iter2d(a, 1);
vector<vector<int>> ret(nr, vector<int>(nc));
for (int i = 0; i < nr; i++)
for (int j = 0; j < nc; j++) ret[i][j] = (int)(a[i][j].real() + EPS);
return ret;
}
const int N = 401;
int n, m, r, c;
string str[N];
string pat[N];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> str[i];
cin >> r >> c;
for (int i = 0; i < r; i++) cin >> pat[i];
vector<vector<cd>> a(n + r, vector<cd>(m + c)), b(r, vector<cd>(c, 0));
for (int i = 0; i < n + r; i++)
for (int j = 0; j < m + c; j++) {
int cur = str[i % n][j % m] - 'a';
double ang = 2 * pi * cur / 26;
a[i][j] = cd(cos(ang), sin(ang));
}
int cnt = 0;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
if (pat[i][j] == '?') continue;
cnt++;
int cur = pat[i][j] - 'a';
double ang = 2 * pi * cur / 26;
b[r - 1 - i][c - 1 - j] = cd(cos(ang), -sin(ang));
}
vector<vector<int>> ret;
ret = mult(a, b);
for (int i = r - 1; i < n + r - 1; i++) {
for (int j = c - 1; j < m + c - 1; j++) cout << (ret[i][j] == cnt);
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 401;
bitset<N> rc[N][N][26];
string s[N];
string q[N];
int n, m;
int r, c;
void init() {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c = s[i][j];
for (int s = 0; s < m; s++) rc[i][s][c - 'a'].set((j - s + m) % m);
}
}
bitset<N> solve(int st) {
bitset<N> res;
res.set();
for (int i = 0; i < r; i++) {
int row = (st + i) % n;
for (int j = 0; j < c; j++)
if (q[i][j] != '?') res &= rc[row][j % m][q[i][j] - 'a'];
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(nullptr);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
cin >> r >> c;
for (int i = 0; i < r; i++) cin >> q[i];
init();
for (int i = 0; i < n; i++) {
auto b = solve(i);
for (int j = 0; j < m; j++)
if (b[j])
cout << '1';
else
cout << '0';
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... second>
void dbs(string str, T t, second... s) {
int idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class second, class T>
ostream& operator<<(ostream& os, const pair<second, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
const double PI = 3.141592653589793238462643383279L;
void fft_main(int n, double theta, complex<double> a[]) {
for (int m = n; m >= 2; m >>= 1) {
int mh = m >> 1;
complex<double> thetaI = complex<double>(0, theta);
for (int i = 0; i < mh; ++i) {
complex<double> w = exp((double)i * thetaI);
for (int j = i; j < n; j += m) {
int k = j + mh;
complex<double> x = a[j] - a[k];
a[j] += a[k];
a[k] = w * x;
}
}
theta *= 2;
}
int i = 0;
for (int j = 1; j < n - 1; ++j) {
for (int k = n >> 1; k > (i ^= k); k >>= 1)
;
if (j < i) swap(a[i], a[j]);
}
}
void fft(int n, complex<double> a[], bool rev) {
if (rev) {
fft_main(n, -2 * PI / n, a);
for (int i = 0; i < n; ++i) a[i] /= n;
} else
fft_main(n, 2 * PI / n, a);
}
void fft2(vector<vector<complex<double>>>& a, bool rev) {
int n = a.size();
int m = a[0].size();
for (int i = 0; i < n; ++i) {
fft(m, &a[i][0], rev);
}
for (int i = 0; i < m; ++i) {
vector<complex<double>> t;
for (int j = 0; j < n; ++j) t.push_back(a[j][i]);
fft(n, &t[0], rev);
for (int j = 0; j < n; ++j) a[j][i] = t[j];
}
}
void convolution(vector<vector<complex<double>>>& v,
vector<vector<complex<double>>>& w) {
int n = 1, vwn = v.size() + w.size() - 1;
while (n < vwn) n <<= 1;
v.resize(n), w.resize(n);
int m = 1, vwm = v[0].size() + w[0].size() - 1;
while (m < vwm) m <<= 1;
for (auto& it : v) it.resize(m);
for (auto& it : w) it.resize(m);
fft2(v, 0);
fft2(w, 0);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) v[i][j] *= w[i][j];
fft2(v, 1);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> a(n);
for (auto& it : a) cin >> it;
int r, c;
cin >> r >> c;
int no = r * c;
vector<string> b(r);
for (auto& it : b) cin >> it, no -= count(it.begin(), it.end(), '?');
a.resize(n + r);
for (auto& it : a) it.resize(m + c);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
for (int I = i; I < n + r; I += n) {
for (int J = j; J < m + c; J += m) {
a[I][J] = a[i][j];
}
}
}
}
vector<vector<complex<double>>> A(n + r, vector<complex<double>>(m + c));
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
double angle = 2 * PI * (a[i][j] - 'a') / 26;
A[i][j] = complex<double>(cos(angle), sin(angle));
}
}
vector<vector<complex<double>>> B(r, vector<complex<double>>(c));
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (b[i][j] == '?') continue;
double angle = -2 * PI * (b[i][j] - 'a') / 26;
B[r - i - 1][c - j - 1] = complex<double>(cos(angle), sin(angle));
}
}
convolution(A, B);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int h = A[i + r - 1][j + c - 1].real() + 1e-5;
cout << (h == no);
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
char a[405][405], b[405][405];
bitset<405> ans[405], G[26][405], aux[405];
inline void Shift() {
for (int i = 0; i < 26; ++i)
for (int j = 0; j < n; ++j) {
int b = G[i][j][0];
G[i][j] >>= 1;
G[i][j][m - 1] = b;
}
}
int main() {
int i, j, x, y;
cin >> n >> m;
for (i = 0; i < n; ++i) cin >> a[i];
cin >> r >> c;
for (i = 0; i < r; ++i) cin >> b[i];
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
G[a[i][j] - 'a'][i][j] = 1;
ans[i][j] = 1;
}
for (y = 0; y < c; ++y) {
for (x = 0; x < r; ++x) {
if (b[x][y] == '?') continue;
int val = b[x][y] - 'a';
for (i = 0; i < n; ++i) ans[i] = (ans[i] & G[val][(i + x) % n]);
}
Shift();
}
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) cout << ans[i][j];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, m, u, v, q, r, ql, qr, k, l, w, x, y, d, p, c, b, a, s;
const int N = 405;
const int T = 101;
const long long mod = 1e9 + 7;
const long long INF = 1LL << 52LL;
string str[N];
string pat[N];
bitset<N> res[N];
bitset<N> g[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> str[i];
for (int j = 0; j < str[i].size(); ++j) {
g[str[i][j] - 'a'][i].set(j);
res[i].set(j);
}
}
cin >> r >> c;
for (int i = 0; i < r; ++i) {
cin >> pat[i];
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (pat[i][j] == '?') continue;
for (int k = 0; k < n; ++k) {
res[((k - i) % n + n) % n] &= (g[pat[i][j] - 'a'][k] >> (j % m)) |
(g[pat[i][j] - 'a'][k] << (m - (j % m)));
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cout << res[i].test(j);
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30, maxn = 400 + 10;
int N, M, r, c;
char A[maxn][maxn], B[maxn][maxn];
bitset<maxn> s[26][maxn], ans[maxn];
bitset<maxn> work(const bitset<maxn> &b, int len, int kk) {
return (b >> kk) | (b << (len - kk));
}
void Init() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; ++i) {
scanf("%s", A[i]);
for (int j = 0; j < M; ++j) s[A[i][j] - 'a'][i][j] = true;
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) scanf("%s", B[i]);
}
void Solve() {
for (int i = 0; i < N; ++i) ans[i] = ~ans[i];
for (int i = 0; i < r; ++i)
for (int j = 0; j < c; ++j) {
if (B[i][j] == '?') continue;
int C = B[i][j] - 'a', y = j % M;
for (int k = 0; k < N; ++k) ans[k] &= work(s[C][(k + i) % N], M, y);
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) putchar(ans[i][j] + '0');
puts("");
}
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 100, mod = 1e9 + 7;
int n, m, r, c;
char a[500][500], p[500][500];
bitset<500> bi[28][500], ans[500];
int flag[29];
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < n; i++) scanf("%s", a[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", p[i]);
memset(flag, 0, sizeof(flag));
for (int i = 0; i < 27; i++)
for (int j = 0; j < n; j++) bi[i][j].reset();
int cc = 0;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (p[i][j] == '?')
continue;
else if (flag[p[i][j] - 'a'] == 0) {
flag[p[i][j] - 'a'] = 1;
for (int s = 0; s < n; s++)
for (int g = 0; g < m; g++)
if (a[s][g] == p[i][j]) bi[p[i][j] - 'a'][s][g] = 1;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j] = 1;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
if (p[i][j] == '?') continue;
int gg = p[i][j] - 'a';
for (int s = 0; s < n; s++) {
ans[((s - i) % n + n) % n] =
ans[((s - i) % n + n) % n] &
((bi[gg][s] >> j % m) | (bi[gg][s] << (m - j % m)));
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(ans[i][j] ? '1' : '0');
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
char a[810][810], b[810][810];
bitset<650000> s[30], st;
int main() {
st.set();
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%s", a[i]);
}
cin >> r >> c;
for (int i = 0; i < n + r; i++) {
for (int j = 0; j < m + c; j++) {
a[i][j] = a[i % n][j % m];
s[a[i][j] - 'a'][i * (m + c) + j] = 1;
}
}
for (int i = 0; i < r; i++) {
scanf("%s", b[i]);
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (b[i][j] != '?') {
st &= (s[(b[i][j] - 'a')] >> (i * (m + c) + j));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << st[i * (m + c) + j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<423> ans[423], p[423][26];
char q;
int main() {
int n, m;
cin >> n >> m;
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
scanf(" %c", &q), p[i][q - 'a'][j] = ans[i][j] = 1;
int r, c;
cin >> r >> c;
for (int(i) = 0; (i) < (r); ++(i))
for (int(j) = 0; (j) < (c); ++(j))
if (scanf(" %c", &q), q != '?')
for (int(k) = 0; (k) < (n); ++(k))
ans[(k + n - i % n) % n] &= p[k][q - 'a'] >> j % m | p[k][q - 'a']
<< m - j % m;
for (int(i) = 0; (i) < (n); ++(i))
for (int(j) = 0; (j) < (m); ++(j))
printf("%d%s", (int)ans[i][j], j == m - 1 ? "\n" : "");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
char **a;
char s[N][N];
int n, m, r, c;
bitset<N> R[N];
bitset<N> b[26][N];
bitset<N> shift(bitset<N> b, int x) { return (b << m - x) | (b >> x); }
int main() {
cin >> n >> m;
a = new char *[N];
for (int i = 0; i < N; i++) a[i] = new char[N];
for (int i = 0; i < N; i++) R[i] = ~R[i];
for (int i = 0; i < n; i++) {
scanf("%s", &a[i][0]);
for (int j = 0; j < m; j++) b[a[i][j] - 'a'][i][j] = 1;
}
cin >> r >> c;
for (int i = 0; i < r; i++) scanf("%s", &s[i][0]);
for (int x = 0; x < r; x++) {
for (int y = 0; y < c; y++) {
if (s[x][y] == '?') continue;
int k = s[x][y] - 'a';
for (int i = 0; i < n; i++) R[i] &= shift(b[k][(i + x) % n], y % m);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(R[i][j] ? '1' : '0');
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 998244353;
const int N = 50005;
const double PI = acos(-1.0);
const double eps = 1e-4;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
struct cp {
double x, y;
};
inline cp operator+(cp &a, cp &b) { return cp{a.x + b.x, a.y + b.y}; }
inline cp operator-(cp &a, cp &b) { return cp{a.x - b.x, a.y - b.y}; }
inline cp operator*(cp &a, cp &b) {
return cp{a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x};
}
inline cp get(double x) { return cp{cos(x), sin(x)}; }
inline ostream &operator<<(ostream &out, const cp &t) {
out << "(" << t.x << "," << t.y << ")";
return out;
}
const int _M = 2048, _N = N;
template <class V>
struct FT {
cp tmp[_M * 2 + 5], aa[_M][_M], bb[_M][_M];
void FFT(cp *a, int n, int op) {
for (int i = (n >> 1), j = 1; j < n; j++) {
if (i < j) swap(a[i], a[j]);
int k;
for (k = (n >> 1); k & i; i ^= k, k >>= 1)
;
i ^= k;
}
for (int m = 2; m <= n; m <<= 1) {
cp w = get(2 * PI * op / m);
tmp[0] = cp{1, 0};
for (int j = 1; j < (m >> 1); j++) tmp[j] = tmp[j - 1] * w;
for (int i = 0; i < n; i += m)
for (int j = i; j < i + (m >> 1); j++) {
cp u = a[j], v = a[j + (m >> 1)] * tmp[j - i];
a[j] = u + v, a[j + (m >> 1)] = u - v;
}
}
if (op == -1)
for (int i = (0); i <= (n - 1); ++i) a[i] = cp{a[i].x / n, a[i].y / n};
}
void FFT(cp a[][_M], int n, int op) {
for (int i = (0); i <= (n - 1); ++i) FFT(a[i], n, op);
}
template <class T>
void Transpose(T a[][_M], int n) {
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (i - 1); ++j) swap(a[i][j], a[j][i]);
}
void Reverse(V a[][_M], int n, int m) {
for (int i = (0); i <= (n - 1 >> 1); ++i)
for (int j = (0); j <= (m - 1); ++j) swap(a[i][j], a[n - 1 - i][j]);
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1 >> 1); ++j) swap(a[i][j], a[i][m - 1 - j]);
}
void Shift(int a[][_M], int n, int m, int p, int q) {
for (int i = (n); i <= (n + p - 1); ++i)
for (int j = (m); j <= (m + q - 1); ++j) a[i - n][j - m] = a[i][j];
}
void In(cp p[][_M], int len, V a[][_M], int n, int m) {
for (int i = (0); i <= (len - 1); ++i)
for (int j = (0); j <= (len - 1); ++j)
p[i][j] = i < n && j < m ? a[i][j] : cp{0, 0};
}
void Out(int a[][_M], int n, int m, cp p[][_M], int len) {
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j) a[i][j] = (int)(p[i][j].x + eps);
}
void Multiply(V A[][_M], int n, V B[][_M], int m, int C[][_M], int &len,
int op = 0) {
if (op) Reverse(A, n, n);
len = 1;
while (len < n + m - 1) len <<= 1;
In(aa, len, A, n, n), In(bb, len, B, m, m), FFT(aa, len, 1),
FFT(bb, len, 1);
Transpose(aa, len), Transpose(bb, len), FFT(aa, len, 1), FFT(bb, len, 1);
for (int i = (0); i <= (len - 1); ++i)
for (int j = (0); j <= (len - 1); ++j) aa[i][j] = aa[i][j] * bb[i][j];
FFT(aa, len, -1), Transpose(aa, len), FFT(aa, len, -1),
Out(C, len, len, aa, len);
if (op) Shift(C, n - 1, n - 1, m, m), len = m, Reverse(A, n, n);
}
};
void Build(cp A[][_M], int n, int m, char s[][405], int M, int op,
int cc = 'a') {
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j)
A[i][j] =
(s[i][j] == '?') ? cp{0, 0} : get(2 * PI / M * (s[i][j] - cc) * op);
}
int n1, n2, m1, m2, nn, mm, len, tot = 0;
char s[405][405], t[405][405];
FT<cp> T;
cp A[_M][_M], B[_M][_M];
int C[_M][_M];
int main() {
scanf("%d%d", &n1, &m1);
for (int i = (0); i <= (n1 - 1); ++i) scanf("%s", s[i]);
scanf("%d%d", &n2, &m2), nn = n1 + n2, mm = m1 + m2;
for (int i = (0); i <= (n2 - 1); ++i) scanf("%s", t[i]);
for (int i = (0); i <= (n2 - 1); ++i)
for (int j = (0); j <= (m2 - 1); ++j) tot += (t[i][j] != '?');
Build(A, n1, m1, s, 26, 1), Build(B, n2, m2, t, 26, -1);
for (int i = (0); i <= (nn - 1); ++i)
for (int j = (0); j <= (mm - 1); ++j) {
if (i < n1 && j < m1) continue;
A[i][j] = A[i % n1][j % m1];
}
T.Multiply(B, ((n2) > (m2) ? (n2) : (m2)), A, ((nn) > (mm) ? (nn) : (mm)), C,
len, 1);
for (int i = (0); i <= (n1 - 1); ++i) {
for (int j = (0); j <= (m1 - 1); ++j) printf("%c", "01"[C[i][j] >= tot]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct psychotronic_induction {
int electromagnetic_wave = 7;
};
const int inf = 0x3f3f3f3f;
const long long infL = LLONG_MAX;
const int nmax = 400 + 10;
const int sigma = 26;
int n, m, r, c;
char a[nmax][nmax];
bitset<nmax> mat[sigma][nmax], ans[nmax];
bitset<nmax> get_shift(bitset<nmax> curr, int shift) {
shift %= m;
return (curr << (m - shift)) | (curr >> shift);
}
int main() {
ios_base ::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) mat[a[i][j] - 'a'][i][j] = 1;
for (int i = 0; i < n; ++i) ans[i] = ~ans[i];
cin >> r >> c;
for (int x = 0; x < r; ++x)
for (int y = 0; y < c; ++y) {
char curr;
cin >> curr;
if (curr == '?') continue;
for (int i = 0; i < n; ++i) {
int line = ((i - x) % n + n) % n;
ans[line] &= get_shift(mat[curr - 'a'][i], y);
}
}
for (int i = 0; i < n; ++i, cout << '\n')
for (int j = 0; j < m; ++j) cout << ans[i][j];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
char T[440][440], P[440][440];
bitset<440> ans[440], G[30][440];
bitset<440> shift(bitset<440> b, int pos) { return b >> pos | b << (m - pos); }
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", T[i]);
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", P[i]);
for (int i = 0; i < 440; i++) ans[i].set();
for (int i = 0; i < 26; i++)
for (int x = 0; x < n; x++)
for (int y = 0; y < m; y++) G[i][x].set(y, T[x][y] == i + 'a');
for (int x = 0; x < r; x++)
for (int y = 0; y < c; y++) {
char aux = P[x][y];
if (aux == '?') continue;
for (int i = 0; i < n; i++)
ans[i] &= shift(G[aux - 'a'][(i + x) % n], y % m);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cout << ans[i][j];
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using mast = vector<string>;
using cd = complex<double>;
const double PI = acos(-1);
void fft(vector<cd>& a, bool invert) {
int n = a.size();
if (n == 1) return;
vector<cd> a0(n / 2), a1(n / 2);
for (int i = 0; 2 * i < n; i++) {
a0[i] = a[2 * i];
a1[i] = a[2 * i + 1];
}
fft(a0, invert);
fft(a1, invert);
double ang = 2 * PI / n * (invert ? -1 : 1);
cd w(1), wn(cos(ang), sin(ang));
for (int i = 0; 2 * i < n; i++) {
a[i] = a0[i] + w * a1[i];
a[i + n / 2] = a0[i] - w * a1[i];
if (invert) {
a[i] /= 2;
a[i + n / 2] /= 2;
}
w *= wn;
}
}
vector<cd> multiply(vector<cd> const& a, vector<cd> const& b) {
vector<cd> fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < a.size() + b.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
fft(fa, false);
fft(fb, false);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, true);
vector<cd> result(n);
for (int i = 0; i < n; i++) result[i] = fa[i];
return result;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
mast st(n);
for (int i = 0; i < n; i++) {
cin >> st[i];
}
mast ss(n, "");
int r, c;
cin >> r >> c;
mast pt(r);
for (int i = 0; i < r; i++) cin >> pt[i];
int col = ceil((c + 0.0) / m) + 1, row = ceil((r + 0.0) / n) + 1;
for (int j = 0; j < col; j++) {
for (int i = 0; i < n; i++) ss[i] += st[i];
}
for (int j = 0; j < row - 1; j++) {
for (int i = 0; i < n; i++) ss.push_back(ss[i]);
}
vector<cd> s(row * col * n * m, (0, 0)), p(col * m * (r - 1) + c);
for (int i = 0; i < row * n; i++) {
for (int j = 0; j < col * m; j++) {
double ang = (2 * PI * (double)(ss[i][j] - 'a')) / 26;
s[i * m * col + j] = cd(cos(ang), sin(ang));
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (pt[i][j] == '?') {
p[col * m * (r - i - 1) + c - j - 1] = 0;
continue;
}
double ang = (2 * PI * (double)(pt[i][j] - 'a')) / 26;
p[col * m * (r - i - 1) + c - j - 1] = cd(cos(ang), -sin(ang));
}
}
auto result = multiply(s, p);
int ct = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
ct += (pt[i][j] == '?');
}
}
int ans[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans[i][j] = 0;
if (abs(result[col * m * i + j + m * col * (r - 1) + c - 1].real() -
r * c + ct) < 0.00001)
ans[i][j] = 1;
}
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cout << ans[i][j] << ((j == m - 1) ? "\n" : "");
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e2 + 5;
char s[N][N], pt[N][N];
int n, m, r, c;
bitset<N << 1> B1[26][N], ANS[N];
int main() {
scanf("%d %d", &n, &m);
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++)
B1[s[i][j] - 'a'][i][j] = B1[s[i][j] - 'a'][i][j + m] = ANS[i][j] = 1;
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", &pt[i]);
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (pt[i][j] != '?') {
for (int k = 0; k < n; k++)
ANS[k] &= B1[pt[i][j] - 'a'][(i + k) % n] >> (j % m);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf(ANS[i][j] ? "1" : "0");
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1205;
const int M = 1 << 21;
const double pi = acos(-1);
int n, m, r, c, W, S, len;
char T[N][N], P[N][N];
int res[M], id[N][N];
struct Complex {
double x, y;
Complex() { x = y = 0; }
Complex(double _x, double _y) { x = _x, y = _y; }
Complex operator+(const Complex &r) const {
return Complex(x + r.x, y + r.y);
}
Complex operator-(const Complex &r) const {
return Complex(x - r.x, y - r.y);
}
Complex operator*(const Complex &r) const {
return Complex(x * r.x - y * r.y, x * r.y + y * r.x);
}
int operator=(const int a) {
*this = Complex(a, 0);
return a;
}
};
Complex A[M], B[M];
void FFT(Complex P[], int n, int oper) {
for (int i = 1, j = 0; i < n - 1; i++) {
for (int s = n; j ^= s >>= 1, ~j & s;)
;
if (i < j) {
swap(P[i], P[j]);
}
}
for (int d = 0; (1 << d) < n; d++) {
int m = 1 << d, m2 = m * 2;
double p0 = pi / m * oper;
Complex unit_p0(cos(p0), sin(p0));
for (int i = 0; i < n; i += m2) {
Complex unit(1, 0);
for (int j = 0; j < m; j++) {
Complex &P1 = P[i + j + m], &P2 = P[i + j];
Complex t = unit * P1;
P1 = P2 - t;
P2 = P2 + t;
unit = unit * unit_p0;
}
}
}
}
void conv(Complex *a, Complex *b, int *c, int multi) {
int num = 0;
reverse(a, a + S);
FFT(a, len, 1);
FFT(b, len, 1);
for (int i = 0; i < len; ++i) {
a[i] = a[i] * b[i];
}
FFT(a, len, -1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int v = (a[S - 1 + (id[i][j])].x / len + 0.5);
c[num++] += v * multi;
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", T[i]);
}
for (int i = 0; i < n + n; ++i) {
for (int j = 0; j < m + m; ++j) {
T[i][j] = T[i % n][j % m];
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", P[i]);
}
W = m + m + c;
S = r * W;
len = 1;
while (len < (n + n + r) * W) {
len <<= 1;
}
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int i = 0; i < n + n; ++i) {
for (int j = 0; j < m + m; ++j) {
id[i][j] = i * W + j;
B[id[i][j]] = (T[i][j] - 'a') * (T[i][j] - 'a');
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
A[id[i][j]] = (P[i][j] != '?');
}
}
conv(A, B, res, 1);
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int i = 0; i < n + n; ++i) {
for (int j = 0; j < m + m; ++j) {
B[id[i][j]] = (T[i][j] - 'a');
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
A[id[i][j]] = (P[i][j] - 'a') * (P[i][j] != '?');
}
}
conv(A, B, res, -2);
memset(A, 0, sizeof(A));
memset(B, 0, sizeof(B));
for (int i = 0; i < n + n; ++i) {
for (int j = 0; j < m + m; ++j) {
B[id[i][j]] = 1;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
A[id[i][j]] = (P[i][j] - 'a') * (P[i][j] - 'a') * (P[i][j] != '?');
}
}
conv(A, B, res, 1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
if (res[i * m + j] == 0) {
putchar('1');
} else {
putchar('0');
}
}
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
namespace io {
const int _kReadBufferSize = 1 << 15;
char _readBuffer[_kReadBufferSize];
int _readPos;
int _readLength;
bool _ended = false;
inline void _loadBuffer() {
_readLength = static_cast<int>(
fread(_readBuffer, sizeof(char), _kReadBufferSize, stdin));
_readPos = 0;
}
inline char readChar(bool advance = true) {
if (_ended) {
return 0;
}
if (_readPos >= _readLength) {
_loadBuffer();
if (_readLength == 0) {
_ended = true;
return 0;
}
}
return _readBuffer[advance ? _readPos++ : _readPos];
}
inline int readCharArray(char* s) {
char ch;
while (true) {
ch = readChar(false);
if (!ch) {
return 0;
}
if (!isspace(ch)) {
break;
}
++_readPos;
}
*s++ = readChar(true);
int res = 1;
while (true) {
ch = readChar(false);
if (!ch) {
return res;
}
if (isspace(ch)) {
break;
}
*s++ = ch;
++res;
++_readPos;
}
*s = '\0';
return res;
}
template <typename T>
inline bool readInt(T& res) {
char ch;
while (true) {
ch = readChar(false);
if (!ch) {
return false;
}
if (!isspace(ch)) {
break;
}
++_readPos;
}
ch = readChar(false);
bool negative = ch == '-';
if (negative) {
++_readPos;
}
res = 0;
while (true) {
ch = readChar(false);
if (!isdigit(ch)) {
break;
}
res = (res << 3) + (res << 1) + (ch & 15);
++_readPos;
}
if (negative) {
res = -res;
}
return true;
}
const int _kWriteBufferSize = 1 << 15;
int _writePos = 0;
char _writeBuffer[_kWriteBufferSize];
inline void writeChar(char x) {
if (_writePos == _kWriteBufferSize) {
fwrite(_writeBuffer, 1, _kWriteBufferSize, stdout);
_writePos = 0;
}
_writeBuffer[_writePos++] = x;
}
struct _Flusher {
inline void flush() {
if (_writePos) {
fwrite(_writeBuffer, 1, _writePos, stdout);
_writePos = 0;
}
fflush(stdout);
}
inline ~_Flusher() { flush(); }
} _flusher;
} // namespace io
namespace math {
inline uint32_t nextPow2_32(uint32_t v) {
if (!v) {
return 1;
}
uint32_t res = 1U << (31 - __builtin_clz(v));
return res == v ? res : res << 1;
}
template <typename T = double>
struct Complex {
inline Complex(T _real = 0, T _imag = 0) : real(_real), imag(_imag) {}
inline void operator+=(const Complex<T>& o) {
real += o.real;
imag += o.imag;
}
inline Complex<T> operator*(const Complex<T>& o) const {
return Complex<T>(real * o.real - imag * o.imag,
real * o.imag + o.real * imag);
}
inline void operator*=(const Complex<T>& o) {
T originalReal = real;
real = originalReal * o.real - imag * o.imag;
imag = originalReal * o.imag + imag * o.real;
}
inline void operator/=(T scale) {
real /= scale;
imag /= scale;
}
inline void init(T _real = 0, T _imag = 0) {
real = _real;
imag = _imag;
}
inline void initPolar(T r, T theta) {
real = r * cos(theta);
imag = r * sin(theta);
}
inline void initSub(const Complex<T>& x, const Complex<T>& y) {
real = x.real - y.real;
imag = x.imag - y.imag;
}
T real, imag;
};
const long double PI = acos(static_cast<long double>(-1));
template <typename T = double>
struct FFTUtils {
inline FFTUtils(int capacity = -1) {
if (capacity > 0) {
capacity = nextPow2_32(capacity);
}
capacity = max(capacity, 2);
_revs.reserve(capacity);
_revs.resize(2);
_revs[0] = 0;
_revs[1] = 1;
_roots.reserve(capacity);
_roots.resize(2);
_roots[0].init(0, 0);
_roots[1].init(1, 0);
_initCapacity(capacity);
}
inline void mulInline(vector<vector<Complex<T>>>& x,
vector<vector<Complex<T>>>& y, bool cyclic = false) {
if (x.empty() || y.empty() || x[0].empty() || y[0].empty()) {
x.clear();
return;
}
int n = cyclic ? max(max(x.size(), y.size()), max(x[0].size(), y[0].size()))
: max(x.size() + y.size(), x[0].size() + y[0].size()) - 1;
int pow2 = nextPow2_32(n);
fft(x, false, pow2);
fft(y, false, pow2);
for (int i = 0; i < pow2; ++i) {
for (int j = 0; j < pow2; ++j) {
x[i][j] *= y[i][j];
}
}
fft(x, true, pow2);
}
inline void fft(vector<vector<Complex<T>>>& cs, bool invert, int n = -1) {
int pow2 = nextPow2_32(n < 0 ? cs.size() : n);
cs.reserve(pow2);
for (size_t i = 0; i < pow2; ++i) {
if (i < cs.size()) {
fft(cs[i], invert, pow2);
} else {
cs.push_back(vector<Complex<T>>(pow2));
}
}
for (int i = 0; i < pow2; ++i) {
for (int j = i + 1; j < pow2; ++j) {
swap(cs[i][j], cs[j][i]);
}
}
for (size_t i = 0; i < pow2; ++i) {
fft(cs[i], invert, pow2);
}
}
inline void fft(vector<Complex<T>>& cs, bool invert, int n = -1) {
int pow2 = nextPow2_32(n < 0 ? cs.size() : n);
_initCapacity(pow2);
_expand(cs, pow2);
if (invert) {
reverse(cs.begin() + 1, cs.begin() + pow2);
for (int i = 0; i < pow2; ++i) {
cs[i] /= pow2;
}
}
int shift = __builtin_ctz(_revs.size()) - __builtin_ctz(pow2);
for (int i = 0; i < pow2; ++i) {
int j = _revs[i] >> shift;
if (i < j) {
swap(cs[i], cs[j]);
}
}
for (int l = 1; l < pow2; l <<= 1) {
for (int i = 0, l2 = l << 1; i < pow2; i += l2) {
for (int j = 0, k = l; j < l; ++j, ++k) {
Complex<T> c = cs[i + j + l] * _roots[k];
cs[i + j + l].initSub(cs[i + j], c);
cs[i + j] += c;
}
}
}
}
inline void _expand(vector<Complex<T>>& cs, int pow2) {
for (size_t i = cs.size(); i < pow2; ++i) {
cs.emplace_back(0, 0);
}
}
inline void _initCapacity(int pow2) {
if (_revs.size() >= pow2) {
return;
}
int oldPow2 = _revs.size(), lgN = __builtin_ctz(pow2);
_revs.resize(pow2);
for (int i = 0; i < pow2; ++i) {
_revs[i] = (_revs[i >> 1] >> 1) + ((i & 1) << (lgN - 1));
}
_roots.resize(pow2);
for (int i = oldPow2; i < pow2; i <<= 1) {
T baseAngle = PI / i;
for (int j = i, k = 1; j < i << 1; j += 2, k += 2) {
_roots[j] = _roots[j >> 1];
_roots[j | 1].initPolar(1, baseAngle * k);
}
}
}
vector<int> _revs;
vector<Complex<T>> _roots;
};
} // namespace math
const int MAXN = 400 + 2;
const int MAXPOW2 = 1 << 10;
const double EPS = 1E-5;
using COMPLEX_T = double;
int n, m, r, c, nr, mc, pow2;
char board[MAXN][MAXN], pattern[MAXN][MAXN];
math::FFTUtils<COMPLEX_T> fft(MAXPOW2);
bool valid[MAXN][MAXN];
vector<vector<math::Complex<COMPLEX_T>>> boardCs, patternCs;
int main() {
io::readInt(n);
io::readInt(m);
for (int i = 0; i < n; ++i) {
io::readCharArray(board[i]);
}
io::readInt(r);
io::readInt(c);
for (int i = 0; i < r; ++i) {
io::readCharArray(pattern[i]);
}
boardCs.reserve(MAXPOW2);
boardCs.resize(n + r);
for (int i = 0; i < n + r; ++i) {
boardCs[i].reserve(MAXPOW2);
boardCs[i].resize(m + c);
for (int j = 0; j < m + c; ++j) {
boardCs[i][j].initPolar(1, math::PI / 13 * (board[i % n][j % m] - 'a'));
}
}
patternCs.reserve(MAXPOW2);
patternCs.resize(r);
int patternCnt = 0;
for (int i = 0; i < r; ++i) {
patternCs[r - 1 - i].reserve(MAXPOW2);
patternCs[r - 1 - i].resize(c);
for (int j = 0; j < c; ++j) {
if (pattern[i][j] == '?') {
patternCs[r - 1 - i][c - 1 - j].init(0, 0);
} else {
patternCs[r - 1 - i][c - 1 - j].initPolar(
1, -math::PI / 13 * (pattern[i][j] - 'a'));
++patternCnt;
}
}
}
fft.mulInline(boardCs, patternCs, true);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
io::writeChar(fabs(boardCs[i + r - 1][j + c - 1].real - patternCnt) < EPS
? '1'
: '0');
}
io::writeChar('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
char a[407][407];
char b[407][407];
bitset<407> pos[407][26];
bitset<407> good[407];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", a[i]);
for (int j = 0; j < m; j++) {
pos[i][a[i][j] - 'a'][j] = true;
good[i][j] = true;
}
}
int aa, bb;
scanf("%d %d", &aa, &bb);
for (int i = 0; i < aa; i++) {
scanf("%s", b[i]);
for (int j = 0; j < bb; j++) {
if (b[i][j] == '?') continue;
for (int k = 0; k < n; k++) {
bitset<407> gg = pos[k][b[i][j] - 'a'];
int ii = i % n, jj = j % m;
gg = (gg >> jj) | (gg << (m - jj));
good[(k + n - ii) % n] &= gg;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (!good[i][j]) {
printf("0");
} else {
printf("1");
}
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 900;
int n, m, r, c;
bitset<N> vis[26][N], ans[N];
char s[N][N], p[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i]), ans[i].set();
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < n + 400; ++j) {
for (int k = 0; k < m + 400; ++k) {
vis[i][j][k] = s[j % n][k % m] == i + 'a';
}
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) scanf("%s", p[i]);
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j)
if (p[i][j] != '?') {
bitset<N>* b = vis[p[i][j] - 'a'];
for (int x = 0; x < n; ++x) {
ans[x] &= b[x + i] >> j;
}
}
}
for (int i = 0; i < n; ++i, putchar('\n'))
for (int j = 0; j < m; ++j) printf("%d", (bool)ans[i][j]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int q = 410;
int n, m, N, M;
char mp1[q][q], mp2[q][q];
bool ans[q][q], g[26][q][q];
bitset<q> b[26][q], h[q];
bitset<q> shift(const bitset<q> &c, int len, int s) {
assert(0 <= s && s < len);
return (c >> s) | (c << (len - s));
}
void solve() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%s", mp1[i]);
for (int j = 0; j < N; j++)
for (int k = 0; k < M; k++) {
b[mp1[j][k] - 'a'][j][k] = 1;
}
for (int i = 0; i < N; i++) h[i] = ~h[i];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mp2[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int w = mp2[i][j];
if (w == '?') continue;
int shiftx = ((-i) % N + N) % N, shifty = (j % M + M) % M;
for (int k = 0; k < N; k++) {
int nx = (k + shiftx) % N;
h[nx] &= shift(b[w - 'a'][k], M, shifty);
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) printf("%d", h[i][j] ? 1 : 0);
printf("\n");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NUM = 410;
int n, m, r, c;
char table[NUM][NUM], pattern[NUM][NUM];
long long qpow(long long x, long long k, long long mod) {
long long res = 1;
for (; k; k >>= 1) {
if (k & 1) res = res * x % mod;
x = x * x % mod;
}
return res;
}
class NTT {
public:
const int wroot = 3;
const long long mod = 998244353;
int N;
int wi[1024];
NTT() {
N = 1024;
wi[0] = 1;
wi[1] = qpow(wroot, (mod - 1) / N, mod);
for (int i = 2; i < N; ++i) wi[i] = 1ll * wi[i - 1] * wi[1] % mod;
}
void ntt_1D(int *A, int n, int op) {
for (int i = 1, j = n >> 1, k; i < n - 2; ++i) {
if (i < j) swap(A[i], A[j]);
for (k = n >> 1; j >= k; k >>= 1) j -= k;
if (j < k) j += k;
}
for (int h = 2; h <= n; h <<= 1) {
int unit = op == -1 ? N - N / h : N / h;
int hf = h >> 1;
for (int i = 0; i < n; i += h) {
for (int j = i, w = 0; j < i + hf; ++j) {
int u = A[j], t = 1ll * wi[w] * A[j + hf] % mod;
if ((A[j] = u + t) >= mod) A[j] -= mod;
if ((A[j + hf] = u - t) < 0) A[j + hf] += mod;
if ((w += unit) >= N) w -= N;
}
}
}
if (op == 1) return;
int inv = qpow(n, mod - 2, mod);
for (int i = 0; i < n; ++i) A[i] = 1ll * A[i] * inv % mod;
}
void ntt_2D(int A[1024][1024], int n, int op) {
for (int i = 0; i < n; ++i) {
ntt_1D(A[i], n, op);
}
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
swap(A[i][j], A[j][i]);
}
}
for (int i = 0; i < n; ++i) {
ntt_1D(A[i], n, op);
}
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
swap(A[i][j], A[j][i]);
}
}
}
} ntt;
int A[1024][1024], B[1024][1024], res[1024][1024], sum;
inline int two(int x) { return x * x; }
inline int three(int x) { return x * x * x; }
int N;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", table[i]);
for (int j = 0; j < m; ++j) table[i][j] = table[i][j] - 'a' + 1;
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", pattern[i]);
for (int j = 0; j < c; ++j) {
if (pattern[i][j] == '?')
pattern[i][j] = 0;
else
pattern[i][j] = pattern[i][j] - 'a' + 1;
sum += two(pattern[i][j]);
}
}
for (N = 1; N < max(n + r, m + c); N <<= 1)
;
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
A[i][j] = table[i % n][j % m];
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
B[r - 1 - i][c - 1 - j] = pattern[i][j];
}
}
ntt.ntt_2D(A, N, 1);
ntt.ntt_2D(B, N, 1);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
res[i][j] = 1ll * A[i][j] * B[i][j] % ntt.mod;
}
}
ntt.ntt_2D(res, N, -1);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
printf("%d", res[r - 1 + i][c - 1 + j] == sum);
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
int n, m, r, c;
char s[N][N], p[N][N];
bitset<N> a[26][N], f[N];
int main() {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
a[s[i][j] - 'a'][i].set(j);
f[i].set(j);
}
}
cin >> r >> c;
for (int i = 0; i < r; ++i) {
cin >> p[i];
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (p[i][j] == '?') continue;
int x = p[i][j] - 'a';
for (int k = 0; k < n; ++k) {
f[k] &= (a[x][(k + i) % n] >> j % m) | (a[x][(k + i) % n] << m - j % m);
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << f[i][j];
}
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
long long POW(long long a, long long b, long long MMM = MOD) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1}, dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int ddx[] = {-1, -2, 1, -2, 2, -1, 2, 1}, ddy[] = {-2, -1, -2, 1, -1, 2, 1, 2};
bitset<404> C[26][404], res[404];
char s[404][404], t[404];
bitset<404> shift(const bitset<404> &B, int len, int s) {
return B >> s | B << (len - s);
}
int main() {
int n, m, r, c;
scanf("%d%d", &n, &m);
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
scanf("%s", s[i]);
for (int(j) = (0); (j) <= (m - 1); (j) += (1)) {
C[s[i][j] - 'a'][i][j] = true;
}
res[i].set();
}
scanf("%d%d", &r, &c);
for (int(i) = (0); (i) <= (r - 1); (i) += (1)) {
scanf("%s", t);
for (int(j) = (0); (j) <= (c - 1); (j) += (1)) {
if (t[j] == '?') continue;
int k = t[j] - 'a';
for (int(x) = (0); (x) <= (n - 1); (x) += (1)) {
int nx = x - i;
nx %= n;
if (nx < 0) nx += n;
res[nx] &= shift(C[k][x], m, j % m);
}
}
}
for (int(i) = (0); (i) <= (n - 1); (i) += (1)) {
for (int(j) = (0); (j) <= (m - 1); (j) += (1))
putchar(res[i][j] ? '1' : '0');
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 410;
int n, m, r, c, fail[N << 1], len, h;
bool match[N << 1][N];
char A[N << 1][N << 1], M[N][N];
struct Bitset {
unsigned int x[26];
void Clear() { memset(x, 0, sizeof(x)); }
void Insert(int set) {
int pos = set / 32, y = (set & ((1 << 5) - 1));
x[pos] |= 1ll << y;
}
bool In(int set) {
int pos = set / 32, y = (set & ((1 << 5) - 1));
return x[pos] & (1ll << y);
}
bool val() {
for (int i = 0; i < 26; ++i)
if (x[i]) return 1;
return 0;
}
Bitset operator<<(int set) {
int lt = set / 32, w = (set & ((1 << 5) - 1)), xv = 32 - w;
Bitset ret;
for (int i = 0; i + lt < 26; ++i) ret.x[i] = x[i + lt];
for (int i = 26 - lt; i < 26; ++i) ret.x[i] = 0;
for (int i = 0; i < 25; ++i) {
ret.x[i] >>= w;
ret.x[i] |= (ret.x[i + 1] & ((1 << w) - 1)) << xv;
}
ret.x[25] >>= w;
return ret;
}
Bitset operator&(Bitset A) {
Bitset ret;
for (int i = 0; i < 26; ++i) ret.x[i] = x[i] & A.x[i];
return ret;
}
} G[30][N << 1], T;
void Init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", A[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) scanf("%s", M[i]);
len = m + c;
h = n + r;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < len - m; ++j) A[i][j + m] = A[i][j];
}
for (int i = n; i < h; ++i)
for (int j = 0; j < len; ++j) A[i][j] = A[i - n][j];
}
void Getfail(char *A) {
fail[0] = 0;
fail[1] = 0;
int k = 0;
for (int i = 1; i < c; ++i) {
while ((A[i] != A[k] && A[k] != '?' && A[i] != '?') && k) k = fail[k];
if (A[i] == A[k] || A[k] == '?' || A[i] == '?') k++;
fail[i + 1] = k;
}
}
void KMP(char *A, char *B, int id) {
Getfail(B);
int k = 0;
for (int i = 0; i < len; ++i) {
while ((A[i] != B[k] && B[k] != '?') && k) k = fail[k];
if (A[i] == B[k] || B[k] == '?') k++;
if (k == c) match[i - c + 1][id] = 1, k = fail[k];
}
}
void Solve() {
for (int i = 0; i < h; ++i)
for (int j = 0; j < len; ++j) {
G[A[i][j] - 'a'][i].Insert(j);
G[26][i].Insert(j);
}
for (int i = 0; i < len; ++i) T.Insert(i);
for (int i = 0; i < n; ++i) {
Bitset ans = T;
for (int x = 0; x < r; ++x)
for (int y = 0; y < c; ++y)
ans = ans & (G[(M[x][y] == '?') ? 26 : (M[x][y] - 'a')][x + i] << y);
for (int j = 0; j < m; ++j) printf("%d", ans.In(j));
putchar('\n');
}
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace XDYIMCMI0LY {
const int N = 400 + 5;
int n;
int m;
int r;
int c;
char s[N][N];
char t[N][N];
bitset<N> b[26][N];
bitset<N> ans[N];
bitset<N> shift(bitset<N> x, int k) { return (x >> k) | (x << (m - k)); }
void solve() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int c = (int)s[i][j] - 'a';
b[c][i][j] = 1;
}
}
cin >> r >> c;
for (int i = 0; i < r; ++i) {
cin >> t[i];
}
for (int i = 0; i < n; ++i) {
ans[i] = ~ans[i];
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (t[i][j] == '?') {
continue;
}
int p = t[i][j] - 'a';
for (int k = 0; k < n; ++k) {
int x = (k + i) % n;
if (ans[k].count() == 0) {
continue;
}
if (b[p][x].count() == 0) {
ans[k].reset();
} else {
ans[k] &= shift(b[p][x], j % m);
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cout << ans[i][j];
}
cout << endl;
}
}
} // namespace XDYIMCMI0LY
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
XDYIMCMI0LY::solve();
flush(cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 400 + 5;
int n, m, r, c;
char table[MX][MX], preg[MX][MX];
bool ok[MX][MX][MX];
bitset<MX> pp[26];
void presolve() {
for (int t = 1; t <= r; t++) {
for (int o = 0; o < 26; o++) pp[o].reset();
for (int i = c; i >= 1; i--) {
for (int o = 0; o < 26; o++) {
pp[o] <<= 1;
if (preg[t][i] == '?' || preg[t][i] - 'a' == o) pp[o][0] = 1;
}
}
for (int i = 1; i <= n; i++) {
bitset<MX> now = 0;
for (int j = 1; j - c + 1 <= m; j++) {
int o = table[i][(j - 1) % m + 1] - 'a';
now <<= 1;
now[0] = 1;
now &= pp[o];
if (now[c - 1]) {
ok[i][j - c + 1][t] = 1;
}
}
}
}
}
bool check(int opx, int opy) {
for (int i = 1; i <= r; i++) {
int x = (opx + i - 2) % n + 1;
if (!ok[x][opy][i]) return 0;
}
return 1;
}
void solve() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
printf("%c", check(i, j) ? '1' : '0');
}
printf("\n");
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", table[i] + 1);
}
scanf("%d%d", &r, &c);
for (int i = 1; i <= r; i++) {
scanf("%s", preg[i] + 1);
}
presolve();
solve();
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 4e18L + 1;
const int IINF = 1e9 + 1;
const int limit = 1048576;
using namespace std;
template <class TH>
void _dbg(const char* sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char* sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
const int M = 26;
const int N = 403;
bitset<N> G[M][N];
char P[N][N];
bitset<N> R[N];
bitset<N> shift(bitset<N>& row, int l, int k) {
bitset<N> rez = (row >> k);
rez |= (row << (l - k));
(rez);
return rez;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> input(n);
for (auto& row : input) {
cin >> row;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
G[input[i][j] - 'a'][i][j] = 1;
}
}
int r, c;
cin >> r >> c;
for (int x = 0; x < r; x++) {
cin >> P[x];
}
for (int i = 0; i < n; i++) {
R[i] = ~R[i];
}
for (int x = 0; x < r; x++) {
for (int y = 0; y < c; y++) {
if (P[x][y] == '?') {
continue;
}
for (int i = 0; i < n; i++) {
int ii = (i + x) % n;
(x, y, i, ii, P[x][y]);
R[i] &= shift(G[P[x][y] - 'a'][ii], m, y % m);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << (R[i][j] ? '1' : '0');
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 450;
int n, m, r, c;
bitset<N> ans[N], t[26][N];
char s[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) {
ans[i][j] = true;
t[s[j] - 'a'][i][j] = true;
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) {
scanf("%s", s);
for (int j = 0; j < c; j++) {
if (s[j] == '?') continue;
for (int k = 0, nxt = n - i % n; k < n; k++, nxt++) {
nxt -= n;
nxt += nxt >> 31 & n;
ans[nxt] &=
(t[s[j] - 'a'][k] >> (j % m)) | (t[s[j] - 'a'][k] << (m - (j % m)));
}
}
}
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) {
bool x = ans[i][j];
printf("%d", x);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 405;
const long long mod = 1e9 + 7;
const long long inf = 1e9 + 1;
int dx[] = {0, 0, -1, 1};
int dy[] = {1, -1, 0, 0};
bitset<2 * N> ans[N], a[26][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
int n, m;
cin >> n >> m;
for (long long i = 0; i <= n - 1; i++)
for (long long j = 0; j <= m - 1; j++) {
char ch;
cin >> ch;
a[ch - 'a'][i][j] = 1;
a[ch - 'a'][i][j + m] = 1;
ans[i][j] = 1;
}
int r, c;
cin >> r >> c;
for (long long i = 0; i <= r - 1; i++)
for (long long j = 0; j <= c - 1; j++) {
char ch;
cin >> ch;
if (ch == '?') continue;
for (long long k = 0; k <= n - 1; k++)
ans[k] &= a[ch - 'a'][(k + i) % n] >> (j % m);
}
for (long long i = 0; i <= n - 1; i++) {
for (long long j = 0; j <= m - 1; j++) cout << ans[i][j];
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int NUM = 400 + 10;
int n, m;
char table[NUM][NUM];
int r, c;
char pattern[NUM][NUM];
bitset<(NUM * 2) * (NUM * 2)> bs[26], ans;
int N, M;
void output() {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
putchar(ans[i * M + j] + '0');
}
putchar('\n');
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", table[i]);
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", pattern[i]);
}
ans.set();
N = r + n;
M = c + m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int a = table[i][j] - 'a';
for (int x = i; x < N; x += n)
for (int y = j; y < M; y += m) bs[a].set(x * M + y);
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (pattern[i][j] == '?') continue;
int a = pattern[i][j] - 'a';
ans &= bs[a] >> (i * M + j);
}
}
output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const double PI = acos(-1.0);
long long rev[3210], cur_len = 0;
cd W[3210];
void reverse(long long n) {
for (long long i = 0; i < n; ++i) {
rev[i] = rev[i >> 1] >> 1;
if (i & 1) rev[i] ^= (n >> 1);
}
}
void fft(vector<cd>& A, bool inv = 0) {
long long n = A.size();
if (cur_len != n) reverse(n), cur_len = n;
for (long long i = 0; i < n; ++i) {
if (i < rev[i]) swap(A[i], A[rev[i]]);
}
for (long long s = 1; s < n; s <<= 1) {
double x = (inv ? -1 : 1) * PI / s;
cd w(cos(x), sin(x));
W[0] = cd(1, 0);
for (long long i = 1; i < s; ++i) W[i] = W[i - 1] * w;
for (long long i = 0; i < n; i += 2 * s) {
for (long long j = 0; j < s; ++j) {
cd u = A[i + j], v = A[i + j + s] * W[j];
A[i + j] = u + v, A[i + j + s] = u - v;
}
}
}
if (inv)
for (long long i = 0; i < n; ++i) A[i] /= n;
}
string s[810], t[810];
void fft2(vector<vector<cd>>& A, long long inv = 0) {
for (auto& v : A) fft(v, inv);
for (long long j = 0; j < (long long)(A[0]).size(); ++j) {
vector<cd> tmp;
for (long long i = 0; i < (long long)(A).size(); ++i)
tmp.push_back(A[i][j]);
fft(tmp, inv);
for (long long i = 0; i < (long long)(A).size(); ++i) A[i][j] = tmp[i];
}
}
void mul(vector<vector<cd>>& A, vector<vector<cd>>& B) {
long long n = 1, m = 1;
while (n < max((long long)(A).size(), (long long)(B).size())) n <<= 1;
n <<= 1;
while (m < max((long long)(A[0]).size(), (long long)(B[0]).size())) m <<= 1;
m <<= 1;
A.resize(n), B.resize(n);
for (auto& v : A) v.resize(m);
for (auto& v : B) v.resize(m);
fft2(A), fft2(B);
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < m; ++j) A[i][j] = A[i][j] * B[i][j];
fft2(A, 1);
}
vector<vector<cd>> brute(vector<vector<cd>>& A, vector<vector<cd>>& B) {
vector<vector<cd>> C((long long)(A).size() + (long long)(B).size());
for (long long i = 0; i < (long long)(C).size(); ++i)
C[i].resize((long long)(A[0]).size() + (long long)(B[0]).size());
for (long long i = 0; i < (long long)(A).size(); ++i)
for (long long j = 0; j < (long long)(A[i]).size(); ++j)
for (long long ii = 0; ii < (long long)(B).size(); ++ii)
for (long long jj = 0; jj < (long long)(B[ii]).size(); ++jj) {
C[i + ii][j + jj] += A[i][j] * B[ii][jj];
}
return C;
}
cd get(char c, long long y = 1) {
double x = 2 * PI * (c - 'a') * y / 26.00;
return cd(cos(x), sin(x));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, m;
cin >> n >> m;
for (long long i = 0; i < n; ++i) cin >> s[i];
long long r, c;
cin >> r >> c;
for (long long i = 0; i < r; ++i) cin >> t[i];
for (long long i = 0; i < n; ++i)
for (long long j = m; j < m + c; ++j) s[i] += s[i][j % m];
for (long long i = n; i < n + r; ++i) s[i] = s[i % n];
vector<vector<cd>> a(n + r, vector<cd>(m + c, 0));
for (long long i = 0; i < n + r; ++i)
for (long long j = 0; j < m + c; ++j) a[i][j] = get(s[i][j]);
vector<vector<cd>> b(r, vector<cd>(c, 0));
long long cnt = 0;
for (long long i = 0; i < r; ++i)
for (long long j = 0; j < c; ++j) {
if (t[i][j] == '?')
++cnt;
else
b[r - i - 1][c - j - 1] = get(t[i][j], -1);
}
mul(a, b);
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j)
cout << ((abs((long double)a[i + r - 1][j + c - 1].real() -
(long double)(r * c - cnt))) < (long double)(1e-4));
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 810;
struct aa {
int x, y;
char c;
};
aa g[N * N];
int n, m, a, b, n1[N * 2], n2[N * 2], tot[26], tot2[26], num[N][26],
num2[N][26];
int num3[N][26], num4[N][26], nn[N];
char s[N][N], s2[N][N], s3[N][N], ans[N][N];
bitset<810> bs[N][26], bs2[N][26], se[N][26], se2[N][26];
int pan(int x, int y) {
for (int k = 0; k < 26; k++)
if (tot2[k]) {
for (int i = 0; i < a; i++) {
if (num2[i][k] == nn[i] && num4[i + x][k] == m + b) continue;
if (num2[i][k])
if (((bs2[x + i][k] >> y) & se2[i][k]) != se2[i][k]) return 0;
}
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
scanf("%d%d", &a, &b);
for (int i = 0; i < a; i++) scanf("%s", s2[i]);
memset(ans, 1, sizeof(ans));
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++)
if (s2[i][j] != '?') {
se[j][s2[i][j] - 'a'][i] = 1;
num[j][s2[i][j] - 'a']++;
se2[i][s2[i][j] - 'a'][j] = 1;
num2[i][s2[i][j] - 'a']++;
tot2[s2[i][j] - 'a']++;
nn[i]++;
}
for (int i = n + a - 1; i >= 0; i--)
for (int j = m + b - 1; j >= 0; j--) {
s3[i][j] = s[i % n][j % m];
bs[j][s3[i][j] - 'a'][i] = 1;
bs2[i][s3[i][j] - 'a'][j] = 1;
tot[s3[i][j] - 'a']++;
num3[j][s3[i][j] - 'a']++;
num4[i][s3[i][j] - 'a']++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) ans[i][j] = pan(i, j);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", ans[i][j]);
printf("\n");
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char pattern[405][405], grid[405][405];
bitset<405> ans[405], possui[26][405];
int n, m;
bitset<405>* shift(bitset<405>* possui, int i, int j) {
bitset<405>* ret = new bitset<405>[405];
j %= m;
for (int k = 0; k < n; k++) {
ret[k] = possui[(k + i) % n];
ret[k] = (ret[k] << j) | (ret[k] >> (m - j));
}
return ret;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
int n2, m2;
scanf("%d %d", &n2, &m2);
for (int i = 0; i < n2; i++) scanf("%s", pattern[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int c = 0; c < 26; c++) ans[i][405 - 1 - j] = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) possui[grid[i][j] - 'a'][i][405 - 1 - j] = true;
for (int i = 0; i < n2; i++) {
for (int j = 0; j < m2; j++) {
int c = pattern[i][j];
if (c == '?') continue;
auto shifted = shift(possui[c - 'a'], i, j);
for (int i = 0; i < n; i++) ans[i] &= shifted[i];
delete shifted;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", ans[i][405 - 1 - j] == true);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char pattern[405][405], grid[405][405];
bitset<405> ans[405], possui[26][405];
int n, m;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
int n2, m2;
scanf("%d %d", &n2, &m2);
for (int i = 0; i < n2; i++) scanf("%s", pattern[i]);
for (int i = 0; i < n; i++)
for (int c = 0; c < 26; c++) ans[i].set();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) possui[grid[i][j] - 'a'][i][405 - 1 - j] = true;
for (int i = 0; i < n2; i++) {
for (int j = 0; j < m2; j++) {
int c = pattern[i][j];
if (c == '?') continue;
for (int k = 0; k < n; k++)
ans[k] &= (possui[c - 'a'][(k + i) % n] << j % m) |
(possui[c - 'a'][(k + i) % n] >> (m - j % m));
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", (int)ans[i][405 - 1 - j]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * f;
}
const int N = 410;
int n, m, r, c;
bitset<N * N << 2> vis[30], ok;
char s[N][N], t[N][N];
int main() {
ok.set();
n = read();
m = read();
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
r = read();
c = read();
for (int i = 0; i < r; ++i) scanf("%s", t[i]);
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
char ch = s[i % n][j % m];
vis[ch - 'a'][i * (m + c) + j] = 1;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
if (t[i][j] != '?') ok &= (vis[t[i][j] - 'a'] >> (i * (m + c) + j));
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
printf("%d", ok[i * (m + c) + j] ? 1 : 0);
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
const int MAX = 11;
const double PI = acos(-1);
const double eps = 1e-9;
void FFT(std::complex<double> *a, int length, int type) {
static std::complex<double> w[2][1 << MAX];
if (std::abs(w[0][0].real()) < eps) {
for (int i = 0; i < 1 << MAX; ++i) {
double cospart = cos(1.0 * i / (1 << MAX - 1) * PI),
sinpart = sin(1.0 * i / (1 << MAX - 1) * PI);
w[0][i] = std::complex<double>(cospart, -sinpart);
w[1][i] = std::complex<double>(cospart, sinpart);
}
}
int len = -1;
for (int x = length; x; ++len, x >>= 1)
;
for (int i = 1, j = 0; i < length - 1; ++i) {
for (int s = length; j ^= s >>= 1, ~j & s;)
;
if (i < j) {
std::swap(a[i], a[j]);
}
}
for (int i = 1; i <= len; ++i) {
for (int j = 0, szk = 1 << i - 1, szw = 1 << MAX - i; j < length;
j += 1 << i) {
for (int k = j, noww = 0; k < j + szk; ++k, noww += szw) {
std::complex<double> s = a[k], t = w[!~type][noww] * a[k + szk];
a[k] = s + t, a[k + szk] = s - t;
}
}
}
if (type == 1) return;
for (int i = 0; i < length; ++i) {
a[i] /= length;
}
}
void FFT_2D(std::complex<double> (*a)[1 << MAX], int lengthx, int lengthy,
int type) {
for (int i = 0; i < lengthx; ++i) {
FFT(a[i], lengthy, type);
}
for (int i = 0, sz = std::max(lengthx, lengthy); i < sz; ++i) {
for (int j = i + 1; j < sz; ++j) {
std::swap(a[i][j], a[j][i]);
}
}
for (int i = 0; i < lengthy; ++i) {
FFT(a[i], lengthx, type);
}
}
void mult(std::complex<double> (*a)[1 << MAX], int lengthax, int lengthay,
std::complex<double> (*b)[1 << MAX], int lengthbx, int lengthby) {
static std::complex<double> aux[2][1 << MAX][1 << MAX];
memset(aux, 0, sizeof(aux));
int lengthx = 1, lengthy = 1, nx = lengthax + lengthbx - 1,
ny = lengthay + lengthby - 1;
for (; lengthx < nx; lengthx <<= 1)
;
for (; lengthy < ny; lengthy <<= 1)
;
for (int i = 0; i < lengthax; ++i) {
for (int j = 0; j < lengthay; ++j) {
aux[0][i][j] = a[i][j];
}
}
for (int i = 0; i < lengthbx; ++i) {
for (int j = 0; j < lengthby; ++j) {
aux[1][i][j] = b[i][j];
}
}
FFT_2D(aux[0], lengthx, lengthy, 1);
FFT_2D(aux[1], lengthx, lengthy, 1);
for (int i = 0; i < lengthy; ++i) {
for (int j = 0; j < lengthx; ++j) {
aux[0][i][j] *= aux[1][i][j];
}
}
FFT_2D(aux[0], lengthy, lengthx, -1);
for (int i = 0; i < nx; ++i) {
for (int j = 0; j < ny; ++j) {
a[i][j] = aux[0][i][j];
}
}
}
std::complex<double> a[1 << MAX][1 << MAX], b[1 << MAX][1 << MAX];
int n, m, r, c;
char s[1 << MAX][1 << MAX];
int main() {
scanf("%d%d", &n, &m);
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) {
a[i][j] = std::complex<double>{sin(2 * PI * s[i][j] / 26),
cos(2 * PI * s[i][j] / 26)};
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", s[i]);
}
int cnt = 0;
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
b[r - i - 1][c - j - 1] = s[i][j] == '?' ? ++cnt, 0
: std::complex<double>{sin(2 * PI * s[i][j] / 26),
-cos(2 * PI * s[i][j] / 26)};
}
}
for (int i = 0; i < 1 << MAX - 1; ++i) {
for (int j = 0; j < 1 << MAX - 1; ++j) {
a[i][j] = a[i % n][j % m];
}
}
mult(a, 1 << MAX - 1, 1 << MAX - 1, b, r, c);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
putchar(std::abs(r * c - cnt - a[i + r - 1][j + c - 1].real()) < eps
? '1'
: '0');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400;
bitset<N> shift(const bitset<N>& set, int n, int x) {
return (set >> x) | (set << (n - x));
}
struct Solution {
vector<string> T, P;
bitset<N> R[N];
int n, m, r, c;
Solution(int n, int m, int r, int c, const vector<string>& T,
const vector<string>& P)
: n(n), m(m), r(r), c(c), T(T), P(P) {}
vector<bitset<N>> solve() {
vector<vector<bitset<N>>> G(26, vector<bitset<N>>(N));
vector<bitset<N>> R(N);
int nn = n;
int mm = m;
n = max(n, r);
m = max(m, c);
T.resize(n);
for (int(i) = (0); (i) < (n); (i)++) {
T[i].resize(m);
for (int(j) = (0); (j) < (m); (j)++) {
T[i][j] = T[(((i) % (nn) + (nn)) % (nn))][(((j) % (mm) + (mm)) % (mm))];
}
}
for (int(i) = (0); (i) < (n); (i)++) {
for (int(j) = (0); (j) < (m); (j)++) {
G[T[i][j] - 'a'][i][j] = 1;
}
}
for (int(i) = (0); (i) < (n); (i)++) {
R[i] = ~R[i];
}
for (int(x) = (0); (x) < (r); (x)++) {
for (int(y) = (0); (y) < (c); (y)++) {
if (P[x][y] != '?') {
for (int(i) = (0); (i) < (n); (i)++) {
auto s =
shift(G[P[x][y] - 'a'][(((i + x) % (n) + (n)) % (n))], m, y);
R[i] &= s;
}
}
}
}
return R;
}
};
vector<string> T, P;
int n, m, r, c;
mt19937 twister(5452222);
int Rand(int a, int b) { return uniform_int_distribution<int>(a, b)(twister); }
void RandomTest() {
n = Rand(1, 200);
m = Rand(1, 200);
r = Rand(1, 200);
c = Rand(1, 200);
T.resize(n);
for (int(i) = (0); (i) < (n); (i)++) {
T[i].resize(m);
for (int(j) = (0); (j) < (m); (j)++) {
T[i][j] = Rand('a', 'z');
}
}
P.resize(r);
for (int(i) = (0); (i) < (r); (i)++) {
P[i].resize(c);
for (int(j) = (0); (j) < (c); (j)++) {
P[i][j] = Rand('a', 'z');
}
}
}
int main(int argc, char* argv[]) {
ios::sync_with_stdio(0);
cin >> n >> m;
for (int(i) = (0); (i) < (n); (i)++) {
string s;
cin >> s;
T.push_back(move(s));
}
cin >> r >> c;
for (int(i) = (0); (i) < (r); (i)++) {
string s;
cin >> s;
P.push_back(move(s));
}
Solution s(n, m, r, c, T, P);
auto R = s.solve();
for (int(i) = (0); (i) < (n); (i)++) {
for (int(j) = (0); (j) < (m); (j)++) {
cout << (R[i][j] ? 1 : 0);
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const int INF = 0x3f3f3f3f;
static const long long INFL = 0x3f3f3f3f3f3f3f3fLL;
template <typename T, typename U>
static void amin(T &x, U y) {
if (y < x) x = y;
}
template <typename T, typename U>
static void amax(T &x, U y) {
if (x < y) x = y;
}
const double PI = 3.141592653589793238462643383279L;
void fft_core(complex<double> *x, int logn, int sign) {
int n = 1 << logn;
for (int i = 1, j = 0; i < n; ++i) {
int h = n >> 1;
while (((j ^= h) & h) == 0) h >>= 1;
if (i < j) swap(x[i], x[j]);
}
for (int m = 2; m <= n; m <<= 1) {
int h = m >> 1;
double theta = sign * 2 * PI / m;
double pr = cos(theta), pi = sin(theta);
for (int i = 0; i < n; i += m) {
double wr = 1, wi = 0;
for (int j = i; j < i + h; ++j) {
int k = j + h;
double lr = x[k].real() * wr - x[k].imag() * wi;
double li = x[k].real() * wi + x[k].imag() * wr;
x[k] = complex<double>(x[j].real() - lr, x[j].imag() - li);
x[j] = complex<double>(x[j].real() + lr, x[j].imag() + li);
double nwr = wr * pr - wi * pi;
double nwi = wr * pi + wi * pr;
wr = nwr, wi = nwi;
}
}
}
}
void fft(int logn, complex<double> a[]) { fft_core(a, logn, +1); }
void inverse_fft(int logn, complex<double> a[]) {
fft_core(a, logn, -1);
complex<double> inv = double(1) / (1 << logn);
for (int(i) = 0; (i) < (int)(1 << logn); ++(i)) a[i] *= inv;
}
using Ring = complex<double>;
void FFT2D(int logh, int H, int logw, int W, vector<vector<Ring>> &A) {
assert(A.size() == 1 << logh);
for (int(i) = 0; (i) < (int)(H); ++(i)) {
assert(A[i].size() == 1 << logw);
fft(logw, A[i].data());
}
vector<Ring> tmp(1 << logh);
for (int(j) = 0; (j) < (int)(1 << logw); ++(j)) {
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) tmp[i] = A[i][j];
fft(logh, tmp.data());
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) A[i][j] = tmp[i];
}
}
void FFT2Dinv(int logh, int H, int logw, int W, vector<vector<Ring>> &A) {
vector<Ring> tmp(1 << logh);
for (int(j) = 0; (j) < (int)(1 << logw); ++(j)) {
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) tmp[i] = A[i][j];
inverse_fft(logh, tmp.data());
for (int(i) = 0; (i) < (int)(1 << logh); ++(i)) A[i][j] = tmp[i];
}
for (int(i) = 0; (i) < (int)(H); ++(i)) inverse_fft(logw, A[i].data());
}
int main() {
int tH;
int tW;
while (~scanf("%d%d", &tH, &tW)) {
vector<string> table(tH);
for (int(i) = 0; (i) < (int)(tH); ++(i)) {
char buf[401];
scanf("%s", buf);
table[i] = buf;
}
int pH;
int pW;
scanf("%d%d", &pH, &pW);
vector<string> pattern(pH);
for (int(i) = 0; (i) < (int)(pH); ++(i)) {
char buf[401];
scanf("%s", buf);
pattern[i] = buf;
}
int H = tH + pH, W = tW + pW;
int logh = 1, logw = 1;
while (1 << logh < H) ++logh;
while (1 << logw < W) ++logw;
vector<vector<Ring>> A(1 << logh, vector<Ring>(1 << logw)), B = A;
for (int(i) = 0; (i) < (int)(tH + pH); ++(i))
for (int(j) = 0; (j) < (int)(tW + pW); ++(j)) {
char c = table[i % tH][j % tW];
double theta = 2 * PI * (c - 'a') / 26;
A[tH + pH - 1 - i][tW + pW - 1 - j] = polar(double(1), theta);
}
for (int(i) = 0; (i) < (int)(pH); ++(i))
for (int(j) = 0; (j) < (int)(pW); ++(j)) {
char c = pattern[i][j];
if (c == '?') continue;
double theta = -2 * PI * (c - 'a') / 26;
B[i][j] = polar(double(1), theta);
}
FFT2D(logh, H, logw, W, A);
FFT2D(logh, H, logw, W, B);
for (int(i) = 0; (i) < (int)(1 << logh); ++(i))
for (int(j) = 0; (j) < (int)(1 << logw); ++(j)) A[i][j] *= B[i][j];
FFT2Dinv(logh, H, logw, W, A);
int qs = 0;
for (int(i) = 0; (i) < (int)(pH); ++(i))
for (int(j) = 0; (j) < (int)(pW); ++(j)) qs += pattern[i][j] == '?';
vector<string> ans(tH, string(tW, '?'));
for (int(i) = 0; (i) < (int)(tH); ++(i))
for (int(j) = 0; (j) < (int)(tW); ++(j)) {
Ring r = A[tH + pH - 1 - i][tW + pW - 1 - j];
ans[i][j] = r.real() >= (pH * pW - qs) - 1e-6 ? '1' : '0';
}
for (int(i) = 0; (i) < (int)(tH); ++(i)) puts(ans[i].c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 810;
int const A = 26;
bitset<N> L[A][N];
string f[N];
string t[N];
bitset<N> ans[N];
bitset<N> rotate(bitset<N> const& a, int size, int x) {
return (a >> x) | (a << (size - x));
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> f[i];
int a, b;
cin >> a >> b;
for (int i = 0; i < a; ++i) cin >> t[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) L[f[i][j] - 'a'][i][j] = 1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) ans[i][j] = 1;
for (int x = 0; x < a; ++x) {
for (int y = 0; y < b; ++y) {
if (t[x][y] == '?') continue;
int z = t[x][y] - 'a';
for (int i = 0; i < n; ++i) {
ans[(i - x % n + n) % n] &= rotate(L[z][i], m, y % m);
}
}
}
for (int i = 0; i < n; ++i, cout << '\n')
for (int j = 0; j < m; ++j) cout << ans[i][j];
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos((long double)-1);
namespace fft {
template <class T>
class comp {
public:
T real, img;
comp(T a = (T)0, T b = (T)0) : real(a), img(b) {}
comp conj() { return comp(this->real, -(this->img)); }
comp operator=(const comp& a) {
this->real = a.real, this->img = a.img;
return *this;
}
comp operator+(const comp& b) {
return comp(this->real + b.real, this->img + b.img);
}
comp operator-(const comp& b) {
return comp(this->real - b.real, this->img - b.img);
}
comp operator*(const T& num) {
return comp(this->real * num, this->img * num);
}
comp operator/(const T& num) {
return comp(this->real / num, this->img / num);
}
comp operator*(const comp& b) {
return comp(this->real * b.real - this->img * b.img,
this->img * b.real + this->real * b.img);
}
comp operator/(const comp& b) {
comp temp(b.real, -b.img);
comp n = (*this) * temp;
return n / (b.x * b.x + b.y * b.y);
}
};
comp<long double> w[1 << 20];
int rev[1 << 20];
void revbits(int newlim) {
static int lim = -1;
int t, j;
if (newlim == lim) return;
lim = newlim;
int k = 0;
while ((1 << k) < newlim) ++k;
assert((1 << k) == newlim);
for (int i = 1; i <= (int)(lim); ++i) {
j = rev[i - 1];
t = k - 1;
while (t >= 0 && ((j >> t) & 1)) j ^= (1 << t), --t;
if (t >= 0) j ^= (1 << t), --t;
rev[i] = j;
}
}
void fft(vector<comp<long double> >& poly, int inv = false) {
int len, l;
revbits((int)(poly).size());
for (int i = 0; i < (int)((int)(poly).size()); ++i)
if (rev[i] > i) swap(poly[i], poly[rev[i]]);
comp<long double> u, v;
for (len = 2, l = 1; len <= (int)(poly).size(); len += len, l += l) {
if (w[l].real == 0 && w[l].img == 0) {
long double ang = PI / l;
comp<long double> ww(cos(ang), sin(ang));
if (l > 1) {
for (int j = 0; j < l; ++j) {
if (j & 1)
w[l + j] = w[(l + j) >> 1] * ww;
else
w[l + j] = w[(l + j) >> 1];
}
} else
w[l] = comp<long double>(1.0, 0.0);
}
for (int i = 0; i < (int)(poly).size(); i += len)
for (int j = 0; j < (int)(l); ++j) {
u = poly[i + j],
v = poly[i + j + l] * (inv ? w[l + j].conj() : w[l + j]);
poly[i + j] = u + v, poly[i + j + l] = u - v;
}
}
if (inv)
for (auto& x : poly) x = x / (long double)(int)(poly).size();
}
void fft2d(vector<vector<comp<long double> > >& A, bool inv = false) {
for (auto& row : A) {
fft(row, inv);
}
vector<comp<long double> > col((int)(A).size());
for (int j = 0; j < (int)((int)(A.front()).size()); ++j) {
for (int i = 0; i < (int)((int)(A).size()); ++i) col[i] = A[i][j];
fft(col, inv);
for (int i = 0; i < (int)((int)(A).size()); ++i) A[i][j] = col[i];
}
}
vector<vector<comp<long double> > > multiply(
vector<vector<comp<long double> > >& x,
vector<vector<comp<long double> > >& y) {
int b_rows = 0, b_cols = 0;
while ((1 << b_rows) <= max((int)(x).size(), (int)(y).size())) ++b_rows;
++b_rows;
while ((1 << b_cols) <= max((int)(x.front()).size(), (int)(y.front()).size()))
++b_cols;
++b_cols;
x.resize(1 << b_rows);
y.resize(1 << b_rows);
for (auto& row : x) row.resize(1 << b_cols, 0);
for (auto& row : y) row.resize(1 << b_cols, 0);
fft2d(x), fft2d(y);
for (int i = 0; i < (int)((int)(x).size()); ++i)
for (int j = 0; j < (int)((int)(x[i]).size()); ++j)
x[i][j] = x[i][j] * y[i][j];
fft2d(x, 1);
return x;
}
const int L = 805;
string A[L], B[L];
int N, M, R, C, X, Y;
void read() {
cin >> N >> M;
for (int i = 0; i < (int)(N); ++i) cin >> A[i];
cin >> R >> C;
for (int i = 0; i < (int)(R); ++i) cin >> B[i];
}
void solve() {
X = N + R, Y = M + C;
vector<vector<comp<long double> > > a(X, vector<comp<long double> >(Y));
for (int i = 0; i < (int)(N); ++i)
for (int j = 0; j < (int)(M); ++j) {
a[i][j].real = cos(2 * PI * (A[i][j] - 'a') / 26.0),
a[i][j].img = sin(2 * PI * (A[i][j] - 'a') / 26.0);
for (int ii = i; ii < X; ii += N)
for (int jj = j; jj < Y; jj += M) a[ii][jj] = a[i][j];
}
vector<vector<comp<long double> > > b(R, vector<comp<long double> >(C));
int valid = 0;
for (int i = 0; i < (int)(R); ++i)
for (int j = 0; j < (int)(C); ++j) {
if (B[i][j] == '?') continue;
++valid;
b[R - i - 1][C - j - 1].real = cos(2 * PI * (B[i][j] - 'a') / 26.0),
b[R - i - 1][C - j - 1].img =
-sin(2 * PI * (B[i][j] - 'a') / 26.0);
}
vector<vector<comp<long double> > > c = multiply(a, b);
for (int i = 0; i < (int)(N); ++i) {
for (int j = 0; j < (int)(M); ++j)
cout << ((int)(c[R - 1 + i][C - 1 + j].real + 1e-5) == valid);
cout << "\n";
}
}
} // namespace fft
int main() {
std::ios::sync_with_stdio(false);
fft::read();
fft::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 404, M = 27;
int n, m, r, c;
char s[N][N], t[N][N];
bitset<N> ok[N], have_char[M][N];
inline int f(char c) { return c - 'a'; }
inline bitset<N> cyclic_shift(bitset<N> b, int len) {
return (b >> len) | (b << (m - len));
}
inline void act(int x, int y, char c) {
x %= n, y %= m;
for (int i = 0; i < n; i++)
ok[i] &= cyclic_shift(have_char[f(c)][(i + x) - (i + x >= n ? n : 0)], y);
}
inline void print(bitset<N> b) {
for (int i = 0; i < m; i++) cout << b[i];
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
ok[i].set();
for (int j = 0; j < m; j++)
cin >> s[i][j], have_char[f(s[i][j])][i][j] = true;
}
cin >> r >> c;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
cin >> t[i][j];
if (t[i][j] != '?') act(i, j, t[i][j]);
}
for (int i = 0; i < n; i++, cout << '\n') print(ok[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
bitset<N> a[26][N], ans[N];
char s[N];
int n, m, r, w;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) a[s[j] - 'a'][i][j] = ans[i][j] = 1;
}
scanf("%d%d", &r, &w);
for (int i = 0; i < r; i++) {
scanf("%s", s);
for (int j = 0; j < w; j++) {
if (s[j] == '?') continue;
for (int k = 0; k < n; k++)
ans[k] &= (a[s[j] - 'a'][(k + i) % n] >> (j % m)) |
(a[s[j] - 'a'][(k + i) % n] << ((m - j) % m + m) % m);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(ans[i][j] + 48);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 810;
struct aa {
int x, y;
char c;
};
aa g[N * N];
int n, m, a, b, n1[N * 2], n2[N * 2], tot[26], tot2[26], num[N][26],
num2[N][26];
int num3[N][26], num4[N][26], nn[N];
char s[N][N], s2[N][N], s3[N][N], ans[N][N];
bitset<810> bs[N][26], bs2[N][26], se[N][26], se2[N][26];
int pan(int x, int y) {
for (int k = 0; k < 26; k++)
if (tot2[k]) {
for (int i = 0; i < a; i++) {
if (num2[i][k] == nn[i] && num4[i + x][k] == m + b) continue;
if (num2[i][k])
if (((bs2[x + i][k] >> y) & se2[i][k]) != se2[i][k]) return 0;
}
}
return 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
scanf("%d%d", &a, &b);
for (int i = 0; i < a; i++) scanf("%s", s2[i]);
memset(ans, 1, sizeof(ans));
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++)
if (s2[i][j] != '?') {
se[j][s2[i][j] - 'a'][i] = 1;
num[j][s2[i][j] - 'a']++;
se2[i][s2[i][j] - 'a'][j] = 1;
num2[i][s2[i][j] - 'a']++;
tot2[s2[i][j] - 'a']++;
nn[i]++;
}
for (int i = n + a - 1; i >= 0; i--)
for (int j = m + b - 1; j >= 0; j--) {
s3[i][j] = s[i % n][j % m];
bs[j][s3[i][j] - 'a'][i] = 1;
bs2[i][s3[i][j] - 'a'][j] = 1;
tot[s3[i][j] - 'a']++;
num3[j][s3[i][j] - 'a']++;
num4[i][s3[i][j] - 'a']++;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) ans[i][j] = pan(i, j);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", ans[i][j]);
printf("\n");
}
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)404;
const int ALPHA = 26;
bitset<N> b[ALPHA][N];
char patt[N][N];
bitset<N> result[N];
bitset<N> getShifted(const bitset<N>& b, int len, int shift) {
assert(0 <= shift && shift < len);
return (b >> shift) | (b << (len - shift));
}
int main() {
int n, m, r, c;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
static char str[N];
scanf("%s", str);
for (int j = 0; j < m; j++) {
b[(int)(str[j] - 'a')][i][j] = true;
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < n; i++) {
result[i] = ~result[i];
}
for (int i = 0; i < r; i++) {
scanf("%s", patt[i]);
for (int j = 0; j < c; j++) {
if (patt[i][j] == '?') continue;
int c = patt[i][j] - 'a';
int shiftByX = (((-i) % n) + n) % n;
int shiftByY = (((j) % m) + m) % m;
for (int x = 0; x < n; x++) {
int nx = (x + shiftByX);
if (nx >= n) nx -= n;
result[nx] &= getShifted(b[c][x], m, shiftByY);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
putchar(result[i][j] ? '1' : '0');
}
puts("");
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
using ll = long long;
template <typename T>
using v = vector<T>;
struct Complex {
double x, y;
Complex() : x(0.0), y(0.0) {}
Complex(double xin) : x(xin), y(0.0) {}
Complex(double xin, double yin) : x(xin), y(yin) {}
Complex operator*(const Complex& rhs) const {
return Complex(x * rhs.x - y * rhs.y, x * rhs.y + y * rhs.x);
}
Complex operator+(const Complex& rhs) const {
return (Complex)(*this) += rhs;
}
Complex operator-(const Complex& rhs) const {
return (Complex)(*this) -= rhs;
}
Complex& operator+=(const Complex& rhs) {
x += rhs.x;
y += rhs.y;
return *this;
}
Complex& operator-=(const Complex& rhs) {
x -= rhs.x;
y -= rhs.y;
return *this;
}
};
double norm(const Complex& z) { return z.x * z.x + z.y * z.y; }
using clx = Complex;
static const double pi = 2.0 * acos(0.0);
static v<clx> roots;
ll log2ll(ll a) {
ll result = 0;
while (a >>= 1) result++;
return result;
}
ll pow2ll(ll a) { return (1LL << a); }
v<ll> getreverse(ll deg) {
ll k = 1 + log2(deg), twok = pow2ll(k);
v<ll> r(twok);
for (ll i = 1; i < twok; i++) {
r[i] = (r[i >> 1] >> 1) | ((i & 1) << (k - 1));
}
return r;
}
v<clx> getroots(ll deg) {
ll twok = pow2ll(1 + log2ll(deg));
v<clx> res(twok);
for (ll i = 0; i < twok / 2; i++) {
double angle = (2.0 * i * pi) / twok;
res[i + twok / 2] = clx(cos(angle), sin(angle));
}
for (ll i = twok / 2 - 1; i >= 1; i--) {
res[i] = res[2 * i];
}
return res;
}
v<clx> fft(const v<clx>& a, const v<ll>& rev) {
assert(a.size() == rev.size());
ll sz = a.size();
v<clx> f(sz);
for (ll i = 0; i < sz; i++) {
f[i] = a[rev[i]];
}
for (ll k = 1; k < sz; k <<= 1) {
for (ll i = 0; i < sz; i += 2 * k) {
for (ll j = 0; j < k; j++) {
clx r = f[i + j + k] * roots[j + k];
f[i + j + k] = f[i + j] - r;
f[i + j] += r;
}
}
}
return f;
}
v<clx> mul(const v<clx>& a, const v<clx>& b) {
ll adeg = a.size() - 1, bdeg = b.size() - 1, newdeg = adeg + bdeg;
ll k = 1 + log2ll(newdeg);
ll twok = pow2ll(k);
v<ll> rev = getreverse(newdeg);
v<clx> f(a), g(b);
f.resize(twok);
g.resize(twok);
f = fft(f, rev);
g = fft(g, rev);
for (ll i = 0; i < twok; i++) {
f[i] = f[i] * g[i] * clx(1.0 / twok, 0);
}
reverse(f.begin() + 1, f.end());
f = fft(f, rev);
f.resize(newdeg + 1);
return f;
}
void printnomatch(ll n, ll m) {
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
cout << 0;
}
cout << endl;
}
}
static const ll L = 400;
static const ll V = 'z' - 'a' + 1;
static ll N;
static ll T[L][L];
static ll P[L][L];
int main(int argc, char const* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
ll n, m, r, c;
cin >> n >> m;
string str;
for (ll i = 0; i < n; i++) {
cin >> str;
for (ll j = 0; j < m; j++) {
T[i][j] = str[j] - 'a';
}
}
cin >> r >> c;
for (ll i = 0; i < r; i++) {
cin >> str;
for (ll j = 0; j < c; j++) {
P[i][j] = ('a' <= str[j] && str[j] <= 'z') ? str[j] - 'a' : -1;
}
}
ll newr = min(n, r), newc = min(m, c);
ll lettercount = 0;
for (ll i = 0; i < newr; i++) {
for (ll j = 0; j < newc; j++) {
ll cell = -1;
for (ll a = i; a < r; a += n) {
for (ll b = j; b < c; b += m) {
if (cell == -1) {
cell = P[a][b];
} else if (cell != P[a][b] && P[a][b] != -1) {
printnomatch(n, m);
return 0;
}
}
}
P[i][j] = cell;
lettercount += (cell != -1);
}
}
r = newr, c = newc;
N = 2 * n + 2 * r - 2;
ll tdeg = (n + r - 1) + N * (m + c - 1);
ll pdeg = (r - 1) + N * (c - 1);
v<clx> pt(1 + tdeg), pp(1 + pdeg);
for (ll i = 0; i < n + r; i++) {
for (ll j = 0; j < m + c; j++) {
double angle = (2.0 * pi * T[i % n][j % m]) / V;
pt[i + N * j] = clx(cos(angle), sin(angle));
}
}
for (ll i = 0; i < r; i++) {
for (ll j = 0; j < c; j++) {
double angle = -(2.0 * pi * P[i][j]) / V;
pp[(r - 1 - i) + N * (c - 1 - j)] =
(P[i][j] == -1) ? 0 : clx(cos(angle), sin(angle));
}
}
roots = getroots(tdeg + pdeg);
v<clx> ptp = mul(pt, pp);
double angle = 2 * pi / V;
double epsilon = 0.5 * norm(clx(1.0) - clx(cos(angle), sin(angle)));
for (ll i = 0; i < n; i++) {
for (ll j = 0; j < m; j++) {
clx coef = ptp[i + N * j + (r - 1) + (c - 1) * N];
double difnorm = norm((clx)lettercount - coef);
cout << "01"[difnorm < epsilon];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mo = 998244353;
const int FFTN = (1 << 20);
const int N = FFTN + 5;
const int M = 805;
char s[M][M], t[M][M];
int n, m, nn, mm, nnn, mmm;
int W[N], w[N], R[N];
int A[N], B[N], C[N];
int a[N], b[N];
unsigned long long p[N];
int power(int x, int y) {
int s = 1;
for (; y; y /= 2, x = 1ll * x * x % mo)
if (y & 1) s = 1ll * s * x % mo;
return s;
}
void FFTinit() {
W[0] = 1;
W[1] = power(3, (mo - 1) / FFTN);
for (int i = (int)(2); i <= (int)(N - 1); i++)
W[i] = 1ll * W[i - 1] * W[1] % mo;
}
int FFTinit(int n) {
int L = 1;
for (; L <= n; L <<= 1)
;
for (int i = (int)(0); i <= (int)(L - 1); i++)
R[i] = (R[i >> 1] >> 1) | ((i & 1) ? (L >> 1) : 0);
return L;
}
void DFT(int *a, int n) {
for (int i = (int)(0); i <= (int)(n - 1); i++) p[R[i]] = a[i];
for (int d = 1; d < n; d <<= 1) {
int len = FFTN / (d << 1);
for (int i = 0, j = 0; i < d; i++, j += len) w[i] = W[j];
for (int i = 0; i < n; i += (d << 1))
for (int j = 0; j < d; j++) {
int y = p[i + j + d] * w[j] % mo;
p[i + j + d] = p[i + j] + mo - y;
p[i + j] += y;
}
if (d == 1 << 10)
for (int i = (int)(0); i <= (int)(n - 1); i++) p[i] %= mo;
}
for (int i = (int)(0); i <= (int)(n - 1); i++) a[i] = p[i] % mo;
}
void IDFT(int *a, int n) {
for (int i = (int)(0); i <= (int)(n - 1); i++) p[R[i]] = a[i];
for (int d = 1; d < n; d <<= 1) {
int len = FFTN / (d << 1);
for (int i = 0, j = FFTN; i < d; i++, j -= len) w[i] = W[j];
for (int i = 0; i < n; i += (d << 1))
for (int j = 0; j < d; j++) {
int y = p[i + j + d] * w[j] % mo;
p[i + j + d] = p[i + j] + mo - y;
p[i + j] += y;
}
if (d == 1 << 10)
for (int i = (int)(0); i <= (int)(n - 1); i++) p[i] %= mo;
}
int v = power(n, mo - 2);
for (int i = (int)(0); i <= (int)(n - 1); i++) a[i] = p[i] * v % mo;
}
int main() {
FFTinit();
scanf("%d%d", &n, &m);
for (int i = (int)(1); i <= (int)(n); i++) scanf("%s", s[i] + 1);
scanf("%d%d", &nn, &mm);
for (int i = (int)(1); i <= (int)(nn); i++) scanf("%s", t[i] + 1);
nnn = nn + n - 1;
mmm = mm + m - 1;
for (int i = (int)(1); i <= (int)(nnn); i++)
for (int j = (int)(1); j <= (int)(mmm); j++)
s[i][j] = s[(i - 1) % n + 1][(j - 1) % m + 1];
for (int i = (int)(1); i <= (int)(nnn); i++)
for (int j = (int)(1); j <= (int)(mmm); j++)
a[i * mmm - mmm + j] = (s[i][j] - 'a' + 1);
for (int i = (int)(1); i <= (int)(nn); i++)
for (int j = (int)(1); j <= (int)(mm); j++)
b[i * mmm - mmm + j - 1] = (t[i][j] == '?' ? 0 : t[i][j] - 'a' + 1);
reverse(b, b + nn * mmm + 1);
int L = FFTinit((nn + nnn) * mmm);
for (int i = (int)(0); i <= (int)(L - 1); i++) A[i] = B[i] = 0;
for (int i = (int)(0); i <= (int)(L - 1); i++)
A[i] = a[i] * a[i], B[i] = b[i];
DFT(A, L);
DFT(B, L);
for (int i = (int)(0); i <= (int)(L - 1); i++)
C[i] = (C[i] + 1ll * A[i] * B[i]) % mo;
for (int i = (int)(0); i <= (int)(L - 1); i++) A[i] = B[i] = 0;
for (int i = (int)(0); i <= (int)(L - 1); i++)
A[i] = a[i], B[i] = b[i] * b[i];
DFT(A, L);
DFT(B, L);
for (int i = (int)(0); i <= (int)(L - 1); i++)
C[i] = (C[i] + mo - 2ll * A[i] * B[i] % mo) % mo;
for (int i = (int)(0); i <= (int)(L - 1); i++) A[i] = B[i] = 0;
for (int i = (int)(0); i <= (int)(L - 1); i++)
A[i] = 1, B[i] = b[i] * b[i] * b[i];
DFT(A, L);
DFT(B, L);
for (int i = (int)(0); i <= (int)(L - 1); i++)
C[i] = (C[i] + 1ll * A[i] * B[i]) % mo;
IDFT(C, L);
for (int i = (int)(1); i <= (int)(n); i++) {
for (int j = (int)(1); j <= (int)(m); j++)
putchar('0' + (C[nn * mmm + i * mmm - mmm + j] == 0));
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int s[405][405];
bitset<405> ans[405], f[28][405];
int n, m, r, c;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= m - 1; j++) {
char c = getchar();
while (c < 'a' || c > 'z') c = getchar();
ans[i][j] = 1;
f[c - 'a'][i][j] = 1;
}
scanf("%d%d", &r, &c);
for (int i = 0; i <= r - 1; i++)
for (int j = 0; j <= c - 1; j++) {
char c = getchar();
while ((c < 'a' || c > 'z') && c != '?') c = getchar();
if (c != '?')
s[i][j] = c - 'a';
else
s[i][j] = -1;
}
for (int i = 0; i <= c - 1; i++) {
for (int j = 0; j <= r - 1; j++) {
if (s[j][i] == -1) continue;
for (int k = 0; k <= n - 1; k++)
ans[k] = ans[k] & f[s[j][i]][(k + j) % n];
}
for (int j = 0; j <= n - 1; j++) {
for (int k = 0; k <= 25; k++) {
int tmp = f[k][j][0];
f[k][j] >>= 1;
f[k][j][m - 1] = tmp;
}
}
}
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++)
if (ans[i][j])
putchar('1');
else
putchar('0');
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = acos((long double)-1);
namespace fft {
template <class T>
class comp {
public:
T real, img;
comp(T a = (T)0, T b = (T)0) : real(a), img(b) {}
comp conj() { return comp(this->real, -(this->img)); }
comp operator=(const comp& a) {
this->real = a.real, this->img = a.img;
return *this;
}
comp operator+(const comp& b) {
return comp(this->real + b.real, this->img + b.img);
}
comp operator-(const comp& b) {
return comp(this->real - b.real, this->img - b.img);
}
comp operator*(const T& num) {
return comp(this->real * num, this->img * num);
}
comp operator/(const T& num) {
return comp(this->real / num, this->img / num);
}
comp operator*(const comp& b) {
return comp(this->real * b.real - this->img * b.img,
this->img * b.real + this->real * b.img);
}
comp operator/(const comp& b) {
comp temp(b.real, -b.img);
comp n = (*this) * temp;
return n / (b.x * b.x + b.y * b.y);
}
};
comp<long double> w[1 << 20];
vector<int> rev;
void revbits(int newlim) {
static int lim = -1;
int t, j;
if (newlim == lim) return;
lim = newlim;
rev.resize(lim + 1);
int k = 0;
while ((1 << k) < newlim) ++k;
assert((1 << k) == newlim);
for (int i = 1; i <= (int)(lim); ++i) {
j = rev[i - 1];
t = k - 1;
while (t >= 0 && ((j >> t) & 1)) j ^= (1 << t), --t;
if (t >= 0) j ^= (1 << t), --t;
rev[i] = j;
}
}
void fft(vector<comp<long double> >& poly, int inv = false) {
int len, l;
revbits((int)(poly).size());
for (int i = 0; i < (int)((int)(poly).size()); ++i)
if (rev[i] > i) swap(poly[i], poly[rev[i]]);
comp<long double> u, v;
for (len = 2, l = 1; len <= (int)(poly).size(); len += len, l += l) {
if (w[l].real == 0 && w[l].img == 0) {
long double ang = PI / l;
comp<long double> ww(cos(ang), sin(ang));
if (l > 1) {
for (int j = 0; j < l; ++j) {
if (j & 1)
w[l + j] = w[(l + j) >> 1] * ww;
else
w[l + j] = w[(l + j) >> 1];
}
} else
w[l] = comp<long double>(1.0, 0.0);
}
for (int i = 0; i < (int)(poly).size(); i += len)
for (int j = 0; j < (int)(l); ++j) {
u = poly[i + j],
v = poly[i + j + l] * (inv ? w[l + j].conj() : w[l + j]);
poly[i + j] = u + v, poly[i + j + l] = u - v;
}
}
if (inv)
for (auto& x : poly) x = x / (long double)(int)(poly).size();
}
void fft2d(vector<vector<comp<long double> > >& A, bool inv = false) {
for (auto& row : A) {
fft(row, inv);
}
vector<comp<long double> > col((int)(A).size());
for (int j = 0; j < (int)((int)(A.front()).size()); ++j) {
for (int i = 0; i < (int)((int)(A).size()); ++i) col[i] = A[i][j];
fft(col, inv);
for (int i = 0; i < (int)((int)(A).size()); ++i) A[i][j] = col[i];
}
}
vector<vector<comp<long double> > > multiply(
vector<vector<comp<long double> > >& x,
vector<vector<comp<long double> > >& y) {
int b_rows = 0, b_cols = 0;
while ((1 << b_rows) <= max((int)(x).size(), (int)(y).size())) ++b_rows;
++b_rows;
while ((1 << b_cols) <= max((int)(x.front()).size(), (int)(y.front()).size()))
++b_cols;
++b_cols;
x.resize(1 << b_rows);
y.resize(1 << b_rows);
for (auto& row : x) row.resize(1 << b_cols, 0);
for (auto& row : y) row.resize(1 << b_cols, 0);
fft2d(x), fft2d(y);
for (int i = 0; i < (int)((int)(x).size()); ++i)
for (int j = 0; j < (int)((int)(x[i]).size()); ++j)
x[i][j] = x[i][j] * y[i][j];
fft2d(x, 1);
return x;
}
const int L = 805;
string A[L], B[L];
int N, M, R, C, X, Y;
void read() {
cin >> N >> M;
for (int i = 0; i < (int)(N); ++i) cin >> A[i];
cin >> R >> C;
for (int i = 0; i < (int)(R); ++i) cin >> B[i];
}
void solve() {
X = N + R, Y = M + C;
vector<vector<comp<long double> > > a(X, vector<comp<long double> >(Y));
for (int i = 0; i < (int)(N); ++i)
for (int j = 0; j < (int)(M); ++j) {
a[i][j].real = cos(2 * PI * (A[i][j] - 'a') / 26.0),
a[i][j].img = sin(2 * PI * (A[i][j] - 'a') / 26.0);
for (int ii = i; ii < X; ii += N)
for (int jj = j; jj < Y; jj += M) a[ii][jj] = a[i][j];
}
vector<vector<comp<long double> > > b(R, vector<comp<long double> >(C));
int valid = 0;
for (int i = 0; i < (int)(R); ++i)
for (int j = 0; j < (int)(C); ++j) {
if (B[i][j] == '?') continue;
++valid;
b[R - i - 1][C - j - 1].real = cos(2 * PI * (B[i][j] - 'a') / 26.0),
b[R - i - 1][C - j - 1].img =
-sin(2 * PI * (B[i][j] - 'a') / 26.0);
}
vector<vector<comp<long double> > > c = multiply(a, b);
for (int i = 0; i < (int)(N); ++i) {
for (int j = 0; j < (int)(M); ++j)
cout << ((int)(c[R - 1 + i][C - 1 + j].real + 1e-5) == valid);
cout << "\n";
}
}
} // namespace fft
int main() {
std::ios::sync_with_stdio(false);
fft::read();
fft::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int r, c;
char tab[455][455];
char pat[455][455];
inline bitset<400> get(const bitset<400> &b, int d) {
return (b >> d) | (b << (m - d));
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", tab[i]);
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", pat[i]);
bitset<400> res[n];
bitset<400> is[26][n];
for (int i = 0; i < n; i++) res[i].set();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
is[tab[i][j] - 'a'][i][j] = true;
}
for (int k = 0; k < r; k++)
for (int l = 0; l < c; l++) {
if (pat[k][l] == '?') continue;
int ch = pat[k][l] - 'a';
for (int i = 0; i < n; i++) {
res[i] &= get(is[ch][(i + k) % n], l % m);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (res[i][j])
printf("1");
else
printf("0");
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 404;
char str[500];
bitset<N> G[27][N], A[N];
int n, m, r, c;
bitset<N> shift(char c, int i, int x) {
bitset<N> temp = G[c][i];
return (temp >> x) | (temp << (m - x));
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", str);
for (int j = 0; j < m; j++) G[str[j] - 'a'][i][j] = 1, A[i][j] = 1;
}
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) {
scanf("%s", str);
for (int j = 0; j < c; j++) {
char ch = str[j];
if (ch == '?') continue;
for (int k = 0; k < n; k++)
A[k] = (A[k] & shift(ch - 'a', (k + i) % n, j % m));
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", A[i][j] ? 1 : 0);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
bitset<444> ans[444], G[26][444];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char ch;
scanf(" %c", &ch);
ans[i][j] = true;
G[ch - 'a'][i][j] = true;
}
}
scanf("%d %d", &r, &c);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char ch;
scanf(" %c", &ch);
if (ch == '?') continue;
for (int k = 0; k < n; k++) {
int next = ((k + n) - (i % n)) % n;
ans[next] &=
(G[ch - 'a'][k] >> (j % m)) | (G[ch - 'a'][k] << (m - (j % m)));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << ans[i][j];
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 20;
const double eps = 1e-8;
int n, m;
int r, c;
char a[410][410];
char b[410][410];
bitset<410> ans[410];
bitset<410> G[28][410];
int main() {
while (cin >> n >> m) {
getchar();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char c = getchar();
a[i][j] = c;
ans[i][j] = G[c - 'a'][i][j] = 1;
}
getchar();
}
cin >> r >> c;
getchar();
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char t = getchar();
if (t == '?') continue;
for (int k = 0; k < n; k++) {
ans[(k - i + 400 * n) % n] &=
(G[t - 'a'][k] >> (j % m)) | (G[t - 'a'][k] << (m - j % m));
}
}
getchar();
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%c", ans[i][j] ? '1' : '0');
printf("\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<405> a[405][26], ans[405];
string pat[405];
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i <= n - 1; i++) {
string s;
cin >> s;
for (int j = 0; j <= m - 1; j++) a[i][s[j] - 'a'].set(j), ans[i].set(j);
}
int r, c;
cin >> r >> c;
for (int i = 0; i <= r - 1; i++) {
cin >> pat[i];
}
for (int i = 0; i <= r - 1; i++) {
for (int j = 0; j <= c - 1; j++)
if (pat[i][j] != '?') {
for (int k = 0; k <= n - 1; k++)
ans[(k - i % n + n) % n] &= ((a[k][pat[i][j] - 'a'] >> (j % m)) |
(a[k][pat[i][j] - 'a'] << (m - j % m)));
}
}
for (int i = 0; i <= n - 1; i++) {
for (int j = 0; j <= m - 1; j++) {
if (ans[i].test(j))
cout << "1";
else
cout << "0";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, r, c;
char ch[410][410], pat[410][410];
bitset<640010> bs[26], ans;
int N, M;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", ch[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", pat[i]);
ans.set();
N = n + r;
M = m + c;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int now = ch[i][j] - 'a';
for (int x = i; x < N; x += n)
for (int y = j; y < M; y += m) bs[now].set(x * M + y);
}
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
if (pat[i][j] == '?') continue;
int now = pat[i][j] - 'a';
ans &= bs[now] >> (i * M + j);
}
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) putchar(ans[i * M + j] + '0');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int q = 410;
int n, m, N, M;
char mp1[q][q], mp2[q][q];
bool ans[q][q], g[26][q][q];
bitset<q> b[26][q], h[q];
bitset<q> shift(const bitset<q> &c, int len, int s) {
assert(0 <= s && s < len);
return (c >> s) | (c << (len - s));
}
void solve() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%s", mp1[i]);
for (int j = 0; j < N; j++)
for (int k = 0; k < M; k++) {
b[mp1[j][k] - 'a'][j][k] = 1;
}
for (int i = 0; i < N; i++) h[i] = ~h[i];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mp2[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int w = mp2[i][j];
if (w == '?') continue;
int shiftx = ((-i) % N + N) % N, shifty = (j % M + M) % M;
for (int k = 0; k < N; k++) {
int nx = (k + shiftx) % N;
h[nx] &= shift(b[w - 'a'][k], M, shifty);
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) printf("%d", h[i][j] ? 1 : 0);
printf("\n");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int kMaxN = 110000;
int n, m, r, c;
bitset<440> ans[440];
bitset<440> G[26][440];
int main() {
scanf("%d%d", &n, &m);
char ch;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf(" %c", &ch);
G[ch - 'a'][i][j] = 1;
}
}
for (int i = 0; i < n; i++) ans[i] = ~ans[i];
scanf("%d%d", &r, &c);
for (int x = 0; x < r; x++) {
for (int y = 0; y < c; y++) {
scanf(" %c", &ch);
if (ch == '?') continue;
for (int i = 0; i < n; i++) {
int ii = x % n, jj = y % m;
ans[(i - ii + n) % n] &=
((G[ch - 'a'][i] >> (jj)) | (G[ch - 'a'][i] << ((m - jj))));
}
}
}
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) printf("%d", (int)ans[i][j]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 998244353;
const int N = 50005;
const double PI = acos(-1.0);
const double eps = 1e-8;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
struct cp {
double x, y;
};
inline cp operator+(cp &a, cp &b) { return cp{a.x + b.x, a.y + b.y}; }
inline cp operator-(cp &a, cp &b) { return cp{a.x - b.x, a.y - b.y}; }
inline cp operator*(cp &a, cp &b) {
return cp{a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x};
}
inline cp get(double x) { return cp{cos(x), sin(x)}; }
inline ostream &operator<<(ostream &out, const cp &t) {
out << "(" << t.x << "," << t.y << ")";
return out;
}
const int _M = 2048, _N = N;
template <class V>
struct FT {
cp tmp[_M * 2 + 5], aa[_M][_M], bb[_M][_M];
void FFT(cp *a, int n, int op) {
for (int i = (n >> 1), j = 1; j < n; j++) {
if (i < j) swap(a[i], a[j]);
int k;
for (k = (n >> 1); k & i; i ^= k, k >>= 1)
;
i ^= k;
}
for (int m = 2; m <= n; m <<= 1) {
cp w = get(2 * PI * op / m);
tmp[0] = cp{1, 0};
for (int j = 1; j < (m >> 1); j++) tmp[j] = tmp[j - 1] * w;
for (int i = 0; i < n; i += m)
for (int j = i; j < i + (m >> 1); j++) {
cp u = a[j], v = a[j + (m >> 1)] * tmp[j - i];
a[j] = u + v, a[j + (m >> 1)] = u - v;
}
}
if (op == -1)
for (int i = (0); i <= (n - 1); ++i) a[i] = cp{a[i].x / n, a[i].y / n};
}
void FFT(cp a[][_M], int n, int op) {
for (int i = (0); i <= (n - 1); ++i) FFT(a[i], n, op);
}
template <class T>
void Transpose(T a[][_M], int n) {
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (i - 1); ++j) swap(a[i][j], a[j][i]);
}
void Reverse(V a[][_M], int n, int m) {
for (int i = (0); i <= (n - 1 >> 1); ++i)
for (int j = (0); j <= (m - 1); ++j) swap(a[i][j], a[n - 1 - i][j]);
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1 >> 1); ++j) swap(a[i][j], a[i][m - 1 - j]);
}
void Shift(int a[][_M], int n, int m, int p, int q) {
for (int i = (n); i <= (n + p - 1); ++i)
for (int j = (m); j <= (m + q - 1); ++j) a[i - n][j - m] = a[i][j];
}
void In(cp p[][_M], int len, V a[][_M], int n, int m) {
for (int i = (0); i <= (len - 1); ++i)
for (int j = (0); j <= (len - 1); ++j)
p[i][j] = i < n && j < m ? a[i][j] : cp{0, 0};
}
void Out(int a[][_M], int n, int m, cp p[][_M], int len) {
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j) a[i][j] = (int)(p[i][j].x + eps);
}
void Multiply(V A[][_M], int n, V B[][_M], int m, int C[][_M], int &len,
int op = 0) {
if (op) Reverse(A, n, n);
len = 1;
while (len < n + m - 1) len <<= 1;
In(aa, len, A, n, n), In(bb, len, B, m, m), FFT(aa, len, 1),
FFT(bb, len, 1);
Transpose(aa, len), Transpose(bb, len), FFT(aa, len, 1), FFT(bb, len, 1);
for (int i = (0); i <= (len - 1); ++i)
for (int j = (0); j <= (len - 1); ++j) aa[i][j] = aa[i][j] * bb[i][j];
FFT(aa, len, -1), Transpose(aa, len), FFT(aa, len, -1),
Out(C, len, len, aa, len);
if (op) Shift(C, n - 1, n - 1, m, m), len = m, Reverse(A, n, n);
}
};
void Build(cp A[][_M], int n, int m, char s[][405], int M, int op,
int cc = 'a') {
for (int i = (0); i <= (n - 1); ++i)
for (int j = (0); j <= (m - 1); ++j)
A[i][j] =
(s[i][j] == '?') ? cp{0, 0} : get(2 * PI / M * (s[i][j] - cc) * op);
}
int n1, n2, m1, m2, nn, mm, len, tot = 0;
char s[405][405], t[405][405];
FT<cp> T;
cp A[_M][_M], B[_M][_M];
int C[_M][_M];
int main() {
scanf("%d%d", &n1, &m1);
for (int i = (0); i <= (n1 - 1); ++i) scanf("%s", s[i]);
scanf("%d%d", &n2, &m2), nn = n1 + n2, mm = m1 + m2;
for (int i = (0); i <= (n2 - 1); ++i) scanf("%s", t[i]);
for (int i = (0); i <= (n2 - 1); ++i)
for (int j = (0); j <= (m2 - 1); ++j) tot += (t[i][j] != '?');
Build(A, n1, m1, s, 26, 1), Build(B, n2, m2, t, 26, -1);
for (int i = (0); i <= (nn - 1); ++i)
for (int j = (0); j <= (mm - 1); ++j) {
if (i < n1 && j < m1) continue;
A[i][j] = A[i % n1][j % m1];
}
T.Multiply(B, ((n2) > (m2) ? (n2) : (m2)), A, ((nn) > (mm) ? (nn) : (mm)), C,
len, 1);
for (int i = (0); i <= (n1 - 1); ++i) {
for (int j = (0); j <= (m1 - 1); ++j) printf("%c", "01"[C[i][j] >= tot]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e6 + 7;
const double pi = acos(-1.0);
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
bitset<807> A[27][407], B[407];
char S[807];
int TaskA() {
int n, m, i, j, k, t, r, c;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) B[i].set();
for (i = 0; i < n; i++) {
scanf("%s", S);
for (j = m; j < 800; j++) S[j] = S[j - m];
for (j = 0; j < 800; j++) A[S[j] - 'a'][i].set(j);
}
scanf("%d%d", &r, &c);
for (i = 0; i < r; i++) {
scanf("%s", S);
for (j = 0; j < c; j++)
if (S[j] != '?') {
for (k = 0; k < n; k++) {
B[k] &= A[S[j] - 'a'][(i + k) % n] >> j;
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++)
if (B[i][j] == 1)
putchar('1');
else
putchar('0');
puts("");
}
return 0;
}
void initialize() {}
int main() {
int startTime = clock();
initialize();
fprintf(stderr, "/--- initializeTime: %ld milliseconds ---/\n",
clock() - startTime);
int T = 1;
startTime = clock();
while (T--) TaskA();
fprintf(stderr, "/--- computeTime: %ld milliseconds ---/\n",
clock() - startTime);
}
|
#include <bits/stdc++.h>
const int MAX = 11;
const double PI = acos(-1);
const double eps = 1e-5;
void FFT(std::complex<double> *a, int length, int type) {
for (int i = 1, j = 0; i < length - 1; ++i) {
for (int s = length; j ^= s >>= 1, ~j & s;)
;
if (i < j) {
std::swap(a[i], a[j]);
}
}
int len = -1;
for (int x = length; x; ++len, x >>= 1)
;
for (int i = 1; i <= len; ++i) {
std::complex<double> unit(cos(PI / (1 << i - 1)),
type * sin(PI / (1 << i - 1)));
for (int j = 0; j < length; j += 1 << i) {
std::complex<double> w(1, 0);
for (int k = j, szk = 1 << i - 1; k < j + szk; ++k) {
std::complex<double> s = a[k], t = w * a[k + szk];
a[k] = s + t, a[k + szk] = s - t;
w *= unit;
}
}
}
if (type == 1) {
return;
}
for (int i = 0; i < length; ++i) {
a[i] /= (std::complex<double>)length;
}
}
void mult(std::complex<double> (*compa)[1 << MAX], std::vector<int> lengtha,
std::complex<double> (*compb)[1 << MAX], std::vector<int> lengthb) {
std::vector<int> length = {1, 1};
std::vector<int> n = {lengtha[1] + lengthb[1] - 1,
lengtha[0] + lengthb[0] - 1};
for (int i = 0; i < 2; ++i) {
for (; length[i] < n[i]; length[i] <<= 1)
;
}
for (int i = 0; i < lengtha[0]; ++i) {
FFT(compa[i], length[0], 1);
}
for (int i = 0; i < lengthb[0]; ++i) {
FFT(compb[i], length[0], 1);
}
for (int i = 0, sz = std::max(length[0], lengtha[0]); i < sz; ++i) {
for (int j = 0; j < i; ++j) {
std::swap(compa[i][j], compa[j][i]);
}
}
for (int i = 0, sz = std::max(length[0], lengthb[0]); i < sz; ++i) {
for (int j = 0; j < i; ++j) {
std::swap(compb[i][j], compb[j][i]);
}
}
for (int i = 0; i < length[0]; ++i) {
FFT(compa[i], length[1], 1);
FFT(compb[i], length[1], 1);
}
for (int i = 0; i < length[0]; ++i) {
for (int j = 0; j < length[1]; ++j) {
compa[i][j] *= compb[i][j];
}
}
for (int i = 0; i < length[0]; ++i) {
FFT(compa[i], length[1], -1);
}
for (int i = 0, sz = std::max(length[0], length[1]); i < sz; ++i) {
for (int j = 0; j < i; ++j) {
std::swap(compa[i][j], compa[j][i]);
}
}
for (int i = 0; i < n[0]; ++i) {
FFT(compa[i], length[0], -1);
}
}
std::complex<double> a[1 << MAX][1 << MAX], b[1 << MAX][1 << MAX];
int n, m, r, c;
char s[1 << MAX][1 << MAX];
int main() {
scanf("%d%d", &n, &m);
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) {
a[i][j] = std::complex<double>{sin(2 * PI * s[i][j] / 26),
cos(2 * PI * s[i][j] / 26)};
}
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", s[i]);
}
int cnt = 0;
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
b[r - i - 1][c - j - 1] = s[i][j] == '?' ? ++cnt, 0
: std::complex<double>{sin(2 * PI * s[i][j] / 26),
-cos(2 * PI * s[i][j] / 26)};
}
}
for (int i = 0; i < 1 << MAX - 1; ++i) {
for (int j = 0; j < 1 << MAX - 1; ++j) {
a[i][j] = a[i % n][j % m];
}
}
mult(a, {1 << MAX - 1, 1 << MAX - 1}, b, {r, c});
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
putchar(std::abs(r * c - cnt - a[i + r - 1][j + c - 1].real()) < eps
? '1'
: '0');
}
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[423];
bitset<423> ans[423], p[423][26];
int main() {
int n, m;
cin >> n >> m;
for (int(i) = 0; (i) < (n); ++(i)) {
scanf("%s", s);
for (int(j) = 0; (j) < (m); ++(j)) {
p[i][s[j] - 'a'][j] = 1;
ans[i][j] = 1;
}
}
int r, c;
cin >> r >> c;
for (int(i) = 0; (i) < (r); ++(i)) {
scanf("%s", s);
for (int(j) = 0; (j) < (c); ++(j)) {
if (s[j] == '?') continue;
int ii = i % n, jj = j % m;
for (int(k) = 0; (k) < (n); ++(k)) {
ans[(k + n - ii) % n] &= p[k][s[j] - 'a'] >> jj | p[k][s[j] - 'a']
<< m - jj;
}
}
}
for (int(i) = 0; (i) < (n); ++(i)) {
for (int(j) = 0; (j) < (m); ++(j)) printf("%d", (int)ans[i][j]);
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int q = 410;
int n, m, N, M;
char mp1[q][q], mp2[q][q];
bool ans[q][q], g[26][q][q];
bitset<q> b[26][q], h[q];
bitset<q> shift(const bitset<q> &c, int len, int s) {
assert(0 <= s && s < len);
return (c >> s) | (c << (len - s));
}
void solve() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%s", mp1[i]);
for (int j = 0; j < N; j++)
for (int k = 0; k < M; k++) {
b[mp1[j][k] - 'a'][j][k] = 1;
}
for (int i = 0; i < N; i++) h[i] = ~h[i];
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", mp2[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int w = mp2[i][j];
if (w == '?') continue;
int shiftx = ((-i) % N + N) % N, shifty = (j % M + M) % M;
for (int k = 0; k < N; k++) {
int nx = (k + shiftx) % N;
h[nx] &= shift(b[w - 'a'][k], M, shifty);
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) printf("%d", h[i][j] ? 1 : 0);
printf("\n");
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
bool bit(int mask, int i) { return (mask >> i) & 1; }
struct cd {
double x, y;
cd() : x(0), y(0) {}
cd(double x, double y) : x(x), y(y) {}
cd(double z) : x(z), y(0) {}
cd& operator*=(const cd& z) {
tie(x, y) = make_pair(x * z.x - y * z.y, x * z.y + y * z.x);
return *this;
}
cd operator*(const cd& z) const {
cd tmp = z;
tmp *= *this;
return tmp;
}
cd& operator/=(const double& z) {
x /= z;
y /= z;
return *this;
}
cd& operator+=(const cd& z) {
x += z.x;
y += z.y;
return *this;
}
cd operator+(const cd& z) const {
cd tmp = z;
tmp += *this;
return tmp;
}
cd operator-(const cd& z) const { return cd(x - z.x, y - z.y); }
double real() const { return x; }
double imag() const { return y; }
};
cd conj(const cd& z) { return cd(z.real(), -z.imag()); }
namespace FFT {
const int B = 12;
const int N = 1 << B;
cd roots[N];
int inv[N];
cd get_root(int k, int n) { return roots[k * (N / n)]; }
void precalc() {
for (int i = 0; i < int(N); ++i) {
double ang = 2 * PI * i / N;
roots[i] = cd(cos(ang), sin(ang));
}
}
void precalc_inv(int n) {
int b = 0;
while ((1 << b) < n) ++b;
assert((1 << b) == n);
assert(b <= B);
inv[0] = 0;
int hb = -1;
for (int i = 1; i < n; ++i) {
if (bit(i, hb + 1)) {
++hb;
}
inv[i] = inv[i ^ (1 << hb)] ^ (1 << (b - hb - 1));
}
}
void fft(vector<cd>& a, bool rev) {
precalc_inv(((int)(a).size()));
for (int i = 0; i < int(((int)(a).size())); ++i) {
if (i < inv[i]) {
swap(a[i], a[inv[i]]);
}
}
for (int len = 1; len * 2 <= ((int)(a).size()); len *= 2) {
for (int i = 0; i < ((int)(a).size()); i += len * 2) {
for (int j = 0; j < int(len); ++j) {
cd x = a[i + j];
cd y = a[i + len + j];
cd r = get_root(j, len * 2);
if (rev) {
r = conj(r);
}
a[i + j] = x + r * y;
a[i + len + j] = x - r * y;
if (rev) {
a[i + j] /= 2;
a[i + len + j] /= 2;
}
}
}
}
}
void fft_2d(vector<vector<cd>>& a, bool rev) {
for (auto& row : a) {
fft(row, rev);
}
for (int j = 0; j < int(((int)(a.front()).size())); ++j) {
vector<cd> col;
for (int i = 0; i < int(((int)(a).size())); ++i) {
col.push_back(a[i][j]);
}
fft(col, rev);
for (int i = 0; i < int(((int)(a).size())); ++i) {
a[i][j] = col[i];
}
}
}
vector<vector<cd>> mult(vector<vector<cd>> x, vector<vector<cd>> y) {
int b_rows = 0;
while ((1 << b_rows) <= max(((int)(x).size()), ((int)(y).size()))) ++b_rows;
++b_rows;
int b_cols = 0;
while ((1 << b_cols) <=
max(((int)(x.front()).size()), ((int)(y.front()).size())))
++b_cols;
++b_cols;
x.resize(1 << b_rows);
y.resize(1 << b_rows);
for (auto& row : x) {
row.resize(1 << b_cols, 0);
}
for (auto& row : y) {
row.resize(1 << b_cols, 0);
}
fft_2d(x, 0);
fft_2d(y, 0);
for (int i = 0; i < int(((int)(x).size())); ++i)
for (int j = 0; j < int(((int)(x[i]).size())); ++j) {
x[i][j] *= y[i][j];
}
fft_2d(x, 1);
return x;
}
vector<vector<cd>> brut_mult(vector<vector<cd>> x, vector<vector<cd>> y) {
vector<vector<cd>> res(((int)(x).size()) + ((int)(y).size()));
for (int i = 0; i < int(((int)(res).size())); ++i) {
res[i].resize(((int)(x.front()).size()) + ((int)(y.front()).size()));
}
for (int i = 0; i < int(((int)(x).size())); ++i)
for (int j = 0; j < int(((int)(x[i]).size())); ++j)
for (int ii = 0; ii < int(((int)(y).size())); ++ii)
for (int jj = 0; jj < int(((int)(y[ii]).size())); ++jj) {
res.at(i + ii).at(j + jj) += x[i][j] * y[ii][jj];
}
return res;
}
}; // namespace FFT
const int MAXN = 800 + 10;
const int AL = 26;
int n, m;
char a[MAXN][MAXN];
int r, c;
char b[MAXN][MAXN];
bool read() {
if (scanf("%d%d\n", &n, &m) < 2) {
return 0;
}
for (int i = 0; i < int(n); ++i) {
scanf("%s\n", a[i]);
for (int j = m; j < MAXN; ++j) {
a[i][j] = 0;
}
}
scanf("%d%d\n", &r, &c);
for (int i = 0; i < int(r); ++i) {
scanf("%s\n", b[i]);
}
return 1;
}
int new_n, new_m;
void expand() {
new_n = new_m = 0;
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
for (int ii = i; ii < n + r; ii += n) {
for (int jj = j; jj < m + c; jj += m) {
a[ii][jj] = a[i][j];
new_n = max(new_n, ii + 1);
new_m = max(new_m, jj + 1);
}
}
}
}
}
void solve() {
expand();
vector<vector<cd>> A(new_n, vector<cd>(new_m, 0));
for (int i = 0; i < int(new_n); ++i)
for (int j = 0; j < int(new_m); ++j) {
int ch = a[i][j] - 'a';
double ang = 2 * PI * ch / AL;
A[i][j] = cd(cos(ang), sin(ang));
}
int not_questions = 0;
vector<vector<cd>> B(r, vector<cd>(c, 0));
for (int i = 0; i < int(r); ++i)
for (int j = 0; j < int(c); ++j) {
if (b[i][j] == '?') {
continue;
}
++not_questions;
int ch = b[i][j] - 'a';
double ang = -2 * PI * ch / AL;
B[r - i - 1][c - j - 1] = cd(cos(ang), sin(ang));
}
auto C = FFT::mult(A, B);
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(m); ++j) {
bool can = 0;
int cnt = floor(C[i + r - 1][j + c - 1].real() + 1e-5);
assert(cnt <= not_questions);
if (cnt == not_questions) {
can = 1;
}
printf("%d", can);
}
puts("");
}
}
int main() {
FFT::precalc();
while (read()) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 410;
int n, m, r, c, fail[N << 1], len, h;
bool match[N << 1][N];
char A[N << 1][N << 1], M[N][N];
struct Bitset {
unsigned int x[26];
void Clear() { memset(x, 0, sizeof(x)); }
void Insert(int set) {
int pos = set / 32, y = (set & ((1 << 5) - 1));
x[pos] |= 1ll << y;
}
bool In(int set) {
int pos = set / 32, y = (set & ((1 << 5) - 1));
return x[pos] & (1ll << y);
}
bool val() {
for (int i = 0; i < 26; ++i)
if (x[i]) return 1;
return 0;
}
Bitset operator<<(int set) {
int lt = set / 32, w = (set & ((1 << 5) - 1)), xv = 32 - w;
Bitset ret;
for (int i = 0; i + lt < 26; ++i) ret.x[i] = x[i + lt];
for (int i = 26 - lt; i < 26; ++i) ret.x[i] = 0;
for (int i = 0; i < 25; ++i) {
ret.x[i] >>= w;
ret.x[i] |= (ret.x[i + 1] & ((1 << w) - 1)) << xv;
}
ret.x[25] >>= w;
return ret;
}
Bitset operator&(Bitset A) {
Bitset ret;
for (int i = 0; i < 26; ++i) ret.x[i] = x[i] & A.x[i];
return ret;
}
} G[30][N << 1], T;
void Init() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", A[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) scanf("%s", M[i]);
len = m + c;
h = n + r;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < len - m; ++j) A[i][j + m] = A[i][j];
}
for (int i = n; i < h; ++i)
for (int j = 0; j < len; ++j) A[i][j] = A[i - n][j];
}
void Getfail(char *A) {
fail[0] = 0;
fail[1] = 0;
int k = 0;
for (int i = 1; i < c; ++i) {
while ((A[i] != A[k] && A[k] != '?' && A[i] != '?') && k) k = fail[k];
if (A[i] == A[k] || A[k] == '?' || A[i] == '?') k++;
fail[i + 1] = k;
}
}
void KMP(char *A, char *B, int id) {
Getfail(B);
int k = 0;
for (int i = 0; i < len; ++i) {
while ((A[i] != B[k] && B[k] != '?') && k) k = fail[k];
if (A[i] == B[k] || B[k] == '?') k++;
if (k == c) match[i - c + 1][id] = 1, k = fail[k];
}
}
void Solve() {
for (int i = 0; i < h; ++i)
for (int j = 0; j < len; ++j) {
G[A[i][j] - 'a'][i].Insert(j);
G[26][i].Insert(j);
}
for (int i = 0; i < len; ++i) T.Insert(i);
for (int i = 0; i < n; ++i) {
Bitset ans = T;
for (int x = 0; x < r; ++x)
for (int y = 0; y < c; ++y)
if (M[x][y] != '?') ans = ans & (G[M[x][y] - 'a'][x + i] << y);
for (int j = 0; j < m; ++j) printf("%d", ans.In(j));
putchar('\n');
}
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
int n, m, u, v;
char s[N];
bitset<N> f[30][N], ans[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> (s + 1);
for (int j = 1; j <= m; ++j)
f[s[j] - 'a'][i][j] = f[s[j] - 'a'][i][j + m] = ans[i][j] = 1;
}
cin >> u >> v;
for (int i = 1; i <= u; ++i) {
cin >> (s + 1);
for (int j = 1; j <= v; ++j)
if (s[j] != '?')
for (int k = 1; k <= n; ++k)
ans[k] &= (f[s[j] - 'a'][(k + i - 2) % n + 1] >> ((j - 1) % m));
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) cout << ans[i][j];
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
bitset<2 * N> a[26][N], ans[N];
char s[N][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) cin >> s[i][j];
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
a[s[i][j] - 'a'][i][j] = 1;
a[s[i][j] - 'a'][i][j + m] = 1;
ans[i][j] = 1;
}
}
int r, c;
cin >> r >> c;
for (int i = (0); i < (r); i++) {
for (int j = (0); j < (c); j++) {
cin >> s[i][j];
if (s[i][j] == '?') continue;
for (int k = (0); k < (n); k++) {
ans[k] &= (a[s[i][j] - 'a'][(k + i) % n] >> (j % m));
}
}
}
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (m); j++) {
if (ans[i][j])
cout << "1";
else
cout << "0";
}
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N1, P = 998244353, E = 31, F, I;
void fft(int *A, int PM, int PW) {
for (int m = N1, h; h = m / 2, m >= 2; PW = (long long)PW * PW % PM, m = h) {
for (int i = 0, w = 1; i < h; ++i, w = (long long)w * PW % PM)
for (int j = i; j < N1; j += m) {
int k = j + h, first = (A[j] - A[k] + PM) % PM;
A[j] += A[k];
A[j] %= PM;
A[k] = (long long)w * first % PM;
}
}
for (int i = 0, j = 1; j < N1 - 1; j++) {
for (int k = N1 / 2; k > (i ^= k); k /= 2)
;
if (j < i) swap(A[j], A[i]);
}
}
int power(int a, int b, int c) {
int ans = 1;
while (b) {
if (b & 1) ans = (long long)ans * a % c;
a = (long long)a * a % c;
b >>= 1;
}
return ans;
}
char grid[410][410], pat[410][410];
int a[1 << 22], b[1 << 22], vst[410][410];
int main() {
int n, m, r, c;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", grid[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", pat[i]);
int mm = m + c - 1;
for (N1 = 1; N1 <= mm * (n + 2 * r); N1 <<= 1)
;
I = power(N1, P - 2, P);
E = power(E, (P - 1) / N1, P);
F = power(E, P - 2, P);
for (int i = 0; i < 26; i++) {
memset(a, 0, sizeof(int) * N1);
memset(b, 0, sizeof(int) * N1);
int cnt = 0;
for (int j = 0; j < r; j++)
for (int k = 0; k < c; k++)
cnt += (b[r * mm - (j * mm + k)] = (pat[j][k] == i + 'a'));
if (!cnt) {
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++) vst[j][k]++;
continue;
}
for (int j = 0; j < n + r - 1; j++)
for (int k = 0; k < m + c - 1; k++)
a[j * mm + k] = (grid[j % n][k % m] == i + 'a');
fft(a, P, E);
fft(b, P, E);
for (int j = 0; j < N1; j++) a[j] = (long long)a[j] * b[j] % P;
fft(a, P, F);
for (int j = 0; j < n; j++)
for (int k = 0; k < m; k++)
if ((long long)a[j * mm + k + (r * mm)] * I % P == cnt) vst[j][k]++;
fprintf(stderr, "%c\n", i + 'a');
}
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) putchar('0' + (vst[i][j] == 26));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long double pi = acos(-1.0);
const string debug_line = "yolo";
const long double PI = acos((long double)-1.0);
const long double eps = 1e-6;
unsigned long long getRand() {
return ((unsigned long long)rand() << 40) +
((unsigned long long)rand() << 20) + ((unsigned long long)rand());
}
char s[410][410];
char pat1[410][410];
bitset<810> bitVal[410][26];
bitset<810> pat[410][26];
bitset<810> ans[410];
bool checkVal(int i1, int j1, int i2, int k) {
bitset<810> temp = (bitVal[i1][k] >> j1);
bitset<810> res = pat[i2][k] & temp;
if (res == pat[i2][k]) {
return true;
} else {
return false;
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int(i) = (0); (i) < (n); ++(i)) {
ans[i].set();
scanf("%s", s[i]);
}
int r1, c1;
scanf("%d%d", &r1, &c1);
for (int(i) = (0); (i) < (r1); ++(i)) {
scanf("%s", pat1[i]);
}
int maxr = max(r1, n);
int maxc = max(c1, m);
for (int(i) = (0); (i) < (maxr); ++(i)) {
for (int(k) = (0); (k) < (26); ++(k)) {
for (int(j) = (0); (j) < (2 * maxc); ++(j)) {
if (s[i % n][j % m] - 'a' == k) {
bitVal[i][k][j] = 1;
}
}
}
}
for (int(i) = (0); (i) < (r1); ++(i)) {
for (int(k) = (0); (k) < (26); ++(k)) {
for (int(j) = (0); (j) < (c1); ++(j)) {
if (pat1[i][j % c1] != '?' && pat1[i][j % c1] - 'a' == k) {
pat[i][k][j] = 1;
}
}
}
}
for (int(i) = (0); (i) < (r1); ++(i)) {
for (int(j) = (0); (j) < (c1); ++(j)) {
if (pat1[i][j] == '?') {
continue;
} else {
int c = pat1[i][j] - 'a';
for (int(k) = (0); (k) < (n); ++(k)) {
int x1 = ((k - i) % n + n) % n;
ans[x1] &= (bitVal[k][c] >> j % m) | (bitVal[k][c] << (m - j) % m);
}
}
}
}
for (int(i) = (0); (i) < (n); ++(i)) {
for (int(j) = (0); (j) < (m); ++(j)) {
(ans[i][j]) ? putchar('1') : putchar('0');
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 410;
bitset<4 * N * N> vis[30], sta;
char s[2 * N][2 * N], w[N][N];
int main() {
int n1, m1, n2, m2, tot = 0;
scanf("%d%d", &n1, &m1);
for (int i = 0; i < n1; i++) scanf("%s", s[i]);
scanf("%d%d", &n2, &m2);
for (int i = 0; i < n2; i++) scanf("%s", w[i]);
for (int i = 0; i < n1 + n2; i++) {
for (int j = 0; j < m1 + m2; j++) {
s[i][j] = s[i % n1][j % m1];
vis[s[i][j] - 'a'].set(i * (m1 + m2) + j);
}
}
sta.set();
for (int i = 0; i < n2; i++) {
for (int j = 0; j < m2; j++) {
if (w[i][j] == '?') continue;
sta &= (vis[w[i][j] - 'a'] >> (i * (m1 + m2) + j));
}
}
for (int i = 0; i < n1; i++) {
for (int j = 0; j < m1; j++) printf("%d", sta[i * (m1 + m2) + j] ? 1 : 0);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<410> f[410][410][26];
string s[410], t[410];
int n, m, p, q;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
cin >> p >> q;
for (int i = 0; i < p; i++) cin >> t[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < m; k++) {
f[i][k][s[i][j] - 'a'].set((j - k + m) % m);
}
}
}
for (int i = 0; i < n; i++) {
bitset<410> res;
for (int j = 0; j < m; j++) res.set(j);
for (int ii = 0; ii < p; ii++) {
int iii = (ii + i) % n;
for (int jj = 0; jj < q; jj++) {
if (t[ii][jj] == '?') continue;
res &= f[(ii + i) % n][jj % m][t[ii][jj] - 'a'];
}
}
for (int j = 0; j < m; j++) putchar(res[j] ? '1' : '0');
putchar('\n');
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
const int maxn = 800 + 50;
int n, m, R, C;
char s[maxn][maxn], f[maxn][maxn], sw[405][405][405];
bitset<400> g[26];
int main(int argc, char* argv[]) {
n = read(), m = read();
for (int i = 0; i < n; ++i) scanf("%s", s + i);
R = read(), C = read();
for (int i = 0; i < R; ++i) scanf("%s", f + i);
for (int i = 0; i < n; ++i)
for (int j = 0, cur = 0; j < m + C; ++j, ++cur) {
if (cur == m) cur = 0;
s[i][j] = s[i][cur];
}
for (int iv = 0; iv < R; ++iv) {
char* seq = f[iv];
bitset<400> swf;
for (int i = 0; i < 26; ++i) {
g[i].reset();
for (int j = 0; j < C; ++j)
if (seq[j] == '?' || seq[j] - 'a' == i) g[i][j] = 1;
}
for (int i = 0; i < n; ++i) {
swf.reset();
for (int j = 0; j < m + C; ++j) {
swf <<= 1;
swf[0] = 1;
swf &= g[s[i][j] - 'a'];
if (swf[C - 1]) sw[i][j - C + 1][iv] = 1;
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int ok = 1;
for (int k = 0, cur = i; k < R; ++k, ++cur) {
if (cur == n) cur = 0;
ok &= sw[cur][j][k];
}
if (ok)
putchar('1');
else
putchar('0');
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = double;
using cd = complex<ld>;
const long double PI = acosl(-1);
const long double EPS = 1e-6;
void dft(vector<cd>& a, bool invert = false) {
int n = a.size();
for (int i = 1, j = 0; i < n; i++) {
int bit = n >> 1;
for (; j & bit; bit >>= 1) {
j ^= bit;
}
j ^= bit;
if (i < j) swap(a[i], a[j]);
}
for (int len = 2; len <= n; len <<= 1) {
long double ang = 2 * PI / len * (invert ? -1 : 1);
cd wlen(cosl(ang), sinl(ang));
for (int i = 0; i < n; i += len) {
cd w(1);
for (int j = 0; j < len / 2; j++) {
cd u = a[i + j], v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert) {
for (auto& x : a) {
x /= n;
}
}
}
void dft_2d(vector<vector<cd>>& a, bool invert = false) {
int row_num = a.size();
int col_num = a[0].size();
int row_size = a[0].size();
int col_size = a.size();
for (auto& row : a) {
dft(row, invert);
}
vector<cd> col(col_size);
for (int j = 0; j < col_num; j++) {
for (int i = 0; i < col_size; i++) {
col[i] = a[i][j];
}
dft(col, invert);
for (int i = 0; i < col_size; i++) {
a[i][j] = col[i];
}
}
}
vector<vector<cd>> multiply_2var_polynomial(vector<vector<cd>> a,
vector<vector<cd>> b) {
size_t row_num = (a.size() + b.size());
size_t temp = 1;
for (; temp < row_num; temp <<= 1)
;
row_num = temp;
size_t col_num = a[0].size() + b[0].size();
temp = 1;
for (; temp < col_num; temp <<= 1)
;
col_num = temp;
a.resize(row_num);
b.resize(row_num);
for (int i = 0; i < row_num; i++) a[i].resize(col_num, 0);
for (int i = 0; i < row_num; i++) b[i].resize(col_num, 0);
vector<vector<cd>> ans(row_num, vector<cd>(col_num));
dft_2d(a, false);
dft_2d(b, false);
for (int i = 0; i < row_num; i++) {
for (int j = 0; j < col_num; j++) ans[i][j] = a[i][j] * b[i][j];
}
dft_2d(ans, true);
return ans;
}
void solve() {
int n, m;
cin >> n >> m;
vector<string> Big(n);
for (int i = 0; i < n; i++) {
cin >> Big[i];
}
int r, c;
cin >> r >> c;
vector<string> Small(r);
for (int i = 0; i < r; i++) {
cin >> Small[i];
}
int new_n = n + r;
int new_m = m + c;
vector<vector<cd>> big(new_n, vector<cd>(new_m, 0));
vector<vector<cd>> small(r, vector<cd>(c));
for (int i = 0; i < new_n; i++) {
for (int j = 0; j < new_m; j++) {
ld ang = 2 * PI * (Big[i % n][j % m] - 'a') / 26;
big[i][j] = cd(cosl(ang), sinl(ang));
}
}
int qcnt = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (Small[i][j] != '?') {
ld ang = 2 * PI * (Small[i][j] - 'a') / 26;
small[r - i - 1][c - j - 1] = cd(cosl(ang), -sinl(ang));
} else {
qcnt++;
small[r - i - 1][c - j - 1] = 0;
}
}
}
auto temp = multiply_2var_polynomial(big, small);
vector<vector<bool>> ans(n, vector<bool>(m, false));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int u = r - 1 + i;
int v = c - 1 + j;
ld cnt = temp[u][v].real();
if (abs(cnt - (r * c - qcnt)) < EPS) {
ans[i][j] = true;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (ans[i][j])
cout << 1;
else
cout << 0;
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
char s[420][420];
char st[420];
bitset<420> c[26][420], ans[420];
int main() {
int r, p;
scanf("%d%d", &n, &m);
int M = 400, N = 400;
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++) c[s[i][j] - 'a'][i][j] = 1;
for (int i = 0; i < n; i++) ans[i].set();
scanf("%d%d", &r, &p);
for (int i = 0; i < r; i++) {
scanf("%s", &st);
for (int j = 0; j < p; j++) {
if (st[j] == '?') continue;
for (int k = 0; k < n; k++) {
int l = ((k - i) % n + n) % n;
ans[l] &= ((c[st[j] - 'a'][k] >> (j % m)) |
(c[st[j] - 'a'][k] << (m - j % m)));
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", ans[i][j] ? 1 : 0);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int getint() {
int res = 0, fh = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') fh = -1, ch = getchar();
while (ch <= '9' && ch >= '0') res = res * 10 + ch - '0', ch = getchar();
return res * fh;
}
int n, m, N, M, R, C, len;
int rev[5000001];
struct cp {
double x, y;
friend inline cp operator+(cp a, cp b) { return (cp){a.x + b.x, a.y + b.y}; }
friend inline cp operator-(cp a, cp b) { return (cp){a.x - b.x, a.y - b.y}; }
friend inline cp operator*(cp a, cp b) {
return (cp){a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x};
}
};
cp x[5000001], y[5000001];
void fft(cp *a, int f) {
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int i = 1; i < n; i <<= 1) {
cp dw = (cp){cos(acos(-1) / i), sin(f * acos(-1) / i)};
for (int j = 0; j < n; j += i << 1) {
cp w = (cp){1, 0};
for (int k = 0; k < i; k++, w = w * dw) {
cp x = a[j + k], y = a[j + k + i] * w;
a[j + k] = x + y;
a[j + k + i] = x - y;
}
}
}
if (f == -1)
for (int i = 0; i < n; i++) a[i].x /= n;
}
char a[1001][1001], b[1001][1001];
long long hav[5000001];
int main() {
N = getint();
M = getint();
for (int i = 1; i <= N; i++) scanf("%s", a[i] + 1);
R = getint();
C = getint();
for (int i = 1; i <= R; i++) scanf("%s", b[i] + 1);
for (int i = 1; i <= N + N; i++)
for (int j = 1; j <= M + M; j++)
a[i][j] = a[(i - 1) % N + 1][(j - 1) % M + 1];
n = 1;
len = 0;
while (n <= (M * 2 + C) * (N * 2 + R)) n <<= 1, len++;
for (int i = 0; i < n; i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (len - 1));
for (int i = 1; i <= N + N; i++)
for (int j = 1; j <= M + M; j++)
x[((i - 1) * (M * 2 + C) + j)] =
(cp){(double)(1LL * (a[i][j] - 'a' + 1) * (a[i][j] - 'a' + 1)), 0};
for (int i = 1; i <= R; i++)
for (int j = 1; j <= C; j++)
y[((i - 1) * (M * 2 + C) + j)] = (cp){(double)(b[i][j] != '?'), 0};
reverse(y + 1, y + 1 + R * (M * 2 + C));
fft(x, 1);
fft(y, 1);
for (int i = 0; i < n; i++) x[i] = x[i] * y[i];
fft(x, -1);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
hav[((i - 1) * (M * 2 + C) + j)] +=
(long long)(x[((i - 1) * (M * 2 + C) + j) + (M * 2 + C) * R].x + 0.5);
for (int i = 0; i < n; i++) x[i].x = x[i].y = y[i].x = y[i].y = 0;
for (int i = 1; i <= N + N; i++)
for (int j = 1; j <= M + M; j++)
x[((i - 1) * (M * 2 + C) + j)] = (cp){(double)(a[i][j] - 'a' + 1), 0};
for (int i = 1; i <= R; i++)
for (int j = 1; j <= C; j++)
y[((i - 1) * (M * 2 + C) + j)] =
(cp){(double)(b[i][j] != '?') * (b[i][j] - 'a' + 1), 0};
reverse(y + 1, y + 1 + R * (M * 2 + C));
fft(x, 1);
fft(y, 1);
for (int i = 0; i < n; i++) x[i] = x[i] * y[i];
fft(x, -1);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
hav[((i - 1) * (M * 2 + C) + j)] -=
2LL *
(long long)(x[((i - 1) * (M * 2 + C) + j) + (M * 2 + C) * R].x + 0.5);
for (int i = 0; i < n; i++) x[i].x = x[i].y = y[i].x = y[i].y = 0;
for (int i = 1; i <= N + N; i++)
for (int j = 1; j <= M + M; j++)
x[((i - 1) * (M * 2 + C) + j)] = (cp){1, 0};
for (int i = 1; i <= R; i++)
for (int j = 1; j <= C; j++)
y[((i - 1) * (M * 2 + C) + j)] =
(cp){(double)(b[i][j] != '?') *
(1LL * (b[i][j] - 'a' + 1) * (b[i][j] - 'a' + 1)),
0};
reverse(y + 1, y + 1 + R * (M * 2 + C));
fft(x, 1);
fft(y, 1);
for (int i = 0; i < n; i++) x[i] = x[i] * y[i];
fft(x, -1);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
hav[((i - 1) * (M * 2 + C) + j)] +=
(long long)(x[((i - 1) * (M * 2 + C) + j) + (M * 2 + C) * R].x + 0.5);
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= M; j++) {
if (!hav[((i - 1) * (M * 2 + C) + j)])
printf("1");
else
printf("0");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
int n, m, x, y;
std::bitset<810> ans[410];
std::bitset<810> g[810][26];
char s[410];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s);
ans[i].set();
for (int j = 0; j < m; j++) {
int d = s[j] - 'a';
for (int b = i; b <= 800; b += n)
for (int z = j; z <= 800; z += m) g[b][d].set(z);
}
}
scanf("%d%d", &x, &y);
for (int i = 0; i < x; i++) {
scanf("%s", s);
for (int j = 0; j < y; j++) {
if (s[j] == '?') continue;
int d = s[j] - 'a';
for (int k = 0; k < n; k++) ans[k] &= (g[(k + i) % n][d] >> j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", ans[i].test(j));
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 405;
char G[405][405], P[405][405];
bitset<MAXN> nolet[405][27];
int main() {
int N, M;
scanf("%d%d", &N, &M);
for (int i = 0; i < N; ++i) {
scanf("%s", G[i]);
for (int c = 0; c < 26; ++c)
for (int j = 0; j < M; ++j)
if (G[i][j] - 'a' != c) nolet[i][c].set(j);
}
int R, C;
scanf("%d%d", &R, &C);
for (int i = 0; i < R; ++i) {
scanf("%s", P[i]);
}
for (int i = 0; i < N; ++i) {
bitset<MAXN> no;
for (int r = 0; r < R; ++r)
for (int c = 0; c < C; ++c) {
if (P[r][c] == '?') continue;
int ii = (i + r) % N;
auto b = nolet[ii][P[r][c] - 'a'];
no |= (b >> c) | (b << (M - c));
}
for (int j = 0; j < M; ++j) printf("%d", !no[j]);
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2;
cin >> s1 >> s2;
int n;
cin >> n;
for (size_t i = 0; i < n; i++) {
i == n ? cout << s1 << " " << s2 : cout << s1 << " " << s2 << endl;
string f, s;
cin >> f >> s;
if (f == s1) {
s1 = s;
} else {
s2 = s;
}
}
cout << s1 << " " << s2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string name1, name2, names[10001][2];
cin >> name1;
cin >> name2;
int n, i, j;
cin >> n;
for (i = 0; i < n; i++) {
for (j = 0; j < 2; j++) {
cin >> names[i][j];
}
}
cout << name1 << " " << name2 << "\n";
for (i = 0; i < n; i++) {
if (names[i][0] == name1) {
name1 = names[i][1];
cout << name1 << " " << name2 << "\n";
}
if (names[i][0] == name2) {
name2 = names[i][1];
cout << name1 << " " << name2 << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1050, mod = 1e9 + 7;
int main() {
string a, b, x, y;
cin >> a >> b;
cout << a << " " << b << endl;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> x >> y;
if (x == a) {
a = y;
} else if (x == b) {
b = y;
} else if (y == a) {
a = x;
} else
b = x;
cout << a << " " << b << endl;
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.