text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int ar[200005], ans[200005], pos[200005];
char ch[200005];
int n, m, ii, k;
vector<pair<int, int>> g[200005];
vector<int> divi[200005];
int Tree[200005 * 4];
void update(int node, int be, int en, int id, int val) {
if (id > en || id < be) return;
if (be == en) {
Tree[node]++;
return;
}
int mid = (be + en) / 2;
update(node * 2, be, mid, id, val);
update(node * 2 + 1, mid + 1, en, id, val);
Tree[node] = Tree[node * 2] + Tree[node * 2 + 1];
}
int query(int node, int be, int en, int i, int j) {
if (i > en || j < be) return 0;
if (i <= be && j >= en) return Tree[node];
int mid = (be + en) / 2;
return query(node * 2, be, mid, i, j) +
query(node * 2 + 1, mid + 1, en, i, j);
}
void solve() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &ar[i]), pos[ar[i]] = i;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[y].push_back({x, i});
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int x = pos[i], y = pos[j];
divi[max(x, y)].push_back(min(x, y));
}
}
for (int i = 1; i <= n; i++) {
for (int v : divi[i]) {
update(1, 1, n, v, 1);
}
for (auto it : g[i]) {
ans[it.second] = query(1, 1, n, it.first, i);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
int main() {
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m;
int a[maxn], pos[maxn], c[maxn], ans[maxn];
vector<int> v[maxn];
struct query {
int id, x, y;
friend bool operator<(query a, query b) { return a.x > b.x; }
} q[maxn];
int lowbit(int x) { return x & -x; }
int sum(int p) {
int res = 0;
while (p > 0) {
res += c[p];
p -= lowbit(p);
}
return res;
}
void add(int p, int val) {
while (p <= n) {
c[p] += val;
p += lowbit(p);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = a[i]; j <= n; j += a[i]) {
if (pos[j] >= i)
v[i].push_back(pos[j]);
else
v[pos[j]].push_back(i);
}
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &q[i].x, &q[i].y);
if (q[i].y < q[i].x) swap(q[i].x, q[i].y);
q[i].id = i;
}
sort(q, q + m);
int maxx = n + 1;
for (int i = 0; i < m; i++) {
int x = q[i].x, y = q[i].y, len;
for (int j = x; j < maxx; j++) {
len = v[j].size();
for (int k = 0; k < len; k++) add(v[j][k], 1);
}
ans[q[i].id] = sum(y) - 0;
maxx = x;
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e6 + 5;
int n, m, cnt, a[N], t[N];
int ans[N], tree[4 * N];
struct data {
int x, y;
int k;
};
data q[N], p[N];
bool cmp(data u, data v) { return (u.y < v.y); }
void Input() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
t[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int curr = a[i];
while (curr <= n) {
int index = t[curr];
cnt++, curr += a[i];
p[cnt].x = min(i, index);
p[cnt].y = max(i, index);
}
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &q[i].x, &q[i].y);
q[i].k = i;
}
sort(q + 1, q + m + 1, cmp);
sort(p + 1, p + cnt + 1, cmp);
}
void Update(int k, int l, int r, int idx) {
if (l > idx || r < idx) return;
if (l == r) {
tree[k] += 1;
return;
}
int mid = (l + r) / 2;
Update(k * 2, l, mid, idx);
Update(k * 2 + 1, mid + 1, r, idx);
tree[k] = tree[k * 2] + tree[k * 2 + 1];
}
int Get(int k, int l, int r, int L, int R) {
if (l > R || r < L) return 0;
if (L <= l && r <= R) return tree[k];
int mid = (l + r) / 2;
return (Get(k * 2, l, mid, L, R) + Get(k * 2 + 1, mid + 1, r, L, R));
}
void Solve() {
int index = 1;
for (int i = 1; i <= m; i++) {
while (index <= cnt && p[index].y <= q[i].y) {
Update(1, 1, n, p[index].x);
index++;
}
ans[q[i].k] = Get(1, 1, n, q[i].x, q[i].y);
}
for (int i = 1; i <= m; i++) printf("%d \n", ans[i]);
}
int main() {
Input();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 200010;
int n, m;
int a[max_n], ind[max_n];
vector<int> D[max_n];
int BIT[max_n + 1];
int bn;
void BITinit() { fill(BIT + 1, BIT + bn + 1, 0); }
void BITupd(int pos, int inc) {
for (int i = pos; i <= bn; i += ((i) & (-i))) BIT[i] += inc;
}
int BITprs(int k) {
int ret = 0;
for (int i = k; i > 0; i -= ((i) & (-i))) ret += BIT[i];
return ret;
}
int BITqry(int l, int r) { return BITprs(r) - BITprs(l - 1); }
struct P {
int IN, l, r;
P() {}
P(int IN_, int l_, int r_) {
IN = IN_;
l = l_;
r = r_;
}
};
struct less_P_r : public binary_function<P, P, bool> {
bool operator()(const P &a, const P &b) {
return (a.r < b.r or (a.r == b.r and a.l < b.l));
}
};
P interval[max_n];
int res[max_n];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ind[a[i]] = i;
}
int x, y;
for (int i = 0; i < m; i++) {
scanf("%d%d", &x, &y);
interval[i] = P(i, x, y);
}
sort(interval, interval + m, less_P_r());
for (int i = 1; i <= n; i++)
for (int j = 2 * i; j <= n; j += i) D[j].push_back(i);
int cnt = 0;
bn = n;
for (int i = 1; i <= n; i++) {
int k = a[i];
for (int j = k; j <= n; j += k)
if (ind[j] <= i) BITupd(ind[j], 1);
for (int j = 0; j < D[k].size(); j++)
if (ind[D[k][j]] <= i) BITupd(ind[D[k][j]], 1);
while (interval[cnt].r == i) {
res[interval[cnt].IN] = BITqry(interval[cnt].l, i);
cnt++;
}
}
for (int i = 0; i < m; i++) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 200000 + 10;
int a[M];
int pos[M];
vector<int> f[M];
vector<pair<int, int> > qe[M];
long long int ans[M];
struct TREE {
int l;
int r;
long long int s;
} tree[4 * M];
void build(int l, int r, int node) {
tree[node].l = l;
tree[node].r = r;
tree[node].s = 0;
if (l == r) {
return;
} else {
int m = (l + r) / 2;
build(l, m, node * 2);
build(m + 1, r, node * 2 + 1);
}
}
void update(int idx, int node, int val) {
int l = tree[node].l;
int r = tree[node].r;
tree[node].s += val;
if (l == r) {
return;
} else {
int m = (l + r) / 2;
if (idx <= m) {
update(idx, node * 2, val);
} else {
update(idx, node * 2 + 1, val);
}
}
}
long long int query(int l, int r, int node) {
if (l > r) {
return 0;
}
if (l <= tree[node].l && tree[node].r <= r) {
return tree[node].s;
}
int m = (tree[node].l + tree[node].r) / 2;
if (r <= m) {
return query(l, r, node * 2);
} else {
if (l >= m + 1) {
return query(l, r, node * 2 + 1);
} else {
long long int s1 = query(l, m, node * 2);
long long int s2 = query(m + 1, r, node * 2 + 1);
return s1 + s2;
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int p1 = pos[i];
int p2 = pos[j];
if (p1 > p2) {
int tmp = p1;
p1 = p2;
p2 = tmp;
}
f[p2].push_back(p1);
}
}
for (int q = 0; q < m; q++) {
int l, r;
scanf("%d%d", &l, &r);
pair<int, int> p = make_pair(q, l);
qe[r].push_back(p);
}
build(1, n, 1);
for (int i = 1; i <= n; i++) {
if (f[i].size() > 0) {
for (int j = 0; j < f[i].size(); j++) {
int idx = f[i][j];
update(idx, 1, 1);
}
}
if (qe[i].size() > 0) {
for (int j = 0; j < qe[i].size(); j++) {
pair<int, int> p = qe[i][j];
int idx = p.first;
int l = p.second;
long long int s1 = query(1, l - 1, 1);
long long int s2 = query(1, i, 1);
ans[idx] = s2 - s1;
}
}
}
for (int i = 0; i < m; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v2d = vector<vector<T> >;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 2e5 + 10;
int n, m, a[maxN], pos[maxN];
vector<int> divisors[maxN], multiples[maxN];
struct query {
int l, r, idx;
long long res;
query() {}
query(int l, int r, int idx) : l(l), r(r), idx(idx) {}
};
vector<query> q;
long long f[maxN];
void update(int x, long long d) {
for (; x <= n; x += x & -x) {
f[x] += d;
}
}
long long prefix(int x) {
long long r = 0;
for (; x > 0; x &= x - 1) {
r += f[x];
}
return r;
}
void init() {
for (int i = 1; i <= (int)(n); ++i) {
for (int j = i; j <= n; j += i) {
divisors[j].emplace_back(i);
multiples[i].emplace_back(j);
}
}
for (int i = 1; i <= (int)(n); ++i) {
sort((divisors[i]).begin(), (divisors[i]).end());
sort((multiples[i]).begin(), (multiples[i]).end());
}
}
void solve() {
cin >> n >> m;
init();
for (int i = 1; i <= (int)(n); ++i) {
cin >> a[i];
pos[a[i]] = i;
}
for (int i = 1; i <= (int)(m); ++i) {
int l, r;
cin >> l >> r;
q.emplace_back(l, r, i);
}
sort((q).begin(), (q).end(), [](query x, query y) { return x.r < y.r; });
int idx = 0;
for (int i = 1; i <= (int)(n); ++i) {
for (auto &div : divisors[a[i]]) {
if (pos[div] <= i) {
update(pos[div], 1);
}
}
for (auto &mul : multiples[a[i]]) {
if (pos[mul] < i) {
update(pos[mul], 1);
}
}
while (idx < m && q[idx].r <= i) {
q[idx].res = prefix(q[idx].r) - prefix(q[idx].l - 1);
++idx;
}
}
sort((q).begin(), (q).end(), [](query x, query y) { return x.idx < y.idx; });
for (auto &qr : q) {
cout << qr.res << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = ((int)2e5) + 5;
const int smaxn = 4 * maxn;
using namespace std;
int arr[maxn], posOf[maxn];
vector<pair<int, int>> divPairs, query, combined;
long long int ans[maxn];
long long int tree[maxn];
int read(int idx) {
int sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val) {
while (idx < maxn) {
tree[idx] += val;
idx += (idx & -idx);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
posOf[arr[i]] = i + 1;
}
for (int i = 0; i < n; i++) {
int div = arr[i];
while (div <= n) {
if ((div) % arr[i] == 0) {
divPairs.push_back(make_pair(min(posOf[arr[i]], posOf[div]),
max(posOf[arr[i]], posOf[div])));
combined.push_back(
make_pair(min(posOf[arr[i]], posOf[div]), divPairs.size()));
}
div += arr[i];
}
}
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
query.push_back(make_pair(l, r));
combined.push_back(make_pair(l, -(i + 1)));
}
sort(combined.begin(), combined.end());
reverse(combined.begin(), combined.end());
for (int i = 0; i < combined.size(); i++) {
int type = combined[i].second;
if (type < 0) {
int l = combined[i].first;
int r = query[-type - 1].second;
ans[-type - 1] = read(r) - read(l - 1);
} else {
int r = divPairs[type - 1].second;
update(r, 1);
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
static constexpr int MAXN = 200000;
static constexpr int INF = std::numeric_limits<int>::max();
class BIT {
private:
std::vector<int> tree;
public:
BIT(int size) : tree(size + 1) {}
void resize(int sz) { tree.resize(sz + 1); }
void update(int idx, int value) {
idx++;
for (int i = idx; i < tree.size(); i += i & -i) {
tree[i] += value;
}
}
int query(int idx) {
idx++;
int answer = 0;
for (int i = idx; i > 0; i -= i & -i) answer += tree[i];
return answer;
}
int query() { return query(static_cast<int>(tree.size()) - 2); }
};
struct query {
int left;
int right;
int index;
query(int l, int r, int i) : left(l), right(r), index(i) {}
};
int main() {
int size, qcount;
std::scanf("%d %d", &size, &qcount);
std::vector<int> values(size);
std::vector<int> index_of(size + 1);
for (int i = 0; i < size; i++) {
std::scanf("%d", &values[i]);
index_of[values[i]] = i;
}
std::vector<std::pair<int, int> > segments;
for (int i = 0; i < size; i++) {
for (int j = values[i]; j <= size; j += values[i]) {
int left = i;
int right = index_of[j];
if (left > right) std::swap(left, right);
segments.emplace_back(left, right);
}
}
std::sort(segments.begin(), segments.end(),
[&](const std::pair<int, int>& a, const std::pair<int, int>& b) {
return a.second < b.second;
});
std::vector<query> queries;
for (int i = 0; i < qcount; i++) {
int left, right;
std::scanf("%d %d", &left, &right);
left--, right--;
queries.emplace_back(left, right, i);
}
std::sort(queries.begin(), queries.end(),
[&](const query& a, const query& b) { return a.right < b.right; });
BIT tree(size + 1);
int curr_pair = 0;
static int answer[MAXN];
for (int i = 0; i < queries.size(); i++) {
int right = queries[i].right;
while (curr_pair < segments.size() && segments[curr_pair].second <= right)
tree.update(segments[curr_pair++].first, 1);
answer[queries[i].index] = tree.query() - tree.query(queries[i].left - 1);
}
for (int i = 0; i < qcount; i++) std::printf("%d\n", answer[i]);
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void mini(T &a, T b) {
if (b < a) a = b;
}
template <class T>
inline void maxi(T &a, T b) {
if (b > a) a = b;
}
int bit[200005], n, m;
inline void update(int x) {
for (; x <= n; x += x & (-x)) bit[x]++;
}
inline int get(int x) {
int s = 0;
for (; x; x -= x & (-x)) s += bit[x];
return s;
}
int p[200005], r[200005];
int L[200005], R[200005];
int g[200005], ans[200005];
vector<int> E[200005];
vector<pair<int, int> > v[200005];
void add(int i, int j) {
if (i == j) return;
E[i].push_back(j);
E[j].push_back(i);
}
int main() {
cin >> n >> m;
for (int i = 1; i < n + 1; i++) scanf("%d", p + i);
for (int i = 1; i < n + 1; i++) r[p[i]] = i;
for (int i = 1; i < m + 1; i++) {
scanf("%d%d", L + i, R + i);
v[R[i]].push_back(pair<int, int>(L[i], i));
}
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j * j <= i; j++)
if (i % j == 0) {
add(i, j);
if (j * j != i) add(i, i / j);
}
}
for (int i = 1; i < n + 1; i++) {
for (typeof E[p[i]].begin() e = E[p[i]].begin(); e != E[p[i]].end(); e++) {
int j = r[*e];
if (j < i) update(j);
}
update(i);
for (typeof v[i].begin() e = v[i].begin(); e != v[i].end(); e++) {
int le = e->first, ind = e->second;
ans[ind] = get(i) - get(le - 1);
}
}
for (int i = 1; i < m + 1; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2000000 + 10;
struct info {
int l, r, id;
} q[MAX_N];
vector<int> d[MAX_N];
int n, m, vis[MAX_N], ans[MAX_N], c[MAX_N];
bool cmp(info i, info j) { return i.l < j.l; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
vis[x] = i;
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i) {
int a = vis[i], b = vis[j];
if (a > b) swap(a, b);
d[a].push_back(b);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + m + 1, cmp);
int p = m;
for (int i = n; i >= 1; i--) {
for (int j = 0; j < d[i].size(); j++)
for (int k = d[i][j]; k <= n; k += k & -k) c[k]++;
while (p >= 1 && q[p].l == i) {
int res = 0;
for (int j = q[p].r; j > 0; j -= j & -j) res += c[j];
ans[q[p].id] = res;
p--;
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200007;
const int MAXM = 4000007;
struct Point {
int l, r, n;
long long ans;
};
int i, j, k, n, m, t, nbit, cnt, l, r;
int a[MAXN], p[MAXN];
long long x, y;
long long bitl[MAXN], bitr[MAXN];
Point q[MAXN], e[MAXM];
bool cmpByR(const Point &a, const Point &b) { return a.r < b.r; }
bool cmpByN(const Point &a, const Point &b) { return a.n < b.n; }
long long sum(long long *bit, int i) {
long long s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(long long *bit, int i, int x) {
while (i <= nbit) {
bit[i] += x;
i += i & -i;
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
memset(bitl, 0, sizeof(bitl));
memset(bitr, 0, sizeof(bitr));
memset(a, 0, sizeof(a));
memset(p, 0, sizeof(p));
memset(q, 0, sizeof(q));
memset(e, 0, sizeof(e));
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
for (i = 0; i < m; i++) {
scanf("%d%d", &q[i].l, &q[i].r);
if (q[i].l > q[i].r) {
swap(q[i].l, q[i].r);
}
q[i].n = i;
}
sort(q, q + m, cmpByR);
cnt = 0;
for (i = 1; i <= n; i++) {
for (j = i + i; j <= n; j += i) {
e[cnt].l = min(p[i], p[j]);
e[cnt++].r = max(p[i], p[j]);
}
}
sort(e, e + cnt, cmpByR);
nbit = n;
t = 0;
for (i = 0; i < m; i++) {
while (e[t].r <= q[i].r && t < cnt) {
add(bitl, e[t].l, 1);
add(bitr, e[t].r, 1);
t++;
}
x = sum(bitl, q[i].l - 1);
y = sum(bitr, q[i].r);
q[i].ans = y - x + q[i].r - q[i].l + 1;
}
sort(q, q + m, cmpByN);
for (i = 0; i < m; i++) {
printf("%I64d\n", q[i].ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = (1 << 30) - 1;
const int MAXN = 400010;
const int mod = 1e9 + 7;
int n, m;
int pos[MAXN], A[MAXN];
vector<int> L[MAXN];
vector<int> R[MAXN];
long long ans[MAXN];
int C[MAXN];
int Q[MAXN][2];
void Update(int x, int d) {
while (x <= n) {
C[x] += d;
x += x & (-x);
}
}
int Getsum(int x) {
int res = 0;
while (x) {
res += C[x];
x -= x & (-x);
}
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &A[i]);
pos[A[i]] = i;
}
for (int i = 1; i <= m; ++i) {
int a, b;
scanf("%d%d", &a, &b);
Q[i][0] = a;
Q[i][1] = b;
L[a].push_back(i);
R[b].push_back(i);
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < L[i].size(); ++j) {
int id = L[i][j];
int tR = Q[id][1];
ans[id] -= Getsum(tR) - Getsum(i - 1);
}
for (int j = 1; j * A[i] <= n; ++j) {
Update(pos[j * A[i]], 1);
}
for (int j = 0; j < R[i].size(); ++j) {
int id = R[i][j];
int tL = Q[id][0];
ans[id] += Getsum(i) - Getsum(tL - 1);
}
}
for (int i = 1; i <= m; ++i) {
printf("%I64d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void setIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long N = 2e5 + 5;
const long long M = 5e5 + 5;
const long long L = 2e1 + 0;
const long long inf = 9e9;
const long long mod = 998244353;
long long xyz = 1;
long long n, m;
long long bit[N];
long long arr[N];
long long pos[N];
long long ans[N];
vector<long long> cur[N];
vector<long long> fac[N];
long long get(long long i) {
long long res = 0;
for (; i >= 1; i -= (-i & i)) res += bit[i];
return res;
}
void add(long long i, long long v = 1) {
for (; i <= n; i += (-i & i)) bit[i] += v;
}
void upd(long long x, long long p) {
for (long long v : fac[x]) {
if (pos[v] <= p)
add(pos[v]);
else {
cur[pos[v]].push_back(p);
}
}
}
void prc() {
for (long long i = 1; i <= n; i++) {
for (long long j = i; j <= n; j += i) fac[j].push_back(i);
}
}
void run() {
cin >> n >> m;
prc();
for (long long i = 1; i <= n; i++) cin >> arr[i], pos[arr[i]] = i;
vector<pair<pair<long long, long long>, long long>> que(m);
for (long long i = 0; i < m; i++)
cin >> que[i].first.second >> que[i].first.first, que[i].second = i;
sort(begin(que), end(que));
long long p = 1;
for (long long i = 0; i < m; i++) {
long long hi = que[i].first.first;
long long lo = que[i].first.second;
while (p <= hi) {
upd(arr[p], p);
for (long long ele : cur[p]) add(ele);
p++;
}
long long sub = lo == 1 ? 0 : get(lo - 1);
ans[que[i].second] = get(n) - sub;
}
for (long long i = 0; i < m; i++) cout << ans[i] << "\n";
}
signed main() {
setIO();
while (xyz--) run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> Right[201000];
vector<pair<int, int> > Q[201000];
int tree[201000];
int N, M;
int lowbit(int x) { return x & (-x); }
void insert(int pos, int val) {
for (int x = pos; x <= N; x += lowbit(x)) tree[x] += val;
}
int getsum(int pos) {
int res = 0;
for (int x = pos; x > 0; x -= lowbit(x)) res += tree[x];
return res;
}
int pos[201000], A[201000];
int ans[201000];
int main() {
int i, j, a, b;
while (scanf("%d%d", &N, &M) != EOF) {
for (i = 0; i < N; i++)
scanf("%d", &A[i + 1]), pos[A[i + 1]] = i + 1, Right[i + 1].clear(),
Q[i + 1].clear();
for (i = 1; i <= N; i++)
for (j = i; j <= N; j += i) {
int L = pos[i], R = pos[j];
if (L > R) swap(L, R);
Right[L].push_back(R);
}
for (i = 0; i < M; i++) {
scanf("%d%d", &a, &b);
Q[a].push_back(pair<int, int>(b, i));
}
for (i = 0; i < N + 10; i++) tree[i] = 0;
for (i = N; i > 0; i--) {
for (j = 0; j < Right[i].size(); j++) insert(Right[i][j], 1);
for (j = 0; j < Q[i].size(); j++)
ans[Q[i][j].second] = getsum(Q[i][j].first);
}
for (i = 0; i < M; i++) printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
const int maxn = (4e5 + 12);
int n, m, plc[maxn], seg[4 * maxn], a[maxn], lazy[4 * maxn], ans[maxn];
vector<pair<int, int> > pof[maxn];
vector<int> ad[maxn];
void add(int id, int l, int r, int st, int en);
int get(int id, int l, int r, int st, int en);
void shift(int id, int l, int r);
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
plc[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
ad[i].push_back(i);
for (int j = i + i; j <= n; j += i) {
ad[i].push_back(j);
ad[j].push_back(i);
}
}
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
pof[r - 1].push_back({i, l});
}
for (int f = 0; f < n; f++) {
int i = a[f];
for (int j = 0; j < ad[i].size(); j++) {
int x = plc[ad[i][j]];
if (x <= f) add(1, 0, n, x, x + 1);
}
for (int i = 0; i < pof[f].size(); i++) {
int id = pof[f][i].first;
int l = pof[f][i].second;
ans[id] = get(1, 0, n, l - 1, f + 1);
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
void add(int id, int l, int r, int st, int en) {
if (en <= l || r <= st) {
return;
}
if (st <= l && r <= en) {
seg[id]++;
return;
}
int mid = (l + r) >> 1;
add(id * 2 + 0, l, mid, st, en);
add(id * 2 + 1, mid, r, st, en);
seg[id] = seg[id * 2 + 0] + seg[id * 2 + 1];
return;
}
int get(int id, int l, int r, int st, int en) {
if (en <= l || r <= st) {
return 0;
}
if (st <= l && r <= en) {
return seg[id];
}
int mid = (l + r) >> 1;
return get(id * 2 + 0, l, mid, st, en) + get(id * 2 + 1, mid, r, st, en);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int MAXN = 200010;
int n, m, x, y, t, l, r;
int pos[MAXN];
int ans[MAXN];
int BIT[MAXN];
vector<int> vec[MAXN];
vector<pair<int, int>> query[MAXN];
void add(int id, int x) {
for (; id < MAXN; id += (id & (-id))) BIT[id] += x;
}
int get(int id) {
int res = 0;
for (; id; id -= (id & (-id))) res += BIT[id];
return res;
}
void upd(int l, int r) {
if (l > r) swap(l, r);
vec[l].push_back(r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> x, pos[x] = i;
for (int i = 1; i <= n; i++)
for (int j = i; j < MAXN; j += i) upd(pos[i], pos[j]);
for (int i = 1; i <= m; i++) {
cin >> l >> r;
query[l].push_back({r, i});
}
for (int i = n; i; i--) {
for (int x : vec[i]) add(x, 1);
for (auto p : query[i]) ans[p.second] = get(p.first);
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct elist {
int v, last;
} e[200010], e2[200010];
int n, m, p[200010], etot, zh[200010], etot2, zh2[200010];
int pos[200010], l[200010], r[200010];
long long final[200010], tt[800010];
void eadd(int u, int v) {
e[++etot].v = v;
e[etot].last = zh[u];
zh[u] = etot;
}
void eadd2(int u, int v) {
e2[++etot2].v = v;
e2[etot2].last = zh2[u];
zh2[u] = etot2;
}
void Init() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
pos[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
eadd(l[i], i);
eadd2(r[i], i);
}
}
int lowbit(int x) { return (x & (-x)); }
int Query(int x) {
int tot = 0;
while (x) {
tot += tt[x];
x -= lowbit(x);
}
return tot;
}
void Update(int x) {
while (x <= n) {
tt[x]++;
x += lowbit(x);
}
}
void solve() {
for (int i = 1; i <= n; i++) {
for (int j = zh[i]; j; j = e[j].last)
final[e[j].v] -= ((long long)Query(r[e[j].v]) - (long long)Query(i - 1));
for (int j = p[i]; j <= n; j += p[i]) Update(pos[j]);
for (int j = zh2[i]; j; j = e2[j].last)
final[e2[j].v] +=
((long long)Query(i) - (long long)Query(l[e2[j].v] - 1));
}
for (int i = 1; i <= m; i++) printf("%I64d\n", final[i]);
}
int main() {
Init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
struct D {
int x, y, id;
bool operator<(const D& a) const { return x < a.x; }
};
int n, a[200005], m, ps[200005];
D qr[200005];
int tr[200005];
int qrs[200005];
void add(int i) {
for (; i <= n; i += (i & -i)) {
tr[i]++;
}
}
int qry(int i) {
int rs = 0;
for (; i > 0; i -= (i & -i)) {
rs += tr[i];
}
return rs;
}
int main() {
int t, i, j, k, x;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), ps[a[i]] = i;
for (i = 0; i < m; i++) {
scanf("%d%d", &qr[i].x, &qr[i].y);
qr[i].id = i;
}
sort(qr, qr + m);
int l;
l = n;
for (i = m - 1; i > -1; i--) {
for (; l >= qr[i].x; l--) {
x = a[l];
for (k = 2; x * k <= n; k++) {
if (ps[x * k] >= l) {
add(ps[x * k]);
}
}
for (k = 1; k * k < x; k++) {
if (x % k == 0) {
if (ps[k] >= l) add(ps[k]);
j = x / k;
if (ps[j] >= l) add(ps[j]);
}
}
if (k * k == x && ps[k] >= l) add(ps[k]);
}
qrs[qr[i].id] = qry(qr[i].y);
}
for (i = 0; i < m; i++) printf("%d\n", qrs[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(2e5) + 1;
long long st[MAXN * 4], ans[MAXN];
int A[MAXN], N, M, pos[MAXN];
struct datapos {
vector<pair<int, int>> q;
vector<int> lefties;
} d[MAXN];
void st_upd(int si, int ss, int se, int pos) {
while (1) {
assert(ss <= pos && pos <= se);
st[si]++;
if (ss == se) break;
int mid = (ss + se) / 2;
if (pos <= mid) {
si = si * 2;
se = mid;
} else {
si = si * 2 + 1;
ss = mid + 1;
}
}
}
long long st_que(int si, int ss, int se, int left, int right) {
assert(ss <= se);
assert(left <= right);
if (left > se || right < ss) return 0;
if (left <= ss && se <= right) return st[si];
int mid = (ss + se) / 2;
return st_que(si * 2, ss, mid, left, right) +
st_que(si * 2 + 1, mid + 1, se, left, right);
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", A + i);
pos[A[i]] = i;
}
for (int queryi = 0, left, right; queryi < M; queryi++) {
scanf("%d%d", &left, &right);
d[right].q.push_back({left, queryi});
}
for (int num = 1; num <= N; num++) {
for (int multi = num; multi <= N; multi += num) {
int left = min(pos[num], pos[multi]);
int right = max(pos[num], pos[multi]);
d[right].lefties.push_back(left);
}
}
for (int posi = 1; posi <= N; posi++) {
for (auto left : d[posi].lefties) st_upd(1, 1, N, left);
for (auto qu : d[posi].q) ans[qu.second] = st_que(1, 1, N, qu.first, posi);
}
for (int i = 0; i < M; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 100;
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
int n, m;
int a[N];
vector<int> vec[N];
pair<pair<int, int>, int> b[N];
int mapp[N];
int ans[N];
int seg[N << 2];
inline void add(int, int, int = 1, int = 0, int = N);
inline int get(int, int = 1, int = 0, int = N);
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
mapp[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int j = 1;
while (j * i <= n) {
if (mapp[j * i] >= mapp[i]) vec[mapp[j * i]].push_back(mapp[i]);
if (mapp[i] > mapp[j * i]) vec[mapp[i]].push_back(mapp[j * i]);
j++;
}
}
for (int i = 0; i < m; i++) {
cin >> b[i].first.second >> b[i].first.first;
b[i].first.second--;
b[i].first.first--;
b[i].second = i;
}
sort(b, b + m);
int k = 0;
for (int t = 0; t < m; t++) {
while (k <= b[t].first.first) {
for (int i = 0; i < vec[k].size(); i++) add(0, vec[k][i] + 1);
k++;
}
ans[b[t].second] = get(b[t].first.second);
}
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
}
inline void add(int st, int en, int id, int l, int r) {
if (en <= l or r <= st) return;
if (st <= l and r <= en) {
seg[id]++;
return;
}
int mid = (l + r) >> 1, lc = id << 1, rc = lc | 1;
add(st, en, lc, l, mid);
add(st, en, rc, mid, r);
}
inline int get(int idx, int id, int l, int r) {
if (idx < l or r <= idx) return 0;
if (l + 1 == r) return seg[id];
int mid = (l + r) >> 1, lc = id << 1, rc = lc | 1;
return get(idx, lc, l, mid) + get(idx, rc, mid, r) + seg[id];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
int n, m;
int a[N];
int p[N];
struct Question {
int i;
int j;
int id;
};
bool operator<(Question a, Question b) { return a.i > b.i; }
Question q[N];
int sol[N];
int aib[N];
void add(int i) {
while (i <= n) {
aib[i]++;
i += i & (-i);
}
}
int get(int i) {
int r = 0;
while (i > 0) {
r += aib[i];
i -= i & (-i);
}
return r;
}
vector<int> push[N];
void addup(int pos) {
for (auto &x : push[pos]) {
add(x);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int l = p[i];
int r = p[j];
if (l > r) {
swap(l, r);
}
push[l].push_back(r);
}
}
for (int id = 1; id <= m; id++) {
cin >> q[id].i >> q[id].j;
q[id].id = id;
}
sort(q + 1, q + m + 1);
int last = n + 1;
for (int id = 1; id <= m; id++) {
while (last > q[id].i) {
last--;
addup(last);
}
sol[q[id].id] = get(q[id].j);
}
for (int id = 1; id <= m; id++) {
cout << sol[id] << "\n";
}
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class L>
bool smax(T &x, L y) {
return x < y ? (x = y, 1) : 0;
}
template <class T, class L>
bool smin(T &x, L y) {
return y < x ? (x = y, 1) : 0;
}
const int maxn = 2e5 + 17;
int n, a[maxn], m, iman[maxn], pos[maxn], ans[maxn];
int hamid(int l, int r) {
int ans = 0;
for (; l; l ^= l & -l) ans -= iman[l];
for (r++; r; r ^= r & -r) ans += iman[r];
return ans;
}
void majid(int p) {
for (p++; p < maxn; p += p & -p) iman[p]++;
}
vector<int> ass[maxn];
vector<pair<int, int> > qs[maxn];
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> a[i], pos[a[i]] = i;
for (int i = 1; i <= n; i++)
for (int j = i * 2; j <= n; j += i)
ass[max(pos[i], pos[j])].push_back(min(pos[i], pos[j]));
for (int i = 0, l, r; i < m; i++)
cin >> l >> r, qs[r - 1].push_back({l - 1, i});
for (int r = 0; r < n; r++) {
for (auto x : ass[r]) majid(x);
for (auto q : qs[r]) ans[q.second] = hamid(q.first, r) + r - q.first + 1;
}
for (int i = 0; i < m; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "{" << p.first << "," << p.second << "}";
return os;
}
const int N = 2e5 + 5;
const int oo = 1e9 + 7;
int p[N];
int id[N];
int ans[N];
vector<pair<int, int> > q[N];
vector<int> del[N];
long long Tree[N];
void update(int idx, long long x, int n) {
while (idx <= n) {
Tree[idx] += x;
idx += (idx & -idx);
}
}
long long query(int idx) {
long long sum = 0;
while (idx > 0) {
sum += Tree[idx];
idx -= (idx & -idx);
}
return sum;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> p[i];
id[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
q[x].push_back({y, i});
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int x = id[i];
int y = id[j];
if (x > y) swap(x, y);
del[x].push_back(y);
update(y, 1, n);
}
}
for (int i = 1; i <= n; i++) {
for (auto x : q[i]) {
ans[x.second] = query(x.first);
}
for (auto x : del[i]) update(x, -1, n);
}
for (int i = 1; i <= m; i++) cout << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 100000 + 20;
vector<pair<int, int> > q[MAXN];
vector<int> d[MAXN];
int mp[MAXN], a[MAXN], ans[MAXN], n, m;
int data[4 * MAXN];
void add(int p, int x, int s, int e, int id) {
data[id] += x;
if (e - s < 2) return;
int mid = (s + e) >> 1;
if (p < mid) {
add(p, x, s, mid, 2 * id);
} else {
add(p, x, mid, e, 2 * id + 1);
}
}
int get(int l, int r, int s, int e, int id) {
if (e <= l or r <= s) return 0;
if (l <= s && e <= r) {
return data[id];
}
int mid = (s + e) >> 1;
return get(l, r, s, mid, 2 * id) + get(l, r, mid, e, 2 * id + 1);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
mp[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
if (mp[i] < mp[j]) {
d[j].push_back(i);
} else {
d[i].push_back(j);
}
}
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--;
y--;
q[y].push_back(make_pair(i, x));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < d[a[i]].size(); j++) {
int ja = d[a[i]][j];
ja = mp[ja];
add(ja, 1, 0, n, 1);
}
for (int j = 0; j < q[i].size(); j++) {
int help1, help2, help3;
help1 = q[i][j].first;
help2 = q[i][j].second;
help3 = i;
ans[help1] = get(help2, help3 + 1, 0, n, 1);
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int block = 5000;
const int mod = 1e6;
int n, m;
int p[N];
int bp[N];
vector<int> second[N];
vector<pair<int, int> > q[N];
int tim;
int ans[N];
struct seg {
int t[4 * N] = {0};
void upd(int pos, int z, int v = 1, int l = 1, int r = n) {
if (pos < l || pos > r) return;
if (l == r) return (void)(t[v] += z);
int m = (l + r) >> 1;
upd(pos, z, v * 2, l, m);
upd(pos, z, v * 2 + 1, m + 1, r);
t[v] = t[v * 2] + t[v * 2 + 1];
}
int get(int l, int r, int v = 1, int tl = 1, int tr = n) {
if (l > tr || tl > r) return 0;
if (l <= tl && tr <= r) return t[v];
int m = (tl + tr) >> 1;
return get(l, r, v * 2, tl, m) + get(l, r, v * 2 + 1, m + 1, tr);
}
} rt;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> p[i], bp[p[i]] = i;
for (int j = 1; j <= n; j++) {
for (int x = j; x <= n; x += j) {
second[min(bp[x], bp[j])].push_back(max(bp[x], bp[j]));
}
}
while (m--) {
int x, y;
cin >> x >> y;
q[x].push_back({y, tim++});
}
for (int i = n; i > 0; i--) {
for (auto u : second[i]) rt.upd(u, 1);
for (auto u : q[i]) ans[u.second] = rt.get(i, u.first);
}
for (int i = 0; i < tim; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int II() {
int q;
scanf("%d", &q);
return q;
}
long long LII() {
long long q;
scanf("%lld", &q);
return q;
}
const long long Mx = 200005;
vector<long long> v[Mx], pa[Mx];
vector<pair<long long, long long>> vv[Mx];
long long tree[Mx];
long long ar[Mx], br[Mx];
void update(long long in) {
while (in < Mx) {
tree[in] += 1, in += (in & (-in));
}
}
long long query(long long in) {
long long sum = 0;
while (in > 0) {
sum += tree[in], in -= (in & (-in));
}
return sum;
}
void solve() {
for (long long i = 1; i < Mx; i++) {
for (long long j = i; j < Mx; j += i) {
v[j].push_back(i);
}
}
long long N, M;
cin >> N >> M;
for (long long i = 1; i <= N; i++) {
scanf("%lld", &ar[i]);
br[ar[i]] = i;
}
for (long long i = 1; i <= M; i++) {
long long l, r;
cin >> l >> r;
vv[r].push_back({l, i});
}
vector<pair<long long, long long>> ans;
for (long long i = 1; i <= N; i++) {
for (auto it : v[ar[i]]) {
long long j = br[it];
long long k = i;
if (j > k) swap(j, k);
pa[k].push_back(j);
}
}
for (long long i = 1; i <= N; i++) {
for (auto it : pa[i]) {
update(it);
}
for (auto it : vv[i]) {
ans.push_back({it.second, query(i) - query(it.first - 1)});
}
}
sort(ans.begin(), ans.end());
for (auto it : ans) printf("%lld\n", it.second);
}
int32_t main() {
long long tt;
tt = 1;
long long cas = 1;
while (tt--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e6 + 10;
const long long mod = 998244353;
struct node {
int l, r, id;
} q[N];
int a[N];
int pos[N];
int tr[N];
int p[N];
int lowbit(int x) { return x & -x; }
void add(int x, int c) {
int i;
for (i = x; i < N; i += lowbit(i)) {
tr[i] += c;
}
}
int sum(int x) {
int i;
int ans = 0;
for (i = x; i; i -= lowbit(i)) {
ans += tr[i];
}
return ans;
}
bool cmp(node a, node b) { return a.r < b.r; }
vector<int> num[N];
int ans[N];
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
int i;
for (i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (i = 1; i <= m; i++) {
cin >> q[i].l >> q[i].r;
q[i].id = i;
}
sort(q + 1, q + 1 + m, cmp);
int cur = 1;
for (i = 1; i <= n; i++) {
int tmp = a[i];
for (auto x : num[tmp]) {
add(x, 1);
}
for (int j = tmp; j <= n; j += tmp) {
int d = pos[j];
if (d <= i) {
add(d, 1);
} else {
num[j].push_back(i);
}
}
while (cur <= m && q[cur].r == i) {
ans[q[cur].id] = sum(q[cur].r) - sum(q[cur].l - 1);
cur++;
}
}
for (i = 1; i <= m; i++) {
cout << ans[i] << endl;
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n;
int a[200005];
int q;
vector<int> p[200005];
vector<pair<int, int> > qu[200005];
int tree[800005];
int pos[200005];
int ans[200005];
void upd(int id, int x, int l, int r, int val) {
if (l == r) {
tree[id] += val;
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
upd(id << 1, x, l, mid, val);
else {
upd((id << 1) + 1, x, mid + 1, r, val);
}
tree[id] = tree[id << 1] + tree[(id << 1) + 1];
}
int qry(int id, int x, int y, int l, int r) {
if (x == l && y == r) return tree[id];
int mid = (l + r) >> 1;
if (y <= mid) return qry(id << 1, x, y, l, mid);
if (x > mid) return qry((id << 1) + 1, x, y, mid + 1, r);
return qry(id << 1, x, mid, l, mid) +
qry((id << 1) + 1, mid + 1, y, mid + 1, r);
}
int main() {
scanf(" %d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf(" %d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int L = min(pos[i], pos[j]);
int R = max(pos[i], pos[j]);
p[R].push_back(L);
}
}
for (int i = 1; i <= q; i++) {
int l, r;
scanf(" %d %d", &l, &r);
qu[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; i++) {
for (auto j : p[i]) {
upd(1, j, 1, n, 1);
}
for (auto j : qu[i]) {
ans[j.second] = qry(1, j.first, i, 1, n);
}
}
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, next;
} edge[3000005];
int head[200005], e;
inline void addedge(int u, int v) {
edge[e].v = v;
edge[e].next = head[u];
head[u] = e++;
}
long long num[200005 << 2];
long long lazy[200005 << 2];
long long ans[200005];
int value[200005];
int pos[200005];
struct node {
int l, r, pos;
bool operator<(node temp) const { return r < temp.r; }
} data[200005];
inline void pushdown(int rt) {
if (lazy[rt]) {
num[rt << 1] += lazy[rt];
num[rt << 1 | 1] += lazy[rt];
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
}
inline void update(int L, int R, int l, int r, int rt, int v) {
if (L <= l && r <= R) {
num[rt] += v;
lazy[rt] += v;
return;
}
pushdown(rt);
int m = (l + r) >> 1;
if (L <= m) update(L, R, l, m, rt << 1, v);
if (R > m) update(L, R, m + 1, r, rt << 1 | 1, v);
}
inline long long query(int p, int l, int r, int rt) {
if (l == r) return num[rt];
pushdown(rt);
int m = (l + r) >> 1;
if (p <= m)
return query(p, l, m, rt << 1);
else
return query(p, m + 1, r, rt << 1 | 1);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
e = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &value[i]);
pos[value[i]] = i;
head[i] = -1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j * j <= value[i]; j++) {
if (value[i] % j == 0) {
if (pos[j] <= pos[value[i]]) addedge(value[i], j);
if (value[i] != j && pos[value[i]] <= pos[j]) addedge(j, value[i]);
if (j * j == value[i]) continue;
int k = value[i] / j;
if (pos[k] <= pos[value[i]]) addedge(value[i], k);
if (value[i] != k && pos[value[i]] <= pos[k]) addedge(k, value[i]);
}
}
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &data[i].l, &data[i].r);
data[i].pos = i;
}
sort(data, data + m);
int p = 0;
for (int i = 1; i <= n; i++) {
for (int j = head[value[i]]; j != -1; j = edge[j].next) {
int k = edge[j].v;
update(1, pos[k], 1, n, 1, 1);
}
while (data[p].r == i && p < m) {
ans[data[p].pos] = query(data[p].l, 1, n, 1);
p++;
}
}
for (int i = 0; i < m; i++) {
printf("%I64d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200 * 1000 + 1;
int BIT[MAX];
void add(int i, int v) {
for (; i < MAX; i += i & -i) BIT[i] += v;
}
int sum(int i) {
int s = 0;
for (; i; i -= i & -i) s += BIT[i];
return s;
}
int n, m;
int A[MAX], B[MAX], X[MAX], Y[MAX], Q[MAX + MAX], R[MAX];
vector<int> divisors[MAX], multiples[MAX];
bool cmp(int a, int b) {
int ea = a <= n ? a : Y[a - n];
int eb = b <= n ? b : Y[b - n];
return ea != eb ? ea < eb : a < b;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = i + i; j <= n; j += i) {
divisors[j].push_back(i);
multiples[i].push_back(j);
}
}
for (int i = 1; i <= n; i++) {
cin >> A[i];
B[A[i]] = i;
}
for (int i = 1; i <= m; i++) {
cin >> X[i] >> Y[i];
}
for (int i = 1; i <= n + m; i++) {
Q[i] = i;
}
sort(Q + 1, Q + n + m + 1, cmp);
for (int i = 1; i <= n + m; i++) {
if (Q[i] <= n) {
int index = Q[i];
int value = A[Q[i]];
add(index, 1);
for (size_t j = 0; j < divisors[value].size(); j++) {
int div = divisors[value][j];
if (B[div] < index) {
add(B[div], 1);
}
}
for (size_t j = 0; j < multiples[value].size(); j++) {
int mul = multiples[value][j];
if (B[mul] < index) {
add(B[mul], 1);
}
}
} else {
R[Q[i] - n] = sum(Y[Q[i] - n]) - sum(X[Q[i] - n] - 1);
}
}
for (int i = 1; i <= m; i++) {
cout << R[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7, maxn = 2e5 + 20;
int n, k, m, x, y, q, a[maxn], b[maxn], cnt[maxn << 2];
std::vector<int> v[maxn];
std::vector<pair<int, int> > p[maxn];
int ans[maxn];
void upd(int pos, int val = 1, int id = 1, int l = 0, int r = n) {
if (r - l == 1) {
cnt[id] += val;
return;
}
int mid = (l + r) >> 1;
if (pos < mid)
upd(pos, val, id << 1, l, mid);
else
upd(pos, val, id << 1 | 1, mid, r);
cnt[id] = cnt[id << 1] + cnt[id << 1 | 1];
}
int get(int s, int e, int id = 1, int l = 0, int r = n) {
if (s >= r || e <= l) return 0;
if (s <= l && e >= r) return cnt[id];
int mid = (l + r) >> 1;
return get(s, e, id << 1, l, mid) + get(s, e, id << 1 | 1, mid, r);
}
int32_t main() {
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
b[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) v[j].push_back(b[i]);
}
for (int i = 0; i < q; i++) {
scanf("%d%d", &x, &y);
x--;
p[x].push_back(make_pair(y, i));
}
for (int i = n - 1; i >= 0; i--) {
for (int j : v[a[i]])
if (j >= i) {
upd(j);
}
for (int j = a[i] * 2; j <= n; j += a[i])
if (b[j] > i) {
upd(b[j]);
}
for (int j = 0; j < p[i].size(); j++) {
ans[p[i][j].second] = get(i, p[i][j].first);
}
}
for (int i = 0; i < q; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e17;
const long long N = 2e5 + 200;
const long long bits = 35;
const long long mod = 1e9 + 7;
const long double pi = 3.14159265358979323846;
long long bit[N], pos[N];
vector<long long> st[N];
long long bs = 1;
struct query {
long long i, l, r;
bool operator<(query b) const { return r < b.r; }
};
long long get(long long index) {
long long sum = 0;
index = index + 1;
while (index > 0) {
sum += bit[index];
index -= index & (-index);
}
return sum;
}
void upd(long long index, long long val) {
index = index + 1;
while (index < N) {
bit[index] += val;
index += index & (-index);
}
}
long long ask(long long l, long long r) { return get(r) - get(l - 1); }
void pre(long long n) {
for (long long i = 1; i <= n; i++) {
for (long long j = 2; i * j <= n; j++) {
st[i].push_back(i * j);
st[i * j].push_back(i);
}
st[i].push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
std::cout << std::fixed << std::setprecision(20);
;
long long n, m;
cin >> n >> m;
pre(n);
vector<long long> arr(n), ans(m);
for (long long i = 0; i < n; i++) {
cin >> arr[i];
pos[arr[i]] = i;
}
vector<query> queries(m);
for (long long i = 0; i < m; i++) {
cin >> queries[i].l >> queries[i].r;
queries[i].l--;
queries[i].r--;
queries[i].i = i;
}
sort(queries.begin(), queries.end());
long long ptr = 0;
long long tot = 0;
for (long long i = 0; i < n; i++) {
for (auto x : st[arr[i]]) {
if (pos[x] <= pos[arr[i]]) {
upd(pos[x], 1);
}
}
while (ptr < m && queries[ptr].r == i) {
ans[queries[ptr].i] = ask(queries[ptr].l, queries[ptr].r);
ptr++;
}
}
for (long long i = 0; i < m; i++) {
cout << ans[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(2e5) + 1;
unsigned bt[MAXN], ans[MAXN];
int A[MAXN], N, M, pos[MAXN];
struct datapos {
vector<pair<int, int>> q;
vector<int> lefties;
} d[MAXN];
unsigned getsum(int index) {
unsigned sum = 0;
while (index > 0) {
sum += bt[index];
index -= index & (-index);
}
return sum;
}
void incr(int index) {
while (index <= N) {
bt[index]++;
index += index & (-index);
}
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", A + i);
pos[A[i]] = i;
}
for (int queryi = 0, left, right; queryi < M; queryi++) {
scanf("%d%d", &left, &right);
d[right].q.push_back({left, queryi});
}
for (int num = 1; num <= N; num++) {
for (int multi = 2 * num; multi <= N; multi += num) {
int left = min(pos[num], pos[multi]);
int right = max(pos[num], pos[multi]);
d[right].lefties.push_back(left);
}
}
for (int posi = 1; posi <= N; posi++) {
for (auto left : d[posi].lefties) incr(left);
for (auto qu : d[posi].q)
ans[qu.second] =
getsum(posi) - getsum(qu.first - 1) + (posi - qu.first + 1);
}
for (int i = 0; i < M; i++) printf("%u\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
int n, m, A[maxn + 20], B[maxn + 20], r[maxn + 20], l[maxn + 20],
Ans[maxn + 20], fen[maxn + 20];
map<pair<int, int>, int> M;
vector<int> joft[maxn + 20], Q[maxn + 20];
void add(int x) {
x++;
for (int i = x; i < maxn + 20; i += (i & (-i))) {
fen[i]++;
}
}
int get(int x) {
x++;
int res = 0;
for (int i = x; i; i -= (i & (-i))) {
res += fen[i];
}
return res;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> A[i];
B[A[i]] = i;
}
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i];
Q[l[i]].push_back(r[i]);
M[{l[i], r[i]}] = i;
}
for (int i = 1; i <= n; i++) {
int tmp = i;
while (tmp <= n) {
joft[min(B[i], B[tmp])].push_back(max(B[i], B[tmp]));
tmp += i;
}
}
for (int i = n; i > 0; i--) {
for (int j = 0; j < joft[i].size(); j++) {
add(n + 1 - joft[i][j]);
}
for (int j = 0; j < Q[i].size(); j++) {
int res = get(n + 1 - i);
res -= get(n - Q[i][j]);
Ans[M[{i, Q[i][j]}]] = res;
}
}
for (int i = 0; i < m; i++) {
cout << Ans[M[{l[i], r[i]}]] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-11;
const int MAXN = (int)2e5 + 7;
const int INF = (int)1e9 + 7;
int n, m;
int a[MAXN], ans[MAXN];
vector<pair<int, int> > query[MAXN];
vector<int> seg[MAXN];
int first[MAXN];
int where[MAXN];
int get(int pos) {
int res = 0;
while (pos > 0) {
res += first[pos];
pos &= (pos + 1);
--pos;
}
return res;
}
void inc(int pos) {
while (pos <= n) {
first[pos]++;
pos |= (pos + 1);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
where[a[i]] = i;
}
vector<pair<int, int> > second;
for (int i = 1; i <= n; i++) {
for (int j = i + i; j <= n; j += i) {
int from = where[i];
int to = where[j];
if (from > to) swap(from, to);
seg[to].push_back(from);
}
}
sort(second.begin(), second.end());
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
query[r].push_back(make_pair(l, i));
ans[i] = r - l + 1;
}
for (int i = 1; i <= n; i++) {
for (auto it : seg[i]) inc(it);
for (auto it : query[i]) {
ans[it.second] += get(i) - get(it.first - 1);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2E5 + 100;
struct Query {
int l, id;
} tmp;
vector<Query> Q[MAXN];
vector<int> G[MAXN];
int pos[MAXN], C[MAXN] = {0}, rem[MAXN];
int n;
int lowbit(int x) { return x & (-x); }
void add(int p) {
for (int i = p; i <= n; i += lowbit(i)) C[i]++;
}
int sum(int p) {
int res = 0;
for (int i = p; i > 0; i -= lowbit(i)) res += C[i];
return res;
}
int main() {
int m, in;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &in);
pos[in] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int x = pos[i], y = pos[j];
if (x > y) swap(x, y);
G[y].push_back(x);
}
}
int l, r;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &l, &r);
tmp.l = l;
tmp.id = i;
Q[r].push_back(tmp);
}
for (int i = 1; i <= n; i++) {
int l1 = G[i].size(), l2 = Q[i].size();
for (int j = 0; j < l1; j++) add(G[i][j]);
for (int j = 0; j < l2; j++) {
rem[Q[i][j].id] = sum(i) - sum(Q[i][j].l - 1);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", rem[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n;
k = n;
int a[10] = {0};
int b[10] = {0};
while (k) {
a[k % 10]++;
k = k / 10;
}
string s;
cin >> s;
for (int i = 0; i < s.size(); ++i) {
b[(s[i] - '0') % 10]++;
}
int count, ans = 99999999;
for (int i = 0; i < 10; ++i) {
if (a[i] != 0) {
if (i == 2 || i == 5)
count = (b[2] + b[5]) / (a[2] + a[5]);
else if (i == 6 || i == 9)
count = (b[6] + b[9]) / (a[6] + a[9]);
else
count = b[i] / a[i];
ans = min(ans, count);
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200 + 10;
string a, b;
int cnt1[10], cnt2[10];
int CC = 0x3f3f3f3f;
int main() {
cin >> a >> b;
for (int i = 0; i < (int)a.size(); ++i) ++cnt1[a[i] - '0'];
for (int i = 0; i < (int)b.size(); ++i) ++cnt2[b[i] - '0'];
cnt1[2] += cnt1[5], cnt1[6] += cnt1[9];
cnt2[2] += cnt2[5], cnt2[6] += cnt2[9];
for (int i = 0; i < 10; ++i) {
if (i == 5 || i == 9) continue;
if (cnt1[i]) CC = min(CC, cnt2[i] / cnt1[i]);
}
cout << CC << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
int i, j, ans = 1000000, s1[10] = {0}, s2[10] = {0};
cin >> a;
for (i = 0; i < a.size(); i++) {
s1[a[i] - '0']++;
}
cin >> b;
for (i = 0; i < b.size(); i++) {
s2[b[i] - '0']++;
}
s1[6] += s1[9];
s1[2] += s1[5];
s2[6] += s2[9];
s2[2] += s2[5];
for (i = 0; i <= 9; i++) {
if (i == 9 || i == 5) continue;
if (s1[i] > 0) ans = min(ans, s2[i] / s1[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int freq[10], need[10];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int cnt = INT_MAX, ok = 1;
string t, s;
cin >> t >> s;
for (int i = 0; i < t.length(); ++i) {
if (t[i] == '5') t[i] = '2';
if (t[i] == '9') t[i] = '6';
++need[t[i] - '0'];
}
need[5] = need[2];
need[9] = need[6];
for (int i = 0; i < s.length(); ++i) {
if (s[i] == '5') s[i] = '2';
if (s[i] == '9') s[i] = '6';
++freq[s[i] - '0'];
}
freq[5] = freq[2];
freq[9] = freq[6];
for (int i = 0; i < 10; ++i) {
if (need[i]) {
cnt = min(cnt, int(freq[i] / need[i]));
}
}
cout << cnt << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using std::cin;
using std::cout;
long long MOD = 998244353;
int main() {
string t, w;
cin >> t >> w;
int charT[10], charW[10];
for (int i = 0; i < 10; i++) {
charT[i] = 0;
charW[i] = 0;
}
for (int i = 0; i < t.length(); i++) {
charT[t[i] - 48] += 1;
}
for (int i = 0; i < w.length(); i++) {
charW[w[i] - 48] += 1;
}
charW[2] += charW[5];
charW[6] += charW[9];
charT[2] += charT[5];
charT[6] += charT[9];
int minnum = 10000000;
for (int i = 0; i < 10; i++) {
if (i != 5 && i != 9 && charT[i] != 0) {
minnum = min(minnum, charW[i] / charT[i]);
}
}
cout << minnum << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char t[10];
char digs[205];
int stats[10];
int stats2[10];
int main() {
scanf("%s %s", t, digs);
int i = 0;
while (t[i] != 0) {
if (t[i] == '5') t[i] = '2';
if (t[i] == '9') t[i] = '6';
stats[t[i] - '0']++;
i++;
}
i = 0;
while (digs[i] != 0) {
if (digs[i] == '5') digs[i] = '2';
if (digs[i] == '9') digs[i] = '6';
stats2[digs[i] - '0']++;
i++;
}
int min = 100000000;
for (int i = 0; i < 10; i++) {
if (stats[i] != 0) {
if (stats2[i] / stats[i] < min) min = stats2[i] / stats[i];
}
}
printf("%d\n", min);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[11], b[11], ans = 1000000;
string s;
int main() {
cin >> s;
for (int i = 0; i < s.length(); i++) a[s[i] - 48]++;
cin >> s;
for (int i = 0; i < s.length(); i++) b[s[i] - 48]++;
a[2] += a[5], b[2] += b[5], a[6] += a[9], b[6] += b[9];
for (int i = 0; i <= 9; i++)
if (a[i] > 0 && i != 5 && i != 9) ans = min(ans, b[i] / a[i]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[181];
string s1, s2;
int i, ans;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s1;
cin >> s2;
for (i = 0; i < s1.size(); i++) {
if (s1[i] == '2') s1[i] = '5';
if (s1[i] == '6') s1[i] = '9';
p[s1[i] - 48].first++;
}
for (i = 0; i < s2.size(); i++) {
if (s2[i] == '2') s2[i] = '5';
if (s2[i] == '6') s2[i] = '9';
p[s2[i] - 48].second++;
}
ans = 1000000000;
for (i = 0; i <= 9; i++)
if (p[i].first != 0) ans = min(ans, p[i].second / p[i].first);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e4 + 100;
char s[maxN], t[maxN];
int a[10], b[10];
int n, m;
int main() {
scanf("%s\n%s", s, t);
n = strlen(s);
for (int i = 0; i < n; i++)
if (s[i] == '5')
++a[2];
else if (s[i] == '9')
++a[6];
else
++a[s[i] - '0'];
m = strlen(t);
for (int i = 0; i < m; i++)
if (t[i] == '5')
b[2]++;
else if (t[i] == '9')
++b[6];
else
++b[t[i] - '0'];
int ans = 10000;
for (int i = 0; i < 9; i++) {
if (a[i] > 0) ans = min(ans, b[i] / a[i]);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int d[10], p[10];
int main() {
int t;
cin >> t;
int i = t;
int k = 0;
while (i > 0) {
int temp = i % 10;
if (temp == 5) temp = 2;
if (temp == 9) temp = 6;
d[temp]++;
i /= 10;
k++;
}
string s;
cin >> s;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '5')
p[2]++;
else if (s[j] == '9')
p[6]++;
else
p[(int)s[j] - 48]++;
}
int ans = s.size() / k;
for (int i = 0; i < 10; i++) {
if (d[i] != 0) {
ans = min(ans, p[i] / d[i]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
char t[10];
char a[210];
int h[10];
int need[10];
int main() {
int i, n, j, c, min;
for (j = 0; j < 10; j++) {
need[j] = 0;
h[j] = 0;
}
scanf("%s", t);
scanf("%s", a);
n = strlen(t);
for (i = 0; i < n; i++)
for (j = 0; j < 10; j++)
if (t[i] == j + '0') need[j]++;
need[2] += need[5];
need[6] += need[9];
need[5] = 0;
need[9] = 0;
n = strlen(a);
for (i = 0; i < n; i++)
for (j = 0; j < 10; j++)
if (a[i] == j + '0') h[j]++;
h[2] += h[5];
h[6] += h[9];
h[5] = 0;
h[9] = 0;
min = 210;
c = 210;
for (j = 0; j < 10; j++) {
if (need[j] != 0) c = h[j] / need[j];
if (c < min) min = c;
}
printf("%d", min);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100], b[100], c[100];
int main() {
string s, n;
long long i, g, p, g1, p1, f, f1, min;
cin >> n >> s;
min = 10000000;
for (i = 0; i < s.size(); i++) {
a[int(s[i]) - 48]++;
}
for (i = 0; i < n.size(); i++) {
b[int(n[i]) - 48]++;
}
g = a[2] + a[5];
p = b[2] + b[5];
g1 = a[6] + a[9];
p1 = b[6] + b[9];
if (p != 0) {
f = g / p;
if (b[2] > 0) {
c[2] = int(f);
} else if (b[2] == 0) {
c[5] = int(f);
}
if (b[2] > 0) {
c[5] = int(f);
} else if (b[2] == 0) {
c[5] = int(f);
}
}
if (p1 != 0) {
f1 = g1 / p1;
if (b[6] > 0) {
c[6] = int(f1);
} else if (b[6] == 0) {
c[9] = int(f1);
}
if (b[9] > 0) {
c[9] = int(f1);
} else if (b[9] == 0) {
c[6] = int(f1);
}
}
if (b[0] != 0) {
c[0] = a[0] / b[0];
}
if (b[1] != 0) {
c[1] = a[1] / b[1];
}
if (b[3] != 0) {
c[3] = a[3] / b[3];
}
if (b[4] != 0) {
c[4] = a[4] / b[4];
}
if (b[7] != 0) {
c[7] = a[7] / b[7];
}
if (b[8] != 0) {
c[8] = a[8] / b[8];
}
for (i = 0; i <= 9; i++) {
if (b[i] != 0) {
if (c[i] < min) {
min = c[i];
}
}
}
cout << min;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, s;
cin >> t >> s;
map<char, int> mp1, mp2;
int i;
for (i = 0; i < t.size(); i++) mp1[t[i]]++;
mp1['2'] += mp1['5'];
mp1['5'] = mp1['2'];
mp1['6'] += mp1['9'];
mp1['9'] = mp1['6'];
for (i = 0; i < s.size(); i++) mp2[s[i]]++;
mp2['2'] += mp2['5'];
mp2['5'] = mp2['2'];
mp2['6'] += mp2['9'];
mp2['9'] = mp2['6'];
double min = 999999;
for (i = 0; i < t.size(); i++) {
if (mp1[t[i]] > 0) {
if (mp2[t[i]] / mp1[t[i]] < min) min = mp2[t[i]] / mp1[t[i]];
}
}
cout << min << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cout.tie(0);
int p[11], q[11], minimo = 10000;
string s, t;
for (int i = 0; i < 11; i++) {
p[i] = 0;
q[i] = 0;
}
cin >> s >> t;
for (int i = 0; i < s.length(); i++)
if (s[i] == '5')
p[2]++;
else if (s[i] == '9')
p[6]++;
else
p[s[i] - '0']++;
for (int i = 0; i < t.length(); i++)
if (t[i] == '5')
q[2]++;
else if (t[i] == '9')
q[6]++;
else
q[t[i] - '0']++;
for (int i = 0; i < 8; i++)
if ((i != 5) && (p[i] != 0)) minimo = min(minimo, q[i] / p[i]);
cout << minimo;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string n, str;
int a[15], b[15], minn = 100000;
int main() {
cin >> n >> str;
for (int i = 0; i <= n.length() - 1; i++) {
if (n[i] == '5') {
a[2]++;
continue;
}
if (n[i] == '6') {
a[9]++;
continue;
}
a[n[i] - '0']++;
}
for (int i = 0; i <= str.length() - 1; i++) {
if (str[i] == '5') {
b[2]++;
continue;
}
if (str[i] == '6') {
b[9]++;
continue;
}
b[str[i] - '0']++;
}
for (int i = 0; i <= 9; i++) {
if (a[i] != 0) {
if (minn > b[i] / a[i]) {
minn = b[i] / a[i];
}
}
}
cout << minn;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[20];
int cn[20];
int main() {
string n;
string a;
cin >> n;
cin >> a;
for (int i = 0; i < a.size(); i++) {
if (a[i] == '5')
c[2]++;
else if (a[i] == '9')
c[6]++;
else
c[a[i] - '0']++;
}
for (int i = 0; i < n.size(); i++) {
if (n[i] == '5')
cn[2]++;
else if (n[i] == '9')
cn[6]++;
else
cn[n[i] - '0']++;
}
int ret = 0x3f3f3f3f;
for (int i = 0; i < 10; i++)
if (cn[i] > 0) ret = min(ret, c[i] / cn[i]);
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char A[32], B[256];
int f1[10], f2[10];
int main() {
int r = 1024;
scanf("%s%s", A, B);
for (int i = 0; A[i]; ++i)
++f1[A[i] - '0' - 3 * (A[i] == '5' || A[i] == '9')];
for (int i = 0; B[i]; ++i)
++f2[B[i] - '0' - 3 * (B[i] == '5' || B[i] == '9')];
for (int i = 0; i < 10; ++i)
if (f1[i]) r = min(r, f2[i] / f1[i]);
printf("%d", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char t[201], q[201];
int lt, lq, ans = INT_MAX;
bool flag[201];
int nt[11], nq[11];
void init() {
cin >> t + 1;
cin >> q + 1;
lt = strlen(t + 1);
lq = strlen(q + 1);
for (int i = 1; i <= lt; i++) {
if (t[i] == '9') t[i] = '6';
if (t[i] == '5') t[i] = '2';
}
for (int i = 1; i <= lq; i++) {
if (q[i] == '9') q[i] = '6';
if (q[i] == '5') q[i] = '2';
}
for (int i = 0; i <= 9; i++) {
for (int j = 1; j <= lt; j++)
if (t[j] == i + '0') nt[i]++;
for (int j = 1; j <= lq; j++)
if (q[j] == i + '0') nq[i]++;
}
}
int main() {
init();
for (int i = 0; i <= 9; i++)
if (nt[i] != 0) {
int minj = nq[i] / nt[i];
ans = min(ans, minj);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000007;
const long long INFLL = (long long)INF * (long long)INF;
const long double EPS = 10e-9;
const unsigned int M = 1000000007;
long double pi = 2 * acos(0.0);
void solve() {
long long n;
cin >> n;
std::map<long long, long long> need;
while (n > 0) {
long long rem = n % 10;
if (rem == 5) rem = 2;
if (rem == 9) rem = 6;
need[rem]++;
n /= 10;
}
string s;
cin >> s;
std::map<long long, long long> have;
for (long long i = 0; i < s.size(); ++i) {
long long temp = s[i] - '0';
if (temp == 5) temp = 2;
if (temp == 9) temp = 6;
have[temp]++;
}
long long ans = INFLL;
for (auto ash : need) {
long long a = ash.second;
long long b = have[ash.first];
ans = min(ans, b / a);
}
cout << ans << endl;
}
int32_t main() {
clock_t start, end;
start = clock();
long long t = 1;
while (t--) solve();
end = clock();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
string s, t;
cin >> s >> t;
vector<int> cnt1(10);
for (char x : s) {
int it = x - '0';
cnt1[it]++;
}
vector<int> cnt2(10);
for (char x : t) {
int it = x - '0';
cnt2[it]++;
}
cnt1[2] += cnt1[5];
cnt1[6] += cnt1[9];
cnt1[5] = 0;
cnt1[9] = 0;
cnt2[2] += cnt2[5];
cnt2[6] += cnt2[9];
cnt2[5] = 0;
cnt2[9] = 0;
int ans = INT_MAX;
for (int i = 0; i <= 9; ++i) {
if (cnt1[i]) {
int tmp = cnt2[i] / cnt1[i];
ans = min(ans, tmp);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int compare(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int freqi[15], freq[15];
char s[100005], s1[100000];
int main(void) {
int i, n, ans, k, l, m, t;
scanf("%s", s1);
l = strlen(s1);
for (i = 0; i < l; i++) {
if (s1[i] == '9') s1[i] = '6';
if (s1[i] == '5') s1[i] = '2';
}
for (i = 0; i < l; i++) freqi[s1[i] - '0']++;
scanf("%s", s);
l = strlen(s);
for (i = 0; i < l; i++) {
if (s[i] == '9') s[i] = '6';
if (s[i] == '5') s[i] = '2';
}
for (i = 0; i < l; i++) freq[s[i] - '0']++;
int mini = 999999999;
for (i = 0; i < 10; i++) {
if (freqi[i]) {
ans = freq[i] / freqi[i];
if (ans) {
if (ans < mini) mini = ans;
}
}
}
if (mini == 999999999) mini = 0;
printf("%d ", mini);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int frc[20];
int main() {
string a, b;
cin >> a >> b;
for (auto &i : a) i -= '0';
for (auto &i : b) frc[i -= '0']++;
int r = 0, m = 1;
while (m) {
for (auto i : a) {
if (frc[i] != 0)
frc[i]--;
else if (i == 6 && frc[9])
frc[9]--;
else if (i == 9 && frc[6])
frc[6]--;
else if (i == 2 && frc[5])
frc[5]--;
else if (i == 5 && frc[2])
frc[2]--;
else
m = 0;
}
if (m) r++;
}
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string one, two;
long long cnt[10];
int main() {
ios_base::sync_with_stdio(0);
;
cin >> one;
cin >> two;
for (auto i : two) {
cnt[i - '0']++;
}
long long nn = (long long)two.size();
long long sig = 0;
long long ans = 0;
while (!sig && nn > 0) {
for (auto i : one) {
if (cnt[i - '0']) {
cnt[i - '0']--;
nn--;
} else {
if (i == '9' || i == '6') {
if (cnt[15 - (i - '0')]) {
cnt[15 - (i - '0')]--;
nn--;
} else {
sig = 1;
break;
}
} else if (i == '2' || i == '5') {
if (cnt[7 - (i - '0')]) {
cnt[7 - (i - '0')]--;
nn--;
} else {
sig = 1;
break;
}
} else {
sig = 1;
break;
}
}
}
if (sig == 0) ans++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string t;
string s;
cin >> t;
cin >> s;
vector<int> tr(10);
vector<int> k(10);
for (int i = 0; i < s.length(); i++) {
k[s[i] - '0']++;
}
for (int i = 0; i < t.length(); i++) {
tr[t[i] - '0']++;
}
tr[2] += tr[5];
k[2] += k[5];
tr[5] = 0;
k[5] = 0;
tr[6] += tr[9];
k[6] += k[9];
tr[9] = 0;
k[9] = 0;
int ans = s.length();
for (int i = 0; i < 8; i++) {
if (tr[i] != 0) {
ans = min(ans, k[i] / tr[i]);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
char g[1100];
int save[11];
int mark[11];
int main() {
int t;
scanf("%d", &t);
scanf("%s", g);
int len = strlen(g);
for (int i = 0; i < len; i++) {
int tmp = g[i] - '0';
if (tmp == 5) tmp = 2;
if (tmp == 9) tmp = 6;
save[tmp]++;
}
while (t) {
int tmp = t % 10;
if (tmp == 5) tmp = 2;
if (tmp == 9) tmp = 6;
mark[tmp]++;
t /= 10;
}
int ans = 0;
while (1) {
int flag = 0;
for (int i = 0; i < 10; i++) {
if (mark[i] != 0) {
if (save[i] >= mark[i]) {
save[i] -= mark[i];
} else {
flag = 1;
break;
}
}
}
if (flag == 0)
ans++;
else
break;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
int i, j, res = 200, s1[10] = {0}, s2[10] = {0};
cin >> a;
for (i = 0; i < a.size(); i++) s1[a[i] - '0']++;
cin >> b;
for (i = 0; i < b.size(); i++) s2[b[i] - '0']++;
s1[6] += s1[9];
s1[2] += s1[5];
s2[6] += s2[9];
s2[2] += s2[5];
for (i = 0; i <= 9; i++) {
if (i == 9 || i == 5) continue;
if (s1[i] > 0) res = min(res, s2[i] / s1[i]);
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string ch, str;
int ice[10] = {0};
int m[10];
int dens[10] = {0};
int i, c, l, n, j = 0, mini;
cin >> str;
cin >> ch;
n = ch.size();
l = str.size();
for (i = 0; i < n; i++) {
c = ch[i] - '0';
ice[c]++;
}
for (i = 0; i < l; i++) {
c = str[i] - '0';
dens[c]++;
}
ice[6] = ice[6] + ice[9];
ice[2] = ice[2] + ice[5];
dens[6] = dens[6] + dens[9];
dens[2] = dens[2] + dens[5];
dens[5] = -1;
dens[9] = -1;
for (i = 0; i < 10; i++) {
if (dens[i] > 0) {
m[j] = ice[i] / dens[i];
j++;
}
}
mini = m[0];
for (i = 0; i < j; i++) {
if (mini > m[i]) {
mini = m[i];
}
}
cout << mini;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int isPrime(long long int n) {
if (n < 2) return 0;
if (n < 4) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
long long int c[10], c1[10];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n, m, i, j, q = 1, ans = INT_MAX, k;
string s1, s2;
cin >> s1 >> s2;
n = s2.length();
m = s1.length();
for (i = 0; i < n; i++) c[s2[i] - '0']++;
c[2] = c[5] = c[2] + c[5];
c[6] = c[9] = c[6] + c[9];
for (i = 0; i < m; i++) c1[s1[i] - '0']++;
c1[2] = c1[5] = c1[2] + c1[5];
c1[6] = c1[9] = c1[6] + c1[9];
for (i = 0; i < 10; i++) {
if (c1[i]) ans = min(ans, c[i] / c1[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char A[32], B[256];
int f1[10], f2[10];
int a25, a69;
int main() {
int r = 1024;
scanf("%s%s", A, B);
for (int i = 0; A[i]; ++i)
if (A[i] == '5')
++f1[2];
else if (A[i] == '9')
++f1[6];
else
++f1[A[i] - '0'];
for (int i = 0; B[i]; ++i) {
if (B[i] == '5')
++f2[2];
else if (B[i] == '9')
++f2[6];
else
++f2[B[i] - '0'];
}
for (int i = 0; i < 10; ++i)
if (f1[i]) r = min(r, f2[i] / f1[i]);
printf("%d", r);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string n;
cin >> n;
string s;
cin >> s;
vector<int> v(10, 0), v1(10, 0);
for (int i = 0; i < n.size(); ++i) {
if (n[i] - '0' == 9)
++v[6];
else if (n[i] - '0' == 5)
++v[2];
else
++v[n[i] - '0'];
}
for (int i = 0; i < s.size(); ++i) {
if (s[i] - '0' == 9)
++v1[6];
else if (s[i] - '0' == 5)
++v1[2];
else
++v1[s[i] - '0'];
}
int minz = s.size();
for (int i = 0; i < 10; ++i) {
if (i != 5 && i != 9) {
if (v[i] == 0) continue;
if (v1[i] / v[i] < minz) minz = v1[i] / v[i];
}
}
cout << minz;
}
|
#include <bits/stdc++.h>
char n[10], a[202];
int b[13], c[13];
int main() {
scanf("%s%s", n, a);
int len1 = strlen(n), len2 = strlen(a);
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
for (int i = 0; i < len1; ++i) b[n[i] - '0']++;
for (int i = 0; i < len2; ++i) c[a[i] - '0']++;
b[2] += b[5], b[5] = 0, c[2] += c[5], c[5] = 0, b[6] += b[9], b[9] = 0,
c[6] += c[9], c[9] = 0;
int cnt = 0, Max = 100000;
for (int i = 0; i < 10; ++i) {
if (b[i]) {
cnt = c[i] / b[i];
if (cnt < Max) Max = cnt;
}
}
printf("%d\n", Max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool pri(int a) {
for (int i = 2; i * i <= a; i++) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
long long c[300000], a[300000], b[300000], d[300000], e[300000];
int main() {
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '5') {
a[2]++;
continue;
}
if (s[i] == '9') {
a[6]++;
continue;
}
a[int(s[i]) - int('0')]++;
}
for (int i = 0; i < t.size(); i++) {
if (t[i] == '5') {
b[2]++;
continue;
}
if (t[i] == '9') {
b[6]++;
continue;
}
b[int(t[i]) - int('0')]++;
}
long long o = 400000;
for (int i = 0; i < 10; i++) {
if (a[i]) o = min(o, b[i] / a[i]);
}
cout << o;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool check(int x[], int y[]) {
for (int i = 0; i < 10; i++) {
if (y[i] < x[i]) {
int diff = x[i] - y[i];
y[i] = 0;
if (i == 2 && y[5] >= diff) {
y[5] -= diff;
} else if (i == 5 && y[2] >= diff) {
y[2] -= diff;
} else if (i == 6 && y[9] >= diff) {
y[9] -= diff;
} else if (i == 9 && y[6] >= diff) {
y[6] -= diff;
} else {
return false;
}
} else {
y[i] -= x[i];
}
}
return true;
}
int main() {
string t, str;
cin >> t >> str;
int tarr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int strarr[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
for (int i = 0; i < t.length(); i++) tarr[t[i] - '0']++;
for (int i = 0; i < str.length(); i++) strarr[str[i] - '0']++;
int ans = 10000000;
tarr[9] += tarr[6];
tarr[5] += tarr[2];
strarr[9] += strarr[6];
strarr[5] += strarr[2];
for (int i = 0; i < 10; i++) {
if (i == 6 || i == 2) continue;
if (tarr[i] > 0) ans = min(ans, strarr[i] / tarr[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int occ[2][10];
int main() {
string a, b;
cin >> a;
cin >> b;
for (int i = 0; i < a.size(); i++) {
occ[0][a[i] - '0']++;
}
for (int i = 0; i < b.size(); i++) {
occ[1][b[i] - '0']++;
}
for (int k = 0; k < 2; k++) {
occ[k][2] += occ[k][5];
occ[k][5] = 0;
occ[k][6] += occ[k][9];
occ[k][9] = 0;
}
int can = 100000000;
for (int d = 0; d < 10; d++) {
if (occ[0][d] != 0) can = min(can, occ[1][d] / occ[0][d]);
}
cout << can << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int banyak[10] = {}, banyak2[10] = {};
char s[205], t[205];
int main() {
scanf("%s", &s);
int len = strlen(s);
for (int i = 0; i < len; i++)
if (s[i] == '5')
banyak[2]++;
else if (s[i] == '9')
banyak[6]++;
else
banyak[s[i] - '0']++;
scanf("%s", &t);
int len2 = strlen(t);
for (int i = 0; i < len2; i++)
if (t[i] == '5')
banyak2[2]++;
else if (t[i] == '9')
banyak2[6]++;
else
banyak2[t[i] - '0']++;
int ans = 999999999;
for (int i = 0; i < 9; i++)
if (banyak[i] != 0) ans = min(ans, banyak2[i] / banyak[i]);
if (ans == 999999999) ans = 0;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string t;
string g;
int T[10];
int G[10];
int res;
void read() {
int i;
cin >> t >> g;
for (i = 0; i < t.size(); i++) T[t[i] - '0']++;
for (i = 0; i < g.size(); i++) {
if (g[i] == '6' or g[i] == '9')
G[6]++, G[9]++;
else if (g[i] == '2' or g[i] == '5')
G[2]++, G[5]++;
else
G[g[i] - '0']++;
}
}
void solve() {
int i;
bool b = 1, k = 1;
while (1) {
b = k = 1;
for (i = 0; i < 10; i++) {
if (i == 2 or i == 5) {
G[2] -= T[i];
G[5] -= T[i];
if (G[2] < 0 or G[5] < 0) return;
}
if (i == 6 or i == 9) {
G[6] -= T[i];
G[9] -= T[i];
if (G[6] < 0 or G[9] < 0) return;
} else if (i != 2 and i != 5 and i != 6 and i != 9) {
G[i] -= T[i];
if (G[i] < 0) return;
}
}
res++;
}
}
int main() {
read();
solve();
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int tot[100], num[100];
string t, now;
int main() {
cin >> t >> now;
int len = t.size();
for (int i = 0; i < len; i++) num[t[i] - '0']++;
num[2] += num[5], num[5] = 0;
num[6] += num[9], num[9] = 0;
len = now.size();
for (int i = 0; i < len; i++) tot[now[i] - '0']++;
tot[2] += tot[5], tot[5] = 0;
tot[6] += tot[9], tot[9] = 0;
int ans = INT_MAX;
for (int i = 0; i <= 9; i++) {
if (num[i] == 0) continue;
ans = min(ans, tot[i] / num[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s1[10005];
char s2[205];
int cnt, ok;
int main() {
gets(s1);
gets(s2);
cnt = 0;
for (int k = 0; k < 205; k++) {
ok = 0;
for (int i = 0; s1[i]; i++) {
for (int j = 0; s2[j]; j++) {
if (s1[i] == s2[j] || (s1[i] == '6' && s2[j] == '9') ||
(s1[i] == '9' && s2[j] == '6') || (s1[i] == '2' && s2[j] == '5') ||
(s1[i] == '5' && s2[j] == '2')) {
s2[j] = 'x';
ok++;
break;
}
}
if (ok == strlen(s1)) cnt++;
}
}
printf("%d", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char t[6], pieces[201];
int i, j, output = 0, found;
cin >> t;
cin >> pieces;
for (i = 0; i < strlen(t); i++) {
if (t[i] == '5') t[i] = '2';
if (t[i] == '9') t[i] = '6';
}
for (i = 0; i < strlen(pieces); i++) {
if (pieces[i] == '5') pieces[i] = '2';
if (pieces[i] == '9') pieces[i] = '6';
}
while (1) {
found = 0;
for (j = 0; j < strlen(t); j++) {
for (i = 0; i < strlen(pieces); i++) {
if (pieces[i] == t[j]) {
pieces[i] = ' ';
found++;
break;
}
}
}
if (found == strlen(t))
output++;
else
break;
}
cout << output;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, y;
cin >> x >> y;
int a[10] = {0};
int b[10] = {0};
for (int i = 0; i < y.size(); i++) {
if (y[i] == '2' || y[i] == '5')
a[2]++;
else if (y[i] == '6' || y[i] == '9')
a[6]++;
else
a[y[i] - 48]++;
}
int ans = INT_MAX;
for (int i = 0; i < x.size(); i++) {
if (x[i] == '2' || x[i] == '5')
b[2]++;
else if (x[i] == '6' || x[i] == '9')
b[6]++;
else
b[x[i] - 48]++;
}
for (int i = 0; i < 10; i++)
if (b[i]) ans = min(ans, a[i] / b[i]);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int aux[10], times[10];
int main() {
string t;
cin >> t;
string arr;
cin >> arr;
for (int i = 0; i < arr.size(); i++) {
aux[arr[i] - '0']++;
if (arr[i] == '2') aux[5]++;
if (arr[i] == '5') aux[2]++;
if (arr[i] == '6') aux[9]++;
if (arr[i] == '9') aux[6]++;
}
int mini = 2000000000;
for (int i = 0; i < t.size(); i++) {
times[t[i] - '0']++;
if (t[i] == '2') times[5]++;
if (t[i] == '5') times[2]++;
if (t[i] == '6') times[9]++;
if (t[i] == '9') times[6]++;
}
for (int i = 0; i < 10; i++) {
if (times[i] != 0) {
if (mini > aux[i] / times[i]) mini = aux[i] / times[i];
}
}
cout << mini;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[15], b[15], c[15];
char y[1080], x[1080];
int main() {
int i, ch = 0;
cin >> x;
cin >> y;
for (int i = 0; i < strlen(x); i++) {
a[x[i] - '0']++;
}
a[2] += a[5];
a[5] = 0;
a[6] += a[9];
a[9] = 0;
for (int i = 0; i < strlen(y); i++) {
b[y[i] - '0']++;
}
b[2] += b[5];
b[5] = 0;
b[6] += b[9];
b[9] = 0;
int mi = 9999999;
for (int i = 0; i < 10; i++) {
if (a[i] != 0) {
if (b[i] >= a[i] && b[i] != 0 && mi > (b[i] / a[i]))
mi = b[i] / a[i], ch = 1;
}
}
if (ch == 1)
cout << mi << endl;
else
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
vector<int> v(10);
vector<int> m(10);
cin >> n;
while (n > 0) {
v[n % 10]++;
n /= 10;
}
v[2] += v[5];
v[5] = 0;
v[6] += v[9];
v[9] = 0;
getline(cin, s);
getline(cin, s);
for (int i = 0; i < s.length(); i++) {
m[s[i] - '0']++;
}
m[2] += m[5];
m[5] = 0;
m[6] += m[9];
m[9] = 0;
int k = 100000;
for (int i = 0; i <= 8; i++) {
if (i != 5 && m[i] != 0 && v[i] != 0) k = min(k, (m[i] / v[i]));
}
cout << k;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s;
cin >> s1 >> s;
int a[10] = {0}, b[10] = {0};
for (int i = 0; i < s1.size(); i++) {
int m = s1[i] - '0';
if (m == 5 || m == 2)
a[2]++;
else if (m == 6 || m == 9)
a[6]++;
else
a[m]++;
}
for (int i = 0; i < s.size(); i++) {
int m = s[i] - '0';
if (m == 5 || m == 2)
b[2]++;
else if (m == 6 || m == 9)
b[6]++;
else
b[m]++;
}
int ans = 1000;
for (int i = 0; i < 10; i++) {
if (a[i]) {
int k = b[i] / a[i];
if (ans > k) ans = k;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n, i, T, p[10], ans, k;
char S[1000];
int main() {
scanf("%d", &t);
scanf("%s", S);
n = strlen(S);
for (i = 0; i < n; i++)
if (S[i] == '5')
p[2]++;
else if (S[i] == '9')
p[6]++;
else
p[S[i] - '0']++;
while (true) {
T = t;
while (T) {
if (T % 10 == 5)
k = 2;
else if (T % 10 == 9)
k = 6;
else
k = T % 10;
if (!p[k]) {
printf("%d\n", ans);
return 0;
}
p[k]--;
T /= 10;
}
ans++;
}
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
string n, s;
cin >> n >> s;
map<int, int> mp, mp2;
int mn = INT_MAX;
for (int i = 0; i < n.length(); i++) {
if (n[i] == '2' || n[i] == '5')
mp[2]++;
else if (n[i] == '6' || n[i] == '9')
mp[6]++;
else
mp[n[i] - '0']++;
}
n = s;
for (int i = 0; i < n.length(); i++) {
if (n[i] == '2' || n[i] == '5')
mp2[2]++;
else if (n[i] == '6' || n[i] == '9')
mp2[6]++;
else
mp2[n[i] - '0']++;
}
for (auto it : mp) {
if (mp2.find(it.first) == mp2.end()) {
cout << "0\n";
return;
} else
mn = min(mn, mp2[it.first] / it.second);
}
cout << mn << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, temp, b[10] = {0}, min = 100000, len, a[11] = {0};
string s;
cin >> t >> s;
len = s.length();
for (int i = 0; i < len; ++i) {
a[s[i] - '0']++;
}
while (t > 0) {
temp = t % 10;
t /= 10;
b[temp]++;
}
b[2] += b[5];
b[5] = 0;
b[6] += b[9];
b[9] = 0;
a[2] += a[5];
a[5] = 0;
a[6] += a[9];
a[9] = 0;
for (int i = 0; i < 10; i++) {
if (b[i] != 0) {
temp = a[i] / b[i];
if (temp < min) {
min = temp;
}
}
}
cout << min << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
string t, s;
cin >> t >> s;
vector<int> tt(10, 0);
vector<int> ss(10, 0);
int ans = s.size();
for (int i = 0; i < t.size(); ++i) {
++tt[t[i] - '0'];
}
for (int i = 0; i < s.size(); ++i) {
++ss[s[i] - '0'];
}
tt[2] += tt[5];
tt[5] = tt[2];
tt[6] += tt[9];
tt[9] = tt[6];
ss[2] += ss[5];
ss[5] = ss[2];
ss[6] += ss[9];
ss[9] = ss[6];
for (int i = 0; i < 10; ++i) {
if (tt[i] > 0) {
if (ss[i] == 0) {
ans = 0;
} else {
ans = min(ans, ss[i] / tt[i]);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string p, q;
cin >> p >> q;
for (int i = 0; i < p.length(); i++) {
if (p[i] == '2') p[i] = '5';
if (p[i] == '6') p[i] = '9';
}
for (int i = 0; i < q.length(); i++) {
if (q[i] == '2') q[i] = '5';
if (q[i] == '6') q[i] = '9';
}
int a[10] = {0}, b[10] = {0};
for (int i = 0; i < p.length(); i++) a[p[i] - '0']++;
for (int i = 0; i < q.length(); i++) b[q[i] - '0']++;
int count = INT_MAX;
for (int i = 0; i < 10; i++) {
if (a[i]) count = min(count, b[i] / a[i]);
}
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long tests;
long long n = 500, p[15], pp[15];
string s, t;
void solve() {
cin >> t >> s;
for (auto i : s) {
if (i == '6') i = '9';
if (i == '2') i = '5';
p[i - '0']++;
}
for (auto i : t) {
if (i == '6') i = '9';
if (i == '2') i = '5';
pp[i - '0']++;
}
for (int i = 0; i <= 9; i++) {
if (pp[i] > 0) n = min(n, p[i] / pp[i]);
}
cout << n;
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
using ld = long double;
void base(int x, int b, int y) {
int d = 1;
int num = 0;
while (x > 0) {
num = (x % b) * d + num;
x /= b;
d *= 10;
}
if (num < 10 && y > 1) cout << ' ';
cout << num << ' ';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
string t;
cin >> t;
string s;
cin >> s;
vector<int> dp(10, 0);
for (int i = 0; i < t.size(); ++i) {
if (t[i] == '5') t[i] = '2';
if (t[i] == '9') t[i] = '6';
dp[t[i] - '0']++;
}
vector<int> dem(10, 0);
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '5') s[i] = '2';
if (s[i] == '9') s[i] = '6';
dem[s[i] - '0']++;
}
int ans = 1e9;
for (int i = 0; i < t.size(); ++i) {
ans = min(ans, dem[t[i] - '0'] / dp[t[i] - '0']);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s, t;
cin >> s >> t;
long long int n = s.size(), m = t.size();
map<char, long long int> x, y;
for (long long int i = 0; i < n; i++) {
if (s[i] == '6')
x['9']++;
else if (s[i] == '2')
x['5']++;
else {
x[s[i]]++;
}
}
for (long long int i = 0; i < m; i++) {
if (t[i] == '6')
y['9']++;
else if (t[i] == '2')
y['5']++;
else {
y[t[i]]++;
}
}
long long int mini = INT_MAX;
for (auto i : x) {
if (y.find(i.first) != y.end()) {
mini = min(mini, y[i.first] / i.second);
} else {
cout << 0 << endl;
return 0;
}
}
cout << mini << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, s;
cin >> t >> s;
int n[10] = {0}, e[10] = {0};
for (int i = 0; i < t.size(); i++) {
if (t[i] == '5')
n[2]++;
else if (t[i] == '9')
n[6]++;
else
n[t[i] - '0']++;
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == '5')
e[2]++;
else if (s[i] == '9')
e[6]++;
else
e[s[i] - '0']++;
}
int ans = (int)1e+9;
for (int i = 0; i < 10; i++) {
if (n[i] == 0) continue;
ans = min(ans, e[i] / n[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int a[1000], b[1000];
char s[1000];
char f[1000];
int main() {
int min = 1000000;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
scanf(" %s", s);
scanf(" %s", f);
int len = strlen(f);
for (int i = 0; i < len; i++) {
a[f[i] - '0']++;
}
a[6] += a[9];
a[9] = 0;
a[2] += a[5];
a[5] = 0;
len = strlen(s);
for (int i = 0; i < len; i++) {
b[s[i] - '0']++;
}
b[6] += b[9];
b[9] = 0;
b[2] += b[5];
b[5] = 0;
for (int i = 0; i < 10; i++) {
if (b[i] > 0 && a[i] / b[i] < min) min = a[i] / b[i];
}
printf("%d\n", min);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> need(9);
vector<int> have(9);
string s;
cin >> s;
for (int i = 0; i < (s.size()); ++i) need[s[i] - '0']++;
need[2] += need[5];
need[6] += need[9];
cin >> s;
for (int i = 0; i < (s.size()); ++i) have[s[i] - '0']++;
have[2] += have[5];
have[6] += have[9];
int max = 10000;
for (int i = 0; i < (9); ++i) {
if (i == 5) continue;
if (need[i] > 0 && have[i] == 0) {
max = 0;
break;
}
if (need[i] > 0) max = min(max, have[i] / need[i]);
}
cout << max << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string t, s;
int cnt_t[10], cnt_s[10];
memset(cnt_t, 0, sizeof(cnt_t));
memset(cnt_s, 0, sizeof(cnt_s));
cin >> t;
cin >> s;
for (int i = 0; i < t.size(); i++) {
if (t[i] == '9') {
t[i] = '6';
}
if (t[i] == '5') {
t[i] = '2';
}
cnt_t[t[i] - '0']++;
}
for (int i = 0; i < s.size(); i++) {
if (s[i] == '9') {
s[i] = '6';
}
if (s[i] == '5') {
s[i] = '2';
}
cnt_s[s[i] - '0']++;
}
int ans = 1e9;
for (int i = 0; i < 10; i++) {
if (cnt_t[i] == 0) {
continue;
}
ans = min(ans, cnt_s[i] / cnt_t[i]);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a[15], sum[15], i, ans;
char str[210];
scanf("%d%s", &t, str);
memset(a, 0, sizeof(a));
memset(sum, 0, sizeof(sum));
while (t != 0) {
a[t % 10]++;
t /= 10;
}
for (i = 0; str[i] != '\0'; i++) sum[str[i] - '0']++;
ans = 1000;
a[6] += a[9];
a[2] += a[5];
sum[6] += sum[9];
sum[2] += sum[5];
for (i = 0; i < 9; i++)
if (i != 5 && a[i] != 0) ans = min(ans, sum[i] / a[i]);
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
int f[10] = {0}, t, g[10] = {0}, ans, l;
char s[210];
int main() {
scanf("%d%s", &t, s);
l = strlen(s);
for (int i = 0; i < l; i++) f[s[i] - '0']++;
f[2] += f[5];
f[5] = 0;
f[6] += f[9];
f[9] = 0;
while (t) {
g[t % 10]++;
t /= 10;
}
g[2] += g[5];
g[5] = 0;
g[6] += g[9];
g[9] = 0;
ans = l;
for (int i = 0; i < 10; i++)
if (g[i] && ans > f[i] / g[i]) ans = f[i] / g[i];
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt[10][2];
int main() {
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '9') s[i] = '6';
if (s[i] == '5') s[i] = '2';
}
for (int i = 0; i < t.size(); i++) {
if (t[i] == '9') t[i] = '6';
if (t[i] == '5') t[i] = '2';
}
for (int i = 0; i < s.size(); i++) cnt[s[i] - '0'][0]++;
for (int i = 0; i < t.size(); i++) cnt[t[i] - '0'][1]++;
int ans = 1e9;
for (int i = 0; i < 10; i++)
if (cnt[i][0]) ans = min(ans, cnt[i][1] / cnt[i][0]);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int t, a[8] = {0}, b[8] = {0}, k = 0, i;
scanf("%d", &t);
while (t) {
if (t % 10 <= 4)
a[t % 10]++;
else if (t % 10 == 5)
a[2]++;
else if (t % 10 < 9)
a[t % 10 - 1]++;
else
a[5]++;
t = t / 10;
}
getchar();
t = getchar();
while (t != '\n') {
t = t - '0';
if (t <= 4)
b[t]++;
else if (t == 5)
b[2]++;
else if (t < 9)
b[t - 1]++;
else
b[5]++;
t = getchar();
}
while (1) {
for (i = 0; i < 8; i++) {
b[i] = b[i] - a[i];
if (b[i] < 0) break;
}
if (i < 8) break;
k++;
}
printf("%d\n", k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, s1;
cin >> s >> s1;
int freq1[10];
int freq2[10];
int freq3[10];
for (int i = 0; i < 10; ++i) {
freq1[i] = 0;
freq2[i] = 0;
freq3[i] = 0;
}
for (int i = 0; i < s.size(); ++i) freq1[(int)s[i] - 48]++;
for (int i = 0; i < s1.size(); ++i) freq2[(int)s1[i] - 48]++;
freq1[6] = freq1[6] + freq1[9];
freq1[9] = 0;
freq2[6] = freq2[6] + freq2[9];
freq2[9] = 0;
freq1[2] = freq1[2] + freq1[5];
freq1[5] = 0;
freq2[2] = freq2[2] + freq2[5];
freq2[5] = 0;
for (int i = 0; i < 10; ++i)
if (freq1[i] && freq2[i]) freq3[i] = freq2[i] / freq1[i];
sort(freq3, freq3 + 10);
int t = 0;
int ans;
for (int i = 0; i < 10; ++i)
if (freq3[i] && (!t)) {
t = 1;
ans = freq3[i];
}
if (t)
cout << ans;
else
cout << 0;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:666000000")
using namespace std;
const int inf = (1 << 30) - 1;
const long double eps = 1e-9;
const long double pi = fabs(atan2(0.0, -1.0));
void ML(const bool v) {
if (v) return;
int *ass;
for (;;) {
ass = new int[2500000];
for (int i = 0; i < 2500000; i++) ass[i] = rand();
}
}
void TL(const bool v) {
if (v) return;
int *ass;
ass = new int[250];
for (;;) {
for (int i = 0; i < 250; i++) ass[i] = rand();
}
}
void PE(const bool v) {
if (v) return;
puts("ass 1 2 3 4 5 6 fuck");
exit(0);
}
string want, have;
int ch[10], cw[10];
int conv(char c) {
if (c == '5') c = '2';
if (c == '9') c = '6';
return c - '0';
}
void LoAd() {
cin >> want >> have;
for (int i = 0; i < (int)want.size(); i++) cw[conv(want[i])]++;
for (int i = 0; i < (int)have.size(); i++) ch[conv(have[i])]++;
}
void SoLvE() {
int res = INT_MAX;
for (int i = 0; i < 10; i++) {
if (0 != cw[i]) res = min(res, ch[i] / cw[i]);
}
cout << res;
}
int main() {
srand((int)time(NULL));
LoAd();
SoLvE();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[10];
int b[10];
string s, t;
int ans = 1e9;
int main() {
cin >> t;
cin >> s;
for (int i = 0; i < t.length(); i++)
if (t[i] == '9')
b[6]++;
else if (t[i] == '5')
b[2]++;
else
b[t[i] - '0']++;
for (int i = 0; i < s.length(); i++)
if (s[i] == '9')
a[6]++;
else if (s[i] == '5')
a[2]++;
else
a[s[i] - '0']++;
for (int i = 0; i < 10; i++)
if (b[i]) ans = min(ans, a[i] / b[i]);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
int a[10] = {0};
int b[10] = {0};
int n = t;
while (n > 0) {
int r = n % 10;
n = n / 10;
if (r == 9) r = 6;
if (r == 5) r = 2;
a[r]++;
}
string str;
cin >> str;
for (int i = 0; i < str.length(); i++) {
if (str[i] == '9')
b[6]++;
else if (str[i] == '5')
b[2]++;
else
b[str[i] - 48]++;
}
int ans = INT_MAX;
for (int i = 0; i < 9; i++) {
if (a[i] > 0) ans = min(ans, b[i] / a[i]);
}
cout << ans;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.