[Codeforces] D. Yaroslav and Divisors

Author            : Dipu Kumar Mohanto 
                    CSE, Batch - 6
                    BRUR.
Problem Statement : D. Yaroslav and Divisors
Source            : Codeforces
Category          : Data Structure
Algorithm         : 
Verdict           : Accepted

Tutorial : https://duoblogger.github.io/offline-query-solution-1/

#undef _GLIBCXX_DEBUG  
  
#include "bits/stdc++.h"  
#include "ext/pb_ds/assoc_container.hpp"  
#include "ext/pb_ds/tree_policy.hpp"  
#include "ext/rope"  
  
using namespace std;  
using namespace __gnu_pbds;  
using namespace __gnu_cxx;  
  
void trace(int x)                         { cerr << x; }  
void trace(long x)                        { cerr << x; }  
void trace(long long x)                   { cerr << x; }  
void trace(unsigned x)                    { cerr << x; }  
void trace(unsigned long x)               { cerr << x; }  
void trace(unsigned long long x)          { cerr << x; }  
void trace(float x)                       { cerr << x; }  
void trace(double x)                      { cerr << x; }  
void trace(long double x)                 { cerr << x; }  
void trace(char x)                        { cerr << '\'' << x << '\''; }  
void trace(const char *x)                 { cerr << '\"' << x << '\"'; }  
void trace(const string &x)               { cerr << '\"' << x << '\"'; }  
void trace(bool x)                        { cerr << (x ? "true" : "false"); }  
  
template <typename A, typename B>                         void trace(const pair <A, B> &x)         { cerr << '{'; trace(x.first); cerr << ','; trace(x.second); cerr << '}'; }  
template <typename A, typename B, typename C>             void trace(const tuple <A, B, C> &x)     { cerr << '{'; trace(get <0> (x)); cerr << ','; trace(get <1> (x)); cerr << ','; trace(get <2> (x)); cerr << '}'; }  
template <typename A, typename B, typename C, typename D> void trace(const tuple <A, B, C, D> &x)  { cerr << '{'; trace(get <0> (x)); cerr << ','; trace(get <1> (x)); cerr << ','; trace(get <2> (x)); cerr << ','; trace(get <3> (x)); cerr << '}'; }  
template <typename T>                                     void trace(const T &x)                   { int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), trace(i); cerr << "}"; }  
template <size_t N>                                       void trace(bitset <N> v)                 { cerr << '{'; for (size_t i = 0; i < N; i++) cerr << static_cast <char> ('0' + v[i]); cerr << '}'; }  
void _print()                                                                                      { cerr << "]\n"; }  
template <typename T, typename... V>                      void _print(T t, V... v)                 { trace(t); if (sizeof...(v)) cerr << ", "; _print(v...); }  
  
#ifndef ONLINE_JUDGE  
      #define debug(x...) cerr << "[" << #x << "] = ["; _print(x)  
#else  
      #define debug(x...)  
#endif // ONLINE_JUDGE  
  
template <typename T> using ordered_set                = tree <T, null_type, less <T>, rb_tree_tag, tree_order_statistics_node_update>;  
template <typename T1, typename T2> using ordered_map  = tree <T1, T2, less <T1>, rb_tree_tag, tree_order_statistics_node_update>;  
  
template <class T> T binaryExpo(T a, T p)              { if (p == 0) { return 1LL; } if (p == 1) { return a; } if (p & 1) { return a * binaryExpo(a, p - 1); } T ret = binaryExpo(a, p / 2); return ret * ret; }  
template <class T> T bigMod(T a, T p, T m)             { if (p == 0) { return 1LL % m; } if (p == 1) { return a % m; } if (p & 1) { return (a % m * bigMod(a, p - 1, m)) % m; } T ret = bigMod(a, p / 2, m) % m; return (ret * ret) % m; }  
template <class T> T modInv(T a, T m)                  { return bigMod(a, m - 2, m); }  
  
template <class T> bool MIN(T &a, T b)                 { return a > b ? (a = b, true) : false; }  
template <class T> bool MAX(T &a, T b)                 { return a < b ? (a = b, true) : false; }  
  
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());  
  
#define ll              long long int  
#define ull             unsigned long long int  
#define ld              long double  
#define endl            '\n'  
#define pii             pair <int, int>  
#define pll             pair <ll, ll>  
#define mk              make_pair  
#define ff              first  
#define ss              second  
#define all(a)          (a).begin(), (a).end()  
#define rall(a)         (a).rbegin(), (a).rend()  
#define eb              emplace_back  
#define pb              push_back  
#define pf              push_front  
#define sz(a)           (int)(a.size())  
#define ook             order_of_key             // The number of items in a set that are strictly smaller than k  
#define fbo             find_by_order            // It returns an iterator to the i'th largest element  
#define ATCODER         if (fopen("in.txt", "r")) { freopen("in.txt", "r", stdin); }  
  
#define int             long long int  
  
const int maxn = 2e5 + 5;  
const int logn = 19;  
const long long MOD = 1000000007;  
const long long INF = 1e18;  
  
vector < vector <int> > divisor;  
  
void seive() {  
      divisor.resize(maxn);  
      for (int i = 1; i < maxn; i++) {  
            for (int j = 1; 1LL * i * j < maxn; j++) {  
                  divisor[i * j].push_back(i);  
            }  
      }  
}  
  
int Tree[maxn];  
  
void update(int pos, int val = 1) {  
      while (pos < maxn) {  
            Tree[pos] += val;  
            pos += (pos & -pos);  
      }  
}  
  
int query(int pos) {  
      int sum = 0;  
      while (pos > 0) {  
            sum += Tree[pos];  
            pos -= (pos & -pos);  
      }  
      return sum;  
}  
  
int query(int l, int r) {  
      return query(r) - query(l - 1);  
}  
  
struct Query {  
      int l, r, id;  
      Query(int l = 0, int r = 0, int id = 0)  
            : l(l), r(r), id(id) {}  
};  
  
signed main()  
{  
      ios_base::sync_with_stdio(false);  
      cin.tie(nullptr); cout.tie(nullptr);  
      cout.precision(12);  
  
      bool FILEIO = 0;  
      if (FILEIO and fopen("in.txt", "r")) {  
            freopen("in.txt", "r", stdin);  
      }  
  
      seive();  
  
      int n, q;  
      cin >> n >> q;  
      vector <int> arr(n + 1);  
      vector <int> position(n + 1);  
      for (int i = 1; i <= n; i++) {  
            cin >> arr[i];  
            position[ arr[i] ] = i;  
      }  
      vector <Query> queries;  
      for (int i = 1; i <= q; i++) {  
            int l, r;  
            cin >> l >> r;  
            queries.emplace_back(l, r, i);  
      }  
      vector <int> ans(q + 1);  
      sort(queries.begin(), queries.end(), [&](Query p, Query q)  
           {  
                 return p.r < q.r;  
           });  
      int l = 0;  
      for (Query it : queries) {  
            while (l < it.r) {  
                  ++l;  
                  for (int d : divisor[ arr[l] ]) {  
                        int pos = position[d];  
                        if (pos <= l) update(pos);  
                  }  
            }  
            ans[it.id] = query(it.l, it.r);  
      }  
      memset(Tree, 0, sizeof Tree);  
      sort(queries.begin(), queries.end(), [&](Query p, Query q)  
           {  
                 return p.l > q.l;  
           });  
      int r = n + 1;  
      for (Query it : queries) {  
            while (r > it.l) {  
                  --r;  
                  for (int d : divisor[ arr[r] ]) {  
                        int pos = position[d];  
                        if (pos > r) {  
                              update(pos);  
                        }  
                  }  
            }  
            ans[it.id] += query(it.l, it.r);  
      }  
      for (int i = 1; i <= q; i++) {  
            cout << ans[i] << endl;  
      }  
  
  
      #ifndef ONLINE_JUDGE  
            cerr << endl << "Time : " << 1.0 * clock() / CLOCKS_PER_SEC << " s." << endl;  
      #endif // ONLINE_JUDGE  
}