update

src/5/17/T464001.cpp

@@ -0,0 +1,37 @@
+#include <cstdio>
+using namespace std;
+
+const int MAXN = 1e6 + 5;
+
+int a[MAXN];
+
+int main() {
+    int n;
+    scanf("%d", &n);
+    for (int i = 1; i <= n; ++i) {
+        scanf("%d", &a[i]);
+    }
+    int m;
+    scanf("%d", &m);
+    while (m--) {
+        int op;
+        scanf("%d", &op);
+        if (op == 1) {
+            int x, y;
+            scanf("%d%d", &x, &y);
+            a[x] = y;
+        } else {
+            int l, r, y;
+            scanf("%d%d%d", &l, &r, &y);
+            int ans = -1;
+            for (int p = l; p <= r; ++p) {
+                if (a[p] >= y) {
+                    ans = p;
+                    break;
+                }
+            }
+            printf("%d\n", ans);
+        }
+    }
+    return 0;
+}

src/5/31/T169734.cpp

@@ -0,0 +1,3 @@
+int main(){
+    
+}

src/5/31/T285013.cpp

@@ -0,0 +1,59 @@
+#include <iostream>
+#include <vector>
+#include <queue>
+using namespace std;
+
+const int maxn = 300010;
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(0);
+    int n;
+    cin >> n;
+    vector<vector<int>> g(n + 1);
+    for (int i = 0; i < n - 1; i++) {
+        int u, v;
+        cin >> u >> v;
+        g[u].push_back(v);
+        g[v].push_back(u);
+    }
+
+    vector<int> fa(n + 1, 0);
+    vector<int> dep(n + 1, 0);
+    vector<long long> size_arr(n + 1, 1);
+    vector<long long> sum_sq(n + 1, 0);
+    vector<int> nodes;
+
+    queue<int> q;
+    q.push(1);
+    fa[1] = 0;
+    dep[1] = 0;
+    while (!q.empty()) {
+        int u = q.front();
+        q.pop();
+        nodes.push_back(u);
+        for (int v : g[u]) {
+            if (v == fa[u]) continue;
+            fa[v] = u;
+            dep[v] = dep[u] + 1;
+            q.push(v);
+        }
+    }
+
+    for (int i = nodes.size() - 1; i >= 0; i--) {
+        int u = nodes[i];
+        if (fa[u] != 0) {
+            size_arr[fa[u]] += size_arr[u];
+            sum_sq[fa[u]] += size_arr[u] * size_arr[u];
+        }
+    }
+
+    long long ans = 0;
+    for (int u = 1; u <= n; u++) {
+        long long count_u = size_arr[u] * size_arr[u] - sum_sq[u];
+        ans += (long long)u * count_u;
+    }
+
+    cout << ans << endl;
+    return 0;
+}

src/6/T178359.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include <vector>
+using namespace std;
+
+const int mod = 1000000007;
+const int maxn = 100000;
+int pow2[maxn + 10]; // pre_pow_arr
+
+void pre_pow() {
+    pow2[0] = 1;
+    for (int i = 1; i <= maxn; i++) {
+        pow2[i] = (1LL * pow2[i - 1] * 2) % mod;
+    }
+}
+
+int main() {
+    pre_pow();
+    int n;
+    cin >> n;
+    vector<int> cnt(n + 1, 0);
+    for (int i = 0; i < n; i++) {
+        int x;
+        cin >> x;
+        cnt[x]++;
+    }
+
+    long long tot = 1; // F(1)
+    long long alt = 1;   // F(-1)
+    for (int i = 1; i <= n; i++) {
+        if (cnt[i] == 0) continue;
+        long long ways = pow2[cnt[i] - 1]; // 2^(c-1)
+        tot = tot * (1 + ways) % mod;
+        alt = alt * ((1 - ways + mod) % mod) % mod;
+    }
+
+    long long inv2 = (mod + 1) / 2; // modinv 2
+    long long ans = (tot - alt + mod) % mod * inv2 % mod;
+    cout << ans << endl;
+
+    return 0;
+}

src/6/T616963.cpp

@@ -0,0 +1,113 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+const int MAXN = 100000;
+const int MAXM = 100000;
+const int K = 17;
+const int mod = 1000000007;
+
+
+vector<vector<int>> divs(MAXN+1);
+vector<vector<vector<int>>> F_by_n_k(MAXN+1, vector<vector<int>>(K+1));
+int ways[MAXN+1][K+1];
+int C[MAXM+1][K+1];
+
+int main() {
+    for (int i=1; i<=MAXN; i++) {
+        for (int j=i; j<=MAXN; j+=i) {
+            divs[j].push_back(i);
+        }
+    }
+
+    ways[1][0] = 1;
+    for (int k=1; k<=K; k++) {
+        ways[1][k] = 0;
+    }
+
+    for (int n=2; n<=MAXN; n++) {
+        for (int k=0; k<=K; k++) {
+            if (k==0) {
+                F_by_n_k[n][k] = vector<int>(divs[n].size(), 0);
+                auto it = lower_bound(divs[n].begin(), divs[n].end(), 2);
+                if (it != divs[n].end()) {
+                    int idx = it - divs[n].begin();
+                    ways[n][k] = F_by_n_k[n][k][idx];
+                } else {
+                    ways[n][k] = 0;
+                }
+                continue;
+            }
+
+            int len = divs[n].size();
+            vector<int> F_vec(len, 0);
+            for (int i = len-1; i>=0; i--) {
+                int d = divs[n][i];
+                int j = n / d;
+                long long ways_temp = 0;
+
+                if (j == 1) {
+                    if (k-1 == 0) {
+                        ways_temp = 1;
+                    }
+                } else if (j <= MAXN && j >= 1 && k-1 >= 0) {
+                    vector<int> &div_j = divs[j];
+                    auto it_j = lower_bound(div_j.begin(), div_j.end(), d);
+                    if (it_j != div_j.end()) {
+                        int idx_j = it_j - div_j.begin();
+                        ways_temp = F_by_n_k[j][k-1][idx_j];
+                    }
+                }
+
+                int next_F = 0;
+                if (i+1 < len) {
+                    next_F = F_vec[i+1];
+                }
+                F_vec[i] = (next_F + ways_temp) % mod;
+            }
+
+            auto it = lower_bound(divs[n].begin(), divs[n].end(), 2);
+            if (it != divs[n].end()) {
+                int idx = it - divs[n].begin();
+                ways[n][k] = F_vec[idx];
+            } else {
+                ways[n][k] = 0;
+            }
+            F_by_n_k[n][k] = F_vec;
+        }
+    }
+
+    for (int i=0; i<=MAXM; i++) {
+        C[i][0] = 1;
+        if (i <= K) {
+            for (int j=1; j<=i && j<=K; j++) {
+                if (j == i) {
+                    C[i][j] = 1;
+                } else {
+                    C[i][j] = (C[i-1][j] + C[i-1][j-1]) % mod;
+                }
+            }
+        } else {
+            for (int j=1; j<=K; j++) {
+                C[i][j] = (C[i-1][j] + C[i-1][j-1]) % mod;
+            }
+        }
+    }
+
+    ios::sync_with_stdio(false);
+    cin.tie(0);
+    int T;
+    cin >> T;
+    while (T--) {
+        int n, m;
+        cin >> n >> m;
+        long long ans = 0;
+        int max_k = min(m, K);
+        for (int k=0; k<=max_k; k++) {
+            ans = (ans + 1LL * C[m][k] * ways[n][k]) % mod;
+        }
+        cout << ans << '\n';
+    }
+    return 0;
+}