text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, radical = 300;
int pos[maxn];
int a[maxn];
vector<int> v[maxn];
vector<pair<int, int> > Q[maxn];
int ans[maxn];
int fen[maxn];
inline void add(int id) {
id++;
while (id < maxn) {
fen[id]++;
id += id & -id;
}
}
inline int get(int id) {
id++;
int ret = 0;
while (id) {
ret += fen[id];
id -= id & -id;
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
int n, q;
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
if (pos[i] < pos[j])
v[pos[j]].push_back(pos[i]);
else
v[pos[i]].push_back(pos[j]);
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
Q[r].push_back(pair<int, int>(l, i));
}
int tot = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++) add(v[i][j]);
tot += v[i].size();
for (int j = 0; j < Q[i].size(); j++)
ans[Q[i][j].second] = tot - get(Q[i][j].first - 1);
}
for (int i = 0; i < q; i++) cout << ans[i] << " ";
return 0;
}
|
#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 {
stack<pair<int, int>> q;
stack<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, int val = 1) {
while (index <= N) {
bt[index] += val;
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({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(left);
}
}
for (int posi = 1; posi <= N; posi++) {
while (!d[posi].lefties.empty()) {
incr(d[posi].lefties.top());
d[posi].lefties.pop();
}
while (!d[posi].q.empty()) {
pair<int, int>& qu = d[posi].q.top();
ans[qu.second] =
getsum(posi) - getsum(qu.first - 1) + (posi - qu.first + 1);
d[posi].q.pop();
}
}
for (int i = 0; i < M; i++) printf("%u\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 9;
const int inf = 1e9 + 9;
const int N = 2e5 + 9;
int n, q, l[N], r[N], a[N], wh[N];
long long bit[N], ans[N];
vector<int> h[N];
vector<pair<int, int> > Q[N];
void update(int t) {
t++;
while (t <= n + 1) {
bit[t]++;
t += (t & -t);
}
}
long long query(int t) {
long long sum = 0;
t++;
while (t > 0) {
sum += bit[t];
t -= (t & -t);
}
return sum;
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
wh[a[i]] = i;
}
for (int i = 1; i <= q; i++) {
scanf("%d %d", &l[i], &r[i]);
Q[r[i]].push_back(make_pair(l[i], i));
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
h[j].push_back(i);
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < h[a[i]].size(); j++) {
if (wh[h[a[i]][j]] <= i) {
update(wh[h[a[i]][j]]);
}
}
for (int j = a[i] * 2; j <= n; j += a[i]) {
if (wh[j] < i) {
update(wh[j]);
}
}
for (int j = 0; j < Q[i].size(); j++) {
ans[Q[i][j].second] += query(i) - query(Q[i][j].first - 1);
}
}
for (int i = 1; i <= q; i++) {
printf("%lld\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200055];
int pos[200055];
vector<int> buf[200055];
struct o9 {
int l;
int id;
};
vector<o9> q[200055];
long long res[200055];
long long dat[400055];
inline long long query(int id) {
long long res = 0ll;
id += n;
for (; id > 0; id >>= 1) {
res += dat[id];
}
return res;
}
inline void update(int l, int r, long long val) {
l += n, r += n;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) dat[l++] += val;
if (r & 1) dat[--r] += val;
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
q[y].push_back((o9){x, i});
}
for (int i = 0; i < n; i++) {
for (auto u : buf[a[i]]) {
update(0, u + 1, 1);
}
for (int j = a[i]; j <= n; j += a[i]) {
if (pos[j] <= i) {
update(0, pos[j] + 1, 1);
} else {
buf[j].push_back(i);
}
}
for (auto p : q[i]) {
res[p.id] = query(p.l);
}
}
for (int i = 0; i < m; i++) printf("%lld\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200005], pos[200005];
vector<int> Div[200005];
int Sum, ans[200005];
pair<pair<int, int>, int> que[200005];
struct BIT {
int tree[200005];
void Up(int x) {
while (x < 200005) {
tree[x]++;
x += x & (-x);
}
}
int Get(int x) {
int r = 0;
while (x) {
r += tree[x];
x -= x & (-x);
}
return r;
}
};
BIT T;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (int i = 1; i < 200005; i++) {
if (pos[i] == 0) continue;
for (int j = i; j < 200005; j += i) {
if (pos[j] == 0) continue;
Div[max(pos[i], pos[j])].push_back(min(pos[i], pos[j]));
}
}
for (int i = 1; i <= m; i++)
cin >> que[i].first.second >> que[i].first.first, que[i].second = i;
sort(que + 1, que + m + 1);
int cur = 1;
for (int i = 1; i <= m; i++) {
while (cur <= que[i].first.first) {
Sum += Div[cur].size();
for (int j = 0; j < Div[cur].size(); j++) T.Up(Div[cur][j]);
cur++;
}
ans[que[i].second] = Sum - T.Get(que[i].first.second - 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
bool myfunction(const pair<int, int> &i, const pair<int, int> &j) {
return i.second < j.second;
}
vector<int> tree;
int high;
void add(int ind, int l, int h, int i) {
tree[ind]++;
if (l == h) return;
int c = (l + h) / 2;
if (c >= i)
add(ind * 2, l, c, i);
else
add(ind * 2 + 1, c + 1, h, i);
}
int find(int ind, int l, int h, int r) {
int c = (l + h) / 2;
if (r >= h)
return tree[ind];
else if (c < r)
return tree[ind * 2] + find(ind * 2 + 1, c + 1, h, r);
return find(ind * 2, l, c, r);
}
vector<pair<int, int> > m;
vector<pair<int, pair<int, int> > > outs;
int totals[200100], I, J, K;
void solver() {
for (; I >= 1; I--) {
while (J >= 0 && m[J].first >= I) {
add(1, 1, high, m[J].second);
J--;
}
while (K >= 0 && outs[K].first >= I) {
totals[outs[K].second.second] = find(1, 1, high, outs[K].second.first);
K--;
}
}
}
int main() {
int N, M;
cin >> N >> M;
high = 1;
while (high <= N) high *= 2;
vector<int> v(N + 1, 0);
vector<int> alloc(high * 2, 0);
tree.swap(alloc);
for (int i = 1, in; i <= N; i++) {
cin >> in;
v[in] = i;
}
for (int i = 1; i <= N; i++) {
for (int j = i; j <= N; j += i) {
m.push_back(make_pair(min(v[i], v[j]), max(v[i], v[j])));
}
}
sort(m.begin(), m.end());
for (int i = 0; i < M; i++) {
int l, r;
cin >> l >> r;
outs.push_back(make_pair(l, make_pair(r, i)));
}
sort(outs.begin(), outs.end());
I = N;
J = m.size() - 1;
K = outs.size() - 1;
solver();
for (int i = 0; i < M; i++) {
cout << totals[i] << '\n';
}
return 0;
}
|
#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() {
ios_base::sync_with_stdio(false);
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;
int where[200005];
vector<int> divisible[200005];
typedef pair<int, int> PII;
typedef pair<PII, int> PII2;
PII2 queries[200005];
int ans[200005];
int fenwick[200005];
void increase(int pos) {
for (int i = pos; i < 200005; i += (i & (-i))) fenwick[i]++;
}
int get(int pos) {
int res = 0;
for (int i = pos; i; i -= (i & (-i))) res += fenwick[i];
return res;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
where[a] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int posi = where[i];
int posj = where[j];
if (posi > posj) swap(posi, posj);
divisible[posj].push_back(posi);
}
}
for (int i = 1; i <= m; i++) {
cin >> queries[i].first.second >> queries[i].first.first;
queries[i].second = i;
}
sort(queries + 1, queries + m + 1);
int now = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < divisible[i].size(); j++) {
increase(divisible[i][j]);
}
while (now < m && queries[now].first.first < i) now++;
for (; now <= m && queries[now].first.first == i; now++) {
ans[queries[now].second] +=
get(queries[now].first.first) - get(queries[now].first.second - 1);
if (queries[now + 1].first.first != i) break;
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pos[300000];
int bit[500000];
int preg[300000];
int n, m;
void sum(int x, int val) {
for (int i = x; i <= n; i += (i & -i)) bit[i] += val;
}
int get(int idx) {
int s = 0;
for (int i = idx; i > 0; i -= (i & -i)) s += bit[i];
return s;
}
vector<pair<int, int> > par;
vector<pair<pair<int, int>, int> > Q;
int main() {
int num;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> num;
pos[num] = i + 1;
}
for (int i = 1; i <= n; i++) {
int mult = i;
while (mult <= n) {
int p1, p2;
p1 = pos[i];
p2 = pos[mult];
if (p1 > p2) swap(p1, p2);
sum(p2, 1);
par.push_back(make_pair(p1, p2));
mult += i;
}
}
int de, a;
for (int i = 0; i < m; i++) {
cin >> de >> a;
Q.push_back(make_pair(make_pair(de, a), i));
}
sort(Q.begin(), Q.end());
sort(par.begin(), par.end());
int pq, pp;
pq = pp = 0;
for (int i = 1; i <= n; i++) {
while (pq < m && Q[pq].first.first == i) {
preg[Q[pq].second] = get(Q[pq].first.second);
pq++;
}
while (pp < par.size() && par[pp].first == i) {
sum(par[pp].second, -1);
pp++;
}
}
for (int i = 0; i < m; i++) cout << preg[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200 * 1000 + 5;
const int inf = 1000 * 1000 * 100;
int a[maxN], pos[maxN];
int c[maxN], ans[maxN];
pair<int, int> r[20 * maxN];
pair<pair<int, int>, int> que[maxN];
inline void set_(int x) {
for (; x < maxN; x += x & (-x)) c[x]++;
}
inline int get(int x) {
int ans = 0;
for (; x > 0; x -= x & (-x)) ans += c[x];
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> a[i], pos[a[i]] = i;
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
r[cnt++] = make_pair(min(pos[i], pos[j]), max(pos[i], pos[j]));
sort(r, r + cnt);
for (int i = 0; i < m; i++)
cin >> que[i].first.first >> que[i].first.second, que[i].second = i;
sort(que, que + m);
int e = cnt - 1, f;
for (int i = m - 1; i >= 0; i--) {
f = 1;
for (int j = e; j >= 0; j--) {
if (r[j].first < que[i].first.first) {
f = 0;
e = j;
break;
}
set_(r[j].second);
}
if (f) e = -1;
ans[que[i].second] = get(que[i].first.second);
}
for (int i = 0; i < m; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 9;
vector<int> v[MAX], qu[MAX];
int fen[MAX], p[MAX], a[MAX], l[MAX], r[MAX], ans[MAX];
void update(int x, int val) {
for (x++; x < MAX; x += x & -x) fen[x] += val;
}
int get(int x) {
int ret = 0;
for (; x; x -= x & -x) ret += fen[x];
return ret;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, q;
cin >> n >> q;
for (int i = 0; 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)
v[min(p[i], p[j])].push_back(max(p[i], p[j]));
for (int i = 0; i < q; i++) cin >> l[i] >> r[i], qu[l[i] - 1].push_back(i);
for (int i = n - 1; i >= 0; i--) {
for (auto p : v[i]) update(p, 1);
for (auto qq : qu[i]) ans[qq] = get(r[qq]);
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int tree[4 * N];
void update(int at, int L, int R, int pos, int val) {
if (pos < L or R < pos) return;
if (pos == L and pos == R) {
tree[at] += val;
return;
}
int mid = (L + R) / 2;
update(2 * at, L, mid, pos, val);
update(2 * at + 1, mid + 1, R, pos, val);
tree[at] = (tree[2 * at] + tree[2 * at + 1]);
}
int query(int at, int L, int R, int l, int r) {
if (r < L or R < l) return 0;
if (l <= L and R <= r) return tree[at];
int mid = (L + R) / 2;
int x = query(2 * at, L, mid, l, r);
int y = query(2 * at + 1, mid + 1, R, l, r);
return (x + y);
}
int n, q;
int in[N], ara[N], answer[N];
vector<int> G[N];
vector<pair<int, int> > que[N];
void precalc() {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int l = in[i];
int r = in[j];
if (l > r) swap(l, r);
G[r].push_back(l);
}
}
}
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) scanf("%d", &ara[i]), in[ara[i]] = i;
precalc();
for (int i = 1; i <= q; i++) {
int l, r;
scanf("%d %d", &l, &r);
que[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < G[i].size(); j++) {
int p = G[i][j];
update(1, 1, n, p, 1);
}
for (int j = 0; j < que[i].size(); j++) {
int l = que[i][j].first;
int id = que[i][j].second;
int ans = query(1, 1, n, l, i);
answer[id] = ans;
}
}
for (int i = 1; i <= q; i++) printf("%d\n", answer[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
vector<int> L[MAXN], R[MAXN];
int c[MAXN], a[MAXN], b[MAXN], ans[MAXN], l[MAXN], r[MAXN];
inline int lowbit(int k) { return k & -k; }
void add(int x) {
for (; x < MAXN; x += lowbit(x)) c[x]++;
}
int query(int x) {
int s = 0;
for (; x > 0; x -= lowbit(x)) s += c[x];
return s;
}
int main() {
int n, m, x, y;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]), b[a[i]] = i;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
L[l[i]].push_back(i);
R[r[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < L[i].size(); j++)
ans[L[i][j]] -= query(r[L[i][j]]) - query(i - 1);
for (int j = a[i]; j <= n; j += a[i]) add(b[j]);
for (int j = 0; j < R[i].size(); j++)
ans[R[i][j]] += query(i) - query(l[R[i][j]] - 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,sse3,sse4,popcnt,abm,mmx")
using namespace std;
const int N = 2e5 + 1;
const int maxn = 1e7 + 13;
int n, m, k;
vector<int> c[N];
int g[N];
vector<pair<int, int> > q[N];
int ans[N];
int was[maxn];
int f[N];
void upd(int pos, int x) {
for (int i = pos; i <= n; i |= (i + 1)) f[i] += x;
}
int get(int r) {
int res = 0;
while (r > 0) {
res += f[r];
r = (r & (r + 1)) - 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; ++i) {
int x;
cin >> x;
g[x] = i;
}
int cur = 0;
for (int i = 1; i <= n; i++) {
for (int j = i + i; j <= n; j += i) {
cur++;
c[g[i]].push_back(cur);
c[g[j]].push_back(cur);
}
}
for (long long i = 1; i <= m; ++i) {
int l, r;
cin >> l >> r;
q[r].push_back(make_pair(l, i));
}
int res = 0;
for (long long i = 1; i <= n; ++i) {
for (auto x : c[i]) {
if (was[x] > 0) {
upd(was[x], 1);
++res;
} else {
was[x] = i;
}
}
for (auto it : q[i]) {
ans[it.second] = res - get(it.first - 1) + i - it.first + 1;
}
}
for (long long i = 1; i <= m; ++i) {
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& _p) {
return os << "(" << _p.first << "," << _p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& _V) {
bool f = true;
os << "[";
for (auto v : _V) {
os << (f ? "" : ",") << v;
f = false;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& _S) {
bool f = true;
os << "(";
for (auto s : _S) {
os << (f ? "" : ",") << s;
f = false;
}
return os << ")";
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& _M) {
return os << set<pair<T, U>>(_M.begin(), _M.end());
}
const signed long long INF = 1000000100;
const long double EPS = 1e-9;
struct Fenwick {
int *A, M;
Fenwick(int n) {
M = 1 << (32 - __builtin_clz(n));
A = new int[M];
for (int(i) = (0); (i) < (M); (i)++) A[i] = 0;
}
int query(int k) {
int r = 0;
for (; k > 0; k -= (k & -k)) r += A[k];
return r;
}
int query(int a, int b) {
if (b == 0)
return query(a);
else
return query(b) - query(a - 1);
}
void insert(int k, int v) {
for (; k < M; k += (k & -k)) A[k] += v;
}
~Fenwick() { delete[] A; }
};
const int MAXN = 200100;
int N, Q;
int A[MAXN];
int Z[MAXN];
int R[MAXN];
vector<int> W[MAXN];
vector<tuple<int, int, int>> queries;
Fenwick F(MAXN);
void read_data() {
scanf("%d %d", &N, &Q);
for (int(i) = (1); (i) <= (N); (i)++) scanf("%d", A + i);
for (int(i) = (1); (i) <= (Q); (i)++) {
int a, b;
scanf("%d %d", &a, &b);
queries.emplace_back(b, a, i);
}
}
void pre() {
for (int(i) = (1); (i) <= (N); (i)++) Z[A[i]] = i;
for (int(i) = (1); (i) <= (N); (i)++)
for (int(j) = (1); (j) <= (INF); (j)++) {
int t = A[i] * j;
if (t >= MAXN) break;
int k = Z[t];
if (k == 0) continue;
W[max(k, i)].push_back(min(k, i));
}
}
void solve() {
pre();
sort(queries.begin(), queries.end());
int right = 0;
for (auto q : queries) {
int a, b, id;
tie(b, a, id) = q;
while (right < b) {
++right;
for (int left : W[right]) F.insert(left, 1);
}
R[id] = F.query(a, b);
}
for (int(i) = (1); (i) <= (Q); (i)++) printf("%d\n", R[i]);
}
int main() {
read_data();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, m, l, r, ans[N], a[N], mark[N], tree[N * 2];
vector<int> g[N];
vector<pair<int, int> > q[N];
int query(int l, int r) {
int res = 0;
r++;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) res += tree[l++];
if (r & 1) res += tree[--r];
}
return res;
}
void add_edge(int x, int y) {
if (x < y) swap(x, y);
g[x].push_back(y);
}
void add(int x) {
x += n;
while (x) tree[x]++, x /= 2;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
;
mark[a[i]] = i;
}
for (int i = 0; i < n; i++)
for (int j = 1; j * j <= a[i]; j++)
if (a[i] % j == 0) {
add_edge(i, mark[j]);
if (j * j != a[i]) add_edge(i, mark[a[i] / j]);
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &l, &r);
;
--l, --r;
q[r].push_back(make_pair(l, i));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < g[i].size(); j++) add(g[i][j]);
for (int j = 0; j < q[i].size(); j++)
ans[q[i][j].second] = query(q[i][j].first, i);
}
for (int i = 0; i < m; i++) cout << ans[i] << " ";
cout << endl;
;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, q, sz, nums[MAXN], pos[MAXN], l[MAXN], r[MAXN];
vector<int> lefts[MAXN];
vector<int> queries[MAXN];
long long ans[MAXN], ft[MAXN];
void update(int i, int val) {
while (i < MAXN) {
ft[i] += val;
i += i & (-i);
}
}
long long query(int i) {
long long ac = 0LL;
while (i) {
ac += ft[i];
i -= i & (-i);
}
return ac;
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", &nums[i]);
pos[nums[i]] = i;
}
for (int i = 1, a, b; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
a = pos[i];
b = pos[j];
if (a > b) swap(a, b);
lefts[b].push_back(a);
}
}
for (int i = 0; i < q; ++i) {
scanf("%d%d", &l[i], &r[i]);
queries[r[i]].push_back(i);
}
for (int i = 1; i < MAXN; ++i) {
for (int j = 0; j < lefts[i].size(); ++j) update(lefts[i][j], 1);
for (int j = 0, id; j < queries[i].size(); ++j) {
id = queries[i][j];
ans[id] = query(i) - query(l[id] - 1);
}
}
for (int i = 0; i < q; ++i) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200005;
vector<pair<int, int> > push[MAX];
vector<int> divi[MAX];
int seg[4 * MAX], ind[MAX], a[MAX], ans[MAX], n, q;
void inc(int p, int v = 1, int s = 0, int e = n) {
seg[v]++;
if (e - s < 2) return;
int mid = (s + e) / 2;
if (p < mid)
inc(p, 2 * v, s, mid);
else
inc(p, 2 * v + 1, mid, e);
}
int get(int l, int r, int v = 1, int s = 0, int e = n) {
if (l <= s && e <= r) return seg[v];
if (e <= l || r <= s) return 0;
int mid = (s + e) / 2;
return get(l, r, 2 * v, s, mid) + get(l, r, 2 * v + 1, mid, e);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
ind[a[i]] = i;
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
if (ind[i] < ind[j])
divi[j].push_back(i);
else
divi[i].push_back(j);
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
l--, r--;
push[r].push_back(make_pair(i, l));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < divi[a[i]].size(); j++) inc(ind[divi[a[i]][j]]);
for (int j = 0; j < push[i].size(); j++)
ans[push[i][j].first] = get(push[i][j].second, i + 1);
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
int a[200010], num[200010], ans[200010];
struct node {
int l, r, id;
} t[200010];
int c[200010], n;
int cmp(node x, node y) { return x.r < y.r; }
int lowbit(int i) { return i & (-i); }
void add(int i, int x) {
for (; i <= n; i += lowbit(i)) c[i] += x;
}
int sum(int i) {
int s = 0;
for (; i > 0; i -= lowbit(i)) s += c[i];
return s;
}
int main() {
int m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
num[a[i]] = i;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &t[i].l, &t[i].r);
t[i].id = i;
}
sort(t, t + m, cmp);
int k = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
if (num[j] <= i) add(num[j], 1);
if (a[i] / j != j) {
if (num[a[i] / j] <= i) add(num[a[i] / j], 1);
}
}
}
for (int j = 2 * a[i]; j <= n; j += a[i]) {
if (num[j] <= i) add(num[j], 1);
}
while (k < m && t[k].r == i) {
ans[t[k].id] = sum(i) - sum(t[k].l - 1);
k++;
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
bool checkbitt(long long int num, int pos);
long long int setbitt(long long int num, long long int pos);
long long int resetbitt(long long int num, int pos);
const long long int mod = 1e9 + 7;
const long long int N = 2e5 + 100;
int idx[N];
int n, q;
int st[N * 4];
vector<int> graph[N];
void seive() {
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
graph[min(idx[i], idx[j])].push_back(max(idx[i], idx[j]));
}
}
}
void update(int n, int s, int e, int pos) {
if (s == e) {
st[n]++;
return;
}
int mid = (s + e) / 2;
if (mid >= pos)
update(n * 2, s, mid, pos);
else
update(n * 2 + 1, mid + 1, e, pos);
st[n] = st[n * 2] + st[n * 2 + 1];
}
int query(int n, int s, int e, int qs, int qe) {
if (s > qe || e < qs) return 0;
if (s >= qs && e <= qe) return st[n];
int mid = (s + e) / 2;
return query(n * 2, s, mid, qs, qe) + query(n * 2 + 1, mid + 1, e, qs, qe);
}
void U(int id, int v) {
for (; id <= n; st[id] += v, id += (id & -id))
;
}
int Q(int id) {
int ret = 0;
for (; id > 0; ret += st[id], id -= (id & -id))
;
return ret;
}
int solve() {
cin >> n >> q;
int x;
for (int i = 1; i <= n; i++) {
cin >> x;
idx[x] = i;
}
seive();
vector<pair<int, int> > ask[n + 1];
for (int i = 0; i < q; i++) {
int l, r;
cin >> l >> r;
ask[l].push_back({r, i});
}
int ans[q];
for (int i = n; i >= 1; i--) {
for (auto x : graph[i]) {
U(x, 1);
}
for (auto x : ask[i]) {
ans[x.second] = Q(x.first);
}
}
for (int i = 0; i < q; i++) cout << ans[i] << endl;
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int cs = 1;
int cn = 1;
while (cs--) {
solve();
}
}
bool checkbitt(long long int num, int pos) { return (num >> pos) & 1; }
long long int setbitt(long long int num, long long int pos) {
return (1 << pos) | num;
}
long long int resetbitt(long long int num, int pos) {
if (!checkbitt(num, pos))
return num;
else
return (1 << pos) ^ num;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
vector<pair<int, int> > q[maxN];
vector<int> d[maxN];
int pos[maxN], a[maxN], res[maxN], n, m;
int data[4 * maxN];
void add(int p, int x, int s = 0, int e = n, int id = 1) {
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 = 0, int e = n, int id = 1) {
if (e <= l || 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() {
ios::sync_with_stdio(false);
cin.tie();
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; j <= n; j += i)
if (pos[i] < pos[j])
d[j].push_back(i);
else
d[i].push_back(j);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r;
l--, r--;
q[r].push_back(make_pair(i, l));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < d[a[i]].size(); j++) {
int cur = d[a[i]][j];
int p = pos[cur];
add(p, 1);
}
for (int j = 0; j < q[i].size(); j++) {
int idx = q[i][j].first;
int l = q[i][j].second;
int r = i;
res[idx] = get(l, r + 1);
}
}
for (int i = 0; i < m; i++) cout << res[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool isvowel(char c) {
c = tolower(c);
if (c == 'a' || c == 'e' || c == 'i' || c == 'y' || c == 'o' || c == 'u')
return 1;
return 0;
}
const double eps = 0.000001;
const long double pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const long long MOD = 1e18 + 9;
const long long INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 2e5 + 1;
const int M = 22;
const int pri = 997;
const int Magic = 501;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
vector<int> c[N];
int g[N];
vector<pair<int, int> > q[N];
int ans[N];
int was[maxn];
int f[N];
void upd(int pos, int x) {
for (int i = pos; i <= n; i |= (i + 1)) f[i] += x;
}
int get(int r) {
int res = 0;
while (r > 0) {
res += f[r];
r = (r & (r + 1)) - 1;
}
return res;
}
int get(int l, int r) { return get(r) - get(l - 1); }
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
int x;
cin >> x;
g[x] = i;
}
int cur = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
cur++;
c[g[i]].push_back(cur);
c[g[j]].push_back(cur);
}
}
for (long long i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
q[r].push_back(make_pair(l, i));
}
for (long long i = 1; i <= n; i++) {
for (auto x : c[i]) {
if (was[x] > 0) {
upd(was[x], 1);
} else {
was[x] = i;
}
}
for (auto it : q[i]) {
ans[it.second] = get(it.first, i);
}
}
for (long long i = 1; i <= m; i++) {
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200005;
struct segment {
int left, right;
segment() {}
segment(int _left, int _right) {
left = _left;
right = _right;
if (left > right) swap(left, right);
}
bool operator<(const segment &a) const { return right < a.right; }
} s[MaxN * 30];
struct query {
int l, r, idx;
query() {}
query(int _l, int _r, int _idx) {
l = _l;
r = _r;
idx = _idx;
}
bool operator<(const query &a) const { return r < a.r; }
} q[MaxN];
int p[MaxN];
int idx[MaxN];
int c[MaxN];
int n;
void add(int idx, int val) {
while (idx <= n) {
c[idx] += val;
idx += idx & -idx;
}
}
int read(int idx) {
int ret = 0;
while (idx) {
ret += c[idx];
idx -= idx & -idx;
}
return ret;
}
int sol[MaxN];
int main() {
int m;
scanf("%d%d", &n, &m);
memset(idx, 0, sizeof(idx));
for (int i = 1; i <= n; i++) scanf("%d", p + i), idx[p[i]] = i;
int cnt = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i) {
s[++cnt] = segment(idx[i], idx[j]);
}
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
q[i] = query(l, r, i);
}
sort(q + 1, q + m + 1);
sort(s + 1, s + cnt + 1);
memset(c, 0, sizeof(c));
int j = 1;
for (int i = 1; i <= m; i++) {
while (j <= cnt && s[j].right <= q[i].r) {
add(s[j].left, 1);
j++;
}
sol[q[i].idx] = read(q[i].r) - read(q[i].l - 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", sol[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int l, r, i;
};
const int MAXN = 200010;
int n, m, p[MAXN], pnt, ind[MAXN], sieve[MAXN];
long long num[MAXN], bit[MAXN], ans[MAXN];
vector<int> adj[MAXN];
data arr[MAXN];
bool cmp(data d1, data d2) { return d1.l != d2.l ? d1.l < d2.l : d1.r < d2.r; }
long long query(int i) {
long long ret = 0;
for (i += 2; i > 0; i -= i & -i) ret += bit[i];
return ret;
}
void update(int i, int p) {
for (i += 2; i < MAXN; i += i & -i) bit[i] += p;
}
int main() {
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
}
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &p[i]);
ind[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
adj[i].push_back(j);
if (i != j) adj[j].push_back(i);
}
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &arr[i].l, &arr[i].r);
arr[i].i = i;
arr[i].l--;
arr[i].r--;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < adj[p[i]].size(); j++) sieve[adj[p[i]][j]]++;
num[i + 1] = num[i] + sieve[p[i]];
}
sort(arr, arr + m, cmp);
for (int i = 0; i < n; i++) {
int j;
for (j = pnt; j < m && arr[j].l == i; j++) {
ans[arr[j].i] = num[arr[j].r + 1] - num[arr[j].l] - query(arr[j].r) +
query(arr[j].l - 1);
}
pnt = j;
for (int k = 0; k < adj[p[i]].size(); k++) update(ind[adj[p[i]][k]], 1);
}
for (int i = 0; i < m; i++) printf("%I64d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
void rf() {}
const int nx[8] = {2, -2, -2, 2, 1, 1, -1, -1};
const int ny[8] = {1, 1, -1, -1, 2, -2, -2, 2};
const int Nx[4] = {0, 0, -1, 1};
const int Ny[4] = {1, -1, 0, 0};
const long long LINF = (long long)5e18;
const int INF = 1e9 + 7;
const int N = 2e5 + 1;
const int MAXN = 1e6 + 50;
const double EPS = 1e-9, PI = 3.14159265359;
inline int get_int() {
char x = getchar();
int ret = 0;
bool neg = 0;
while (!('0' <= x && x <= '9')) {
if (x == '-') neg = 1;
x = getchar();
}
while ('0' <= x && x <= '9') {
ret = ret * 10 + x - '0';
x = getchar();
}
if (neg) ret *= -1;
return ret;
}
int n, m;
vector<int> queries[N], divisors[N];
int a[N], id[N], l[N], r[N];
long long t[N], ans[N];
void update(int x, int y) {
if (!x) return;
for (int i = x - 1; i < n; i = (i | (i + 1))) t[i] += y;
}
long long get(int x) {
long long ans = 0;
for (int i = x - 1; i >= 0; i = (i & (i + 1)) - 1) ans += t[i];
return ans;
}
int main() {
srand(time(0));
rf();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) divisors[j].push_back(i);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
queries[r[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
id[a[i]] = i;
for (auto d : divisors[a[i]]) update(id[d], 1);
for (auto q : queries[i]) ans[q] = get(i) - get(l[q] - 1);
}
memset(id, 0, sizeof(id));
memset(t, 0, sizeof(t));
for (int i = 1; i <= n; i++) queries[i].clear();
for (int i = 1; i <= m; i++) queries[l[i]].push_back(i);
for (int i = n; i >= 1; i--) {
id[a[i]] = i;
for (auto d : divisors[a[i]])
if (d != a[i]) update(id[d], 1);
for (auto q : queries[i]) ans[q] += get(r[q]) - get(i - 1);
}
for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bit[200001];
int n;
void init() {
for (int i = 0; i <= n; i++) bit[i] = 0;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
int ar[200001];
int pos[200001];
int ans[200000];
vector<pair<pair<int, int>, int> > pt;
int main() {
int m;
int i, j;
scanf("%d %d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &ar[i]);
pos[ar[i]] = i;
}
for (i = 1; i <= n; i++) {
for (j = 1; j * ar[i] <= n; j++)
pt.push_back(
pair<pair<int, int>, int>(pair<int, int>(i, pos[j * ar[i]]), 0));
}
for (i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
pt.push_back(pair<pair<int, int>, int>(pair<int, int>(a, a), i + 1));
pt.push_back(pair<pair<int, int>, int>(pair<int, int>(a, b), m + i + 1));
pt.push_back(pair<pair<int, int>, int>(pair<int, int>(b, a), m + i + 1));
pt.push_back(pair<pair<int, int>, int>(pair<int, int>(b, b), i + 1));
ans[i] = 0;
}
sort(pt.begin(), pt.end());
init();
for (i = 0; i < pt.size(); i++) {
int x = pt[i].first.first;
int y = pt[i].first.second;
int t = pt[i].second;
if (t == 0)
add(y, 1);
else if (t > m)
ans[t - m - 1] -= sum(y);
else
ans[t - 1] += sum(y);
}
for (i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, cmo, mal;
long long T[200009 * 4], res[200009];
vector<int> par[200009];
int a[200009], yer[200009], pars[200009];
vector<pair<int, int> > v[200009];
void build(int l, int r, int node) {
if (l == r) {
T[node] = pars[l];
return;
}
build(l, (l + r) / 2, node * 2 + 1);
build((l + r) / 2 + 1, r, node * 2);
T[node] = T[node * 2] + T[node * 2 + 1];
}
long long search(int x, int y, int l, int r, int node) {
if (x <= l && r <= y) return T[node];
if (l > y || r < x) return 0ll;
return search(x, y, l, (l + r) / 2, node * 2 + 1) +
search(x, y, (l + r) / 2 + 1, r, node * 2);
}
void upd(int x, int l, int r, int node) {
if (l == r) {
T[node]--;
return;
}
if (x <= (l + r) / 2)
upd(x, l, (l + r) / 2, node * 2 + 1);
else
upd(x, (l + r) / 2 + 1, r, node * 2);
T[node] = T[node * 2] + T[node * 2 + 1];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), yer[a[i]] = i;
for (int i = 0; i < k; i++) {
scanf("%d%d", &cmo, &mal);
v[cmo].push_back({mal, i});
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int yeri = yer[i], yerj = yer[j], yerh = yer[i];
if (yeri > yerj) yeri = yerj, yerj = yerh;
pars[yerj]++;
par[a[yeri]].push_back(a[yerj]);
}
}
build(1, n, 1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < v[i].size(); j++)
res[v[i][j].second] = search(i, v[i][j].first, 1, n, 1);
for (int j = 0; j < par[a[i]].size(); j++) upd(yer[par[a[i]][j]], 1, n, 1);
}
for (int i = 0; i < k; i++) printf("%I64d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long A[N], idx[N], ans[N], BIT[N];
vector<long long> in[N], out[N];
vector<pair<long long, long long> > ss[N], se[N];
void update(long long idx, long long val) {
for (; idx < N; idx += (idx & -idx)) BIT[idx] += val;
return;
}
long long query(long long idx) {
long long ret = 0;
for (; idx > 0; idx -= (idx & -idx)) ret += BIT[idx];
return ret;
}
int main() {
long long n, m;
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; ++i) scanf("%lld", &A[i]), idx[A[i]] = i;
for (long long i = 1; i <= n; ++i) {
for (long long j = A[i]; j <= n; j += A[i]) {
long long st = idx[A[i]], en = idx[j];
if (st > en) swap(st, en);
in[st].push_back(en);
out[en].push_back(en);
}
}
for (long long i = 1; i <= m; ++i) {
long long l, r;
scanf("%lld%lld", &l, &r);
se[l].push_back({r, i});
ss[r].push_back({l, i});
}
for (long long i = 1; i <= n; ++i) {
for (auto u : se[i]) ans[u.second] = -query(u.first);
for (auto u : in[i]) update(u, 1);
for (auto u : ss[i]) ans[u.second] += query(i);
}
for (long long i = 1; i <= m; ++i) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<pair<int, int>, int> query[200000];
int arr[200000], ans[200000];
vector<pair<int, int>> valids;
int loc[200001];
const int base = 1 << 18;
int iTree[base << 1];
int getVal(int cs, int ce, int ts, int te, int ind) {
if (cs >= ce or ts >= te or cs >= te or ts >= ce) return 0;
if (cs == ts and ce == te) return iTree[ind];
int mid = (cs + ce) / 2;
return getVal(cs, mid, ts, min(te, mid), ind * 2) +
getVal(mid, ce, max(ts, mid), te, ind * 2 + 1);
}
int main(void) {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
loc[arr[i]] = i;
}
for (int i = 0; i < m; i++) {
scanf("%d %d", &query[i].first.first, &query[i].first.second);
query[i].second = i;
}
sort(query, query + m);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
valids.push_back(make_pair(min(loc[i], loc[j]), max(loc[i], loc[j])));
sort(valids.begin(), valids.end());
int vind = valids.size() - 1;
for (int i = m - 1; i >= 0; i--) {
while (vind >= 0 and valids[vind].first >= query[i].first.first - 1) {
int ind = valids[vind--].second;
ind += base;
while (ind > 0) {
iTree[ind]++;
ind /= 2;
}
}
ans[query[i].second] =
getVal(0, base, query[i].first.first - 1, query[i].first.second, 1);
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 2e5 + 10;
int64_t n, m, a[N], first[N], ans[N], p[N];
pair<std::pair<int64_t, int64_t>, int64_t> q[N];
vector<int64_t> adj[N];
void add(int64_t x, int64_t y) {
for (; x < N; x += x & -x) {
first[x] += y;
}
}
int64_t get(int64_t x) {
int64_t ret = 0;
for (; x; x -= x & -x) {
ret += first[x];
}
return ret;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int64_t i = 1; i <= n; i++) {
cin >> a[i];
p[a[i]] = i;
}
for (int64_t i = 1; i <= n; i++) {
for (int64_t j = i; j <= n; j += i) {
adj[min(p[i], p[j])].push_back(max(p[i], p[j]));
add(max(p[i], p[j]), 1ll);
}
}
for (int64_t i = 0; i < m; i++) {
cin >> q[i].first.first >> q[i].first.second;
q[i].second = i;
}
sort(q, q + m);
int64_t last = 1;
for (int64_t i = 0; i < m; i++) {
while (last < q[i].first.first) {
for (int64_t k = 0; k < adj[last].size(); k++) {
add(adj[last][k], -1ll);
}
last++;
}
ans[q[i].second] = get(q[i].first.second);
}
for (int64_t i = 0; i < m; i++) {
cout << ans[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long MOD = 1e9 + 7;
struct fuck {
long long idx;
long long l;
long long r;
};
bool cmp(fuck a, fuck b) { return (a.r < b.r); }
long long BIT[N];
long long n;
void update(long long idx) {
while (idx <= n) {
BIT[idx]++;
idx += ((idx & (-idx)));
}
}
long long query(long long idx) {
long long sum = 0;
while (idx > 0) {
sum += BIT[idx];
idx -= ((idx & (-idx)));
}
return sum;
}
int main() {
long long q;
scanf("%lld", &n);
scanf("%lld", &q);
long long a[n + 1];
long long pos[n + 1];
for (int i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
pos[a[i]] = i;
}
vector<long long> v[n + 1];
for (int i = 1; i <= n; i++) {
v[i].push_back(i);
for (long long x = a[i] + a[i]; x <= n; x += a[i]) {
if (pos[x] < i) v[i].push_back(pos[x]);
if (i < pos[x]) v[pos[x]].push_back(i);
}
}
fuck ranges[q + 1];
for (int i = 1; i <= q; i++) {
cin >> ranges[i].l >> ranges[i].r;
ranges[i].idx = i;
}
sort(ranges + 1, ranges + q + 1, cmp);
vector<long long> ending[n + 1];
for (int i = 1; i <= q; i++) {
ending[ranges[i].r].push_back(i);
}
vector<long long> ans(q + 1, 0);
for (int i = 1; i <= n; i++) {
for (auto x : v[i]) {
update(x);
}
for (auto x : ending[i]) {
ans[ranges[x].idx] = query(ranges[x].r) - query(ranges[x].l - 1);
}
}
for (int i = 1; i <= q; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> dis[200005];
long long ans[200005];
long long num[200005 << 2];
int value[200005];
int pos[200005];
int n;
struct node {
int l, r, pos;
bool operator<(node temp) const { return r < temp.r; }
} data[200005];
inline int lowbit(int x) { return x & (-x); }
inline void update(int x, int v) {
while (x > 0) {
num[x] += v;
x -= lowbit(x);
}
}
inline long long query(int x) {
long long ans = 0;
while (x <= n) {
ans += num[x];
x += lowbit(x);
}
return ans;
}
int main() {
int m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
scanf("%d", &value[i]);
pos[value[i]] = i;
}
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]]) dis[value[i]].push_back(j);
if (value[i] != j && pos[value[i]] <= pos[j])
dis[j].push_back(value[i]);
if (j * j == value[i]) continue;
int k = value[i] / j;
if (pos[k] <= pos[value[i]]) dis[value[i]].push_back(k);
if (value[i] != k && pos[value[i]] <= pos[k])
dis[k].push_back(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++) {
int len = dis[value[i]].size();
for (int j = 0; j < len; j++) {
int k = dis[value[i]][j];
update(pos[k], 1);
}
while (data[p].r == i && p < m) {
ans[data[p].pos] = query(data[p].l);
p++;
}
}
for (int i = 0; i < m; i++) {
printf("%I64d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(2e5) + 1;
int bt[MAXN], ans[MAXN];
int A[MAXN], N, M, pos[MAXN];
struct datapos {
vector<pair<int, int>> qR;
vector<pair<int, int>> qL;
} d[MAXN];
int 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].qR.push_back({left, queryi});
d[left].qL.push_back({right, queryi});
}
for (int posi = 1; posi <= N; posi++) {
for (auto qu : d[posi].qL)
ans[qu.second] -= (getsum(qu.first) - getsum(posi - 1));
for (int x = A[posi]; x <= N; x += A[posi]) incr(pos[x]);
for (auto qu : d[posi].qR)
ans[qu.second] += (getsum(posi) - getsum(qu.first - 1));
}
for (int i = 0; i < M; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200 * 1000 + 9;
const bool QRY = 0;
const bool UPD = 1;
struct Data {
int l, r, id;
Data() : l(0), r(0){};
Data(int _l, int _r) : l(_l), r(_r){};
} a[MAX_N];
int n, m, N;
int p[MAX_N], idx[MAX_N];
long long fwt[MAX_N], ans[MAX_N];
vector<pair<long long, long long> > divP;
void treeUpdate(int idx, long long val) {
for (; idx <= n; idx += (idx & -idx)) fwt[idx] += val;
}
long long sum(int idx) {
long long total = 0;
for (; idx > 0; idx -= (idx & -idx)) total += fwt[idx];
return total;
}
long long treeSum(int l, int r) { return sum(r) - sum(l - 1); }
bool cmp(const Data &lhs, const Data &rhs) { return lhs.r < rhs.r; }
bool dCmp(const pair<long long, long long> &lhs,
const pair<long long, long long> &rhs) {
return lhs.second < rhs.second;
}
void gen() {
for (int i = 1; i <= n; i++) {
for (int pj = p[i]; pj <= n; pj += p[i]) {
int j = idx[pj];
divP.push_back(make_pair(i, j));
if (divP.back().first > divP.back().second)
swap(divP.back().first, divP.back().second);
}
}
}
void readInput() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> p[i];
idx[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
cin >> a[i].l >> a[i].r;
a[i].id = i;
}
}
void solve() {
gen();
sort(a + 1, a + m + 1, cmp);
sort(divP.begin(), divP.end(), dCmp);
N = divP.size();
int j = 0;
for (int i = 1; i <= m; i++) {
while (j < N && divP[j].second <= a[i].r) {
treeUpdate(divP[j].first, 1);
j++;
}
ans[a[i].id] = treeSum(a[i].l, a[i].r);
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
readInput();
solve();
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) {
assert(pos <= se);
assert(pos >= ss);
if (ss == se) {
assert(ss == pos);
st[si]++;
} else {
int mid = (ss + se) / 2;
if (pos <= mid)
st_upd(si * 2, ss, mid, pos);
else
st_upd(si * 2 + 1, mid + 1, se, pos);
st[si] = st[si * 2] + st[si * 2 + 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;
void fastscan(int &number) {
bool negative = false;
register int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
const int N = 2e5 + 5;
int arr[N], seg[4 * N], ind[N], p[N], ans[N];
vector<int> start[N];
vector<pair<int, int>> q[N];
void build(int l, int u, int i) {
if (l == u) {
seg[i] = arr[l];
return;
}
build(l, ((l + u) / 2), (i * 2 + 1));
build(((l + u) / 2) + 1, u, (i * 2 + 2));
seg[i] = seg[(i * 2 + 1)] + seg[(i * 2 + 2)];
}
int query(int l, int u, int i, int ll, int uu) {
if (l >= ll && u <= uu) return seg[i];
if (l > uu || u < ll) return 0;
return query(l, ((l + u) / 2), (i * 2 + 1), ll, uu) +
query(((l + u) / 2) + 1, u, (i * 2 + 2), ll, uu);
}
void update(int l, int u, int i, int uu, int upval) {
if (l >= uu && u <= uu) {
seg[i] += upval;
return;
}
if (l > uu || u < uu) return;
update(l, ((l + u) / 2), (i * 2 + 1), uu, upval);
update(((l + u) / 2) + 1, u, (i * 2 + 2), uu, upval);
seg[i] = seg[(i * 2 + 1)] + seg[(i * 2 + 2)];
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> p[i];
ind[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int a = ind[i] + 1, b = ind[j] + 1;
if (a > b) swap(a, b);
start[a].push_back(b);
arr[b]++;
}
}
build(1, n, 0);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
q[u].push_back(make_pair(v, i));
}
int toremove = 1;
for (int i = 1; i <= n; i++) {
while (toremove < i) {
for (int j : start[toremove]) update(1, n, 0, j, -1);
toremove++;
}
for (pair<int, int> lol : q[i]) {
ans[lol.second] = query(1, n, 0, i, lol.first);
}
}
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int a[MAXN], pos[MAXN], tree[MAXN];
int n, m;
int lowbit(int x) { return x & (-x); }
int get_sum(int k) {
int ans = 0;
while (k > 0) {
ans += tree[k];
k -= lowbit(k);
}
return ans;
}
void modify(int k, int val) {
while (k <= n) {
tree[k] += val;
k += lowbit(k);
}
}
struct QUERY {
int id, L, R;
bool operator<(const QUERY &rhs) const { return L < rhs.L; }
} query[MAXN], query_t[MAXN];
int ans[MAXN];
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) {
scanf("%d%d", &query[i].L, &query[i].R);
query_t[i].L = query[i].R;
query_t[i].R = query[i].L;
query[i].id = query_t[i].id = i;
}
sort(query + 1, query + m + 1);
sort(query_t + 1, query_t + m + 1);
for (int i = 1, j = 1, k = 1; i <= n; ++i) {
while (j <= m && query[j].L == i) {
ans[query[j].id] -= get_sum(query[j].R) - get_sum(query[j].L - 1);
++j;
}
for (int p = a[i]; p <= n; p += a[i]) modify(pos[p], 1);
while (k <= m && query_t[k].L == i) {
ans[query_t[k].id] += get_sum(query_t[k].L) - get_sum(query_t[k].R - 1);
++k;
}
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200010], num[200010];
vector<pair<pair<int, int>, int> > v;
vector<pair<int, int> > vadd;
long long seg[200010], ans[200010];
void workadd() {
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
vadd.push_back(make_pair(max(num[i], num[j]), min(num[i], num[j])));
sort(vadd.begin(), vadd.end());
for (int i = 0; i < vadd.size(); i++) swap(vadd[i].first, vadd[i].second);
}
void add(int x) {
x++;
while (x <= n + 5) seg[x]++, x += x & (-x);
}
long long sum(int x) {
x++;
int r = 0;
while (x > 0) r += seg[x], x -= x & (-x);
return r;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), num[a[i]] = i;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
v.push_back(make_pair(make_pair(y, x), i));
}
sort(v.begin(), v.end());
for (int i = 0; i < m; i++) swap(v[i].first.first, v[i].first.second);
workadd();
int bk = -1, t = 0;
for (int i = 0; i < m;) {
int rbound = v[i].first.second;
while (bk != rbound) {
bk++;
while (t < vadd.size() && vadd[t].second <= rbound)
add(vadd[t].first), t++;
}
int j;
for (j = i; v[j].first.second == rbound && j < m; j++)
ans[v[j].second] = sum(n) - sum(v[j].first.first - 1);
i = j;
}
for (int i = 0; i < m; i++) printf("%I64d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 18;
vector<int> pair_list[N];
vector<pair<int, int> > q[N];
int n, m, a[N], ans[N], pos[N], seg[N << 2];
void update(int ind, int l, int r, int w) {
if (l > w || r < w) return;
if (l == w && r == w) {
seg[ind]++;
return;
}
int mid = (l + r) / 2;
update(ind * 2, l, mid, w);
update(ind * 2 + 1, mid + 1, r, w);
seg[ind] = seg[ind * 2] + seg[ind * 2 + 1];
}
int query(int ind, int l, int r, int lw, int rw) {
if (l > rw || r < lw) return 0;
if (l >= lw && r <= rw) return seg[ind];
int mid = (l + r) / 2;
return query(ind * 2, l, mid, lw, rw) +
query(ind * 2 + 1, mid + 1, r, lw, rw);
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
int l, r;
cin >> l >> r;
q[l].push_back({r, i});
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
pair_list[min(pos[i], pos[j])].push_back(max(pos[i], pos[j]));
}
}
for (int i = n; i > 0; i--) {
for (auto j : pair_list[i]) {
update(1, 1, n, j);
}
for (auto j : q[i]) {
ans[j.second] = query(1, 1, n, 1, j.first);
}
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = (1 << 18) - 1;
int t[sz * 2];
void upd(int pos) {
++t[pos += sz];
while ((pos /= 2) >= 1) ++t[pos];
}
int get(int l, int r) {
int res = 0;
for (l += sz, r += sz; l <= r; l /= 2, r /= 2) {
if (l % 2 == 1) res += t[l++];
if (r % 2 == 0) res += t[r--];
if (l > r) break;
}
return res;
}
int n, m, a, f[sz], l, r;
long long ans[sz];
vector<int> g[sz];
vector<pair<int, int> > b[sz], c[sz];
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 >> a;
f[a] = i;
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
l = min(f[i], f[j]);
r = max(f[i], f[j]);
g[l].push_back(r);
}
}
for (int i = 1; i <= m; ++i) {
cin >> l >> r;
b[l].push_back(make_pair(r, i));
c[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; ++i) {
for (auto to : b[i]) {
ans[to.second] -= get(i, to.first);
}
for (auto to : g[i]) upd(to);
for (auto to : c[i]) {
ans[to.second] += get(to.first, i);
}
}
for (int i = 1; i <= m; ++i) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e5;
int n, m;
int a[2 * MaxN + 5];
int pos[2 * MaxN + 5];
int c[2 * MaxN + 5];
int tot;
struct PP {
int l, r;
int p;
int ans;
} ll[50 * MaxN + 5];
PP q[2 * MaxN + 5];
int cmpl(PP x, PP y) {
if (x.l == y.l)
return x.r < y.r;
else
return x.l < y.l;
}
int cmpp(PP x, PP y) { return x.p < y.p; }
int lowbit(int x) { return x & (-x); }
void add(int x, int w) {
while (x <= n) {
c[x] += w;
x += lowbit(x);
}
}
int getsum(int end) {
int res = 0;
while (end > 0) {
res += c[end];
end -= lowbit(end);
}
return res;
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
tot = 0;
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 = 1; i * j <= n; j++) {
ll[++tot].l = min(pos[i], pos[i * j]);
ll[tot].r = max(pos[i], pos[i * j]);
add(ll[tot].r, 1);
}
}
sort(ll + 1, ll + tot + 1, cmpl);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &q[i].l, &q[i].r);
q[i].p = i;
}
sort(q + 1, q + m + 1, cmpl);
int head = 1, now = 1;
for (int i = 1; i <= m; i++) {
while (head < q[i].l) head++;
while (ll[now].l < head) {
add(ll[now].r, -1);
now++;
}
q[i].ans = getsum(q[i].r);
}
sort(q + 1, q + m + 1, cmpp);
for (int i = 1; i <= m; i++) printf("%d\n", q[i].ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Query {
long long l, r, id;
Query(long long l, long long r, long long id) : l(l), r(r), id(id) {}
bool operator<(const Query& q) const { return r < q.r; }
};
long long n, m, p[200005], a[200005], bit[200005], ans[200005];
vector<long long> add[200005];
vector<Query> req;
void upd(long long id) {
for (; id; id -= id & -id) bit[id]++;
}
long long get(long long id) {
long long ret = 0;
for (; id < 200005; id += id & -id) ret += bit[id];
return ret;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (long long i = 1; i <= n; i++) cin >> p[i], a[p[i]] = i;
for (long long l, r, i = 0; i < m; i++) {
cin >> l >> r;
req.push_back({l, r, i});
}
sort(req.begin(), req.end());
for (long long i = 1; i <= n; i++) {
for (long long j = p[i]; j <= n; j += p[i]) {
if (a[j] > i)
add[a[j]].push_back(i);
else
add[i].push_back(a[j]);
}
}
long long run = 0;
for (long long l, r, id, i = 0; i < m; i++) {
l = req[i].l;
r = req[i].r;
id = req[i].id;
while (run < r) {
++run;
for (long long j = 0; j < add[run].size(); j++) upd(add[run][j]);
}
ans[id] = get(l);
}
for (long long i = 0; i < m; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
vector<int> factor[maxn];
vector<pair<int, int> > query[maxn];
int n, m, ret;
int tr[maxn], a[maxn], ans[maxn], pos[maxn];
void Read() {
int i, x, y;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), pos[a[i]] = i;
for (i = 1; i <= m; i++)
scanf("%d%d", &x, &y), query[y].push_back(make_pair(x, i));
}
void Update(int x) {
for (; x <= n; x += x & -x) tr[x]++;
}
int Query(int x) {
for (ret = 0; x; x -= x & -x) ret += tr[x];
return ret;
}
void Solve() {
int i, j, t;
for (i = 1; i <= n; i++)
for (j = i; j <= n; j += i) factor[j].push_back(i);
for (i = 1; i <= n; i++) {
for (j = 0; j < factor[a[i]].size(); j++) {
t = pos[factor[a[i]][j]];
if (t <= i) Update(t);
}
for (j = 2; a[i] * j <= n; j++) {
t = pos[a[i] * j];
if (t <= i) Update(t);
}
for (j = 0; j < query[i].size(); j++)
ans[query[i][j].second] = Query(i) - Query(query[i][j].first - 1);
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
int main() {
Read();
Solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (const int)(2e5 + 10);
int fen[MAXN], a[MAXN], ans[MAXN];
vector<int> zar[MAXN];
vector<pair<int, int> > q[MAXN];
void add(int p) {
for (p++; p < MAXN; p += p & -p) {
fen[p]++;
}
}
int get(int p) {
int ret = 0;
for (; p > 0; p -= p & -p) {
ret += fen[p];
}
return ret;
}
int mp[MAXN];
int main() {
int n, m;
cin >> 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]) {
zar[mp[j]].push_back(mp[i]);
} else {
zar[mp[i]].push_back(mp[j]);
}
}
}
for (int i = 0, x, y; i < m; i++) {
cin >> x >> y;
q[--x].push_back({y, i});
}
if (n == 1) {
for (int i = 0; i < m; i++) {
cout << 1 << endl;
}
return 0;
}
for (int i = n - 1; i > -1; i--) {
for (auto j : zar[i]) {
add(j);
}
for (auto j : q[i]) {
ans[j.second] = get(j.first) - get(i);
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200000 + 100;
long long fen[maxn], p[maxn], ans[maxn];
vector<pair<int, int> > vec;
vector<pair<pair<int, int>, int> > seg;
void add(int x, int val) {
for (; x < maxn; x += x & -x) fen[x] += val;
}
long long sum(int x) {
long long res = 0;
for (; x > 0; x -= x & -x) res += fen[x];
return res;
}
int main() {
int n, q, x, y, ind = 0;
scanf("%d%d ", &n, &q);
for (int i = 0; i < n; i++) scanf("%d ", &x), p[x] = i + 1;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
vec.push_back({max(p[i], p[j]), min(p[i], p[j])});
while (q--) {
int l, r;
scanf("%d%d ", &l, &r);
seg.push_back({{r, l}, ind++});
}
sort(seg.begin(), seg.end());
sort(vec.begin(), vec.end());
x = y = 0;
for (int now = 1; now <= n; now++) {
while (vec[x].first == now) {
add(vec[x].second, 1);
x++;
}
while (seg[y].first.first == now) {
ans[seg[y].second] =
sum(seg[y].first.first) - sum(seg[y].first.second - 1);
y++;
}
}
for (int i = 0; i < ind; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N(200010);
int n, m;
vector<int> ad[N];
vector<pair<int, int> > q[N];
int c[N], ans[N], a[N], b[N], l[N], r[N];
int low(int x) { return x & (-x); }
void add(int x) {
for (; x; x -= low(x)) ++c[x];
}
int sum(int x) {
int ret = 0;
for (; x <= n; x += low(x)) ret += c[x];
return ret;
}
void calc() {
memset(c, 0, sizeof(c));
for (int i = int(1); i < int(n + 1); ++i) {
b[a[i]] = i;
ad[i].clear();
q[i].clear();
}
for (int i = int(0); i < int(m); ++i) q[l[i]].push_back(make_pair(r[i], i));
for (int i = int(1); i < int(n + 1); ++i)
for (int j = i; j <= n; j += i)
if (b[i] <= b[j]) ad[b[i]].push_back(b[j]);
for (int i = n; i; --i) {
for (int j = int(0); j < int(ad[i].size()); ++j) add(ad[i][j]);
for (int j = int(0); j < int(q[i].size()); ++j)
ans[q[i][j].second] += sum(i) - sum(q[i][j].first + 1);
}
}
int main() {
cin >> n >> m;
for (int i = int(1); i < int(n + 1); ++i) cin >> a[i];
for (int i = int(0); i < int(m); ++i) {
cin >> l[i] >> r[i];
ans[i] = -(r[i] - l[i] + 1);
}
calc();
for (int i = int(0); i < int(m); ++i) {
l[i] = n - l[i] + 1;
r[i] = n - r[i] + 1;
swap(l[i], r[i]);
}
reverse(a + 1, a + n + 1);
calc();
for (int i = int(0); i < int(m); ++i) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tree[200005];
void update(int idx, int val) {
while (idx < 200005) {
tree[idx] += val;
idx += (idx & (-idx));
}
}
int query(int idx) {
int ans = 0;
while (idx > 0) {
ans += tree[idx];
idx -= (idx & (-idx));
}
return ans;
}
int ans[200005];
int v[200005];
vector<int> v1[200005];
vector<pair<int, int> > queries[200005];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
v[a] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
v1[max(v[i], v[j])].push_back(min(v[i], v[j]));
}
}
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d %d", &l, &r);
queries[r].push_back({l, i});
}
for (int i = 1; i <= n; i++) {
for (int x : v1[i]) {
update(x, 1);
}
for (pair<int, int> q : queries[i]) {
ans[q.second] = query(i) - query(q.first - 1);
}
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed long long int bit[200000 + 5];
signed long long int read(int idx) {
signed long long int sum = 0;
if (idx == 0) return 0;
while (idx > 0) {
sum += bit[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, int val) {
while (idx <= 200000) {
bit[idx] += val;
idx += (idx & -idx);
}
}
vector<pair<int, int> > Q[200000 + 5];
int where[200000 + 5];
vector<int> good[200000 + 5];
signed long long int ans[200000 + 5];
int main() {
int N, q, x, L, R;
cin >> N >> q;
for (int i = 1; i <= N; ++i) {
scanf("%d", &x);
where[x] = i;
}
for (int i = 1; i <= N; ++i) {
for (int j = i; j <= N; j += i) {
if (where[j] < where[i]) {
good[where[i]].push_back(where[j]);
} else {
good[where[j]].push_back(where[i]);
}
}
}
for (int i = 1; i <= q; ++i) {
scanf("%d", &L);
scanf("%d", &R);
Q[R].push_back(make_pair(L, i));
}
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < good[i].size(); ++j) {
update(good[i][j], 1);
}
for (int j = 0; j < Q[i].size(); ++j) {
ans[Q[i][j].second] = read(N) - read(Q[i][j].first - 1);
}
}
for (int i = 1; i <= q; ++i) {
printf("%lld\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int v, next;
} edge[4000005];
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;
using ll = long long;
template <class T>
using V = vector<T>;
const int N = 2e5 + 5;
int n, m;
int a[N], pos[N], L[N], R[N], ans[N];
V<int> add[N], Q[N];
int base[N];
void upd(int at, int v) {
for (int i = at; i < N; i += (i & -i)) base[i] += v;
}
int get(int at) {
int sum = 0;
for (int i = at; i; i -= (i & -i)) sum += base[i];
return sum;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i], pos[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = a[i]; j <= n; j += a[i]) {
int x = i, y = pos[j];
if (x < y) swap(x, y);
add[x].push_back(y);
}
}
for (int i = 1; i <= m; i++) {
cin >> L[i] >> R[i], Q[R[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (auto& x : add[i]) upd(x, 1);
for (auto& id : Q[i]) ans[id] = get(i) - get(L[id] - 1);
}
for (int i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 Rand(time(0));
const int maxn = 2e5 + 5;
const long long maxc = 1e9 + 7;
int p[maxn], r[maxn], n, m;
vector<int> in[maxn];
vector<int> query[maxn];
int bit[maxn], ans[maxn];
void up(int x) {
for (; x <= n; x += x & -x) bit[x]++;
}
int get(int x) {
int res = 0;
for (; x > 0; x -= x & -x) res += bit[x];
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
p[x] = i;
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
in[min(p[i], p[j])].push_back(max(p[i], p[j]));
for (int i = 1; i <= m; i++) {
int l;
cin >> l >> r[i];
query[l].push_back(i);
}
for (int i = n; i >= 1; i--) {
for (auto p : in[i]) up(p);
for (auto x : query[i]) ans[x] = get(r[x]);
}
for (int i = 1; i <= m; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long pre[N];
int a[N], vis[N], pos[N];
struct node {
int l, r, id;
bool operator<(const node& nod) const { return l < nod.l; }
} q[N];
long long sum[N], ans[N];
int lowbit(int x) { return x & (-x); }
void add(int x) {
for (int i = x; i < N; i += lowbit(i)) sum[i]++;
}
int query(int x) {
long long ans = 0;
for (int i = x; i; i -= lowbit(i)) ans += sum[i];
return ans;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
long long sum = n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]), pos[a[i]] = i;
sum = sum + n / i - 1;
}
pre[n] = sum;
for (int i = n; i >= 2; i--) {
pre[i - 1] = pre[i];
for (int j = 1; j <= sqrt(a[i]); j++) {
if (a[i] % j == 0) {
if (!vis[j]) pre[i - 1]--;
if (a[i] / j != j && !vis[a[i] / j]) pre[i - 1]--;
}
}
for (int j = 2; j * a[i] <= n; j++) {
if (!vis[a[i] * j]) pre[i - 1]--;
}
vis[a[i]] = 1;
}
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= m; i++) scanf("%d%d", &q[i].l, &q[i].r), q[i].id = i;
sort(q + 1, q + 1 + m);
int p = 1;
for (int i = 1; i <= m; i++) {
while (p < q[i].l) {
for (int j = 1; j <= sqrt(a[p]); j++) {
if (a[p] % j == 0) {
if (!vis[j]) add(pos[j]);
if (a[p] / j != j && !vis[a[p] / j]) add(pos[a[p] / j]);
}
}
for (int j = 2; j * a[p] <= n; j++) {
if (!vis[a[p] * j]) add(pos[a[p] * j]);
}
vis[a[p]] = 1;
p++;
}
ans[q[i].id] =
pre[q[i].r] - pre[q[i].l - 1] - query(q[i].r) + query(q[i].l - 1);
}
for (int i = 1; i <= m; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long c[300000], ans[300000];
int p[300000], a[300000], x, y, N, M;
vector<int> E[300000];
vector<pair<int, int> > q[300000];
int lowbit(int x) { return x & (-x); }
void modify(int x) {
while (x <= N) c[x]++, x += lowbit(x);
}
long long query(int x) {
long long ans = 0;
while (x) ans += c[x], x -= lowbit(x);
return ans;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) scanf("%d", &a[i]), p[a[i]] = i;
for (int i = 1; i <= N; ++i)
for (int j = i; j <= N; j += i)
if (p[i] <= p[j])
E[p[j]].push_back(p[i]);
else
E[p[i]].push_back(p[j]);
for (int i = 1; i <= M; ++i)
scanf("%d%d", &x, &y), q[y].push_back(make_pair(x, i));
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < E[i].size(); ++j) modify(E[i][j]);
for (int j = 0; j < q[i].size(); ++j)
ans[q[i][j].second] = query(i) - query(q[i][j].first - 1);
}
for (int i = 1; i <= M; ++i) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200 * 1000 + 10;
int a[MAXN];
int ans[MAXN];
pair<pair<int, int>, int> se[MAXN];
int pos[MAXN];
int fen[MAXN];
void addF(int x) {
while (x < MAXN) {
fen[x]++;
x += x & -x;
}
}
int getF(int x) {
int ans = 0;
while (x) {
ans += fen[x];
x -= x & -x;
}
return ans;
}
int main() {
int n, m;
cin >> n >> m;
memset(pos, -1, sizeof pos);
for (int i = 0; i < n; i++) {
cin >> a[i];
pos[a[i]] = i + 1;
}
for (int i = 0; i < m; i++) {
se[i].second = i;
cin >> se[i].first.first >> se[i].first.second;
}
sort(se, se + m);
int x = n;
for (int i = m - 1; i >= 0; i--) {
while (x >= se[i].first.first) {
for (int y = a[x - 1]; y <= n; y += a[x - 1])
if (pos[y] != -1 && pos[y] >= x) addF(pos[y]);
x--;
}
ans[se[i].second] += getF(se[i].first.second) - getF(se[i].first.first - 1);
swap(se[i].first.first, se[i].first.second);
}
sort(se, se + m);
memset(fen, 0, sizeof fen);
x = 1;
for (int i = 0; i < m; i++) {
while (x <= se[i].first.first) {
for (int y = a[x - 1]; y <= n; y += a[x - 1])
if (pos[y] != -1 && pos[y] < x) addF(pos[y]);
x++;
}
ans[se[i].second] += getF(se[i].first.first) - getF(se[i].first.second - 1);
}
for (int i = 0; i < m; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5;
struct node {
int l, r, id;
} q[maxn + 10];
int a[maxn + 10];
int ans[maxn + 10];
int inx[maxn + 10];
int c[maxn + 10];
int lowbit(int x) { return x & (-x); }
int sum(int x) {
int res = 0;
while (x > 0) {
res += c[x];
x -= lowbit(x);
}
return res;
}
void add(int x, int val) {
while (x <= maxn) {
c[x] += val;
x += lowbit(x);
}
}
bool cmp(node a, node b) { return a.r < b.r; }
vector<int> ve[maxn + 10];
int main() {
int n, m;
while (~scanf("%d%d", &n, &m)) {
memset(c, 0, sizeof(c));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
inx[a[i]] = i;
ve[i].clear();
}
for (int i = 1; i <= n; i++) {
for (int j = i + i; j <= n; j += i) {
int idi = inx[i];
int idj = inx[j];
if (idj > idi) {
ve[idj].push_back(idi);
} else {
ve[idi].push_back(idj);
}
}
}
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 r = 1;
for (int i = 1; i <= m; i++) {
while (r <= q[i].r) {
for (auto id : ve[r]) {
add(id, 1);
}
r++;
}
ans[q[i].id] = sum(q[i].r) - sum(q[i].l - 1) + q[i].r - q[i].l + 1;
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7, N = 4e5 + 500;
struct query {
int l, r, id;
bool operator<(const query &t) const {
if (r != t.r) return r < t.r;
return id < t.id;
}
};
vector<query> queries;
vector<int> pos, ans;
void add_pair(int a, int b) {
int l = pos[a], r = pos[b];
if (l > r) swap(l, r);
queries.push_back({l, r, -1});
}
int ftree[N];
void fadd(int u) {
for (int i = u; i < N; i += i & (-i)) {
++ftree[i];
}
}
int fget(int u) {
int ans = 0;
for (int i = u; i > 0; i -= i & (-i)) {
ans += ftree[i];
}
return ans;
}
int main() {
int n, q;
cin >> n >> q;
queries.resize(q);
pos.resize(n + 1);
ans.resize(q);
for (int i = 1; i <= n; ++i) {
int a;
scanf("%d", &a);
pos[a] = i;
}
for (int i = 0; i < q; ++i) {
scanf("%d %d", &queries[i].l, &queries[i].r);
queries[i].id = i;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j * j <= i; ++j) {
if (i % j == 0) {
add_pair(i, j);
if (j * j != i) add_pair(i, i / j);
}
}
}
sort(queries.begin(), queries.end());
for (int i = 0; i < queries.size(); ++i) {
if (queries[i].id == -1) {
fadd(N - queries[i].l);
} else {
ans[queries[i].id] = fget(N - queries[i].l);
}
}
for (int i = 0; i < q; ++i) printf("%d\n", ans[i]);
}
|
#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) {
assert(pos <= se);
assert(pos >= ss);
if (ss == se) {
assert(ss == pos);
st[si]++;
} else {
int mid = (ss + se) / 2;
if (pos <= mid)
st_upd(si * 2, ss, mid, pos);
else
st_upd(si * 2 + 1, mid + 1, se, pos);
st[si] = st[si * 2] + st[si * 2 + 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 posi = 1; posi <= N; posi++) {
for (int multi = A[posi]; multi <= N; multi += A[posi]) {
int left = min(posi, pos[multi]);
int right = max(posi, 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 maxn = 262144;
int s[maxn * 2];
int n, q;
int pos[maxn];
int l[maxn], r[maxn];
int ans[maxn];
vector<int> A[maxn], B[maxn];
void add(int seg, int ls, int rs, int ind) {
if (rs <= ind or ind < ls) return;
if (ls == rs - 1) {
s[seg]++;
return;
}
int mid = (ls + rs) >> 1;
add(seg * 2 + 1, ls, mid, ind);
add(seg * 2 + 2, mid, rs, ind);
s[seg]++;
}
int sum(int seg, int ls, int rs, int ind) {
if (ind < ls) return 0;
if (rs <= ind + 1) return s[seg];
int mid = (ls + rs) >> 1;
return sum(seg * 2 + 1, ls, mid, ind) + sum(seg * 2 + 2, mid, rs, ind);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d", &n, &q);
for (int x, i = 0; i < n; i++) {
scanf("%d", &x);
pos[x] = i;
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
A[min(pos[i], pos[j])].push_back(max(pos[i], pos[j]));
for (int i = 0; i < q; i++) {
scanf("%d%d", l + i, r + i);
l[i]--, r[i]--;
B[l[i]].push_back(i);
}
for (int i = n; i--;) {
for (int j = 0; j < A[i].size(); j++) add(0, 0, n, A[i][j]);
for (int j = 0; j < B[i].size(); j++)
ans[B[i][j]] += sum(0, 0, n, r[B[i][j]]);
}
for (int i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 1;
int n, m;
int p[N];
int h[N];
int fen[N];
pair<pair<int, int>, int> q[N];
int ans[N];
vector<pair<int, int> > pnt;
void add(int p, int val) {
for (p++; p < N; p += p & (-p)) fen[p] += val;
}
int get(int p) {
int sum = 0;
for (; p > 0; p -= p & (-p)) sum += fen[p];
return sum;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> p[i];
h[p[i]] = i;
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
pnt.push_back(make_pair(min(h[i], h[j]), max(h[i], h[j])));
add(max(h[i], h[j]), 1);
}
}
sort(pnt.begin(), pnt.end());
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
l--;
q[i].first.first = l;
q[i].first.second = r;
q[i].second = i;
}
sort(q, q + m);
int t = 0;
for (int i = 0; i < m; ++i) {
while (t < ((int)pnt.size()) && pnt[t].first < q[i].first.first) {
add(pnt[t].second, -1);
t++;
}
ans[q[i].second] = get(q[i].first.second);
}
for (int i = 0; i < m; ++i) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 2e5 + 4;
int n, m, p[N], idx[N];
vector<int> vals[N];
LL v1[N], v2[N], v3[N], ps[N];
struct Q {
int id, l, r;
Q() = default;
Q(int _id, int _l, int _r) : id(_id), l(_l), r(_r) {}
} qs[N];
bool cmp1(const Q &lhs, const Q &rhs) { return lhs.l < rhs.l; }
bool cmp2(const Q &lhs, const Q &rhs) { return lhs.r > rhs.r; }
struct BIT {
LL s[N];
void init() { memset(s, 0, sizeof(s)); }
void build() {
for (int i = 1; i <= n; i++) s[i] = ps[i] - ps[i - (i & (-i))];
}
void add(int i, int v) {
for (; i <= n; i += i & (-i)) s[i] += v;
}
LL get(int i) {
LL sum = 0;
for (; i; i -= i & (-i)) sum += s[i];
return sum;
}
} bit;
int main() {
scanf("%d%d", &n, &m);
bit.init();
for (int i = 1; i <= n; i++) {
scanf("%d", p + i);
idx[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (!idx[i]) continue;
for (int j = i; j <= n; j += i) {
if (idx[j]) {
vals[idx[j]].push_back(idx[i]);
ps[idx[i]]++;
}
}
}
for (int i = 1; i <= n; i++) ps[i] = ps[i] + ps[i - 1];
bit.build();
for (int i = 1; i <= m; i++) {
scanf("%d%d", &qs[i].l, &qs[i].r);
qs[i].id = i;
v1[i] = ps[qs[i].r] - ps[qs[i].l - 1];
}
memcpy(ps, bit.s, sizeof(ps));
sort(qs + 1, qs + m + 1, cmp1);
for (int i = 1, j = 1; i <= m; i++) {
for (; j < qs[i].l; j++) {
for (int v : vals[j]) bit.add(v, -1);
}
v2[qs[i].id] = bit.get(qs[i].r) - bit.get(qs[i].l - 1);
}
memcpy(bit.s, ps, sizeof(ps));
sort(qs + 1, qs + m + 1, cmp2);
for (int i = 1, j = n; i <= m; i++) {
for (; j > qs[i].r; j--) {
for (int v : vals[j]) bit.add(v, -1);
}
v3[qs[i].id] = bit.get(qs[i].r) - bit.get(qs[i].l - 1);
}
for (int i = 1; i <= m; i++) printf("%lld\n", v3[i] - (v1[i] - v2[i]));
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
struct Ques {
int l, r, id;
};
int n, m, num;
int a[N], b[N], bit[N];
pair<int, int> c[N * 20];
Ques q[N];
int ans[N];
int cmp1(pair<int, int> a, pair<int, int> b) { return a.second < b.second; }
int cmp2(Ques a, Ques b) { return a.r < b.r; }
void C(int i, int d) {
for (; i <= n; i += i & -i) bit[i] += d;
}
int Q(int i) {
int res = 0;
for (; i; i -= i & -i) res += bit[i];
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) b[a[i]] = i;
for (int i = 1; i <= n; i++)
if (b[i])
for (int j = i; j <= n; j += i)
if (b[j]) {
c[++num] = make_pair(min(b[i], b[j]), max(b[i], b[j]));
}
sort(c + 1, c + 1 + num, cmp1);
for (int i = 1; i <= m; i++) scanf("%d%d", &q[i].l, &q[i].r), q[i].id = i;
sort(q + 1, q + 1 + m, cmp2);
for (int i = 1, j = 1; i <= m; i++) {
while (j <= num && c[j].second <= q[i].r) {
C(1, 1);
C(c[j].first + 1, -1);
j++;
}
ans[q[i].id] = Q(q[i].l);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Task {
int p, id;
};
struct Tdata {
int x, y;
};
vector<Task> ask[200010];
vector<Tdata> v[200010];
int n, m, a[200010], pos[200010], ans[200010], tr[200010];
int getint() {
int x, f = 1;
char ch;
while (!isdigit(ch = getchar())) f = ch == '-' ? -1 : 1;
x = ch - '0';
while (isdigit(ch = getchar())) x = x * 10 + ch - '0';
return x * f;
}
void add(int p, int v) {
for (int i = p; i <= n; i += ((i) & (-(i)))) tr[i] += v;
}
int query(int p) {
int ans = 0;
for (int i = p; i >= 1; i -= ((i) & (-(i)))) ans += tr[i];
return ans;
}
int main() {
(n = getint()), (m = getint());
for (int i = 1; i <= n; i++) pos[(a[i] = getint())] = i;
for (int i = 1; i <= m; i++) {
int l = getint(), r = getint();
ask[r].push_back((Task){l, 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);
v[y].push_back((Tdata){x, y});
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= (int)v[i].size() - 1; j++) add(v[i][j].x, 1);
for (int j = 0; j <= (int)ask[i].size() - 1; j++)
ans[ask[i][j].id] = query(n) - query(ask[i][j].p - 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
int n, t;
int a[N];
vector<int> p[N], couple[N];
vector<pair<int, int> > q[N];
int f[N];
int res[N];
void update(int x) {
for (; x; x -= x & -x) ++f[x];
}
int get(int x) {
int res = 0;
for (; x < N; x += x & -x) res += f[x];
return res;
}
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> t;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= t; ++i) {
int l, r;
cin >> l >> r;
q[r].push_back({l, i});
}
for (int i = 1; i <= N - 1; ++i) {
couple[i].push_back(i);
for (int j = i + i; j < N; j += i)
couple[i].push_back(j), couple[j].push_back(i);
}
for (int i = 1; i <= n; ++i) {
p[a[i]].push_back(i);
for (int val : couple[a[i]]) {
for (int j : p[val]) update(j);
}
for (pair<int, int> T : q[i]) res[T.second] = get(T.first);
}
for (int i = 1; i <= t; ++i) cout << res[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> link[200007];
int a[200007], b[200007];
int p[200007], f[200007 << 1];
struct Query {
int l, r, id;
} q[200007];
int ans[200007];
bool C(Query p, Query q) { return p.l < q.l; }
struct Tree {
int l, r, ls, rs;
int cnt;
} tree[200007 << 1];
int tot;
void buildtree(int l, int r) {
int t = ++tot;
tree[t].l = l, tree[t].r = r;
tree[t].ls = tree[t].rs = 0;
if (l == r) {
p[l] = t;
tree[t].cnt = 0;
return;
}
int mid = (l + r) >> 1;
if (l <= mid) {
f[1 + tot] = t;
tree[t].ls = 1 + tot;
buildtree(l, mid);
}
++mid;
if (mid <= r) {
f[1 + tot] = t;
tree[t].rs = 1 + tot;
buildtree(mid, r);
}
}
void update(int t) {
t = p[t];
++tree[t].cnt;
while (f[t] > 0) {
t = f[t];
tree[t].cnt = tree[tree[t].ls].cnt + tree[tree[t].rs].cnt;
}
}
int query(int t, int l, int r) {
if (t <= 0) return 0;
if (l == tree[t].l && r == tree[t].r) return tree[t].cnt;
int mid = (tree[t].l + tree[t].r) >> 1;
if (r <= mid) return query(tree[t].ls, l, r);
if (l > mid) return query(tree[t].rs, l, r);
return query(tree[t].ls, l, mid) + query(tree[t].rs, mid + 1, r);
}
int main() {
int n, m;
int i, j, k, x, l, r;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
b[a[i]] = i;
}
for (i = 1; i <= n; ++i) {
x = a[i] << 1;
while (x <= n) {
l = min(i, b[x]), r = max(i, b[x]);
link[l].push_back(r);
x += a[i];
}
}
for (i = 0; i < m; ++i) {
q[i].id = i;
scanf("%d%d", &q[i].l, &q[i].r);
}
sort(q, q + m, C);
tot = 0, buildtree(1, n);
k = n;
for (i = m - 1; i >= 0; --i) {
while (q[i].l <= k) {
for (j = 0; j < (int)link[k].size(); ++j) {
update(link[k][j]);
}
--k;
}
ans[q[i].id] = (q[i].r - q[i].l + 1) + query(1, q[i].l, q[i].r);
}
for (i = 0; i < m; ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
vector<pair<int, int> > q[maxN];
vector<int> d[maxN];
int pos[maxN], a[maxN], res[maxN], n, m;
int data[4 * maxN];
void add(int p, int x, int s = 0, int e = n, int id = 1) {
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 = 0, int e = n, int id = 1) {
if (e <= l || 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);
}
int32_t main() {
scanf("%d %d", &n, &m);
for (int i = 0; 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)
if (pos[i] < pos[j])
d[j].push_back(i);
else
d[i].push_back(j);
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d %d", &l, &r);
l--, r--;
q[r].push_back(make_pair(i, l));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < d[a[i]].size(); j++) {
int cur = d[a[i]][j];
int p = pos[cur];
add(p, 1);
}
for (int j = 0; j < q[i].size(); j++) {
int idx = q[i][j].first;
int l = q[i][j].second;
int r = i;
res[idx] = get(l, r + 1);
}
}
for (int i = 0; i < m; i++) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct data {
int l, r, id;
data(){};
data(int a, int b, int c) { l = a, r = b, id = c; }
bool operator<(const data &p) const { return l < p.l; }
};
int n, m, ps[200002 + 5], ar[200002 + 5];
int ans[200002 + 5], BIT[200002 + 5];
vector<data> v;
void add(int p, int v) {
for (int i = p; i <= n; i += (i & -i)) BIT[i] += v;
}
int read(int p) {
int ret = 0;
for (int i = p; i > 0; i -= (i & -i)) ret += BIT[i];
return ret;
}
void ChkDivisors(int x, int p) {
int sq = sqrt(x);
for (int i = 1; i <= sq; i++) {
if (x % i == 0) {
if (ps[i] >= p) add(ps[i], 1);
if (i * i != x) {
if (ps[x / i] >= p) add(ps[x / i], 1);
}
}
}
}
void ChkDivisibles(int x, int p) {
for (int i = x + x; i <= n; i += x) {
if (ps[i] >= p) add(ps[i], 1);
}
}
int main() {
int i, j, k, x, y;
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> ar[i];
ps[ar[i]] = i;
}
for (i = 1; i <= m; i++) {
cin >> x >> y;
v.push_back(data(x, y, i));
}
sort(v.begin(), v.end());
j = n;
for (i = m - 1; i >= 0; i--) {
while (j >= v[i].l) {
ChkDivisors(ar[j], j);
ChkDivisibles(ar[j], j);
j--;
}
ans[v[i].id] = read(v[i].r) - read(v[i].l - 1);
}
for (i = 1; i <= m; i++) {
cout << ans[i] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
long long a, cn, b, cnn = 1, c, ans[200007], T[200007 * 2], d[200007], n, m;
vector<long long> rr[200007];
vector<long long> q[200007];
vector<pair<int, int> > rt[200007];
void upd(long long x) {
for (; x; x -= (long long)(-x & x)) T[x]++;
}
long long tek(long long x) {
if (x == 0) return 0;
long long sum = 0;
for (; x <= n; x += (long long)(-x & x)) sum += T[x];
return sum;
}
long long bul(long long x, long long y) { return tek(x) - tek(y + 1); }
int main() {
scanf("%lld%lld", &n, &m);
for (long long i = 1; i <= n; i++)
scanf("%lld", d + i), rr[d[i]].push_back(i);
for (long long i = 1; i <= n; i++) {
for (long long j = d[i]; j <= n; j += d[i])
for (long long h : rr[j]) q[max(i, h)].push_back(min(i, h));
}
for (long long i = 1; i <= m; i++) {
scanf("%lld%lld", &a, &b);
rt[b].push_back({a, i});
}
for (long long i = 1; i <= n; i++) {
for (int h : q[i]) upd(h);
for (pair<long long, long long> h : rt[i]) ans[h.second] = bul(h.first, i);
}
for (long long i = 1; i <= m; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 200000 + 10;
int n, arr[nax], fen[nax], pos[nax];
vector<pair<int, pair<int, int> > > queries;
void add(int idx, int val) {
while (idx <= n) fen[idx] += val, idx += (idx & -idx);
}
int sum(int idx) {
int res = 0;
while (idx) res += fen[idx], idx -= (idx & -idx);
return res;
}
int m;
int ans[nax];
bool cmp(pair<int, pair<int, int> > p1, pair<int, pair<int, int> > p2) {
if (p1.first == p2.first) return p1.second.second <= p2.second.second;
return p1.first < p2.first;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]), pos[arr[i]] = i;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int posl = pos[i], posr = pos[j];
if (posl > posr) swap(posl, posr);
queries.push_back({posr, {-1, posl}});
}
}
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d %d", &l, &r);
queries.push_back({r, {i, l}});
}
sort(queries.begin(), queries.end());
long long int curans = 0;
for (auto x : queries) {
int l = x.second.second, idx = x.second.first;
if (idx != -1) {
ans[idx] = curans - sum(l - 1);
continue;
}
curans++;
add(l, 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 * 1000 + 85;
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;
template <class T>
inline void sc(T &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c<48 | c> 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
template <class T>
inline T bigmod(T p, T e, T M) {
long long 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);
}
const int N = 2e5 + 5;
vector<int> L[N];
vector<pair<int, int> > V;
vector<pair<int, int> > Q[N];
long long A[N];
long long bit[N];
int n;
int pos[N];
long long ans[N];
void update(int x, int val) {
while (x > 0) {
bit[x] += val;
x -= x & -x;
}
}
long long query(int x) {
long long res = 0;
while (x <= n) {
res += bit[x];
x += x & -x;
}
return res;
}
int main() {
sc(n);
int m;
sc(m);
for (int i = (1); i < (n + 1); i++) {
sc(A[i]);
pos[A[i]] = i;
}
for (int i = 1; i <= n; i++) {
int a = A[i];
for (int b = a; b <= n; b += a) {
int pp = pos[b];
L[((i) > (pp) ? (i) : (pp))].push_back((((i) > (pp) ? (pp) : (i))));
V.push_back((make_pair(i, pp)));
}
}
for (int i = 0; i < m; i++) {
int l, r;
sc(l);
sc(r);
Q[r].push_back((make_pair(l, i)));
}
for (int i = 1; i <= n; i++) {
for (auto a : L[i]) update(a, 1);
for (auto a : Q[i]) {
int l = a.first;
int iv = a.second;
ans[iv] = query(l);
}
}
for (int i = 0; i < m; i++) printf("%lld\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> t;
void inc(int i) {
for (; i <= n; i = (i | (i + 1))) ++t[i];
}
int sum(int i) {
int ot = 0;
for (; i >= 0; i = ((i) & (i + 1)) - 1) ot += t[i];
return ot;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int haha = 0;
cin >> n >> m;
t.resize(n, 0);
vector<int> hoho(n, 0);
vector<vector<int> > mem(n);
int a[n], pos[n + 1];
for (int i = 0; i < n; ++i) {
cin >> a[i];
pos[a[i]] = i;
}
pair<pair<int, int>, int> q[m];
for (int i = 0; i < m; ++i) {
cin >> q[i].first.second >> q[i].first.first;
q[i].second = i;
--q[i].first.first;
--q[i].first.second;
}
vector<int> ot(m);
sort(q, q + m);
int now = 0;
for (int i = 0; i < n && now < m; ++i) {
for (int d = 1; d <= sqrt(a[i]); ++d) {
if (a[i] % d) continue;
if (pos[a[i]] >= pos[d]) {
++hoho[i];
mem[i].push_back(pos[d]);
} else {
++hoho[pos[d]];
mem[pos[d]].push_back(i);
}
if (d * d == a[i]) continue;
if (pos[a[i]] > pos[a[i] / d]) {
++hoho[i];
mem[i].push_back(pos[a[i] / d]);
} else {
++hoho[pos[a[i] / d]];
mem[pos[a[i] / d]].push_back(i);
}
}
haha += hoho[i];
for (auto kek : mem[i]) inc(kek);
while (i == q[now].first.first && now < m) {
int z38 = haha;
if (q[now].first.second) z38 -= sum(q[now].first.second - 1);
ot[q[now].second] = z38;
++now;
}
}
for (int i = 0; i < m; ++i) cout << ot[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 5;
vector<int> lazy[MAX];
vector<pair<int, int> > queries[MAX];
int bit[MAX], pos[MAX], arr[MAX], ans[MAX];
int n, m;
void update(int idx, int val) {
while (idx < MAX) {
bit[idx] += val;
idx += idx & -idx;
}
}
int query(int idx) {
int sum = 0;
while (idx) {
sum += bit[idx];
idx -= idx & -idx;
}
return sum;
}
int query(int a, int b) { return query(b) - query(a - 1); }
int main() {
scanf("%d %d", &n, &m);
for (int i = int(1); i < int(n + 1); i++) {
scanf("%d", arr + i);
pos[arr[i]] = i;
}
for (int i = int(1); i < int(m + 1); i++) {
int l, r;
scanf("%d %d", &l, &r);
queries[r].emplace_back(l, i);
}
for (int i = int(1); i < int(n + 1); i++) {
for (auto &each : lazy[i]) {
update(each, 1);
}
for (int j = arr[i]; j <= n; j += arr[i]) {
if (pos[j] <= i) {
update(pos[j], 1);
} else {
lazy[pos[j]].push_back(i);
}
}
for (auto &each : queries[i]) {
int l, idx;
tie(l, idx) = each;
ans[idx] = query(l, i);
}
}
for (int i = int(1); i < int(m + 1); i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 200 * 1000 + 9;
const bool QRY = 0;
const bool UPD = 1;
struct Data {
int l, r, id;
Data() : l(0), r(0){};
Data(int _l, int _r) : l(_l), r(_r){};
} a[MAX_N];
int n, m, N;
int p[MAX_N], idx[MAX_N];
int fwt[MAX_N], ans[MAX_N];
pair<int, int> divP[3600 * 1000 + 9];
void treeUpdate(int idx, int val) {
for (; idx <= n; idx += (idx & -idx)) fwt[idx] += val;
}
int sum(int idx) {
int total = 0;
for (; idx > 0; idx -= (idx & -idx)) total += fwt[idx];
return total;
}
int treeSum(int l, int r) { return sum(r) - sum(l - 1); }
bool cmp(const Data &lhs, const Data &rhs) { return lhs.r < rhs.r; }
bool dCmp(const pair<int, int> &lhs, const pair<int, int> &rhs) {
return lhs.second < rhs.second;
}
void gen() {
for (int i = 1; i <= n; i++) {
for (int pj = p[i]; pj <= n; pj += p[i]) {
int j = idx[pj];
divP[N++] = (i < j) ? make_pair(i, j) : make_pair(j, i);
}
}
}
void readInput() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> p[i];
idx[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
cin >> a[i].l >> a[i].r;
a[i].id = i;
}
}
void solve() {
gen();
sort(a + 1, a + m + 1, cmp);
sort(divP, divP + N, dCmp);
int j = 0;
for (int i = 1; i <= m; i++) {
while (j < N && divP[j].second <= a[i].r) {
treeUpdate(divP[j].first, 1);
j++;
}
ans[a[i].id] = treeSum(a[i].l, a[i].r);
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
readInput();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 2e5 + 4;
int n, m, p[N], idx[N];
LL v1[N], v2[N];
vector<int> vals[N];
struct BIT {
int s[N];
void init() { memset(s, 0, sizeof(s)); }
void add(int i, int v) {
for (; i <= n; i += i & (-i)) s[i] += v;
}
LL get(int i) {
LL sum = 0;
for (; i; i -= i & (-i)) sum += s[i];
return sum;
}
} bit;
struct E {
int id, wh, v;
E() = default;
E(int _id, int _wh, int _v) : id(_id), wh(_wh), v(_v) {}
bool operator<(const E &rhs) const { return wh < rhs.wh; }
};
struct Q {
int l, r;
} qs[N];
vector<E> events;
int main() {
bit.init();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", p + i);
idx[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
if (!idx[i]) continue;
int ii = idx[i];
for (int j = i; j <= n; j += i) {
if (int ij = idx[j]) vals[ij].push_back(ii);
}
}
events.reserve(2 * m);
for (int i = 1; i <= m; i++) {
int l, r;
scanf("%d%d", &l, &r);
if (l > 1) events.emplace_back(i, l - 1, 1);
if (r <= n) events.emplace_back(i, r, 2);
qs[i].l = l;
qs[i].r = r;
}
sort(events.begin(), events.end());
for (int i = 1, j = 0, es = events.size(); i <= n && j < es; i++) {
for (int v : vals[i]) bit.add(v, 1);
for (; j < es && events[j].wh == i; j++) {
if (events[j].v == 1)
v1[events[j].id] =
bit.get(qs[events[j].id].r) - bit.get(qs[events[j].id].l - 1);
else
v2[events[j].id] =
bit.get(qs[events[j].id].r) - bit.get(qs[events[j].id].l - 1);
}
}
for (int i = 1; i <= m; i++) {
printf("%lld\n", v2[i] - v1[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const static int inf = 0x3f3f3f3f;
const static int maxn = 2e5 + 10;
int n, m;
int a[maxn];
vector<int> ll[maxn];
vector<int> rr[maxn];
int l[maxn], r[maxn];
int p[maxn];
int tree[maxn];
int lowbit(int x) { return x & (-x); }
void add(int x) {
for (int i = x; i <= n; i += lowbit(i)) tree[i]++;
}
int query(int x) {
int ret = 0;
for (int i = x; i >= 1; i -= lowbit(i)) ret += tree[i];
return ret;
}
int ans[maxn];
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &l[i], &r[i]);
ll[l[i]].push_back(i);
rr[r[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < ll[i].size(); j++)
ans[ll[i][j]] -= query(r[ll[i][j]]) - query(i - 1);
for (int j = 1; j * a[i] <= n; j++) add(p[a[i] * j]);
for (int j = 0; j < rr[i].size(); j++)
ans[rr[i][j]] += query(i) - query(l[rr[i][j]] - 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Flandre_Scarlet {
struct node {
int l, r, id;
} q[255555];
bool operator<(node a, node b) { return a.l > b.l; }
int n, m;
int a[255555];
void R1(int &x) {
x = 0;
char c = getchar();
int f = 1;
while (c < '0' or c > '9') f = (c == '-') ? -1 : 1, c = getchar();
while (c >= '0' and c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
x = (f == 1) ? x : -x;
}
void Input() {
R1(n), R1(m);
for (int i = 1; i <= n; ++i) R1(a[i]);
for (int i = 1; i <= m; ++i) {
int l, r;
R1(l), R1(r);
if (l > r) swap(l, r);
q[i] = (node){l, r, i};
}
}
int pos[255555];
int ans[255555];
vector<int> mul[255555];
void initmul() {
for (int i = 1; i <= n; ++i) pos[a[i]] = i;
for (int i = 1; i <= n; ++i) {
for (int num = a[i]; num <= n; num += a[i]) {
if (pos[num] >= i) {
mul[i].push_back(pos[num]);
} else {
mul[pos[num]].push_back(i);
}
}
}
}
class BIT {
public:
int tree[255555];
int len;
void BuildTree(int _len) {
len = _len;
memset(tree, 0, sizeof(tree));
}
void Add(int pos, int val = 1) {
for (int i = pos; i <= len; i += (i & (-i))) {
tree[i] += val;
}
}
int Query(int pos) {
int ans = 0;
for (int i = pos; i > 0; i -= (i & (-i))) {
ans += tree[i];
}
return ans;
}
} T;
void Soviet() {
initmul();
sort(q + 1, q + m + 1);
T.BuildTree(n);
int Max = n + 1;
for (int i = 1; i <= m; ++i) {
for (int j = q[i].l; j <= Max - 1; ++j) {
for (int k = 0; k <= (int)mul[j].size() - 1; ++k) {
T.Add(mul[j][k], 1);
}
}
ans[q[i].id] = T.Query(q[i].r);
Max = q[i].l;
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
}
void IsMyWife() {
Input();
Soviet();
}
} // namespace Flandre_Scarlet
int main() {
Flandre_Scarlet::IsMyWife();
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int MAX = 1e9 + 5;
long long ans[N], ST[N * 5], n, m, i, j, k, x, y, t, where[N], h[N], a[N];
vector<long long> v[N];
vector<pair<long long, long long> > Q[N];
long long init(int k, int bas, int son) {
if (bas == son) return ST[k] = h[bas];
int orta = bas + son >> 1;
return ST[k] = init(2 * k, bas, orta) + init(2 * k + 1, orta + 1, son);
}
long long update(int k, int bas, int son, int x) {
if (bas > x || son < x) return ST[k];
if (bas == son) return --ST[k];
int orta = bas + son >> 1;
return ST[k] =
update(2 * k, bas, orta, x) + update(2 * k + 1, orta + 1, son, x);
}
long long query(int k, int bas, int son, int x, int y) {
if (bas > y || son < x) return 0;
if (x <= bas && son <= y) return ST[k];
int orta = bas + son >> 1;
return query(2 * k, bas, orta, x, y) + query(2 * k + 1, orta + 1, son, x, y);
}
int main() {
scanf("%lld %lld", &n, &m);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
where[a[i]] = i;
}
for (long long i = 1; i <= n; i++)
for (int j = i; j <= n; j += i) {
int index1 = where[i];
int index2 = where[j];
if (index1 > index2) swap(index1, index2);
v[index1].push_back(index2);
h[index2]++;
}
for (long long i = 1; i <= m; i++) {
scanf("%lld %lld", &x, &y);
Q[x].push_back(make_pair(y, i));
}
init(1, 1, n);
int index = 1;
for (long long i = 1; i <= n; i++) {
for (__typeof(Q[i].begin()) it = Q[i].begin(); it != Q[i].end(); it++)
ans[it->second] = query(1, 1, n, i, it->first);
for (__typeof(v[i].begin()) it = v[i].begin(); it != v[i].end(); it++)
update(1, 1, n, *it);
}
for (long long i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200010], t[200010], pos[200010], ans[200010];
struct point {
int pos, v, f;
point(int pos, int v, int f) : pos(pos), v(v), f(f) {}
};
vector<point> v[200010];
inline void insert(int x) {
for (register int i = x; i <= n; i += i & -i) t[i]++;
}
inline int find(int x) {
register int ans = 0;
for (register int i = x; i; i -= i & -i) ans += t[i];
return ans;
}
inline void add(int x, int y, int f, int i) { v[x].push_back(point(i, y, f)); }
inline int read() {
register int x = 0, ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
int main() {
n = read(), m = read();
for (register int i = 1; i <= n; i++) pos[a[i] = read()] = i;
for (register int i = 1; i <= m; i++) {
int l = read(), r = read();
add(r, r, 1, i), add(l - 1, r, -1, i), add(r, l - 1, -1, i),
add(l - 1, l - 1, 1, i);
}
for (register int i = 1; i <= n; i++) {
for (register int j = a[i]; j <= n; j += a[i]) insert(pos[j]);
for (register int j = 0; j < v[i].size(); j++)
ans[v[i][j].pos] += find(v[i][j].v) * v[i][j].f;
}
for (register 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;
int ans[maxn], a[maxn], tree[maxn], pos[maxn];
vector<int> v[maxn];
pair<pair<int, int>, int> sg[maxn];
void addToSegs(int fi, int se) {
if (fi > se) return addToSegs(se, fi);
v[fi].push_back(se);
}
void add(int idx) {
while (idx <= 200000) {
tree[idx]++;
idx += idx & (-idx);
}
}
int get(int idx) {
int ret = 0;
while (idx > 0) {
ret += tree[idx];
idx -= idx & (-idx);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pos[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
cin >> sg[i].first.first >> sg[i].first.second;
sg[i].second = i;
}
sort(sg + 1, sg + m + 1);
for (int i = 1; i <= n; i++)
for (int j = 1; j * i <= n; j++) addToSegs(pos[i], pos[i * j]);
int now = n;
for (int i = m; i >= 1; i--) {
while (now >= 1 and sg[i].first.first <= now) {
for (int j = 0; j < v[now].size(); j++) add(v[now][j]);
now--;
}
ans[sg[i].second] = get(sg[i].first.second);
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
}
|
#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 j = 1; j < n + 1; j++)
for (int i = 2 * j; i <= n; i += j) add(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 = 200 * 1000 + 9;
const bool QRY = 0;
const bool UPD = 1;
struct Data {
int l, r, id;
Data() : l(0), r(0){};
Data(int _l, int _r) : l(_l), r(_r){};
} a[MAX_N];
int n, m, N;
int p[MAX_N], idx[MAX_N];
long long fwt[MAX_N], ans[MAX_N];
vector<pair<long long, long long> > divP;
void treeUpdate(int idx, long long val) {
for (; idx <= n; idx += (idx & -idx)) fwt[idx] += val;
}
long long sum(int idx) {
long long total = 0;
for (; idx > 0; idx -= (idx & -idx)) total += fwt[idx];
return total;
}
long long treeSum(int l, int r) { return sum(r) - sum(l - 1); }
bool cmp(const Data &lhs, const Data &rhs) { return lhs.r < rhs.r; }
bool dCmp(const pair<long long, long long> &lhs,
const pair<long long, long long> &rhs) {
return lhs.second < rhs.second;
}
void gen() {
for (int i = 1; i <= n; i++) {
for (int pj = p[i]; pj <= n; pj += p[i]) {
int j = idx[pj];
divP.push_back(make_pair(i, j));
if (divP.back().first > divP.back().second)
swap(divP.back().first, divP.back().second);
}
}
}
void readInput() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> p[i];
idx[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
cin >> a[i].l >> a[i].r;
a[i].id = i;
}
}
void solve() {
gen();
sort(a + 1, a + m + 1, cmp);
sort(divP.begin(), divP.end(), dCmp);
N = divP.size();
int j = 0;
for (int i = 1; i <= m; i++) {
while (j < N && divP[j].second <= a[i].r) {
treeUpdate(divP[j].first, 1);
j++;
}
ans[a[i].id] = treeSum(a[i].l, a[i].r);
}
for (int i = 1; i <= m; i++) cout << ans[i] << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
readInput();
solve();
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) {
assert(pos <= se);
assert(pos >= ss);
if (ss == se) {
assert(ss == pos);
st[si]++;
} else {
int mid = (ss + se) / 2;
if (pos <= mid)
st_upd(si * 2, ss, mid, pos);
else
st_upd(si * 2 + 1, mid + 1, se, pos);
st[si] = st[si * 2] + st[si * 2 + 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;
void assignStdin() {
cin.sync_with_stdio(false);
cin.tie(nullptr);
}
bool isDebug() { return false; }
const int MAXN = 200008;
int idx[MAXN], data[MAXN], n, m, ql[MAXN], qr[MAXN], rs[MAXN];
vector<int> assoDivisor[MAXN], queries[MAXN], tree(MAXN);
int query(vector<int> &tree, int idx) {
int rs = 0;
for (int i = idx; i > 0; i -= i & -i) {
rs += tree[i];
}
return rs;
}
void updateTree(vector<int> &tree, int idx, int value) {
for (int i = idx; i < tree.size(); i += i & -i) {
tree[i] += value;
}
}
int main(int argc, char *argv[]) {
assignStdin();
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> data[i];
idx[data[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
if (idx[i] != 0 && idx[j] != 0) {
assoDivisor[min(idx[i], idx[j])].push_back(max(idx[i], idx[j]));
}
}
}
for (int i = 1; i <= m; i++) {
cin >> ql[i] >> qr[i];
queries[ql[i]].push_back(i);
}
for (int i = n; i >= 1; i--) {
for (int assoIdx : assoDivisor[i]) {
updateTree(tree, assoIdx, 1);
}
if (isDebug()) {
for (int j = 1; j <= n; j++) {
cout << tree[j] << " ";
}
cout << endl;
}
for (int qIdx : queries[i]) {
rs[qIdx] = query(tree, qr[qIdx]);
}
}
for (int i = 1; i <= m; i++) {
cout << rs[i] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void __read(T &a) {
cin >> a;
}
template <typename T, typename... Args>
void __read(T &a, Args &...args) {
cin >> a;
__read(args...);
}
constexpr long long M7 = 1000000007ll;
constexpr long long M9 = 1000000009ll;
constexpr long long MFFT = 998244353ll;
template <class T>
void outv(T &a) {
for (auto &x : a) cout << x << ' ';
}
static mt19937 rnd(static_cast<unsigned>(
chrono::steady_clock::now().time_since_epoch().count()));
auto __fast_io__ = (ios_base::sync_with_stdio(false), cin.tie(nullptr));
void incVal(long long i, vector<long long> &ft) {
for (; i < ft.size(); i |= (i + 1)) {
ft[i]++;
}
}
long long getSum(long long i, vector<long long> &ft) {
long long res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) {
res += ft[i];
}
return res;
}
long long getSum(long long l, long long r, vector<long long> &ft) {
return getSum(r, ft) - getSum(l - 1, ft);
}
int32_t main() {
long long n, q;
__read(n, q);
vector<long long> pos(n + 1);
for (long long i = 0; i < n; ++i) {
long long q;
__read(q);
pos[q] = i;
}
vector<vector<long long>> ind(n);
for (long long i = 1; i <= n; ++i) {
for (long long j = i; j <= n; j += i) {
ind[max(pos[i], pos[j])].push_back(min(pos[i], pos[j]));
}
}
vector<vector<pair<long long, long long>>> qw(n);
for (long long i = 0; i < q; ++i) {
long long l, r;
__read(l, r);
l--, r--;
qw[r].emplace_back(l, i);
}
vector<long long> ans(q), ft(n);
for (long long r = 0; r < n; ++r) {
for (long long l : ind[r]) {
incVal(l, ft);
}
for (auto &[l, i] : qw[r]) {
ans[i] = getSum(l, r, ft);
}
}
for (auto &val : ans) {
cout << val << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct query {
int l, r, id;
} Q[201010];
int n, m, v[201010], f[201010];
long long bit[201010], answer[201010];
vector<int> d[201010];
void calc(int x) {
for (int i = 1; i * 1LL * i <= x; i++) {
if (x % i) continue;
if (i * 1LL * i != x) d[x].push_back(x / i);
d[x].push_back(i);
}
}
void update(int pos, int val) {
for (; pos <= n; pos += pos & (-pos)) bit[pos] += val;
}
long long sum(int pos) {
long long s = 0;
for (; pos; pos -= pos & (-pos)) s += bit[pos];
return s;
}
void add(int x, int p) {
f[x] = p;
for (int a : d[x]) {
if (f[a]) update(f[a], 1);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &v[i]);
calc(v[i]);
}
for (int i = 0; i < m; i++) {
Q[i].id = i;
scanf("%d %d", &Q[i].l, &Q[i].r);
answer[i] = -(Q[i].r - Q[i].l + 1);
}
sort(Q, Q + m, [](query a, query b) { return a.r < b.r; });
int p = 1;
for (int i = 0; i < m; i++) {
while (p <= Q[i].r) add(v[p], p), p++;
answer[Q[i].id] += sum(Q[i].r) - sum(Q[i].l - 1);
}
sort(Q, Q + m, [](query a, query b) { return a.l > b.l; });
memset(f, 0, sizeof f);
memset(bit, 0, sizeof bit);
p = n;
for (int i = 0; i < m; i++) {
while (p >= Q[i].l) add(v[p], p), p--;
answer[Q[i].id] += sum(Q[i].r) - sum(Q[i].l - 1);
}
for (int i = 0; i < m; i++) printf("%lld\n", answer[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int BS = 5;
int n, m;
int a[N];
int p[N], ps[N];
int l[N], r[N];
int idx[N];
long long ans[N];
long long u[N];
vector<pair<int, int> > v;
int cmp(int a, int b) { return l[a] < l[b] || l[a] == l[b] && r[a] < r[b]; }
void modify(int x, long long v) {
for (x += BS; x < N; x += x & -x) u[x] += v;
}
long long getsum(int x) {
long long s = 0;
for (x += BS; x; x -= x & -x) s += u[x];
return s;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", p + i);
ps[p[i]] = i;
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
int x = ps[i], y = ps[j];
if (x > y) swap(x, y);
v.push_back(make_pair(x, y));
a[y]++;
}
}
sort(v.begin(), v.end());
for (int i = 1; i <= n; ++i) {
modify(i, a[i]);
}
for (int i = 0; i < m; ++i) {
scanf("%d%d", l + i, r + i);
}
for (int i = 0; i < m; ++i) {
idx[i] = i;
}
sort(idx, idx + m, cmp);
int j = 0;
for (int i = 0; i < m; ++i) {
int ii = idx[i];
for (; j < v.size(); ++j) {
if (v[j].first < l[ii]) {
modify(v[j].second, -1);
} else {
break;
}
}
ans[ii] = getsum(r[ii]);
}
for (int i = 0; i < m; ++i) {
printf("%lld\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int p[400000 + 5], ink[400000 + 5];
vector<pair<int, int> > E;
struct query {
int l, r, idx;
query(int _l, int _r, int _idx) {
l = _l;
r = _r;
idx = _idx;
}
bool operator<(const query &T) const { return l < T.l; }
};
int ans[400000 + 5];
vector<query> Q;
struct TA {
int a[400000 + 5];
int n;
void Init(int n) {
this->n = n;
memset(a, 0, sizeof(int) * n);
}
void add(int p, int x) {
for (p; p <= n; p += p & -p) a[p] += x;
}
int get(int pos) {
pos = min(pos, n);
int r = 0;
for (; pos; pos -= pos & -pos) r += a[pos];
return r;
}
} ta;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int cnt = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
ink[p[i]] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
E.push_back(make_pair(min(ink[i], ink[j]), max(ink[i], ink[j])));
}
}
sort(E.begin(), E.end());
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
Q.push_back(query(l, r, i));
}
sort(Q.begin(), Q.end());
ta.Init(n);
int idx = E.size() - 1;
for (int i = m - 1; i >= 0; i--) {
while (idx >= 0 && E[idx].first >= Q[i].l) {
ta.add(E[idx].second, 1);
idx--;
}
ans[Q[i].idx] = ta.get(Q[i].r);
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 200000;
int n, m, p[N + 1], rp[N + 1], ans[N + 1], s[N + 1];
pair<int, int> qq[N + 1];
vector<pair<int, int>> q[N + 1];
vector<int> v[N + 1];
inline int sum(int x) {
int rtn = 0;
while (x > 0) {
rtn += s[x];
x -= (x & -x);
}
return rtn;
}
inline void add(int x) {
while (x <= N) {
++s[x];
x += (x & -x);
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", p + i);
rp[p[i]] = i;
}
for (int i = 1; i <= n; ++i) {
int j = i + i;
for (; j <= n; j += i) {
if (rp[i] < rp[j])
v[rp[i]].push_back(rp[j]);
else
v[rp[j]].push_back(rp[i]);
}
}
for (int i = 1; i <= m; ++i) {
scanf("%d %d", &qq[i].first, &qq[i].second);
q[qq[i].first].emplace_back(qq[i].second, i);
}
for (int i = n; i > 0; --i) {
for (int &j : v[i]) add(j);
for (auto &j : q[i]) ans[j.second] = sum(j.first);
}
for (int i = 1; i <= m; ++i)
printf("%d\n", ans[i] + qq[i].second - qq[i].first + 1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 100;
const int maxrand = 10;
const int maxdiv = 7e3;
vector<pair<pair<int, int>, int> > g;
vector<pair<int, int> > v;
int seg[4 * maxn], ans[maxn], a[maxn], n, m;
int mp[maxn];
bool mark[maxn];
void add(int x, int val) {
for (; x < maxn; x += x & -x) seg[x] += val;
}
int get(int x) {
int dal = 0;
for (; x > 0; x -= x & -x) dal += seg[x];
return dal;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; 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)
v.push_back(make_pair(min(mp[i], mp[j]), max(mp[i], mp[j])));
for (int i = 1; i <= m; i++) {
int fi, se;
scanf("%d%d", &fi, &se);
g.push_back(make_pair(make_pair(fi, se), i));
}
sort(g.begin(), g.end());
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) add(v[i].second, 1);
int ad = 0;
int s = 0;
for (int i = 1; i <= n; i++) {
while (ad < g.size() and g[ad].first.first == i) {
ans[g[ad].second] = get(g[ad].first.second);
ad++;
}
while (s < v.size() and v[s].first == i) {
add(v[s].second, -1);
s++;
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return printf("\n"), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct BIT {
int bn;
vector<int> bA;
BIT() { bn = 0; }
BIT(int bn_) {
bn = bn_;
bA.resize(bn + 1);
fill(bA.begin(), bA.end(), 0);
}
int prefix(int bposn) {
if (bposn <= 0) return 0;
if (bposn > bn) bposn = bn;
int ret = 0;
for (int i = bposn; i > 0; i -= ((i) & (-i))) ret += bA[i];
return ret;
}
void update(int bposn, int bincr) {
if (bposn <= 0) return;
if (bposn > bn) return;
for (int i = bposn; i <= bn; i += ((i) & (-i))) bA[i] += bincr;
}
int query(int bl, int br) {
if (br <= 0 or bl > bn or bl > br) return 0;
if (bl <= 0) bl = 1;
if (br > bn) br = bn;
return (prefix(br) - prefix(bl - 1));
}
};
const int max_nm = 200010;
int n, m, l, r;
int p[max_nm];
int ip[max_nm];
vector<pair<pair<int, int>, int> > Q;
vector<pair<int, int> > matches;
BIT bit;
int res[max_nm];
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < (n); i++) {
scanf("%d", &p[i]);
ip[p[i]] = i + 1;
}
for (int i = (1); i <= (n); i++)
for (int j = i; j <= n; j += i)
matches.push_back(make_pair(min(ip[i], ip[j]), max(ip[i], ip[j])));
sort(matches.begin(), matches.end());
for (int i = 0; i < (m); i++) {
scanf("%d", &l);
scanf("%d", &r);
Q.push_back(make_pair(make_pair(l, r), i));
}
sort(Q.begin(), Q.end());
bit = BIT(n);
int j = matches.size() - 1;
for (int q = (m - 1); q >= (0); q--) {
while (j >= 0 and matches[j].first >= Q[q].first.first) {
bit.update(matches[j].second, 1);
j--;
}
res[Q[q].second] = bit.prefix(Q[q].first.second);
}
for (int i = 0; i < (m); i++) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
struct event {
int t, time, L, R, idx;
event() {}
event(int t, int time, int L, int R, int idx)
: t(t), time(time), L(L), R(R), idx(idx) {}
bool operator<(const event& a) const {
return (time < a.time || (time == a.time && t < a.t));
}
} e[200005 * 23];
int n, m, i, j, ai, place[200005], L, R, en, idx, ans[200005], fw[200005];
void modify(int j) {
for (; j <= n; j = (j | (j - 1)) + 1) ++fw[j];
}
int query(int j) {
int rt = 0;
for (; j; j &= (j - 1)) rt += fw[j];
return rt;
}
int main(int argc, char* const argv[]) {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%d", &ai);
place[ai] = i;
}
for (i = 1; i <= m; i++) {
scanf("%d%d", &L, &R);
e[++en] = event(2, R, L, R, i);
e[++en] = event(2, L - 1, L, R, -i);
}
for (i = 1; i <= n; i++) {
j = i;
while (j <= n) {
e[++en] = event(1, place[i], place[j], 0, 0);
j += i;
}
}
std::sort(e + 1, e + en + 1);
for (i = 1; i <= en; i++)
if (e[i].t == 1)
modify(e[i].L);
else {
idx = abs(e[i].idx);
ans[idx] += (query(e[i].R) - query(e[i].L - 1)) * (e[i].idx / idx);
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m, pos[maxn], p[maxn], ans[maxn], bit[maxn];
vector<pair<int, int> > q[maxn];
vector<int> link[maxn];
void update(int x) {
while (x <= n) {
bit[x]++;
x += x & -x;
}
}
int get(int x) {
int ans = 0;
while (x) {
ans += bit[x];
x -= x & -x;
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int u, i = 1; i <= n; i++) {
scanf("%d", &u);
pos[u] = i;
p[i] = u;
}
for (int u, i = 1; i <= n; i++) {
u = p[i];
for (int v, j = 1; 1LL * j * j <= 1LL * u; j++) {
if (u % j == 0) {
if (j != u) {
v = pos[j];
if (v < i)
link[v].push_back(i);
else
link[i].push_back(v);
}
if (j != 1 && j * j != u) {
v = pos[u / j];
if (v < i)
link[v].push_back(i);
else
link[i].push_back(v);
}
}
}
}
for (int u, v, i = 1; i <= m; i++) {
scanf("%d%d", &u, &v);
ans[i] = v - u + 1;
q[u].push_back(make_pair(v, i));
}
for (int i = n; i >= 1; i--) {
for (vector<int>::iterator it = link[i].begin(); it != link[i].end();
it++) {
update(*it);
}
for (vector<pair<int, int> >::iterator it = q[i].begin(); it != q[i].end();
it++) {
ans[it->second] += get(it->first);
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000 + 10;
int n, p[N], m, idx[N];
long long sum[4 * N], ans[N];
pair<pair<int, int>, int> q[N];
vector<int> id[N];
void add(int i, int lo, int hi, int ql) {
if (lo == hi) {
sum[i]++;
return;
}
int mid = lo + hi >> 1;
if (ql <= mid)
add(2 * i, lo, mid, ql);
else
add(2 * i + 1, mid + 1, hi, ql);
sum[i] = sum[2 * i] + sum[2 * i + 1];
}
long long ask(int i, int lo, int hi, int ql, int qr) {
if (qr < lo || hi < ql) return 0;
if (ql <= lo && hi <= qr) return sum[i];
int mid = lo + hi >> 1;
return ask(2 * i, lo, mid, ql, qr) + ask(2 * i + 1, mid + 1, hi, ql, qr);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", p + i);
idx[p[i]] = i;
}
for (int i = 1; i <= m; i++)
scanf("%d%d", &q[q[i].second = i].first.first, &q[i].first.second);
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i) {
if (idx[j] > idx[i])
id[i].push_back(idx[j]);
else
id[j].push_back(idx[i]);
}
sort(q + 1, q + m + 1);
int mm = m;
memset(sum, 0, sizeof sum);
int l, r;
int st = n;
int x;
while (m--) {
l = q[m + 1].first.first, r = q[m + 1].first.second;
while (st >= l) {
x = p[st];
while ((int)id[x].size() && id[x].back() >= l) {
add(1, 1, n, id[x].back());
id[x].pop_back();
}
st--;
}
ans[q[m + 1].second] = ask(1, 1, n, l, r);
}
for (int i = 1; i <= mm; i++) printf("%I64d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
const int nmax = 2e5 + 5;
std::pair<std::pair<int, int>, int> qu[nmax];
int aib[nmax], v[nmax], m[nmax], n, q, ans[nmax];
std::vector<std::pair<int, int> > a;
int query(int first) {
int ans = 0;
for (int i = first; i; i -= (i & (-i))) ans += aib[i];
return ans;
}
void update(int first, int second) {
for (int i = first; i <= nmax; i += (-i) & i) aib[i] += second;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
std::cin >> n >> q;
for (int i = 1; i <= n; i++) std::cin >> v[i], m[v[i]] = i;
std::sort(v + 1, v + n + 1);
for (int i = 1; i <= n; i++)
for (int j = v[i]; j <= nmax; j += v[i])
if (m[j] != 0) a.push_back({m[v[i]], m[j]});
for (int i = 0; i < a.size(); i++)
if (a[i].first > a[i].second) std::swap(a[i].first, a[i].second);
std::sort(a.begin(), a.end());
for (auto z : a) update(z.second, 1);
for (int i = 1; i <= q; i++)
std::cin >> qu[i].first.first >> qu[i].first.second, qu[i].second = i;
std::sort(qu + 1, qu + q + 1);
int cnt = 0;
for (int i = 1; i <= q; i++) {
while (cnt < a.size() and a[cnt].first < qu[i].first.first)
update(a[cnt++].second, -1);
ans[qu[i].second] = query(qu[i].first.second);
}
for (int i = 1; i <= q; i++) std::cout << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * (1e5 + 5);
int t[N + 5];
int n;
int inde[N];
vector<vector<int>> pai(N);
vector<vector<pair<int, int>>> query(N);
int m;
inline int zeros(int x) { return ((x ^ (x - 1)) & x); }
void add(int pos, int val) {
for (int i = pos; i <= n; i += zeros(i)) {
t[i] += val;
}
}
int getSum(int pos) {
int sum = 0;
for (int i = pos; i >= 1; i -= zeros(i)) {
sum += t[i];
}
return sum;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
inde[x] = i;
}
for (int i = 1; i <= n; i++) {
for (int j = 2 * i; j <= n; j += i) {
pai[max(inde[i], inde[j])].push_back(min(inde[i], inde[j]));
}
}
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
query[y - 1].push_back(make_pair(x - 1, i));
}
int result[m + 5];
for (int i = 0; i < n; i++) {
for (int j = 0; j < pai[i].size(); j++) {
add(pai[i][j] + 1, 1);
}
for (int j = 0; j < query[i].size(); j++) {
result[query[i][j].second] =
getSum(i + 1) - getSum(query[i][j].first) + i + 1 - query[i][j].first;
}
}
for (int i = 0; i < m; i++) {
printf("%d\n", result[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimization_level 3
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const int G = 200005;
int a, z;
int m[G], ps[G], BIT[G];
vector<int> rg[G];
pair<int, int> que[G];
inline void add(int p, int val) {
for (; p < G; p += p & -p) BIT[p] += val;
}
inline int prs(int p) {
int o = 0;
for (; p > 0; p -= p & -p) o += BIT[p];
return o;
}
int main() {
cin.tie(0);
cout.tie(0);
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
;
memset(BIT, 0, sizeof(BIT));
cin >> a >> z;
for (int q = 0; q < a; q++) {
cin >> m[q];
ps[m[q]] = q + 1;
}
for (int q = 1; q <= a; q++) {
for (int w = q; w <= a; w += q) {
rg[min(ps[q], ps[w])].push_back(max(ps[q], ps[w]));
}
}
for (int q = 0; q < z; q++) cin >> que[q].first >> que[q].second;
pair<int, int> st[G];
memcpy(st, que, sizeof(st));
sort(que, que + z);
int l = a + 1;
map<pair<int, int>, int> mp;
for (int q = z - 1; q >= 0; q--) {
for (; l > que[q].first;) {
l--;
for (int i : rg[l]) add(i, 1);
}
int o = prs(que[q].second) - prs(que[q].first - 1);
mp[que[q]] = o;
}
for (int q = 0; q < z; q++) {
cout << mp[st[q]] << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
__inline bool nextInt(int &val) {
char ch;
int sgn = 1;
while ((ch = getchar()) != EOF) {
if (ch == '-') sgn = -1;
if (ch >= '0' && ch <= '9') break;
}
if (ch == EOF) return false;
val = (int)(ch - '0');
while (true) {
ch = getchar();
if (ch >= '0' && ch <= '9') {
val = 10 * val + (int)(ch - '0');
} else
break;
}
val *= sgn;
return true;
}
__inline bool nextString(string &s) {
char ch;
while ((ch = getchar()) != EOF) {
if (ch >= 33 && ch <= 126) break;
}
if (ch == EOF) return false;
s = string(1, ch);
while (true) {
ch = getchar();
if (ch >= 33 && ch <= 126) {
s = s + string(1, ch);
} else
break;
}
return true;
}
int n, m, p[333888], pos[333888], ret[333888], l[333888], r[333888];
int finish[333888 * 2];
vector<int> e[333888];
vector<pair<pair<int, int>, int> > q;
int main() {
ios_base::sync_with_stdio(false);
scanf("%d%d", &n, &m);
for (int i = (1); i < (n + 1); i++) {
scanf("%d", p + i);
pos[p[i]] = i;
}
{
memset(finish, 0, sizeof(finish));
;
};
for (int i = (1); i < (n + 1); i++) {
for (int j = p[i]; j <= n; j += p[i]) {
{
for (int x = ((pos[p[i]]) > (pos[j]) ? (pos[p[i]]) : (pos[j]));
x < 333888 * 2; x += x & -x)
finish[x] += 1;
};
e[((pos[p[i]]) < (pos[j]) ? (pos[p[i]]) : (pos[j]))].push_back(
((pos[p[i]]) > (pos[j]) ? (pos[p[i]]) : (pos[j])));
}
}
for (int iq = 0; iq < (m); iq++) {
scanf("%d%d", l + iq, r + iq);
q.push_back(pair<pair<int, int>, int>(pair<int, int>(l[iq], r[iq]), iq));
}
sort(q.begin(), q.end());
int last = 0;
for (int iq = 0; iq < (q.size()); iq++) {
int curL = q[iq].first.first, curR = q[iq].first.second,
curIdx = q[iq].second;
while (last < curL) {
for (int i = 0; i < (e[last].size()); i++) {
for (int x = e[last][i]; x < 333888 * 2; x += x & -x) finish[x] += -1;
};
last++;
}
{
ret[curIdx] = 0;
for (int x = curR; x > 0; x -= x & -x) ret[curIdx] += finish[x];
};
}
for (int i = 0; i < (q.size()); i++) printf("%d\n", ret[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
vector<long long> v[N], g[N];
long long a[N], p[N], ans[N];
long long n, Q, l[N], r[N], tree[N];
inline void add(long long x, long long v) {
for (; x <= n; x += x & -x) tree[x] += v;
}
inline long long check(long long x) {
long long cnt = 0;
for (; x; x -= x & -x) cnt += tree[x];
return cnt;
}
signed main() {
scanf("%d%d", &n, &Q);
for (long long i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
}
for (long long i = 1; i <= n; i++) {
for (long long j = i; j <= n; j += i) {
v[min(p[i], p[j])].push_back(max(p[i], p[j]));
}
}
for (long long i = 1; i <= Q; i++) {
scanf("%d%d", &l[i], &r[i]);
g[l[i]].push_back(i);
}
for (long long i = n; i >= 0; i--) {
for (long long j = 0; j < v[i].size(); j++) add(v[i][j], 1);
for (long long j = 0; j < g[i].size(); j++) {
ans[g[i][j]] = check(r[g[i][j]]);
}
}
for (long long i = 1; i <= Q; i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 2;
struct TSeg {
int l, r;
};
struct TQuery {
int l, r, id;
};
int n, m, b[N], res[N];
vector<TSeg> a;
vector<TQuery> p;
void Prep() {
vector<int> p(n + 1);
for (int i = 1; i <= n; ++i) p[b[i]] = i;
for (int i = 1; i <= n; ++i)
for (int j = 1; i * j <= n; ++j) {
int l = p[i], r = p[i * j];
if (l > r) swap(l, r);
a.push_back({l, r});
}
}
class TBTree {
int bit[N];
public:
void Update(int id) {
for (; id > 0; id -= id & -id) ++bit[id];
}
int Query(int id) {
int sum = 0;
for (; id <= n; id += id & -id) sum += bit[id];
return sum;
}
} tree;
void Solve() {
sort(a.begin(), a.end(), [](TSeg a, TSeg b) { return a.r < b.r; });
sort(p.begin(), p.end(), [](TQuery a, TQuery b) { return a.r < b.r; });
auto upd = a.begin();
auto itq = p.begin();
for (int i = 1; i <= n; ++i) {
while (upd != a.end() && upd->r <= i) tree.Update((upd++)->l);
while (itq != p.end() && itq->r <= i) {
res[itq->id] = tree.Query(itq->l);
++itq;
}
}
for (int i = 0; i < m; ++i) printf("%d\n", res[i]);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &b[i]);
for (int i = 0; i < m; ++i) {
int l, r;
scanf("%d %d", &l, &r);
p.push_back({l, r, i});
}
Prep();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 2e5 + 5;
vector<int> divisors[N];
vector<int> multi[N];
int l[N], r[N];
int occur[N];
struct Compare {
bool operator()(const vector<int>& m, const vector<int>& n) {
if (m[1] != n[1])
return m[1] < n[1];
else if (m[2] != n[2])
return m[2] < n[2];
}
};
set<vector<int>, Compare> intervals;
int n, m;
int p[N];
using ll = long long;
ll ans[N];
ll t[N];
void update(int x, int val) {
for (int i = x; i < n + 2; i += (i & -i)) t[i] += val;
}
ll query(int k) {
ll an = 0;
for (int i = k; i > 0; i -= (i & -i)) an += t[i];
return an;
}
ll query(int a, int b) { return query(b) - query(a - 1); }
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i]);
occur[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d %d", &l[i], &r[i]);
intervals.insert({l[i], r[i], i});
}
for (int i = 1; i <= n; i++) {
for (int j = 2 * i; j <= n; j += i) {
divisors[j].push_back(i);
multi[i].push_back(j);
}
}
auto it = intervals.begin();
for (int i = 1; i <= n; i++) {
for (int k = 0; k < divisors[p[i]].size(); k++) {
int u = divisors[p[i]][k];
if (occur[u] < i) {
update(occur[u], 1);
}
}
for (int k = 0; k < multi[p[i]].size(); k++) {
int u = multi[p[i]][k];
if (occur[u] < i) {
update(occur[u], 1);
}
}
while ((*it)[1] == i) {
ans[(*it)[2]] = query((*it)[0], (*it)[1]) + (*it)[1] - (*it)[0] + 1;
it++;
if (it == intervals.end()) break;
}
if (it == intervals.end()) break;
}
for (int i = 1; i <= m; i++) {
printf("%I64d \n", ans[i]);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.