text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
struct lx {
int x, y;
} a[105];
bool cmp(lx a, lx b) { return a.y > b.y; }
inline int min(int a, int b) {
a -= b;
return b + (a & (a >> 31));
}
int n, m, v, sum, ans, f[105][10005];
inline int read() {
int c = getchar(), t = 0;
for (; c < 48 || c > 57; c = getchar())
;
do {
t = (t << 1) + (t << 3) + c - 48;
c = getchar();
} while (48 <= c && c <= 57);
return t;
}
int main() {
n = read();
memset(f, 127, sizeof f);
for (int i = 1; i <= n; ++i) sum += a[i].x = read();
for (int i = 1; i <= n; ++i) a[i].y = read();
std::sort(a + 1, a + n + 1, cmp);
ans = f[0][0] = sum;
for (int i = 1; i <= n && v < sum; ++i) v += a[i].y, ++m;
for (int i = 1; i <= n; ++i)
for (int j = min(i, m); j; --j)
for (int k = a[i].y; k <= v; ++k)
f[j][k] = min(f[j][k], f[j - 1][k - a[i].y] - a[i].x);
for (int i = sum; i <= v; ++i) ans = min(ans, f[m][i]);
printf("%d %d", m, ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 111;
long long a[MAXN], b[MAXN];
pair<long long, long long> dp[MAXN][MAXN * MAXN];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, s = 0;
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i], s += a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
dp[n - 1][0] = {0, 0};
for (long long i = 1; i <= b[n - 1]; i++) dp[n - 1][i] = {1, -a[n - 1]};
for (long long i = b[n - 1] + 1; i <= s; i++) dp[n - 1][i] = {1e18, a[n - 1]};
for (long long i = n - 2; i > -1; i--) {
dp[i][0] = {0, 0};
for (long long j = 1; j <= s; j++) {
dp[i][j] = dp[i + 1][j];
pair<long long, long long> p = dp[i + 1][max(0ll, j - b[i])];
p.first++;
p.second -= a[i];
dp[i][j] = min(dp[i][j], p);
}
}
cout << dp[0][s].first << ' ' << s + dp[0][s].second;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, dp[105][10005];
struct node {
int now, lim;
};
node nod[105];
bool nodecmp(node x, node y) { return x.lim > y.lim; }
using namespace std;
int main() {
cin >> n;
int water = 0, maxx = 0;
for (int i = 1; i <= n; i++) {
cin >> nod[i].now;
water += nod[i].now;
}
for (int i = 1; i <= n; i++) {
cin >> nod[i].lim;
maxx += nod[i].lim;
}
sort(nod + 1, nod + n + 1, nodecmp);
int k = 0;
int temp = water;
while (temp > 0) {
k++;
temp -= nod[k].lim;
}
cout << k << " ";
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int x = maxx; x >= nod[i].lim; x--) {
for (int j = 1; j <= k; j++) {
if (dp[j - 1][x - nod[i].lim] != -1) {
dp[j][x] = max(dp[j][x], dp[j - 1][x - nod[i].lim] + nod[i].now);
}
}
}
}
int ans = 0;
for (int i = water; i <= maxx; i++) {
ans = max(ans, dp[k][i]);
}
cout << water - ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
const int maxn = 105;
struct node {
int a, b;
} NODE[maxn];
int B[maxn], dp[maxn][maxn * maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) cin >> NODE[i].a, sum += NODE[i].a;
for (int i = 1; i <= n; i++) cin >> NODE[i].b, B[i] = NODE[i].b;
sort(B + 1, B + n + 1);
int Max = 0, idx = n, Msum = 0;
int sum1 = sum;
while (sum1 > 0) Max += 1, sum1 -= B[idx], Msum += B[idx], idx--;
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = min(i, Max); j >= 1; j--) {
for (int k = Msum; k >= NODE[i].b; k--) {
if (dp[j - 1][k - NODE[i].b] == -1) continue;
dp[j][k] = max(dp[j - 1][k - NODE[i].b] + NODE[i].a, dp[j][k]);
}
}
}
int res = 0;
for (int i = sum; i <= Msum; i++) res = max(res, dp[Max][i]);
cout << Max << " " << sum - res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2][101][10001];
signed main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
memset(dp, -1, sizeof(dp));
long long n, tot = 0;
cin >> n;
long long a[n], b[n], c[n];
for (long long i = 0; i < n; i++) cin >> a[i], tot += a[i];
for (long long i = 0; i < n; i++) cin >> b[i], c[i] = b[i];
sort(c, c + n, greater<long long>());
long long mx = -1;
long long sum = 0;
for (long long i = 0;; i++) {
sum += c[i];
if (sum >= tot) {
mx = i + 1;
cout << mx << ' ';
break;
}
}
dp[1][0][0] = 0;
for (long long i = 0; i < n; i++) {
long long cur = i & 1;
long long prev = cur ^ 1;
for (long long j = 0; j <= mx; j++) {
for (long long k = 0; k <= 10000; k++) {
dp[cur][j][k] = dp[prev][j][k];
if (j && k >= b[i] && dp[prev][j - 1][k - b[i]] != -1)
dp[cur][j][k] = max(dp[cur][j][k], dp[prev][j - 1][k - b[i]] + a[i]);
}
}
}
long long cur = ((n - 1) & 1);
long long mx2 = 0;
for (long long i = tot; i <= 10000; i++) mx2 = max(mx2, dp[cur][mx][i]);
cout << tot - mx2;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 109;
int n, suma, K, sumb, f[10086][N], ans = 0;
struct node {
int a, b;
} c[N];
bool cmp(const node& a, const node& b) { return a.b > b.b; }
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; i++) scanf("%d", &c[i].a), suma += c[i].a;
for (register int i = 1; i <= n; i++) scanf("%d", &c[i].b);
sort(c + 1, c + n + 1, cmp);
while (sumb < suma) sumb += c[++K].b;
printf("%d ", K);
memset(f, 128, sizeof(f));
f[0][0] = 0;
for (register int i = 1; i <= n; i++)
for (register int j = sumb; j >= c[i].b; j--)
for (register int k = 1; k <= K; k++)
f[j][k] = max(f[j][k], f[j - c[i].b][k - 1] + c[i].a);
for (register int j = suma; j <= sumb; j++) ans = max(ans, f[j][K]);
printf("%d", suma - ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("trapv")
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
#pragma GCC target("avx2")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long MOD = 1000000007;
const long long MOD2 = 998244353;
const long long BIG = 1197423052705914509LL;
mt19937 rng(
(long long)std::chrono::steady_clock::now().time_since_epoch().count());
const long long MAXN = 1e5 + 10;
const long long is_query = -BIG;
struct line {
long long m, b;
mutable function<const line*()> succ;
bool operator<(const line& rhs) const {
if (rhs.b != is_query) return m < rhs.m;
const line* s = succ();
if (!s) return 0;
long long x = rhs.m;
return b - s->b < (s->m - m) * x;
}
};
struct dynamic_hull : public multiset<line> {
const long long inf = BIG;
bool bad(iterator y) {
auto z = next(y);
if (y == begin()) {
if (z == end()) return 0;
return y->m == z->m && y->b <= z->b;
}
auto x = prev(y);
if (z == end()) return y->m == x->m && y->b <= x->b;
long long v1 = (x->b - y->b);
if (y->m == x->m)
v1 = x->b > y->b ? inf : -inf;
else
v1 /= (y->m - x->m);
long long v2 = (y->b - z->b);
if (z->m == y->m)
v2 = y->b > z->b ? inf : -inf;
else
v2 /= (z->m - y->m);
return v1 >= v2;
}
void insert_line(long long m, long long b) {
auto y = insert({m, b});
y->succ = [=] { return next(y) == end() ? 0 : &*next(y); };
if (bad(y)) {
erase(y);
return;
}
while (next(y) != end() && bad(next(y))) erase(next(y));
while (y != begin() && bad(prev(y))) erase(prev(y));
}
long long eval(long long x) {
auto l = *lower_bound((line){x, is_query});
return l.m * x + l.b;
}
};
struct auxiliary_tree {
long long n;
vector<long long> ori[MAXN];
vector<long long> storelatest;
long long tin[MAXN], tout[MAXN], dep[MAXN], cor[MAXN];
bool imp[MAXN];
long long run = 0;
vector<long long> euler;
vector<vector<pair<long long, long long> > > lca_table;
long long lef[MAXN], rig[MAXN];
void dfs(long long node, long long prev, long long de) {
dep[node] = de;
tin[node] = ++run;
cor[tin[node]] = node;
euler.push_back(node);
for (long long i = 0; i < ori[node].size(); i++) {
if (ori[node][i] != prev) {
dfs(ori[node][i], node, de + 1);
euler.push_back(node);
}
}
tout[node] = ++run;
}
void find_all_lcas() {
long long k = log2(2 * n - 1);
lca_table.resize(k + 1);
for (long long i = 0; i < k + 1; i++) {
lca_table[i].resize(2 * n - 1);
}
for (long long i = 0; i < 2 * n - 1; i++) {
lca_table[0][i] = make_pair(dep[euler[i]], euler[i]);
}
for (long long i = 1; i <= k; i++) {
for (long long j = 0; j < 2 * n - 1; j++) {
if (j + (1 << (i - 1)) >= 2 * n - 1) continue;
if (lca_table[i - 1][j].first <
lca_table[i - 1][j + (1 << (i - 1))].first) {
lca_table[i][j].first = lca_table[i - 1][j].first;
lca_table[i][j].second = lca_table[i - 1][j].second;
} else {
lca_table[i][j].first = lca_table[i - 1][j + (1 << (i - 1))].first;
lca_table[i][j].second = lca_table[i - 1][j + (1 << (i - 1))].second;
}
}
}
for (long long i = 0; i < MAXN; i++) lef[i] = -1;
for (long long i = 0; i < 2 * n - 1; i++) {
if (lef[euler[i]] == -1) {
lef[euler[i]] = i;
}
rig[euler[i]] = i;
}
}
bool isParent(long long u, long long v) {
return tin[u] < tin[v] && tout[v] < tout[u];
}
public:
vector<long long> adj[MAXN];
long long root;
long long lcadep(long long x, long long y) {
if (lef[x] > rig[y]) {
swap(x, y);
}
long long k = log2(rig[y] - lef[x] + 1);
return min(lca_table[k][lef[x]].first,
lca_table[k][rig[y] - (1 << k) + 1].first);
}
long long lcaidx(long long x, long long y) {
if (lef[x] > rig[y]) {
swap(x, y);
}
long long k = log2(rig[y] - lef[x] + 1);
if (lca_table[k][lef[x]].first <
lca_table[k][rig[y] - (1 << k) + 1].first) {
return lca_table[k][lef[x]].second;
} else {
return lca_table[k][rig[y] - (1 << k) + 1].second;
}
}
void base(long long x, long long rt, vector<long long> y[]) {
n = x;
for (long long i = 1; i <= n; i++) {
ori[i] = y[i];
}
dfs(rt, -1, 0);
find_all_lcas();
}
void build(vector<long long> g) {
for (long long i = 0; i < g.size(); i++) {
g[i] = tin[g[i]];
}
sort(g.begin(), g.end());
for (long long i = 0; i < g.size(); i++) {
g[i] = cor[g[i]];
}
long long k = g.size();
for (long long i = 0; i < k - 1; i++) {
g.push_back(lcaidx(g[i], g[i + 1]));
}
for (long long i = 0; i < g.size(); i++) {
g[i] = tin[g[i]];
}
sort(g.begin(), g.end());
for (long long i = 0; i < g.size(); i++) {
g[i] = cor[g[i]];
}
g.erase(unique(g.begin(), g.end()), g.end());
for (long long i = 0; i < g.size(); i++) {
imp[g[i]] = 1;
storelatest.push_back(g[i]);
}
stack<long long> vert;
vert.push(g[0]);
for (long long i = 1; i < g.size(); i++) {
long long u = g[i];
while (vert.size() > 1 && isParent(vert.top(), u) == 0) {
long long sto = vert.top();
vert.pop();
adj[vert.top()].push_back(sto);
}
vert.push(u);
}
while (vert.size() > 1) {
long long sto = vert.top();
vert.pop();
adj[vert.top()].push_back(sto);
}
root = vert.top();
}
void clear() {
for (long long i = 0; i < storelatest.size(); i++) {
imp[storelatest[i]] = 0;
adj[storelatest[i]].clear();
}
storelatest.clear();
}
};
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t a) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(a + FIXED_RANDOM);
}
template <class T>
size_t operator()(T a) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
hash<T> x;
return splitmix64(x(a) + FIXED_RANDOM);
}
template <class T, class H>
size_t operator()(pair<T, H> a) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
hash<T> x;
hash<H> y;
return splitmix64(x(a.f) * 37 + y(a.s) + FIXED_RANDOM);
}
};
template <class T, class H>
using umap = unordered_map<T, H, custom_hash>;
void solve(long long test_case) {
long long n;
cin >> n;
long long s = 0;
long long a[n + 1], b[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
}
priority_queue<long long> kaz;
for (long long i = 1; i <= n; i++) {
cin >> b[i];
kaz.push(b[i]);
}
long long s2 = 0, k = 0;
while (s2 < s) {
s2 += kaz.top();
k++;
kaz.pop();
}
cout << k << " ";
long long dp[2][n + 1][10001];
for (long long i = 0; i <= n; i++) {
for (long long j = 1; j < 10001; j++) {
dp[0][i][j] = -1e9;
}
dp[0][i][0] = 0;
}
long long t = 1e9;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= n; j++) {
for (long long l = 0; l <= 10000; l++) {
dp[i & 1][j][l] = dp[(i + 1) & 1][j][l];
if (j > 0) dp[i & 1][j][l] = max(dp[i & 1][j][l], dp[i & 1][j - 1][l]);
if (j > 0 && l >= b[j]) {
dp[i & 1][j][l] =
max(dp[i & 1][j][l], dp[(i + 1) & 1][j - 1][l - b[j]] + a[j]);
}
if (l >= s && i == k) {
t = min(t, s - dp[i & 1][j][l]);
}
}
}
}
cout << t << "\n";
}
int32_t main() {
time_t t = clock();
srand(time(NULL));
ios::sync_with_stdio(0);
cin.tie(0);
long long T = 1;
long long test_case = 1;
while (T--) {
solve(test_case);
test_case++;
}
cerr << "Program terminated successfully\n";
t = clock() - t;
cerr << "Time used: " << fixed << setprecision(3)
<< (long double)(t * 1.0 / CLOCKS_PER_SEC) << " seconds\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[105][10005];
struct node {
int a, b;
} bottle[105];
bool cmp(node t1, node t2) {
if (t1.b != t2.b)
return t1.b > t2.b;
else
return t1.a > t2.a;
}
int main() {
int n, sum = 0;
int cnt;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &bottle[i].a);
sum += bottle[i].a;
}
for (int i = 1; i <= n; i++) scanf("%d", &bottle[i].b);
sort(bottle + 1, bottle + n + 1, cmp);
for (int i = 1, tmp = 0; i <= n; i++) {
tmp += bottle[i].b;
if (sum <= tmp) {
cnt = i;
break;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum - bottle[i].a; j >= 0; j--) {
for (int pre = i - 1; pre >= 0; pre--) {
if (dp[pre][j] != -1) {
dp[pre + 1][j + bottle[i].a] =
max(dp[pre + 1][j + bottle[i].a], dp[pre][j] + bottle[i].b);
}
}
}
}
int t;
for (int i = sum; i >= 0; i--) {
if (dp[cnt][i] >= sum) {
t = i;
break;
}
}
printf("%d %d\n", cnt, sum - t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[105], b[105], dp[105][10005], suma, sumb, ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
suma += a[i];
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
sumb += b[i];
}
for (int i = 1; i <= n; i++) {
for (int j = sumb; j >= b[i]; j--) {
for (int k = i; k > 0; k--) {
if (j == b[i] || dp[k - 1][j - b[i]]) {
dp[k][j] = max(dp[k][j], dp[k - 1][j - b[i]] + a[i]);
}
}
}
}
for (int i = 1; i <= n; i++) {
ans = 100005;
for (int j = suma; j <= sumb; j++) {
if (dp[i][j]) {
ans = min(ans, suma - dp[i][j]);
}
}
if (ans < 100005) {
printf("%d %d", i, ans);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
const int INF = 0x3f3f3f3f;
struct node {
int v, r;
bool operator<(const node& u) const { return v > u.v; }
} a[N];
int dp[110][10010];
int sum[N];
int main() {
int n, tot = 0, k = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].r), tot += a[i].r;
for (int i = 1; i <= n; i++) scanf("%d", &a[i].v);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i].v;
for (int i = 1; i <= n; i++)
if (sum[i] >= tot) {
k = i;
break;
}
memset(dp, INF, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = min(i - 1, k); j >= 0; j--)
for (int x = sum[i - 1]; x >= 0; x--) {
dp[j + 1][x + a[i].v] = min(dp[j][x], dp[j + 1][x + a[i].v]);
if (dp[j][x] != INF) dp[j][x] += a[i].r;
}
int ans = INF;
for (int i = tot; i <= sum[k]; i++) ans = min(ans, dp[k][i]);
printf("%d %d\n", k, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 120;
int w[maxn], v[maxn];
pair<int, int> dp[maxn * maxn];
int main() {
int n;
while (scanf("%d", &n) == 1) {
int sum = 0, need = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
need += v[i];
}
for (int i = 0; i < n; i++) {
scanf("%d", &w[i]);
sum += w[i];
}
for (int i = 0; i <= sum; i++) dp[i] = make_pair(1e9, 0);
dp[0] = make_pair(0, 0);
for (int i = 0; i < n; i++) {
for (int j = sum; j >= w[i]; j--) {
pair<int, int> tmp = dp[j - w[i]];
if (dp[j].first > dp[j - w[i]].first + 1) {
dp[j].first = dp[j - w[i]].first + 1;
dp[j].second = dp[j - w[i]].second + v[i];
} else if (dp[j].first == dp[j - w[i]].first + 1) {
dp[j].second = max(dp[j].second, dp[j - w[i]].second + v[i]);
}
}
}
pair<int, int> ans;
ans = make_pair(n, 0);
for (int i = need; i <= sum; i++) {
if (dp[i].first < ans.first)
ans = dp[i];
else if (dp[i].first == ans.first) {
ans.second = max(ans.second, dp[i].second);
}
}
printf("%d %d\n", ans.first, need - ans.second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 10005;
int n;
pair<int, int> memo[105][2 * N + 10];
int a[N], b[N];
pair<int, int> dp(int i, int l) {
if (i == n) return (l <= N ? pair<int, int>(0, 0) : pair<int, int>(n, N));
if (memo[i][l].first != -1) return memo[i][l];
pair<int, int> r = dp(i + 1, l + a[i]);
r.second += a[i];
pair<int, int> p = dp(i + 1, l - b[i] + a[i]);
p.first++;
if (p.first == r.first) r.second = min(r.second, p.second);
if (p.first < r.first) swap(p, r);
return memo[i][l] = r;
}
int main() {
scanf("%d", &n);
for (int i = 0, qwer = n; i < qwer; i++) scanf("%d", a + i);
for (int i = 0, qwer = n; i < qwer; i++) scanf("%d", b + i);
memset(memo, -1, sizeof memo);
pair<int, int> k = dp(0, N);
printf("%d %d\n", k.first, k.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T qmin(const T &a, const T &b) {
return a < b ? a : b;
}
template <typename T>
inline T qmax(const T &a, const T &b) {
return a > b ? a : b;
}
template <typename T>
inline void getmin(T &a, const T &b) {
if (a > b) a = b;
}
template <typename T>
inline void getmax(T &a, const T &b) {
if (a < b) a = b;
}
inline void fileio(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const int inf = (int)1e9 + 7;
const long long linf = (long long)1e17 + 7;
const int N = 101;
int f[N][N * N];
int a[N], b[N], id[N], n, suma, sumb, tot;
inline bool cmp(const int &x, const int &y) { return b[x] > b[y]; }
int main() {
scanf("%d", &n);
for (register int i = (1); i <= (n); ++i) scanf("%d", a + i), suma += a[i];
for (register int i = (1); i <= (n); ++i)
scanf("%d", b + i), sumb += b[i], id[i] = i;
sort(id + 1, id + n + 1, cmp);
for (int rest = suma; rest > 0; rest -= b[id[++tot]])
;
for (register int i = (0); i <= (tot); ++i)
for (register int j = (0); j <= (sumb); ++j) f[i][j] = -inf;
f[0][0] = 0;
for (register int i = (1); i <= (n); ++i) {
for (register int j = (tot); j >= (1); --j) {
for (register int k = (b[i]); k <= (sumb); ++k) {
getmax(f[j][k], f[j - 1][k - b[i]] + a[i]);
}
}
}
int ans = 0;
for (register int k = (suma); k <= (sumb); ++k) getmax(ans, f[tot][k]);
printf("%d %d\n", tot, suma - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200], b[200];
pair<int, int> dp[200][10100];
int sum = 0;
pair<int, int> rec(int i, int h) {
if (i == n) {
if (h >= sum) return {0, 0};
return {1e9, 1e9};
}
pair<int, int> &ret = dp[i][h];
if (ret != make_pair(-1, -1)) return ret;
pair<int, int> res1 = {1e9, 1e9}, res2 = {1e9, 1e9};
res1 = {rec(i + 1, h).first, a[i] + rec(i + 1, h).second};
res2 = {rec(i + 1, h + b[i]).first + 1, rec(i + 1, h + b[i]).second};
return ret = min(res1, res2);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(dp, -1, sizeof dp);
cin >> n;
int i;
for (i = 0; i < n; i++) cin >> a[i], sum += a[i];
for (i = 0; i < n; i++) cin >> b[i];
cout << rec(0, 0).first << " " << rec(0, 0).second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL;
vector<vector<int> > array2_int(int N, int M, int def = 0) {
return vector<vector<int> >(N, vector<int>(M, def));
}
vector<vector<vector<int> > > array3_int(int N, int M, int K, int def = 0) {
return vector<vector<vector<int> > >(
N, vector<vector<int> >(M, vector<int>(K, def)));
}
vector<vector<long long> > array2_ll(int N, int M, long long def = 0) {
return vector<vector<long long> >(N, vector<long long>(M, def));
}
vector<vector<vector<long long> > > array3_ll(int N, int M, int K,
long long def = 0) {
return vector<vector<vector<long long> > >(
N, vector<vector<long long> >(M, vector<long long>(K, def)));
}
template <class T>
void printImpl(const vector<T>& coll) {
copy(coll.begin(), coll.end(), ostream_iterator<T>(cout, " "));
cout << endl;
}
template <class T, int N>
void printImpl(T (&coll)[N]) {
copy(coll, coll + N, ostream_iterator<T>(cout, " "));
cout << endl;
}
template <class Key, class Value>
void printImpl(const map<Key, Value>& data) {
typename map<Key, Value>::const_iterator it;
for (it = data.begin(); it != data.end(); ++it) {
cout << it->first << ":" << it->second << endl;
}
}
template <class T>
void printImpl(const T& data) {
cout << data << endl;
}
int N;
int totalB;
void update(vector<vector<int> >& dp, int a, int b) {
vector<vector<int> > newDp(dp);
for (int used = 1; used < N; ++used) {
for (int sumB = 1; sumB + b <= totalB; ++sumB) {
if (dp[used][sumB]) {
newDp[used + 1][sumB + b] =
max(dp[used + 1][sumB + b], dp[used][sumB] + a);
}
}
}
newDp[1][b] = max(dp[1][b], a);
swap(dp, newDp);
}
int main() {
cin >> N;
vector<int> a(N), b(N);
for (int i = 0; i < (N); ++i) cin >> a[i];
for (int i = 0; i < (N); ++i) cin >> b[i];
int totalA = 0;
totalB = 0;
for (int i = 0; i < (N); ++i) totalA += a[i];
for (int i = 0; i < (N); ++i) totalB += b[i];
vector<vector<int> > dp = array2_int(N + 1, totalB + 1);
for (int ix = 0; ix < N; ++ix) {
update(dp, a[ix], b[ix]);
}
vector<int> bb(b);
sort(bb.begin(), bb.end(), greater<int>());
int curr = 0;
int need = 0;
for (int i = 0; i < N; ++i) {
curr += bb[i];
if (curr >= totalA) {
need = i + 1;
break;
}
}
int canDo = 0;
for (int sb = totalA; sb <= totalB; ++sb) {
canDo = max(canDo, dp[need][sb]);
}
cout << need << " " << totalA - canDo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[110];
int b[110];
int mem[2][110][10010];
int main() {
int n, i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
vector<int> v;
for (i = 1; i <= n; i++) v.push_back(b[i]);
sort(v.rbegin(), v.rend());
int sum = 0;
for (i = 1; i <= n; i++) sum += a[i];
int cur = 0;
int cnt = -1;
for (i = 0; i < n; i++) {
cur += v[i];
if (cur >= sum) {
cnt = i + 1;
break;
}
}
assert(cnt != -1);
memset(mem, -1, sizeof mem);
mem[0][0][0] = 0;
int c = 1;
for (i = 1; i <= n; i++) {
for (j = 0; j <= cnt; j++) {
for (k = 0; k <= 10000; k++) {
mem[c][j][k] = mem[1 - c][j][k];
if (j - 1 >= 0 && k - b[i] >= 0 && mem[1 - c][j - 1][k - b[i]] != -1)
mem[c][j][k] = max(mem[c][j][k], mem[1 - c][j - 1][k - b[i]] + a[i]);
}
}
c = 1 - c;
}
int res = 0;
for (i = sum; i <= 10000; i++) res = max(res, mem[1 - c][cnt][i]);
printf("%d %d\n", cnt, sum - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[105][10005];
struct node {
int le, val;
friend bool operator<(node a, node b) {
if (a.val == b.val) return a.le > b.le;
return a.val > b.val;
}
} s[105];
int main() {
int n, i, j, k, ans1, ans2, tmp, sum;
while (scanf("%d", &n) != EOF) {
sum = 0;
for (i = 1; i <= n; i++) {
scanf("%d", &s[i].le);
sum += s[i].le;
}
for (i = 1; i <= n; i++) scanf("%d", &s[i].val);
sort(s + 1, s + n + 1);
tmp = 0;
for (i = 1; i <= n; i++) {
tmp += s[i].val;
if (tmp >= sum) {
ans1 = i;
break;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = sum; j >= 0; j--) {
for (k = 1; k <= i; k++) {
if (j >= s[i].le && dp[k - 1][j - s[i].le] != -1)
dp[k][j] = max(dp[k][j], dp[k - 1][j - s[i].le] + s[i].val);
}
}
}
for (i = sum; i >= 0; i--) {
if (dp[ans1][i] >= sum) {
ans2 = sum - i;
break;
}
}
printf("%d %d\n", ans1, ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 110;
int n, a[N], b[N], dp[N][N * N], pd[N][N * N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i);
dp[0][0] = 0;
int sa = 0, sb = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i + 1; j++)
for (int k = 0; k < sb + 1; k++) pd[j][k] = dp[j][k];
for (int j = 0; j < i + 1; j++)
for (int k = 0; k < sb + 1 + b[i]; k++) dp[j][k] = -(1 << 20);
for (int j = 0; j < i + 1; j++)
for (int k = 0; k < sb + 1; k++) {
dp[j][k] = max(dp[j][k], pd[j][k]);
dp[j + 1][k + b[i]] = max(dp[j + 1][k + b[i]], pd[j][k] + a[i]);
}
sa += a[i], sb += b[i];
}
int ret = 0;
for (int j = 0; j < n + 1; j++) {
for (int k = sa; k < sb + 1; k++)
if (dp[j][k] >= 0) {
ret = max(ret, dp[j][k]);
}
if (ret > 0) {
printf("%d %d\n", j, sa - ret);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, sum, all, a[105], b[105], f[105][105 * 105], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), sum += a[i];
for (int i = 1; i <= n; i++) scanf("%d", &b[i]), all += b[i];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= all; j++) f[i][j] = -1e9;
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = n; j; j--)
for (int k = all; k >= b[i]; k--)
f[j][k] = max(f[j][k], f[j - 1][k - b[i]] + a[i]);
for (int i = 1; i <= n; i++) {
ans = -1e9;
for (int j = sum; j <= all; j++) ans = max(ans, f[i][j]);
if (ans >= 0) {
printf("%d %d\n", i, sum - ans);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
const int N = 110;
int n, a[N], b[N], dp[N][N * N], pd[N][N * N];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i);
dp[0][0] = 0;
int sa = 0, sb = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++)
for (int k = 0; k <= sb; k++) pd[j][k] = dp[j][k];
for (int j = 0; j <= i; j++)
for (int k = 0; k <= sb + b[i]; k++) dp[j][k] = -(1 << 20);
for (int j = 0; j <= i; j++)
for (int k = 0; k <= sb; k++) {
dp[j][k] = max(dp[j][k], pd[j][k]);
dp[j + 1][k + b[i]] = max(dp[j + 1][k + b[i]], pd[j][k] + a[i]);
}
sa += a[i], sb += b[i];
}
int ret = 0;
for (int j = 0; j <= n; j++) {
for (int k = sa; k <= sb; k++) ret = max(ret, dp[j][k]);
if (ret > 0) {
printf("%d %d\n", j, sa - ret);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int get() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
const int N = 105;
int n, k, sum, now, f[N * N][N];
struct Bottle {
int a, b;
} t[N];
int main() {
n = get();
for (int i = 1; i <= n; i++) t[i].a = get(), sum += t[i].a;
for (int i = 1; i <= n; i++) t[i].b = get();
sort(t + 1, t + 1 + n, [](Bottle x, Bottle y) { return x.b > y.b; });
for (int i = 1; i <= n; i++) {
now += t[i].b;
if (now >= sum) {
k = i;
break;
}
}
memset(f, -0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = now; j >= t[i].b; j--)
for (int l = k; l >= 1; l--)
f[j][l] = max(f[j][l], f[j - t[i].b][l - 1] + t[i].a);
int ans = 0;
for (int i = sum; i <= now; i++) ans = max(ans, f[i][k]);
printf("%d %d\n", k, sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x *= f;
}
const int maxn = 110;
int n;
int tot, res, ans;
struct bottle {
int a, b;
friend bool operator<(bottle a, bottle b) { return a.b > b.b; }
} bt[maxn];
int f[maxn][maxn * maxn], mx;
inline void dp() {
memset(f, -12, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = mx; j >= bt[i].b; --j)
for (int k = 1; k <= res; ++k)
f[k][j] = max(f[k][j], f[k - 1][j - bt[i].b] + bt[i].a);
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(bt[i].a);
tot += bt[i].a;
}
for (int i = 1; i <= n; ++i) {
read(bt[i].b);
mx += bt[i].b;
}
sort(bt + 1, bt + n + 1);
ans = tot;
for (int i = 1; i <= n; ++i) {
if (tot > bt[i].b)
tot -= bt[i].b;
else {
res = i;
break;
}
}
dp();
int maxx = 0;
for (int i = ans; i <= mx; ++i) maxx = max(maxx, f[res][i]);
cout << res << ' ' << ans - maxx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int scan(int *buf_tar) {
char buf_c = 0;
bool is_rev = 0;
while (buf_c != '-' && (buf_c < '0' || buf_c > '9')) {
buf_c = getchar();
if (buf_c == EOF) return EOF;
}
if (buf_c == '-') is_rev = 1, buf_c = getchar();
*buf_tar = 0;
while (buf_c >= '0' && buf_c <= '9') {
*buf_tar *= 10;
*buf_tar += buf_c - '0';
buf_c = getchar();
}
if (is_rev) *buf_tar = -*buf_tar;
return 0;
}
int scan(long long *buf_tar) {
char buf_c = 0;
bool is_rev = 0;
while (buf_c != '-' && (buf_c < '0' || buf_c > '9')) {
buf_c = getchar();
if (buf_c == EOF) return EOF;
}
if (buf_c == '-') is_rev = 1, buf_c = getchar();
*buf_tar = 0;
while (buf_c >= '0' && buf_c <= '9') {
*buf_tar *= 10;
*buf_tar += buf_c - '0';
buf_c = getchar();
}
if (is_rev) *buf_tar = -*buf_tar;
return 0;
}
int n;
int a[110], b[110], sb[110];
int limit[110];
int f[110][10010];
inline bool cp(const int &, const int &);
int main() {
register int suma = 0, max_cnt, ans = 0;
scan(&n);
for (int i = 1; i <= n; ++i) {
scan(&a[i]);
suma += a[i];
}
for (int i = 1; i <= n; ++i) {
scan(&b[i]);
sb[i] = b[i];
}
sort(sb + 1, sb + 1 + n, cp);
for (int i = 1; i <= n; ++i) limit[i] = limit[i - 1] + sb[i];
for (int i = 1; i <= n; ++i)
if (limit[i] >= suma) {
printf("%d ", max_cnt = i);
break;
}
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = max_cnt; j; --j)
for (int t = limit[j - 1] + b[i]; t >= b[i]; --t)
if (f[j - 1][t - b[i]] >= 0)
f[j][t] = max(f[j][t], f[j - 1][t - b[i]] + a[i]);
}
for (int i = suma; i <= limit[max_cnt]; ++i) ans = max(ans, f[max_cnt][i]);
printf("%d\n", suma - ans);
return 0;
}
inline bool cp(const int &_a, const int &_b) { return _a > _b; }
|
#include <bits/stdc++.h>
using namespace std;
long long mem[101][10010], t[101][10010];
long long n, a[101], b[101], total;
long long dp(long long cur, long long ob) {
if (ob == 0) {
t[cur][ob] = 0;
return 0;
}
if (n == cur) {
t[cur][ob] = 999999;
return 200;
}
long long &ret = mem[cur][ob];
if (ret != -1) return ret;
long long cob, x;
if (ob < b[cur]) {
x = ob - a[cur];
cob = 0;
} else {
cob = ob - b[cur];
x = b[cur] - a[cur];
}
ret = 1 + dp(cur + 1, cob);
t[cur][ob] = x + t[cur + 1][cob];
if (ret == dp(cur + 1, ob)) {
t[cur][ob] = min(t[cur][ob], t[cur + 1][ob]);
} else if (ret > dp(cur + 1, ob)) {
ret = dp(cur + 1, ob);
t[cur][ob] = t[cur + 1][ob];
}
return ret;
}
int main() {
long long total = 0;
memset(mem, -1, sizeof(mem));
scanf("%lld", &n);
for (long long i = 0; i < n; i++) {
scanf("%lld", a + i);
total += a[i];
}
for (long long i = 0; i < n; i++) scanf("%lld", b + i);
cout << dp(0, total);
printf(" ");
cout << t[0][total] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int ra() {
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;
}
int a[100005], b[100005];
int f[100005], size[100005];
int main() {
int n = ra(), sum = 0, tot = 0;
memset(size, 0x7, sizeof(size));
size[0] = 0;
for (int i = 1; i <= n; i++) a[i] = ra(), sum += a[i];
for (int i = 1; i <= n; i++) b[i] = ra(), tot += b[i];
for (int i = 1; i <= n; i++)
for (int j = tot; j >= 0; j--) {
if (size[j] + 1 == size[j + b[i]])
f[j + b[i]] = max(f[j + b[i]], f[j] + a[i]);
if (size[j] + 1 < size[j + b[i]]) {
size[j + b[i]] = size[j] + 1;
f[j + b[i]] = f[j] + a[i];
}
}
int anssz = 0x3f3f3f3f, ans;
for (int i = sum; i <= tot; i++) {
if (anssz == size[i]) ans = max(ans, f[i]);
if (anssz > size[i]) {
anssz = size[i];
ans = f[i];
}
}
printf("%d %d", anssz, sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, f[105][10005];
int sum1 = 0, sum2 = 0;
int ans1 = 0, ans2 = -1;
struct node {
int w;
int v;
} a[105];
int cmp(node a, node b) { return a.v > b.v; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].w;
sum1 += a[i].w;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].v;
sum2 += a[i].v;
}
memset(f, 0xff, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = n; j >= 1; j--) {
for (int k = sum2; k >= a[i].v; k--) {
if (f[j - 1][k - a[i].v] != -1) {
f[j][k] = max(f[j][k], f[j - 1][k - a[i].v] + a[i].w);
}
}
}
}
ans2 = -1;
for (int j = 1; j <= n; j++) {
for (int k = sum1; k <= sum2; k++) ans2 = max(ans2, f[j][k]);
if (ans2 != -1) {
cout << j << ' ' << sum1 - ans2 << endl;
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 10, M = 2e4 + 10;
int dp[M][N], a[N], b[N];
int main() {
int n, sum = 0, mx = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
mx += b[i];
}
mx += sum;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= mx + 2; j++) dp[j][i] = -1e9;
for (int i = 0; i <= n; i++) dp[0][i] = 0;
for (int i = 0; i < n; i++) {
for (int j = mx; j >= 0; j--) {
if (j - b[i] < 0) break;
for (int k = 1; k <= n; k++) {
if (dp[j - b[i]][k - 1] >= 0)
dp[j][k] = max(dp[j][k], dp[j - b[i]][k - 1] + a[i]);
}
}
}
for (int i = mx; i >= 0; i--)
for (int j = 0; j <= n; j++) dp[i][j] = max(dp[i][j], dp[i + 1][j]);
for (int i = 0; i <= n; i++)
if (dp[sum][i] >= 0) {
cout << i << " " << sum - dp[sum][i] << "\n";
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[110], b[110], sum = 0;
pair<int, int> dp[110][11000], q = {-1, -1};
pair<int, int> Rec(int i, int W) {
if (i == n) {
if (W >= sum)
return {0, 0};
else
return {1e9, 1e9};
}
if (dp[i][W] != q) return dp[i][W];
pair<int, int> Res1 = {1e9, 1e9}, Res2 = {1e9, 1e9};
Res1 = {0 + Rec(i + 1, W).first, a[i] + Rec(i + 1, W).second};
Res2 = {1 + Rec(i + 1, W + b[i]).first, 0 + Rec(i + 1, W + b[i]).second};
return dp[i][W] = min(Res1, Res2);
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i], sum += a[i];
for (int i = 0; i < n; i++) cin >> b[i];
cout << Rec(0, 0).first << " " << Rec(0, 0).second;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e4 + 10;
struct Bottle {
int v, n;
} a[110];
int DP[110][MAX];
int main() {
int n, sum_n = 0, sum_v = 0, maxx = 0, num = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].n);
sum_n += a[i].n;
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].v);
sum_v += a[i].v;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j; j--)
for (int k = sum_v; k >= a[i].v; k--)
if (DP[j - 1][k - a[i].v] || k == a[i].v)
DP[j][k] = max(DP[j][k], DP[j - 1][k - a[i].v] + a[i].n);
for (int i = 1; i <= n; i++) {
for (int j = sum_n; j <= sum_v; j++)
if (DP[i][j] > maxx) {
maxx = DP[i][j];
num = i;
}
if (maxx != 0) break;
}
printf("%d %d\n", num, sum_n - maxx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M, ansx, ansy, Max, now, pre;
int f[2][110][10010];
class rec {
public:
int v, r;
} P[110];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &P[i].r);
for (int i = 1; i <= N; i++) scanf("%d", &P[i].v);
Max = 0;
pre = 1;
now = 0;
memset(f[now], 230, sizeof(f[now]));
f[now][0][0] = 0;
for (int i = 1; i <= N; i++) {
swap(now, pre);
memset(f[now], 230, sizeof(f[now]));
for (int j = 0; j < i; j++)
for (int k = 0; k <= Max; k++)
if (f[pre][j][k] > -1e8) {
f[now][j][k + P[i].r] =
max(f[now][j][k + P[i].r], f[pre][j][k] - P[i].r);
f[now][j + 1][k] =
max(f[now][j + 1][k], f[pre][j][k] + P[i].v - P[i].r);
}
Max += P[i].v;
}
ansx = -1;
for (int j = 0; j <= N && ansx == -1; j++)
for (int k = 0; k <= Max; k++)
if (f[now][j][k] >= 0) {
ansx = j;
ansy = k;
break;
}
printf("%d %d\n", ansx, ansy);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct bot {
int a, b;
} a[110];
int n, f[10100][105], suma, sumb, kk;
bool cmp(bot a, bot b) { return a.b > b.b; }
int main() {
memset(f, -0x3f, sizeof(f));
f[0][0] = 0;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].a);
suma += a[i].a;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].b);
}
sort(a + 1, a + n + 1, cmp);
while (sumb < suma) {
sumb += a[++kk].b;
}
printf("%d ", kk);
for (int i = 1; i <= n; ++i) {
for (int j = sumb; j >= a[i].b; --j) {
for (int k = 1; k <= kk; ++k) {
f[j][k] = max(f[j][k], f[j - a[i].b][k - 1] + a[i].a);
}
}
}
int ans = 0;
for (int i = suma; i <= sumb; ++i) {
ans = max(ans, f[i][kk]);
}
printf("%d", suma - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
const int N = 105;
int a[N], b[N];
int dp[N][N * N];
int main() {
int n;
scanf("%i", &n);
for (int i = 1; i <= n; i++) scanf("%i", &a[i]);
for (int i = 1; i <= n; i++) scanf("%i", &b[i]);
for (int i = 0; i <= n; i++)
for (int j = 0; j < N * N; j++) dp[i][j] = -inf;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
for (int k = b[i]; k < N * N; k++) {
dp[j][k] = max(dp[j][k], dp[j - 1][k - b[i]] + a[i]);
}
}
}
int sumA = 0;
for (int i = 1; i <= n; i++) sumA += a[i];
int ans = n + 1, ret = 0;
for (int i = 1; i <= n; i++) {
for (int k = sumA; k < N * N; k++) {
if (dp[i][k] > 0) {
if (ans > i || ans == i && ret > sumA - dp[i][k]) {
ans = i;
ret = sumA - dp[i][k];
}
}
}
}
printf("%i %i\n", ans, ret);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.141592653589793238462643383279;
const long double EPS = 1e-7;
const long long INF = 1e9 + 7;
const long long MOD = INF;
const long long maxn = 2e5 + 1;
int a[101];
int b[101];
pair<int, int> dp[101][20001];
bool used[101][20001];
pair<int, int> calc(int i, int capac) {
if (!i) {
if (capac <= 10000) return make_pair(0, 0);
return make_pair(1e9, 0);
}
if (used[i][capac]) return dp[i][capac];
used[i][capac] = true;
pair<int, int> p1, p2;
p1 = calc(i - 1, capac - (b[i] - a[i]));
p1.first += 1;
p2 = calc(i - 1, capac + a[i]);
p2.second += a[i];
return dp[i][capac] = min(p1, p2);
}
int main() {
int n;
cin >> n;
for (long long i = 1; i < n + 1; ++i) cin >> a[i];
for (long long i = 1; i < n + 1; ++i) cin >> b[i];
pair<int, int> res = calc(n, 10000);
cout << res.first << " " << res.second;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> dp[20001];
pair<int, int> dp_copy[20001];
int a[100];
int b[100];
void copy_dp() {
for (int i = -10000; i <= 10000; i++) {
dp_copy[i + 10000] = dp[i + 10000];
dp[i + 10000] = make_pair(1e9, 1e9);
}
}
int main() {
int n;
scanf("%d", &n);
int t;
for (int i = 0; i < n; i++) scanf("%d", &t), a[i] = t;
for (int i = 0; i < n; i++) scanf("%d", &t), b[i] = t;
copy_dp();
dp[0 + 10000] = make_pair(0, 0);
for (int i = 0; i < n; i++) {
copy_dp();
for (int j = -10000 + a[i]; j <= 10000; j++)
dp[j - a[i] + 10000] = min(dp[j - a[i] + 10000],
make_pair(dp_copy[j + 10000].first,
dp_copy[j + 10000].second + a[i]));
for (int j = -10000; j <= 10000; j++)
dp[j + b[i] - a[i] + 10000] = min(
dp[j + b[i] - a[i] + 10000],
make_pair(dp_copy[j + 10000].first + 1, dp_copy[j + 10000].second));
}
pair<int, int> res_min = make_pair(1e9, 1e9);
for (int i = 0; i <= 10000; i++) res_min = min(dp[i + 10000], res_min);
printf("%d %d\n", res_min.first, res_min.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} A[105];
int dp[10005][105];
bool cmp(node h, node g) { return h.y > g.y; }
bool cmm(node h, node g) { return h.x > g.x; }
int main() {
int n, m, i, j, sum = 0, cnt = 0, ans = 0, q, ans2 = 0;
cin >> n;
for (i = 1; i <= n; i++) {
scanf("%d", &A[i].x);
sum += A[i].x;
}
for (i = 1; i <= n; i++) {
scanf("%d", &A[i].y);
}
sort(A + 1, A + n + 1, cmp);
for (i = 1; i < n; i++) {
cnt += A[i].y;
if (cnt >= sum) break;
}
int k = i;
for (i = i + 1; i <= n; i++) {
ans += A[i].x;
}
sort(A + 1, A + n + 1, cmm);
for (i = 0; i <= 10000; i++) {
for (j = 0; j <= 100; j++) {
dp[i][j] = -1;
}
}
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = k - 1; j >= 0; j--) {
for (q = cnt; q >= 0; q--) {
if (q + A[i].y > cnt) continue;
if (dp[q][j] != -1) {
dp[q + A[i].y][j + 1] = max(dp[q + A[i].y][j + 1], dp[q][j] + A[i].x);
}
}
}
}
for (i = sum; i <= cnt; i++) {
if (sum - dp[i][k] < ans) {
ans = sum - dp[i][k];
}
}
printf("%d %d", k, ans);
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;
}
struct FFTCoeffTable {
static const int logn = 10, n = 1 << logn;
complex<double> coeffs[n];
FFTCoeffTable() {
const double PI = 3.141592653589793238462643383279L;
for (int i = 0; i < n; ++i) {
double theta = 2 * PI * i / n;
coeffs[i] = complex<double>(cos(theta), sin(theta));
}
}
} fftCoeffTable;
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 logm = 1; logm <= logn; ++logm) {
int winc = (1 << (fftCoeffTable.logn - logm)) * sign;
if (winc < 0) winc += fftCoeffTable.n;
int h = 1 << (logm - 1);
for (int i = 0; i < n; i += 1 << logm) {
int wk = 0;
for (int j = i; j < i + h; ++j) {
const complex<double> &w = fftCoeffTable.coeffs[wk];
int k = j + h;
double lr = x[k].real() * w.real() - x[k].imag() * w.imag();
double li = x[k].real() * w.imag() + x[k].imag() * w.real();
x[k] = complex<double>(x[j].real() - lr, x[j].imag() - li);
x[j] = complex<double>(x[j].real() + lr, x[j].imag() + li);
if ((wk += winc) >= fftCoeffTable.n) wk -= fftCoeffTable.n;
}
}
}
}
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<int>> matches(tH, vector<int>(tW, 0));
for (int a = 0; a < 26; a += 2) {
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];
int x = c == 'a' + a, y = c == 'a' + (a + 1);
A[tH + pH - 1 - i][tW + pW - 1 - j] = complex<double>(x, y);
}
for (int(i) = 0; (i) < (int)(pH); ++(i))
for (int(j) = 0; (j) < (int)(pW); ++(j)) {
char c = pattern[i][j];
int x = c == 'a' + a, y = c == 'a' + (a + 1);
B[i][j] = complex<double>(x, -y);
}
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);
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];
matches[i][j] += (int)round(r.real());
}
}
int qs = 0;
for (int(i) = 0; (i) < (int)(pH); ++(i))
for (int(j) = 0; (j) < (int)(pW); ++(j)) qs += pattern[i][j] == '?';
for (int(i) = 0; (i) < (int)(tH); ++(i))
for (int(j) = 0; (j) < (int)(tW); ++(j)) matches[i][j] += qs;
vector<string> ans(tH, string(tW, '?'));
for (int(i) = 0; (i) < (int)(tH); ++(i))
for (int(j) = 0; (j) < (int)(tW); ++(j))
ans[i][j] = matches[i][j] == pH * pW ? '1' : '0';
for (int(i) = 0; (i) < (int)(tH); ++(i)) puts(ans[i].c_str());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 800 + 10;
int n, m, r, c, N, M;
char P[Maxn][Maxn], T[Maxn][Maxn];
bitset<Maxn> R[Maxn], G[26][Maxn];
bitset<Maxn> calc(const bitset<Maxn>& b, int len, int l) {
return (b >> l) | (b << (len - l));
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", P[i]);
scanf("%d%d", &r, &c);
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++) P[i][j] = P[i % n][j % m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) R[i].set(j);
for (int ch = 0; ch < 26; ch++)
for (int i = 0; i < n + r; i++)
for (int j = 0; j < m + c; j++)
if (P[i][j] == ch + 'a') G[ch][i].set(j);
for (int x = 0; x < r; x++)
for (int y = 0; y < c; y++) {
if (T[x][y] == '?') continue;
for (int k = 0; k < n; k++)
R[k] = R[k] & calc(G[T[x][y] - 'a'][(k + x) % n], m, y);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) putchar(R[i][j] + '0');
putchar('\n');
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 404;
const int Maxm = 3 * Maxn;
int n, m;
char A[Maxn][Maxn];
int r, c;
char B[Maxn][Maxn];
char str[Maxm];
int slen;
int Z[Maxm];
int res[Maxn][Maxn];
bool Eq(char a, char b) { return a == '?' || a == b; }
void Match(int bin, int ain) {
slen = 0;
for (int j = 0; j < c; j++) str[slen++] = B[bin][j];
int nd = m + c - 1;
for (int j = 0; j < nd; j++) str[slen++] = A[ain][j % m];
fill(Z, Z + slen, 0);
int L = -1, R = -1;
for (int i = 1; i < slen; i++) {
if (i <= R) Z[i] = min(R - i, Z[i - L]);
while (i + Z[i] < slen && Eq(str[Z[i]], str[i + Z[i]])) Z[i]++;
if (Z[i] >= c && i >= c) res[(ain - bin % n + n) % n][i - c]++;
if (i + Z[i] - 1 > R) {
L = i;
R = i + Z[i] - 1;
}
}
}
int main() {
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", B[i]);
for (int i = 0; i < n; i++)
for (int j = 0; j < r; j++) Match(j, i);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d", res[i][j] >= r);
printf("\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 int MX = 405;
int n, m, r, c;
bitset<MX> bs[26][MX], res[MX];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < int(n); i++)
for (int j = 0; j < int(m); j++) {
char c;
cin >> c;
bs[c - 'a'][i][j] = 1;
res[i][j] = 1;
}
cin >> r >> c;
for (int i = 0; i < int(r); i++)
for (int j = 0; j < int(c); j++) {
char h;
cin >> h;
if (h != '?') {
int oy = ((((-j) % (m)) + (m)) % (m));
for (int k = 0; k < n; k++)
res[((((k - i) % (n)) + (n)) % (n))] &=
(bs[h - 'a'][k] << oy) | (bs[h - 'a'][k] >> (m - oy));
}
}
for (int i = 0; i < int(n); i++) {
for (int j = 0; j < int(m); j++) cout << int(res[i][j]);
cout << '\n';
}
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;
};
map<double, cp> DD;
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 cp Get(double x) { return DD.count(x) ? DD[x] : DD[x] = get(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, k; j < n; j++) {
if (i < j) swap(a[i], a[j]);
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 double EPS = 0.00001;
void fft(vector<complex<double>> &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 * acos(-1) / len * (invert ? -1 : 1);
complex<double> wlen(cos(ang), sin(ang));
for (int i = 0; i < n; i += len) {
complex<double> w(1);
for (int j = 0; j < len / 2; j++) {
complex<double> 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 (int i = 0; i < n; i++) a[i] /= n;
}
}
void multiply(const vector<int> &a, const vector<int> &b, vector<int> &res) {
vector<complex<double>> fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < max(a.size(), b.size())) n <<= 1;
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);
res.resize(n);
for (int i = 0; i < n; i++)
res[i] = int(fa[i].real() + (fa[i].real() > 0 ? 0.5 : -0.5));
}
void multiply_complex(const vector<complex<double>> &a,
const vector<complex<double>> &b,
vector<complex<double>> &res) {
vector<complex<double>> fa(a.begin(), a.end()), fb(b.begin(), b.end());
int n = 1;
while (n < max(a.size(), b.size())) n <<= 1;
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);
res.resize(n);
for (int i = 0; i < n; i++) res[i] = fa[i];
}
const int MAXN = 405;
const int LOGN = 19;
string S[MAXN], T[MAXN];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) cin >> S[i];
int r, c;
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) cin >> T[i];
int p = 1, q = 1;
while (q < m + c) q <<= 1;
while (p < n + r) p <<= 1;
vector<vector<complex<double>>> a(p, vector<complex<double>>(q)),
b(p, vector<complex<double>>(q));
for (int i = 0; i < p; i++) {
for (int j = 0; j < q; j++) {
int t = S[i % n][j % m] - 'a';
double ang = 2 * acos(-1) * t / 26;
a[i][j] = complex<double>(cos(ang), sin(ang));
}
}
int cnt = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (T[i][j] != '?') {
cnt++;
int t = T[i][j] - 'a';
double ang = 2 * acos(-1) * t / 26;
b[(r - 1) - i][(c - 1) - j] = complex<double>(cos(-ang), sin(-ang));
}
}
}
vector<vector<complex<double>>> fa, fb, res;
for (int i = 0; i < p; i++) {
vector<complex<double>> ta(a[i].begin(), a[i].end()),
tb(b[i].begin(), b[i].end());
fft(ta, false);
fft(tb, false);
fa.push_back(ta);
fb.push_back(tb);
}
for (int j = 0; j < q; j++) {
vector<complex<double>> ta(p), tb(p), tmp;
for (int i = 0; i < p; i++) {
ta[i] = fa[i][j];
tb[i] = fb[i][j];
}
multiply_complex(ta, tb, tmp);
if (j == 0) res.resize(tmp.size(), vector<complex<double>>(q));
for (int i = 0; i < res.size(); i++) res[i][j] = tmp[i];
}
for (int i = 0; i < res.size(); i++) fft(res[i], true);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (abs(res[i + r - 1][j + c - 1].real() - cnt) < EPS &&
abs(res[i + r - 1][j + c - 1].imag()) < EPS)
printf("1");
else
printf("0");
}
printf("\n");
}
}
|
#include <bits/stdc++.h>
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...);
}
struct FFT_2D {
struct node {
double x, y;
node() {}
node(double a, double b) : x(a), y(b) {}
node operator+(const node &a) const {
return node(this->x + a.x, this->y + a.y);
}
node operator-(const node a) const {
return node(this->x - a.x, this->y - a.y);
}
node operator*(const node a) const {
return node(this->x * a.x - this->y * a.y, this->x * a.y + a.x * this->y);
}
};
int M[2];
vector<vector<node>> A, B;
vector<node> w[2][2];
vector<int> rev[2];
long double pi;
FFT_2D() { pi = 3.1415926535897932384; }
void init(int n, int m) {
M[0] = 1, M[1] = 1;
while (M[0] < n) M[0] <<= 1;
M[0] <<= 1;
while (M[1] < m) M[1] <<= 1;
M[1] <<= 1;
A.resize(M[0], vector<node>(M[1]));
B.resize(M[0], vector<node>(M[1]));
for (int z = 0; z < 2; ++z) {
w[z][0].resize(M[z]);
w[z][1].resize(M[z]);
rev[z].resize(M[z]);
for (int i = 0; i < M[z]; i++) {
int j = i, y = 0;
for (int x = 1; x < M[z]; x <<= 1, j >>= 1) (y <<= 1) += j & 1;
rev[z][i] = y;
}
for (int i = 0; i < M[z]; i++) {
w[z][0][i] = node(cos(2 * pi * i / M[z]), sin(2 * pi * i / M[z]));
w[z][1][i] = node(cos(2 * pi * i / M[z]), -sin(2 * pi * i / M[z]));
}
}
}
void ftransform_2D(vector<vector<node>> &A, int p) {
for (int z = 0; z < M[0]; z++) {
for (int i = 0; i < M[1]; i++)
if (i < rev[1][i]) swap(A[z][i], A[z][rev[1][i]]);
for (int i = 1; i < M[1]; i <<= 1)
for (int j = 0, t = M[1] / (i << 1); j < M[1]; j += i << 1)
for (int k = 0, l = 0; k < i; k++, l += t) {
node x = A[z][i + j + k] * w[1][p][l];
node y = A[z][j + k];
A[z][j + k] = y + x;
A[z][j + k + i] = y - x;
}
}
for (int z = 0; z < M[1]; z++) {
for (int i = 0; i < M[0]; i++)
if (i < rev[0][i]) swap(A[i][z], A[rev[0][i]][z]);
for (int i = 1; i < M[0]; i <<= 1)
for (int j = 0, t = M[0] / (i << 1); j < M[0]; j += i << 1)
for (int k = 0, l = 0; k < i; k++, l += t) {
node x = w[0][p][l] * A[i + j + k][z];
node y = A[j + k][z];
A[j + k][z] = y + x;
A[j + k + i][z] = y - x;
}
}
if (p) {
for (int i = 0; i < M[0]; i++) {
for (int j = 0; j < M[1]; ++j) {
A[i][j].x /= M[0] * M[1];
}
}
}
}
void multiply_2D(vector<vector<long long>> &P, vector<vector<long long>> &Q,
vector<vector<long long>> &res) {
init(max(P.size(), Q.size()), max(P[0].size(), Q[0].size()));
for (int i = 0; i < M[0]; i++)
for (int j = 0; j < M[1]; j++)
A[i][j].x = A[i][j].y = B[i][j].x = B[i][j].y = 0;
for (int i = 0; i < P.size(); i++)
for (int j = 0; j < P[i].size(); j++) A[i][j].x = P[i][j];
for (int i = 0; i < Q.size(); i++)
for (int j = 0; j < Q[i].size(); j++) B[i][j].x = Q[i][j];
ftransform_2D(A, 0);
ftransform_2D(B, 0);
for (int i = 0; i < M[0]; i++)
for (int j = 0; j < M[1]; j++) A[i][j] = A[i][j] * B[i][j];
ftransform_2D(A, 1);
res.resize(M[0], vector<long long>(M[1]));
for (int i = 0; i < M[0]; i++)
for (int j = 0; j < M[1]; j++) res[i][j] = round(A[i][j].x);
}
} fft_2D;
string t[805], p[805];
vector<string> vec;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> t[i];
vec.resize(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
vec[i].push_back('0');
}
}
int r, c;
cin >> r >> c;
for (int i = 0; i < r; ++i) cin >> p[i];
for (int i = n; i < n + r; ++i) {
t[i] = t[i % n];
}
n = n + r;
for (int i = 0; i < n; ++i) {
string temp = t[i];
while (t[i].size() < m + c) t[i] += temp;
}
m = t[0].size();
vector<vector<long long>> a(n, vector<long long>(m)),
b(r, vector<long long>(c)), store, ans(n + r, vector<long long>(m + c));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = t[i][j] - 'a' + 1;
a[i][j] = num * num * num;
if (t[i][j] == '?') a[i][j] = 0;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
int num = p[i][j] - 'a' + 1;
b[r - i - 1][c - j - 1] = num;
if (p[i][j] == '?') b[r - i - 1][c - j - 1] = 0;
}
}
fft_2D.multiply_2D(a, b, store);
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
ans[i][j] = store[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = t[i][j] - 'a' + 1;
a[i][j] = 2 * num * num;
if (t[i][j] == '?') a[i][j] = 0;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
int num = p[i][j] - 'a' + 1;
b[r - i - 1][c - j - 1] = num * num;
if (p[i][j] == '?') b[r - i - 1][c - j - 1] = 0;
}
}
fft_2D.multiply_2D(a, b, store);
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
ans[i][j] -= store[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = t[i][j] - 'a' + 1;
a[i][j] = num;
if (t[i][j] == '?') a[i][j] = 0;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
int num = p[i][j] - 'a' + 1;
b[r - i - 1][c - j - 1] = num * num * num;
if (p[i][j] == '?') b[r - i - 1][c - j - 1] = 0;
}
}
fft_2D.multiply_2D(a, b, store);
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
ans[i][j] += store[i][j];
}
}
for (int i1 = 0, i2 = r - 1; i2 < n; ++i2, ++i1) {
for (int j1 = 0, j2 = c - 1; j2 < m; ++j1, ++j2) {
if (i1 == vec.size() || j1 == vec[0].size()) break;
if (ans[i2][j2] == 0) vec[i1][j1] = '1';
}
}
for (int i = 0; i < vec.size(); ++i) cout << vec[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)404;
const int ALPHA = 26;
bitset<N> b[ALPHA][N];
char a[N][N];
bitset<N> ans[N];
bitset<N> get(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++) {
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++) {
ans[i] = ~ans[i];
}
for (int i = 0; i < r; i++) {
scanf("%s", a[i]);
for (int j = 0; j < c; j++) {
if (a[i][j] == '?') continue;
int c = a[i][j] - 'a', xx = (((-i) % n) + n) % n,
yy = (((j) % m) + m) % m;
for (int x = 0; x < n; x++) {
int nx = (x + xx);
if (nx >= n) nx -= n;
ans[nx] &= get(b[c][x], m, yy);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
putchar(ans[i][j] ? '1' : '0');
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 5;
const int M = 805;
const double PI = acos(-1.0);
int n, m, nn, mm, r, c, id[M][M], ans[M][M];
char s1[M][M], s2[M][M];
struct Complex {
double real, imag;
Complex() {}
Complex(double real_, double imag_) : real(real_), imag(imag_) {}
friend inline Complex operator+(const Complex &lhs, const Complex &rhs) {
return Complex(lhs.real + rhs.real, lhs.imag + rhs.imag);
}
friend inline Complex operator-(const Complex &lhs, const Complex &rhs) {
return Complex(lhs.real - rhs.real, lhs.imag - rhs.imag);
}
friend inline Complex operator*(const Complex &lhs, const Complex &rhs) {
return Complex(lhs.real * rhs.real - lhs.imag * rhs.imag,
lhs.real * rhs.imag + lhs.imag * rhs.real);
}
};
void FFT(Complex *a, int n, int rev) {
for (int i = 0, j = 0; i < n; ++i) {
if (i > j) swap(a[i], a[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int i = 2; i <= n; i <<= 1) {
int m = i >> 1;
Complex g(cos(PI / m), rev * sin(PI / m));
for (int j = 0; j < n; j += i) {
Complex w(1.0, 0.0);
for (int k = 0; k != m; k++) {
Complex z = a[j + m + k] * w;
a[j + m + k] = a[j + k] - z;
a[j + k] = a[j + k] + z;
w = w * g;
}
}
}
if (rev == -1) {
for (int i = 0; i < n; i++) a[i].real /= n;
}
}
int tot, len, T[N], P[N], T2[N], P2[N], TT[N], PP[N];
Complex A[N], B[N];
inline void cal(int *a, int *b, int c) {
for (int i = 0; i < tot; i++) {
if (i > tot - i) break;
swap(b[i], b[tot - i]);
}
for (int i = 0; i < len; i++)
A[i] = Complex(a[i], 0), B[i] = Complex(b[i], 0);
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 < nn; i++)
for (int j = 0; j < mm; j++)
ans[i][j] += c * (int)(A[id[i][j] + tot].real + 0.5);
}
void solve() {
tot = n * m;
len = 1;
while (len < 2 * tot) len <<= 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
T[id[i][j]] = s1[i][j] - 'a' + 1;
P[id[i][j]] = s2[i][j] - 'a' + 1;
}
}
for (int i = 0; i < tot; i++) {
T2[i] = T[i] * T[i];
P2[i] = P[i] * P[i];
TT[i] = (T[i] != 0);
PP[i] = (P[i] != 0);
}
cal(T2, PP, 1);
cal(T, P, -2);
cal(TT, P2, 1);
}
int main() {
scanf("%d%d", &nn, &mm);
for (int i = 0; i < nn; i++) scanf("%s", s1[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", s2[i]);
n = nn;
m = mm;
for (int i = 0; i < n; i++)
for (int j = m; j < m + c; j++) s1[i][j] = s1[i][j % m];
m += c - 1;
for (int i = 0; i < m; i++)
for (int j = n; j < n + r; j++) s1[j][i] = s1[j % n][i];
n += r - 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) id[i][j] = i * m + j;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (i >= r || j >= c || s2[i][j] == '?') s2[i][j] = 'a' - 1;
solve();
for (int i = 0; i < nn; i++) {
for (int j = 0; j < mm; j++)
if (ans[i][j] == 0)
printf("1");
else
printf("0");
printf("\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
bitset<N> b[26][N];
bitset<N> res[N];
char p[N][N];
bitset<N> cyclic_shift_right(const bitset<N> &b, int len, int shift) {
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++) {
char s[N];
scanf("%s", s);
for (int j = 0; j < m; j++) {
b[s[j] - 'a'][i][j] = true;
}
}
scanf("%d %d", &r, &c);
for (int i = 0; i < n; i++) res[i] = ~res[i];
for (int i = 0; i < r; i++) {
scanf("%s", p[i]);
for (int j = 0; j < c; j++) {
if (p[i][j] == '?') continue;
int a = p[i][j] - 'a';
int dx = (-i % n + n) % n, dy = (j % m + m) % m;
for (int x = 0; x < n; x++) {
int nx = (x + dx) % n;
res[nx] &= cyclic_shift_right(b[a][x], m, dy);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
putchar(res[i][j] ? '1' : '0');
}
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<400> iseq[26][400];
bitset<400> sol[400];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, r, c, i, j, k;
char ch;
cin >> n >> m;
for (i = 0; i < n; ++i) {
sol[i].flip();
for (j = 0; j < m; ++j) {
cin >> ch;
iseq[ch - 'a'][i].set(j);
}
}
cin >> r >> c;
for (i = 0; i < r; ++i)
for (j = 0; j < c; ++j) {
cin >> ch;
if (ch == '?') continue;
for (k = 0; k < n; ++k) {
sol[k] &= iseq[ch - 'a'][(k + i) % n] >> j % m |
iseq[ch - 'a'][(k + i) % n] << (m - j % m);
}
}
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) cout << sol[i][j];
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
char mat[405][405], pat[405][405];
bitset<405> ans[405], G[30][405];
int main() {
int n, m, r, c;
scanf("%d%d", &n, &m);
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>
namespace IO {
const int SIZE = (1 << 20) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = obuf + SIZE - 1;
char _st[55];
int _qr = 0;
inline char gc() {
return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++) : *iS++);
}
inline void qread() {}
template <class T1, class... T2>
inline void qread(T1 &IEE, T2 &...ls) {
register T1 __ = 0, ___ = 1;
register char ch;
while (!isdigit(ch = gc())) ___ = (ch == '-') ? -___ : ___;
do {
__ = (__ << 1) + (__ << 3) + (ch ^ 48);
} while (isdigit(ch = gc()));
__ *= ___;
IEE = __;
qread(ls...);
return;
}
template <class T>
inline void QreadArr(T Begin, T End) {
while (Begin != End) {
qread(*Begin);
++Begin;
}
}
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
return;
}
inline void putc_(char _x) {
*oS++ = _x;
if (oS == oT) flush();
}
inline void qwrite() {}
template <class T1, class... T2>
inline void qwrite(T1 IEE, T2... ls) {
if (!IEE) putc_('0');
if (IEE < 0) putc_('-'), IEE = -IEE;
while (IEE) _st[++_qr] = IEE % 10 + '0', IEE /= 10;
while (_qr) putc_(_st[_qr--]);
qwrite(ls...);
return;
}
template <class T>
inline void WriteArr(T Begin, T End) {
const char Kg = ' ', Edl = '\n';
while (Begin != End) {
qwrite(*Begin);
++Begin;
putc_(Kg);
}
putc_(Edl);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher;
} // namespace IO
using namespace IO;
using namespace std;
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());
long long My_Rand(long long Mod) { return (unsigned long long)(rnd()) % Mod; }
template <class T1, class T2>
void Min(const T1 x, const T2 y) {
return x > y ? y : x;
}
template <class T1, class T2>
void Max(const T1 x, const T2 y) {
return x > y ? x : y;
}
template <class T1, class T2>
void To_max(T1 &x, const T2 y) {
x < y ? x = y : x = x;
}
template <class T1, class T2>
void To_min(T1 &x, const T2 y) {
x > y ? x = y : x = x;
}
inline long long qpow(long long n, long long base, long long mod = 1e18) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * base % mod;
base = base * base % mod;
n >>= 1;
}
return ret % mod;
}
inline long long gcd(long long x, long long y) {
return !y ? x : gcd(y, x % y);
}
inline long long lcm(long long x, long long y) { return x / gcd(x, y) * y; }
const int N = 405;
int n, m, r, c;
bitset<N> bst[30][N], ans[N];
int main() {
cin >> 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;
bst[ch - 'a' + 1][i][j] = true;
}
}
cin >> r >> c;
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
char ch;
scanf(" %c", &ch);
if (ch != '?') {
for (int k = 0; k < n; ++k) {
ans[((k + n) - (i % n)) % n] &=
(bst[ch - 'a' + 1][k] >> (j % m) | bst[ch - 'a' + 1][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;
int n, m, r, c;
char s[404][404], t[404][404];
bitset<404> ok[26][404], res[404];
bitset<404> bs(bitset<404> ini, int cyclen, int mov) {
return ((ini << 1) >> mov + 1) | (ini << cyclen - mov);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (n); i++) scanf(" %s", s[i] + 1);
scanf("%d %d", &r, &c);
for (int i = (1); i <= (r); i++) scanf(" %s", t[i] + 1);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) ok[s[i][j] - 'a'][i][j] = true;
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (m); j++) res[i][j] = true;
for (int i = (1); i <= (r); i++)
for (int j = (1); j <= (c); j++) {
char cur = t[i][j];
if (cur == '?') continue;
for (int k = (1); k <= (n); k++) {
int R = (k - i + 1) % n + n;
if (R > n) R -= n;
res[R] &= bs(ok[cur - 'a'][k], m, (j - 1) % m);
}
}
for (int i = (1); i <= (n); i++) {
for (int j = (1); j <= (m); j++) {
if (res[i][j])
printf("1");
else
printf("0");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 405, B = 60;
char c[MAXN][MAXN], mat[MAXN][MAXN];
long long red[MAXN][MAXN][7], bit[MAXN][26][7];
void setbit(int x, int y, int s) { bit[x][s][y / B] |= 1LL << (y % B); }
bool calc(int qr, int j, int i) {
if ((1LL << (i % B)) & red[qr][j][i / B]) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
cin >> c[i][j];
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
for (int s = 0; s < 26; ++s) {
if (c[i][j] - 'a' == s) setbit(j, i, s);
}
int r, s;
cin >> r >> s;
for (int i = 0; i < r; ++i)
for (int j = 0; j < s; ++j) {
cin >> mat[i][j];
}
for (int redak = 0; redak < r; ++redak)
for (int j = 0; j < m; ++j) {
for (int i = 0; i < 7; ++i) red[redak][j][i] = (long long)(1LL << 60) - 1;
for (int stupac = 0; stupac < s; ++stupac) {
if (mat[redak][stupac] == '?') continue;
for (int i = 0; i < 7; ++i) {
red[redak][j][i] &=
bit[(j + stupac) % m][mat[redak][stupac] - 'a'][i];
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
bool mogu = true;
for (int redak = 0; redak < r; ++redak) {
mogu &= calc(redak, j, (i + redak) % n);
}
cout << mogu;
}
cout << endl;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1073741824")
#pragma warning(disable : 4996)
using namespace std;
const int N = 410, D = 26;
char s[N][N], t[N][N];
bitset<N> ans[N], g[D][N];
int main() {
int n, m, r, c;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf(" %s", s[i]);
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf(" %s", t[i]);
for (int i = 0; i < n; i++) ans[i].set();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < D; k++) {
if (s[i][j] == k + 'a') g[k][i][j] = 1;
}
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char a = t[i][j];
if (a == '?') continue;
a -= 'a';
for (int k = 0; k < n; k++) {
int h = (k + i) % n;
ans[k] &= ((g[a][h] >> j % m) | (g[a][h] << (m - 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;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(int a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(int a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
const int N = 405;
char a[N][N], b[N][N];
int n, m, r, c;
bitset<N> ans[N][N];
bitset<N> t1[26], t2;
void kmp(char a[], char b[], int i, int j) {
int n = strlen(a), m = strlen(b);
for (int i = 0; i < 26; i++) t1[i].reset();
for (int i = 0; i < n; i++) {
t1[a[i] - 'a'].set(i);
}
t2.set();
for (int k = 0; k < m; k++) {
t2 = t2 << 1;
t2[0] = t2[n];
if (b[k] != '?') t2 = t2 & t1[b[k] - 'a'];
}
for (int k = 0; k < n; k++)
if (t2[k]) ans[i][(k - m % n + 1 + n) % n].set(j);
}
int main() {
n = read();
m = read();
for (int i = 0; i < n; i++) scanf("%s", a[i]);
r = read();
c = read();
for (int i = 0; i < r; i++) scanf("%s", b[i]);
for (int i = 0; i < n; i++) {
for (int j = 0; j < r; j++) {
kmp(a[i], b[j], i, j);
}
}
for (int i = 2 * n - 1; i >= 0; i--) {
for (int j = 0; j < m; j++) {
ans[(i + 1) % n][j][r] = 1;
ans[i % n][j] = ans[i % n][j] & (ans[(i + 1) % n][j] >> 1);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
putchar(ans[i][j][0] + '0');
}
putchar('\n');
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400;
int n, m, r, c;
bitset<2 * N> a[26][N], res[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = (0); i < (n); ++i)
for (int j = (0); j < (m); ++j) {
char ch;
cin >> ch;
a[ch - 'a'][i][j] = a[ch - 'a'][i][j + m] = 1, res[i][j] = 1;
}
cin >> r >> c;
for (int i = (0); i < (r); ++i)
for (int j = (0); j < (c); ++j) {
char ch;
cin >> ch;
if (ch == '?') continue;
for (int k = (0); k < (n); ++k)
res[k] &= (a[ch - 'a'][(i + k) % n] >> (j % m));
}
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (m); ++j) cout << res[i][j];
cout << "\n";
}
return 0;
}
|
#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[1]; ++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;
const int N = 500 + 10;
bitset<N> can[30][N], answer[N];
char s[N][N], pattern[N][N];
int n, m, p, q;
void shift() {
for (int c = 0; c < 30; c++) {
for (int i = 0; i < n; i++) {
bitset<N> tmp = (can[c][i] >> 1);
tmp[m - 1] = tmp[m - 1] | (can[c][i][0] & 1);
can[c][i] = tmp;
}
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
cin >> p >> q;
for (int i = 0; i < p; i++) {
cin >> pattern[i];
}
for (int i = 0; i < n; i++) {
answer[i].flip();
for (int j = 0; j < m; j++) {
can[(int)(s[i][j] - 'a')][i][j] = 1;
}
}
for (int j = 0; j < q; j++) {
for (int i = 0; i < p; i++) {
if (pattern[i][j] == '?') continue;
for (int k = 0; k < n; k++) {
answer[(k - i + n) % n] &= can[pattern[i][j] - 'a'][k];
}
}
shift();
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << answer[i][j];
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
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...);
}
struct FFT_2D {
struct node {
double x, y;
node() {}
node(double a, double b) : x(a), y(b) {}
node operator+(const node &a) const {
return node(this->x + a.x, this->y + a.y);
}
node operator-(const node a) const {
return node(this->x - a.x, this->y - a.y);
}
node operator*(const node a) const {
return node(this->x * a.x - this->y * a.y, this->x * a.y + a.x * this->y);
}
};
int N, M;
vector<vector<node>> A, B;
vector<node> w[2][2];
vector<int> rev[2];
long double pi;
FFT_2D() { pi = 3.1415926535897932384; }
void init(int n, int m) {
N = 1;
while (N < n) N <<= 1;
N <<= 1;
A.resize(N);
B.resize(N);
w[0][0].resize(N);
w[0][1].resize(N);
rev[0].resize(N);
for (int i = 0; i < N; i++) {
int j = i, y = 0;
for (int x = 1; x < N; x <<= 1, j >>= 1) (y <<= 1) += j & 1;
rev[0][i] = y;
}
for (int i = 0; i < N; i++) {
w[0][0][i] = node(cos(2 * pi * i / N), sin(2 * pi * i / N));
w[0][1][i] = node(cos(2 * pi * i / N), -sin(2 * pi * i / N));
}
M = 1;
while (M < m) M <<= 1;
M <<= 1;
for (int i = 0; i < N; i++) A[i].resize(M), B[i].resize(M);
w[1][0].resize(M);
w[1][1].resize(M);
rev[1].resize(M);
for (int i = 0; i < M; i++) {
int j = i, y = 0;
for (int x = 1; x < M; x <<= 1, j >>= 1) (y <<= 1) += j & 1;
rev[1][i] = y;
}
for (int i = 0; i < M; i++) {
w[1][0][i] = node(cos(2 * pi * i / M), sin(2 * pi * i / M));
w[1][1][i] = node(cos(2 * pi * i / M), -sin(2 * pi * i / M));
}
}
void ftransform_2D(vector<vector<node>> &A, int p) {
for (int z = 0; z < N; z++) {
for (int i = 0; i < M; i++)
if (i < rev[1][i]) swap(A[z][i], A[z][rev[1][i]]);
for (int i = 1; i < M; i <<= 1)
for (int j = 0, t = M / (i << 1); j < M; j += i << 1)
for (int k = 0, l = 0; k < i; k++, l += t) {
node x = A[z][i + j + k] * w[1][p][l];
node y = A[z][j + k];
A[z][j + k] = y + x;
A[z][j + k + i] = y - x;
}
if (p)
for (int i = 0; i < M; i++) A[z][i].x /= M, A[z][i].y /= M;
}
for (int z = 0; z < M; z++) {
for (int i = 0; i < N; i++)
if (i < rev[0][i]) swap(A[i][z], A[rev[0][i]][z]);
for (int i = 1; i < N; i <<= 1)
for (int j = 0, t = N / (i << 1); j < N; j += i << 1)
for (int k = 0, l = 0; k < i; k++, l += t) {
node x = w[0][p][l] * A[i + j + k][z];
node y = A[j + k][z];
A[j + k][z] = y + x;
A[j + k + i][z] = y - x;
}
if (p)
for (int i = 0; i < N; i++) A[i][z].x /= N;
}
}
void multiply_2D(vector<vector<long long>> &P, vector<vector<long long>> &Q,
vector<vector<long long>> &res) {
init(max(P.size(), Q.size()), max(P[0].size(), Q[0].size()));
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
A[i][j].x = A[i][j].y = B[i][j].x = B[i][j].y = 0;
for (int i = 0; i < P.size(); i++)
for (int j = 0; j < P[i].size(); j++) A[i][j].x = P[i][j];
for (int i = 0; i < Q.size(); i++)
for (int j = 0; j < Q[i].size(); j++) B[i][j].x = Q[i][j];
ftransform_2D(A, 0);
ftransform_2D(B, 0);
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) A[i][j] = A[i][j] * B[i][j];
ftransform_2D(A, 1);
res.resize(N);
for (int i = 0; i < N; i++) res[i].resize(M);
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) res[i][j] = round(A[i][j].x);
}
} fft_2D;
string t[805], p[805];
vector<string> vec;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) cin >> t[i];
vec.resize(n);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
vec[i].push_back('0');
}
}
int r, c;
cin >> r >> c;
for (int i = 0; i < r; ++i) cin >> p[i];
for (int i = n; i < n + r; ++i) {
t[i] = t[i % n];
}
n = n + r;
for (int i = 0; i < n; ++i) {
string temp = t[i];
while (t[i].size() < m + c) t[i] += temp;
}
m = t[0].size();
vector<vector<long long>> a(n, vector<long long>(m)),
b(r, vector<long long>(c)), store, ans(n + r, vector<long long>(m + c));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = t[i][j] - 'a' + 1;
a[i][j] = num * num * num;
if (t[i][j] == '?') a[i][j] = 0;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
int num = p[i][j] - 'a' + 1;
b[r - i - 1][c - j - 1] = num;
if (p[i][j] == '?') b[r - i - 1][c - j - 1] = 0;
}
}
fft_2D.multiply_2D(a, b, store);
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
ans[i][j] = store[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = t[i][j] - 'a' + 1;
a[i][j] = 2 * num * num;
if (t[i][j] == '?') a[i][j] = 0;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
int num = p[i][j] - 'a' + 1;
b[r - i - 1][c - j - 1] = num * num;
if (p[i][j] == '?') b[r - i - 1][c - j - 1] = 0;
}
}
fft_2D.multiply_2D(a, b, store);
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
ans[i][j] -= store[i][j];
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int num = t[i][j] - 'a' + 1;
a[i][j] = num;
if (t[i][j] == '?') a[i][j] = 0;
}
}
for (int i = 0; i < r; ++i) {
for (int j = 0; j < c; ++j) {
int num = p[i][j] - 'a' + 1;
b[r - i - 1][c - j - 1] = num * num * num;
if (p[i][j] == '?') b[r - i - 1][c - j - 1] = 0;
}
}
fft_2D.multiply_2D(a, b, store);
for (int i = 0; i < n + r; ++i) {
for (int j = 0; j < m + c; ++j) {
ans[i][j] += store[i][j];
}
}
for (int i1 = 0, i2 = r - 1; i2 < n; ++i2, ++i1) {
for (int j1 = 0, j2 = c - 1; j2 < m; ++j1, ++j2) {
if (i1 == vec.size() || j1 == vec[0].size()) break;
if (ans[i2][j2] == 0) vec[i1][j1] = '1';
}
}
for (int i = 0; i < vec.size(); ++i) cout << vec[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 402;
int n, m, r, c;
char a[N][N], b[N][N];
bitset<N> first[26][N], ans[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i <= n - 1; ++i)
for (int j = 0; j <= m - 1; ++j) {
scanf(" %c", &a[i][j]);
first[a[i][j] - '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) scanf(" %c", &b[i][j]);
for (int i = 0; i <= n - 1; ++i) ans[i].set();
for (int i = 0; i <= r - 1; ++i)
for (int j = 0; j <= c - 1; ++j)
if (b[i][j] != '?')
for (int x = 0; x <= n - 1; ++x)
ans[((x - i) % n + n) % n] &=
(first[b[i][j] - 'a'][x] >> (j % m)) |
(first[b[i][j] - 'a'][x] << (m - j % m));
for (int i = 0; i <= n - 1; ++i) {
for (int j = 0; j <= m - 1; ++j) printf("%d", ans[i][j] & 1);
puts("");
}
}
|
#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];
int f(char c) { return c - 'a'; }
bitset<N> cyclic_shift(bitset<N> b, int len) {
return (b >> (len % m)) | (b << ((m - (len % m))));
}
void act(int x, int y, char c) {
for (int i = 0; i < n; i++)
ok[i] &= cyclic_shift(have_char[f(c)][(i + x) % n], y);
}
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;
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); }
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 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];
cd v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w = w * wlen;
}
}
}
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) {
vector<cd> ans;
reverse(b.begin(), b.end());
vector<cd> res = mult(a, b);
for (int i = (int)b.size() - 1; i < a.size(); i++) ans.push_back(res[i]);
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);
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;
#pragma comment(linker, "/STACK:64000000")
const int infi = 1e9 + 7;
const long long infl = 1e18 + 7;
int z[2010];
int eq(char a, char b) { return b == '?' || a == b; }
void calc_z(char *s, int len) {
int l = 0, r = -1;
memset(z, 0, sizeof(z));
for (int i = 1; i < len; ++i) {
if (i <= r) {
z[i] = min(z[i - l], r - i + 1);
}
for (; i + z[i] < len && eq(s[i + z[i]], s[z[i]]); ++z[i])
;
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
}
char ar[401][401];
char shab[401][401];
bitset<401> can[401][401];
char tmp[2010];
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (m); ++j) cin >> ar[i][j];
int q, w;
cin >> q >> w;
for (int i = 0; i < (q); ++i)
for (int j = 0; j < (w); ++j) cin >> shab[i][j];
for (int k = 0; k < (q); ++k) {
for (int i = 0; i < (w); ++i) tmp[i] = shab[k][i];
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (m); ++j) tmp[w + j] = ar[i][j];
int sum = 1;
int cnt = 1;
while (sum < w) {
for (int j = 0; j < (m); ++j) tmp[w + m * cnt + j] = ar[i][j];
++cnt;
sum += m;
}
calc_z(tmp, w + m * cnt);
for (int j = 0; j < (m); ++j) {
if (z[j + w] >= w) {
can[i][j][k] = 1;
}
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int cur = i;
int flag = 1;
for (int k = 0; k < q && flag; ++k) {
if (!can[cur][j][k]) {
flag = 0;
} else {
++cur;
if (cur == n) cur = 0;
}
}
cout << flag;
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int H, W;
int TH, TW;
string S[404];
string T[404];
bitset<170000> B[26];
bitset<170000> R, R2, mask, lef[401], ri[401];
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> H >> W;
for (y = 0; y < (H); y++) {
cin >> S[y];
for (x = 0; x < (W); x++) {
B[S[y][x] - 'a'][y * W + x] = 1;
R[y * W + x] = 1;
}
}
lef[0] = R2 = R;
for (x = 1; x <= W; x++) {
lef[x] = lef[x - 1];
for (y = 0; y < (H); y++) lef[x][y * W + W - x] = 0;
ri[x] = (~lef[x]) & R;
}
mask = ~R;
cin >> TH >> TW;
for (y = 0; y < (TH); y++) {
cin >> T[y];
for (x = 0; x < (TW); x++)
if (T[y][x] != '?') {
r = T[y][x] - 'a';
int yy = y % H;
int xx = x % W;
bitset<170000> BT =
((B[r] >> (yy * W)) | (B[r] << (W * H - (yy * W)))) & R2;
R &= ((BT >> (xx)) & lef[xx]) | ((BT << (W - xx)) & ri[xx]);
}
}
for (y = 0; y < (H); y++) {
for (x = 0; x < (W); x++) (void)printf("%d", R[y * W + x] == 1);
(void)printf("\n");
}
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false), cin.tie(0);
for (i = 0; i < (argc - 1); i++) s += argv[i + 1], s += '\n';
for (i = 0; i < (s.size()); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 405;
char S[maxn][maxn];
bitset<maxn> B[27][maxn], R[maxn];
int n, m, r, c;
bitset<maxn> Shifted(const bitset<maxn> &b, int len, int shift) {
return ((b >> shift) | (b << (len - shift)));
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", S[i]);
for (int j = 0; j < m; ++j) B[S[i][j] - 'a'][i][j] = 1;
}
for (int i = 0; i < n; ++i) R[i] = ~R[i];
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) scanf("%s", S[i]);
for (int i = 0; i < r; ++i)
for (int j = 0; j < c; ++j) {
if (S[i][j] == '?') continue;
int ch = S[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;
R[nx] &= Shifted(B[ch][x], m, shiftByY);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j)
if (R[i][j])
putchar('1');
else
putchar('0');
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 int N = 401;
bitset<N> bs[26][N][N];
char a[N][N], b[N][N];
int n, m, r, c, ans[N][N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
cin >> r >> c;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) cin >> b[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int l = 0; l < c; l++) bs[a[i][(j + l) % m] - 'a'][i][l].set(j);
for (int i = 0; i < n; i++) {
bitset<N> k;
k.set();
for (int j = 0; j < r; j++)
for (int l = 0; l < c; l++)
if (b[j][l] != '?') k &= bs[b[j][l] - 'a'][(j + i) % n][l];
for (int j = 0; j < m; j++) ans[i][j] = k[j];
}
for (int i = 0; i < n; i++, cout << endl)
for (int j = 0; j < m; j++) cout << ans[i][j];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
bitset<805> a[405], b[405][26];
string s[405], c[405];
int main() {
int n, m;
cin >> n >> m;
int i;
for (i = 0; i < n; i++) cin >> s[i];
int r, c1;
cin >> r >> c1;
int j;
for (i = 0; i < n; i++) {
a[i].set();
for (j = 0; j < m + c1 - 1; j++) {
int x = s[i][j % m] - 'a';
b[i][x].set(j);
}
}
for (i = 0; i < r; i++) cin >> c[i];
for (i = 0; i < r; i++) {
for (j = 0; j < c1; j++) {
int x = c[i][j] - 'a';
if (c[i][j] == '?') continue;
for (int k = 0; k < n; k++) {
int h = ((k - i) + n) % n;
bitset<805> b1 = b[k][x] >> j;
a[h] &= b1;
}
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++)
if (a[i].test(j))
cout << "1"
<< "";
else
cout << "0"
<< "";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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 void operator+=(const Complex<T>& o) {
real += o.real;
imag += o.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 initMul(const Complex<T>& x, const Complex<T>& y) {
real = x.real * y.real - x.imag * y.imag;
imag = x.real * y.imag + x.imag * y.real;
}
inline void initSub(const Complex<T>& x, const Complex<T>& y) {
real = x.real - y.real;
imag = x.imag - y.imag;
}
inline void flip() {
real = -real;
imag = -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 | 1);
_roots.resize(2);
_roots[0].init(0, 0);
_roots[1].init(1, 0);
_initCapacity(capacity);
_cs.reserve(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(pow2, cs);
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]);
}
}
const Complex<T>* csEnd = cs.data() + pow2;
for (int l = 1; l < pow2; l <<= 1) {
Complex<T>* i = cs.data();
for (int l2 = l << 1; i != csEnd; i += l2) {
Complex<T>*k = _roots.data() + l, *ij = i, *ijl = ij + l;
const Complex<T>* endIj = i + l;
for (; ij != endIj; ++ij, ++ijl, ++k) {
_c.initMul(*ijl, *k);
ijl->initSub(*ij, _c);
*ij += _c;
}
}
}
}
inline void _expand(int pow2, vector<Complex<T>>& cs) {
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 angle = PI / i, baseAngle = angle * 2;
for (int j = i; j < i << 1; j += 2, angle += baseAngle) {
_roots[j] = _roots[j >> 1];
_roots[j | 1].initPolar(1, angle);
}
}
}
vector<int> _revs;
vector<Complex<T>> _roots, _cs;
Complex<T> _c;
};
} // namespace math
const int MAXN = 400 + 2;
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;
bool valid[MAXN][MAXN];
vector<vector<math::Complex<COMPLEX_T>>> boardCs, patternCs;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", board[i]);
}
scanf("%d%d", &r, &c);
for (int i = 0; i < r; ++i) {
scanf("%s", pattern[i]);
}
boardCs.resize(n + r);
for (int i = 0; i < n + r; ++i) {
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.resize(r);
int patternCnt = 0;
for (int i = 0; i < r; ++i) {
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) {
putchar(fabs(boardCs[i + r - 1][j + c - 1].real - patternCnt) < EPS
? '1'
: '0');
}
putchar('\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;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
char s[2011][2011];
char pat[2011][2011];
namespace fft {
const int mod = 998244353;
const int root = 31;
const int root_1 = power(root, mod - 2, mod);
int mPow(int a, int first) { return power(a, first, mod); }
void fft(vector<int> &a, bool invert) {
int n = a.size();
int PW = mPow(invert ? root_1 : root, (mod - 1) / n);
for (int m = n, h; h = m / 2, m >= 2; PW = 1LL * PW * PW % mod, m = h) {
for (int i = 0, w = 1; i < h; ++i, w = 1LL * w * PW % mod)
for (int j = i; j < n; j += m) {
int k = j + h, first = (a[j] - a[k] + mod) % mod;
a[j] += a[k];
a[j] %= mod;
a[k] = 1LL * w * first % mod;
}
}
for (int i = 0, j = 1; j < n - 1; ++j) {
for (int k = n / 2; k > (i ^= k); k /= 2)
;
if (j < i) swap(a[i], a[j]);
}
if (invert) {
int rev = mPow(n, mod - 2);
for (int i = 0; i < n; ++i) a[i] = 1LL * a[i] * rev % mod;
}
}
vector<int> multiply(const vector<int> &a, const vector<int> &b) {
int n = a.size() + b.size();
vector<int> na = a, nb = b;
int mx = 1;
while (mx < n) mx <<= 1;
na.resize(mx);
nb.resize(mx);
fft(na, false);
fft(nb, false);
for (int i = 0; i < mx; ++i) na[i] = 1LL * na[i] * nb[i] % mod;
fft(na, true);
na.resize(n);
return na;
}
}; // namespace fft
vector<int> a, b, C;
int ans[2011][2011];
int main() {
int n, m, r, c;
gn(n, m);
for (int i = 0; i < n; i++) scanf("%s", s[i]);
gn(r, c);
for (int i = 0; i < r; i++) scanf("%s", pat[i]);
for (int i = 'a'; i <= 'z'; i++) {
a.clear();
b.clear();
for (int j = 0; j < n + r - 1; j++) {
for (int k = 0; k < m + c - 1; k++) a.push_back(s[j % n][k % m] == i);
}
int cnt = 0;
for (int j = 0; j < n + r - 1; j++) {
for (int k = 0; k < m + c - 1; k++) {
if (j < r and k < c) {
b.push_back(pat[j][k] == i);
if (pat[j][k] == i) cnt++;
} else
b.push_back(0);
}
}
if (cnt == 0) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) ans[i][j]++;
continue;
}
reverse(b.begin(), b.end());
C = fft::multiply(a, b);
int ed = (m + c - 1) * (n + r - 1);
for (int j = (m + c - 1) * (n + r - 1) - 1; j < 2 * ed - 1; j++) {
int d = j - ed + 1;
int first = d / (m + c - 1);
int second = d % (m + c - 1);
ans[first][second] += C[j] == cnt;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) print(ans[i][j] == 26);
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
template <class T>
void show(T a) {
for (auto x : a) cout << x << " ";
cout << endl;
}
const string DIGITS = "0123456789";
const int LOG = 21;
const int N = 1 << LOG;
complex<double> w[N];
int rev[N];
inline void init_fft() {
double ang = 2.0 * PI / N;
w[1] = complex<double>(cos(ang), sin(ang));
w[0] = 1;
for (int i = 2; i < N; ++i) w[i] = w[1] * w[i - 1];
int rmask = 0;
for (int i = 0;; ++i) {
rev[i] = rmask;
if (i == N - 1) break;
for (int i = LOG - 1;; --i) {
rmask ^= 1 << i;
if ((rmask >> i) & 1) break;
}
}
}
inline void fft(vector<complex<double> > &a, int lgn) {
int n = 1 << lgn;
for (int i = 0; i < n; ++i) {
int rv = rev[i] >> LOG - lgn;
if (rv < i) swap(a[rv], a[i]);
}
for (int pw = 1; pw <= lgn; ++pw) {
int len2 = 1 << pw - 1;
int len = len2 << 1;
for (int st = 0; st < n; st += len) {
for (int i = 0; i < len2; ++i) {
complex<double> u = a[st + i], v = a[st + i + len2] * w[i << LOG - pw];
a[st + i] = u + v;
a[st + i + len2] = u - v;
}
}
}
}
inline void inverse_fft(vector<complex<double> > &a, int lgn) {
fft(a, lgn);
int n = 1 << lgn;
for (auto &x : a) x /= n;
reverse(a.begin() + 1, a.end());
}
inline vector<int> multiply(const vector<int> &a, const vector<int> &b) {
int lgn = 0;
int n = max(a.size(), b.size());
while ((1 << lgn) < n) ++lgn;
++lgn;
n = 1 << lgn;
assert(lgn <= LOG);
vector<complex<double> > fa(a.begin(), a.end()), fb(b.begin(), b.end());
fa.resize(n, complex<double>(0, 0));
fb.resize(n, complex<double>(0, 0));
fft(fa, lgn);
fft(fb, lgn);
for (int i = 0; i < n; ++i) fa[i] *= fb[i];
inverse_fft(fa, lgn);
vector<int> ret(n);
for (int i = 0; i < ((int)(fa.size())); ++i)
ret[i] = (fa[i].real() > 0) ? fa[i].real() + 0.5 : fa[i].real() - 0.5;
return ret;
}
inline int get(vector<vector<int> > &prec, int i, int j, int ii, int jj) {
if (!i && !j) {
return prec[ii][jj];
} else if (!i) {
j--;
return prec[ii][jj] - prec[ii][j];
} else if (!j) {
i--;
return prec[ii][jj] - prec[i][jj];
} else {
i--;
j--;
return prec[ii][jj] - prec[i][jj] - prec[ii][j] + prec[i][j];
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init_fft();
int n, m;
cin >> n >> m;
int init_n = n, init_m = m;
vector<vector<int> > tmp(n, vector<int>(m));
for (int i = 0; i < int(n); ++i) {
string s;
cin >> s;
for (int j = 0; j < int(m); ++j) {
tmp[i][j] = s[j] - 'a' + 1;
}
}
int r, c;
cin >> r >> c;
n = n + r + 1;
m = m + c + 1;
vector<int> pattern(n * m, 0);
for (int i = 0; i < int(r); ++i) {
string s;
cin >> s;
for (int j = 0; j < int(c); ++j) {
int cur = s[j] - 'a' + 1;
if (s[j] == '?') cur = 0;
pattern[i * m + j] = cur;
}
}
r = n, c = m;
reverse(pattern.begin(), pattern.end());
vector<int> str(n * m);
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) {
str[i * m + j] = tmp[i % init_n][j % init_m];
}
vector<int> pat_sqr(r * c);
for (int i = 0; i < int(((int)(pat_sqr.size()))); ++i)
pat_sqr[i] = (pattern[i]) * (pattern[i]);
int sum_three = 0;
for (int i = 0; i < int(r * c); ++i) sum_three += pat_sqr[i] * pattern[i];
vector<int> str_sqr(n * m, 0);
for (int i = 0; i < n * m; ++i) {
str_sqr[i] = (str[i]) * (str[i]);
}
vector<int> f1 = multiply(str, pat_sqr);
vector<int> f2 = multiply(str_sqr, pattern);
for (int i = 0; i < int(init_n); ++i) {
string s(init_m, ' ');
for (int j = 0; j < int(init_m); ++j) {
int cur =
sum_three - 2 * f1[i * m + j + r * c - 1] + f2[i * m + j + r * c - 1];
s[j] = char(!bool(cur) + '0');
}
cout << s << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long double EPS = 1e-9;
template <class second, class T>
ostream& operator<<(ostream& os, const pair<second, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const unordered_set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const unordered_map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const multiset<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class second, class T>
ostream& operator<<(ostream& os, const map<second, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
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) {
long long idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
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";
}
long long binpow(long long b, long long p, long long mod) {
long long ans = 1;
for (; p; p >>= 1) {
if (p & 1) ans = ans * b % mod;
b = b * b % mod;
}
return ans;
}
void pre() {}
class cpx {
public:
double x, y;
cpx(double p = 0, double q = 0) : x(p), y(q) {}
cpx operator+(const cpx& o) { return cpx(x + o.x, y + o.y); }
cpx operator-(const cpx& o) { return cpx(x - o.x, y - o.y); }
cpx operator*(const cpx& o) {
return cpx(x * o.x - y * o.y, x * o.y + y * o.x);
}
cpx conj() { return cpx(x, -y); }
};
ostream& operator<<(ostream& os, const cpx& x) {
return os << "(" << x.x << ' ' << x.y << ")";
}
const double pi = acos(-1.l);
const int N = 1 << 20;
cpx root[N];
void precalc() {
for (int i = 0; i < N; ++i) {
double ang = 2 * i * pi / N;
root[i] = cpx(cos(ang), sin(ang));
}
}
void fft(vector<cpx>& a, int f) {
int i, j, k, l, n = a.size();
cpx w, x, y;
for (i = j = 0; i < n; ++i) {
if (i > j) swap(a[i], a[j]);
for (k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (i = 2; i <= n; i <<= 1) {
l = i >> 1;
for (j = 0; j < n; j += i)
for (k = 0; k < l; ++k) {
w = root[k * (N / i)], w.y *= f;
x = a[j + k], y = w * a[j + k + l];
a[j + k] = x + y, a[j + k + l] = x - y;
}
}
if (f == -1)
for (i = 0; i < n; ++i) a[i].x /= n, a[i].y /= n;
}
vector<cpx> conv(vector<cpx>& a, vector<cpx>& b) {
int n, m = a.size() + b.size() - 1;
for (n = 1; n < m; n <<= 1)
;
vector<cpx> A(n), B(n);
for (int i = 0; i < int(a.size()); ++i) A[i] = a[i];
for (int i = 0; i < int(b.size()); ++i) B[i] = b[i];
fft(A, 1), fft(B, 1);
for (int i = 0; i < n; ++i) A[i] = A[i] * B[i];
fft(A, -1);
A.resize(m);
return A;
}
void fft2(vector<vector<cpx>>& a, int f) {
int n = a.size();
int m = a[0].size();
for (int i = 0; i < n; ++i) {
fft(a[i], f);
}
for (int i = 0; i < m; ++i) {
vector<cpx> t;
for (int j = 0; j < n; ++j) t.push_back(a[j][i]);
fft(t, f);
for (int j = 0; j < n; ++j) a[j][i] = t[j];
}
}
void conv2(vector<vector<cpx>>& v, vector<vector<cpx>>& 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, 1);
fft2(w, 1);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) v[i][j] = v[i][j] * w[i][j];
fft2(v, -1);
}
long long n, m;
long long r, c;
char arr[801][801];
char pat[401][401];
int ans[2000][2000];
void solve() {
long long n, m;
precalc();
cin >> n >> m;
for (long long i = 0; i < n; ++i) cin >> arr[i];
cin >> r >> c;
for (long long i = 0; i < r; ++i) cin >> pat[i];
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) {
arr[I][J] = arr[i][j];
}
}
}
}
vector<vector<cpx>> A(n + r, vector<cpx>(m + c)), B(r, vector<cpx>(c));
for (long long i = 0; i < n + r; ++i) {
for (long long j = 0; j < m + c; ++j) {
double angle = (2 * pi * (arr[i][j] - 'a')) / 26;
A[i][j] = cpx(cos(angle), sin(angle));
}
}
int cc = 0;
for (long long i = 0; i < r; ++i) {
for (long long j = 0; j < c; ++j) {
if (pat[i][j] == '?') {
cc++;
B[r - i - 1][c - j - 1] = cpx(0, 0);
} else {
double angle = -(2 * pi * (pat[i][j] - 'a')) / 26;
B[r - i - 1][c - j - 1] = cpx(cos(angle), sin(angle));
}
}
}
conv2(A, B);
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < m; ++j) {
int ans = A[i + r - 1][j + c - 1].x + 1e-5;
cout << (ans == (r * c - cc));
}
cout << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
pre();
long long t = 1;
for (long long i = 1; i <= t; i++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 2e5;
const int M = 805;
const double PI = acos(-1.0);
int n, m, nn, mm, r, c, id[M][M], ans[M][M];
char s1[M][M], s2[M][M];
struct Complex {
double real, imag;
Complex() {}
Complex(double real_, double imag_) : real(real_), imag(imag_) {}
friend inline Complex operator+(const Complex &lhs, const Complex &rhs) {
return Complex(lhs.real + rhs.real, lhs.imag + rhs.imag);
}
friend inline Complex operator-(const Complex &lhs, const Complex &rhs) {
return Complex(lhs.real - rhs.real, lhs.imag - rhs.imag);
}
friend inline Complex operator*(const Complex &lhs, const Complex &rhs) {
return Complex(lhs.real * rhs.real - lhs.imag * rhs.imag,
lhs.real * rhs.imag + lhs.imag * rhs.real);
}
};
inline Complex conj(Complex &a) { return Complex(a.real, -a.imag); }
inline void FFT(Complex *a, int n, int rev) {
for (int i = 0, j = 0; i < n; ++i) {
if (i > j) swap(a[i], a[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int i = 2; i <= n; i <<= 1) {
int m = i >> 1;
Complex g(cos(PI / m), rev * sin(PI / m));
for (int j = 0; j < n; j += i) {
Complex w(1, 0);
for (int k = 0; k != m; k++) {
Complex z = a[j + m + k] * w;
a[j + m + k] = a[j + k] - z;
a[j + k] = a[j + k] + z;
w = w * g;
}
}
}
if (rev == -1) {
for (int i = 0; i < n; i++) a[i].real /= n, a[i].imag /= n;
}
}
int tot, len, T[N], P[N], T2[N], P2[N], TT[N], PP[N];
Complex A[N], B[N], f1[N], f2[N], f3[N], f4[N];
void cal(int *a, int *b, int *c) {
for (int i = 0; i < len; i++) A[i] = Complex(b[i] & 32767, b[i] >> 15);
for (int i = 0; i < len; i++) B[i] = Complex(c[i] & 32767, c[i] >> 15);
FFT(A, len, 1);
FFT(B, len, 1);
for (int i = 0; i < len; i++) {
int j = (len - i) & (len - 1);
f2[i] = (A[i] + conj(A[j])) * Complex(0.5, 0);
f1[i] = (A[i] - conj(A[j])) * Complex(0, -0.5);
f4[i] = (B[i] + conj(B[j])) * Complex(0.5, 0);
f3[i] = (B[i] - conj(B[j])) * Complex(0, -0.5);
}
for (int i = 0; i < len; i++) {
A[i] = f1[i] * f3[i] + f1[i] * f4[i] * Complex(0, 1);
B[i] = f2[i] * f4[i] * Complex(0, 1) + f2[i] * f3[i];
}
FFT(A, len, -1);
FFT(B, len, -1);
int g1, g2, g3, g4;
for (int i = 0; i < len; i++) {
g1 = (int)(A[i].real + 0.5);
g2 = (int)(A[i].imag + 0.5);
g3 = (int)(B[i].real + 0.5);
g4 = (int)(B[i].imag + 0.5);
a[i] = (g4 + (g2 + g3 << 15) + (g1 << 30));
}
}
inline void cal(int *a, int *b, int c) {
for (int i = 0; i < tot; i++) {
if (i > tot - i) break;
swap(b[i], b[tot - i]);
}
cal(a, a, b);
for (int i = 0; i < nn; i++)
for (int j = 0; j < mm; j++) ans[i][j] += c * a[id[i][j] + tot];
}
void solve() {
tot = n * m;
len = 1;
while (len < 2 * tot) len <<= 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
T[id[i][j]] = s1[i][j] - 'a' + 1;
P[id[i][j]] = s2[i][j] - 'a' + 1;
}
}
for (int i = 0; i < tot; i++) {
T2[i] = T[i] * T[i];
P2[i] = P[i] * P[i];
TT[i] = (T[i] != 0);
PP[i] = (P[i] != 0);
}
cal(T2, PP, 1);
cal(T, P, -2);
cal(TT, P2, 1);
}
int main() {
scanf("%d%d", &nn, &mm);
for (int i = 0; i < nn; i++) scanf("%s", s1[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", s2[i]);
n = nn;
m = mm;
for (int i = 0; i < n; i++)
for (int j = m; j < m + c; j++) s1[i][j] = s1[i][j % m];
m += c - 1;
for (int i = 0; i < m; i++)
for (int j = n; j < n + r; j++) s1[j][i] = s1[j % n][i];
n += r - 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) id[i][j] = i * m + j;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (i >= r || j >= c || s2[i][j] == '?') s2[i][j] = 'a' - 1;
solve();
for (int i = 0; i < nn; i++) {
for (int j = 0; j < mm; j++)
if (ans[i][j] == 0)
putchar('1');
else
putchar('0');
printf("\n");
}
}
|
#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;
using cd = complex<double>;
const double PI = acos(-1.0);
vector<cd> prec_w;
int lg;
void precomp(int need_lg) {
if (prec_w.size() >= (1 << need_lg) + 1) return;
lg = need_lg;
prec_w.clear();
cd w(1, 0);
double ang = 2 * PI / (1 << need_lg);
cd wlen(cos(ang), sin(ang));
while (prec_w.size() != (1 << need_lg) + 1) {
prec_w.push_back(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++) {
cd u = a[i + j];
cd v = a[i + j + (1 << (cur_lg - 1))] *
prec_w[invert ? ((1 << lg) - (1 << (lg - cur_lg)) * j)
: (1 << (lg - cur_lg)) * j];
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] /= 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] *= 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) {
vector<cd> ans;
reverse(b.begin(), b.end());
vector<cd> res = mult(a, b);
for (int i = (int)b.size() - 1; i < a.size(); i++) ans.push_back(res[i]);
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 MAXN = 405;
bitset<MAXN> mp[26][MAXN], ans[MAXN];
int n, m, r, c;
char ch[MAXN];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", ch);
for (int j = 0; j < m; j++) mp[ch[j] - 'a'][i][j] = true;
}
for (int i = 0; i < n; i++) ans[i] = ~ans[i];
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) {
scanf("%s", ch);
for (int j = 0; j < c; j++) {
if (ch[j] == '?') continue;
int dx = ((-i) % n + n) % n, dy = j % m;
for (int x = 0; x < n; x++)
ans[(x + dx) % n] &=
((mp[ch[j] - 'a'][x] >> dy) | (mp[ch[j] - 'a'][x] << (m - dy)));
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (ans[i][j])
putchar('1');
else
putchar('0');
putchar(10);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
const int NMAX = 405;
bitset<NMAX> bt[NMAX][NMAX][26], ans;
int n, m, r, c;
string a[NMAX], b[NMAX];
void Prep() {
for (int i = 0; i < n; i++)
for (int s = 0; s < m; s++)
for (int j = 0; j < m; j++) bt[i][s][a[i][j] - 'a'].set((j - s + m) % m);
}
void Go(int poz) {
ans.set();
for (int i = 0; i < r; i++) {
int row = (poz + i) % n;
for (int j = 0; j < c; j++)
if (b[i][j] != '?') ans &= bt[row][j % m][b[i][j] - 'a'];
}
}
int main() {
cin.sync_with_stdio(false);
int i, j;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
cin >> r >> c;
for (i = 0; i < r; i++) cin >> b[i];
Prep();
for (i = 0; i < n; i++) {
Go(i);
for (j = 0; j < m; j++) cout << ans[j];
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400;
char f[MAXN + 1][MAXN + 1];
bitset<400> pos[400][26], good[400];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> f[i][j];
pos[i][f[i][j] - 'a'][j] = true;
good[i][j] = true;
}
}
int r, c;
cin >> r >> c;
for (int i = 0; i < r; i++) {
string s;
cin >> s;
for (int j = 0; j < c; j++) {
if (s[j] == '?') continue;
for (int k = 0; k < n; k++) {
bitset<400> g = pos[k][s[j] - 'a'];
g = (g >> (j % m)) | (g << ((m - j + MAXN * m) % m));
good[(k - i + MAXN * n) % n] &= g;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (good[i][j])
printf("1");
else
printf("0");
}
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bitset<404> b[26][404];
bitset<404> ans[404];
char s[404];
bitset<404> Shift(const bitset<404>& b, int len, int shift) {
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++) {
scanf("%s", s);
for (int j = 0; j < m; j++) b[s[j] - 'a'][i][j] = 1;
}
scanf("%d%d", &r, &c);
for (int i = 0; i < n; i++) ans[i] = ~ans[i];
for (int i = 0; i < r; i++) {
scanf("%s", s);
for (int j = 0; j < c; j++) {
if (s[j] == '?') continue;
int c = s[j] - 'a', X = (2333 * n - i) % n, Y = (2333 * m + j) % m;
for (int x = 0; x < n; x++) {
int nx = x + X;
if (nx >= n) nx -= n;
ans[nx] &= Shift(b[c][x], m, Y);
}
}
}
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++) putchar(ans[i][j] ? '1' : '0');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
struct my_complex {
double re, im;
};
inline my_complex operator*(const my_complex &a, const my_complex &b) {
return {a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re};
}
inline my_complex operator+(const my_complex &a, const my_complex &b) {
return {a.re + b.re, a.im + b.im};
}
inline my_complex operator-(const my_complex &a, const my_complex &b) {
return {a.re - b.re, a.im - b.im};
}
void fft(vector<my_complex> &a, bool invert) {
int n = (int)a.size(), k = (int)log2(n);
for (int i = 0; i < n; i++) {
int rev = 0;
for (int j = 0; j < k; j++) {
if (i & (1 << j)) {
rev |= (1 << (k - j - 1));
}
}
if (rev < i) {
swap(a[i], a[rev]);
}
}
for (int len = 2; len <= n; len *= 2) {
double ang = 2 * pi / (double)len * (invert ? -1 : 1);
my_complex w_len = {cos(ang), sin(ang)};
for (int i = 0; i < n; i += len) {
my_complex w = {1, 0};
for (int j = i; j < i + len / 2; j++) {
my_complex u = a[j], v = a[j + len / 2] * w;
a[j] = u + v;
a[j + len / 2] = u - v;
w = w * w_len;
}
}
}
if (invert) {
for (auto &x : a) {
x.re /= n;
x.im /= n;
}
}
}
void fft(vector<vector<my_complex> > &a, bool invert) {
for (int i = 0; i < (int)a.size(); i++) {
fft(a[i], invert);
}
for (int j = 0; j < (int)a[0].size(); j++) {
vector<my_complex> tmp;
for (int i = 0; i < (int)a.size(); i++) {
tmp.push_back(a[i][j]);
}
fft(tmp, invert);
for (int i = 0; i < (int)a.size(); i++) {
a[i][j] = tmp[i];
}
}
}
vector<vector<my_complex> > mul(const vector<vector<my_complex> > &a,
const vector<vector<my_complex> > &b) {
int n = 1, m = 1;
while (n < (int)a.size() + (int)b.size()) {
n *= 2;
}
while (m < (int)a[0].size() + (int)b[0].size()) {
m *= 2;
}
vector<vector<my_complex> > f(n, vector<my_complex>(m)),
g(n, vector<my_complex>(m));
for (int i = 0; i < (int)a.size(); i++) {
for (int j = 0; j < (int)a[i].size(); j++) {
f[i][j] = a[i][j];
}
}
for (int i = 0; i < (int)b.size(); i++) {
for (int j = 0; j < (int)b[i].size(); j++) {
g[i][j] = b[i][j];
}
}
fft(f, false);
fft(g, false);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
f[i][j] = f[i][j] * g[i][j];
}
}
fft(f, true);
vector<vector<my_complex> > ans(
(int)a.size() + (int)b.size() - 1,
vector<my_complex>((int)a[0].size() + (int)b[0].size() - 1));
for (int i = 0; i < (int)ans.size(); i++) {
for (int j = 0; j < (int)ans[i].size(); j++) {
ans[i][j] = f[i][j];
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<string> grid(2 * n);
for (int i = 0; i < n; i++) {
cin >> grid[i];
}
int r, c;
cin >> r >> c;
grid.resize(n + r - 1);
for (int i = 0; i < n; i++) {
for (int j = m; j < m + c - 1; j++) {
grid[i] += grid[i][j - m];
}
}
for (int i = n; i < n + r - 1; i++) {
grid[i] = grid[i - n];
}
n += r - 1;
m += c - 1;
vector<string> pattern(r);
for (int i = 0; i < r; i++) {
cin >> pattern[i];
}
vector<vector<my_complex> > a(n, vector<my_complex>(m)),
b(r, vector<my_complex>(c, {0, 0}));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
double ang = 2 * pi * (grid[i][j] - 'a') / 26;
a[i][j] = {cos(ang), sin(ang)};
}
}
int not_wildcard = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (pattern[i][j] == '?') {
continue;
}
not_wildcard++;
double ang = 2 * pi * (pattern[i][j] - 'a') / 26;
b[r - i - 1][c - j - 1] = {cos(-ang), sin(-ang)};
}
}
vector<vector<my_complex> > ans = mul(a, b);
for (int i = r - 1; i < n; i++) {
for (int j = c - 1; j < m; j++) {
int re = (int)floor(ans[i][j].re + 1e-5);
if (re == not_wildcard) {
cout << 1;
} else {
cout << 0;
}
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long infLL = 0x3f3f3f3f3f3f3f3fLL;
const int maxn = 400 + 5;
const int maxs = 4 * 400 * 400 + 5;
int n, m, r, c;
char t[maxn][maxn], p[maxn][maxn];
bitset<maxs> mask[26];
int main() {
scanf("%d%d", &n, &m);
for (register int i = 0; i < (n); ++i) scanf("%s", t[i]);
scanf("%d%d", &r, &c);
for (register int i = 0; i < (r); ++i) scanf("%s", p[i]);
for (register int i = 0; i < (n + r); ++i)
for (register int j = 0; j < (m + c); ++j)
mask[t[i % n][j % m] - 'a'].set(i * (m + c) + j);
bitset<maxs> ret;
ret.set();
for (register int i = 0; i < (r); ++i)
for (register int j = 0; j < (c); ++j)
if (p[i][j] != '?') {
ret &= mask[p[i][j] - 'a'] >> (i * (m + c) + j);
}
for (register int i = 0; i < (n); ++i) {
for (register int j = 0; j < (m); ++j)
putchar('0' + ret.test(i * (m + c) + j));
puts("");
}
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];
bitset<N << 1> 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].set(j);
G[26][i].set(j);
}
for (int i = 0; i < len; ++i) T.set(i);
for (int i = 0; i < n; ++i) {
bitset<N << 1> ans = T;
for (int x = 0; x < r; ++x)
for (int y = 0; y < c; ++y) {
if (M[x][y] == '?') continue;
ans = ans & (G[(M[x][y] - 'a')][x + i] >> y);
}
for (int j = 0; j < m; ++j) printf("%d", ans.test(j));
putchar('\n');
}
}
int main() {
Init();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char c = getchar();
int x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
struct modint {
int x;
modint(int o = 0) { x = o; }
modint &operator=(int o) { return x = o, *this; }
modint &operator+=(modint o) {
return x = x + o.x >= 998244353 ? x + o.x - 998244353 : x + o.x, *this;
}
modint &operator-=(modint o) {
return x = x - o.x < 0 ? x - o.x + 998244353 : x - o.x, *this;
}
modint &operator*=(modint o) { return x = 1ll * x * o.x % 998244353, *this; }
modint &operator^=(int b) {
modint a = *this, c = 1;
for (; b; b >>= 1, a *= a)
if (b & 1) c *= a;
return x = c.x, *this;
}
modint &operator/=(modint o) { return *this *= o ^= 998244353 - 2; }
modint &operator+=(int o) {
return x = x + o >= 998244353 ? x + o - 998244353 : x + o, *this;
}
modint &operator-=(int o) {
return x = x - o < 0 ? x - o + 998244353 : x - o, *this;
}
modint &operator*=(int o) { return x = 1ll * x * o % 998244353, *this; }
modint &operator/=(int o) { return *this *= ((modint(o)) ^= 998244353 - 2); }
template <class I>
friend modint operator+(modint a, I b) {
return a += b;
}
template <class I>
friend modint operator-(modint a, I b) {
return a -= b;
}
template <class I>
friend modint operator*(modint a, I b) {
return a *= b;
}
template <class I>
friend modint operator/(modint a, I b) {
return a /= b;
}
friend modint operator^(modint a, int b) { return a ^= b; }
friend bool operator==(modint a, int b) { return a.x == b; }
friend bool operator!=(modint a, int b) { return a.x != b; }
bool operator!() { return !x; }
modint operator-() { return x ? 998244353 - x : 0; }
};
vector<modint> fac, ifac, iv;
inline void initC(int n) {
if (iv.empty()) fac = ifac = iv = vector<modint>(2, 1);
int m = iv.size();
++n;
if (m >= n) return;
iv.resize(n), fac.resize(n), ifac.resize(n);
for (register int i = (m); i <= (n - 1); ++i) {
iv[i] = iv[998244353 % i] * (998244353 - 998244353 / i);
fac[i] = fac[i - 1] * i, ifac[i] = ifac[i - 1] * iv[i];
}
}
inline modint C(int n, int m) {
if (m < 0 || n < m) return 0;
return initC(n), fac[n] * ifac[m] * ifac[n - m];
}
inline modint sign(int n) { return (n & 1) ? (998244353 - 1) : (1); }
int n, m, r, c;
bitset<400> res[400], bo[400][26];
signed main() {
n = read(), m = read();
for (register int i = (0); i <= (n - 1); ++i)
for (register int j = (0); j <= (m - 1); ++j) {
char ch;
cin >> ch;
bo[i][ch - 'a'][j] = 1;
res[i][j] = 1;
}
r = read(), c = read();
for (register int i = (0); i <= (r - 1); ++i)
for (register int j = (0); j <= (c - 1); ++j) {
char ch;
cin >> ch;
if (ch != '?') {
int c = ch - 'a';
for (register int k = (0); k <= (n - 1); ++k)
res[(k - i % n + n) % n] &=
(bo[k][c] >> (j % m)) | (bo[k][c] << (m - j % m));
}
}
for (register int i = (0); i <= (n - 1); ++i) {
for (register int j = (0); j <= (m - 1); ++j)
if (res[i][j])
cout << 1;
else
cout << 0;
puts("");
}
return 0;
}
|
#include <bits/stdc++.h>
using int64 = long long;
using uchar = unsigned char;
constexpr int maxn(400);
constexpr int sigma(26);
inline int io() {
static int _;
return scanf("%d", &_), _;
}
std::bitset<maxn> ans[maxn], pos[sigma][maxn];
char s[maxn][maxn], t[maxn][maxn], buf[maxn * (maxn + 1) + 1];
int main() {
const int n(io()), m(io());
for (int i = 0; i != n; ++i) scanf("\n"), fread(s[i], 1, m, stdin);
const int r(io()), c(io());
for (int i = 0; i != r; ++i) scanf("\n"), fread(t[i], 1, c, stdin);
for (int i = 0; i != n; ++i) ans[i].set();
for (int i = 0; i != n; ++i)
for (int j = 0; j != m; ++j) pos[s[i][j] - 'a'][i][j] = 1;
for (int j = 0; j != c; ++j) {
for (int i = 0; i != r; ++i)
if (t[i][j] != '?') {
const int cc = t[i][j] - 'a';
for (int k = 0, ii = i % n; k != n; ++k, (++ii == n) && (ii = 0))
ans[k] &= pos[cc][ii];
}
for (int k = 0; k != sigma; ++k)
for (int i = 0; i != n; ++i)
if (pos[k][i][0])
pos[k][i] >>= 1, pos[k][i][m - 1] = 1;
else
pos[k][i] >>= 1;
}
char* pa(buf);
for (int i = 0; i != n; ++i, *++pa = '\n')
for (int j = 0; j != m; ++j) *++pa = '0' + ans[i][j];
fwrite(buf + 1, 1, pa - buf, stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
template <class T>
void show(T a) {
for (auto x : a) cout << x << " ";
cout << endl;
}
const string DIGITS = "0123456789";
const int LOG = 21;
const int N = 1 << LOG;
complex<double> w[N];
int rev[N];
inline void init_fft() {
double ang = 2.0 * PI / N;
w[1] = complex<double>(cos(ang), sin(ang));
w[0] = 1;
for (int i = 2; i < N; ++i) {
ang = 2.0 * PI * i / N;
w[i] = complex<double>(cos(ang), sin(ang));
}
int rmask = 0;
for (int i = 0;; ++i) {
rev[i] = rmask;
if (i == N - 1) break;
for (int i = LOG - 1;; --i) {
rmask ^= 1 << i;
if ((rmask >> i) & 1) break;
}
}
}
inline void fft(vector<complex<double> > &a, int lgn) {
int n = 1 << lgn;
for (int i = 0; i < n; ++i) {
int rv = rev[i] >> LOG - lgn;
if (rv < i) swap(a[rv], a[i]);
}
for (int pw = 1; pw <= lgn; ++pw) {
int len2 = 1 << pw - 1;
int len = len2 << 1;
for (int st = 0; st < n; st += len) {
for (int i = 0; i < len2; ++i) {
complex<double> u = a[st + i], v = a[st + i + len2] * w[i << LOG - pw];
a[st + i] = u + v;
a[st + i + len2] = u - v;
}
}
}
}
inline void inverse_fft(vector<complex<double> > &a, int lgn) {
fft(a, lgn);
int n = 1 << lgn;
for (auto &x : a) x /= n;
reverse(a.begin() + 1, a.end());
}
inline vector<int> multiply(const vector<int> &a, const vector<int> &b) {
int lgn = 0;
int n = max(a.size(), b.size());
while ((1 << lgn) < n) ++lgn;
++lgn;
n = 1 << lgn;
assert(lgn <= LOG);
vector<complex<double> > fa(n);
for (int i = 0; i < n; ++i)
fa[i] = complex<double>(i < a.size() ? a[i] : 0, i < b.size() ? b[i] : 0);
fft(fa, lgn);
for (int i = 0; i < n; ++i) fa[i] *= fa[i];
inverse_fft(fa, lgn);
vector<int> ret(n);
for (int i = 0; i < ((int)(fa.size())); ++i) {
ret[i] = (fa[i].imag() > 0) ? fa[i].imag() + 0.5 : fa[i].imag() - 0.5;
ret[i] /= 2;
}
return ret;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init_fft();
int n, m;
cin >> n >> m;
int init_n = n, init_m = m;
vector<vector<int> > tmp(n, vector<int>(m));
for (int i = 0; i < int(n); ++i) {
string s;
cin >> s;
for (int j = 0; j < int(m); ++j) {
tmp[i][j] = s[j] - 'a' + 1;
}
}
int r, c;
cin >> r >> c;
n = n + r + 1;
m = m + c + 1;
vector<int> pattern(n * m, 0);
for (int i = 0; i < int(r); ++i) {
string s;
cin >> s;
for (int j = 0; j < int(c); ++j) {
int cur = s[j] - 'a' + 1;
if (s[j] == '?') cur = 0;
pattern[i * m + j] = cur;
}
}
r = n, c = m;
reverse(pattern.begin(), pattern.end());
vector<int> str(n * m);
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) {
str[i * m + j] = tmp[i % init_n][j % init_m];
}
vector<int> pat_sqr(r * c);
for (int i = 0; i < int(((int)(pat_sqr.size()))); ++i)
pat_sqr[i] = (pattern[i]) * (pattern[i]);
int sum_three = 0;
for (int i = 0; i < int(r * c); ++i) sum_three += pat_sqr[i] * pattern[i];
vector<int> str_sqr(n * m, 0);
for (int i = 0; i < n * m; ++i) {
str_sqr[i] = (str[i]) * (str[i]);
}
vector<int> f1 = multiply(str, pat_sqr);
vector<int> f2 = multiply(str_sqr, pattern);
for (int i = 0; i < int(init_n); ++i) {
string s(init_m, ' ');
for (int j = 0; j < int(init_m); ++j) {
int cur =
sum_three - 2 * f1[i * m + j + r * c - 1] + f2[i * m + j + r * c - 1];
s[j] = char(!bool(cur) + '0');
}
cout << s << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
void fft(valarray<complex<double> > &x) {
unsigned int N = x.size(), k = N, n;
double thetaT = 3.14159265358979323846264338328L / N;
complex<double> phiT = complex<double>(cos(thetaT), sin(thetaT)), T;
while (k > 1) {
n = k;
k >>= 1;
phiT = phiT * phiT;
T = 1.0L;
for (unsigned int l = 0; l < k; l++) {
for (unsigned int a = l; a < N; a += n) {
unsigned int b = a + k;
complex<double> t = x[a] - x[b];
x[a] += x[b];
x[b] = t * T;
}
T *= phiT;
}
}
unsigned int m = (unsigned int)log2(N);
for (unsigned int a = 0; a < N; a++) {
unsigned int b = a;
b = (((b & 0xaaaaaaaa) >> 1) | ((b & 0x55555555) << 1));
b = (((b & 0xcccccccc) >> 2) | ((b & 0x33333333) << 2));
b = (((b & 0xf0f0f0f0) >> 4) | ((b & 0x0f0f0f0f) << 4));
b = (((b & 0xff00ff00) >> 8) | ((b & 0x00ff00ff) << 8));
b = ((b >> 16) | (b << 16)) >> (32 - m);
if (b > a) {
complex<double> t = x[a];
x[a] = x[b];
x[b] = t;
}
}
}
void ifft(valarray<complex<double> > &x) {
x = x.apply(conj);
fft(x);
x = x.apply(conj);
x /= x.size();
}
void fft2d(vector<valarray<complex<double> > > &X) {
for (int i = 0; i < X.size(); i++) fft(X[i]);
for (int i = 0; i < X[0].size(); i++) {
valarray<complex<double> > tmp(X.size());
for (int j = 0; j < X.size(); j++) tmp[j] = X[j][i];
fft(tmp);
for (int j = 0; j < X.size(); j++) X[j][i] = tmp[j];
}
}
void ifft2d(vector<valarray<complex<double> > > &X) {
for (int i = 0; i < X.size(); i++) ifft(X[i]);
for (int i = 0; i < X[0].size(); i++) {
valarray<complex<double> > tmp(X.size());
for (int j = 0; j < X.size(); j++) tmp[j] = X[j][i];
ifft(tmp);
for (int j = 0; j < X.size(); j++) X[j][i] = tmp[j];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
string a[801];
for (int i = 0; i < n; i++) cin >> a[i];
int r, c;
cin >> r >> c;
string b[401];
for (int i = 0; i < r; i++) cin >> b[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < c - 1; j++) a[i] += a[i][j];
for (int i = 0; i < r - 1; i++) a[i + n] = a[i];
int nn = n + r - 1, mm = m + c - 1, b2n = 1, b2m = 1;
while (b2n <= max(nn, r)) b2n <<= 1;
while (b2m <= max(mm, c)) b2m <<= 1;
vector<valarray<complex<double> > > A(b2n, valarray<complex<double> >(b2m));
for (int i = 0; i < nn; i++)
for (int j = 0; j < mm; j++) {
double ang = 2.0 * PI * (a[i][j] - 'a') / 26.0;
A[i][j] = complex<double>(cos(ang), sin(ang));
}
fft2d(A);
int q = 0;
vector<valarray<complex<double> > > B(b2n, valarray<complex<double> >(b2m));
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (b[i][j] != '?') {
double ang = -2.0 * PI * (b[i][j] - 'a') / 26.0;
B[r - i - 1][c - j - 1] = complex<double>(cos(ang), sin(ang));
q++;
}
fft2d(B);
for (int i = 0; i < A.size(); i++)
for (int j = 0; j < A[i].size(); j++) A[i][j] *= B[i][j];
ifft2d(A);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (floor(A[i + r - 1][j + c - 1].real() + 0.0000001) == q)
cout << "1";
else
cout << "0";
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int ALPHABETS = 30;
const int maxN = 410;
bitset<maxN> orig[ALPHABETS][maxN], ans[maxN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N, M;
cin >> N >> M;
string s;
for (int i = 0; i < N; i++) {
cin >> s;
for (int j = 0; j < M; j++) {
orig[s[j] - 'a'][i][j] = true;
ans[i][j] = true;
}
}
int R, C;
cin >> R >> C;
for (int i = 0; i < R; i++) {
cin >> s;
for (int j = 0; j < C; j++) {
if (s[j] == '?') continue;
char ch = s[j] - 'a';
int goForward = j % M;
for (int k = 0; k < N; k++) {
int origR = (((k - i) % N) + N) % N;
ans[origR] &=
(orig[ch][k] >> goForward) | (orig[ch][k] << (M - goForward));
}
}
}
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;
const int N = 410;
bitset<N> ans[N], mat[26][N];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
char c;
scanf(" %c", &c);
ans[i][j] = true;
mat[c - 'a'][i][j] = true;
}
int r, c;
scanf("%d%d", &r, &c);
for (int k = 0; k < r; k++)
for (int l = 0; l < c; l++) {
char c;
scanf(" %c", &c);
if (c == '?') continue;
for (int i = 0; i < n; i++) {
int pos = (i - (k % n) + n) % n;
ans[pos] &=
(mat[c - 'a'][i] >> (l % m)) | (mat[c - 'a'][i] << (m - (l % m)));
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m - 1; j++) cout << ans[i][j];
cout << ans[i][m - 1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
bool Finish_read;
template <class T>
inline void read(T &x) {
Finish_read = 0;
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
if (ch == EOF) return;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
x *= f;
Finish_read = 1;
}
template <class T>
inline void print(T x) {
if (x / 10 != 0) print(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void writeln(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
putchar('\n');
}
template <class T>
inline void write(T x) {
if (x < 0) putchar('-');
x = abs(x);
print(x);
}
const int maxn = 405, alphabet = 26;
bitset<maxn> vis[alphabet][maxn], ans[maxn];
int n, m, r, c;
char now[maxn];
inline int fix(int p, int mod) {
while (p < 0) p += mod;
while (p >= mod) p -= mod;
return p;
}
int main() {
read(n), read(m);
for (int i = 0; i < n; ++i) {
scanf("%s", now);
for (int j = 0; j < m; ++j) vis[now[j] - 'a'][i][j] = 1;
}
for (int i = 0; i < n; ++i) ans[i].set();
read(r), read(c);
for (int i = 0; i < r; ++i) {
scanf("%s", now);
for (int j = 0; j < c; ++j) {
if (now[j] == '?') continue;
int p = now[j] - 'a', plsx = fix(-i, n), plsy = fix(-j, m);
for (int k = 0; k < n; ++k) {
int px = k + plsx;
if (px >= n) px -= n;
ans[px] &= (vis[p][k] >> (m - plsy)) | (vis[p][k] << plsy);
}
}
}
for (int i = 0; i < n; ++i, puts(""))
for (int j = 0; j < m; ++j) printf("%d", ans[i][j] ? 1 : 0);
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) {
if (prec_w.size() >= (1 << need_lg) + 1) return;
lg = need_lg;
prec_w.clear();
cd w(1, 0);
double ang = 2 * PI / (1 << need_lg);
cd wlen(cos(ang), sin(ang));
while (prec_w.size() != (1 << need_lg) + 1) {
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) {
vector<cd> ans;
reverse(b.begin(), b.end());
vector<cd> res = mult(a, b);
for (int i = (int)b.size() - 1; i < a.size(); i++) ans.push_back(res[i]);
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 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-7;
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 = (int)1e9 + 10;
const int mod = (int)1e9 + 7;
const int N = (int)1e6 + 10;
const long long LLINF = (long long)1e18 + 10;
const long double pi = acos(-1.0);
const long double eps = (long double)1e-5;
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
template <typename T>
T getint() {
char c = getchar();
T p = 1, x = 0;
while (c == ' ' || c == '\n') c = getchar();
if (c == '-') p = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * p;
}
int z[1500];
char a[410][410], b[410][410];
int n, m, r, c;
bitset<410> can[410][410];
bitset<410> ans[410][410];
char str[1500];
int eq(char a, char b) { return b == '?' || a == b; }
void zed(bitset<410> &res) {
char *s = str;
for (int i = 0; i < c + c + m; ++i) z[i] = 0;
int l = 0, r = -1;
for (int i = 1; i < c + c + m; ++i) {
if (i <= r) z[i] = min(r - i + 1, z[i - l]);
while (i + z[i] < c + c + m && eq(s[i + z[i]], s[z[i]])) ++z[i];
if (i + z[i] - 1 > r) {
l = i;
r = i + z[i] - 1;
}
}
for (int i = 0; i < m; ++i) {
res[i] = (z[c + i] >= c);
}
}
void make_str(int x, int y) {
int j = 1;
for (int i = 1; i <= c; ++i) {
str[i - 1] = b[y][i];
}
for (int i = 1; i <= c + m; ++i) {
str[c + i - 1] = a[x][j++];
if (j == m + 1) j = 1;
}
}
int main() {
srand(time(NULL));
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cin >> a[i][j];
}
}
cin >> r >> c;
for (int i = 1; i <= r; ++i) {
for (int j = 1; j <= c; ++j) {
cin >> b[i][j];
}
}
for (int k = 1; k <= r; ++k) {
for (int i = 1; i <= n; ++i) {
make_str(i, k);
zed(can[k][i]);
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
ans[r + 1][i][j] = true;
}
}
for (int k = r; k >= 1; --k) {
for (int i = 1; i <= n; ++i) {
ans[k][i] = ans[k + 1][(i == n ? 1 : i + 1)] & can[k][i];
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
cout << ans[1][i][j - 1];
}
cout << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
struct FFT {
int N;
vector<int> perm;
void precalculate() {
perm.resize(N);
perm[0] = 0;
for (int k = 1; k < N; k <<= 1) {
for (int i = 0; i < k; i++) {
perm[i] <<= 1;
perm[i + k] = 1 + perm[i];
}
}
}
void fft(vector<complex<double> > &v, bool invert = false) {
if (v.size() != perm.size()) {
N = v.size();
assert(N && (N & (N - 1)) == 0);
precalculate();
}
for (int i = 0; i < N; i++)
if (i < perm[i]) swap(v[i], v[perm[i]]);
for (int len = 2; len <= N; len <<= 1) {
double angle = 2 * PI / len;
if (invert) angle = -angle;
complex<double> factor = polar(1.0, angle);
for (int i = 0; i < N; i += len) {
complex<double> w(1);
for (int j = 0; j < len / 2; j++) {
complex<double> x = v[i + j], y = w * v[i + j + len / 2];
v[i + j] = x + y;
v[i + j + len / 2] = x - y;
w *= factor;
}
}
}
if (invert)
for (complex<double> &x : v) x /= N;
}
vector<complex<double> > multiply(vector<complex<double> > fa,
vector<complex<double> > fb) {
int n = 1;
while (n < fa.size() + fb.size()) n <<= 1;
fa.resize(n);
fb.resize(n);
fft(fa);
fft(fb);
for (int i = 0; i < n; i++) fa[i] *= fb[i];
fft(fa, true);
return fa;
}
};
int main() {
int n, m;
cin >> n >> m;
vector<string> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
int r, c;
cin >> r >> c;
vector<string> t(r);
for (int i = 0; i < r; i++) cin >> t[i];
string ss;
for (int i = 0; i < n; i++) {
string add = s[i];
add += s[i];
while (add.size() < 2 * c) add += s[i];
ss += add;
}
string base = ss;
ss += base;
int lines = 2 * n;
while (lines < 2 * r) ss += base, lines += n;
int len = ss.size() / lines;
string tt;
for (int i = 0; i < r; i++) {
string add = t[i];
while (add.size() < len) add += "?";
tt += add;
}
for (int i = r; i < lines; i++) tt += string(len, '?');
int nn = ss.size();
vector<complex<double> > a(nn), b(nn);
for (int i = 0; i < nn; i++) {
if (ss[i] == '?')
a[i] = complex<double>(0);
else
a[i] = polar(1.0, (ss[i] - 'a') * PI / 13);
}
for (int i = 0; i < nn; i++) {
if (tt[i] == '?')
b[i] = complex<double>(0);
else
b[i] = polar(1.0, -(tt[i] - 'a') * PI / 13);
}
reverse(b.begin(), b.end());
FFT fft;
vector<complex<double> > mul = fft.multiply(a, b);
int cnt = 0;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
if (t[i][j] != '?') cnt++;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int pos = i * len + j + nn - 1;
cout << (abs(mul[pos].real() - cnt) < 1e-3);
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 5;
const int M = 805;
int n, m, nn, mm, r, c, id[M][M], ans[M][M];
char s1[M][M], s2[M][M];
const int Mod = 998244353;
const int g = 3;
int Pow(long long a, int x) {
long long res = 1;
while (x) {
if (x & 1) (res *= a) %= Mod;
(a *= a) %= Mod;
x >>= 1;
}
return (int)res;
}
void FFT(int *a, int n, int rev) {
for (int i = 0, j = 0; i < n; ++i) {
if (i > j) swap(a[i], a[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1)
;
}
for (int i = 2; i <= n; i <<= 1) {
int m = i >> 1;
int w = Pow(g, (Mod - 1) / i);
if (rev == -1) w = Pow(w, Mod - 2);
for (int j = 0; j < n; j += i) {
long long Wx = 1;
for (int k = 0; k != m; k++) {
long long z = a[j + m + k] * Wx % Mod;
a[j + m + k] = a[j + k] - z + Mod;
if (a[j + m + k] > Mod) a[j + m + k] -= Mod;
a[j + k] = a[j + k] + z;
if (a[j + k] > Mod) a[j + k] -= Mod;
Wx = Wx * w % Mod;
}
}
}
}
int tot, len, inv, T[N], P[N], T2[N], P2[N], TT[N], PP[N];
inline void cal(int *a, int *b, int c) {
for (int i = 0; i < tot; i++) {
if (i > tot - i) break;
swap(b[i], b[tot - i]);
}
FFT(a, len, 1);
FFT(b, len, 1);
for (int i = 0; i < len; i++) a[i] = (long long)a[i] * b[i] % Mod;
FFT(a, len, -1);
for (int i = 0; i < nn; i++)
for (int j = 0; j < mm; j++)
ans[i][j] += c * (long long)a[id[i][j] + tot] * inv % Mod;
}
void solve() {
tot = n * m;
len = 1;
while (len < 2 * tot) len <<= 1;
inv = Pow(len, Mod - 2);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
T[id[i][j]] = s1[i][j] - 'a' + 1;
P[id[i][j]] = s2[i][j] - 'a' + 1;
}
}
for (int i = 0; i < tot; i++) {
T2[i] = T[i] * T[i];
P2[i] = P[i] * P[i];
TT[i] = (T[i] != 0);
PP[i] = (P[i] != 0);
}
cal(T2, PP, 1);
cal(T, P, -2);
cal(TT, P2, 1);
}
int main() {
scanf("%d%d", &nn, &mm);
for (int i = 0; i < nn; i++) scanf("%s", s1[i]);
scanf("%d%d", &r, &c);
for (int i = 0; i < r; i++) scanf("%s", s2[i]);
n = nn;
m = mm;
for (int i = 0; i < n; i++)
for (int j = m; j < m + c; j++) s1[i][j] = s1[i][j % m];
m += c - 1;
for (int i = 0; i < m; i++)
for (int j = n; j < n + r; j++) s1[j][i] = s1[j % n][i];
n += r - 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) id[i][j] = i * m + j;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (i >= r || j >= c || s2[i][j] == '?') s2[i][j] = 'a' - 1;
solve();
for (int i = 0; i < nn; i++) {
for (int j = 0; j < mm; j++)
if (ans[i][j] == 0)
putchar('1');
else
putchar('0');
printf("\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 = max(v.size(), w.size());
while (n < vwn) n <<= 1;
v.resize(n), w.resize(n);
int m = 1, vwm = max(v[0].size(), w[0].size());
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>
const int N = 400;
std::bitset<N> q[N][N], ans[N];
char map[N][N + 5], mode[N][N + 5];
int n, m, a, b;
int main() {
std::ios::sync_with_stdio(0), std::cin.tie(0);
std::cin >> n >> m;
for (int i = 0; i < n; ++i) std::cin >> map[i];
std::cin >> a >> b;
for (int i = 0; i < a; ++i) std::cin >> mode[i];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) ans[i].set(j);
for (char c = 'a'; c <= 'z'; ++c) {
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) q[i][j].reset();
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (map[i][j] == c)
for (int k = 0; k < m; ++k) q[i][k].set((j + m - k) % m);
for (int i = 0; i < a; ++i)
for (int j = 0; j < b; ++j)
if (mode[i][j] == c)
for (int k = 0; k < n; ++k) ans[k] &= q[(k + i) % n][j % m];
}
for (int i = 0; i < n; ++i, std::cout << '\n')
for (int j = 0; j < m; ++j) std::cout << (bool)ans[i].test(j);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 410;
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 double PI = 2 * acos(0.0);
struct point {
double x, y;
point(double _x = 0, double _y = 0) {
x = _x;
y = _y;
}
point operator+(const point &t) const { return point(x + t.x, y + t.y); }
point operator-(const point &t) const { return point(x - t.x, y - t.y); }
point operator*(const point &t) const {
return point(x * t.x - y * t.y, x * t.y + y * t.x);
}
point operator*(const double &t) const { return point(x * t, y * t); }
};
template <class T>
void show(T a) {
for (auto x : a) cout << x << " ";
cout << endl;
}
const string DIGITS = "0123456789";
const int LOG = 21;
const int N = 1 << LOG;
point w[N];
int rev[N];
inline void init_fft() {
double ang = 2.0 * PI / N;
w[1] = point(cos(ang), sin(ang));
w[0] = 1;
for (int i = 2; i < N; ++i) {
ang = 2.0 * PI * i / N;
w[i] = point(cos(ang), sin(ang));
}
int rmask = 0;
for (int i = 0;; ++i) {
rev[i] = rmask;
if (i == N - 1) break;
for (int i = LOG - 1;; --i) {
rmask ^= 1 << i;
if ((rmask >> i) & 1) break;
}
}
}
inline void fft(vector<point> &a, int lgn) {
int n = 1 << lgn;
for (int i = 0; i < n; ++i) {
int rv = rev[i] >> LOG - lgn;
if (rv < i) swap(a[rv], a[i]);
}
for (int pw = 1; pw <= lgn; ++pw) {
int len2 = 1 << pw - 1;
int len = len2 << 1;
for (int st = 0; st < n; st += len) {
for (int i = 0; i < len2; ++i) {
point u = a[st + i], v = a[st + i + len2] * w[i << LOG - pw];
a[st + i] = u + v;
a[st + i + len2] = u - v;
}
}
}
}
inline void inverse_fft(vector<point> &a, int lgn) {
fft(a, lgn);
int n = 1 << lgn;
for (auto &x : a) x = x * (1.0 / n);
reverse(a.begin() + 1, a.end());
}
inline vector<int> multiply(const vector<int> &a, const vector<int> &b) {
int lgn = 0;
int n = max(a.size(), b.size());
while ((1 << lgn) < n) ++lgn;
++lgn;
n = 1 << lgn;
assert(lgn <= LOG);
vector<point> fa(n);
for (int i = 0; i < n; ++i)
fa[i] = point(i < a.size() ? a[i] : 0, i < b.size() ? b[i] : 0);
fft(fa, lgn);
for (int i = 0; i < n; ++i) fa[i] = fa[i] * fa[i];
inverse_fft(fa, lgn);
vector<int> ret(n);
for (int i = 0; i < ((int)(fa.size())); ++i) {
ret[i] = (fa[i].y > 0) ? fa[i].y + 0.5 : fa[i].y - 0.5;
ret[i] /= 2;
}
return ret;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
init_fft();
int n, m;
cin >> n >> m;
int init_n = n, init_m = m;
vector<vector<int> > tmp(n, vector<int>(m));
for (int i = 0; i < int(n); ++i) {
string s;
cin >> s;
for (int j = 0; j < int(m); ++j) {
tmp[i][j] = s[j] - 'a' + 1;
}
}
int r, c;
cin >> r >> c;
n = n + r + 1;
m = m + c + 1;
vector<int> pattern(n * m, 0);
for (int i = 0; i < int(r); ++i) {
string s;
cin >> s;
for (int j = 0; j < int(c); ++j) {
int cur = s[j] - 'a' + 1;
if (s[j] == '?') cur = 0;
pattern[i * m + j] = cur;
}
}
r = n, c = m;
reverse(pattern.begin(), pattern.end());
vector<int> str(n * m);
for (int i = 0; i < int(n); ++i)
for (int j = 0; j < int(m); ++j) {
str[i * m + j] = tmp[i % init_n][j % init_m];
}
vector<int> pat_sqr(r * c);
for (int i = 0; i < int(((int)(pat_sqr.size()))); ++i)
pat_sqr[i] = (pattern[i]) * (pattern[i]);
int sum_three = 0;
for (int i = 0; i < int(r * c); ++i) sum_three += pat_sqr[i] * pattern[i];
vector<int> str_sqr(n * m, 0);
for (int i = 0; i < n * m; ++i) {
str_sqr[i] = (str[i]) * (str[i]);
}
vector<int> f1 = multiply(str, pat_sqr);
vector<int> f2 = multiply(str_sqr, pattern);
for (int i = 0; i < int(init_n); ++i) {
string s(init_m, ' ');
for (int j = 0; j < int(init_m); ++j) {
int cur =
sum_three - 2 * f1[i * m + j + r * c - 1] + f2[i * m + j + r * c - 1];
s[j] = char(!bool(cur) + '0');
}
cout << s << "\n";
}
}
|
#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;
using cd = complex<double>;
const double PI = acos(-1.0);
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 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];
cd v = a[i + j + len / 2] * w;
a[i + j] = u + v;
a[i + j + len / 2] = u - v;
w *= wlen;
}
}
}
if (invert)
for (int i = 0; i < n; 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] *= fb[i];
fft(fa, 1);
for (int i = 0; i < fa.size(); i++) res[i] = (int)(fa[i].real() + 1e-5);
return res;
}
vector<cd> get_scalar(vector<cd> &a, vector<cd> &b) {
vector<cd> ans;
reverse(b.begin(), b.end());
vector<cd> res = mult(a, b);
for (int i = (int)b.size() - 1; i < a.size(); i++) ans.push_back(res[i]);
return ans;
}
vector<cd> get(string second, string t) {
vector<cd> a, b;
for (int i = 0; i < second.size(); i++) {
double alp = 2 * 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 = 2 * 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);
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;
int n, m, r, c;
bitset<405> res[405], st[26][405];
char a[405][405], b[405][405];
bitset<405> myShift(bitset<405> temp, int shift, int siz) {
assert(0 <= shift && shift < siz);
return (temp >> shift) | (temp << (siz - shift));
}
int main() {
ios_base::sync_with_stdio(false);
long long precision = numeric_limits<long double>::digits10;
cin >> n >> m;
for (long long i = 0; i <= n - 1; i++) {
for (long long j = 0; j <= m - 1; j++) {
cin >> a[i][j];
st[a[i][j] - 'a'][i][j] = 1;
}
}
for (long long i = 0; i <= n - 1; i++) res[i] = ~res[i];
cin >> r >> c;
for (long long i = 0; i <= r - 1; i++) {
for (long long j = 0; j <= c - 1; j++) cin >> b[i][j];
}
for (long long i = 0; i <= r - 1; i++) {
for (long long j = 0; j <= c - 1; j++) {
if (b[i][j] == '?') continue;
int temp = b[i][j] - 'a';
int x = ((-i) % n + n) % n;
int y = j % m;
for (long long p = 0; p <= n - 1; p++) {
res[(p + x) % n] &= myShift(st[temp][p], y, m);
}
}
}
for (long long i = 0; i <= n - 1; i++) {
for (long long j = 0; j <= m - 1; j++) cout << res[i][j];
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A>
void rd(vector<A>& v);
template <class T>
void rd(T& x) {
cin >> x;
}
template <class H, class... T>
void rd(H& h, T&... t) {
rd(h);
rd(t...);
}
template <class A>
void rd(vector<A>& x) {
for (auto& a : x) rd(a);
}
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
void __p(T a) {
cout << a;
}
template <typename T, typename F>
void __p(pair<T, F> a) {
cout << "{";
__p(a.first);
cout << ",";
__p(a.second);
cout << "}\n";
}
template <typename T>
void __p(std::vector<T> a) {
cout << "{";
for (auto it = a.begin(); it < a.end(); it++)
__p(*it), cout << ",}\n"[it + 1 == a.end()];
}
template <typename T, typename... Arg>
void __p(T a1, Arg... a) {
__p(a1);
__p(a...);
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : ";
__p(arg1);
cout << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
int64_t bracket = 0, i = 0;
for (;; i++)
if (names[i] == ',' && bracket == 0)
break;
else if (names[i] == '(')
bracket++;
else if (names[i] == ')')
bracket--;
const char* comma = names + i;
cout.write(names, comma - names) << " : ";
__p(arg1);
cout << " | ";
__f(comma + 1, args...);
}
void setIO(string s = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin.exceptions(cin.failbit);
cout.precision(15);
cout << fixed;
if (((int64_t)(s).size())) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
}
const int64_t MX = 400, A = 26;
using bs = bitset<MX>;
bs shift(const bs B, int64_t x, int64_t len) {
return (B >> x) | (B << (len - x));
}
bs G[MX][A];
bs ans[MX];
signed main() {
setIO();
int64_t n, m;
rd(n, m);
vector<string> T(n);
rd(T);
for (int64_t i = int64_t(0); i < int64_t(n); ++i) {
for (int64_t j = int64_t(0); j < int64_t(m); ++j) {
G[i][T[i][j] - 'a'][j] = 1;
ans[i][j] = 1;
}
}
int64_t r, c;
rd(r, c);
vector<string> P(r);
rd(P);
for (int64_t x = int64_t(0); x < int64_t(r); ++x) {
for (int64_t y = int64_t(0); y < int64_t(c); ++y) {
if (P[x][y] == '?') continue;
for (int64_t i = int64_t(0); i < int64_t(n); ++i) {
int64_t c = P[x][y] - 'a';
ans[i] &= shift(G[(i + x) % n][c], (y % m), m);
}
}
}
for (int64_t i = int64_t(0); i < int64_t(n); ++i) {
for (int64_t j = int64_t(0); j < int64_t(m); ++j) {
cout << ans[i][j];
}
cout << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 61;
const long long mod = 1000000007;
const int maxn = 404;
bitset<maxn> cb[30][maxn];
bitset<maxn> ans[maxn];
bitset<maxn> shift(bitset<maxn> b, int len, int sh);
int main() {
std::ios::sync_with_stdio(false);
int i = 0, j = 0, k = 0;
int n, m, c, r;
scanf("%d%d", &n, &m);
getchar();
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
char ch = getchar();
cb[ch - 'a'][i][j] = true;
}
getchar();
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
ans[i][j] = true;
}
}
scanf("%d%d", &r, &c);
getchar();
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
char ch = getchar();
if (ch == '?') continue;
int shiftx = ((-i) % n + n) % n;
int shifty = j % m;
for (k = 0; k < n; k++) {
int nk = k + shiftx;
if (nk >= n) nk -= n;
ans[nk] &= shift(cb[ch - 'a'][k], m, shifty);
}
}
getchar();
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
printf("%d", ans[i][j] ? 1 : 0);
}
puts("");
}
return 0;
}
bitset<maxn> shift(bitset<maxn> b, int len, int sh) {
return (b >> sh) | (b << (len - sh));
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.