update

src/7/16/T633666.cpp

@@ -1,3 +1,167 @@
-int main(){
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <unordered_map>
+using namespace std;
+
+const int maxn = 1000000;
+
+
+int phi[maxn + 10];
+int gvt[maxn + 10];
+int f_temp[maxn + 10];
+int S1[maxn + 10];
+
+
+int F[maxn + 10];             
+int G_pre[maxn + 10];   
+int g_val[maxn + 10];         
+bool ispsf[maxn + 10];
+int prF[maxn + 10], cnt_sieveF = 0;
+
+
+unordered_map<int, int> cache;
+
+
+void init_phi() {
+    for (int i = 1; i <= maxn; i++) phi[i] = i;
+    for (int i = 2; i <= maxn; i++) {
+        if (phi[i] == i) {
+            for (int j = i; j <= maxn; j += i) {
+                phi[j] = phi[j] / i * (i - 1);
+            }
+        }
+    }
+}
+
+
+void init_F() {
+    for (int i = 1; i <= maxn; i++) {
+        ispsf[i] = true;
+    }
+    ispsf[1] = false;
+    F[1] = 1;
+    g_val[1] = 1;
+    for (int i = 2; i <= maxn; i++) {
+        if (ispsf[i]) {
+            prF[cnt_sieveF++] = i;
+            F[i] = i + 1;
+            g_val[i] = i + 1;
+        }
+        for (int j = 0; j < cnt_sieveF; j++) {
+            int p = prF[j];
+            int num = 1LL * i * p;
+            if (num > maxn) break;
+            ispsf[num] = false;
+            if (i % p == 0) {
+                g_val[num] = g_val[i] * p + 1;
+                F[num] = F[i] / g_val[i] * g_val[num];
+                break;
+            } else {
+                g_val[num] = p + 1;
+                F[num] = F[i] * F[p];
+            }
+        }
+    }
+    G_pre[0] = 0;
+    for (int i = 1; i <= maxn; i++) {
+        G_pre[i] = G_pre[i - 1] + F[i];
+    }
+}
+
+
+int getG(int n) {
+    if (n <= 0) return 0;
+    if (n <= maxn) {
+        return G_pre[n];
+    }
+    if (cache.find(n) != cache.end()) {
+        return cache[n];
+    }
+    int ans = 0;
+    int l = 1, r;
+    for (; l <= n; l = r + 1) {
+        int k = n / l;
+        r = n / k;
+        int sum_i = (int)(l + r) * (r - l + 1) / 2;
+        ans += (int)k * sum_i;
+    }
+    cache[n] = ans;
+    return ans;
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(0);
+
     
+    init_phi();
+    for (int i = 1; i <= maxn; i++) {
+        if (i == 1) {
+            gvt[i] = 1;
+        } else {
+            gvt[i] = (int)i * phi[i] / 2;
+        }
+    }
+    for (int d = 1; d <= maxn; d++) {
+        for (int j = d; j <= maxn; j += d) {
+            f_temp[j] += gvt[d];
+        }
+    }
+    for (int i = 1; i <= maxn; i++) {
+        S1[i] = (int)i * f_temp[i];
+    }
+
+    
+    init_F();
+
+    
+    vector<int> fib;
+    fib.push_back(1);
+    fib.push_back(1);
+    while (fib.back() < 100000) {
+        int next_fib = fib[fib.size() - 1] + fib[fib.size() - 2];
+        fib.push_back(next_fib);
+    }
+
+    int t;
+    cin >> t;
+    vector<pair<int, int>> que(t);
+    for (int i = 0; i < t; i++) {
+        cin >> que[i].first >> que[i].second;
+    }
+
+    
+    vector<int> type(t, 0);
+    int cur = 0;
+    int fibidx = 0;
+    while (cur < t) {
+        int num1 = fib[fibidx];
+        int end1 = min(cur + num1, t);
+        for (int i = cur; i < end1; i++) {
+            type[i] = 1;
+        }
+        cur = end1;
+        if (cur < t) {
+            type[cur] = 2;
+            cur++;
+        }
+        fibidx++;
+    }
+
+    
+    for (int i = 0; i < t; i++) {
+        int x = que[i].first;
+        int y = que[i].second;
+        if (type[i] == 1) {
+            int ans = S1[y] - S1[x];
+            cout << ans << '\n';
+        } else {
+            int res = getG(y) - getG(x - 1);
+            int ans = (int)res;
+            cout << ans << '\n';
+        }
+    }
+
+    return 0;
 }