text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void gmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void gmax(T &a, T b) {
if (a < b) a = b;
}
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double DINF = 1e30;
const double EPS = 1e-10;
const double PI = 3.14159265358979333846264338337950288;
inline int dcmp(double a) { return a > EPS ? 1 : (a < -EPS ? -1 : 0); }
inline int dcmp(double a, double b) {
return a - b > EPS ? 1 : (a - b < -EPS ? -1 : 0);
}
const int MAXN = 1000005;
int n, ans;
vector<pair<int, int> > seg;
string s;
inline int len(pair<int, int> a) { return a.second - a.first + 1; }
int main() {
cin >> s;
n = s.size();
for (int i = 0; i < n; i++)
if (s[i] == '1') {
int j;
for (j = i; j < n && s[j + 1] == '1'; j++)
;
seg.push_back(make_pair(i, j));
i = j;
}
n = seg.size();
for (int i = 0; i < n; i++) {
if (len(seg[i]) == 1)
ans++;
else {
int j;
for (j = i; seg[j + 1].first == seg[j].second + 2; j++)
;
ans += 2 + j - i;
i = j;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const double PI = 3.14159265359;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
vector<int> dp = {0, 1};
for (int i = 0; i < n; i++) {
dp['1' - s[i]] = min(dp[0], dp[1]) + 1;
}
cout << dp[0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int n, ans = 0;
int main() {
cin >> s;
s = "0" + s;
n = s.size();
for (int i = n - 1; i >= 0;) {
if (s[i] == '0') {
i--;
continue;
}
int j = i, ted = 0;
for (; j >= 0 && s[j] == s[i]; j--, ted++) {
}
if (ted == 1) {
} else {
ans++;
for (int k = i; k > j; k--) s[k] = '0';
s[j] = '1';
}
i = j;
}
for (int i = 0; i < n; i++)
if (s[i] == '1') ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int len, dp[1000009];
string str;
int solve(int ind) {
if (ind >= len - 1) {
return 1;
}
if (str[ind] == '0') return solve(ind + 1);
int cnt = 0;
for (int i = ind; i < len; i++) {
if (str[i] == '0') break;
cnt++;
}
if (cnt > 1) {
str[ind + cnt] = '1';
return solve(ind + cnt) + 1;
} else
return solve(ind + 1) + 1;
}
int main() {
int i, j;
int cases = 1;
int K, n;
int m;
cin >> str;
reverse(str.begin(), str.end());
len = str.length();
int res = solve(0);
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char s[1000000 + 10];
int n;
int dp[1000000 + 10][2];
const int inf = 100000000;
int main() {
scanf("%s", s);
n = strlen(s);
reverse(s, s + n);
for (int i = 0; i < n + 2; i++)
for (int j = 0; j < 2; j++) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j < 2; j++)
if (dp[i][j] != inf) {
const int ss = s[i] == '1' ? 1 : 0;
if (ss == j) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j]);
} else {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][j] + 1);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][j] + 1);
}
}
const int ans = dp[n + 1][0];
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[1000010];
int dp[1000010][2];
int a[1000010], b[1000011];
int main() {
scanf("%s", str);
int n = strlen(str);
n++;
for (int i = 0; i < n - 1; i++) a[i + 1] = str[i] - '0';
while (n > 0 && a[n - 1] == 0) n--;
for (int i = 0; i < n; i++) b[i] = 1 - a[i];
b[n - 1]++;
a[0] = 0;
for (int i = n - 1; i >= 0; i--) {
dp[i][0] = dp[i + 1][0] + a[i];
if (b[i] == 0) dp[i][0] = min(dp[i][0], dp[i + 1][1] + 1);
dp[i][1] = dp[i + 1][1] + b[i];
if (a[i] == 0) dp[i][1] = min(dp[i][1], dp[i + 1][0] + 1);
}
printf("%d\n", dp[0][0]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000009;
const long long INFL = 1e18 + 5LL;
const long double EPS = 1e-11;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
string s;
cin >> s;
s.push_back('0');
s.push_back('0');
int ans = 0;
int f1 = -1;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '1') {
if (f1 == -1) {
f1 = i;
}
}
if (s[i] == '0') {
if (f1 == i - 1) {
++ans;
f1 = -1;
} else if (f1 >= 0) {
if (s[i - 1] == '1') {
++ans;
} else {
++ans;
f1 = -1;
}
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long c = 0, ans = 0;
string x;
cin >> x;
x += "00";
for (int i = 0; i < x.size(); i++) {
if (x[i] & 1)
c++;
else if (c > 1)
c = 1, ans++;
else if (c)
ans++, c = 0;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NUM = 1000000 + 10;
char str[NUM];
int main() {
scanf("%s", str + 1);
int len = strlen(str + 1);
int i;
int first = 0, second = 1;
for (i = 1; i <= len; ++i) {
int ny, nx;
if (str[i] == '0') {
ny = min(second + 1, first + 1);
nx = first;
} else {
nx = min(first + 1, second + 1);
ny = second;
}
first = nx, second = ny;
}
printf("%d\n", first);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 8;
char s[N];
vector<int> a;
int main() {
cin >> s;
int i = 0;
while (s[i]) {
int num = 1;
while (s[i + 1] && s[i + 1] == s[i]) i++, num++;
if (s[i] == '1')
a.push_back(num);
else
a.push_back(-num);
i++;
}
i = 0;
int ans = 0;
while (i < a.size() && a[i] <= 1) {
if (a[i] == 1) ans++;
i++;
}
bool on = 1;
if (i >= a.size()) {
printf("%d\n", ans);
return 0;
}
ans += 2;
i++;
while (i + 1 < a.size()) {
if (a[i] == -1) {
if (on) {
ans++;
i += 2;
} else {
if (a[i + 1] == 1)
ans++;
else {
ans += 2;
on = 1;
}
i += 2;
}
} else {
on = 0;
if (a[i + 1] == 1)
ans++;
else {
ans += 2;
on = 1;
}
i += 2;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
char s[1001000];
int main() {
int a = 0, b = 1;
char c;
while (1) {
c = getchar();
if (c == '\n' || c == EOF) break;
if (c == '0')
b = (a < b ? a : b) + 1;
else
a = (a < b ? a : b) + 1;
}
printf("%d\n", a);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, n, rez;
string s;
int main(void) {
cin >> s;
s = "00" + s;
n = s.length() - 1;
i = n;
while (s[i] == '0') --i;
while (i > 0) {
++rez;
char ch = s[i - 1];
--i;
while (s[i] == ch && i >= 0) --i;
}
cout << rez;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int kol = 0;
char t;
int ans = 0;
cin >> s;
s += '0';
int l = 0;
for (int i = 0; i < s.length(); ++i) {
t = s[l + 1];
if (kol % 2 == 1) {
(s[l] == '0') ? (s[l] = '1') : (s[l] = '0');
(t == '0') ? (t = '1') : (t = '0');
}
if (s[l] == '1') {
if (t == '1') {
s[l] = '0';
++l;
++kol;
} else {
++l;
}
++ans;
} else {
++l;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int tot = 0;
int st = 0;
int ind = 0;
int siz = str.size();
while (ind < siz) {
if (st == 0) {
if (str[ind] == '0') {
ind++;
continue;
}
int cnt = 0;
while (ind < siz) {
if (str[ind] == '0') {
ind++;
if (cnt > 1) st = 1;
break;
}
ind++;
cnt++;
}
if (cnt > 1)
tot += 2;
else {
st = 0;
if (cnt > 0) tot++;
}
} else if (st == 1) {
if (str[ind] == '0') {
st = 0;
ind++;
continue;
}
int cnt = 0;
while (ind < siz) {
if (str[ind] == '0') {
ind++;
break;
}
ind++;
cnt++;
}
if (cnt > 0) tot++;
}
}
cout << tot << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int dp[1000001];
int len[1000001];
int main() {
cin >> s;
for (int i = s.size() - 1, l = 0; i >= 0; i--) {
if (s[i] == '0') {
if (s[i - 1] != '0' && l >= 2)
++l, dp[i] = 1, len[i] = l;
else
l = 0, dp[i] = 0;
} else {
l++;
if (l >= 2)
dp[i] = 1, len[i] = l;
else
dp[i] = 0;
}
}
int n = s.size();
stringstream ss;
int ans = 0;
for (int i = 0; i < n;) {
if (dp[i]) {
int k = len[i];
ss << "+2^" << n - i << endl;
ss << "-2^" << n - i - k << endl;
ans += 2;
while (k) {
if (s[i] == '0') ss << "-2^" << n - i - 1 << endl, ++ans;
++i;
--k;
}
} else {
if (s[i] == '1') ss << "+2^" << n - i - 1 << endl, ++ans;
++i;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char lst[1000010] = {0};
int sig[1000010] = {0};
int main() {
lst[0] = '0';
scanf("%s", lst + 1);
int len = strlen(lst);
lst[len] = '0';
len++;
lst[len] = 0;
int res = 0;
int acc = 0;
for (int i = 0; i < len; i++) {
if (lst[i] == '1') {
acc++;
} else {
if (acc >= 2) {
sig[i - acc] = 1;
sig[i] = -1;
} else if (acc == 1) {
sig[i] = 1;
}
acc = 0;
}
}
int done = 0;
do {
done = 0;
for (int i = 1; i < len - 1; i++) {
if (sig[i] == 1 && sig[i + 1] == -1) {
sig[i] = 0;
sig[i + 1] = 1;
done++;
} else if (sig[i] == -1 && sig[i + 1] == 1) {
sig[i] = 0;
sig[i + 1] = -1;
done++;
} else if (sig[i] == 1 && sig[i + 1] == 1) {
sig[i - 1] = 1;
sig[i] = 0;
sig[i + 1] = -1;
done++;
} else if (sig[i] == -1 && sig[i + 1] == -1) {
sig[i - 1] = -1;
sig[i] = 0;
sig[i + 1] = 1;
done++;
}
}
} while (done);
for (int i = 0; i < len; i++) {
if (sig[i] != 0) {
res++;
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
void solve() {
string s;
cin >> s;
long long n = (long long int)s.size(), ans = 0, c = 0;
for (long long i = 0; i <= n - 1; i++)
if (s[i] == '1') c++;
for (long long i = n - 1; i >= 0; i--) {
long long j = i;
while (j >= 0 && s[j] == '0') j--;
i = j;
while (j >= 0 && s[j] == '1') j--;
if (i - j > 1) {
if (j == -1 && s[0] == '1') ans = 1;
for (long long k = j + 1; k <= i - 1; k++) s[k] = '0';
if (j == -1) break;
s[j] = '1';
}
i = j + 1;
}
for (long long i = 0; i <= n - 1; i++)
if (s[i] == '1') ans++;
cout << min(c, ans);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
char s[1000001];
int dp[1000001][2];
int min(int a, int b) { return a < b ? a : b; }
int main() {
scanf("%s", s);
int n = strlen(s);
int i;
for (i = 0; i <= n; i++) {
dp[i][0] = 100000000;
dp[i][1] = 100000000;
}
dp[n][0] = 0;
for (i = n - 1; i >= 0; i--) {
int acos = s[i] == '0' ? 0 : 1;
int bcos = s[i] == '0' ? 1 : 0;
dp[i][0] = min(dp[i + 1][0], dp[i + 1][1]) + acos;
dp[i][1] = min(dp[i + 1][0] + 2, dp[i + 1][1]) + bcos;
}
printf("%d\n", min(dp[0][0], dp[0][1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a = 0, b = 1;
string s;
cin >> s;
for (int i = 0; i <= s.size(); i++) {
if (s[i] == '1')
a = min(a, b) + 1;
else
b = min(a, b) + 1;
}
cout << min(a, b) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
os << "[ ";
for (auto v : V) os << v << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, set<T> S) {
os << "{ ";
for (auto s : S) os << s << " ";
return os << "}";
}
template <class L, class R>
ostream& operator<<(ostream& os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R>
ostream& operator<<(ostream& os, map<L, R> M) {
os << "{ ";
for (auto m : M) os << "(" << m.F << ":" << m.S << ")";
return os << "}";
}
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cout << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(25);
int ans = 0;
string s;
cin >> s;
while (s.size() > 0 && s.back() == '0') s.pop_back();
reverse((s).begin(), (s).end());
while (s.size() > 0 && s.back() == '0') s.pop_back();
reverse((s).begin(), (s).end());
if (s.size() == '0') {
cout << 0 << "\n";
return 0;
}
int x = 0, y = 0;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '0' && s[i + 1] == '0') {
ans += min(x + 2, y);
x = 0, y = 0;
while (i < s.size() && s[i] == '0') {
++i;
}
assert(i != s.size());
--i;
} else if (s[i] == '0') {
++x;
} else {
++y;
}
}
cout << ans + min(x + 2, y) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
char s[N];
int main() {
scanf("%s", s);
int ans = 0;
int i;
for (i = strlen(s) - 1; i >= 0; --i) {
if (s[i] == '0') continue;
ans++;
if (i == 0 || s[i - 1] == '0') continue;
while (--i >= 0 && s[i] == '1')
;
if (i >= 0)
s[i++] = '1';
else
ans++;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
string str;
int dp[2000001][2];
int main(void) {
cin >> str;
for (int i = 0; i <= 2000000; i++) dp[i][0] = dp[i][1] = 100000000;
dp[0][0] = 0;
int n = str.size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
if (str[i] == '1') {
if (j == 1) dp[i + 1][1] = min(dp[i + 1][1], dp[i][1]);
if (j == 0) {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][0] + 1);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][0] + 1);
}
}
if (str[i] == '0') {
if (j == 0) dp[i + 1][0] = min(dp[i + 1][0], dp[i][0]);
if (j == 1) {
dp[i + 1][0] = min(dp[i + 1][0], dp[i][1] + 1);
dp[i + 1][1] = min(dp[i + 1][1], dp[i][1] + 1);
}
}
}
}
printf("%d\n", min(dp[n][0], dp[n][1] + 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 0;
for (int i = s.size() - 1; i >= 0;) {
if (s[i] == '0') {
--i;
continue;
}
if (i > 0 && s[i - 1] == '1') {
int j = i - 1;
while (j >= 0 && s[j] == '1') s[j] = '0', --j;
if (j < 0)
++ans;
else
s[j] = '1';
i = j;
continue;
}
--i;
}
for (int i = 0; i < s.size(); ++i) ans += (s[i] == '1');
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char g[1000100];
int save[1000100];
int dp[1000100];
int dp1[1000100];
int min1(int x, int y) {
if (x > y)
return y;
else
return x;
}
int main() {
scanf("%s", g);
int i = 0;
int cnt = 0;
while (g[i] == '0') {
i++;
}
int len = strlen(g);
if (i == len) {
printf("0");
return 0;
}
char tmp = '1';
int tcnt = 0;
for (; i <= len; i++) {
if (tmp == g[i] && i != len) {
tcnt++;
} else {
tmp = g[i];
save[cnt++] = tcnt;
tcnt = 1;
}
}
if (cnt % 2 == 0) cnt--;
dp[0] = save[0];
dp1[0] = 2;
for (int j = 2; j < cnt; j++) {
dp[j] = min1(dp[j - 2], dp1[j - 2]) + save[j];
dp1[j] =
min1(min1(dp[j - 2] + 2, dp1[j - 2] + save[j - 1]), dp1[j - 2] + 2);
j++;
}
printf("%d", min1(dp[cnt - 1], dp1[cnt - 1]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
int GETi() {
int i;
scanf("%d", &i);
return i;
}
template <class T>
T sqr(T val) {
return val * val;
}
int L;
char S[1000003];
void solve() {
int f, r, i, j, k, l, x, y, cur, tar;
int ma = 0;
scanf("%s", S);
;
L = strlen(S);
reverse(S, S + L);
int dp[2][2];
memset(dp, 0, sizeof(dp));
dp[0][1] = 9999999;
for (i = 0; i < L - 1; i++) {
cur = i % 2;
tar = 1 - cur;
if (S[i] == '0') {
dp[tar][0] = dp[cur][0];
dp[tar][0] = min(dp[tar][0], 1 + dp[cur][1]);
dp[tar][1] = 1 + dp[cur][1];
} else {
dp[tar][1] = dp[cur][1];
dp[tar][1] = min(dp[tar][1], 1 + dp[cur][0]);
dp[tar][0] = 1 + dp[cur][0];
}
}
if (L == 1)
printf("1\n");
else
printf("%d\n", 1 + min(dp[tar][0], dp[tar][1]));
return;
}
int main(int argc, char** argv) {
if (argc > 1) freopen(argv[1], "r", stdin);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt(time(0));
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
string s;
cin >> s;
int i = 1, zero = 0, ret = 0;
int mi[2] = {INT_MAX, INT_MAX};
for (char c : s) {
if (c == '0') {
zero++;
continue;
}
int prev = ret;
ret++;
if (i != 1) {
mi[0] += zero;
mi[1]++;
ret = min(ret, mi[0]);
ret = min(ret, mi[1]);
}
mi[0] = min(mi[0], prev + 2);
mi[1] = min(mi[1], prev + 1);
i++;
zero = 0;
}
cout << ret << '\n';
return 0;
}
|
#include <bits/stdc++.h>
char S[1000005];
int Best[1000005][3], Op[1000005];
using namespace std;
enum { SUB, NOTHING, ADD };
int min(int a, int b, int c) {
int x = min(a, b);
return c < x ? c : x;
}
int main() {
cin.getline(S, 1000005, '\n');
int length = strlen(S);
for (int i = length; i > 0; i--) S[i] = S[i - 1];
for (int i = 1; i <= length; i++)
if (S[i] == '1') {
Op[i - 1]++;
Op[i]--;
}
for (int i = 0; i <= length; i++) Op[i]++;
for (int i = 0; i <= length; i++)
Best[i][ADD] = Best[i][NOTHING] = Best[i][SUB] = 2500000;
Best[0][Op[0]] = Op[0] == NOTHING ? 0 : 1;
for (int i = 1; i <= length; i++) {
if (Op[i] == SUB) {
Best[i][ADD] = Best[i - 1][ADD];
Best[i][SUB] =
min(Best[i - 1][ADD], Best[i - 1][NOTHING], Best[i - 1][SUB]) + 1;
}
if (Op[i] == ADD) {
Best[i][SUB] = Best[i - 1][SUB];
Best[i][ADD] =
min(Best[i - 1][ADD], Best[i - 1][NOTHING], Best[i - 1][SUB]) + 1;
}
if (Op[i] == NOTHING)
Best[i][NOTHING] =
min(Best[i - 1][ADD], Best[i - 1][NOTHING], Best[i - 1][SUB]);
}
cout << min(Best[length][NOTHING], Best[length][SUB], Best[length][ADD]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Pnt {
int x, y;
Pnt() {}
Pnt(int _x, int _y) {
x = _x;
y = _y;
}
bool operator<(const Pnt& o) const {
if (x != o.x) return x < o.x;
return y < o.y;
}
void show() { printf("Pnt %d %d\n", x, y); }
};
const int MAXN = 1000005;
const int MAXS = 20;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int n, m;
char s[MAXN];
int f[MAXN][2];
void preGao() {}
void init() {
if (scanf("%s", s) == EOF) exit(0);
n = strlen(s);
}
void work() {
f[n][0] = 0;
f[n][1] = 2;
for (int i = n - 1; i >= 0; i--) {
f[i][0] = f[i + 1][0] + (s[i] == '1');
f[i][0] = min(f[i][0], f[i + 1][1]);
f[i][1] = f[i + 1][0] + 2 + (s[i] == '0');
f[i][1] = min(f[i][1], f[i + 1][1] + (s[i] == '0'));
}
printf("%d\n", min(f[0][0], f[0][1]));
}
int main() {
preGao();
while (true) {
init();
work();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int Mmax(long long int a, long long int b) {
if (a > b) return a;
return b;
}
long long int Mmin(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int nod(long long int a, long long int b) {
while (a && b) {
if (a > b)
a %= b;
else
b %= a;
}
return Mmax(a, b);
}
long long int nok(long long int a, long long int b) {
return a * b / nod(a, b);
}
bool IsPrime(long long int x) {
if (x < 2) return false;
long long int X = sqrt(x), i;
for (i = 2; i <= X; i++)
if (x % i == 0) return false;
return true;
}
void hanoi(int n, int A, int C, int B) {
if (n == 1) {
cout << n << " " << A << " " << C << endl;
} else {
hanoi(n - 1, A, B, C);
cout << n << " " << A << " " << C << endl;
hanoi(n - 1, B, C, A);
}
}
string pr2(string a, int d) {
if (d == 0) return "0";
string b;
long long int sz = a.size(), i, prenos = 0;
for (i = 0; i < sz; i++) {
b[i] = a[i];
}
for (i = sz - 1; i > -1; i--) {
a[i] = ((b[i] - '0') * d + prenos) % 10 + '0';
prenos = ((b[i] - '0') * d + prenos) / 10;
}
if (prenos) a = char(prenos + '0') + a;
return a;
}
string sum(string a, string b) {
bool carry = false;
long long int i, sz1, sz2, maxsz, minsz;
string c, d;
sz1 = a.size();
sz2 = b.size();
maxsz = max(sz1, sz2);
minsz = min(sz1, sz2);
while (sz1 < maxsz) {
sz1++;
a = '0' + a;
}
while (sz2 < maxsz) {
sz2++;
b = '0' + b;
}
for (i = maxsz - 1; i > -1; i--) {
d = char((a[i] + b[i] - 96 + carry) % 10 + 48) + d;
if (a[i] + b[i] - 96 + carry > 9)
carry = true;
else
carry = false;
}
if (carry == true) d = char('1') + d;
return d;
}
string pr(string a, string b) {
string res = "0", p, p2;
int sz = a.size(), x = 0;
for (sz = a.size(); sz > 0; sz--, x++) {
int d = a[sz - 1] - '0';
a = a.erase(sz - 1, 1);
p2 = pr2(b, d);
p2 += p;
res = sum(res, p2);
p += "0";
}
return res;
}
bool vesokosna(long long int x) {
return (x % 4 == 0 && x % 100 || x % 400 == 0);
}
long long int reverse(long long int x) {
long long int mirror = 0;
while (x) {
mirror = mirror * 10 + x % 10;
x /= 10;
}
return mirror;
}
long long int ost(string x, long long int k) {
long long int num = 0, i, sz = x.size();
for (i = 0; i < sz; i++) {
num = num * 10;
num += x[i] - '0';
num %= k;
}
return num;
}
int dp[1048576];
int main() {
string x;
cin >> x;
if (x == "0") {
cout << 0 << endl;
return 0;
}
int sz = x.size(), i;
x += "00000";
int answer = 0;
for (i = 0; i < sz; i++) {
if (x[i] == '1' && x[i + 1] == '1') {
answer += 2;
while (true) {
if (x[i] == '1')
i++;
else if (x[i] == '0' && x[i + 1] == '0') {
i++;
break;
} else
answer++, i++;
}
} else if (x[i] == '1')
answer++;
}
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
int main() {
string s;
cin >> s;
reverse((s).begin(), (s).end());
int ops = 0;
int pos = 0;
while (pos < s.size()) {
if (s[pos] == '0')
;
else {
if (pos == s.size() - 1)
ops++;
else {
if (s[pos + 1] == '0')
ops++;
else {
int x = pos;
while (x < s.size() && s[x] == '1') {
s[x] = '0';
x++;
}
if (x == s.size())
s += '1';
else
(s[x] = '1');
ops++;
}
}
}
pos++;
}
cout << ops << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
s = "00" + s;
int i, ans = 0;
for (i = s.size() - 1; i >= 1; i--)
if (s[i] == '1') {
ans++;
if (s[i - 1] == '1') {
while (s[i] == '1') s[i--] = '0';
s[i++] = '1';
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
#pragma hdrstop
using namespace std;
inline void sIO() {}
inline void iIO() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
inline void fIO(string fn) {
freopen((fn + ".in").c_str(), "r", stdin);
freopen((fn + ".out").c_str(), "w", stdout);
}
inline void TM() {}
inline void swap(short& a, short& b) { b ^= a ^= b ^= a; }
inline void swap(int& a, int& b) { b ^= a ^= b ^= a; }
inline void swap(char& a, char& b) { b ^= a ^= b ^= a; }
inline void swap(long long& a, long long& b) { b ^= a ^= b ^= a; }
template <class T>
inline T abs(T x) {
return x < 0 ? -x : x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T min(T& a, T& b) {
return a < b ? a : b;
}
template <class T>
inline T max(T& a, T& b) {
return a > b ? a : b;
}
template <class T>
inline T gcd(T a, T b) {
if (a < b) swap(a, b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
inline bool isPrime(T n) {
if (n < 2) return false;
T kk = (T)sqrt(n + 0.);
for (T i = 2; i <= kk; ++i)
if (!(n % i)) return false;
return true;
}
template <class T>
inline string toa(T x) {
stringstream ss;
ss << x;
string ret;
ss >> ret;
return ret;
}
template <class T>
inline T ppow(T a, long long b) {
T ret = 1;
while (b) {
if (b & 1) ret *= a;
a *= a;
b >>= 1;
}
return ret;
}
template <class T>
inline T ppow(T a, long long b, long long md) {
T ret = 1;
a %= md;
while (b) {
if (b & 1) ret = ret * a % md;
a = a * a % md;
b >>= 1;
}
return ret % md;
}
inline int toi(string s) {
stringstream ss;
ss << s;
int ret;
ss >> ret;
return ret;
}
inline long long tol(string s) {
stringstream ss;
ss << s;
long long ret;
ss >> ret;
return ret;
}
inline int Random() { return ((rand() << 16) | rand()); }
inline int Random(int l, int r) {
if (l == r) return l;
return Random() % (r - l) + l;
}
inline char upperCase(char ch) {
return (ch >= 'a' && ch <= 'z') ? ch ^ 32 : ch;
}
inline char lowerCase(char ch) {
return (ch >= 'A' && ch <= 'Z') ? ch ^ 32 : ch;
}
inline string upperCase(string s) {
int ls = s.length();
for (int i = 0; i < ls; ++i)
if (s[i] >= 'a' && s[i] <= 'z') s[i] ^= 32;
return s;
}
inline string lowerCase(string s) {
int ls = s.length();
for (int i = 0; i < ls; ++i)
if (s[i] >= 'A' && s[i] <= 'Z') s[i] ^= 32;
return s;
}
inline int dig(char ch) { return ch - 48; }
inline bool isAlpha(char ch) {
return (ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z');
}
inline bool isDigit(char ch) { return (ch >= '0' && ch <= '9'); }
inline bool isLowerCase(char ch) { return (ch >= 'a' && ch <= 'z'); }
inline bool isUpperCase(char ch) { return (ch >= 'A' && ch <= 'Z'); }
int __;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-9;
const int MD = 1000000007;
int ls, ans, cx, cy;
char s[1111111];
int main() {
sIO();
gets(s);
ls = strlen(s);
ans = cx = 1;
while (cx < ls) {
cy = cx;
while (s[cy] == s[cx]) ++cy;
if (s[cx] == '1' || cy < ls) ++ans;
cx = cy + 1;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int M = 1000010;
const int mod = 1000000007;
const double eps = 1e-8;
const double Pi = 2 * acos(0.0);
char s[M];
int main() {
ios::sync_with_stdio(0);
cin >> s;
int tmp = 0, zero = 2, con = 0, single = 0;
for (int i = 0; s[i];) {
if (s[i] == '1') {
con = 0;
while (s[i + con] == '1') con++;
if (con == 1) {
tmp++;
if (zero > 1) single = 1;
} else if (zero == 1) {
tmp++;
if (single) tmp++;
single = 0;
} else {
tmp += 2;
single = 0;
}
i += con;
} else {
zero = 0;
while (s[i + zero] == '0') zero++;
i += zero;
}
}
cout << tmp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 201000;
int n, a[N], pos[N], l[N], r[N], C[N], idx[N], ans[N];
vector<int> nu[N];
void bitModify(int p) {
for (int i = p; i > 0; i -= i & -i) C[i]++;
}
int bitQuery(int p) {
int ret = 0;
for (int i = p; i <= n; i += i & -i) ret += C[i];
return ret;
}
bool cmp(int a, int b) { return r[a] < r[b]; }
int main() {
int nq;
scanf("%d%d", &n, &nq);
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++) {
int a = pos[i];
int b = pos[i * j];
if (a > b) swap(a, b);
nu[b].push_back(a);
}
}
for (int i = 0; i < nq; i++) {
scanf("%d%d", &l[i], &r[i]);
idx[i] = i;
}
sort(idx, idx + nq, cmp);
int p = 0;
for (int i = 0; i < nq; i++) {
int ll = l[idx[i]];
int rr = r[idx[i]];
while (p < rr) {
p++;
for (int i = 0; i < (int)nu[p].size(); i++) {
bitModify(nu[p][i]);
}
}
ans[idx[i]] = bitQuery(ll);
}
for (int i = 0; i < nq; i++) {
printf("%d%c", ans[i], " \n"[i == nq - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Fread {
const int MAXN = 1 << 20;
char buf[MAXN], *S, *T;
inline char getchar() {
if (S == T) {
T = (S = buf) + fread(buf, 1, MAXN, stdin);
if (S == T) return EOF;
}
return *S++;
}
} // namespace Fread
inline int read() {
int f = 1, x = 0;
char ch = Fread::getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = Fread::getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = Fread::getchar();
}
return x * f;
}
inline long long readll() {
long long f = 1, x = 0;
char ch = Fread::getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = Fread::getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = Fread::getchar();
}
return x * f;
}
const int MAXN = 2e5;
int n, m, a[MAXN + 5], pos[MAXN + 5], cnt;
long long ans[MAXN + 5];
struct event {
int type, l, r, id;
bool operator<(const event &b) const {
return l < b.l || (l == b.l && type < b.type);
}
event(int _type, int _l, int _r) {
type = _type;
l = _l;
r = _r;
}
event() {}
} q[MAXN * 20];
struct FenwickTree {
long long c[MAXN + 5];
void modify(int p, long long v) {
for (; p <= n; p += (p & (-p))) c[p] += v;
}
long long query(int p) {
long long res = 0;
for (; p; p -= (p & (-p))) res += c[p];
return res;
}
FenwickTree() {}
} F;
int main() {
n = read();
m = read();
for (int i = 1; i <= n; ++i) a[i] = read(), pos[a[i]] = i;
for (int i = 1; i <= m; ++i)
q[i].l = read(), q[i].r = read(), q[i].type = 1, q[i].id = i;
cnt = m;
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
int l = pos[i], r = pos[j];
if (l > r) swap(l, r);
q[++cnt] = event(2, l, r);
F.modify(r, 1);
}
}
sort(q + 1, q + cnt + 1);
for (int i = 1; i <= cnt; ++i) {
if (q[i].type == 1) {
ans[q[i].id] += F.query(q[i].r);
} else {
F.modify(q[i].r, -1);
}
}
for (int i = 1; i <= m; ++i) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, p[N], inv[N], tree[N], ans[N];
vector<int> prevDivs[N];
vector<pair<int, int> > qs[N];
void update(int i, int v) {
while (i < N) tree[i] += v, i += i & -i;
}
int query(int i) {
int ret = 0;
while (i > 0) ret += tree[i], i -= i & -i;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = (1); (i) <= (int)(n); (i)++) scanf("%d", &p[i]), inv[p[i]] = i;
for (int(i) = (1); (i) <= (int)(n); (i)++) {
for (int j = i; j <= n; j += i) {
if (inv[j] <= inv[i])
prevDivs[inv[i]].push_back(inv[j]);
else
prevDivs[inv[j]].push_back(inv[i]);
}
}
for (int(i) = (1); (i) <= (int)(m); (i)++) {
int l, r;
scanf("%d%d", &l, &r);
qs[r].push_back({l, i});
}
for (int(i) = (1); (i) <= (int)(n); (i)++) {
for (int x : prevDivs[i]) update(x, 1);
for (pair<int, int> q : qs[i])
ans[q.second] = query(i) - query(q.first - 1);
}
for (int(i) = (1); (i) <= (int)(m); (i)++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char ch, B[1 << 20], *S = B, *T = B;
int aa, bb;
int rd() {
while (ch = (S == T && (T = (S = B) + fread(B, 1, 1 << 20, stdin), S == T)
? 0
: *S++),
!(ch >= '0' && ch <= '9') && ch != '-')
;
ch == '-' ? aa = bb = 0 : (aa = ch - '0', bb = 1);
while (ch = (S == T && (T = (S = B) + fread(B, 1, 1 << 20, stdin), S == T)
? 0
: *S++),
(ch >= '0' && ch <= '9'))
aa = aa * 10 + ch - '0';
return bb ? aa : -aa;
}
const int MAXN = 2e5 + 10;
int n, m, p[MAXN], tr[MAXN], ans[MAXN], pos[MAXN];
struct Node {
int l, r, id;
} a[MAXN], b[MAXN];
bool cmp1(Node a, Node b) { return a.l == b.l ? a.r < b.r : a.l < b.l; }
bool cmp2(Node a, Node b) { return a.r == b.r ? a.l < b.l : a.r < b.r; }
inline void add(int x, int c) {
while (x <= n) {
tr[x] += c;
x += (x & (-x));
}
}
int sum(int x) {
int ret = 0;
while (x) {
ret += tr[x];
x -= (x & (-x));
}
return ret;
}
inline void work() {
n = rd();
m = rd();
for (register int i = 1; i <= n; ++i) {
p[i] = rd();
pos[p[i]] = i;
}
for (register int i = 1; i <= m; ++i) {
int l = rd(), r = rd();
a[i].l = l;
a[i].r = r;
a[i].id = i;
b[i] = a[i];
}
sort(a + 1, a + m + 1, cmp1);
sort(b + 1, b + m + 1, cmp2);
int j = 1, k = 1;
for (register int i = 1; i <= n; ++i) {
while (a[j].l == i && j <= m) {
ans[a[j].id] -= sum(a[j].r) - sum(a[j].l - 1);
++j;
}
for (register int l = 1; l * p[i] <= n; ++l) add(pos[l * p[i]], 1);
while (b[k].r == i && k <= m) {
ans[b[k].id] += sum(b[k].r) - sum(b[k].l - 1);
++k;
}
}
for (register int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int prime = 9241;
const long double pi = acos(-1.);
int a[200005];
int ra[200005];
vector<int> d[200005];
struct event {
int x, l, r, t, qn;
event() {}
event(int x, int l, int r, int t, int qn) : x(x), l(l), r(r), t(t), qn(qn) {}
};
bool operator<(const event &a, const event &b) {
if (a.x < b.x) return 1;
if (a.x > b.x) return 0;
return a.t < b.t;
}
event ev[5000005];
long long ans[200005];
const int C = 200005;
int fenw[C];
void inc(int i, int v) {
i++;
for (; i < C; i += -i & i) fenw[i] += v;
}
int sum(int i) {
int ans = 0;
i++;
for (; i > 0; i &= i - 1) ans += fenw[i];
return ans;
}
int sum(int l, int r) {
int ans = -1;
if (l == 0)
ans = sum(r);
else
ans = sum(r) - sum(l - 1);
return ans;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
ra[a[i]] = i;
}
int ecnt = 0;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i) {
ev[ecnt++] = event(ra[i], ra[j], ra[j], 0, -1);
}
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
ans[i] = 0;
l--;
r--;
ev[ecnt++] = event(l, l, r, -1, i);
ev[ecnt++] = event(r, l, r, 1, i);
}
sort(ev, ev + ecnt);
for (int i = 0; i < ecnt; i++) {
if (ev[i].t == 0) inc(ev[i].l, 1);
if (ev[i].t == 1) ans[ev[i].qn] += (long long)sum(ev[i].l, ev[i].r);
if (ev[i].t == -1) ans[ev[i].qn] -= (long long)sum(ev[i].l, ev[i].r);
}
for (int i = 0; i < m; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int _;
const int MAXN = 200 * 1000;
int n, m;
int tree[MAXN + 1];
void Add(int x, int val) {
for (; x <= n; x += x & (-x)) tree[x] += val;
}
int Get(int x) {
int ans = 0;
for (; x; x -= x & (-x)) ans += tree[x];
return ans;
}
int p[MAXN + 1], pos[MAXN + 1];
vector<int> v[MAXN + 1];
vector<pair<int, int> > q[MAXN + 1];
int ans[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m;
for (__typeof(n) i = (1); i <= (n); ++i) {
cin >> p[i];
pos[p[i]] = i;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j * i <= n; ++j) {
int x = pos[i], y = pos[j * i];
if (x > y) swap(x, y);
v[x].push_back(y);
}
for (__typeof(m) i = (0); i < (m); ++i) {
int l, r;
cin >> l >> r;
q[l].push_back(pair<int, int>(r, i));
}
for (int i = n; i >= 1; --i) {
for (int j = 0; j < ((int)(v[i]).size()); ++j) {
Add(v[i][j], 1);
}
for (int j = 0; j < ((int)(q[i]).size()); ++j) {
ans[q[i][j].second] = Get(q[i][j].first);
}
}
for (__typeof(m) i = (0); i < (m); ++i) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long N = 210000;
vector<long> R[N], L[N];
long i, j, x, n, m, b[N] = {}, p[N] = {}, l[N] = {}, r[N] = {}, ans[N] = {};
struct Tree {
long l, r, s;
} a[5 * N] = {};
void build(long k) {
if (a[k].l == a[k].r) return;
long lc = 2 * k, rc = 2 * k + 1;
a[k].s = 0;
a[lc].l = a[k].l;
a[lc].r = (a[k].l + a[k].r) / 2;
a[rc].l = a[lc].r + 1;
a[rc].r = a[k].r;
build(lc);
build(rc);
}
void change(long k, long x) {
if (a[k].l != a[k].r)
if (a[2 * k].r >= x)
change(2 * k, x);
else
change(2 * k + 1, x);
a[k].s++;
}
long search(long k, long l, long r) {
if ((l > a[k].l) || (a[k].r > r)) {
long lc = 2 * k, rc = 2 * k + 1, t = 0;
if (a[lc].r >= l) t += search(lc, l, r);
if (a[rc].l <= r) t += search(rc, l, r);
return t;
} else
return a[k].s;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
for (i = 1; i <= n; i++) {
cin >> b[i];
p[b[i]] = i;
}
for (i = 0; i < m; i++) {
cin >> l[i] >> r[i];
L[l[i]].push_back(i);
R[r[i]].push_back(i);
}
a[1].l = 1;
a[1].r = n;
build(1);
for (i = 1; i <= n; i++) {
for (j = 0; j < L[i].size(); j++)
ans[L[i][j]] -= search(1, l[L[i][j]], r[L[i][j]]);
for (x = b[i]; x <= n; x += b[i]) change(1, p[x]);
for (j = 0; j < R[i].size(); j++)
ans[R[i][j]] += search(1, l[R[i][j]], r[R[i][j]]);
}
for (i = 0; i < m; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200005], pos[200005];
vector<int> gr[200005];
vector<pair<int, int> > query[200005];
int tree[4 * 200005], ans[200005];
int sum(int node, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) return tree[node];
int mid = (tl + tr) / 2;
return (sum(node * 2, tl, mid, l, min(r, mid)) +
sum(node * 2 + 1, mid + 1, tr, max(l, mid + 1), r));
}
void update(int node, int l, int r, int pos, int val) {
if (l == r)
tree[node] += val;
else {
int mid = (l + r) / 2;
if (pos <= mid)
update(node * 2, l, mid, pos, val);
else
update(node * 2 + 1, mid + 1, r, pos, val);
tree[node] = (tree[node * 2] + tree[node * 2 + 1]);
}
}
int main() {
int i, j;
scanf("%d", &n);
scanf("%d", &m);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j += i) {
gr[min(pos[i], pos[j])].push_back(max(pos[i], pos[j]));
}
}
for (i = 1; i <= m; i++) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
query[l].push_back({r, i});
}
for (i = n; i >= 1; i--) {
for (auto to : gr[i]) update(1, 1, n, to, 1);
for (auto to : query[i]) ans[to.second] = sum(1, 1, n, i, to.first);
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
template <class T>
inline T abs1(T a) {
return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a > b ? a : b;
if (c != -1234567) ans = max1(ans, c);
if (d != -1234567) ans = max1(ans, d);
return ans;
}
template <class T>
inline T min1(T a, T b, T c = -1234567, T d = -1234567) {
T ans = a < b ? a : b;
if (c != -1234567) ans = min(ans, c);
if (d != -1234567) ans = min(ans, d);
return ans;
}
template <class T>
inline T gcd1(T a, T b) {
if (a < b) swap(a, b);
if (a % b == 0) return b;
return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
return num & (-num);
}
inline int jud(double a, double b) {
if (abs1(a - b) < eps) return 0;
if (a < b) return -1;
return 1;
}
template <typename it, typename t1>
inline int find(t1 val, it a, int na, bool f_small = 1, bool f_lb = 1) {
if (na == 1) return 0;
int be = 0, en = na - 1;
if (*a <= *(a + na - 1)) {
if (f_lb == 0)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != 1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != -1)
en = mid;
else
be = mid + 1;
}
if (f_small && jud(*(a + be), val) == 1 && be != 0) be--;
if (!f_small && jud(*(a + be), val) == -1 && be != na - 1) be++;
} else {
if (f_lb)
while (be < en) {
int mid = (be + en + 1) / 2;
if (jud(*(a + mid), val) != -1)
be = mid;
else
en = mid - 1;
}
else
while (be < en) {
int mid = (be + en) / 2;
if (jud(*(a + mid), val) != 1)
en = mid;
else
be = mid + 1;
}
if (!f_small && jud(*(a + be), val) == -1 && be != 0) be--;
if (f_small && jud(*(a + be), val) == 1 && be != na - 1) be++;
}
return be;
}
inline int bitnum(unsigned long long nValue) {
nValue = ((0xaaaaaaaaaaaaaaaaull & nValue) >> 1) +
(0x5555555555555555ull & nValue);
nValue = ((0xccccccccccccccccull & nValue) >> 2) +
(0x3333333333333333ull & nValue);
nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue) >> 4) +
(0x0f0f0f0f0f0f0f0full & nValue);
nValue = ((0xff00ff00ff00ff00ull & nValue) >> 8) +
(0x00ff00ff00ff00ffull & nValue);
nValue = ((0xffff0000ffff0000ull & nValue) >> 16) +
(0x0000ffff0000ffffull & nValue);
nValue = ((0xffffffff00000000ull & nValue) >> 32) +
(0x00000000ffffffffull & nValue);
return nValue;
}
long long pow(long long n, long long m, long long mod = 0) {
long long ans = 1;
long long k = n;
while (m) {
if (m & 1) {
ans *= k;
if (mod) ans %= mod;
}
k *= k;
if (mod) k %= mod;
m >>= 1;
}
return ans;
}
const int maxn = 300110;
template <class t>
struct tree_array {
t num[maxn], n, bigwei;
tree_array(int nn = maxn) {
n = nn;
while (lb(nn) != nn) nn -= lb(nn);
bigwei = nn;
}
void upd(int no, t add) {
while (no <= n) {
num[no] += add;
no += lb(no);
}
}
t que(int no) {
t ans = 0;
while (no) {
ans += num[no];
no -= lb(no);
}
return ans;
}
int getrank(t x) {
int ans = 0, ranwei = bigwei;
t rank = 0;
while (ranwei) {
if (rank + num[ranwei + ans] < x) {
ans += ranwei;
rank += num[ans];
}
ranwei >>= 1;
}
return ans + 1;
}
};
tree_array<int> ta;
int orig[maxn];
int trans[maxn];
pair<int, int> can;
vector<int> should[maxn];
vector<pair<int, int> > que[maxn];
int n, nq;
int ans[maxn];
int main() {
scanf("%d%d", &n, &nq);
for (int i = 0; i < n; i++) {
scanf("%d", orig + i);
trans[orig[i]] = i;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j * i <= n; j++) {
int a = trans[i], b = trans[j * i];
if (a > b) swap(a, b);
should[a].push_back(b);
}
for (int i = 0; i < nq; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
que[a].push_back(make_pair(b, i));
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < (int)should[i].size(); j++) ta.upd(should[i][j] + 1, 1);
for (int j = 0; j < (int)que[i].size(); j++)
ans[que[i][j].second] = ta.que(que[i][j].first + 1);
}
for (int i = 0; i < nq; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[200005], pos[200005], a[200005], c[200005];
int n, m;
struct node {
int i, l, r;
bool operator<(const node &a) const { return l < a.l; }
} es[200005], et[200005];
int lowbit(int x) { return x & (-x); }
void update(int x) {
int i;
for (i = x; i <= n; i += lowbit(i)) c[i]++;
}
int getsum(int x) {
int i, sum = 0;
for (i = x; i > 0; i -= lowbit(i)) sum += c[i];
return sum;
}
void init() {
scanf("%d%d", &n, &m);
int i;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
int j, k;
for (i = 1; i <= m; i++) {
scanf("%d%d", &j, &k);
es[i].i = i, es[i].l = j, es[i].r = k;
et[i].i = i, et[i].l = k, et[i].r = j;
}
sort(es + 1, es + 1 + m);
sort(et + 1, et + 1 + m);
}
void solve() {
int i, j, k, p;
for (i = j = k = 1; i <= n; i++) {
for (; j <= m; j++) {
if (es[j].l != i) break;
ans[es[j].i] -= getsum(es[j].r) - getsum(es[j].l - 1);
}
for (p = a[i]; p <= n; p += a[i]) update(pos[p]);
for (; k <= m; k++) {
if (et[k].l != i) break;
ans[et[k].i] += getsum(et[k].l) - getsum(et[k].r - 1);
}
}
for (i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 2e5 + 5;
int tree[SIZE], n, m, N, p[SIZE], indx[SIZE], res[SIZE];
pair<int, int> divP[18 * SIZE];
struct data {
int u, v, p;
} queries[SIZE];
bool compare(const pair<int, int> &a, const pair<int, int> &b) {
return a.second < b.second;
}
bool compareD(const data &a, const data &b) { return a.v < b.v; }
void Input() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> p[i];
indx[p[i]] = i;
}
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
queries[i] = {x, y, i};
}
}
void make_Div_pair() {
for (int i = 1; i <= n; i++) {
for (int pj = p[i]; pj <= n; pj += p[i]) {
int j = indx[pj];
divP[++N] = (i < j) ? make_pair(i, j) : make_pair(j, i);
}
}
}
int sum(int u) {
int temp = 0;
for (; u > 0; u -= (u & -u)) temp += tree[u];
return temp;
}
int get_sum(int u, int v) { return sum(v) - sum(u - 1); }
void update(int u, int val) {
for (; u <= n; u += (u & -u)) tree[u] += val;
}
void Solve() {
make_Div_pair();
sort(divP + 1, divP + N + 1, compare);
sort(queries + 1, queries + m + 1, compareD);
int now = 1;
for (int i = 1; i <= m; i++) {
int u = queries[i].u;
int v = queries[i].v;
int p = queries[i].p;
while (now <= N && divP[now].second <= v) {
update(divP[now].first, 1);
now++;
}
res[p] = get_sum(u, v);
}
}
void Print() {
for (int i = 1; i <= m; i++) cout << res[i] << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Input();
Solve();
Print();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int bit[MAXN + 100], ans[MAXN], _pos[MAXN];
vector<pair<int, int> > _query[MAXN];
vector<int> d[MAXN];
void upd(int id) {
for (; id <= MAXN; id += id & (-id)) bit[id]++;
return;
}
int get(int id) {
int now = 0;
for (; id > 0; id = id & (id - 1)) now += bit[id];
return now;
}
int main() {
ios::sync_with_stdio(0);
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
_pos[x] = i + 1;
}
for (int i = 0; i < q; i++) {
int x, y;
cin >> x >> y;
_query[y].push_back({i, x});
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
d[max(_pos[i], _pos[j])].push_back(min(_pos[i], _pos[j]));
for (int i = 1; i <= n; i++) {
for (auto j : d[i]) upd(j);
for (auto j : _query[i]) ans[j.first] = get(i) - get(j.second - 1);
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct BinaryIndexedTree {
long long c[210000], n;
inline void init() { memset(c, 0, sizeof(c)); }
inline int lowbit(int x) { return x & -x; }
inline void update(int x, int k) {
while (x <= n) {
c[x] += k;
x += lowbit(x);
}
}
inline long long getsum(int x) {
long long ans = 0;
while (x > 0) {
ans += c[x];
x -= lowbit(x);
}
return ans;
}
} BIT;
struct query {
int l, r, id;
} q1[210000], q2[210000];
int n, m, a[210000], pos[210000];
long long ans[210000];
bool cmp1(query a, query b) { return a.l == b.l ? a.r < b.r : a.l < b.l; }
bool cmp2(query a, query b) { return a.r == b.r ? a.l < b.l : a.r < b.r; }
int main() {
while (~scanf("%d%d", &n, &m)) {
BIT.n = n;
BIT.init();
memset(ans, 0, sizeof(ans));
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", &q1[i].l, &q1[i].r);
q2[i] = q1[i];
q1[i].id = q2[i].id = i;
}
int i, j, k;
sort(q1 + 1, q1 + 1 + m, cmp1);
sort(q2 + 1, q2 + 1 + m, cmp2);
for (i = 1, j = 1, k = 1; i <= n; i++) {
for (; q1[j].l == i && j <= m; j++)
ans[q1[j].id] -= BIT.getsum(q1[j].r) - BIT.getsum(q1[j].l - 1);
for (int p = 1; a[i] * p <= n; p++) BIT.update(pos[a[i] * p], 1);
for (; q2[k].r == i && k <= m; k++)
ans[q2[k].id] += BIT.getsum(q2[k].r) - BIT.getsum(q2[k].l - 1);
}
for (int i = 1; i <= m; i++) printf("%I64d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, pos[200005], res[200005];
vector<int> V[200005];
vector<pair<int, int> > query[200005];
int bit[200005];
void upd(int p) {
while (p <= n) {
bit[p]++;
p += p & (-p);
}
return;
}
int f(int x) {
int ans = 0;
while (x) {
ans += bit[x];
x -= x & (-x);
}
return ans;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = (1); i <= (n); i++) {
int x;
scanf("%d", &x);
pos[x] = i;
}
for (int i = (1); i <= (n); i++)
for (int j = i; j <= n; j += i) {
int l = pos[i];
int r = pos[j];
if (l > r) swap(l, r);
V[l].push_back(r);
}
for (int i = (1); i <= (m); i++) {
int l, r;
scanf("%d %d", &l, &r);
query[l].push_back(make_pair(r, i));
}
for (int i = (n); i >= (1); i--) {
for (int j = (0); j <= ((int)V[i].size() - 1); j++) upd(V[i][j]);
for (int j = (0); j <= ((int)query[i].size() - 1); j++)
res[query[i][j].second] = f(query[i][j].first);
}
for (int i = (1); i <= (m); i++) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e5 + 2;
int t, n, k, q, l, r, w;
int ans[mxn], cnt[mxn], ind[mxn];
vector<int> v, adj[mxn], jda[mxn], a;
bool b[mxn];
struct item {
int r, l, i;
};
struct segtree {
int size;
vector<int> v;
void init(int n) {
size = 1;
while (size < n) {
size *= 2;
}
v.assign(2 * size, 0);
}
void opr(int i, int k, int x, int lx, int rx) {
if (lx + 1 == rx) {
v[x] += k;
return;
}
int m = (lx + rx) / 2;
if (i < m) {
opr(i, k, 2 * x + 1, lx, m);
} else {
opr(i, k, 2 * x + 2, m, rx);
}
v[x] = v[2 * x + 1] + v[2 * x + 2];
}
void opr(int i, int k) { opr(i, k, 0, 0, size); }
int calc(int l, int r, int x, int lx, int rx) {
if (rx <= l || r <= lx) {
return 0;
}
if (l <= lx && rx <= r) {
return v[x];
}
int m = (lx + rx) / 2;
int ans1 = calc(l, r, 2 * x + 1, lx, m);
int ans2 = calc(l, r, 2 * x + 2, m, rx);
return ans1 + ans2;
}
int calc(int l, int r) { return calc(l, r, 0, 0, size); }
};
vector<item> fq;
bool comp(item a, item b) {
if (a.r < b.r) {
return true;
} else if (a.r > b.r) {
return false;
}
if (a.l < b.l) {
return true;
} else if (a.l > b.l) {
return false;
}
if (a.i < b.i) {
return true;
} else if (a.i > b.i) {
return false;
}
return true;
}
void input() {
v.clear();
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> w;
ind[w] = i;
v.push_back(w);
}
for (int i = 0; i < q; i++) {
cin >> l >> r;
l--;
fq.push_back({r, l, i});
}
}
void solve() {
segtree st;
st.init(n);
for (int i = 1; i <= n / 2; i++) {
for (int j = i + i; j <= n; j += i) {
adj[j].push_back(i);
jda[i].push_back(j);
}
}
sort(fq.begin(), fq.end(), comp);
for (int j = 0; j < fq[0].r; j++) {
b[v[j]] = 1;
for (int w = 0; w < adj[v[j]].size(); w++) {
int x = adj[v[j]][w];
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
for (int w = 0; w < jda[v[j]].size(); w++) {
int x = jda[v[j]][w];
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
}
for (int i = 0; i < a.size(); i++) {
st.opr(ind[a[i]], cnt[a[i]]);
cnt[a[i]] = 0;
}
a.clear();
ans[fq[0].i] = st.calc(fq[0].l, fq[0].r) + (fq[0].r - fq[0].l);
for (int i = 1; i < q; i++) {
for (int j = fq[i - 1].r; j < fq[i].r; j++) {
b[v[j]] = 1;
for (int w = 0; w < adj[v[j]].size(); w++) {
int x = adj[v[j]][w];
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
for (int w = 0; w < jda[v[j]].size(); w++) {
int x = jda[v[j]][w];
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
}
for (int j = 0; j < a.size(); j++) {
st.opr(ind[a[j]], cnt[a[j]]);
cnt[a[j]] = 0;
}
a.clear();
ans[fq[i].i] = st.calc(fq[i].l, fq[i].r) + (fq[i].r - fq[i].l);
}
for (int i = 0; i < q; i++) {
cout << ans[i] << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
input(), solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int bit[maxn];
int vis[maxn];
int a[maxn];
long long c[maxn];
struct pi {
int l;
int id;
} pp;
int low(int p) { return p & (-p); };
void merg(int p, int n, int k) {
while (p <= n) {
bit[p] += k;
p = p + low(p);
}
}
long long sum(int p) {
long long s = 0;
while (p > 0) {
s += bit[p];
p = p - low(p);
}
return s;
}
vector<pi> g[maxn];
int main() {
int i, j, n, m;
cin >> n >> m;
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
pp.id = i;
pp.l = a;
g[b].push_back(pp);
}
memset(vis, -1, sizeof(vis));
for (i = 1; i <= n; i++) {
vis[a[i]] = i;
for (j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
if (vis[j] != -1) {
merg(vis[j], n, 1);
}
if (j * j != a[i]) {
if (vis[a[i] / j] != -1) {
merg(vis[a[i] / j], n, 1);
}
}
}
}
for (j = 2 * a[i]; j <= n; j += a[i]) {
if (vis[j] != -1) {
merg(vis[j], n, 1);
}
}
int p = g[i].size();
for (j = 0; j < p; j++) {
c[g[i][j].id] = sum(i) - sum(g[i][j].l - 1);
}
}
for (i = 0; i < m; i++) {
printf("%I64d\n", c[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
long long mod = 1000000007;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a * (b / gcd(a, b)); }
bool is_vowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') return 1;
return 0;
}
double getDistance(double x1, double y1, double x2, double y2) {
return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}
long long extended_euclidean(long long a, long long b, long long &x,
long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long g = extended_euclidean(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
long long power(long long base, long long p) {
if (p == 1) return base;
if (!p) return 1ll;
long long ret = power(base, p / 2);
ret *= ret;
ret %= mod;
if (p & 1) ret *= base;
return ret % mod;
}
vector<int> v[N];
int arr[N], pos[N];
int bit[N], n;
void update(int idx, int val) {
while (idx <= n) {
bit[idx] += val;
idx += idx & -idx;
}
}
int get(int idx) {
int ret = 0;
while (idx > 0) {
ret += bit[idx];
idx -= idx & -idx;
}
return ret;
}
int sol[N];
vector<pair<int, int> > query[N];
int main() {
int q;
scanf("%d %d", &n, &q);
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)
v[min(pos[i], pos[j])].push_back(max(pos[i], pos[j])),
update(max(pos[i], pos[j]), 1);
for (int i = (1); i <= (q); ++i) {
int a, b;
scanf("%d %d", &a, &b);
query[a].push_back(pair<int, int>(b, i));
}
for (int i = (1); i <= (n); ++i) {
for (int j = (0); j <= ((int)query[i].size() - 1); ++j) {
sol[query[i][j].second] = get(query[i][j].first);
}
for (int j = (0); j <= ((int)v[i].size() - 1); ++j) update(v[i][j], -1);
}
for (int i = (1); i <= (q); ++i) printf("%d\n", sol[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long powmod(long long base, long long exponent, long long mod) {
long long ans = 1;
while (exponent) {
if (exponent & 1) ans = (ans * base) % mod;
base = (base * base) % mod;
exponent /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
const int upperlimit = 2e5 + 100;
const int mod = 1e9 + 7;
struct range {
int ind, l, r;
};
bool cmp(range a, range b) { return (a.r < b.r); }
int segtree[4 * upperlimit];
int arr[upperlimit];
int location[upperlimit];
range queries[upperlimit];
vector<int> factors[upperlimit];
vector<int> multiples[upperlimit];
int ans[upperlimit];
void update(int node, int i, int j, int ind) {
segtree[node]++;
if (i == j) return;
int mid = (i + j) / 2;
if (ind <= mid)
update(2 * node, i, mid, ind);
else
update(2 * node + 1, mid + 1, j, ind);
}
int query(int node, int i, int j, int l, int r) {
if ((i > r) || (l > j) || (i > j) || (l > r)) return 0;
if ((i >= l) && (j <= r)) return segtree[node];
int mid = (i + j) / 2;
return (query(2 * node, i, mid, l, r) +
query(2 * node + 1, mid + 1, j, l, r));
}
int main() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
location[arr[i]] = i;
}
for (int i = 1; i <= m; i++) {
queries[i].ind = i;
scanf("%d", &queries[i].l);
scanf("%d", &queries[i].r);
}
sort(queries + 1, queries + m + 1, cmp);
for (int i = 1; i <= n; i++) {
multiples[i].push_back(i);
for (int j = 2 * i; j <= n; j += i) {
multiples[i].push_back(j);
factors[j].push_back(i);
}
}
int j = 1;
for (int i = 1; i <= n; i++) {
for (int k = 0; k < multiples[arr[i]].size(); k++)
if (location[multiples[arr[i]][k]] <= i)
update(1, 1, n, location[multiples[arr[i]][k]]);
for (int k = 0; k < factors[arr[i]].size(); k++)
if (location[factors[arr[i]][k]] <= i)
update(1, 1, n, location[factors[arr[i]][k]]);
while (queries[j].r == i) {
ans[queries[j].ind] = query(1, 1, n, queries[j].l, i);
j++;
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n, m;
int seg[maxn << 2];
vector<int> divisiors[maxn], ansqrs[maxn];
vector<pair<int, int>> qrs;
int ans[maxn];
int a[maxn], pos[maxn];
void change(int pos, int id = 1, int s = 0, int e = n) {
if (e - s == 1) {
seg[id]++;
return;
}
int mid = (s + e) >> 1;
if (pos < mid)
change(pos, id << 1, s, mid);
else
change(pos, id << 1 | 1, mid, e);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
int get(int l, int r, int id = 1, int s = 0, int e = n) {
if (e <= l || s >= r) return 0;
if (e <= r && s >= l) return seg[id];
int mid = (s + e) >> 1;
return get(l, r, id << 1, s, mid) + get(l, r, id << 1 | 1, mid, e);
}
int main() {
cin >> 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) divisiors[j].push_back(i);
}
for (int i = 0; i < m; i++) {
int l, r;
scanf("%d%d", &l, &r);
l--;
qrs.push_back(make_pair(l, r));
ansqrs[r - 1].push_back(i);
}
for (int i = 0; i < n; i++) {
for (int j = a[i]; j <= n; j += a[i]) {
if (pos[j] <= i) change(pos[j]);
}
for (int div : divisiors[a[i]]) {
if (pos[div] < i) change(pos[div]);
}
for (int id : ansqrs[i]) ans[id] = get(qrs[id].first, qrs[id].second);
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
int A[200002], X[200002], Y[200002], pos[200002];
long long result[200002];
vector<int> V[200002];
int is[200002];
long long AIB[200002];
inline bool compare(const int& i1, const int& i2) { return X[i1] < X[i2]; }
void update(int pos, int val) {
for (; pos <= 200000; pos += pos & -pos) AIB[pos] += val;
}
long long query(int pos) {
long long sum = 0;
for (; pos >= 1; pos -= pos & -pos) sum += AIB[pos];
return sum;
}
int main() {
cin >> N >> M;
for (int i = 1; i <= N; ++i) {
cin >> A[i];
is[A[i]] = i;
}
for (int i = 1; i <= M; ++i) {
cin >> X[i] >> Y[i];
pos[i] = i;
}
sort(pos + 1, pos + M + 1, compare);
for (int i = 1; i <= N; ++i) {
for (int j = 2 * A[i]; j <= N; j += A[i]) {
if (is[j] < i) {
V[is[j]].push_back(i);
update(i, 1);
} else {
V[i].push_back(is[j]);
update(is[j], 1);
}
}
}
int now = 1;
for (int i = 1; i <= N; ++i) {
while (now <= M && X[pos[now]] == i) {
result[pos[now]] = query(Y[pos[now]]) + (Y[pos[now]] - X[pos[now]] + 1);
++now;
}
for (vector<int>::iterator it = V[i].begin(); it != V[i].end(); ++it)
update(*it, -1);
}
for (int i = 1; i <= M; ++i) cout << result[i] << '\n';
}
|
#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];
pair<long long, long long> divP[3600 * 1000 + 9];
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[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;
int at[200010];
struct Event {
int x, y, flag;
Event() {}
Event(int x0, int y0, int flag0) : x(x0), y(y0), flag(flag0) {}
} pp[1000010];
int qq;
bool cmp(Event a, Event b) {
if (a.y == b.y) return a.flag < b.flag;
return a.y < b.y;
}
int sum[200010 << 2];
void pushup(int rt) { sum[rt] = sum[rt << 1] + sum[rt << 1 | 1]; }
void update(int p, int add, int l, int r, int rt) {
if (l == r) {
sum[rt] += add;
return;
}
int m = (l + r) / 2;
if (p <= m)
update(p, add, l, m, rt << 1);
else
update(p, add, m + 1, r, rt << 1 | 1);
pushup(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return sum[rt];
int m = (l + r) / 2;
int ret = 0;
if (L <= m) ret += query(L, R, l, m, rt << 1);
if (R > m) ret += query(L, R, m + 1, r, rt << 1 | 1);
return ret;
}
struct Edge {
int v, next;
} edge[3000010];
int head[200010];
int pos;
void insert(int x, int y) {
edge[pos].v = y;
edge[pos].next = head[x];
head[x] = pos++;
}
int ans[200010];
int main() {
int n, m;
scanf("%d %d", &n, &m);
memset(at, -1, sizeof(at));
for (int i = 1; i <= n; i++) {
int s;
scanf("%d", &s);
at[s] = i;
}
memset(head, 0, sizeof(head));
pos = 1;
qq = 0;
for (int i = 1; i <= n; i++) {
int x = at[i];
if (x == -1) continue;
for (int j = i; j <= n; j += i) {
int y = at[j];
if (y != -1) {
int xx = x;
int yy = y;
if (xx > yy) swap(xx, yy);
insert(yy, xx);
}
}
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d %d", &x, &y);
pp[qq++] = Event(x, y, i);
}
sort(pp, pp + qq, cmp);
memset(sum, 0, sizeof(sum));
int j = 0;
for (int i = 0; i < qq; i++) {
while (j <= pp[i].y) {
for (int k = head[j]; k; k = edge[k].next) {
int v = edge[k].v;
update(v, 1, 1, n, 1);
}
j++;
}
ans[pp[i].flag] = query(pp[i].x, n, 1, n, 1);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = int(2e5) + 1;
long long st[MAXN * 4], ans[MAXN];
int A[MAXN], N, M, pos[MAXN];
struct datapos {
vector<pair<int, int>> q;
vector<int> lefties;
} d[MAXN];
void st_upd(int si, int ss, int se, int pos) {
while (1) {
assert(ss <= pos && pos <= se);
st[si]++;
if (ss == se) break;
int mid = (ss + se) / 2;
if (pos <= mid) {
si = si * 2;
se = mid;
} else {
si = si * 2 + 1;
ss = mid + 1;
}
}
}
long long st_que(int si, int ss, int se, int left, int right) {
assert(ss <= se);
assert(left <= right);
if (left > se || right < ss) return 0;
if (left <= ss && se <= right) return st[si];
int mid = (ss + se) / 2;
return st_que(si * 2, ss, mid, left, right) +
st_que(si * 2 + 1, mid + 1, se, left, right);
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", A + i);
pos[A[i]] = i;
}
for (int queryi = 0, left, right; queryi < M; queryi++) {
scanf("%d%d", &left, &right);
d[right].q.push_back({left, queryi});
}
for (int num = 1; num <= N; num++) {
for (int multi = num; multi <= N; multi += num) {
int left = min(pos[num], pos[multi]);
int right = max(pos[num], pos[multi]);
d[right].lefties.push_back(left);
}
}
for (int posi = 1; posi <= N; posi++) {
for (auto left : d[posi].lefties) st_upd(1, 1, N, left);
for (auto qu : d[posi].q) ans[qu.second] = st_que(1, 1, N, qu.first, posi);
}
for (int i = 0; i < M; i++) printf("%lld\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int mx = 2e5 + 5;
int n, m;
int p[mx], rev[mx];
vector<int> vec[mx];
vector<pair<int, int> > q[mx];
int ans[mx];
int tree[mx * 4];
void update(int node, int l, int r, int b, int x) {
if (l == r) {
tree[node] += x;
return;
}
int mid = (l + r) / 2;
if (mid >= b)
update(2 * node, l, mid, b, x);
else
update(2 * node + 1, mid + 1, r, b, x);
tree[node] = tree[2 * node] + tree[2 * node + 1];
}
int query(int node, int l, int r, int b, int e) {
if (l > e || r < b) return 0;
if (l >= b && r <= e) return tree[node];
int mid = (l + r) / 2;
return query(2 * node, l, mid, b, e) + query(2 * node + 1, mid + 1, r, b, e);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
rev[p[i]] = i;
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
int u = rev[i], v = rev[j];
if (u > v) swap(u, v);
vec[v].push_back(u);
}
}
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
q[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; ++i) {
while (!vec[i].empty()) {
update(1, 1, n, vec[i].back(), 1);
vec[i].pop_back();
}
while (!q[i].empty()) {
pair<int, int> p = q[i].back();
q[i].pop_back();
int l = p.first, r = i, idx = p.second;
ans[idx] = query(1, 1, n, l, r);
}
}
for (int 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, long long val) {
while (idx <= n) {
BIT[idx] += val;
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, 1);
}
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;
const int N = 200200;
const int mod = 1e9 + 7;
const int M = 2e9 + 1;
const int K = 50;
int n, m, res[N], cnt[N], p[N];
int pos[N];
int root[N];
int sz;
vector<pair<int, int> > g[N], e[N];
int t[4 * N];
int ans[N];
inline void upd(int v, int tl, int tr, int p) {
if (tl == tr) {
t[v]++;
return;
}
int tm = tl + tr >> 1;
if (p <= tm)
upd(v + v, tl, tm, p);
else
upd(v + v + 1, tm + 1, tr, p);
t[v] = t[v + v] + t[v + v + 1];
}
inline int get(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t[v];
int tm = tl + tr >> 1;
return get(v + v, tl, tm, l, min(r, tm)) +
get(v + v + 1, tm + 1, tr, max(tm + 1, l), r);
}
inline void solve() {
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
cin >> p[i];
pos[p[i]] = i;
}
for (int i = 1; i <= m; ++i) {
int l, r;
cin >> l >> r;
g[r].push_back(make_pair(l, i));
e[l].push_back(make_pair(r, i));
}
for (int i = 1; i <= n; ++i) {
for (pair<int, int> w : e[i]) {
int id = w.second, r = w.first;
ans[id] -= get(1, 1, n, i, r);
}
for (int j = p[i]; j <= n; j += p[i]) upd(1, 1, n, pos[j]);
for (pair<int, int> w : g[i]) {
int id = w.second, l = w.first;
ans[id] += get(1, 1, n, l, i);
}
}
for (int i = 1; i <= m; ++i) cout << ans[i] << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
t = 1;
while (t--) solve();
return 0;
}
|
#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 start[333888 * 2], 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(start, 0, sizeof(start));
;
};
{
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]]; x < 333888 * 2; x += x & -x) start[x] += 1;
};
{
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;
long long n, m, u, v, i, f[1000100], a[1000100], j, k;
struct g {
long long l, r, id;
} d[1000100];
long long c[1000100], ans[1000100];
long long lowbit(long long x) { return (x & (-x)); }
void cc(long long x, long long w) {
while (x <= n) {
c[x] += w;
x = x + lowbit(x);
}
}
long long sum(long long x) {
long long ans = 0;
while (x) {
ans = ans + c[x];
x = x - lowbit(x);
}
return ans;
}
bool cmp1(g a, g b) { return a.l < b.l; }
bool cmp2(g a, g b) { return a.r > b.r; }
int main() {
scanf("%I64d%I64d", &n, &m);
for (i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
f[a[i]] = i;
}
for (i = 1; i <= n; i++)
for (j = i; j <= n; j = j + i) cc(f[j], 1);
for (i = 1; i <= m; i++) {
scanf("%I64d%I64d", &d[i].l, &d[i].r);
d[i].id = i;
}
sort(d + 1, d + 1 + m, cmp1);
k = 1;
for (i = 1; i <= n; i++) {
while ((d[k].l == i) && (k <= m)) {
ans[d[k].id] = sum(d[k].r) - sum(i - 1);
k++;
}
for (j = a[i]; j <= n; j = j + a[i]) cc(f[j], -1);
}
sort(d + 1, d + 1 + m, cmp2);
k = 1;
for (i = n; i >= 1; i--) {
while ((d[k].r == i) && (k <= m)) {
ans[d[k].id] = ans[d[k].id] - (sum(n - d[k].l + 1) - sum(n - d[k].r));
k++;
}
for (j = a[i]; j <= n; j = j + a[i]) cc(n - f[j] + 1, 1);
}
for (i = 1; i <= m; i++) printf("%I64d\n", ans[i]);
}
|
#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 + 10;
int n, m;
int a[N], ct[N];
int pos[N], l[N], r[N], ans[N];
vector<int> ll[N], rr[N];
void init() {
memset(a, 0, sizeof(a));
memset(ct, 0, sizeof(ct));
memset(pos, 0, sizeof(pos));
}
int lowbit(int x) { return x & (-x); }
void add(int x) {
while (x <= n) {
ct[x]++;
x += lowbit(x);
}
}
int getsum(int x) {
int ans = 0;
while (x > 0) {
ans += ct[x];
x -= lowbit(x);
}
return ans;
}
int main() {
while (~scanf("%d%d", &n, &m)) {
init();
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", &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]] -= getsum(r[ll[i][j]]) - getsum(i - 1);
}
for (int j = 1; j * a[i] <= n; j++) {
add(pos[j * a[i]]);
}
for (int j = 0; j < rr[i].size(); j++) {
ans[rr[i][j]] += getsum(i) - getsum(l[rr[i][j]] - 1);
}
}
for (int i = 1; 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 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;
int a[200010], b[200010], n, ans[200010], po[200010];
struct node {
int l, r, id;
} c[200010], d[200010];
void mf(int x, int y) {
for (; x <= n; x += x & (-x)) b[x] += y;
}
int qq(int x) {
int ans = 0;
for (; x > 0; x -= x & (-x)) ans += b[x];
return ans;
}
int cmp(node a, node b) { return a.l < b.l; }
int cmp1(node a, node b) { return a.r < b.r; }
int main() {
int i, j, l, m, p, q, r, t, k;
while (~scanf("%d %d", &n, &m)) {
memset(ans, 0, sizeof(ans));
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
po[a[i]] = i;
}
for (i = 0; i < m; i++) {
scanf("%d %d", &c[i].l, &c[i].r);
c[i].id = d[i].id = i;
d[i].l = c[i].l;
d[i].r = c[i].r;
}
sort(c, c + m, cmp);
sort(d, d + m, cmp1);
for (i = 1, j = k = 0; i <= n; i++) {
for (; j < m && c[j].l == i; j++)
ans[c[j].id] -= qq(c[j].r) - qq(c[j].l - 1);
for (l = a[i]; l <= n; l += a[i]) mf(po[l], 1);
for (; k < m && d[k].r == i; k++)
ans[d[k].id] += qq(d[k].r) - qq(d[k].l - 1);
}
for (i = 0; i < m; i++) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[200100];
vector<int> pos[200100];
int p[200100];
int help[200100];
int t[800100];
int sz = 1;
struct item {
int x, num;
bool nach;
item() {}
item(int X, bool Nach, int Num) {
x = X;
nach = Nach;
num = Num;
};
};
inline bool cmp(const item& a, const item& b) {
return (a.x < b.x || (a.x == b.x && a.nach && !b.nach));
}
item ev[400100];
void inc(int v) {
while (v > 0) {
t[v]++;
v >>= 1;
}
}
int sum(int i, int x, int y, int l, int r) {
if (x > r || y < l) return 0;
if (x >= l && y <= r) return t[i];
return sum(2 * i, x, (x + y) >> 1, l, r) +
sum(2 * i + 1, ((x + y) >> 1) + 1, y, l, r);
}
pair<int, int> z[200100];
int ans[200100];
int main() {
cin >> n >> m;
while (sz < n) sz *= 2;
memset(t, 0, sizeof(t));
for (int i = 0; i < int(n); i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < int(n + 1); i++) p[a[i]] = i + 1;
for (int i = 0; i < int(n); i++) {
for (int j = 1; j * j <= a[i]; ++j) {
if (a[i] % j == 0) {
pos[i].push_back(p[j]);
if (a[i] / j != j) pos[i].push_back(p[a[i] / j]);
}
}
}
for (int i = 0; i < int(m); i++) {
int l, r;
scanf("%d %d", &l, &r);
l--;
r--;
z[i] = make_pair(l, r);
ev[2 * i] = item(l, true, i);
ev[2 * i + 1] = item(r, false, i);
}
sort(ev, ev + 2 * m, cmp);
for (int i = 0, k = 0; i < 2 * m; ++k) {
int j = i;
for (; j < 2 * m && ev[j].x == k && (ev[j].nach == true); ++j) {
help[ev[j].num] = sum(1, 1, sz, ev[j].x + 1, z[ev[j].num].second + 1);
}
for (int k1 = 0; k1 < int(pos[k].size()); k1++) {
inc(sz + pos[k][k1] - 1);
}
for (; j < 2 * m && ev[j].x == k; ++j) {
ans[ev[j].num] =
sum(1, 1, sz, z[ev[j].num].first + 1, ev[j].x + 1) - help[ev[j].num];
}
i = j;
}
for (int i = 0; i < int(m); i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 100;
int fen[MAXN];
void upd(int a) {
for (a++; a < MAXN; a += (a & -a)) fen[a]++;
}
int get(int a) {
int res = 0;
for (a++; a > 0; a -= (a & -a)) res += fen[a];
return res;
}
vector<int> ver[MAXN];
vector<pair<int, int>> que[MAXN];
int p[MAXN];
int res[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
int qn;
cin >> qn;
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 + i; j <= n; j += i)
if (p[i] < p[j])
ver[p[j]].push_back(p[i]);
else
ver[p[i]].push_back(p[j]);
for (int i = 0; i < qn; i++) {
int x, y;
cin >> x >> y;
que[y].push_back({x, i});
}
for (int i = 1; i <= n; i++) {
upd(i);
for (auto u : ver[i]) upd(u);
for (auto u : que[i]) res[u.second] = get(i) - get(u.first - 1);
}
for (int i = 0; i < qn; i++) cout << res[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 200005;
int n, m;
int a[Maxn], Pos[Maxn], bit[Maxn];
int ans[Maxn];
int lowbit(int x) { return x & (-x); }
int sum(int x) {
int res = 0;
while (x > 0) {
res += bit[x];
x -= lowbit(x);
}
return res;
}
void update(int x, int val) {
while (x <= n) {
bit[x] += val;
x += lowbit(x);
}
}
struct node {
int pos, l, r;
} q1[Maxn], q2[Maxn];
bool cmp(node a, node b) { return a.l < b.l; }
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", &q1[i].l, &q1[i].r);
q2[i].l = q1[i].r;
q2[i].r = q1[i].l;
q1[i].pos = q2[i].pos = i;
}
sort(q1 + 1, q1 + m + 1, cmp);
sort(q2 + 1, q2 + m + 1, cmp);
for (int i = 1, j = 1, k = 1; i <= n; ++i) {
while (j <= m && q1[j].l == i) {
ans[q1[j].pos] -= sum(q1[j].r) - sum(q1[j].l - 1);
++j;
}
for (int p = a[i]; p <= n; p += a[i]) update(Pos[p], 1);
while (k <= m && q2[k].l == i) {
ans[q2[k].pos] += sum(q2[k].l) - sum(q2[k].r - 1);
++k;
}
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXV = 2e5 + 1;
struct fen {
int n;
vector<int> table;
void update(int k, int v) {
k++;
for (; k <= n; k += (k & (-k))) table[k] += v;
}
int query(int k) {
int rs = 0;
for (; k; k -= (k & (-k))) rs += table[k];
return rs;
}
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> nms(MAXV, -1);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
nms[a] = i;
}
vector<pair<int, int>> ps;
for (int i = 1; i < MAXV; i++) {
if (nms[i] == -1) continue;
for (int j = 0; j < MAXV; j += i) {
if (nms[j] == -1) continue;
ps.emplace_back(min(nms[i], nms[j]), max(nms[i], nms[j]));
}
}
sort(ps.begin(), ps.end());
vector<vector<int>> lp(n);
vector<int> rs(m);
vector<int> res(m);
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
rs[i] = b;
lp[a].push_back(i);
}
fen ft;
ft.n = n;
ft.table.resize(n + 1);
for (auto p : ps) ft.update(p.second, 1);
int l = 0;
for (int i = 0; i < n; i++) {
for (auto j : lp[i]) {
res[j] = ft.query(rs[j] + 1);
}
while (l < (int)ps.size() && ps[l].first <= i) {
ft.update(ps[l].second, -1);
l++;
}
}
for (auto i : res) cout << i << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int const maxn = 2e5 + 10;
int n, q, pos[maxn], a[maxn];
vector<int> p[maxn];
long long ans[maxn], bit[maxn];
void add(int idx, int val) {
while (idx < maxn) bit[idx] += val, idx += (idx & -idx);
}
long long get(int idx) {
long long ret = 0;
while (idx > 0) ret += bit[idx], idx -= (idx & -idx);
return ret;
}
struct qry {
int l, r, id;
qry(int a, int b, int c) : l(a), r(b), id(c) {}
};
bool operator<(qry A, qry B) { return A.r < B.r; }
vector<qry> Q;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= (int)n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1; i <= (int)n; i++)
for (int j = i; j < maxn; j += i)
if (pos[j]) {
if (pos[j] < pos[i])
p[pos[i]].push_back(pos[j]);
else
p[pos[j]].push_back(pos[i]);
}
for (int i = 1; i <= (int)q; i++) {
int l, r;
scanf("%d%d", &l, &r);
Q.push_back(qry(l, r, i));
}
sort((Q).begin(), (Q).end());
int pt = 0;
for (int i = 1; i <= (int)n; i++) {
if (pt >= q) break;
for (auto j : p[pos[a[i]]]) add(j, 1);
while (Q[pt].r == i) {
int id = Q[pt].id;
ans[id] = get(i) - get(Q[pt].l - 1);
pt++;
if (pt >= q) break;
}
}
for (int i = 1; i <= (int)q; i++) printf("%I64d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> divisor[200035];
int cc = 0;
vector<int> con[2500006];
int pos[2500006];
void div() {
int n = 200005;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j = j + i) {
divisor[j].push_back(i);
int aa = pos[j];
int bb = pos[i];
if (aa > bb) swap(aa, bb);
con[aa].push_back(bb);
}
}
}
bool compare(pair<int, pair<int, int>> a, pair<int, pair<int, int>> b) {
return a.first > b.first;
}
int tree[2500006 * 3];
int query(int node, int b, int e, int ll, int rr) {
if (rr < b || ll > e) return 0;
if (ll <= b && e <= rr) return tree[node];
int left = node * 2;
int right = left + 1;
int mid = (b + e) / 2;
int p1 = query(left, b, mid, ll, rr);
int p2 = query(right, mid + 1, e, ll, rr);
return p1 + p2;
}
void update(int node, int b, int e, int pos) {
if (pos < b || e < pos) return;
if (b == pos && e == pos) {
tree[node]++;
return;
}
int left = node * 2;
int right = left + 1;
int mid = (b + e) / 2;
update(left, b, mid, pos);
update(right, mid + 1, e, pos);
tree[node] = tree[left] + tree[right];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
scanf("%d%d", &n, &m);
int a[n + 5];
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
div();
vector<pair<int, pair<int, int>>> query1;
for (int i = 0; i < m; i++) {
int aa, bb;
scanf("%d%d", &aa, &bb);
query1.push_back(make_pair(aa, make_pair(bb, i)));
}
sort(query1.begin(), query1.end(), compare);
int range = n;
int anslist[m + 5];
for (int i = 0; i < query1.size(); i++) {
int x = query1[i].first;
int y = query1[i].second.first;
int id = query1[i].second.second;
for (int j = x; j <= range; j++) {
for (int k = 0; k < con[j].size(); k++) {
int now = con[j][k];
update(1, 1, n, now);
}
}
int ans = query(1, 1, n, x, y);
anslist[id] = ans;
range = x - 1;
}
for (int i = 0; i < m; i++) {
printf("%d\n", anslist[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 2e5 + 10;
int t, n, k, q, l, r, ans[mxn], cnt[mxn], w, ind[mxn];
vector<int> v, adj[mxn], jda[mxn], a;
bool b[mxn];
struct item {
int r, l, i;
};
struct segtree {
int size;
vector<int> v;
void init(int n) {
size = 1;
while (size < n) {
size *= 2;
}
v.assign(2 * size, 0);
}
void opr(int i, int k, int x, int lx, int rx) {
if (lx + 1 == rx) {
v[x] += k;
return;
}
int m = (lx + rx) / 2;
if (i < m) {
opr(i, k, 2 * x + 1, lx, m);
} else {
opr(i, k, 2 * x + 2, m, rx);
}
v[x] = v[2 * x + 1] + v[2 * x + 2];
}
void opr(int i, int k) { opr(i, k, 0, 0, size); }
int calc(int l, int r, int x, int lx, int rx) {
if (rx <= l || r <= lx) {
return 0;
}
if (l <= lx && rx <= r) {
return v[x];
}
int m = (lx + rx) / 2;
int ans1 = calc(l, r, 2 * x + 1, lx, m);
int ans2 = calc(l, r, 2 * x + 2, m, rx);
return ans1 + ans2;
}
int calc(int l, int r) { return calc(l, r, 0, 0, size); }
};
vector<item> fq;
bool comp(item a, item b) {
if (a.r < b.r) {
return true;
} else if (a.r > b.r) {
return false;
}
if (a.l < b.l) {
return true;
} else if (a.l > b.l) {
return false;
}
if (a.i < b.i) {
return true;
} else if (a.i > b.i) {
return false;
}
return true;
}
void input() {
v.clear();
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> w;
ind[w] = i;
v.push_back(w);
}
for (int i = 0; i < q; i++) {
cin >> l >> r;
l--;
fq.push_back({r, l, i});
}
}
void solve() {
segtree st;
st.init(n);
for (int i = 1; i <= n / 2; i++) {
for (int j = i + i; j <= n; j += i) {
adj[j].push_back(i);
jda[i].push_back(j);
}
}
sort(fq.begin(), fq.end(), comp);
set<pair<int, int> > s;
for (int j = 0; j < fq[0].r; j++) {
b[v[j]] = 1;
for (int w = 0; w < adj[v[j]].size(); w++) {
int x = adj[v[j]][w];
if (s.count(make_pair(v[j], x)) == 1) {
continue;
}
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
for (int w = 0; w < jda[v[j]].size(); w++) {
int x = jda[v[j]][w];
if (s.count(make_pair(x, v[j])) == 1) {
continue;
}
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
}
for (int i = 0; i < a.size(); i++) {
st.opr(ind[a[i]], cnt[a[i]]);
cnt[a[i]] = 0;
}
a.clear();
ans[fq[0].i] = st.calc(fq[0].l, fq[0].r) + (fq[0].r - fq[0].l);
for (int i = 1; i < q; i++) {
for (int j = fq[i - 1].r; j < fq[i].r; j++) {
b[v[j]] = 1;
for (int w = 0; w < adj[v[j]].size(); w++) {
int x = adj[v[j]][w];
if (s.count(make_pair(v[j], x)) == 1) {
continue;
}
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
for (int w = 0; w < jda[v[j]].size(); w++) {
int x = jda[v[j]][w];
if (s.count(make_pair(x, v[j])) == 1) {
continue;
}
if (b[x] == 0) {
continue;
} else {
if (cnt[x] == 0) {
a.push_back(x);
}
cnt[x]++;
}
}
}
for (int j = 0; j < a.size(); j++) {
st.opr(ind[a[j]], cnt[a[j]]);
cnt[a[j]] = 0;
}
a.clear();
ans[fq[i].i] = st.calc(fq[i].l, fq[i].r) + (fq[i].r - fq[i].l);
}
for (int i = 0; i < q; i++) {
cout << ans[i] << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
input(), solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005], poz[200005], aib[200005], aib1[200005], n;
long long sol[200005];
vector<int> Mic[200005], Mare[200005];
struct query {
int val, poz;
};
vector<query> Left[200005], Right[200005];
inline void Ciur() {
int i, j;
for (i = 1; i <= n; ++i)
for (j = i; j <= n; j += i)
if (poz[i] < poz[j])
Mic[poz[j]].push_back(poz[i]);
else
Mare[poz[j]].push_back(poz[i]);
}
inline void Update(int p) {
int i;
for (i = p; i > 0; i -= (i & (-i))) ++aib[i];
}
inline void Update1(int p) {
int i;
for (i = p; i <= n; i += (i & (-i))) ++aib1[i];
}
inline int Query(int p) {
int i, sol = 0;
for (i = p; i <= n; i += (i & (-i))) sol += aib[i];
return sol;
}
inline int Query1(int p) {
int i, sol = 0;
for (i = p; i > 0; i -= (i & (-i))) sol += aib1[i];
return sol;
}
int main() {
int i, m, x, y;
query w;
ios::sync_with_stdio(false);
cin >> n >> m;
for (i = 1; i <= n; ++i) {
cin >> a[i];
poz[a[i]] = i;
}
Ciur();
for (i = 1; i <= m; ++i) {
cin >> x >> y;
w.val = x;
w.poz = i;
Right[y].push_back(w);
w.val = y;
w.poz = i;
Left[x].push_back(w);
}
for (i = 1; i <= n; ++i) {
vector<int>::iterator it;
vector<query>::iterator itt;
for (it = Mic[i].begin(); it != Mic[i].end(); ++it) Update(*it);
for (itt = Right[i].begin(); itt != Right[i].end(); ++itt)
sol[itt->poz] += Query(itt->val);
}
for (i = n; i; --i) {
vector<int>::iterator it;
vector<query>::iterator itt;
for (it = Mare[i].begin(); it != Mare[i].end(); ++it) Update1(*it);
for (itt = Left[i].begin(); itt != Left[i].end(); ++itt)
sol[itt->poz] += Query1(itt->val);
}
for (i = 1; i <= m; ++i) cout << sol[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MXN = 200002;
struct edge {
int d, id;
edge* next;
edge(int d, edge* n) : d(d), next(n) {}
} * e[MXN], *q[MXN];
int N, Q;
int a[MXN], p[MXN];
long long ans[MXN];
namespace Tarray {
long long c[MXN];
void met() {
for (int i = 1; i <= N; i++) c[i] = 0;
}
void ins(int x, int v) {
for (; x <= N; x += ((x) & (-x))) c[x] += v;
}
long long sum(int x) {
long long s = 0;
for (; x > 0; x -= ((x) & (-x))) s += c[x];
return s;
}
} // namespace Tarray
void work() {
scanf("%d%d", &N, &Q);
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[i]] = new edge(p[j], e[p[i]]);
else
e[p[j]] = new edge(p[i], e[p[j]]);
int x, y;
for (int i = 1; i <= Q; i++)
scanf("%d%d", &x, &y), q[y] = new edge(x, q[y]), q[y]->id = i;
Tarray::met();
for (int i = 1; i <= N; i++) {
for (edge* lk = e[i]; lk; lk = lk->next) Tarray::ins(lk->d, 1);
for (edge* lk = q[i]; lk; lk = lk->next)
ans[lk->id] = Tarray::sum(i) - Tarray::sum(lk->d - 1);
}
for (int i = 1; i <= Q; i++) printf("%I64d\n", ans[i]);
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read_file(bool outToFile = true) {}
int n, nq;
const int MAXN = 2 * 100 * 1000 + 1 + 9;
int A[MAXN], pos[MAXN];
int ans[MAXN];
const int MAXIDX = 25 * MAXN;
pair<pair<int, int>, pair<int, int> > events[MAXIDX];
int evIdx;
int FT[MAXN];
void add(int idx) {
while (idx <= n) {
FT[idx]++;
idx += idx & -idx;
}
}
int query(int idx) {
int ret = 0;
while (idx > 0) {
ret += FT[idx];
idx -= idx & -idx;
}
return ret;
}
int main() {
read_file();
while (scanf("%d%d", &n, &nq) != -1) {
memset(FT, 0, sizeof FT);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]), pos[A[i]] = i;
evIdx = 0;
for (int i = 0; i < nq; i++) {
int l, r;
scanf("%d%d", &l, &r);
events[evIdx++] = (make_pair(make_pair(r, 1), make_pair(l, i)));
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
int l = min(pos[i], pos[j]);
int r = max(pos[i], pos[j]);
events[evIdx++] = (make_pair(make_pair(r, 0), make_pair(l, -1)));
}
}
sort(events, events + evIdx);
int cur = 0;
for (int i = 0; i < evIdx; i++) {
int l, r, idx, type;
r = events[i].first.first;
type = events[i].first.second;
l = events[i].second.first;
idx = events[i].second.second;
if (type == 0) {
cur++;
add(l);
} else {
ans[idx] = cur;
ans[idx] -= query(l - 1);
}
}
for (int i = 0; i < nq; i++) printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T nextInt() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') {
p = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch - '0');
ch = getchar();
}
return x * p;
}
const int maxN = (int)2e5 + 10;
const int INF = (int)1e9;
const int mod = (int)1e9 + 7;
const long long LLINF = (long long)1e18;
int n, q;
int a[maxN];
int p[maxN];
vector<int> segments[maxN];
int fw[maxN];
void add(int r) {
for (; r < maxN; r |= r + 1) {
fw[r]++;
}
}
int get(int r) {
int ret = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) {
ret += fw[r];
}
return ret;
}
vector<pair<int, int> > queries[maxN];
int answer[maxN];
int main() {
n = nextInt<int>();
q = nextInt<int>();
for (int i = 0; i < n; ++i) {
a[i] = nextInt<int>();
p[a[i]] = i;
}
for (int i = 0; i < n; ++i) {
for (int j = a[i]; j <= n; j += a[i]) {
int l = i;
int r = p[j];
if (l > r) swap(l, r);
segments[l].push_back(r);
}
}
for (int qq = 0; qq < q; ++qq) {
int l, r;
l = nextInt<int>() - 1;
r = nextInt<int>() - 1;
queries[l].push_back(make_pair(r, qq));
}
for (int l = n - 1; l >= 0; --l) {
for (int r : segments[l]) {
add(r);
}
for (auto q : queries[l]) {
answer[q.second] = get(q.first);
}
}
for (int i = 0; i < q; ++i) {
printf("%d\n", answer[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int before, ed;
} l[200001], r[200001];
int LX[200001], RX[200001], L[200001], R[200001], a[200001], from[200001], k1,
k2;
long long Tree[200001], Ans[200001];
int n, m, i, j;
int lowbit(int x) { return x & -x; }
void insert(int x) {
for (; x <= n; x += lowbit(x)) Tree[x]++;
}
long long ask(int x) {
int sum = 0;
for (; x; x -= lowbit(x)) sum += Tree[x];
return sum;
}
void add(int p1, int p2) {
l[++k1].ed = p2;
l[k1].before = LX[p1];
LX[p1] = k1;
}
void Add(int p1, int p2) {
r[++k2].ed = p2;
r[k2].before = RX[p1];
RX[p1] = k2;
}
int main() {
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), from[a[i]] = i;
for (i = 1; i <= m; i++)
scanf("%d%d", &L[i], &R[i]), add(L[i], i), Add(R[i], i);
for (i = 1; i <= n; i++) {
for (j = LX[i]; j; j = l[j].before)
Ans[l[j].ed] -= ask(R[l[j].ed]) - ask(i - 1);
for (j = 1; a[i] * j <= n; j++) insert(from[a[i] * j]);
for (j = RX[i]; j; j = r[j].before)
Ans[r[j].ed] += ask(i) - ask(L[r[j].ed] - 1);
}
for (i = 1; i <= m; i++) printf("%I64d\n", Ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
const int N = 200005;
int n, m;
int a[N], loc[N];
vector<pair<int, int> > Q[N];
vector<int> U[N];
int C[N];
int ans[N];
void update(int x, int d) {
while (x <= n) {
C[x] += d;
x += (x & (-x));
}
}
int query(int x) {
int ans = 0;
while (x) {
ans += C[x];
x -= (x & (-x));
}
return ans;
}
void init() {
read(n);
read(m);
for (int i = 1; i <= n; ++i) read(a[i]), loc[a[i]] = i;
for (int i = 1, l, r; i <= m; ++i) {
read(l);
read(r);
Q[r].push_back(make_pair(l, i));
}
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
int x = loc[i], y = loc[j];
if (x > y) swap(x, y);
U[y].push_back(x);
}
}
}
void solve() {
int sum = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < (int)U[i].size(); ++j) update(U[i][j], 1), sum++;
for (int j = 0; j < (int)Q[i].size(); ++j) {
ans[Q[i][j].second] = sum - query(Q[i][j].first - 1);
}
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 100;
long long int ind[N], a[N], l[N], r[N], fen[N], ans[N];
vector<long long int> v[N], d[N];
void upd(int x) {
for (int i = x; i <= N - 100; i += i & (-i)) fen[i]++;
}
long long int sum(int x) {
long long int ret = 0;
for (int i = x; i > 0; i -= i & (-i)) ret += fen[i];
return ret;
}
int main() {
ios::sync_with_stdio(0);
long long int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
ind[a[i]] = i + 1;
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j += i) {
v[max(ind[i], ind[j])].emplace_back(min(ind[i], ind[j]));
}
}
for (int i = 0; i < q; i++) {
cin >> l[i] >> r[i];
d[r[i]].emplace_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j : v[i]) upd(j);
for (int j : d[i]) {
ans[j] = sum(r[j]) - sum(l[j] - 1);
}
}
for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int bit[200007];
void upd(int idx, int v) {
while (idx < 200007) {
bit[idx] += v;
idx += (idx & -idx);
}
}
int get(int idx) {
int ret = 0;
while (idx) {
ret += bit[idx];
idx -= (idx & -idx);
}
return ret;
}
int pos[200007], a[200007], ans[200007];
pair<pair<long long, long long>, int> qry[200007];
vector<pair<int, int> > v;
int main() {
int n, q;
scanf("%d %d", &n, &q);
for (int i = (1); i < (n + 1); i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = (0); i < (q); i++) {
int l, r;
scanf("%d %d", &l, &r);
qry[i] = make_pair(make_pair(r, l), i);
}
for (int i = (1); i < (n + 1); i++) {
for (int j = 1; j * j <= i; j++) {
if (i % j == 0) {
v.push_back(make_pair(max(pos[i], pos[j]), min(pos[i], pos[j])));
if ((j * j) != i) {
v.push_back(
make_pair(max(pos[i], pos[i / j]), min(pos[i], pos[i / j])));
}
}
}
}
sort(v.begin(), v.end());
sort(qry, qry + q);
int now = 0;
for (int i = (0); i < (q); i++) {
int l = qry[i].first.second, r = qry[i].first.first;
while (now < v.size() && v[now].first <= r) {
upd(v[now].second, 1);
now++;
}
ans[qry[i].second] = get(r) - get(l - 1);
}
for (int i = (0); i < (q); i++) {
printf("%d\n", ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Query {
int p, id, l, r, fl;
Query(int _p, int _id, int _l, int _r, int _fl) {
p = _p;
id = _id;
l = _l;
r = _r;
fl = _fl;
}
bool operator<(const Query &B) const { return p < B.p; }
};
int N, M, P[200005], pos[200005], ans[200005], tree[200005];
vector<Query> vec;
int read(int id) {
int sum = 0;
while (id > 0) {
sum += tree[id];
id -= (id & -id);
}
return sum;
}
void update(int id, int v) {
while (id < 200005) {
tree[id] += v;
id += (id & -id);
}
}
int main() {
scanf("%d", &N);
scanf("%d", &M);
for (int i = 1; i <= N; i++) {
scanf("%d", &P[i]);
pos[P[i]] = i;
}
for (int i = 0; i < M; i++) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
if (l > 1) vec.push_back(Query(l - 1, i, l, r, -1));
vec.push_back(Query(r, i, l, r, 1));
}
sort(vec.begin(), vec.end());
int p = 0;
for (int i = 1; i <= N; i++) {
for (int j = P[i]; j <= N; j += P[i]) update(pos[j], 1);
while (p < vec.size() && vec[p].p == i) {
ans[vec[p].id] += (vec[p].fl * (read(vec[p].r) - read(vec[p].l - 1)));
p++;
}
}
for (int i = 0; i < M; i++) printf("%d\n", ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = false;
int n, m, k;
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
long long ln, lk, lm;
int p[200105], B, id[200105];
struct qy {
int id, l, r;
bool operator<(const qy &b) const {
if (l == b.l) return r < b.r;
return l < b.l;
}
} q[200105];
vector<int> vp[200105];
void pre() {
for (int i = 1; i <= n; i++) {
for (int j = i + i; j <= n; j += i) {
vp[min(id[i], id[j])].push_back(max(id[i], id[j]));
}
}
}
long long b[200105], ans[200105];
void update(int x, int val) {
for (int i = x; i <= n; i += i & -i) {
b[i] += val;
}
}
long long query(int x) {
int ret = 0;
for (; x > 0; ret += b[x], x -= x & -x)
;
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%d", p + i);
id[p[i]] = i;
}
for (int(i) = 1; (i) <= (int)(m); (i)++) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + 1 + m);
pre();
int l = 0, r = 0;
for (int(i) = 1; (i) <= (int)(m); (i)++) {
while (r < q[i].r) {
r++;
for (int c : vp[r]) update(c, 1);
}
while (l < q[i].l) {
for (int c : vp[l]) update(c, -1);
l++;
}
ans[q[i].id] = query(q[i].r) + q[i].r - q[i].l + 1;
}
for (int(i) = 1; (i) <= (int)(m); (i)++) printf("%lld\n", 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 {
vector<pair<int, int>> q;
vector<int> lefties;
} d[MAXN];
unsigned getsum(int index) {
unsigned sum = 0;
while (index > 0) {
sum += bt[index];
index -= index & (-index);
}
return sum;
}
void incr(int index) {
while (index <= N) {
bt[index]++;
index += index & (-index);
}
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
scanf("%d", A + i);
pos[A[i]] = i;
}
for (int queryi = 0, left, right; queryi < M; queryi++) {
scanf("%d%d", &left, &right);
d[right].q.push_back({left, queryi});
}
for (int num = 1; num <= N; num++) {
for (int multi = 2 * num; multi <= N; multi += num) {
int left = min(pos[num], pos[multi]);
int right = max(pos[num], pos[multi]);
d[right].lefties.push_back(left);
}
}
for (int posi = 1; posi <= N; posi++) {
for (auto left : d[posi].lefties) incr(left);
for (auto qu : d[posi].q)
ans[qu.second] =
getsum(posi) - getsum(qu.first - 1) + (posi - qu.first + 1);
}
for (int i = 0; i < M; i++) printf("%u\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
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++) {
scanf("%d", &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++) {
scanf("%d %d", &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++) printf("%d\n", preg[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string first;
while (getline(ss, first, c)) v.emplace_back(first);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << a << " ";
err(++it, args...);
}
const int M = 300010;
struct BIT {
vector<int> tree;
BIT(int n) { tree.resize(n); }
void update(int idx, int val) {
while (idx < tree.size()) {
tree[idx] += val;
idx += idx & (-idx);
}
}
int query(int idx) {
int sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= idx & (-idx);
}
return sum;
}
};
struct data {
int id, l, r;
data(int a = 0, int b = 0, int c = 0) {
id = a;
l = b, r = c;
}
bool operator<(const data& d) const { return r < d.r; }
};
vector<data> qr;
BIT t(M);
vector<int> A[M];
int pos[M], ans[M];
int main() {
ios_base::sync_with_stdio(false);
int n, i, j, k, l, r, q;
scanf("%d%d", &n, &q);
for (i = 1; i <= n; i++) scanf("%d", &k), pos[k] = i;
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j += i) {
if (pos[i] >= pos[j])
A[pos[i]].push_back(pos[j]);
else
A[pos[j]].push_back(pos[i]);
}
}
qr.push_back(data(0, 0, 0));
for (i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
qr.push_back(data(i, l, r));
}
sort((qr).begin(), (qr).end());
for (i = 1; i <= q; i++) {
for (j = qr[i - 1].r + 1; j <= qr[i].r; j++) {
for (k = 0; k < A[j].size(); k++) {
t.update(A[j][k], 1);
}
}
ans[qr[i].id] = t.query(qr[i].r) - t.query(qr[i].l - 1);
}
for (i = 1; i <= q; i++) printf("%d\n", ans[i]);
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() {
scanf("%d%d", &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++) {
scanf("%d", A + i);
B[A[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", 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++) {
printf("%d\n", R[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:64000000")
using namespace std;
void __never(int a) { printf("\nOPS %d", a); }
void __die(int a) { printf("%d", (a * a) / (a + a)); }
struct tree {
long long m[300000 + 300000];
int n;
void Init(int _n) {
n = _n;
for (int(i) = (1); (i) <= (n + n - 1); ++(i)) m[i] = 0;
}
void Add(int i, int j, int val) {
{
if (!(1 <= i && i <= j && j <= n)) {
__never(39);
cout.flush();
cerr.flush();
__die(0);
}
};
i += n - 1;
j += n - 1;
while (i <= j) {
if ((i & 1) == 1) m[i] += val;
if ((j & 1) == 0) m[j] += val;
i = (i + 1) >> 1;
j = (j - 1) >> 1;
}
}
long long get(int pos) {
{
if (!(1 <= pos && pos <= n)) {
__never(50);
cout.flush();
cerr.flush();
__die(0);
}
};
pos += n - 1;
long long res = m[pos];
while (pos > 1) {
pos = pos >> 1;
res += m[pos];
}
return res;
}
} tr;
int n, m;
int pos[300000];
int p[300000];
vector<pair<int, int> > qs[300000];
long long ans[300000];
long long all[300000];
void init() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
void sol() {
scanf("%d %d", &n, &m);
for (int(i) = (1); (i) <= (n); ++(i)) scanf("%d", &p[i]);
int a, b;
for (int(i) = (1); (i) <= (m); ++(i)) {
scanf("%d %d", &a, &b);
if (a > b) swap(a, b);
qs[b].push_back(make_pair(a, i));
}
tr.Init(n);
for (int(i) = (1); (i) <= (n); ++(i)) {
int v = p[i];
all[i] = all[i - 1];
for (int j = v + v; j <= n; j += v)
if (pos[j]) {
tr.Add(pos[j], i - 1, 1);
all[i]++;
}
for (int j = 1; j * j <= v; j++)
if (v % j == 0 && v != j) {
if (pos[j]) {
tr.Add(pos[j], i - 1, 1);
all[i]++;
}
if (j * j != v && pos[v / j]) {
tr.Add(pos[v / j], i - 1, 1);
all[i]++;
}
}
pos[p[i]] = i;
for (int(j) = (0); (j) <= ((int)((qs[i]).size()) - 1); ++(j)) {
int be = qs[i][j].first;
long long r = (i - be + 1) + all[i] - all[be - 1];
if (be > 1) r -= tr.get(be - 1);
ans[qs[i][j].second] = r;
}
}
for (int(i) = (1); (i) <= (m); ++(i)) printf("%I64d\n", ans[i]);
}
int main() {
sol();
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int C[200005];
int lowbit(int x) { return x & (-x); }
void update(int x, int v) {
while (x < 200005) {
C[x] += v;
x += lowbit(x);
}
}
int sum(int x) {
int res = 0;
while (x > 0) {
res += C[x];
x -= lowbit(x);
}
return res;
}
int n, m;
int val[200005];
struct node {
int L, R, id;
} e[200005], e1[200005];
bool cmp(node a, node b) { return a.R < b.R; }
bool cmp1(node a, node b) { return a.L < b.L; }
int ans[200005];
int pre[200005];
void Init() {
memset(pre, 0, sizeof pre);
memset(C, 0, sizeof C);
}
int main() {
while (~scanf("%d%d", &n, &m)) {
Init();
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
pre[val[i]] = i;
}
for (int i = 0; i < m; i++) {
scanf("%d%d", &e[i].L, &e[i].R);
e[i].id = i;
e1[i] = e[i];
}
sort(e, e + m, cmp);
sort(e1, e1 + m, cmp1);
int k = 0, k1 = 0;
for (int i = 1; i <= n; i++) {
while (k1 < m && e1[k1].L == i) {
ans[e1[k1].id] -= sum(e1[k1].R) - sum(e1[k1].L - 1);
k1++;
}
for (long long j = val[i]; j <= n; j += val[i]) update(pre[j], 1);
while (k < m && e[k].R == i) {
ans[e[k].id] += sum(e[k].R) - sum(e[k].L - 1);
k++;
}
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, q;
vector<int> oni[200009], son[200009];
vector<pair<int, int> > Q[200009];
int sanavach[200009];
int arr[200009];
int res[200009];
int sum[200009];
int ans = 0;
void upd(int x) {
for (int i = x; i <= n; i += (i & -i)) sum[i]++;
}
int ask(int x) {
int nw = 0;
for (int i = x; i > 0; i -= (i & -i)) nw += sum[i];
return nw;
}
int calc(int l, int r) { return abs(ask(r - 1) - ask(l)); }
int pos[200009];
int main() {
cin >> n;
cin >> q;
int a;
for (int i = 1; i <= n; i++) {
scanf("%d", &a);
pos[a] = i;
}
int l, r;
for (int i = 1; i <= q; i++) {
scanf("%d%d", &l, &r);
Q[r].push_back({l, i});
}
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i)
son[max(pos[i], pos[j])].push_back(min(pos[i], pos[j]));
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (int)son[i].size(); j++) upd(son[i][j]);
for (int j = 0; j < (int)Q[i].size(); j++)
res[Q[i][j].second] = calc(i, Q[i][j].first);
}
for (int i = 1; i <= q; i++) printf("%d\n", res[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 = 1; j * j <= i; j++) {
if (i % j != 0) continue;
int posl = pos[i], posr = pos[j];
if (posl > posr) swap(posl, posr);
queries.push_back({posr, {-1, posl}});
if (j * j != i) {
int posl = pos[i], posr = pos[i / 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>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
inline string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
template <typename T>
inline int bit(T mask, int b) {
return (b >= 0 && (mask & (T(1) << b)) != 0) ? 1 : 0;
}
inline int nextInt() {
int x;
if (scanf("%d", &x) != 1) throw;
return x;
}
inline long long nextInt64() {
long long x;
if (scanf("%I64d", &x) != 1) throw;
return x;
}
inline double nextDouble() {
double x;
if (scanf("%lf", &x) != 1) throw;
return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 200100;
const int OSN = (1 << 18) - 1;
int n, m, a[MAXN], pos[MAXN], ans[MAXN], tree[2 * OSN + 10];
vector<pair<int, int> > q[MAXN];
vector<int> lf[MAXN];
void update(int v, int value) {
v += OSN;
tree[v] += value;
while (v > 0) {
v = (v - 1) >> 1;
tree[v] += value;
}
}
int get(int v, int l, int r, int ll, int rr) {
if (l > rr || ll > r || ll > rr) return 0;
if (ll <= l && r <= rr) return tree[v];
int mid = (l + r) >> 1;
return get(2 * v + 1, l, mid, ll, rr) + get(2 * v + 2, mid + 1, r, ll, rr);
}
void addEdge(int a, int b) {
int v = pos[a], u = pos[b];
if (v > u) swap(v, u);
lf[u].push_back(v);
}
int main() {
n = nextInt();
m = nextInt();
for (int i = 0; i < (int)(n); i++) {
a[i] = nextInt();
pos[a[i]] = i;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j * j <= i; j++)
if (i % j == 0) {
addEdge(i, j);
if (i != j * j) addEdge(i, i / j);
}
for (int i = 0; i < (int)(m); i++) {
int l = nextInt() - 1;
int r = nextInt() - 1;
q[r].push_back(make_pair(l, i));
}
for (int r = 0; r < (int)(n); r++) {
for (int i = 0; i < (int)(lf[r].size()); i++) update(lf[r][i], +1);
for (int i = 0; i < (int)(q[r].size()); i++) {
int l = q[r][i].first, id = q[r][i].second;
ans[id] = get(0, 0, OSN, l, r);
}
}
for (int i = 0; i < (int)(m); i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, m;
int a[N], pos[N], l[N], r[N], c[N], ans[N];
vector<int> v[N], q[N];
void ins(int x) {
for (; x <= n; x += -x & x) c[x]++;
}
int ask(int x) {
int res = 0;
for (; x; x -= -x & x) res += c[x];
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pos[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
q[l[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j * a[i] <= n; j++) {
int p = pos[j * a[i]];
if (p < i)
v[p].push_back(i);
else
v[i].push_back(p);
}
}
for (int i = n; i; i--) {
for (auto x : v[i]) ins(x);
for (auto x : q[i]) ans[x] = ask(r[x]);
}
for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1.0e-11;
const double pi = acos(-1.0);
const int N = 200001;
vector<vector<int> > dv(N);
int a[N], id[N];
map<int, int> pos;
vector<pair<int, int> > all, req;
int t[N];
void add(int i) {
for (; i < N; i = i | (i + 1)) ++t[i];
}
int sum(int i) {
int res = 0;
for (; i >= 0; i = (i & (i + 1)) - 1) res += t[i];
return res;
}
void Evclid() {
for (int i = 1; i < N; ++i) {
for (int j = i; j < N; j += i) dv[j].push_back(i);
}
}
int cmp(const int i, const int j) { return req[i] < req[j]; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
pos[a[i]] = i;
}
Evclid();
for (int i = 0; i < n; i++) {
int val = a[i];
for (int j = 0; j < (int)(dv[val]).size(); j++) {
if (pos.count(dv[val][j])) {
all.push_back(
make_pair(max(i, pos[dv[val][j]]), min(i, pos[dv[val][j]])));
}
}
}
vector<int> res(m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
req.push_back(make_pair(y, x));
id[i] = i;
}
sort(id, id + m, cmp);
sort((all).begin(), (all).end());
int idx = -1;
for (int i = 0; i < m; i++) {
int curr = req[id[i]].first;
while (idx + 1 < (int)(all).size() && all[idx + 1].first <= curr)
add(all[idx + 1].second), ++idx;
int rr = sum(req[id[i]].second - 1);
res[id[i]] += 1 + idx - rr;
}
for (int i = 0; i < (int)(res).size(); i++) printf("%d\n", res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 200010;
int N, M, L, R, P[NMAX], Start[NMAX], Ans[NMAX], ValPos[NMAX];
vector<pair<int, int> > LeftQuery[NMAX];
vector<int> Interv[NMAX];
int LSB(int X) { return (X & (X - 1)) ^ X; }
void Update(int Pos) {
for (; Pos <= N; Pos += LSB(Pos)) Start[Pos]++;
}
int Query(int Pos) {
int Nr = 0;
for (; Pos; Pos -= LSB(Pos)) Nr += Start[Pos];
return Nr;
}
int main() {
scanf("%i %i", &N, &M);
for (int i = 1; i <= N; ++i) scanf("%i", &P[i]), ValPos[P[i]] = i;
for (int i = 1; i <= M; ++i) {
scanf("%i %i", &L, &R);
LeftQuery[R].push_back({L, i});
}
for (int i = 1; i <= N; ++i)
for (int j = P[i]; j < NMAX; j += P[i])
if (ValPos[j] != 0)
Interv[max(i, ValPos[j])].push_back(min(i, ValPos[j]));
for (int i = 1; i <= N; ++i) {
for (int j = 0; j < Interv[i].size(); ++j) Update(Interv[i][j]);
for (int j = 0; j < LeftQuery[i].size(); ++j) {
int X = LeftQuery[i][j].first, Y = i, Index = LeftQuery[i][j].second;
Ans[Index] = Query(Y) - Query(X - 1);
}
}
for (int i = 1; i <= M; ++i) printf("%i\n", Ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long tree[1000000];
int n, m;
long long query(int x) {
x++;
long long ret = 0;
while (x <= n) {
ret += tree[x];
x += x & ~(x - 1);
}
return ret;
}
void update(int x, int y) {
x++;
while (x) {
tree[x] += y;
x -= x & ~(x - 1);
}
}
int main() {
scanf("%d %d", &n, &m);
vector<int> a(n), lookup(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
lookup[a[i] - 1] = i;
}
vector<int> starts_at(n), ends_at(n);
vector<vector<int> > endings(n);
for (int i = 0; i < n; i++) {
for (int j = a[i]; j <= n; j += a[i]) {
int x = i;
int y = lookup[j - 1];
if (x > y) swap(x, y);
starts_at[x]++;
ends_at[y]++;
endings[x].push_back(y);
}
}
vector<long long> acc_starts_at(n + 1), acc_ends_at(n + 1);
for (int i = 0; i < n; i++) {
acc_starts_at[i + 1] = acc_starts_at[i] + starts_at[i];
acc_ends_at[i + 1] = acc_ends_at[i] + ends_at[i];
}
vector<pair<pair<int, int>, int> > qs(m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &qs[i].first.first, &qs[i].first.second);
qs[i].second = i;
}
sort(qs.begin(), qs.end());
int add = 0;
vector<long long> ans(m);
for (int i = 0; i < qs.size(); i++) {
int x = qs[i].first.first - 1;
int y = qs[i].first.second - 1;
while (add < x) {
for (int j = 0; j < endings[add].size(); j++) {
update(endings[add][j], 1);
}
add++;
}
ans[qs[i].second] = (acc_ends_at[y + 1] - acc_ends_at[x]) -
(acc_starts_at[x] - acc_starts_at[0]) +
(acc_ends_at[x] - acc_ends_at[0]) + query(y + 1);
}
for (int i = 0; i < m; i++) {
printf("%I64d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void chmax(T& a, const T& b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, const T& b) {
a = min(a, b);
}
template <class T>
void uniq(T& c) {
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
}
template <class T>
string to_s(const T& a) {
ostringstream os;
os << a;
return os.str();
}
template <class T>
T to_T(const string& s) {
istringstream is(s);
T res;
is >> res;
return res;
}
template <typename T>
void print_container(ostream& os, const T& c) {
const char* _s = " ";
if (!c.empty()) {
__typeof__(c.begin()) last = --c.end();
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it) {
os << *it;
if (it != last) cout << _s;
}
}
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& c) {
print_container(os, c);
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& c) {
print_container(os, c);
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& c) {
print_container(os, c);
return os;
}
template <typename T>
ostream& operator<<(ostream& os, const deque<T>& c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const map<T, U>& c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "( " << p.first << ", " << p.second << " )";
return os;
}
template <class T>
void print(T a, int n, const string& deli = " ", int br = 1) {
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 != n) cout << deli;
}
while (br--) cout << endl;
}
template <class T>
void print2d(T a, int w, int h, int width = -1, int br = 1) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1) cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--) cout << endl;
}
template <class T>
void input(T& a, int n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
template <class T>
void input(T* a, int n) {
for (int i = 0; i < n; ++i) cin >> a[i];
}
void fix_pre(int n) {
cout.setf(ios::fixed, ios::floatfield);
cout.precision(10);
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const double PI = acos(-1.0);
template <class T>
class BIT {
public:
vector<T> a;
int n;
BIT(int n) : n(n), a(n + 1) {}
BIT() {}
void add(int i, T x) {
++i;
assert(i > 0);
while (i <= n) {
a[i] += x;
i += i & -i;
}
}
T sum(int i) const {
++i;
T res = 0;
while (i > 0) {
res += a[i];
i -= i & -i;
}
return res;
}
T range_sum(int low, int high) const { return sum(high) - sum(low - 1); }
T at(int i) const { return sum(i) - sum(i - 1); }
void assign(int i, T x) { add(i, x - at(i)); }
};
int main() {
fast_io();
int n, m;
cin >> n >> m;
static int p[2 * ((long long)(1e5))], pos[2 * ((long long)(1e5)) + 10];
input(p, n);
for (int i = 0; i < (int)(n); ++i) pos[p[i]] = i;
vector<vector<int> > div_pair(n);
for (int i = 1; i <= n; ++i) {
for (int j = i; j <= n; j += i) {
int a = pos[i], b = pos[j];
if (a < b) swap(a, b);
div_pair[a].push_back(b);
}
}
vector<pair<pair<int, int>, int> > query;
for (int i = 0; i < (int)(m); ++i) {
int l, r;
cin >> l >> r;
--l, --r;
query.push_back(make_pair(pair<int, int>(r, l), i));
}
sort((query).begin(), (query).end());
BIT<long long> bit(n);
long long res[2 * ((long long)(1e5))];
for (int i = 0, j = 0; i < m; ++i) {
const int l = query[i].first.second, r = query[i].first.first,
idx = query[i].second;
for (; j <= r; ++j) {
for (int k = 0; k < (int)(div_pair[j].size()); ++k)
bit.add(div_pair[j][k], 1);
}
res[idx] = bit.range_sum(l, r);
}
for (int i = 0; i < (int)(m); ++i) cout << res[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double fRand(double fMin, double fMax) {
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
struct BIT {
private:
vector<int> t;
public:
BIT(int n) { t.assign(n + 1, 0); }
void update(int p, int x) {
for (int i = p; i < t.size(); i += i & (-i)) t[i] += x;
}
int query(int p) {
int res = 0;
for (int i = p; i > 0; i -= i & (-i)) res += t[i];
return res;
}
};
struct query {
int l, r, id;
};
bool cmpQ(const query &a, const query &b) { return a.l > b.l; }
int n, m, pos[200005], ans[200005];
vector<pair<int, int> > s;
vector<query> Q;
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) {
int x;
scanf("%d", &x);
pos[x] = i;
}
for (int i = (1); i <= (n); ++i) {
for (int j = i; j <= n; j += i) {
int l = pos[i], r = pos[j];
if (l > r) swap(l, r);
s.push_back(make_pair(l, r));
}
}
sort(s.begin(), s.end());
for (int i = (1); i <= (m); ++i) {
int l, r;
scanf("%d%d", &l, &r);
Q.push_back({l, r, i});
}
sort(Q.begin(), Q.end(), cmpQ);
int i = (int)s.size() - 1;
BIT t(n);
for (query q : Q) {
while (i >= 0 && s[i].first >= q.l) {
t.update(s[i].second, 1);
--i;
}
ans[q.id] = t.query(q.r);
}
for (int i = (1); i <= (m); ++i) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class BIT {
int n;
vector<long long> data;
public:
BIT(int n) {
this->n = n;
data.assign(n + 1, 0);
}
void add(int k, long long x) {
++k;
while (k <= n) {
data[k] += x;
k += k & -k;
}
}
long long sum(int k) {
++k;
long long ret = 0;
while (k > 0) {
ret += data[k];
k -= k & -k;
}
return ret;
}
long long sum(int a, int b) { return sum(b) - sum(a - 1); }
};
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n + 1);
vector<int> index(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
index[a[i]] = i;
}
vector<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;
}
sort(q.begin(), q.end());
BIT b(n + 1);
int k = 0;
vector<long long> ret(m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j * j <= a[i]; ++j) {
if (a[i] % j == 0) {
if (index[j] < i) b.add(index[j], 1);
if (j * j < a[i] && index[a[i] / j] < i) b.add(index[a[i] / j], 1);
}
}
for (int j = a[i]; j <= n; j += a[i]) {
if (index[j] <= i) b.add(index[j], 1);
}
while (k < m && q[k].first.first == i) {
ret[q[k].second] = b.sum(q[k].first.second, q[k].first.first);
++k;
}
}
for (int i = 0; i < m; ++i) cout << ret[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
int n, m, a[N], pos[N], l[N], r[N], ans[N], tree[N];
vector<int> ask[N];
vector<int> vec[N];
inline int lowbit(int x) { return -x & x; }
inline void add(int x) {
for (int i = x; i <= n; i += lowbit(i)) {
tree[i]++;
}
}
inline int query(int x) {
int res = 0;
for (int i = x; i; i -= lowbit(i)) {
res += tree[i];
}
return res;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
pos[a[i]] = i;
}
for (int i = 1; i <= m; i++) {
l[i] = read(), r[i] = read();
ask[r[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < vec[i].size(); j++) {
add(vec[i][j]);
}
for (int k = 1; k * a[i] <= n; k++) {
int p = pos[k * a[i]];
if (p <= i) {
add(p);
} else
vec[p].push_back(i);
}
for (int j = 0; j < ask[i].size(); j++) {
ans[ask[i][j]] = query(r[ask[i][j]]) - query(l[ask[i][j]] - 1);
}
}
for (int i = 1; i <= m; i++) {
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
int C[200005];
int lowbit(int x) { return x & (-x); }
void update(int x, int v) {
while (x < 200005) {
C[x] += v;
x += lowbit(x);
}
}
int sum(int x) {
int res = 0;
while (x > 0) {
res += C[x];
x -= lowbit(x);
}
return res;
}
int n, m;
int val[200005];
struct node {
int L, R, id;
} e[200005];
bool cmp(node a, node b) { return a.R < b.R; }
int ans[200005];
int pre[200005];
void Init() {
memset(pre, 0, sizeof pre);
memset(C, 0, sizeof C);
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; i++) scanf("%d", &val[i]);
for (int i = 0; i < m; i++) {
scanf("%d%d", &e[i].L, &e[i].R);
e[i].id = i;
}
sort(e, e + m, cmp);
Init();
int k = 0;
for (int i = 1; i <= n; i++) {
pre[val[i]] = i;
for (long long j = 1; j * j <= val[i]; j++) {
if (val[i] % j) continue;
if (pre[j] > 0) {
update(pre[j], 1);
}
if (j * j != val[i] && pre[val[i] / j] > 0) {
update(pre[val[i] / j], 1);
}
}
for (long long j = val[i] * 2; j <= n; j += val[i]) {
if (pre[j] > 0) update(pre[j], 1);
}
while (k < m && e[k].R == i) {
ans[e[k].id] = sum(e[k].R) - sum(e[k].L - 1);
k++;
}
}
for (int i = 0; i < m; i++) printf("%d\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.