text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n;
int a[N];
int dp[N][7][2];
bool nss[N];
vector<int> pr[N];
vector<int> g[N];
void init() {
for (int i = 2; i < N; i++) {
if (!nss[i]) {
for (int j = i; j < N; j += i) {
nss[j] = 1;
pr[j].push_back(i);
}
}
}
}
int ans;
void dfs(int u, int fa) {
for (int i = 0; i < pr[a[u]].size(); i++) {
dp[u][i][0] = 1;
}
for (auto v : g[u]) {
if (v == fa) continue;
dfs(v, u);
for (int i = 0; i < pr[a[u]].size(); i++) {
int x = pr[a[u]][i];
if (a[v] % x == 0) {
int pos = find(pr[a[v]].begin(), pr[a[v]].end(), x) - pr[a[v]].begin();
int tmp = dp[v][pos][0] + 1;
if (tmp > dp[u][i][0]) {
dp[u][i][1] = dp[u][i][0];
dp[u][i][0] = tmp;
} else if (tmp > dp[u][i][1]) {
dp[u][i][1] = tmp;
}
}
}
}
for (int i = 0; i < pr[a[u]].size(); i++) {
ans = max(ans, dp[u][i][0]);
ans = max(ans, dp[u][i][0] + dp[u][i][1] - 1);
}
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d %d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
ans = 0;
dfs(1, -1);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, t = 1;
register char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') {
ch = getchar();
}
if (ch == '-') {
t = -1, ch = getchar();
}
while (ch <= '9' && ch >= '0') {
x = x * 10 + ch - 48, ch = getchar();
}
return x * t;
}
struct Line {
int v, next;
} e[222222 << 1];
int h[222222], cnt = 1, mx;
inline void Add(int u, int v) {
e[cnt] = (Line){v, h[u]};
h[u] = cnt++;
}
vector<int> ys[222222];
int n, a[222222], tot;
bool book[222222], vis[222222];
long long ans[222222];
void Div(int x, int id) {
for (int i = 1, m = sqrt(x); i <= m; ++i)
if (x % i == 0) {
ys[i].push_back(id);
if (i * i != x) {
ys[x / i].push_back(id);
}
}
}
void dfs(int u, int ff) {
if (!book[u]) {
return;
}
vis[u] = true;
++tot;
for (int i = h[u]; i; i = e[i].next)
if (e[i].v != ff) {
dfs(e[i].v, u);
}
}
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
mx = max(mx, a[i] = read());
}
for (int i = 1; i <= n; ++i) {
Div(a[i], i);
}
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
Add(u, v);
Add(v, u);
}
for (int i = 1; i <= mx; ++i) {
for (int j = 0, l = ys[i].size(); j < l; ++j) {
int v = ys[i][j];
vis[v] = false;
book[v] = true;
}
for (int j = 0, l = ys[i].size(); j < l; ++j) {
tot = 0;
int v = ys[i][j];
if (!vis[v]) {
dfs(v, 0);
}
book[v] = false;
ans[i] += 1ll * tot * (tot - 1) / 2 + tot;
}
}
for (int i = mx; i; --i)
if (ans[i])
for (int j = i + i; j <= mx; j += i) {
ans[i] -= ans[j];
}
for (int i = 1; i <= mx; ++i)
if (ans[i]) {
printf("%d %I64d\n", i, ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000001;
int n, m, k, a[M], ver[M], nex[M], head[M], cnt, fa[M], dp[M], tmp[M], sz[M];
vector<int> v[M];
long long d[M];
void add(int x, int y) {
ver[++cnt] = y, nex[cnt] = head[x], head[x] = cnt;
ver[++cnt] = x, nex[cnt] = head[y], head[y] = cnt;
}
void dfs(int x, int f) {
fa[x] = f;
dp[x] = dp[f] + 1;
for (int i = head[x]; i; i = nex[i]) {
if (ver[i] == f) continue;
dfs(ver[i], x);
}
}
bool cmp(int a, int b) { return dp[a] > dp[b]; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), v[a[i]].push_back(i), m = max(m, a[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
}
dfs(1, 0);
for (int i = 1; i <= m; i++) {
int cnt = 0;
for (int j = i; j <= m; j += i) {
for (int l = 0; l < v[j].size(); l++) tmp[++cnt] = v[j][l];
}
sort(tmp + 1, tmp + 1 + cnt, cmp);
d[i] = cnt;
for (int j = 1; j <= cnt; j++) sz[tmp[j]] = 1;
for (int j = 1; j <= cnt; j++) {
int x = tmp[j], f = fa[x];
if (!sz[f]) continue;
d[i] = (d[i] + (long long)sz[x] * sz[f]);
sz[f] += sz[x];
}
for (int j = 1; j <= cnt; j++) sz[tmp[j]] = 0;
}
for (int i = m; i >= 1; i--)
for (int j = i + i; j <= m; j += i) d[i] -= d[j];
for (int i = 1; i <= m; i++)
if (d[i]) printf("%d %lld\n", i, d[i]);
}
|
#include <bits/stdc++.h>
class dsu {
int fa[200005], sz[200005];
public:
void init(int pos) {
fa[pos] = -1;
sz[pos] = 1;
}
int query_root(int pos) {
return fa[pos] == -1 ? pos : (fa[pos] = query_root(fa[pos]));
}
int query_size(int pos) { return sz[query_root(pos)]; }
void merge(int pa, int child) {
pa = query_root(pa);
child = query_root(child);
if (pa != child) {
fa[child] = pa;
sz[pa] += sz[child];
}
}
};
dsu du;
int a[200005], maxa;
std::vector<int> nodes[200005];
std::vector<int> adj[200005];
int64_t ans[200005];
int n;
int main(int argc, char* argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
nodes[a[i]].push_back(i);
maxa = std::max(maxa, a[i]);
}
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = maxa; i > 0; --i) {
int64_t& nowans = ans[i];
std::vector<int> rd;
for (int j = i; j <= maxa; j += i) {
for (int nd : nodes[j]) du.init(nd);
rd.insert(rd.end(), nodes[j].begin(), nodes[j].end());
}
for (int nd : rd) {
for (int nxt : adj[nd]) {
if (a[nxt] % i)
continue;
else {
if (du.query_root(nd) != du.query_root(nxt)) {
nowans += (int64_t)du.query_size(nd) * du.query_size(nxt);
du.merge(nd, nxt);
}
}
}
}
for (int j = i + i; j <= maxa; j += i) nowans -= ans[j];
}
for (int i = 1; i <= maxa; ++i) ans[i] += nodes[i].size();
for (int i = 1; i <= maxa; ++i) {
if (ans[i]) printf("%d %lld\n", i, ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
int primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101,
103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167,
173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239,
241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397,
401, 409, 419, 421, 431, 433, 439, 443};
int mgcd = 0;
int n;
std::vector<int> a;
std::vector<std::vector<int>> e;
int work(int v, int p, int d, bool strict) {
if (d < 2) {
return 0;
}
bool ok = a[v] % d == 0;
if (ok) {
while (a[v] % d == 0) {
a[v] /= d;
}
}
if (strict && !ok) {
return 0;
}
int m1 = 0;
int m2 = 0;
std::vector<int> children = e[v];
for (std::vector<int>::const_iterator i = children.begin();
i != children.end(); ++i) {
if (*i != p) {
int ch = work(*i, v, d, strict);
if (ch > m2) {
m1 = m2;
m2 = ch;
} else if (ch > m1) {
m1 = ch;
}
}
}
if (ok && m1 + m2 + 1 > mgcd) {
mgcd = m1 + m2 + 1;
}
return ok ? m2 + 1 : 0;
}
int main() {
std::cin >> n;
a.resize(n);
e.resize(n);
for (int i = 0; i < n; ++i) {
std::cin >> a[i];
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
std::cin >> x >> y;
--x;
--y;
e[x].push_back(y);
e[y].push_back(x);
}
for (int i = 0; i < sizeof(primes) / sizeof(int); ++i) {
int d = primes[i];
work(0, -1, d, false);
}
for (int i = 0; i < n; ++i) {
if (a[i] > 444) {
work(i, -1, a[i], true);
}
}
std::cout << mgcd << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 13, N = 2e5;
long long n, ans[maxN], a[maxN], cur;
vector<int> adj[maxN], vec[maxN], node, dv[maxN];
bool mark[maxN];
void dfs(int v, int val) {
mark[v] = 1;
node.push_back(v);
if (a[v] % val == 0) cur++;
for (auto u : adj[v]) {
if (!mark[u] && a[u] % val == 0) dfs(u, val);
}
}
long long solve(int x) {
long long ret = 0;
for (auto a : vec[x]) {
cur = 0;
if (!mark[a]) {
dfs(a, x);
ret += cur * (cur + 1) / 2;
}
}
while (node.size()) {
int v = node.back();
node.pop_back();
mark[v] = 0;
}
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= N; i++)
for (int j = 1; j * j <= i; j++) {
if (i % j == 0) {
dv[i].push_back(j);
if (j * j != i) dv[i].push_back(i / j);
}
}
for (int i = 0; i < n; i++) {
cin >> a[i + 1];
for (auto j : dv[a[i + 1]]) {
vec[j].push_back(i + 1);
}
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = N; i >= 1; i--) {
ans[i] += solve(i);
for (auto j : dv[i]) {
if (j != i) ans[j] -= ans[i];
}
}
for (int i = 1; i <= N; i++)
if (ans[i] != 0) cout << i << " " << ans[i] << '\n';
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const long double pi = 3.141592653589793238462643383279;
const long double log23 = 1.58496250072115618145373894394781;
const long double eps = 1e-11;
const long long INF = 1e18 + 239;
const long long prost = 239;
const int two = 2;
const int th = 3;
const long long MOD = 1e9 + 7;
const long long MOD2 = MOD * MOD;
const int BIG = 2 * 1e9 + 239;
const int alf = 26;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
const int dxo[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
const int dyo[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dig = 10;
const string str_alf = "abcdefghijklmnopqrstuvwxyz";
const string str_alf_big = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const int day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int digarr[10] = {6, 2, 5, 5, 4, 5, 6, 3, 7, 6};
const int bt = 31;
template <typename T>
inline T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <typename T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
inline bool is_down(char x) { return ('a' <= x && x <= 'z'); }
inline bool is_upper(char x) { return ('A' <= x && x <= 'Z'); }
inline bool is_digit(char x) { return ('0' <= x && x <= '9'); }
long long power(long long a, int k) {
long long ans = 1;
while (k) {
if (k & 1) ans = (ans * a) % MOD;
ans = (ans * ans) % MOD;
k >>= 1;
}
return ans;
}
mt19937 rnd(239);
const int M = 2 * 1e5 + 239;
const int N = 2 * 1e3 + 239;
const int L = 20;
const int T = (1 << 20);
const int B = trunc(sqrt(M)) + 1;
const int X = 1e6 + 239;
bool can[M], used[M];
int n, a[M];
vector<int> ids[M];
vector<int> v[M];
long long ans[M], sz;
inline void dfs(int p) {
used[p] = true;
sz++;
for (int i : v[p])
if (can[i] && !used[i]) dfs(i);
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) ids[a[i]].push_back(i);
for (int i = 0; i < n - 1; i++) {
int s, f;
cin >> s >> f;
s--, f--;
v[s].push_back(f);
v[f].push_back(s);
}
memset(can, 0, sizeof(can));
memset(used, 0, sizeof(used));
for (int i = 1; i < M; i++) {
vector<int> now;
for (int x = i; x < M; x += i)
for (int t : ids[x]) now.push_back(t);
for (int t : now) can[t] = true;
ans[i] = 0;
for (int t : now)
if (!used[t]) {
sz = 0;
dfs(t);
ans[i] += (sz * (sz + 1)) / 2LL;
}
for (int t : now) can[t] = false;
for (int t : now) used[t] = false;
}
for (int i = M - 1; i >= 1; i--)
for (int x = 2 * i; x < M; x += i) ans[i] -= ans[x];
for (int i = 1; i < M; i++)
if (ans[i] != 0) cout << i << " " << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int prime[50000];
int lp[200102];
class prime_class {
public:
long top;
prime_class() {
int i, i2, j;
top = 0;
lp[0] = 0;
lp[1] = 1;
for (i = 2; i < 200102; i++) lp[i] = 0;
top = 0;
for (i = 2; i < 200102; ++i) {
if (lp[i] == 0) {
lp[i] = i;
prime[top++] = i;
}
for (j = 0; (j < top) && (prime[j] <= lp[i]) && (i * prime[j] < 200102);
++j)
lp[i * prime[j]] = prime[j];
}
}
bool isprime(int key) {
if (key < 200102)
return (lp[key] == key) && (key >= 2);
else {
int i;
for (i = 0; (i < top) && (prime[i] * prime[i] <= key); i++)
if (key % prime[i] == 0) return false;
return true;
}
}
unordered_map<int, int> factorize(int key) {
unordered_map<int, int> ans;
while (lp[key] != key) {
ans[lp[key]]++;
key /= lp[key];
}
if (key > 1) ans[key]++;
return ans;
}
vector<pair<long long, long long>> factorize_full(long long key) {
vector<pair<long long, long long>> ans;
long i, ct;
for (i = 0; (i < top) && (prime[i] <= key); i++)
if (key % prime[i] == 0) {
ct = 0;
while (key % prime[i] == 0) {
ct++;
key /= prime[i];
}
ans.push_back({prime[i], ct});
}
if (key > 1) {
ans.push_back({key, 1});
}
return ans;
}
void generate_divisors(int step, int v, vector<pair<int, int>> &fp,
vector<int> &ans) {
if (step < fp.size()) {
generate_divisors(step + 1, v, fp, ans);
for (int i = 1; i <= fp[step].second; i++) {
v *= fp[step].first;
generate_divisors(step + 1, v, fp, ans);
}
} else
ans.push_back(v);
}
vector<int> get_divisors(int key) {
unordered_map<int, int> f = factorize(key);
int n = f.size();
vector<pair<int, int>> fp;
for (auto p : f) fp.push_back(p);
vector<int> ans;
generate_divisors(0, 1, fp, ans);
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
prime_class pr;
int n, i, j, k, x, y, id, ans;
cin >> n;
vector<int> a(n + 1);
for (i = 1; i <= n; i++) cin >> a[i];
vector<vector<int>> adj(n + 1), son(n + 1);
vector<int> parent(n + 1, -1);
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
queue<int> q;
stack<int> st;
q.push(1);
parent[1] = 0;
st.push(1);
while (!q.empty()) {
id = q.front();
q.pop();
for (auto p : adj[id]) {
if (parent[p] == -1) {
parent[p] = id;
son[id].push_back(p);
q.push(p);
st.push(p);
}
}
}
ans = 0;
vector<map<int, int>> best(n + 1);
while (!st.empty()) {
id = st.top();
st.pop();
if (a[id] > 1) ans = max(ans, 1);
unordered_map<int, int> f = pr.factorize(a[id]);
for (auto p : f) best[id][p.first] = 1;
for (auto x : son[id]) {
for (auto p : best[x]) {
if (best[id].find(p.first) != best[id].end()) {
ans = max(ans, best[id][p.first] + p.second);
best[id][p.first] = max(best[id][p.first], 1 + p.second);
}
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
inline T gethash(T h[], T power[], int l, int r) {
if (r < l) return (T)0;
return h[l] - h[r + 1] * power[r - l + 1];
}
struct data {
data() {}
bool friend operator<(data a, data b) { return 0; }
};
int n, m, k;
long long N, M, K;
int a[200005];
long long ans[200005];
vector<int> adj[200005];
int subtree[200005];
bool bad[200005];
int tot = 0;
int cnt[200005];
unordered_set<int> st;
unordered_set<int>::iterator it;
unordered_map<int, int> mm[200005];
int _gcd(int a, int b) {
if (a == 0) return b;
if (b == 0) return a;
int p = _gcd(b, a % b);
return p;
}
void dfs(int u, int p) {
subtree[u] = 1;
tot++;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p || bad[v]) continue;
dfs(v, u);
subtree[u] += subtree[v];
}
}
int getcenter(int u, int p) {
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p || bad[v]) continue;
if (subtree[v] > tot / 2) return getcenter(v, u);
}
return u;
}
void query(int u, int p, int g) {
g = _gcd(g, a[u]);
for (it = st.begin(); it != st.end(); it++) {
int x = *it;
int gc = _gcd(g, x);
ans[gc] += cnt[x];
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p || bad[v]) continue;
query(v, u, g);
}
}
void update(int u, int p, int g) {
g = _gcd(a[u], g);
st.insert(g);
cnt[g]++;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == p || bad[v]) continue;
update(v, u, g);
}
}
void decompose(int u, int p) {
tot = 0;
dfs(u, p);
int c = getcenter(u, p);
ans[a[c]]++;
cnt[a[c]] = 1;
st.insert(a[c]);
bad[c] = 1;
for (int i = 0; i < adj[c].size(); i++) {
int v = adj[c][i];
if (v == p || bad[v]) continue;
query(v, c, 0);
update(v, c, a[c]);
}
for (it = st.begin(); it != st.end(); it++) {
int x = *it;
cnt[x] = 0;
}
st.clear();
for (int i = 0; i < adj[c].size(); i++) {
int v = adj[c][i];
if (v == p || bad[v]) continue;
decompose(v, c);
}
}
int main() {
int t, tc = 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
decompose(1, -1);
for (int i = 1; i <= 200000; i++) {
if (ans[i]) {
printf("%d %lld\n", i, ans[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200020;
int n;
vector<int> v[N];
vector<int> g[N];
int lab[N];
int sz;
int appear[N];
long long save[N];
int changes[N * 40];
long long curr = 0;
void recover() {
curr = 0;
while (sz > 0) lab[changes[sz--]] = -1;
}
int fin(int u) {
if (lab[u] < 0) return u;
changes[++sz] = u;
return lab[u] = fin(lab[u]);
}
void join(int u, int v) {
u = fin(u);
v = fin(v);
if (u == v) return;
changes[++sz] = u;
changes[++sz] = v;
if (lab[u] > lab[v]) swap(u, v);
curr += 1LL * lab[u] * lab[v];
lab[u] += lab[v];
lab[v] = u;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
v[x].push_back(i);
}
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
memset(lab, -1, sizeof lab);
for (int i = 200000; i >= 1; --i) {
recover();
for (int j = i; j < N; j += i) {
save[i] -= (j > i) * (save[j]);
for (int x : v[j]) {
save[i]++;
appear[x] = 1;
for (int y : g[x]) {
if (appear[y]) join(x, y);
}
}
}
save[i] += curr;
for (int j = i; j < N; j += i) {
for (int x : v[j]) appear[x] = 0;
}
}
for (int i = 1; i < N; ++i) {
if (save[i]) printf("%d %lld\n", i, save[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 2e5 + 5;
vector<bool> isprime(N, true), vis(N, false), take(N, false);
long long int path = 0;
vector<long long int> adj[N], fact[N], mul[N], prime;
long long int dfs(long long int u, long long int p = -1) {
long long int mx1 = 0, mx2 = 0;
vis[u] = true;
for (auto v : adj[u]) {
if (v != p && take[v]) {
long long int sz = dfs(v, u);
if (sz > mx1) {
mx2 = mx1;
mx1 = sz;
} else if (sz <= mx1 && sz > mx2) {
mx2 = sz;
}
}
}
path = max(path, mx1 + mx2 + 1);
return mx1 + 1;
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int t, pro = 1, temp, k, n, m, i, j, l, r, mid, x, y, z, rem, ind,
ans = 0, mx = -LONG_LONG_MAX, mn = LONG_LONG_MAX, cnt = 0,
curr = 0, prev, sum = 0, flag = 0, i1 = -1, i2 = -1;
cin >> n;
long long int a[n + 1];
for (i = 2; i <= N - 1; i++) {
if (isprime[i]) {
prime.push_back(i);
for (j = i; j < N; j += i) {
isprime[j] = false;
fact[j].push_back(i);
}
}
}
for (i = 1; i <= n; i++) {
cin >> a[i];
for (auto f : fact[a[i]]) {
mul[f].push_back(i);
}
}
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (auto p : prime) {
for (auto nd : mul[p]) {
take[nd] = true;
}
for (auto nd : mul[p]) {
if (!vis[nd]) {
dfs(nd);
}
}
for (auto nd : mul[p]) {
take[nd] = vis[nd] = false;
}
}
cout << path;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ans;
int a[200020], val[200020];
int primo[200020];
vector<int> primos;
vector<int> adj[200020];
int vis[200020];
set<int> mult[200020];
void dfs(int u, int last, int p) {
if (vis[u] || p == 1 || !mult[u].count(p)) return;
vis[u] = val[u] = 1;
int mx1 = -1, mx2 = -1;
for (int i = (int)0; i < (int)adj[u].size(); i++) {
int v = adj[u][i];
if (vis[v]) continue;
dfs(v, u, p);
if (mx1 == -1) {
mx1 = val[v];
} else {
if (val[v] >= mx1) {
mx2 = mx1;
mx1 = val[v];
} else {
mx2 = max(mx2, val[v]);
}
}
}
if (mx1 != -1) val[u] += mx1;
ans = max(ans, val[u]);
if (mx2 != -1) ans = max(ans, mx1 + mx2 + 1);
}
void buildPrimos() {
memset(primo, 1, sizeof primo);
primo[0] = primo[1] = 0;
int fim = sqrt(200002);
for (int i = 2; i <= fim; i++) {
if (primo[i]) {
for (int j = i * i; j <= fim; j += i) primo[j] = 0;
}
}
for (int i = (int)1; i < (int)fim + 1; i++) {
if (primo[i]) {
primos.push_back(i);
}
}
}
int main() {
buildPrimos();
scanf("%d", &n);
for (int i = (int)1; i < (int)n + 1; i++) scanf("%d", &a[i]);
int u, v;
for (int i = (int)1; i < (int)n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = (int)1; i < (int)n + 1; i++) {
for (int j = (int)0; j < (int)primos.size(); j++) {
if (a[i] % primos[j] == 0) {
mult[i].insert(primos[j]);
while (a[i] % primos[j] == 0) a[i] /= primos[j];
}
}
}
for (int i = (int)1; i < (int)n + 1; i++) mult[i].insert(a[i]);
for (int z = (int)0; z < (int)primos.size(); z++) {
memset(vis, 0, sizeof vis);
memset(val, 0, sizeof val);
for (int i = (int)1; i < (int)n + 1; i++) {
dfs(i, i, primos[z]);
}
}
memset(vis, 0, sizeof vis);
memset(val, 0, sizeof val);
for (int i = (int)1; i < (int)n + 1; i++) {
dfs(i, i, a[i]);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
x = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0) {
putchar('-'), write(-x);
} else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
const int N = 2e5 + 5;
long long cnt[N];
int f[N], sz[N], n, ma, en, h[N], m, id[N], lis[N];
vector<int> val[N];
struct edge {
int n, v;
} e[N << 1];
inline void add(const int &x, const int &y) {
e[++en] = (edge){h[x], y};
h[x] = en;
}
inline int getf(const int &x) { return f[x] == x ? x : f[x] = getf(f[x]); }
inline void swap(int &x, int &y) { x ^= y ^= x ^= y; }
inline void unite(int x, int y) {
x = getf(x);
y = getf(y);
if (x == y) return;
if (sz[y] < sz[x]) swap(x, y);
sz[x] += sz[y];
f[y] = x;
}
inline int max(const int &x, const int &y) { return x > y ? x : y; }
signed main() {
read(n);
for (int i = 1, x; i <= n; i++) ma = max(ma, read(x)), val[x].push_back(i);
for (int i = 1, x, y; i < n; i++) {
read(x);
read(y);
add(x, y);
add(y, x);
}
for (register int i = 1; i <= ma; i++) {
m = 0;
for (register int j = i; j <= ma; j += i)
for (register int k = 0; k < val[j].size(); k++)
lis[++m] = val[j][k], sz[m] = 1, f[m] = m, id[val[j][k]] = m;
if (!m) continue;
cnt[i] = m;
for (register int j = 1; j <= m; j++) {
int x = lis[j];
for (register int k = h[x]; k; k = e[k].n) {
int y = e[k].v;
if (!id[y]) continue;
unite(id[x], id[y]);
}
}
for (int j = 1; j <= m; j++) {
int x = getf(j);
if (x == j) cnt[i] += 1ll * sz[x] * (sz[x] - 1) >> 1;
}
for (register int j = 1; j <= m; j++) id[lis[j]] = 0;
}
for (register int i = ma; i; i--)
for (register int j = i + i; j <= ma; j += i) cnt[i] -= cnt[j];
for (register int i = 1; i <= ma; i++)
if (cnt[i]) {
write(i);
putchar(' ');
write(cnt[i]);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n, a[N];
vector<int> g[N], fac[N];
int sz[N], rt, minv, sum, cnt1[N], cnt2[N];
bool vis[N];
unsigned long long ans[N];
unsigned long long gcd(unsigned long long a, unsigned long long b) {
if (!b) return a;
return gcd(b, a % b);
}
void dfs(int u, int f) {
sz[u] = 1;
int r = 0;
for (int v : g[u]) {
if (v == f || vis[v]) continue;
dfs(v, u);
sz[u] += sz[v];
r = max(r, sz[v]);
}
r = max(r, sum - sz[u]);
if (r < minv) {
minv = r;
rt = u;
}
}
int dfs2(int u, int f) {
int ret = 1;
for (int v : g[u])
if (v != f && !vis[v]) ret += dfs2(v, u);
return ret;
}
void dfs3(int u, int f, int gg, int d) {
gg = gcd(gg, a[u]);
for (int i : fac[gg]) cnt2[i] += d;
for (int v : g[u])
if (v != f && !vis[v]) dfs3(v, u, gg, d);
}
void solve(int u) {
for (int i : fac[a[u]]) ans[i]++;
bool flag = 0;
for (int v : g[u]) {
if (vis[v]) continue;
dfs3(v, u, 0, 1);
if (!flag) {
for (int i : fac[a[u]]) ans[i] += cnt2[i];
flag = 1;
} else {
for (int i : fac[a[u]]) ans[i] += 1LL * (cnt1[i] + 1) * cnt2[i];
}
for (int i : fac[a[u]]) cnt1[i] += cnt2[i];
for (int i : fac[a[v]]) cnt2[i] = 0;
}
for (int i : fac[a[u]]) cnt1[i] = 0;
vis[u] = 1;
for (int v : g[u]) {
if (vis[v]) continue;
sum = dfs2(v, u);
minv = N;
dfs(v, u);
solve(rt);
}
}
int main() {
ios::sync_with_stdio(0);
scanf("%d", &n);
for (int i = int(1); i <= int(N - 1); ++i) {
for (int j = i; j < N; j += i) fac[j].push_back(i);
}
for (int i = int(1); i <= int(n); ++i) scanf("%d", a + i);
for (int i = int(1); i <= int(n - 1); ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
minv = N;
sum = n;
dfs(1, 0);
solve(rt);
for (int i = int((int)1e5); i >= int(1); --i) {
for (int j = i + i; j <= (int)2e5; j += i) ans[i] -= ans[j];
}
for (int i = int(1); i <= int((int)2e5); ++i)
if (ans[i]) cout << i << " " << ans[i] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2E5 + 5;
const long long int base = 2E5 + 5;
int n, val[maxn];
int head[maxn * 2], size;
long long int ans[maxn], wait[maxn];
bool vis[maxn];
inline int gcd(int x, int y) { return x % y == 0 ? y : gcd(y, x % y); }
struct edge {
int to, next;
} E[maxn * 2];
inline void add(int u, int v) {
E[++size].to = v;
E[size].next = head[u];
head[u] = size;
}
struct note {
int x, c;
note(int a = 0, int b = 0) { x = a, c = b; }
};
queue<note> T[maxn];
vector<note> t;
void dfs(int u, int F) {
vector<int> what;
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].to;
if (v == F) continue;
dfs(v, u);
}
for (int i = head[u]; i; i = E[i].next) {
int v = E[i].to;
if (v == F) continue;
t.clear();
while (!T[v].empty()) {
t.push_back(T[v].front());
T[v].pop();
}
for (int j = 0; j < what.size(); ++j) {
int x = what[j];
for (int k = 0; k < t.size(); ++k)
ans[gcd(x, t[k].x)] += wait[x] * t[k].c;
}
for (int j = 0; j < t.size(); ++j) {
int x = gcd(val[u], t[j].x);
if (!vis[x]) {
vis[x] = 1;
wait[x] = t[j].c;
what.push_back(x);
} else
wait[x] += t[j].c;
}
}
if (!vis[val[u]]) {
vis[val[u]] = 1;
wait[val[u]] = 1;
what.push_back(val[u]);
} else
++wait[val[u]];
for (int i = 0; i < what.size(); ++i) {
long long int x = what[i];
ans[x] += wait[x];
T[u].push(note(x, wait[x]));
vis[x] = wait[x] = 0;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> val[i];
for (int i = 1; i <= n - 1; ++i) {
int x, y;
cin >> x >> y;
add(x, y);
add(y, x);
}
dfs(1, 1);
for (int i = 1; i <= 200000; ++i)
if (ans[i]) cout << i << " " << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
int a[N];
long long ans[N];
map<int, long long> mp[N];
vector<vector<int> > g;
int Gcd(int a, int b) { return (b ? Gcd(b, a % b) : a); }
void dfs(int u, int p = -1) {
mp[u][a[u]] = 1;
ans[a[u]]++;
for (auto v : g[u]) {
if (v == p) continue;
dfs(v, u);
for (auto x : mp[u])
for (auto y : mp[v])
ans[Gcd(x.first, y.first)] += 1LL * x.second * y.second;
for (auto y : mp[v]) mp[u][Gcd(a[u], y.first)] += y.second;
mp[v].clear();
}
}
void solve() {
int n;
cin >> n;
g.resize(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1);
for (int i = 1; i < N; i++) {
if (ans[i]) cout << i << ' ' << ans[i] << '\n';
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int miu[N + 5], prime[N + 5], pcnt;
bool not_prime[N + 5];
void shai() {
miu[1] = 1;
for (int i = 2; i <= N; i++) {
if (!not_prime[i]) {
pcnt++;
prime[pcnt] = i;
miu[i] = -1;
}
for (int j = 1; prime[j] * i <= N; j++) {
not_prime[prime[j] * i] = 1;
if (i % prime[j] == 0) {
miu[prime[j] * i] = 0;
break;
}
miu[prime[j] * i] = -miu[i];
}
}
}
int a[N + 5];
int cnt;
vector<int> val[N + 5];
vector<int> G[N + 5];
int good[N + 5];
int vis[N + 5];
long long h[N + 5];
long long ans[N + 5];
int q[N + 5];
int bfs(int x) {
int head = 0;
int tail = 0;
q[tail++] = x;
vis[x] = cnt;
while (head < tail) {
int z = q[head++];
for (int i = 0, sz = G[z].size(); i < sz; i++) {
int y = G[z][i];
if (good[a[y]] == cnt && vis[y] < cnt) {
vis[y] = cnt;
q[tail++] = y;
}
}
}
return tail;
}
int main() {
shai();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
val[a[i]].push_back(i);
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = N; i > 0; i--) {
cnt++;
for (int j = i; j <= N; j += i) good[j] = cnt;
for (int j = i; j <= N; j += i)
for (int k = 0, sz = val[j].size(); k < sz; k++) {
int x = val[j][k];
if (vis[x] == cnt) continue;
int z = bfs(x);
h[i] += 1ll * z * (z + 1) / 2;
}
for (int j = i, k = 1; j <= N; j += i, k++) ans[i] += miu[k] * h[j];
}
for (int i = 1; i <= N; i++)
if (ans[i] > 0) printf("%d %I64d\n", i, ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int a[maxn];
int dp[maxn][10];
vector<int> G[maxn];
vector<int> vec[maxn];
map<pair<int, int>, int> mp;
int ans;
void dfs(int x, int fa) {
for (int i = 0; i < G[x].size(); i++) dp[x][i] = 1;
int f1[10], f2[10];
memset(f1, 0, sizeof(f1));
memset(f2, 0, sizeof(f2));
for (int i = 0; i < vec[x].size(); i++) {
int to = vec[x][i];
if (to == fa) continue;
dfs(to, x);
for (int j = 0; j < G[x].size(); j++) {
if (a[to] % G[x][j] == 0) {
int pos = mp[pair<int, int>(G[x][j], to)];
int tmp = dp[to][pos];
if (f1[j] < tmp) {
f2[j] = f1[j];
f1[j] = tmp;
} else if (f2[j] < tmp) {
f2[j] = tmp;
}
}
}
}
for (int i = 0; i < G[x].size(); i++) {
dp[x][i] += f1[i];
ans = max(ans, f1[i] + f2[i] + 1);
}
return;
}
int main() {
ios::sync_with_stdio(false);
int n, u, v;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
int tmp = a[i];
for (int j = 2; j * j <= tmp; j++) {
if (tmp % j == 0) {
G[i].push_back(j);
mp[pair<int, int>(j, i)] = G[i].size() - 1;
while (tmp % j == 0) tmp /= j;
}
}
if (tmp > 1) {
G[i].push_back(tmp);
mp[pair<int, int>(tmp, i)] = G[i].size() - 1;
}
}
for (int i = 1; i <= n - 1; i++) {
cin >> u >> v;
vec[u].push_back(v);
vec[v].push_back(u);
}
dfs(1, -1);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace SHENZHEBEI {
static const int GYN = 2333333;
char SZB[GYN], *SS = SZB, *TT = SZB;
inline char gc() {
if (SS == TT) {
TT = (SS = SZB) + fread(SZB, 1, GYN, stdin);
if (SS == TT) return '\n';
}
return *SS++;
}
inline long long read() {
long long x = 0, g = 1;
char ch = gc();
for (; !isdigit(ch); ch = gc())
if (ch == '-') g = -1;
for (; isdigit(ch); ch = gc()) x = x * 10 - 48 + ch;
return x * g;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline char readchar() {
char ch = gc();
for (; isspace(ch); ch = gc())
;
return ch;
}
inline long long readstr(char *s) {
char ch = gc();
int cur = 0;
for (; isspace(ch); ch = gc())
;
for (; !isspace(ch); ch = gc()) s[cur++] = ch;
s[cur] = '\0';
return cur;
}
void Print(long long *a, int s, int t) {
for (int i = int(s); i <= int(t); ++i) printf("%lld ", a[i]);
}
void Print(int *a, int s, int t) {
for (int i = int(s); i <= int(t); ++i) printf("%d ", a[i]);
}
void Print(char *a, int s, int t) {
for (int i = int(s); i <= int(t); ++i) putchar(a[i]);
}
void writeln(long long x) {
write(x);
puts("");
}
} // namespace SHENZHEBEI
using namespace SHENZHEBEI;
const long long N = 200010;
vector<int> g[N], h[N];
long long id[N], a[N], sum[N], answ[N], fa[N], dep[N], vis[N], ok[N], n, cnt,
cogito;
void dfs(long long x) {
for (int i = int(0); i < int(g[x].size()); ++i) {
long long to = g[x][i];
if (to == fa[x]) continue;
dep[to] = dep[x] + 1;
fa[to] = x;
dfs(to);
}
}
void insert(long long x, long long w) {
cnt = 0;
for (long long i = 1; i * i <= w; i++)
if (!(w % i)) {
h[i].push_back(x);
++cnt;
if (i * i != w) h[w / i].push_back(x);
++cnt;
}
((cogito) = ((cogito) < (cnt) ? (cnt) : (cogito)));
}
bool cmp(long long a, long long b) { return dep[a] > dep[b]; }
int main() {
n = read();
for (int i = int(1); i <= int(n); ++i) id[i] = i;
for (int i = int(1); i <= int(n); ++i) a[i] = read();
for (int i = int(1); i < int(n); ++i) {
long long x = read(), y = read();
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
sort(id + 1, id + n + 1, cmp);
for (int i = int(1); i <= int(n); ++i) insert(id[i], a[id[i]]);
for (int val = int(1); val <= int(200000); ++val) {
for (int i = int(0); i < int(h[val].size()); ++i) ok[i] = h[val][i];
long long Sum = h[val].size();
long long ans = 0;
for (int i = int(0); i < int(Sum); ++i) vis[ok[i]] = val, sum[ok[i]] = 1;
for (int i = int(0); i < int(Sum); ++i) {
long long x = ok[i];
if (vis[fa[x]] != val)
ans += sum[x] * (sum[x] + 1) >> 1;
else
sum[fa[x]] += sum[x];
}
answ[val] = ans;
}
for (int i = int(200000); i >= int(1); --i)
for (long long j = 2 * i; j <= 200000; j += i) answ[i] -= answ[j];
for (int i = int(1); i <= int(200000); ++i)
if (answ[i]) write(i), putchar(' '), writeln(answ[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
static inline int ctz(unsigned x) { return __builtin_ctz(x); }
static inline int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
static inline int clz(unsigned x) { return __builtin_clz(x); }
static inline int clzll(unsigned long long x) { return __builtin_clzll(x); }
static inline int popcnt(unsigned x) { return __builtin_popcount(x); }
static inline int popcntll(unsigned long long x) {
return __builtin_popcountll(x);
}
static inline int bsr(unsigned x) { return 31 ^ clz(x); }
static inline int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
int a[200008];
int id[200008];
int sz[200008];
int rk[200008];
void rst(int x) {
id[x] = x;
sz[x] = 1;
rk[x] = 0;
}
int fin(int x) { return id[x] == x ? x : id[x] = fin(id[x]); }
void uni(int x, int y) {
if (rk[x] < rk[y]) {
id[x] = y;
sz[y] += sz[x];
} else {
id[y] = x;
sz[x] += sz[y];
rk[x] = max(rk[x], rk[y] + 1);
}
}
vector<int> vs[200008];
vector<pair<int, int> > es[200008];
long long ans[200008];
int main() {
canhazfast();
int n, amx = 0;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
amx = max(amx, a[i]);
vs[a[i]].push_back(i);
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
es[gcd(a[x], a[y])].push_back(make_pair(x, y));
}
for (int i = amx; i > 0; --i) {
long long res = 0;
for (int j = i; j <= amx; j += i) {
res += (long long)vs[j].size();
for (int v : vs[j]) rst(v);
if (j > i) res -= ans[j];
}
for (int j = i; j <= amx; j += i) {
for (pair<int, int> e : es[j]) {
int x = fin(e.first), y = fin(e.second);
res += (long long)sz[x] * sz[y];
uni(x, y);
}
}
ans[i] = res;
}
for (int i = 1; i <= amx; ++i)
if (ans[i]) cout << i << ' ' << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2 * acos(0.0);
template <class T>
void show(const vector<T> &a) {
for (T x : a) cout << x << " ";
cout << endl;
}
const int N = 2e5 + 1;
vector<int> g[N];
int a[N];
long long ans[N];
int gcd(int a, int b) {
if (a < b) swap(a, b);
while (b) {
a %= b;
swap(a, b);
}
return a;
}
vector<int> get(int);
vector<pair<int, int> > trans(const vector<pair<int, int> > &a, int nfrom,
int nto) {
vector<int> to = get(nto);
vector<int> ret(((int)(to.size())), 0);
for (auto x : a) {
int g = gcd(nto, x.first);
g = lower_bound(to.begin(), to.end(), g) - to.begin();
ret[g] += x.second;
}
vector<pair<int, int> > real_ret;
for (int i = 0; i < int(((int)(to.size()))); ++i) {
if (ret[i]) real_ret.push_back(make_pair(to[i], ret[i]));
}
return real_ret;
}
vector<int> get(int n) {
vector<int> ret;
for (int i = 1; i * i <= n; ++i)
if (!(n % i)) {
ret.push_back(i);
if (i != n / i) ret.push_back(n / i);
}
sort(ret.begin(), ret.end());
return ret;
}
void my_merge(vector<pair<int, int> > &a, const vector<pair<int, int> > &b) {
vector<pair<int, int> > ret;
int na = 0;
int nb = 0;
while (na < ((int)(a.size())) && nb < ((int)(b.size()))) {
if (a[na].first == b[nb].first) {
ret.push_back(make_pair(a[na].first, a[na].second + b[nb].second));
++na;
++nb;
} else if (a[na].first < b[nb].first) {
ret.push_back(a[na]);
++na;
} else {
ret.push_back(b[nb]);
++nb;
}
}
while (na < ((int)(a.size()))) ret.push_back(a[na++]);
while (nb < ((int)(b.size()))) ret.push_back(b[nb++]);
a = ret;
}
vector<pair<int, int> > dfs(int v, int par, vector<pair<int, int> > up) {
vector<pair<int, int> > sum = up;
vector<pair<int, int> > ret;
ret.push_back(make_pair(a[v], 1));
for (int to : g[v]) {
if (to == par) continue;
vector<pair<int, int> > kek = dfs(to, v, trans(sum, a[v], a[to]));
kek = trans(kek, a[to], a[v]);
my_merge(ret, kek);
my_merge(sum, kek);
}
for (auto x : ret) ans[x.first] += x.second;
for (auto x : up) ans[x.first] += x.second;
return ret;
}
int cnt[N];
void cnt_dfs(int v, int par) {
cnt[v] = 1;
for (int to : g[v])
if (to != par) {
cnt_dfs(to, v);
cnt[v] += cnt[to];
}
}
void find_str(int v, int par, int &c, int n) {
bool ok = 1;
if (n - cnt[v] > n / 2) ok = 0;
for (int to : g[v]) {
if (to == par) continue;
if (cnt[to] > n / 2) ok = 0;
}
if (ok) c = v;
for (int to : g[v])
if (to != par) find_str(to, v, c, n);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < int(n); ++i) cin >> a[i + 1];
for (int iter = 0; iter < int(n - 1); ++iter) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
cnt_dfs(1, -1);
int c = 1;
find_str(1, -1, c, n);
dfs(c, -1, {});
for (int i = 0; i < int(N); ++i)
if (ans[i]) cout << i << " " << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int n;
int a[N], f[N], sz[N];
long long Ans[N];
vector<int> ve[N], g[N];
inline int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), g[a[i]].push_back(i);
for (int i = 1, x, y; i < n; ++i)
scanf("%d%d", &x, &y), ve[x].push_back(y), ve[y].push_back(x);
for (int i = 1; i < N; ++i) {
long long ans = 0;
for (int j = i; j < N; j += i)
for (auto x : g[j]) f[x] = x, sz[x] = 1, ++ans;
for (int j = i; j < N; j += i)
for (auto x : g[j])
for (auto y : ve[x])
if (a[y] % i == 0 && find(x) != find(y)) {
ans += 1ll * sz[f[x]] * sz[f[y]];
sz[f[x]] += sz[f[y]];
f[f[y]] = f[x];
}
Ans[i] = ans;
}
for (int i = N - 1; i; --i)
for (int j = i + i; j < N; j += i) Ans[i] -= Ans[j];
for (int i = 1; i < N; ++i)
if (Ans[i]) printf("%d %lld\n", i, Ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
x = 0;
bool flag = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == 45) flag = 1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
if (flag) x = -x;
}
int n, a[200010], mx[200010], siz[200010], sum, root;
long long ans[200010];
vector<int> g[200010];
bool vis[200010];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void getRoot(int u, int fa) {
siz[u] = 1, mx[u] = 0;
for (auto v : g[u])
if (v != fa && !vis[v])
getRoot(v, u), siz[u] += siz[v], mx[u] = max(mx[u], siz[v]);
mx[u] = max(mx[u], sum - siz[u]);
if (mx[u] < mx[root]) root = u;
}
map<int, int> mp, tp;
void getAns(int u, int fa, int num) {
tp[num]++;
for (auto v : g[u])
if (v != fa && !vis[v]) getAns(v, u, gcd(num, a[v]));
}
void dfs(int u) {
vis[u] = 1;
mp.clear(), mp[a[u]]++, ans[a[u]]++;
for (auto v : g[u])
if (!vis[v]) {
tp.clear(), getAns(v, u, gcd(a[u], a[v]));
for (auto it1 : mp)
for (auto it2 : tp)
ans[gcd(it1.first, it2.first)] += (long long)it1.second * it2.second;
for (auto it : tp) mp[it.first] += it.second;
}
for (auto v : g[u])
if (!vis[v]) root = 0, sum = siz[v], getRoot(v, 0), dfs(root);
}
int main() {
read(n);
int gay = 0;
for (int i = 1; i <= n; i++) read(a[i]), gay = max(gay, a[i]);
for (int i = 2; i <= n; i++) {
int u, v;
read(u), read(v);
g[u].push_back(v), g[v].push_back(u);
}
sum = mx[0] = n;
getRoot(1, 0);
dfs(root);
for (int i = 1; i <= gay; i++)
if (ans[i]) printf("%d %lld\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int n;
vector<int> graph[MAXN];
int a[MAXN];
void read_input() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i + 1]);
}
int v, w;
for (int i = 0; i < n - 1; i++) {
scanf("%d %d", &v, &w);
graph[v].push_back(w);
graph[w].push_back(v);
}
}
int br;
int cnt[MAXN];
bool used[MAXN];
void dfs(int v, int p) {
br++;
cnt[v] = 1;
for (auto x : graph[v]) {
if (x != p && !used[x]) {
dfs(x, v);
cnt[v] += cnt[x];
}
}
}
int get_centroid(int v, int p) {
for (auto x : graph[v]) {
if (x != p && !used[x] && cnt[x] >= (br >> 1)) {
return get_centroid(x, v);
}
}
return v;
}
map<int, long long> mp, mp2, ans;
int _gcd(int a, int b) {
if (b == 0) return a;
return _gcd(b, a % b);
}
void mark(int v, int p, int gc) {
mp2[gc]++;
for (auto x : graph[v]) {
if (x == p || used[x]) {
continue;
}
mark(x, v, _gcd(gc, a[x]));
}
}
void rec(int v) {
br = 0;
dfs(v, v);
int cen = get_centroid(v, v);
used[cen] = true;
mp.clear();
ans[a[cen]]++;
for (auto x : graph[cen]) {
if (!used[x]) {
mp2.clear();
mark(x, cen, _gcd(a[cen], a[x]));
for (auto z : mp2) {
ans[z.first] += z.second;
for (auto g : mp) {
ans[_gcd(z.first, g.first)] += 1LL * z.second * g.second;
}
}
for (auto z : mp2) {
mp[z.first] += z.second;
}
}
}
for (auto x : graph[cen]) {
if (!used[x]) {
rec(x);
}
}
}
void solve() {
rec(1);
for (auto z : ans) {
printf("%d %lld\n", z.first, z.second);
}
}
int main() {
read_input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> factors(200001, vector<long long>(1, 1));
void precompute() {
for (long long i = 2; i < 200001; ++i) {
for (long long j = i; j < 200001; j += i) {
factors[j].push_back(i);
}
}
}
struct Centroid {
long long total = 0;
vector<long long> dead, sz, freq, ans, pre, weight, temp;
long long subtree(long long a, long long p, vector<vector<long long>>& tree) {
sz[a] = 1;
for (long long& c : tree[a])
if (c != p && !dead[c]) sz[a] += subtree(c, a, tree);
return sz[a];
}
long long OneCentroid(long long a, long long p, long long s,
vector<vector<long long>>& tree) {
for (long long& c : tree[a])
if (c != p && !dead[c] && sz[c] > (s >> 1))
return OneCentroid(c, a, s, tree);
return a;
}
void change(long long a, long long p, long long ch,
vector<vector<long long>>& tree) {
for (long long& i : factors[pre[a]]) freq[i] += ch;
for (long long& c : tree[a])
if (c != p && !dead[c]) change(c, a, ch, tree);
}
void computeans(long long a, long long p, vector<vector<long long>>& tree) {
for (long long& i : factors[pre[a]]) temp[i] = freq[i];
for (auto it = factors[pre[a]].rbegin(); it != factors[pre[a]].rend();
it++) {
if (temp[*it] == 0) continue;
for (long long& c : factors[*it])
if (*it != c) temp[c] -= temp[*it];
}
for (long long& f : factors[pre[a]]) ans[f] += temp[f], temp[f] = 0;
for (long long& c : tree[a])
if (c != p && !dead[c]) computeans(c, a, tree);
}
long long gcd(long long a, long long b) {
return (a == 0) ? b : gcd(b % a, a);
}
void compute(long long a, long long p, long long d,
vector<vector<long long>>& tree) {
for (long long& i : factors[pre[a] = d]) freq[i]++;
for (long long& c : tree[a])
if (c != p && !dead[c]) compute(c, a, gcd(d, weight[c]), tree);
}
void decompose(long long a, long long p, vector<vector<long long>>& tree) {
long long cent = OneCentroid(a, p, subtree(a, p, tree), tree);
compute(cent, -1, weight[cent], tree);
dead[cent] = 1;
for (long long& c : tree[cent])
if (!dead[c]) {
change(c, cent, -1, tree);
computeans(c, cent, tree);
}
for (long long& f : factors[pre[cent]]) freq[f]--;
ans[weight[cent]]++;
for (long long& c : tree[cent])
if (!dead[c]) decompose(c, cent, tree);
}
Centroid(vector<vector<long long>>& tree, long long N, vector<long long>& w)
: weight(w) {
dead.assign(N, 0);
sz.assign(N, 0);
pre.assign(N, 0);
temp.assign(200001, 0);
ans.assign(200001, 0);
freq.assign(200001, 0);
decompose(0, -1, tree);
for (long long i = 0; i < 200001; ++i) {
if (ans[i]) cout << i << ' ' << ans[i] << '\n';
}
}
};
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long N;
cin >> N;
vector<vector<long long>> tree(N);
vector<long long> w(N);
for (long long& i : w) cin >> i;
for (long long i = 1, u, v; i < N; ++i) {
cin >> u >> v;
--u, --v;
tree[u].push_back(v);
tree[v].push_back(u);
}
precompute();
Centroid ans(tree, N, w);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int n, par[maxn], rot[maxn], sz[maxn];
vector<int> divs[maxn], g[maxn], subt[maxn], vers[maxn];
long long cnt[maxn];
void dfs(int x, int parx) {
for (auto y : g[x])
if (y != parx) par[y] = x, dfs(y, x);
}
int root(int x) { return rot[x] == x ? x : rot[x] = root(rot[x]); }
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (int i = 2; i < maxn; ++i) {
for (int j = i; j < maxn; j += i) divs[j].emplace_back(i);
}
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
for (auto d : divs[x]) vers[d].emplace_back(i + 1);
}
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
g[a].emplace_back(b), g[b].emplace_back(a);
}
g[0].emplace_back(1);
dfs(0, 0);
cnt[1] = 1LL * n * (n + 1) / 2;
iota(rot, rot + n + 1, 0);
for (int d = 2; d < maxn; ++d) {
for (auto v : vers[d]) {
sz[v] = 1;
++cnt[d];
if (sz[par[v]]) {
rot[v] = root(par[v]);
cnt[d] += sz[rot[v]];
sz[rot[v]] += sz[v];
} else
subt[par[v]].emplace_back(v);
root(v);
for (auto ch : subt[v]) {
rot[ch] = rot[v];
cnt[d] += 1LL * sz[rot[v]] * sz[ch];
sz[rot[v]] += sz[ch];
}
}
for (auto v : vers[d]) {
sz[v] = 0;
subt[par[v]].clear();
rot[v] = v;
}
}
for (int i = (maxn)-1; i >= 1; --i) {
for (int j = i + i; j < maxn; j += i) cnt[i] -= cnt[j];
}
for (int i = 1; i < maxn; ++i)
if (cnt[i]) {
cout << i << ' ' << cnt[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)2e5 + 5;
vector<int> g[MAXN];
vector<pair<int, int> > values[MAXN];
const int INF = 1000000000;
int spf[200001];
void initSPF() {
for (int i = 0; i < 200001; i++) spf[i] = INF;
for (int i = 2; i < 200001; i++) {
if (spf[i] != INF) continue;
for (int j = 1; j * i < 200001; j++) {
spf[i * j] = min(spf[i * j], i);
}
}
}
int mxx = 0;
int vals[MAXN];
void dfs(int node, int pp) {
vector<int> primes;
int k = vals[node];
while (k > 1) {
if (primes.size() > 0 and primes[primes.size() - 1] == spf[k]) {
k /= spf[k];
continue;
}
primes.push_back(spf[k]);
k /= spf[k];
}
for (int i = 0; i < g[node].size(); i++) {
int child = g[node][i];
if (child == pp) continue;
dfs(child, node);
}
int mx = 0;
for (int i = 0; i < primes.size(); i++) {
int p = primes[i];
int val = 0;
int val2 = 0;
for (int j = 0; j < g[node].size(); j++) {
int child = g[node][j];
if (child == pp) continue;
int ans = lower_bound(values[child].begin(), values[child].end(),
make_pair(p, 0)) -
values[child].begin();
if (ans < values[child].size() and values[child][ans].first == p) {
int vs = values[child][ans].second;
if (val == -1) {
val = vs;
} else {
if (vs > val) {
val2 = val;
val = vs;
} else if (vs > val2)
val2 = vs;
}
}
}
mx = val + val2 + 1;
mxx = max(mxx, mx);
values[node].push_back(make_pair(p, val + 1));
}
sort(values[node].begin(), values[node].end());
for (int j = 0; j < values[node].size(); j++) {
}
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> vals[i];
initSPF();
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
bool ok = 0;
for (int i = 0; i < n; i++)
if (vals[i] > 1) ok = 1;
if (!ok) {
cout << 0 << endl;
return 0;
}
dfs(0, -1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < values[i].size(); j++) {
}
}
cout << mxx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const double PI = acos(-1.0);
const double EPS = 1e-9;
const long long INF = 1e9;
const long long LINF = 1e18;
const long long mod = 1e9 + 7;
const long long MAX = 2e5 + 7;
int n;
int a[MAX];
vector<int> g[MAX];
long long DP[MAX];
vector<int> vert[MAX];
bool ye[MAX];
bool pozn[MAX];
int marked[MAX];
int counter = 0;
int q[MAX];
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) {
scanf("%d", &a[i]);
vert[a[i]].push_back(i);
}
int u, v;
for (int i = (0); i < (n - 1); ++i) {
scanf("%d %d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = (1); i < (MAX); ++i) {
counter = 0;
for (int j = i; j < MAX; j += i) {
int k;
for (int to = (0); to < ((int)((vert[j]).size())); ++to) {
k = vert[j][to];
marked[counter++] = k;
ye[k] = 1;
pozn[k] = 0;
}
}
long long tut = 0;
for (int to = (0); to < (counter); ++to) {
int k = marked[to];
if (pozn[k]) continue;
int poch = 0, kinec = 0;
q[0] = k;
pozn[k] = 1;
int ye1 = 1;
while (poch <= kinec) {
int t = q[poch++];
for (int to = (0); to < ((int)((g[t]).size())); ++to) {
int su = g[t][to];
if (pozn[su] || ye[su] == 0) continue;
pozn[su] = 1;
++ye1;
q[++kinec] = su;
}
}
tut += ye1 * 1LL * (ye1 - 1) / 2LL;
}
DP[i] = tut;
for (int k = (0); k < (counter); ++k) ye[marked[k]] = 0;
}
for (int i = (MAX)-1; i >= (1); --i)
for (int j = i * 2; j < MAX; j += i) DP[i] -= DP[j];
for (int i = (1); i < (MAX); ++i) DP[i] += (int)((vert[i]).size());
for (int i = (1); i < (MAX); ++i)
if (DP[i]) {
printf("%d ", i);
printf("%lld\n", DP[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
using namespace std;
long long n, k, a[200005];
long long p[200005], r[200005], sz[200005], ans[200005];
vector<pair<int, int> > G[200005];
vector<int> v[200005];
long long cur;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long find(long long x) {
if (p[x] == x)
return x;
else
return p[x] = find(p[x]);
}
void unite(long long x, long long y) {
x = find(x);
y = find(y);
if (x == y) return;
cur -= sz[x] * (sz[x] - 1) / 2;
cur -= sz[y] * (sz[y] - 1) / 2;
p[x] = y;
sz[y] += sz[x];
cur += sz[y] * (sz[y] - 1) / 2;
}
int main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
v[a[i]].push_back(i);
}
for (long long i = 0; i < n - 1; i++) {
long long u, v;
scanf("%lld%lld", &u, &v);
G[gcd(a[u], a[v])].push_back(pair<int, int>(u, v));
}
for (long long i = 1; i <= 200000; i++) {
cur = 0;
for (long long j = i; j <= 200000; j += i) {
for (long long k = 0; k < (int)v[j].size(); k++) {
long long node = v[j][k];
p[node] = node, sz[node] = 1;
cur++;
}
}
for (long long j = i; j <= 200000; j += i) {
for (long long k = 0; k < (int)G[j].size(); k++) {
pair<int, int> e = G[j][k];
unite(e.first, e.second);
}
}
ans[i] = cur;
}
for (long long i = 200000; i >= 1; i--)
for (long long j = 2 * i; j <= 200000; j += i) ans[i] -= ans[j];
for (long long i = 1; i <= 200000; i++)
if (ans[i]) printf("%lld %lld\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > adj(200001), vertices(200001);
bool marked[200001];
long long ans[200001];
int DFS(int i) {
marked[i] = 0;
int ans = 1;
for (auto k : adj[i]) {
if (marked[k]) {
ans += DFS(k);
}
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
vertices[x].push_back(i);
}
for (int x = 1; x < n; ++x) {
int i, j;
scanf("%d%d", &i, &j);
adj[i].push_back(j);
adj[j].push_back(i);
}
for (int i = 200001 - 1; i > 0; --i) {
vector<int> v;
for (int j = i; j < 200001; j += i) {
for (auto x : vertices[j]) {
v.push_back(x);
marked[x] = 1;
}
}
long long val = 0;
for (auto x : v) {
if (marked[x] == 0) continue;
long long valx = DFS(x);
val += (valx * (valx + 1) / 2);
}
ans[i] = val;
for (int j = i + i; j < 200001; j += i) ans[i] -= ans[j];
}
for (int i = 1; i < 200001; ++i) {
if (ans[i]) {
printf("%d %lld\n", i, ans[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int lg(long long n) {
assert(n > 0);
int ans = -1;
while (n) {
ans++;
n >>= 1;
}
return ans;
}
void solve() {
const int M = 2e5;
vector<int> mobius(M + 1), par(M + 1), pri;
for (int i = 1; i <= M; i++) {
if (i == 1)
mobius[i] = 1;
else {
if (!par[i]) {
pri.push_back(i);
par[i] = i;
mobius[i] = -1;
}
for (int x : pri) {
if (x > M / i) break;
mobius[x * i] = -mobius[i];
par[x * i] = x;
if (x == par[i]) {
mobius[x * i] = 0;
break;
}
}
}
}
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vector<vector<int>> adj(n);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
vector<vector<int>> idxbyval(M + 1);
for (int i = 0; i < n; i++) idxbyval[a[i]].push_back(i);
vector<int> vis(n), ingraph(n);
int cnt = 0;
function<void(int, int)> dfs = [&](int cur, int fa) {
vis[cur] = 1;
cnt++;
for (int nxt : adj[cur]) {
if (ingraph[nxt] && !vis[nxt]) {
dfs(nxt, cur);
}
}
};
vector<long long> ans(M + 1);
for (int i = 1; i <= M; i++) {
vector<int> subgraph;
for (int x = i; x <= M; x += i) {
for (int idx : idxbyval[x]) {
subgraph.push_back(idx);
ingraph[idx] = 1;
}
}
if (subgraph.empty()) continue;
for (int idx : subgraph) {
if (!vis[idx]) {
cnt = 0;
dfs(idx, -1);
ans[i] += 1LL * cnt * (cnt + 1) / 2;
}
}
for (int idx : subgraph) {
ingraph[idx] = vis[idx] = 0;
}
}
vector<long long> ans2(M + 1);
for (int mul = 1; mul <= M; mul++) {
if (mobius[mul] == 0) continue;
for (int i = 1; i * mul <= M; i++) {
ans2[i] += (mobius[mul] == 1 ? ans[i * mul] : -ans[i * mul]);
}
}
for (int i = 1; i <= M; i++) {
if (ans2[i] != 0) {
cout << i << ' ' << ans2[i] << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 7;
const long long maxn = 1e6 + 7;
const double pi = acos(-1.0);
const double eps = 0.00000001;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline T powMM(T a, T b) {
T ret = 1;
for (; b; b >>= 1ll, a = (long long)a * a % M)
if (b & 1) ret = (long long)ret * a % M;
return ret;
}
int A[maxn];
vector<int> edge[maxn];
int sz[maxn];
bool mark[maxn];
int minweight, root;
void dfs1(int x, int fa, int n) {
int weight = 0;
sz[x] = 1;
for (int v : edge[x]) {
if (v == fa || mark[v]) continue;
dfs1(v, x, n);
sz[x] += sz[v];
weight = max(weight, sz[v]);
}
weight = max(weight, n - sz[x]);
if (weight < minweight) root = x, minweight = weight;
}
map<int, int> now;
map<int, int> MP;
map<int, long long> ans;
void dfs2(int x, int fa, int gg) {
gg = gcd(gg, A[x]);
now[gg]++;
for (int v : edge[x]) {
if (v == fa || mark[v]) continue;
dfs2(v, x, gg);
}
}
unordered_map<long long, int> MMP;
inline int getgcd(int x, int y) {
if (MMP[(long long)x * 1000000 + y])
return MMP[(long long)x * 1000000 + y];
else
return MMP[(long long)x * 1000000 + y] = gcd(x, y);
}
void calc(int x) {
MP.clear();
MP[A[x]]++;
for (int u : edge[x]) {
if (mark[u]) continue;
now.clear();
dfs2(u, x, A[x]);
for (auto P : now)
for (auto Q : MP)
ans[getgcd(P.first, Q.first)] += (long long)Q.second * P.second;
for (auto P : now) MP[P.first] += P.second;
}
MP.clear();
}
void dfs3(int x) {
calc(x);
mark[x] = 1;
ans[A[x]]++;
for (int v : edge[x]) {
if (mark[v]) continue;
minweight = sz[v];
dfs1(v, 0, sz[v]);
dfs3(root);
}
}
int main() {
int i, j, n;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &A[i]);
for (i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
edge[u].push_back(v);
edge[v].push_back(u);
}
minweight = n;
dfs1(1, 0, n);
dfs3(root);
for (auto now : ans) printf("%d %I64d\n", now.first, now.second);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 1200031;
int n, ar[N], w[N];
int gcd(int a, int b) {
while (a && b) a > b ? a %= b : b %= a;
return a + b;
}
vector<pair<int, int> > edges;
vector<int> entries[N];
int sz[N];
long long ANS[N];
vector<int> interesting;
long long cur_pairs;
void run_cleanup() {
for (int i = 0; i < interesting.size(); i++) {
int id = interesting[i];
sz[id] = 1;
w[id] = id;
}
}
int get(int x) {
interesting.push_back(x);
if (x == w[x]) return x;
return w[x] = get(w[x]);
}
long long F(int x) { return 1ll * x * (x - 1) / 2; }
void merge(int a, int b) {
a = get(a);
b = get(b);
if (a == b) return;
cur_pairs -= F(sz[a]);
cur_pairs -= F(sz[b]);
w[a] = b;
sz[b] += sz[a];
cur_pairs += F(sz[b]);
}
vector<int> divs[N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
edges.push_back(make_pair(a, b));
}
for (int i = 0; i < edges.size(); i++) {
int here = gcd(ar[edges[i].first], ar[edges[i].second]);
entries[here].push_back(i);
}
for (int i = 1; i <= n; i++) {
w[i] = i;
sz[i] = 1;
}
for (int i = 1; i <= 200000; i++) {
interesting.clear();
cur_pairs = 0;
for (int j = i; j <= 200000; j += i) {
for (int q = 0; q < entries[j].size(); q++) {
int id = entries[j][q];
merge(edges[id].first, edges[id].second);
}
}
ANS[i] = cur_pairs;
run_cleanup();
}
for (int i = 1; i <= 200000; i++) {
for (int j = i * 2; j <= 200000; j += i) divs[j].push_back(i);
}
for (int i = 200000; i; --i) {
for (int j = 0; j < divs[i].size(); j++) {
int p = divs[i][j];
ANS[p] -= ANS[i];
}
}
for (int i = 1; i <= n; i++) {
ANS[ar[i]]++;
}
for (int i = 1; i <= 200000; i++) {
if (ANS[i]) cout << i << " " << ANS[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> ind[N];
vector<int> adj[N];
int a[N], cnt[N];
bool av[N];
long long ans[N];
vector<int> factors[N];
void pre() {
for (int i = 1; i < N; i++)
for (int j = i; j < N; j += i) factors[j].push_back(i);
}
int dfs(int u) {
int ans = 1;
av[u] = 0;
for (auto v : adj[u])
if (av[v]) ans += dfs(v);
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
pre();
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (auto d : factors[a[i]]) ind[d].push_back(i);
cnt[a[i]]++;
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i < N; i++) {
for (auto v : ind[i]) av[v] = true;
for (auto v : ind[i])
if (av[v]) {
int cnt = dfs(v);
ans[i] += 1LL * cnt * cnt;
}
}
for (int i = N - 1; i > 0; i--)
for (int j = 2 * i; j < N; j += i) ans[i] -= ans[j];
for (int i = 1; i < N; i++) {
ans[i] += cnt[i];
ans[i] /= 2;
}
for (int i = 1; i < N; i++)
if (ans[i]) cout << i << " " << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
int gcd(int x, int y) {
while (x % y) {
x %= y;
swap(x, y);
}
return y;
}
int N;
vector<int> adj[MAXN];
int val[MAXN];
long long ans[MAXN];
unordered_map<int, int> freq[MAXN];
void dfs(int pos, int par) {
freq[pos][val[pos]] = 1;
ans[val[pos]]++;
for (int i : adj[pos]) {
if (i == par) {
continue;
}
dfs(i, pos);
for (const pair<int, int> &p1 : freq[i]) {
int newv = gcd(p1.first, val[pos]);
for (const pair<int, int> &p2 : freq[pos]) {
int g = gcd(newv, p2.first);
ans[g] += (long long)p1.second * p2.second;
}
}
for (const pair<int, int> &p1 : freq[i]) {
int newv = gcd(p1.first, val[pos]);
freq[pos][newv] += p1.second;
}
freq[i].clear();
}
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
cin >> N;
for (int a = 1; a <= N; a++) {
cin >> val[a];
}
for (int a = 1; a <= N - 1; a++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, -1);
for (int a = 1; a < MAXN; a++) {
if (ans[a] != 0) {
cout << a << " " << ans[a] << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MX = 2e5 + 1;
bool sieve[MX], in_graph[MX], vstd[MX];
vector<int> pos[MX], adj[MX];
int mu[MX];
ll res[MX];
void init() {
vector<int> primes;
mu[1] = 1;
for (int i = 2; i < MX; ++i) {
if (!sieve[i]) {
mu[i] = -1;
primes.push_back(i);
}
for (auto j : primes) {
if (i * j >= MX) break;
sieve[i * j] = true;
if (i % j == 0) {
mu[i * j] = 0;
break;
}
mu[i * j] = -mu[i];
}
}
}
int dfs(int u, int p) {
int res = 1;
vstd[u] = true;
for (auto c : adj[u]) {
if (c == p || !in_graph[c]) continue;
res += dfs(c, u);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
init();
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
for (int j = 1; j * j <= a; ++j) {
if (a % j) continue;
pos[j].push_back(i);
if (a / j != j) {
pos[a / j].push_back(i);
}
}
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i < MX; ++i) {
for (auto j : pos[i]) {
in_graph[j] = true;
}
for (auto j : pos[i]) {
if (!vstd[j]) {
ll cnt = dfs(j, 0);
res[i] += cnt * (cnt + 1) / 2;
}
}
for (auto j : pos[i]) {
in_graph[j] = false;
vstd[j] = false;
}
}
for (int i = 1; i < MX; ++i) {
ll ans = 0;
for (int j = 1; j * i < MX; ++j) {
ans += mu[j] * res[j * i];
}
if (ans) {
cout << i << ' ' << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
char c;
int num = 0, flg = 1;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flg = -1;
while (c >= '0' && c <= '9') {
num = num * 10 + c - 48;
c = getchar();
}
return num * flg;
}
int gcd(int x, int y) { return !y ? x : gcd(y, x % y); }
vector<pair<int, int> > e[200005];
int a[200005], fa[200005], siz[200005];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
long long ans, f[200005], G[200005];
int prime[200005], tot, mu[200005];
bool vis[200005];
void shai() {
int i, j, lim = 200000;
vis[1] = 1;
mu[1] = 1;
for (i = 2; i <= lim; i++) {
if (!vis[i]) {
prime[++tot] = i;
mu[i] = -1;
}
for (j = 1; j <= tot; j++) {
int tmp = i * prime[j];
if (tmp > lim) break;
vis[tmp] = 1;
if (i % prime[j] == 0) {
mu[tmp] = 0;
break;
}
mu[tmp] = -mu[i];
}
}
}
int main() {
int n, m = 0, i, j, k, u, v, g, p, q;
n = gi();
shai();
for (i = 1; i <= n; i++) a[i] = gi(), m = max(m, a[i]), G[a[i]]++;
for (i = 1; i < n; i++) {
u = gi();
v = gi();
g = gcd(a[u], a[v]);
e[g].push_back(make_pair(u, v));
}
for (i = 1; i <= m; i++) {
for (j = i; j <= m; j += i) {
for (k = 0; k < int(e[j].size()); k++) {
u = e[j][k].first;
v = e[j][k].second;
fa[u] = u;
fa[v] = v;
siz[u] = siz[v] = 1;
}
}
for (j = i; j <= m; j += i) {
for (k = 0; k < int(e[j].size()); k++) {
u = e[j][k].first;
v = e[j][k].second;
p = find(u);
q = find(v);
if (p != q) {
fa[q] = p;
f[i] += 1ll * siz[p] * siz[q];
siz[p] += siz[q];
}
}
}
}
for (i = 1; i <= m; i++) {
for (j = 2 * i; j <= m; j += i) f[i] += f[j] * mu[j / i];
if (f[i] || G[i]) printf("%d %lld\n", i, f[i] + G[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long a[N], n, f[N], mob[N], lst[N], cc, gud[N];
vector<long long> adj[N], idx[N], primes;
bitset<N> bs;
void sieve() {
bs.set();
bs[0] = bs[1] = false;
for (long long i = 2; i <= N - 5; ++i)
if (bs[i]) {
for (long long j = i * i; j <= N - 5; j += i) bs[j] = false;
primes.push_back(i);
}
}
long long mobius(long long a) {
long long PF_idx = 0, PF = primes[0];
vector<long long> d;
d.clear();
while (PF * PF <= a) {
long long cnt = 0;
while (a % PF == 0) {
a /= PF;
cnt++;
}
if (cnt > 1) return 0;
if (cnt == 1) d.push_back(PF);
PF = primes[++PF_idx];
}
if (a) d.push_back(a);
if ((long long)d.size() & 1)
return -1;
else
return 1;
}
long long dfs(long long u, long long val) {
long long t = 0;
lst[u] = cc;
for (long long v : adj[u])
if (gud[a[v]] == cc && lst[v] != cc) t += dfs(v, val);
return t + 1;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
sieve();
cin >> n;
for (long long i = 1; i <= n; ++i) {
cin >> a[i];
idx[a[i]].push_back(i);
}
for (long long i = 1; i < n; ++i) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (long long i = 1; i <= N - 5; ++i) {
++cc;
long long tmp = 0;
for (long long j = i; j <= N - 5; j += i) gud[j] = cc;
for (long long j = i; j <= N - 5; j += i) {
for (long long u : idx[j])
if (lst[u] != cc) {
long long sz = dfs(u, i);
tmp += sz * (sz + 1) / 2;
}
}
f[i] = tmp;
}
for (long long i = 1; i <= N - 5; ++i) mob[i] = mobius(i);
for (long long i = 1; i <= N - 5; ++i) {
long long res = f[i];
for (long long j = 2; j <= (N - 5) / i; j++) res += f[i * j] * mob[j];
if (res > 0) cout << i << ' ' << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
int n, a[maxn], dp[maxn];
vector<int> g[maxn], p[maxn];
set<int> s[maxn];
int dfs(int u, int par, int d) {
s[u].insert(d);
int res = dp[u] = 1;
for (auto v : g[u]) {
if (v != par && a[v] % d == 0) {
res = max(res, dfs(v, u, d));
res = max(res, dp[u] + dp[v]);
dp[u] = max(dp[u], dp[v] + 1);
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
int x = a[i];
for (int j = 2; j * j <= x; j++) {
if (x % j == 0) {
p[i].push_back(j);
while (x % j == 0) x /= j;
}
}
if (x > 1) p[i].push_back(x);
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (auto j : p[i]) {
if (s[i].find(j) == s[i].end()) {
ans = max(ans, dfs(i, i, j));
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int M[maxn];
vector<int> a[maxn];
vector<int> E[maxn];
long long h[maxn];
int maxa = 0;
void pre(int maxa) {
M[1] = 1;
for (int i = 1; i < maxa; i++) {
for (int j = i * 2; j <= maxa; j += i) M[j] -= M[i];
}
return;
}
int n;
vector<int> now;
bool ok[maxn], vis[maxn];
int siz;
void dfs(int u) {
siz++;
vis[u] = 1;
for (int i = 0; i < E[u].size(); i++) {
if (!vis[E[u][i]] && ok[E[u][i]]) dfs(E[u][i]);
}
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int q;
scanf("%d", &q);
a[q].push_back(i);
maxa = max(maxa, q);
}
pre(maxa);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
E[x].push_back(y);
E[y].push_back(x);
}
for (int i = 1; i <= maxa; i++) {
now.clear();
for (int j = i; j <= maxa; j += i) {
for (int k = 0; k < a[j].size(); k++) now.push_back(a[j][k]);
}
for (int j = 0; j < now.size(); j++) ok[now[j]] = 1;
for (int j = 0; j < now.size(); j++) {
if (!vis[now[j]]) {
siz = 0;
dfs(now[j]);
h[i] += (1LL * siz * (siz + 1) / 2);
}
}
for (int j = 0; j < now.size(); j++) ok[now[j]] = vis[now[j]] = 0;
}
for (int i = 1; i <= maxa; i++) {
long long ans = 0;
for (int j = 1; j <= maxa / i; j++) {
ans += 1LL * h[j * i] * M[j];
}
if (ans != 0) printf("%d %I64d\n", i, ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 10000020;
int bufpos;
char buf[MAXSIZE];
void init() {
buf[fread(buf, 1, MAXSIZE, stdin)] = '\0';
bufpos = 0;
}
int readint() {
int val = 0;
for (; !isdigit(buf[bufpos]); bufpos++)
;
for (; isdigit(buf[bufpos]); bufpos++) val = val * 10 + buf[bufpos] - '0';
return val;
}
char readchar() {
for (; isspace(buf[bufpos]); bufpos++)
;
return buf[bufpos++];
}
int readstr(char* s) {
int cur = 0;
for (; isspace(buf[bufpos]); bufpos++)
;
for (; !isspace(buf[bufpos]); bufpos++) s[cur++] = buf[bufpos];
s[cur] = '\0';
return cur;
}
const int maxn = 200002;
vector<int> v[maxn], e[maxn];
int a[maxn], f[maxn], sz[maxn], fa[maxn];
void dfs(int u) {
for (const auto& v : e[u]) {
if (fa[u] == v) continue;
fa[v] = u;
dfs(v);
}
}
bool label[maxn];
long long now;
int getf(int x) { return f[x] == x ? x : f[x] = getf(f[x]); }
void mer(int x, int y) {
x = getf(x), y = getf(y);
now += 1LL * sz[x] * sz[y];
f[x] = y;
sz[y] += sz[x];
}
long long ans[maxn];
int main() {
init();
int n = readint();
for (int i = 1; i <= n; i++) f[i] = i, sz[i] = 1;
for (int i = 1; i <= n; i++) a[i] = readint(), v[a[i]].push_back(i);
for (int i = 1; i < n; i++) {
int u = readint(), v = readint();
e[u].push_back(v);
e[v].push_back(u);
}
dfs(1);
for (int i = 1; i <= 200000; i++) {
now = 0;
for (int j = i; j <= 200000; j += i)
for (const auto& k : v[j]) {
now++;
if (fa[k] && a[fa[k]] % i == 0) mer(k, fa[k]);
}
ans[i] = now;
for (int j = i; j <= 200000; j += i)
for (const auto& k : v[j]) f[k] = k, sz[k] = 1;
}
for (int i = 200000; i; i--)
for (int j = i * 2; j <= 200000; j += i) ans[i] -= ans[j];
for (int i = 1; i <= 200000; i++)
if (ans[i]) printf("%d %lld\n", i, ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int v;
int nxt;
} e[400010];
int n, m, h[200010], cnt, val[200010];
int num[200010][20], dp[200010][20], ans = 1;
bool flag = 0;
void add(int u, int v) {
e[++cnt].v = v;
e[cnt].nxt = h[u];
h[u] = cnt;
}
void work(int pos, int x) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
num[pos][++num[pos][0]] = i;
while (x % i == 0) x /= i;
}
}
if (x > 1) num[pos][++num[pos][0]] = x;
}
void dfs(int u, int fa) {
for (int i = 1; i <= num[u][0]; i++) dp[u][i] = 1;
for (int i = h[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v == fa) continue;
dfs(v, u);
for (int j = 1; j <= num[u][0]; j++) {
for (int k = 1; k <= num[v][0]; k++)
if (num[u][j] == num[v][k]) {
ans = max(ans, dp[u][j] + dp[v][k]);
dp[u][j] = max(dp[u][j], dp[v][k] + 1);
}
ans = max(ans, dp[u][j]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
if (val[i] > 1) flag = 1;
work(i, val[i]);
}
if (!flag) {
printf("0");
return 0;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
dfs(1, 0);
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <class A>
ostream &operator<<(ostream &out, const vector<A> &v) {
out << "[";
for (auto &e : v) out << e << ", ";
return out << "]";
}
const int N = 1000 * 1000 + 555;
const int LOGN = 21;
int mind[N];
int pw[LOGN][N];
int n, a[N];
vector<int> g[N];
long long res[N];
bool gen() {
mt19937 rnd(42);
n = 200 * 1000;
for (int i = int(0); i < int(n); i++) a[i] = 831600;
for (int i = int(1); i < int(n); i++) {
int u = rnd() % i, v = i;
g[u].push_back(v);
g[v].push_back(u);
}
return true;
}
inline bool read() {
if (!(cin >> n)) return false;
for (int i = int(0); i < int(n); i++) assert(scanf("%d", &a[i]) == 1);
for (int i = int(0); i < int(n - 1); i++) {
int u, v;
assert(scanf("%d%d", &u, &v) == 2);
u--, v--;
g[u].push_back(v);
g[v].push_back(u);
}
return true;
}
vector<pair<int, int> > dv[N];
inline int gcd(int a, int b) {
int ans = 1;
unsigned int u = 0, v = 0;
while (u < dv[a].size() && v < dv[b].size()) {
if (dv[a][u].first < dv[b][v].first)
u++;
else if (dv[a][u].first > dv[b][v].first)
v++;
else {
ans *= pw[min(dv[a][u].second, dv[b][v].second)][dv[a][u].first];
u++, v++;
}
}
return ans;
}
bool used[N];
int sz[N];
void calcSz(int v, int p) {
sz[v] = 1;
for (int to : g[v]) {
if (to == p || used[to]) continue;
calcSz(to, v);
sz[v] += sz[to];
}
}
int findC(int v, int p, int all) {
for (int to : g[v]) {
if (to == p || used[to]) continue;
if (sz[to] > all / 2) return findC(to, v, all);
}
return v;
}
int u[N], T = 0;
int cntD[N];
inline void addDiv(int d, int cnt) {
if (u[d] != T) u[d] = T, cntD[d] = 0;
cntD[d] += cnt;
}
int cds[N], szcds;
void calcDs(int v, int p, int gc) {
gc = gcd(a[v], gc);
cds[szcds++] = gc;
for (int to : g[v]) {
if (to == p || used[to]) continue;
calcDs(to, v, gc);
}
}
vector<int> cps, cmx, vmx;
void check(int curd, int curg, int pos, int add) {
if (pos >= (int)cps.size()) {
if (u[curd] == T) res[curg] += cntD[curd] * 1ll * add;
return;
}
for (int st = int(0); st < int(cmx[pos] + 1); st++) {
check(curd, curg, pos + 1, add);
curd *= cps[pos];
if (st < vmx[pos]) curg *= cps[pos];
}
}
pair<int, int> ops[N];
int szops;
int cntDiff[N];
void calc(int v) {
calcSz(v, -1);
int c = findC(v, -1, sz[v]);
used[c] = 1;
cps.resize(dv[a[c]].size());
cmx.resize(cps.size());
vmx.resize(cmx.size());
for (int i = int(0); i < int(cps.size()); i++) {
cps[i] = dv[a[c]][i].first;
cmx[i] = dv[a[c]][i].second;
}
T++;
addDiv(a[c], 1);
for (int to : g[c]) {
if (used[to]) continue;
szcds = 0;
calcDs(to, c, a[c]);
for (int i = int(0); i < int(szcds); i++) cntDiff[cds[i]]++;
szops = 0;
for (int j = int(0); j < int(szcds); j++) {
if (cntDiff[cds[j]] == 0) continue;
int p = 0, val = cds[j];
for (int i = int(0); i < int(vmx.size()); i++) {
if (p >= (int)dv[val].size() || dv[val][p].first > cps[i])
vmx[i] = 0;
else
vmx[i] = dv[val][p].second, p++;
}
check(1, 1, 0, cntDiff[cds[j]]);
ops[szops++] = {cds[j], cntDiff[cds[j]]};
cntDiff[cds[j]] = 0;
}
for (int j = int(0); j < int(szops); j++)
addDiv(ops[j].first, ops[j].second);
}
for (int to : g[c]) {
if (used[to]) continue;
calc(to);
}
}
inline void solve() {
iota(mind, mind + N, 0);
for (int i = int(2); i < int(N); i++) {
if (mind[i] != i) continue;
pw[0][i] = 1;
for (int st = int(1); st < int(LOGN); st++) pw[st][i] = pw[st - 1][i] * i;
for (long long j = i * 1ll * i; j < N; j += i) mind[j] = min(mind[j], i);
}
for (int i = int(2); i < int(N); i++) {
int val = i;
while (mind[val] > 1) {
if (dv[i].empty() || dv[i].back().first != mind[val])
dv[i].emplace_back(mind[val], 0);
dv[i].back().second++;
val /= mind[val];
}
}
memset(res, 0, sizeof res);
T = 0;
calc(0);
for (int i = int(0); i < int(n); i++) res[a[i]]++;
for (int i = int(1); i < int(1000000 + 1); i++) {
if (res[i]) cout << i << ' ' << res[i] << endl;
}
}
int main() {
if (read()) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[200050];
struct node {
int x, y;
} ed[200050];
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
vector<int> v[200050];
long long f[200050];
int x[200050], fa[200050], sz[200050];
inline int getfa(int x) { return x == fa[x] ? x : fa[x] = getfa(fa[x]); }
inline void merge(int id, int x, int y) {
x = getfa(x);
y = getfa(y);
f[id] += 1ll * sz[x] * sz[y];
fa[x] = y;
sz[y] += sz[x];
}
bool zhi[200050];
int mu[200050], pri[200050], tot;
inline void init(int n) {
mu[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!zhi[i]) pri[++tot] = i, mu[i] = -1;
for (int j = 1; j <= tot && 1ll * i * pri[j] <= n; ++j) {
zhi[i * pri[j]] = 1;
if (!(i % pri[j])) break;
mu[i * pri[j]] = -mu[i];
}
}
}
inline void fen(int n) {
for (int i = 1; 1ll * i * i <= n; ++i)
if (!(n % i)) {
++f[i];
if (i * i != n) ++f[n / i];
}
}
int main() {
scanf("%d", &n);
m = 2e5;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), fen(a[i]), m = max(m, a[i]);
init(m);
for (int i = 1, gc; i < n; ++i) {
scanf("%d%d", &ed[i].x, &ed[i].y);
gc = gcd(a[ed[i].x], a[ed[i].y]);
for (int j = 1; j * j <= gc; ++j)
if (!(gc % j)) {
v[j].push_back(i);
if (j * j != gc) v[gc / j].push_back(i);
}
}
for (int i = 1; i <= n; ++i) fa[i] = i, sz[i] = 1;
for (int i = 1; i <= m; ++i) {
for (int j = 0, x, y; j < v[i].size(); ++j) {
x = ed[v[i][j]].x;
y = ed[v[i][j]].y;
merge(i, x, y);
}
for (int j = 0, x, y; j < v[i].size(); ++j) {
x = ed[v[i][j]].x;
y = ed[v[i][j]].y;
fa[x] = x;
sz[x] = 1;
fa[y] = y;
sz[y] = 1;
}
}
for (int i = 1; i <= m; ++i) {
for (int j = 2; 1ll * i * j <= m; ++j) f[i] += mu[j] * f[i * j];
if (f[i]) printf("%d %lld\n", i, f[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, long long> ans, re, now;
int n, h[200005], tot, mp[200005], siz[200005], mz[200005], rem[200005], cnt;
bool vis[200005];
struct DX {
int v, p;
} dx[400005];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
void add(int u, int v) {
dx[tot].p = h[u];
dx[tot].v = v;
h[u] = tot++;
}
void dfs_G(int u, int fx) {
siz[u] = 1;
rem[++cnt] = u;
mz[u] = 0;
for (int i = h[u]; ~i; i = dx[i].p) {
int v = dx[i].v;
if (v == fx || vis[v]) continue;
dfs_G(v, u);
siz[u] += siz[v];
mz[u] = max(mz[u], siz[v]);
}
}
int fd_G(int u) {
cnt = 0;
dfs_G(u, u);
for (int i = 1; i <= cnt; i++)
if (mz[rem[i]] <= siz[u] / 2 && siz[u] - siz[rem[i]] <= siz[u] / 2)
return rem[i];
}
void dfs(int u, int fx, int gc) {
re[gc = gcd(gc, mp[u])]++;
for (int i = h[u]; ~i; i = dx[i].p) {
int v = dx[i].v;
if (v == fx || vis[v]) continue;
dfs(v, u, gc);
}
}
void sol(int u) {
u = fd_G(u);
vis[u] = 1;
now[mp[u]] = 1;
ans[mp[u]] += 1;
for (int i = h[u]; ~i; i = dx[i].p) {
int v = dx[i].v;
if (vis[v]) continue;
dfs(v, 0, mp[u]);
for (map<int, long long>::iterator it = now.begin(); it != now.end(); it++)
for (map<int, long long>::iterator ti = re.begin(); ti != re.end(); ti++)
ans[gcd(it->first, ti->first)] += it->second * ti->second;
for (map<int, long long>::iterator ti = re.begin(); ti != re.end(); ti++)
now[ti->first] += ti->second;
re.clear();
}
now.clear();
for (int i = h[u]; ~i; i = dx[i].p) {
int v = dx[i].v;
if (vis[v]) continue;
sol(v);
}
}
int main() {
memset(h, -1, sizeof(h));
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &mp[i]);
int a, b;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
add(a, b);
add(b, a);
}
sol(1);
for (map<int, long long>::iterator it = ans.begin(); it != ans.end(); it++)
printf("%d %lld\n", it->first, it->second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int a[200010], father[200010], fa[200010];
long long size[200010];
vector<int> lis[200010], E[200010];
long long ans[200010];
int find(int x) {
if (x == father[x]) return x;
return father[x] = find(father[x]);
}
void DFS(int x, int pre) {
for (auto y : E[x]) {
if (y == pre) continue;
fa[y] = x;
DFS(y, x);
}
}
int main() {
int n, u, v;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), lis[a[i]].push_back(i);
for (int i = 1; i < n; ++i) {
scanf("%d %d", &u, &v);
E[u].push_back(v);
E[v].push_back(u);
}
DFS(1, -1);
for (int i = 1; i <= 200000; ++i) {
for (int j = i; j <= 200000; j += i) {
ans[i] += lis[j].size();
for (auto x : lis[j]) {
father[x] = x;
size[x] = 1;
}
}
for (int j = i; j <= 200000; j += i) {
for (auto x : lis[j]) {
if (x == 1) continue;
if (father[fa[x]] == 0) continue;
int a = find(x), b = find(fa[x]);
ans[i] += size[a] * size[b];
father[a] = b, size[b] += size[a];
}
}
for (int j = i; j <= 200000; j += i)
for (auto x : lis[j]) father[x] = size[x] = 0;
}
for (int i = 200000; i >= 1; --i) {
for (int j = 2 * i; j <= 200000; j += i) ans[i] -= ans[j];
}
for (int i = 1; i <= 200000; ++i)
if (ans[i]) printf("%d %I64d\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200000 + 5], mu[200000 + 5], cc, good[200000 + 5], used[200000 + 5],
q[200000 + 5], fr, bk;
long long ans1[200000 + 5], ans2[200000 + 5];
vector<int> G[200000 + 5], nbfs[200000 + 5], prime;
bool vis[200000 + 5];
void init() {
mu[1] = 1;
for (int i = 2; i <= 200000; i++) {
if (!vis[i]) {
prime.push_back(i);
mu[i] = -1;
}
for (int j = 0; i * prime[j] <= 200000; j++) {
vis[i * prime[j]] = true;
if (i % prime[j] == 0) {
mu[i * prime[j]] = 0;
break;
}
mu[i * prime[j]] = -mu[i];
}
}
}
int bfs(int x, int gc) {
fr = bk = 0;
q[bk++] = x;
used[x] = cc;
while (fr < bk) {
int z = q[fr++];
for (int i = 0; i < G[z].size(); i++) {
int y = G[z][i];
if (good[a[y]] == cc && used[y] < cc) {
used[y] = cc;
q[bk++] = y;
}
}
}
return bk;
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
nbfs[a[i]].push_back(i);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 200000; i > 0; i--) {
cc++;
for (int j = i; j <= 200000; j += i) good[j] = cc;
for (int j = i; j <= 200000; j += i)
for (int k = 0; k < nbfs[j].size(); k++) {
int x = nbfs[j][k];
if (used[x] == cc) continue;
int z = bfs(x, i);
ans1[i] += 1ll * z * (z + 1) / 2;
}
for (int j = i, k = 1; j <= 200000; j += i, k++) ans2[i] += mu[k] * ans1[j];
}
for (int i = 1; i <= 200000; i++)
if (ans2[i]) printf("%d %lld\n", i, ans2[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 100;
vector<int> g[N];
int a[N], good[N];
long long ans[N];
int sizes[N], par[N];
vector<int> take[N], vals[N];
int n;
int getPar(int v) {
if (v == par[v]) return v;
return (par[v] = getPar(par[v]));
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (int i = 0; i < N; i++) {
par[i] = i;
sizes[i] = 1;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vals[a[i]].push_back(i);
}
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
for (int i = 1; i < N; i++) {
for (int j = i; j < N; j += i) {
take[i].insert(take[i].end(), vals[j].begin(), vals[j].end());
}
}
for (int i = 1; i < N; i++) {
long long cur = 0;
for (auto v : take[i]) {
good[v] = 1;
cur++;
}
auto get = [&](int x) { return 1ll * x * (x + 1) / 2; };
auto add_edge = [&](int v, int u) {
v = getPar(v);
u = getPar(u);
if (v == u) return;
cur -= get(sizes[v]);
cur -= get(sizes[u]);
if (sizes[v] < sizes[u]) swap(v, u);
par[u] = v;
sizes[v] += sizes[u];
sizes[u] = 0;
cur += get(sizes[v]);
};
for (auto v : take[i]) {
for (auto u : g[v]) {
if (good[u]) {
add_edge(v, u);
}
}
}
for (auto v : take[i]) {
good[v] = 0;
par[v] = v;
sizes[v] = 1;
}
ans[i] = cur;
}
for (int i = N - 1; i >= 1; i--) {
for (int j = i + i; j < N; j += i) {
ans[i] -= ans[j];
}
}
for (int i = 1; i < N; i++) {
if (ans[i]) {
cout << i << ' ' << ans[i] << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const double PI = acos(-1.0);
const double EPS = 1e-9;
const long long INF = 1e9;
const long long LINF = 1e18;
const long long mod = 1e9 + 7;
const long long MAX = 2e5 + 1;
int n;
int a[MAX];
vector<int> g[MAX];
long long DP[MAX];
vector<int> vert[MAX];
bool ye[MAX];
bool pozn[MAX];
int marked[MAX];
int counter = 0;
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) {
scanf("%d", &a[i]);
vert[a[i]].push_back(i);
}
int u, v;
for (int i = (0); i < (n - 1); ++i) {
scanf("%d %d", &u, &v);
--u;
--v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = (1); i < (MAX); ++i) {
counter = 0;
for (int j = i; j < MAX; j += i) {
int k;
for (int to = (0); to < ((int)((vert[j]).size())); ++to) {
k = vert[j][to];
marked[counter++] = k;
ye[k] = 1;
pozn[k] = 0;
}
}
queue<int> q;
long long tut = 0;
for (int to = (0); to < (counter); ++to) {
int k = marked[to];
if (pozn[k]) continue;
q.push(k);
pozn[k] = 1;
int ye1 = 1;
while (!q.empty()) {
int t = q.front();
q.pop();
for (int to = (0); to < ((int)((g[t]).size())); ++to) {
int su = g[t][to];
if (pozn[su] || ye[su] == 0) continue;
pozn[su] = 1;
++ye1;
q.push(su);
}
}
tut += ye1 * 1LL * (ye1 - 1) / 2LL;
}
DP[i] = tut;
for (int k = (0); k < (counter); ++k) ye[marked[k]] = 0;
}
for (int i = (MAX)-1; i >= (1); --i)
for (int j = i * 2; j < MAX; j += i) DP[i] -= DP[j];
for (int i = (1); i < (MAX); ++i) DP[i] += (int)((vert[i]).size());
for (int i = (1); i < (MAX); ++i)
if (DP[i]) {
printf("%d ", i);
printf("%lld\n", DP[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[200100];
vector<int> g[200100];
map<int, long long> m[200100];
long long cnt[200100];
long long gcd(long long x, long long y) { return y == 0 ? x : gcd(y, x % y); }
void dfs(int x, int pa) {
m[x][a[x]]++;
for (int i = 0; i < g[x].size(); i++) {
int ver = g[x][i];
if (ver == pa) continue;
dfs(ver, x);
map<int, long long>::iterator it1, it2;
for (it1 = m[x].begin(); it1 != m[x].end(); it1++) {
for (it2 = m[ver].begin(); it2 != m[ver].end(); it2++) {
cnt[gcd(it1->first, it2->first)] += it1->second * it2->second;
}
}
for (it1 = m[ver].begin(); it1 != m[ver].end(); it1++) {
m[x][gcd(a[x], it1->first)] += it1->second;
}
m[ver].clear();
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]), cnt[a[i]]++;
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= 200000; i++) {
if (cnt[i]) {
printf("%d %lld\n", i, cnt[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long cmod = 998244353;
const long long inf = 1LL << 61;
const int M = 1e6 + 500;
const long long int ths = 1LL << 40;
const int NN = 5e3 + 6;
vector<long long int> g[N];
map<long long int, long long int> dp[N];
long long int ans = 0;
void dfs(long long int u, long long int p = -1) {
for (auto it : g[u]) {
if (it != p) {
dfs(it, u);
}
}
for (auto &it : dp[u]) {
long long int mx1 = 0, mx2 = 0;
priority_queue<long long int> pq;
for (auto X : g[u]) {
if (X == p) {
continue;
}
if (dp[X].count(it.first)) pq.push(dp[X][it.first]);
}
if (pq.size()) {
mx1 = pq.top();
pq.pop();
}
if (pq.size()) {
mx2 = pq.top();
pq.pop();
}
it.second += mx1;
ans = max(ans, mx1 + mx2 + 1);
}
return;
}
void solve() {
long long int n;
cin >> n;
long long int a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) {
continue;
}
while (a[i] % 2 == 0) {
a[i] /= 2;
dp[i][2] = 1;
}
for (int j = 3; j * j <= a[i]; j++) {
while (a[i] % j == 0) {
dp[i][j] = 1;
a[i] /= j;
}
}
if (a[i] > 2) {
dp[i][a[i]] = 1;
}
}
for (int i = 1; i < n; i++) {
long long int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1);
cout << ans;
cout << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static inline void canhazfast() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
}
template <typename T>
T gcd(T a, T b) {
return b == 0 ? a : gcd(b, a % b);
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) {
T x0 = 1, y0 = 0, x1 = 0, y1 = 1;
while (b) {
T q = a / b;
a %= b;
swap(a, b);
x0 -= q * x1;
swap(x0, x1);
y0 -= q * y1;
swap(y0, y1);
}
x = x0;
y = y0;
return a;
}
static inline int ctz(unsigned x) { return __builtin_ctz(x); }
static inline int ctzll(unsigned long long x) { return __builtin_ctzll(x); }
static inline int clz(unsigned x) { return __builtin_clz(x); }
static inline int clzll(unsigned long long x) { return __builtin_clzll(x); }
static inline int popcnt(unsigned x) { return __builtin_popcount(x); }
static inline int popcntll(unsigned long long x) {
return __builtin_popcountll(x);
}
static inline int bsr(unsigned x) { return 31 ^ clz(x); }
static inline int bsrll(unsigned long long x) { return 63 ^ clzll(x); }
unsigned a[200008];
long long ans[200008];
vector<int> adj[200008];
unordered_map<unsigned, long long> cnt[200008];
void dfs(int u, int p = 0) {
for (int v : adj[u]) {
if (v == p) continue;
dfs(v, u);
for (auto &cv : cnt[v]) {
for (auto &cu : cnt[u]) {
ans[gcd(cv.first, cu.first)] += cv.second * cu.second;
}
}
for (auto &cv : cnt[v]) cnt[u][gcd(a[u], cv.first)] += cv.second;
cnt[v].clear();
}
++cnt[u][a[u]];
for (auto cu : cnt[u]) ans[cu.first] += cu.second;
}
int main() {
canhazfast();
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(1);
for (int i = 1; i <= 200000; ++i)
if (ans[i]) cout << i << ' ' << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> v) {
os << "( " << v.first << ", " << v.second << ")";
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << " ";
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<vector<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<set<T>> &v) {
for (int i = 0; i < v.size(); i++) {
if (i > 0) {
os << endl;
}
os << v[i];
}
return os;
}
template <class T>
ostream &operator<<(ostream &os, const set<T> &v) {
int i = 0;
for (auto it : v) {
if (i > 0) {
os << ' ';
}
os << it;
i++;
}
return os;
}
using ll = long long int;
const int MAX_N = 2e5;
vector<int> min_divs(MAX_N + 1);
void init() {
iota(min_divs.begin(), min_divs.end(), 0);
for (ll x = 2; x <= MAX_N; ++x) {
if (min_divs[x] == x) {
for (int y = x * x; y <= MAX_N; y += x) {
if (min_divs[y] == y) {
min_divs[y] = x;
}
}
}
}
}
ll bfs(int start, const vector<vector<int>> &edges, vector<int> &oks) {
assert(oks[start] == true);
int sum = 0;
queue<int> que;
que.push(start);
while (!que.empty()) {
int now = que.front();
que.pop();
oks[now] = false;
sum++;
for (auto e : edges[now]) {
if (oks[e]) que.emplace(e);
}
}
return sum;
}
int main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> v(N);
for (int i = 0; i < N; ++i) cin >> v[i];
vector<vector<int>> ids(MAX_N + 1);
for (int i = 0; i < N; ++i) ids[v[i]].push_back(i);
vector<vector<int>> edges(N);
for (int i = 0; i < N - 1; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
vector<ll> anss(MAX_N + 1);
vector<int> oks(N);
for (int num = 1; num <= MAX_N; ++num) {
vector<int> now_ids;
for (int x = num; x <= MAX_N; x += num) {
for (auto id : ids[x]) {
oks[id] = true;
now_ids.push_back(id);
}
}
ll nanswer = 0;
for (auto n_id : now_ids) {
if (oks[n_id]) {
ll sum = bfs(n_id, edges, oks);
nanswer += sum * (sum + 1) / 2;
}
}
anss[num] = nanswer;
}
for (int num = MAX_N; num >= 1; --num) {
for (int x = 2 * num; x <= MAX_N; x += num) {
anss[num] -= anss[x];
}
}
for (int num = 1; num <= MAX_N; ++num) {
if (anss[num]) {
cout << num << ' ' << anss[num] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int MAXN = 200000;
int n, tot;
bool bz[N];
vector<int> g[N], edge[N];
int e[N * 2][2], gg[N];
int sz;
long long ans[N];
void add(int x, int y) {
e[++tot][0] = y;
e[tot][1] = gg[x];
gg[x] = tot;
}
void dfs(int x) {
bz[x] = 0;
sz++;
for (int i = gg[x]; i; i = e[i][1])
if (bz[e[i][0]]) dfs(e[i][0]);
gg[x] = 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
for (int j = 1; 1ll * j * j <= x; j++)
if ((x % j) == 0) {
g[j].push_back(i);
if (j * j != x) g[x / j].push_back(i);
}
}
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
edge[x].push_back(y);
edge[y].push_back(x);
}
for (int i = 1; i <= MAXN; i++)
if (g[i].size()) {
tot = 0;
for (auto u : g[i]) bz[u] = 1;
for (auto u : g[i])
for (auto v : edge[u])
if (bz[v]) add(u, v);
for (auto u : g[i])
if (bz[u]) {
sz = 0;
dfs(u);
ans[i] += 1ll * sz * (sz - 1) / 2 + sz;
}
}
for (int i = MAXN; i; i--)
for (int j = 2; 1ll * j * i <= MAXN; j++) ans[i] -= ans[i * j];
for (int i = 1; i <= MAXN; i++)
if (ans[i]) printf("%d %lld\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, a[MAXN], u[MAXN], v[MAXN];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
vector<int> c[MAXN];
long long f[MAXN];
int x[MAXN], fa[MAXN], siz[MAXN];
int getfa(int u) { return u == fa[u] ? u : fa[u] = getfa(fa[u]); }
inline void merge(int j, int u, int v) {
u = getfa(u);
v = getfa(v);
if (u == v) return;
f[j] += (long long)siz[u] * siz[v];
fa[u] = v;
siz[v] += siz[u];
}
int mu[MAXN], prm[MAXN], pn;
bool notp[MAXN];
void table(int n) {
notp[0] = notp[1] = 1;
mu[1] = 1;
for (int i = 2; i <= n; i++) {
if (!notp[i]) {
prm[++pn] = i;
mu[i] = -1;
}
for (int j = 1; j <= pn && prm[j] * i <= n; j++) {
notp[prm[j] * i] = 1;
if (i % prm[j])
mu[prm[j] * i] = -mu[i];
else {
mu[prm[j] * i] = 0;
break;
}
}
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
for (int j = 1; j * j <= a[i]; j++)
if (!(a[i] % j)) {
f[j]++;
if (j * j != a[i]) ++f[a[i] / j];
}
}
for (int i = 1; i < n; i++) {
cin >> u[i] >> v[i];
int t = gcd(a[u[i]], a[v[i]]);
for (int j = 1; j * j <= t; j++)
if (!(t % j)) {
c[j].push_back(i);
if (j * j != t) c[t / j].push_back(i);
}
}
int m = 200000;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < c[i].size(); j++) {
fa[u[c[i][j]]] = u[c[i][j]];
siz[u[c[i][j]]] = 1;
fa[v[c[i][j]]] = v[c[i][j]];
siz[v[c[i][j]]] = 1;
}
for (int j = 0; j < c[i].size(); j++) merge(i, u[c[i][j]], v[c[i][j]]);
}
table(m);
for (int k = 1; k <= m; k++) {
long long ans = 0;
for (int i = 1; i * k <= m; i++) ans += mu[i] * f[i * k];
if (ans) cout << k << ' ' << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int readInt() {
char c;
int tmp = 0, x = 1;
c = getchar();
while (c > '9' || c < '0') {
if (c == '-') x = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
tmp = tmp * 10 + c - '0';
c = getchar();
}
return tmp * x;
}
const int maxN = 200000 + 10;
int a[maxN], n;
vector<int> g[maxN];
void addEdge(int u, int v) {
g[u].push_back(v);
g[v].push_back(u);
}
bool vis[maxN];
int pri[maxN], tot = 0, mu[maxN];
void sieve() {
mu[1] = 1;
for (int i = 2; i < maxN; i++) {
if (!vis[i]) pri[++tot] = i, mu[i] = -1;
for (int j = 1; j <= tot && pri[j] * i < maxN; j++) {
vis[pri[j] * i] = true;
if (i % pri[j] == 0) {
mu[pri[j] * i] = 0;
break;
}
mu[pri[j] * i] = -mu[i];
}
}
}
int Fa[maxN];
void dfs(int v, int fa) {
Fa[v] = fa;
for (int i = 0; i < (int)g[v].size(); i++) {
int u = g[v][i];
if (u != fa) dfs(u, v);
}
}
int siz[maxN], f[maxN];
int getFather(int x) { return x == f[x] ? f[x] : f[x] = getFather(f[x]); }
void mergeUnion(int u, int v) {
int fu = getFather(u), fv = getFather(v);
if (fu == fv)
return;
else {
if (siz[fu] > siz[fv]) swap(fu, fv);
siz[fv] += siz[fu];
f[fu] = fv;
}
}
vector<int> hav[maxN], all;
long long h[maxN], ans[maxN];
int main() {
sieve();
memset(vis, 0, sizeof(vis));
n = readInt();
for (int i = 1; i <= n; i++) a[i] = readInt(), hav[a[i]].push_back(i);
int u, v;
for (int i = 1; i <= n - 1; i++) {
u = readInt(), v = readInt();
addEdge(u, v);
}
dfs(1, -1);
for (int i = 1; i <= 200000; i++) {
for (int k = 0; k < (int)all.size(); k++)
siz[all[k]] = 0, f[all[k]] = 0, vis[all[k]] = false;
all.clear();
for (int j = i; j <= 200000; j += i) {
for (int k = 0; k < (int)hav[j].size(); k++) {
siz[hav[j][k]] = 1, f[hav[j][k]] = hav[j][k];
all.push_back(hav[j][k]);
}
}
for (int k = 0; k < (int)all.size(); k++) {
v = all[k];
if (Fa[v] != -1 && a[Fa[v]] % i == 0) mergeUnion(Fa[v], v);
}
for (int k = 0; k < (int)all.size(); k++) {
v = all[k];
if (!vis[u = getFather(v)])
h[i] += 1ll * siz[u] * (siz[u] + 1) / 2, vis[u] = true;
}
}
for (int i = 1; i <= 200000; i++) {
for (int j = 1; j <= (200000 / i); j++) {
ans[i] += h[j * i] * 1ll * mu[j];
}
}
for (int i = 1; i <= 200000; i++) {
if (ans[i] > 0) printf("%d %I64d\n", i, ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
const int maxn = 2e5 + 10;
const int mod = 1e9 + 7;
map<int, int> mp[maxn][2];
vector<int> G[maxn];
vector<int> fac[maxn];
int ans = 1;
void get_fac(int x, int id) {
int n = x;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
fac[id].push_back(i);
}
}
if (n != 1) fac[id].push_back(n);
}
void dfs(int u, int fa) {
for (int i = 0; i < fac[u].size(); i++) mp[u][0][fac[u][i]] = 1;
for (int i = 0; i < G[u].size(); i++) {
int to = G[u][i];
if (to == fa) continue;
dfs(to, u);
for (int j = 0; j < fac[u].size(); j++) {
int nxt = fac[u][j];
int Max = mp[to][0][nxt];
if (Max + 1 > mp[u][0][nxt]) {
mp[u][1][nxt] = mp[u][0][nxt];
mp[u][0][nxt] = Max + 1;
} else if (Max + 1 == mp[u][0][nxt])
mp[u][1][nxt] = Max + 1;
else if (Max + 1 > mp[u][1][nxt])
mp[u][1][nxt] = Max + 1;
ans = max(ans, mp[u][0][nxt] + mp[u][1][nxt] - 1);
}
}
}
int main() {
int n;
cin >> n;
int flag = 1;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
if (x != 1) flag = 0;
get_fac(x, i);
}
if (flag) {
printf("0\n");
return 0;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 200000;
int n, a[N + 1];
long long an[N + 1];
vector<int> x[N + 1], tr[N + 1];
bool good[N + 1];
int go(int v) {
int an = 1;
good[v] = false;
for (int i = 0; i < (int)(tr[v].size()); ++i) {
int u = tr[v][i];
if (!good[u]) continue;
an += go(u);
}
return an;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < (int)(n + 1); ++i)
scanf("%d", a + i), x[a[i]].push_back(i);
for (int i = 1; i < (int)(n); ++i) {
int a, b;
scanf("%d%d", &a, &b);
tr[a].push_back(b);
tr[b].push_back(a);
}
for (int i = 1; i < (int)(N + 1); ++i) {
for (int j = i; j <= N; j += i)
for (int k = 0; k < (int)(x[j].size()); ++k) good[x[j][k]] = true;
for (int j = i; j <= N; j += i)
for (int k = 0; k < (int)(x[j].size()); ++k)
if (good[x[j][k]]) {
int s = go(x[j][k]);
an[i] += s + ((long long)s * (s - 1) >> 1);
}
}
for (int i = N; i > 0; --i)
for (int j = i << 1; j <= N; j += i) an[i] -= an[j];
for (int i = 1; i < (int)(N + 1); ++i)
if (an[i]) printf("%d %lld\n", i, an[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200000 + 5], mu[200000 + 5], cc, good[200000 + 5], used[200000 + 5],
q[200000 + 5], fr, bk;
vector<int> G[200000 + 5], nbfs[200000 + 5], prime;
long long ans1[200000 + 5], ans2[200000 + 5];
bool vis[200000 + 5];
void init() {
mu[1] = 1;
for (int i = 2; i <= 200000; i++) {
if (!vis[i]) {
prime.push_back(i);
mu[i] = -1;
}
for (int j = 0; i * prime[j] <= 200000; j++) {
vis[i * prime[j]] = true;
if (i % prime[j] == 0) {
mu[i * prime[j]] = 0;
break;
}
mu[i * prime[j]] = -mu[i];
}
}
}
int bfs(int x, int gc) {
fr = bk = 0;
q[bk++] = x;
used[x] = cc;
while (fr < bk) {
int z = q[fr++];
for (int i = 0; i < G[z].size(); i++) {
int y = G[z][i];
if (good[a[y]] == cc && used[y] < cc) {
used[y] = cc;
q[bk++] = y;
}
}
}
return bk;
}
int main() {
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
nbfs[a[i]].push_back(i);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 200000; i > 0; i--) {
cc++;
for (int j = i; j <= 200000; j += i) good[j] = cc;
for (int j = i; j <= 200000; j += i)
for (int k = 0; k < nbfs[j].size(); k++) {
int x = nbfs[j][k];
if (used[x] == cc) continue;
int z = bfs(x, i);
ans1[i] += 1ll * z * (z + 1) / 2;
}
for (int j = i, k = 1; j <= 200000; j += i, k++) ans2[i] += mu[k] * ans1[j];
}
for (int i = 1; i <= 200000; i++)
if (ans2[i]) printf("%d %lld\n", i, ans2[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MX = 2e5 + 1;
bool sieve[MX], in_graph[MX], vstd[MX];
vector<int> pos[MX], adj[MX];
int mu[MX];
ll res[MX];
void init() {
vector<int> primes;
mu[1] = 1;
for (int i = 2; i < MX; ++i) {
if (!sieve[i]) {
mu[i] = -1;
primes.push_back(i);
}
for (auto j : primes) {
if (i * j >= MX) break;
sieve[i * j] = true;
if (i % j == 0) {
mu[i * j] = 0;
break;
}
mu[i * j] = -mu[i];
}
}
}
int dfs(int u, int p) {
int res = 1;
vstd[u] = true;
for (auto c : adj[u]) {
if (c == p || !in_graph[c]) continue;
res += dfs(c, u);
}
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
init();
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int a;
cin >> a;
pos[a].push_back(i);
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i < MX; ++i) {
for (int j = i; j < MX; j += i) {
for (auto k : pos[j]) {
in_graph[k] = true;
}
}
for (int j = i; j < MX; j += i) {
for (auto k : pos[j]) {
if (!vstd[k]) {
ll cnt = dfs(k, 0);
res[i] += cnt * (cnt + 1) / 2;
}
}
}
for (int j = i; j < MX; j += i) {
for (auto k : pos[j]) {
in_graph[k] = false;
vstd[k] = false;
}
}
}
for (int i = 1; i < MX; ++i) {
ll ans = 0;
for (int j = 1; j * i < MX; ++j) {
ans += mu[j] * res[j * i];
}
if (ans) {
cout << i << ' ' << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Graph {
int n;
vector<vector<int>> g;
Graph(int n) : n(n) { g.resize(n); }
void init(int n_) {
n = n_;
g.resize(n_);
}
void add_edge(int from, int to) { g[from].push_back(to); }
};
struct Tree {
int n;
int root;
vector<vector<int>> t;
vector<int> par;
vector<int> dpt;
void init(Graph &g, int root_) {
n = g.n;
root = root_;
t.resize(n);
par.resize(n);
dpt.resize(n);
fill(dpt.begin(), dpt.end(), -1);
queue<int> que;
par[root] = -1;
dpt[root] = 0;
que.push(root);
while (que.size()) {
int pa = que.front();
que.pop();
for (int ch : g.g[pa]) {
if (dpt[ch] == -1) {
t[pa].push_back(ch);
par[ch] = pa;
dpt[ch] = dpt[pa] + 1;
que.push(ch);
}
}
}
}
Tree() {}
Tree(Graph &g, int root_) { init(g, root_); }
};
int a[200005];
pair<int, int> p[200005];
map<int, int> mp[200005];
int main() {
bool pr[500];
vector<int> prime;
fill(pr, pr + 500, true);
for (int i = 2; i < 500; i++) {
if (pr[i]) prime.push_back(i);
for (int j = i; j <= 500; j += i) pr[j] = false;
}
int n;
cin >> n;
Graph g(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
g.add_edge(x, y);
g.add_edge(y, x);
}
Tree t(g, 0);
for (int i = 0; i < n; i++) p[i] = pair<int, int>(t.dpt[i], i);
sort(p, p + n, greater<pair<int, int>>());
int ans = 0;
for (int c = 0; c < n; c++) {
int i = p[c].second;
for (int q : prime) {
if (a[i] % q == 0) {
while (a[i] % q == 0) a[i] /= q;
int f = 0, s = 0;
for (int ch : t.t[i]) {
int x = mp[ch][q];
if (x > f) {
s = f;
f = x;
} else if (x > s) {
s = x;
}
}
ans = max(ans, f + s + 1);
mp[i][q] = f + 1;
}
}
if (a[i] != 1) {
int q = a[i];
int f = 0, s = 0;
for (int ch : t.t[i]) {
int x = mp[ch][q];
if (x > f) {
s = f;
f = x;
} else if (x > s) {
s = x;
}
}
ans = max(ans, f + s + 1);
mp[i][q] = f + 1;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, k;
int head[N], nex[2 * N], to[2 * N], now;
void add(int a, int b) {
to[++now] = b;
nex[now] = head[a];
head[a] = now;
}
int a[N];
long long ans[N];
inline int gcd(int a, int b) { return a == 0 ? b : gcd(b % a, a); }
int G;
int vis[N];
int siz[N], maxn[N];
void getG(int p, int fa, int sum) {
siz[p] = 1;
maxn[p] = 0;
for (int i = head[p]; ~i; i = nex[i]) {
if (!vis[to[i]] && to[i] != fa) {
getG(to[i], p, sum);
siz[p] += siz[to[i]];
maxn[p] = max(maxn[p], siz[to[i]]);
}
}
maxn[p] = max(maxn[p], sum - siz[p]);
if (maxn[G] > maxn[p]) G = p;
}
int dep[N], num, len[N];
int t1[N], t2[N];
void dfs(int p, int fa) {
for (int i = head[p]; ~i; i = nex[i]) {
if (vis[to[i]] || fa == to[i]) continue;
len[++num] = dep[to[i]] = gcd(dep[p], a[to[i]]);
dfs(to[i], p);
}
}
void cal(int p, int mul, int flag) {
num = 0;
len[++num] = dep[p] = gcd(mul, a[p]);
dfs(p, 0);
sort(len + 1, len + 1 + num);
int ct = 0;
for (int i = 1; i <= num; i++) {
if (i > 1 && len[i] == len[i - 1])
t2[ct]++;
else {
t1[++ct] = len[i];
t2[ct] = 1;
}
}
for (int i = 1; i <= ct; i++) {
if (t2[i] > 1) {
ans[t1[i]] += 1ll * flag * (t2[i] - 1) * t2[i] / 2;
}
for (int j = i + 1; j <= ct; j++) {
ans[gcd(t1[i], t1[j])] += 1ll * flag * t2[i] * t2[j];
}
}
}
void divide(int p) {
vis[p] = 1;
cal(p, a[p], 1);
for (int i = head[p]; ~i; i = nex[i]) {
if (vis[to[i]]) continue;
cal(to[i], a[p], -1);
G = 0;
maxn[0] = siz[to[i]];
getG(to[i], 0, siz[to[i]]);
divide(G);
}
}
int main() {
memset(head, -1, sizeof head);
now = 0;
int n;
scanf("%d", &n);
maxn[0] = n;
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
ans[a[i]]++;
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y), add(y, x);
}
G = 0;
getG(1, 0, n);
divide(G);
for (int i = 1; i <= 2e5; i++) {
if (ans[i]) {
printf("%d %lld\n", i, ans[i]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 2e5 + 100;
vector<int> g[N];
int a[N], good[N];
long long ans[N];
int sizes[N], par[N];
vector<int> vals[N];
int n;
int getPar(int v) {
if (v == par[v]) return v;
return (par[v] = getPar(par[v]));
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (int i = 0; i < N; i++) {
par[i] = i;
sizes[i] = 1;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
vals[a[i]].push_back(i);
}
for (int i = 1; i < n; i++) {
int v, u;
cin >> v >> u;
v--;
u--;
g[v].push_back(u);
g[u].push_back(v);
}
for (int i = 1; i < N; i++) {
long long cur = 0;
for (int j = i; j < N; j += i) {
for (auto v : vals[j]) {
good[v] = 1;
cur++;
}
}
auto get = [&](int x) { return 1ll * x * (x + 1) / 2; };
auto add_edge = [&](int v, int u) {
v = getPar(v);
u = getPar(u);
if (v == u) return;
cur -= get(sizes[v]);
cur -= get(sizes[u]);
if (sizes[v] < sizes[u]) swap(v, u);
par[u] = v;
sizes[v] += sizes[u];
sizes[u] = 0;
cur += get(sizes[v]);
};
for (int j = i; j < N; j += i) {
for (auto v : vals[j]) {
for (auto u : g[v]) {
if (good[u]) {
add_edge(v, u);
}
}
}
}
for (int j = i; j < N; j += i) {
for (auto v : vals[j]) {
good[v] = 0;
par[v] = v;
sizes[v] = 1;
}
}
ans[i] = cur;
}
for (int i = N - 1; i >= 1; i--) {
for (int j = i + i; j < N; j += i) {
ans[i] -= ans[j];
}
}
for (int i = 1; i < N; i++) {
if (ans[i]) {
cout << i << ' ' << ans[i] << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005, MAXA = 200000;
int n;
int mu[MAXN], pri[MAXN], pcnt;
bool npr[MAXN];
void sieve() {
mu[1] = 1;
npr[1] = true;
for (int i = 2; i < MAXN; i++) {
if (!npr[i]) {
pri[++pcnt] = i;
mu[i] = -1;
}
for (int j = 1; j <= pcnt && 1LL * pri[j] * i < MAXN; j++) {
npr[i * pri[j]] = true;
if (i % pri[j] == 0) {
mu[i * pri[j]] = 0;
break;
}
mu[i * pri[j]] = -mu[i];
}
}
}
vector<int> adj[MAXN], node[MAXN];
queue<int> Q;
int a[MAXN];
int vis[MAXN];
int bfs(int st, int d) {
Q.push(st);
vis[st] = d;
int ret = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
ret++;
for (int i = 0; i < (int)adj[u].size(); i++) {
int v = adj[u][i];
if (vis[v] != d && a[v] % d == 0) {
vis[v] = d;
Q.push(v);
}
}
}
return ret;
}
long long h[MAXN], ans[MAXN];
int main() {
sieve();
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
node[a[i]].push_back(i);
}
for (int i = 1, x, y; i <= n - 1; i++) {
scanf("%d%d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= MAXA; i++)
for (int j = i; j <= MAXA; j += i)
for (int k = 0; k < (int)node[j].size(); k++) {
int st = node[j][k];
if (vis[st] != i) {
int sz = bfs(st, i);
h[i] += 1LL * sz * (sz + 1LL) / 2LL;
}
}
for (int i = MAXA; i >= 1; i--)
for (int j = i, k = 1; j <= MAXA; j += i, k++) ans[i] += mu[k] * h[j];
for (int i = 1; i <= MAXA; i++)
if (ans[i]) printf("%d %I64d\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[200009];
int a[200009];
vector<int> v[200009];
vector<int> ad[200009];
vector<int> v1[200009];
int dp1[200009][7];
int dp2[200009][7];
int ans = 0;
void dfs(int x, int p) {
int s = ad[x].size();
int i, j, k, l;
for (i = 0; i < s; i++) {
if (ad[x][i] != p) dfs(ad[x][i], x);
}
int s1 = v1[x].size();
for (i = 0; i < s1; i++) {
int m1 = 0, m2 = 0;
for (j = 0; j < s; j++) {
if (ad[x][j] == p) continue;
int s2 = v1[ad[x][j]].size();
for (k = 0; k < s2; k++) {
if (v1[x][i] == v1[ad[x][j]][k]) {
if (dp2[ad[x][j]][k] > m1) {
m2 = m1;
m1 = dp2[ad[x][j]][k];
} else if (dp2[ad[x][j]][k] > m2)
m2 = dp2[ad[x][j]][k];
break;
}
}
}
dp2[x][i] = 1 + m1;
dp1[x][i] = 1 + m1 + m2;
ans = max(ans, dp1[x][i]);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, i, j, k, l;
for (i = 1; i <= 200000; i++) ar[i] = 1;
int maxi = 0;
for (i = 2; i <= 200000; i++) {
if (ar[i] == 1) {
for (j = 1; j * i <= 200000; j++) {
v[i * j].push_back(i);
int sii = v[i * j].size();
ar[i * j] = 0;
maxi = max(maxi, sii);
}
}
}
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
int si = v[a[i]].size();
for (j = 0; j < si; j++) v1[i].push_back(v[a[i]][j]);
}
for (i = 1; i <= n - 1; i++) {
cin >> j >> k;
ad[j].push_back(k);
ad[k].push_back(j);
}
dfs(1, 0);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int spf[200005];
set<int> v[200005];
vector<int> g[200005];
int a[200005];
int ans = 0;
map<int, int> c[200005];
void sieve() {
spf[1] = 1;
for (int i = 2; i < 200005; i++) spf[i] = i;
for (int i = 4; i < 200005; i += 2) spf[i] = 2;
for (int i = 3; i * i < 200005; i++) {
if (spf[i] == i) {
for (int j = i * i; j < 200005; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
void get(int i, int x) {
if (x == 0 || x == 1) return;
while (x != 1) {
v[i].insert(spf[x]);
x = x / spf[x];
}
}
void dfs(int p, int pr) {
int i;
for (i = 0; i < g[p].size(); i++) {
int v1 = g[p][i];
if (v1 != pr) dfs(v1, p);
}
set<int>::iterator it;
for (it = v[a[p]].begin(); it != v[a[p]].end(); it++) {
int m = 0;
multiset<int> k;
k.clear();
for (i = 0; i < g[p].size(); i++) {
int v1 = g[p][i];
if (v1 != pr) {
if (a[v1] % (*it) == 0) {
k.insert(c[v1][*it]), m = max(m, c[v1][*it]);
while (k.size() > 2) k.erase(k.begin());
}
}
}
ans = max(ans, m + 1);
c[p][*it] = m + 1;
if (k.size() == 2) {
int x = *k.begin();
ans = max(ans, x + m + 1);
}
}
}
int main() {
sieve();
int i, j;
for (i = 0; i < 200005; i++)
v[i].clear(), g[i].clear(), c[i].clear(), get(i, i);
int n;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n - 1; i++) {
int u, v1;
cin >> u >> v1;
g[u].push_back(v1);
g[v1].push_back(u);
}
ans = 0;
dfs(1, -1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int maxm = 2 * maxn;
const int inf = 0x7fffffff;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
struct node {
int to, next;
} g[maxm];
int n, head[maxn], tol;
int a[maxn], prime[maxn][30], ans, dp[maxn][30];
void init() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
};
void add(int x, int y) {
g[tol].to = y;
g[tol].next = head[x];
head[x] = tol++;
}
void dfs(int x, int fa) {
for (int i = head[x]; i != -1; i = g[i].next) {
int id = g[i].to;
if (id == fa) continue;
dfs(id, x);
for (int j = 1; j <= prime[id][0]; j++) {
for (int k = 1; k <= prime[x][0]; k++) {
if (prime[id][j] == prime[x][k]) {
ans = max(ans, dp[x][k] + dp[id][j] + 1);
dp[x][k] = max(dp[x][k], dp[id][j] + 1);
}
}
}
}
}
int main() {
init();
memset(head, -1, sizeof(head));
tol = 0;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
bool flag = 1;
for (int i = 1; i <= n; i++)
if (a[i] != 1) flag = 0;
if (flag) {
cout << 0;
return 0;
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
add(x, y);
add(y, x);
}
for (int i = 1; i <= n; i++) {
for (int j = 2; j * j <= a[i]; j++)
if (a[i] % j == 0) {
prime[i][++prime[i][0]] = j;
while (a[i] % j == 0) a[i] /= j;
}
if (a[i] > 1) prime[i][++prime[i][0]] = a[i];
}
dfs(1, 1);
cout << ans + 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void setIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int N = 2e5 + 3;
const int M = 2e5;
const long long inf = 9e17;
const long long mod = 1e9 + 7;
int xyz = 1;
int n, q;
int arr[N];
long long vis[N];
long long res[N];
vector<int> fac[N];
vector<int> con[N];
int dfs(int pos, int x) {
vis[pos] = 1;
for (int adj : con[pos])
if (!vis[adj] && arr[adj] % x == 0) vis[pos] += dfs(adj, x);
return vis[pos];
}
void red(int x, int p) {
for (int i = 1; i * i <= x; i++) {
if (x % i) continue;
if (i * i == x) {
fac[i].push_back(p);
} else {
fac[i / 1].push_back(p);
fac[x / i].push_back(p);
}
}
}
void run() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i], red(arr[i], i);
for (int i = 2; i <= n; i++) {
int u;
int v;
cin >> u >> v;
con[u].push_back(v);
con[v].push_back(u);
}
for (int i = 1; i <= M; i++) {
for (int x : fac[i])
if (!vis[x]) {
long long s = dfs(x, i);
res[i] += s * s - s * (s - 1) / 2;
}
for (int x : fac[i]) vis[x] = 0;
}
for (int i = M; i >= 1; i--)
for (int j = i + i; j <= M; j += i) res[i] -= res[j];
for (int i = 1; i <= M; i++)
if (res[i]) cout << i << " " << res[i] << "\n";
}
int main() {
setIO();
while (xyz--) run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, c = 2e5;
int n, p[maxn], pri[maxn], mu[maxn], t, vis[maxn], go[maxn], w[maxn],
pi = 1, Q[maxn], l, r;
long long f[maxn], g[maxn];
vector<int> S[maxn];
struct Edge {
Edge* next;
int to;
Edge(Edge* next = 0, int to = 0) : next(next), to(to) {}
} * first[maxn], pool[maxn << 1], *pis = pool;
void sieve() {
mu[1] = 1;
for (int i = 2; i <= c; i++) p[i] = 1;
for (int i = 2; i <= c; i++) {
if (p[i]) pri[t++] = i, mu[i] = -1;
for (int j = 0, d; j < t && (d = i * pri[j]) <= c; j++) {
p[d] = 0;
if (i % pri[j] == 0) {
mu[d] = 0;
break;
} else
mu[d] = -mu[i];
}
}
}
int Bfs(int u) {
l = 0, r = 0, Q[++r] = u;
vis[u] = pi;
while (l < r) {
int x = Q[++l];
for (Edge* now = first[x]; now; now = now->next) {
if (go[w[now->to]] == pi && (vis[now->to] ^ pi)) {
vis[now->to] = pi, Q[++r] = now->to;
}
}
}
return r;
}
int main() {
sieve();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &w[i]);
S[w[i]].push_back(i);
}
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
first[u] = new (pis++) Edge(first[u], v);
first[v] = new (pis++) Edge(first[v], u);
}
for (int i = c; i; i--, pi++) {
for (int j = i; j <= c; j += i) go[j] = pi;
for (int j = i; j <= c; j += i) {
for (int k = 0; k < S[j].size(); k++) {
int u = S[j][k];
if (vis[u] == pi) continue;
int x = Bfs(u);
g[i] += 1ll * x * (x + 1) >> 1;
}
}
for (int j = i; j <= c; j += i) {
f[i] += g[j] * mu[j / i];
}
}
for (int i = 1; i <= c; i++)
if (f[i]) printf("%d %lld\n", i, f[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int x;
scanf("%d", &x);
return x;
}
long long lin() {
long long x;
scanf("%lld", &x);
return x;
}
const int N = 200010;
int n, a[N];
long long ans[N];
vector<int> e[N];
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
void dfs(int now, int past, map<int, long long> &mp) {
for (int next : e[now]) {
if (next == past) continue;
map<int, long long> tmp;
dfs(next, now, tmp);
for (auto p1 : mp) {
for (auto p2 : tmp) {
ans[gcd(p1.first, p2.first)] += p1.second * p2.second;
}
}
for (auto p : tmp) {
mp[gcd(p.first, a[now])] += p.second;
}
}
mp[a[now]]++;
for (auto p : mp) {
ans[p.first] += p.second;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) a[i] = in();
for (int i = 0; i < n - 1; ++i) {
int u = in() - 1, v = in() - 1;
e[u].push_back(v);
e[v].push_back(u);
}
map<int, long long> mp;
dfs(0, -1, mp);
for (int i = 1; i <= N - 1; ++i) {
if (ans[i] == 0) continue;
printf("%d %lld\n", i, ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, l, m, v[201010], q[201001];
vector<long long> qq[201010];
map<long long, long long> c[201010];
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
void dfs(long long x, long long p) {
c[x][v[x]]++;
for (int i = 0; i < qq[x].size(); i++) {
long long u = qq[x][i];
if (u == p) {
continue;
}
dfs(u, x);
for (map<long long, long long>::iterator it1 = c[x].begin();
it1 != c[x].end(); it1++) {
for (map<long long, long long>::iterator it2 = c[u].begin();
it2 != c[u].end(); it2++) {
q[gcd(it1->first, it2->first)] += it1->second * it2->second;
}
}
for (map<long long, long long>::iterator it1 = c[u].begin();
it1 != c[u].end(); it1++) {
c[x][gcd(it1->first, v[x])] += it1->second;
}
c[u].clear();
}
}
int main() {
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", &v[i]);
q[v[i]]++;
}
for (i = 1; i <= n - 1; i++) {
scanf("%lld%lld", &k, &l);
qq[k].push_back(l);
qq[l].push_back(k);
}
dfs(1, 0);
for (i = 1; i <= 200000; i++) {
if (q[i]) {
printf("%lld %lld\n", i, q[i]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200010];
vector<int> G[200010];
int S = -1;
int idx = -1;
void dfs1(int x, int parent, int kind, int depth) {
for (auto to : G[x]) {
if (parent == to) continue;
if (a[to] % kind == 0) dfs1(to, x, kind, depth + 1);
}
if (S < depth) {
S = depth;
idx = x;
}
}
int c = 0;
int dfs2(int x, int parent, int kind, int depth) {
while (a[x] % kind == 0) a[x] /= kind;
for (auto to : G[x]) {
if (a[to] % kind == 0) dfs2(to, x, kind, depth + 1);
}
if (parent == -1) return c + 1;
c = max(c, depth);
return depth;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
int s, t;
cin >> s >> t;
s--;
t--;
G[s].push_back(t);
G[t].push_back(s);
}
int k = 0;
for (int j = 2; j * j <= 200000; j++) {
for (int i = 0; i < n; i++) {
if (a[i] % j == 0) {
S = -1;
idx = -1;
dfs1(i, -1, j, 0);
k = max(k, dfs2(idx, -1, j, 0));
}
}
}
for (int i = 0; i < n; i++) {
if (a[i] > 1) {
S = -1;
idx = -1;
dfs1(i, -1, a[i], 0);
k = max(k, dfs2(idx, -1, a[i], 0));
}
}
cout << k << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
vector<int> G[210000], F[210000], dp[210000];
void fac(int x) {
for (int i = 2; i * i <= a[x]; i++) {
if (a[x] % i == 0) {
F[x].push_back(i);
dp[x].push_back(1);
}
while (a[x] % i == 0) a[x] /= i;
}
if (a[x] != 1) {
F[x].push_back(a[x]);
dp[x].push_back(1);
}
}
void dfs(int u, int f, int& maxn) {
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (v == f) continue;
dfs(v, u, maxn);
for (int j = 0; j < F[u].size(); j++) {
for (int k = 0; k < F[v].size(); k++) {
if (F[u][j] == F[v][k]) {
maxn = max(maxn, dp[u][j] + dp[v][k]);
dp[u][j] = max(dp[u][j], dp[v][k] + 1);
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
int n, x, y;
while (cin >> n) {
bool flg = true;
for (int i = 1; i <= n; i++) {
F[i].clear();
dp[i].clear();
G[i].clear();
cin >> a[i];
if (a[i] != 1) flg = false;
fac(i);
}
for (int i = 1; i < n; i++) {
cin >> x >> y;
G[x].push_back(y);
G[y].push_back(x);
}
if (flg) {
cout << 0 << endl;
continue;
}
int maxn = 1;
dfs(1, 0, maxn);
cout << maxn << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int wei[200005];
vector<int> v[200005];
vector<int> fact[200005];
bool per[200005];
int maxdis;
int dfs(int now, int father) {
per[now] = 0;
int max_child = 1;
for (auto i : v[now]) {
if (i != father) {
if (per[i]) {
int val = dfs(i, now);
maxdis = max(maxdis, max_child + val);
max_child = max(max_child, val + 1);
}
}
}
maxdis = max(maxdis, 1);
return max_child;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> wei[i];
for (int j = 2; j * j <= wei[i]; j++) {
if (wei[i] % j == 0) {
fact[j].push_back(i);
if (wei[i] / j != j) {
fact[wei[i] / j].push_back(i);
}
}
}
fact[wei[i]].push_back(i);
}
int a, b;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
a--, b--;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 2; i < 200005; i++) {
for (auto j : fact[i]) {
per[j] = 1;
}
for (auto j : fact[i]) dfs(j, -1);
}
cout << maxdis << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 13;
long long dp[MAXN];
int odw[MAXN];
int war[MAXN];
vector<int> v[MAXN];
vector<int> val[MAXN];
int DFS(int x, int licz) {
odw[x] = licz;
int roz = 1;
for (auto it : v[x]) {
if (odw[it] != licz && war[it] % licz == 0) roz += DFS(it, licz);
}
return roz;
}
int main() {
int n;
int x, y;
long long a;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
war[i] = x;
for (int j = 1; j * j < x; j++) {
if (x % j == 0) {
val[j].emplace_back(i);
val[x / j].emplace_back(i);
}
}
y = sqrt(x);
if (y * y == x) val[y].emplace_back(i);
}
for (int i = 1; i < n; i++) {
scanf("%d %d", &x, &y);
v[x].emplace_back(y);
v[y].emplace_back(x);
}
for (int i = 1; i < MAXN; i++) {
for (auto it : val[i]) {
if (odw[it] != i) {
a = DFS(it, i);
dp[i] += a * (a + 1) / 2;
}
}
}
for (int i = MAXN / 2 - 1; i > 0; i--) {
for (int j = i * 2; j < MAXN; j += i) dp[i] -= dp[j];
}
for (int i = 1; i < MAXN; i++) {
if (dp[i] != 0) printf("%d %lld\n", i, dp[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 550000;
const int INF = 99999999;
using namespace std;
int v[maxn], head[maxn], ne[maxn], to[maxn];
long long ans[maxn];
int size[maxn], ma[maxn], maxx = -INF;
bool vis[maxn];
int n, cnt = 0, root, tot;
map<int, long long> temp;
map<int, long long> mem;
map<int, long long>::iterator iter1;
map<int, long long>::iterator iter2;
inline int GCD(register int a, register int b) {
return a == 0 ? b : GCD(b % a, a);
}
inline void read(register int &x) {
x = 0;
register char ch = getchar();
while (ch < '0' || ch > '9') ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
}
inline void add(int f, int t) {
ne[++cnt] = head[f], head[f] = cnt, to[cnt] = t;
}
inline void get_root(int now, int fa) {
ma[now] = 0, size[now] = 1;
for (register int i = head[now]; i; i = ne[i]) {
if (to[i] == fa || vis[to[i]]) continue;
get_root(to[i], now);
size[now] += size[to[i]];
ma[now] = max(ma[now], size[to[i]]);
}
ma[now] = max(ma[now], tot - size[now]);
if (ma[now] < ma[root]) root = now;
}
inline void get_dep(int now, int fa, int gcd) {
temp[gcd]++;
for (register int i = head[now]; i; i = ne[i]) {
if (to[i] == fa || vis[to[i]]) continue;
get_dep(to[i], now, GCD(gcd, v[to[i]]));
}
}
inline void get_ans(int now) {
mem.clear(), mem[v[now]]++, ans[v[now]]++;
for (register int i = head[now]; i; i = ne[i]) {
if (vis[to[i]]) continue;
temp.clear();
get_dep(to[i], now, GCD(v[now], v[to[i]]));
for (iter1 = mem.begin(); iter1 != mem.end(); iter1++) {
for (iter2 = temp.begin(); iter2 != temp.end(); iter2++) {
ans[GCD(iter1->first, iter2->first)] +=
(long long)(iter1->second) * (iter2->second);
}
}
for (iter1 = temp.begin(); iter1 != temp.end(); iter1++) {
mem[iter1->first] += iter1->second;
}
}
}
inline void solve(int now) {
vis[now] = 1, get_ans(now);
for (register int i = head[now]; i; i = ne[i]) {
if (vis[to[i]]) continue;
tot = size[to[i]], root = 0;
get_root(to[i], 0);
solve(root);
}
}
int main() {
read(n);
for (register int i = 1; i <= n; i++) {
read(v[i]);
maxx = max(maxx, v[i]);
}
register int f, t;
for (register int i = 1; i < n; i++) {
read(f), read(t);
add(f, t), add(t, f);
}
size[0] = ma[0] = INF, tot = n;
get_root(1, 0);
solve(root);
for (register int i = 1; i <= maxx; i++) {
if (ans[i]) {
printf("%d %lld\n", i, ans[i]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int lim = 2e5;
vector<int> g[maxn];
long long ans[maxn];
long long a[maxn];
int N;
map<int, long long> cnt[maxn];
int gcd(int n, int m) { return n == 0 ? m : gcd(m % n, n); }
void DFS(int v, int p) {
++cnt[v][a[v]];
++ans[a[v]];
for (int u : g[v]) {
if (u != p) {
DFS(u, v);
for (auto& e1 : cnt[v]) {
for (auto& e2 : cnt[u]) {
ans[gcd(e1.first, e2.first)] += (long long)e1.second * e2.second;
}
}
for (auto& e : cnt[u]) {
cnt[v][gcd(a[v], e.first)] += e.second;
}
cnt[u].clear();
}
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%lld", &a[i]);
for (int i = 1; i < N; ++i) {
int first, second;
scanf("%d %d", &first, &second);
g[first].push_back(second);
g[second].push_back(first);
}
DFS(1, 1);
for (int i = 1; i <= lim; ++i) {
if (ans[i]) printf("%d %lld\n", i, ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 1;
long long f[MAXN], ans[MAXN];
int par[MAXN], mb[MAXN], sz[MAXN], w[MAXN];
vector<int> di[MAXN], arr[MAXN], adj[MAXN];
inline int qry(int x) { return x == par[x] ? x : par[x] = qry(par[x]); }
int main() {
for (int i = 2; i * i < MAXN; i++)
if (!par[i])
for (int j = i * i; j < MAXN; j += i) par[j] = i;
for (int i = 1; i < MAXN; i++) {
mb[i] = -1;
int j = i;
while (j > 0 && par[j] > 0) {
if (j % (par[j] * par[j]) == 0) {
mb[i] = 0;
break;
}
j /= par[j];
mb[i] *= -1;
}
for (int j = i; j < MAXN; j += i) di[j].push_back(i);
}
mb[1] = 1;
int n, mx = 0;
scanf("%d", &(n));
for (int i = 1; i <= n; i++) {
scanf("%d", &(w[i]));
for (int j : di[w[i]]) {
f[j]++;
arr[j].push_back(i);
}
mx = max(mx, w[i]);
}
for (int j = 1; j < n; j++) {
int u, v;
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = mx; i > 0; i--) {
if (f[i] == 0) continue;
for (int j : arr[i]) par[j] = j, sz[j] = 1;
for (int j : arr[i]) {
int u = qry(j), v;
for (int k : adj[j]) {
if (w[k] % i != 0 || (v = qry(k)) == u) continue;
par[v] = u;
f[i] += (long long)sz[u] * (long long)sz[v];
sz[u] += sz[v];
}
}
for (int j = i, cnt = 1; j <= mx; j += i, cnt++) ans[i] += mb[cnt] * f[j];
}
for (int i = 1; i <= mx; i++)
if (ans[i]) printf("%d %I64d\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<int, long long> c[200018];
vector<int> a[200018];
int n, u, v, val[200018];
long long cnt[200018];
map<int, long long>::iterator it1, it2;
inline int read() {
int X = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
X = (X << 3) + (X << 1) + ch - '0', ch = getchar();
return X * w;
}
int gcd(int x, int y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
void dfs(int x, int fa) {
c[x][val[x]]++;
for (int i = (int)a[x].size() - 1; i >= 0; i--) {
if (a[x][i] == fa) {
continue;
}
int u = a[x][i];
dfs(u, x);
for (it1 = c[x].begin(); it1 != c[x].end(); it1++) {
for (it2 = c[u].begin(); it2 != c[u].end(); it2++) {
cnt[gcd(it1->first, it2->first)] += it1->second * it2->second;
}
}
for (it1 = c[u].begin(); it1 != c[u].end(); it1++) {
c[x][gcd(val[x], it1->first)] += it1->second;
}
c[u].clear();
}
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
val[i] = read();
cnt[val[i]]++;
}
for (int i = 1; i < n; i++) {
v = read(), u = read();
a[u].push_back(v);
a[v].push_back(u);
}
dfs(1, 0);
for (int i = 1; i <= 200000; i++) {
if (cnt[i]) {
printf("%d %lld\n", i, cnt[i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[200001];
vector<long long> divv[200001];
long long val[200001];
long long ans = 0;
vector<long long> path[200001];
void sieve() {
for (long long i = 2; i <= 200000; i++) {
if (divv[i].size() != 0) continue;
for (long long j = i; j <= 200000; j += i) divv[j].push_back(i);
}
}
void dfs(long long node, long long par) {
for (long long i = 0; i < adj[node].size(); i++) {
if (adj[node][i] != par) dfs(adj[node][i], node);
}
for (long long i = 0; i < divv[val[node]].size(); i++) {
long long maxx = 0, minn = 0;
for (long long j = 0; j < adj[node].size(); j++) {
if (adj[node][j] == par) continue;
long long ind =
lower_bound(divv[val[adj[node][j]]].begin(),
divv[val[adj[node][j]]].end(), divv[val[node]][i]) -
divv[val[adj[node][j]]].begin();
if (val[adj[node][j]] % divv[val[node]][i] == 0) {
if (maxx < path[adj[node][j]][ind]) {
minn = maxx;
maxx = path[adj[node][j]][ind];
} else if (minn < path[adj[node][j]][ind])
minn = path[adj[node][j]][ind];
}
}
path[node].push_back(1 + maxx);
ans = max(ans, maxx + minn + 1);
}
}
int main() {
sieve();
long long n;
cin >> n;
for (long long i = 0; i < n; i++) cin >> val[i];
for (long long i = 0; i < n - 1; i++) {
long long x, y;
cin >> x >> y;
x--;
y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, -1);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int a[N], c[N];
vector<int> divs[N];
vector<int> G[N];
vector<int> cnt[N];
long long tot[N], ans[N];
int mu[N], np[N];
void getAns(int n) {
for (int i = n; i >= 1; i--) {
ans[i] = tot[i];
for (int j = i + i; j <= n; j += i) ans[i] -= ans[j];
}
}
void dfs(int v, int p = -1) {
for (auto u : G[v]) {
if (u == p) continue;
dfs(u, v);
}
for (auto x : divs[a[v]]) {
c[x] = 1;
tot[x]++;
}
for (auto u : G[v]) {
if (u == p) continue;
for (int i = 0; i < cnt[u].size(); i++) {
int x = divs[a[u]][i];
if (a[v] % x == 0) {
tot[x] += (long long)c[x] * cnt[u][i];
c[x] += cnt[u][i];
}
}
}
for (auto x : divs[a[v]]) {
cnt[v].push_back(c[x]);
c[x] = 0;
}
}
int main() {
int n = 200000;
for (int i = 1; i <= n; i++)
for (int j = i; j <= n; j += i) divs[j].push_back(i);
int V;
scanf("%d", &V);
for (int i = 1; i <= V; i++) {
scanf("%d", a + i);
}
for (int i = 1; i < V; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
dfs(1);
getAns(n);
for (int i = 1; i <= n; i++) {
if (ans[i] > 0) {
printf("%d %lld\n", i, ans[i]);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gli() {
long long a;
scanf("%I64d", &a);
return a;
}
int n;
vector<int> ne[200000];
vector<int> pr[200000];
int res = 1;
bool fn(int a, int b) { return a > b; }
void dfs(int a, int parent, map<int, int> &m) {
for (int p : pr[a]) m[p] = 1;
map<int, vector<int>> q;
for (int b : ne[a])
if (b != parent) {
map<int, int> mb;
dfs(b, a, mb);
for (auto &it : mb)
if (m.find(it.first) != m.end()) {
vector<int> &vec = q[it.first];
vec.push_back(it.second);
sort(vec.begin(), vec.end(), fn);
if (vec.size() > 2) vec.pop_back();
}
}
for (auto &it : q) {
int alt = it.second[0] + 1;
m[it.first] = alt;
if (it.second.size() > 1) alt = it.second[0] + it.second[1] + 1;
res = (res > alt ? res : alt);
}
}
int main() {
n = gi();
int n1 = 1;
for (int i = 0; i < n; i++) {
int a = gi();
if (a > 1) n1 = 0;
for (int p = 2; a > 1 && p * p <= a; p++)
if (a % p == 0) {
pr[i].push_back(p);
while (a % p == 0) a /= p;
}
if (a) pr[i].push_back(a);
}
if (n1) {
printf("0\n");
return 0;
}
for (int i = 1; i < n; i++) {
int x = gi() - 1;
int y = gi() - 1;
ne[x].push_back(y);
ne[y].push_back(x);
}
map<int, int> mb;
dfs(0, -1, mb);
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int prime[150000];
int lp[200010];
int phi[200010];
class prime_class {
public:
long top;
prime_class() {
int i, i2, j;
top = 0;
lp[0] = 0;
lp[1] = 1;
for (i = 2; i < 200010; i++) lp[i] = 0;
top = 0;
for (i = 2; i < 200010; ++i) {
if (lp[i] == 0) {
lp[i] = i;
prime[top++] = i;
}
for (j = 0; (j < top) && (prime[j] <= lp[i]) && (i * prime[j] < 200010);
++j)
lp[i * prime[j]] = prime[j];
}
}
bool isprime(long long key) {
if (key < 200010)
return (lp[key] == key) && (key >= 2);
else {
int i;
for (i = 0; (i < top) && (prime[i] * prime[i] <= key); i++)
if (key % prime[i] == 0) return false;
return true;
}
}
unordered_map<int, int> factorize(int key) {
unordered_map<int, int> ans;
while (lp[key] != key) {
ans[lp[key]]++;
key /= lp[key];
}
if (key > 1) ans[key]++;
return ans;
}
int get_phi(int key) {
int ans = key, last = 0;
while (lp[key] != key) {
if (lp[key] != last) {
last = lp[key];
ans -= ans / last;
}
key /= lp[key];
}
if ((key > 1) && (key != last)) ans -= ans / key;
return ans;
}
void calc_all_phi(int n) {
int i, j, k;
for (int i = 1; i < n; i++) phi[i] = i;
for (int i = 2; i < n; i++) {
if (phi[i] == i) {
for (int j = i; j < n; j += i) {
phi[j] /= i;
phi[j] *= i - 1;
}
}
}
}
vector<pair<long long, long long>> factorize_full(long long key) {
vector<pair<long long, long long>> ans;
long i, ct, sq = sqrt(key) + 10;
for (i = 0; (i < top) && (prime[i] <= sq); i++)
if (key % prime[i] == 0) {
ct = 0;
while (key % prime[i] == 0) {
ct++;
key /= prime[i];
}
ans.push_back({prime[i], ct});
}
if (key > 1) {
ans.push_back({key, 1});
}
return ans;
}
void generate_divisors(int step, int v, vector<pair<int, int>>& fp,
vector<int>& ans) {
if (step < fp.size()) {
generate_divisors(step + 1, v, fp, ans);
for (int i = 1; i <= fp[step].second; i++) {
v *= fp[step].first;
generate_divisors(step + 1, v, fp, ans);
}
} else
ans.push_back(v);
}
void generate_divisors_full(long long step, long long v,
vector<pair<long long, long long>>& fp,
vector<long long>& ans) {
if (step < fp.size()) {
generate_divisors_full(step + 1, v, fp, ans);
for (int i = 1; i <= fp[step].second; i++) {
v *= fp[step].first;
generate_divisors_full(step + 1, v, fp, ans);
}
} else
ans.push_back(v);
}
vector<int> get_divisors(int key) {
unordered_map<int, int> f = factorize(key);
int n = f.size();
vector<pair<int, int>> fp;
for (auto p : f) fp.push_back(p);
vector<int> ans;
generate_divisors(0, 1, fp, ans);
return ans;
}
vector<long long> get_divisors_full(long long key) {
vector<pair<long long, long long>> f = factorize_full(key);
int n = f.size();
vector<pair<long long, long long>> fp;
for (auto p : f) fp.push_back(p);
vector<long long> ans;
generate_divisors_full(0, 1, fp, ans);
return ans;
}
long long get_divisors_count(long long key) {
vector<pair<long long, long long>> f = factorize_full(key);
long long ans = 1;
for (auto p : f) ans *= (p.second + 1);
return ans;
}
};
class UnionFind {
private:
vector<int> p, rank, setSize;
int numSets;
public:
UnionFind(int N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (int i = 0; i < N; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, i, j, k, aa, bb, MAXX = 200010, x, m;
prime_class pr;
vector<vector<int>> d(MAXX);
vector<int> mobius(MAXX);
for (i = 1; i < MAXX; i++) d[i] = pr.get_divisors(i);
for (i = 1; i < MAXX; i++) {
unordered_map<int, int> f = pr.factorize(i);
if (f.size() % 2 == 0)
mobius[i] = 1;
else
mobius[i] = -1;
for (auto p : f) {
if (p.second >= 2) mobius[i] = 0;
}
}
cin >> n;
vector<int> a(n + 1);
vector<vector<int>> plist(MAXX);
for (i = 1; i <= n; i++) {
cin >> a[i];
for (auto p : d[a[i]]) plist[p].push_back(i);
}
vector<vector<int>> adj(n + 1);
for (i = 0; i < n - 1; i++) {
cin >> aa >> bb;
adj[aa].push_back(bb);
}
vector<int> last(n + 1, -1), cid(n + 1, -1);
vector<long long> ans(MAXX, 0), h(MAXX, 0);
for (i = 1; i < MAXX; i++) {
m = plist[i].size();
for (j = 0; j < m; j++) {
int id = plist[i][j];
last[id] = i;
cid[id] = j;
}
UnionFind uf(m);
for (j = 0; j < m; j++) {
int id = plist[i][j];
for (auto v : adj[id]) {
if (last[v] == i) uf.unionSet(j, cid[v]);
}
}
for (j = 0; j < m; j++) {
if (uf.findSet(j) == j) {
x = uf.sizeOfSet(j);
h[i] += x * (x + 1) / 2;
}
}
}
for (i = 1; i < MAXX; i++) {
x = 0;
for (j = i; j < MAXX; j += i) {
++x;
if (mobius[x] == 1)
ans[i] += h[j];
else if (mobius[x] == -1)
ans[i] -= h[j];
}
}
for (i = 1; i < MAXX; i++) {
if (ans[i] > 0) cout << i << " " << ans[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > dp[200100];
int val[200100];
vector<vector<int> > g;
int res;
void ds(int v, int p) {
vector<pair<int, int> > ch;
for (int i = 0; i < g[v].size(); i++) {
if (g[v][i] == p) {
continue;
}
ds(g[v][i], v);
for (int j = 0; j < dp[g[v][i]].size(); j++) {
ch.push_back(dp[g[v][i]][j]);
}
}
sort(ch.begin(), ch.end());
for (int i = 0; i < ch.size(); i++) {
int j = i - 1;
int ma = 0, mb = 0;
while (ch[j + 1].first == ch[i].first && j + 1 < ch.size()) {
j++;
int va = ch[j].second;
if (va >= ma) {
mb = ma;
ma = va;
} else if (va > mb) {
mb = va;
}
}
if (val[v] % ch[j].first == 0) {
res = max(res, ma + mb + 1);
dp[v].push_back(pair<int, int>(ch[i].first, ma + 1));
while (val[v] % ch[i].first == 0) {
val[v] /= ch[i].first;
}
} else {
res = max(res, ma);
}
i = j;
}
for (int i = 2; i * i <= val[v]; i++)
if (!(val[v] % i)) {
dp[v].push_back(pair<int, int>(i, 1));
res = max(res, 1);
while (!(val[v] % i)) {
val[v] /= i;
}
}
if (val[v] > 1) {
dp[v].push_back(pair<int, int>(val[v], 1));
res = max(res, 1);
}
}
int main() {
scanf("%d ", &n);
for (int i = 0; i < n; i++) {
int t;
scanf("%d ", &t);
val[i] = t;
}
g.assign(n, vector<int>());
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d %d ", &a, &b);
a--;
b--;
g[b].push_back(a);
g[a].push_back(b);
}
res = 0;
ds(0, -1);
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long inf = 1e9 + 7;
const long N = 2e5 + 5;
long A[N], n, k, vis[N], c;
vector<long> adj[N], v[N];
long long dp[N];
void dfs(long id, long p, long num) {
c++;
vis[id] = num;
for (auto i : adj[id])
if (i != p && A[i] % num == 0) dfs(i, id, num);
}
void solve() {
long i, j, x = 0, y = 1, m, a, b;
cin >> n;
for (i = 1; i < n + 1; i++) {
cin >> A[i];
for (j = 1; j * j < A[i]; j++) {
if (A[i] % j == 0) {
v[j].emplace_back(i);
v[A[i] / j].emplace_back(i);
}
}
if (j * j == A[i]) v[j].emplace_back(i);
}
for (i = 1; i < n; i++) {
cin >> a >> b;
adj[a].emplace_back(b);
adj[b].emplace_back(a);
}
for (i = 1; i < N; i++) {
for (j = 0; j < (long)v[i].size(); j++) {
c = 0;
if (vis[v[i][j]] != i) dfs(v[i][j], 0, i);
dp[i] += 1LL * c * (c + 1) / 2;
}
}
for (i = N - 1; i > 0; i--)
for (j = i + i; j < N; j += i) dp[i] -= dp[j];
for (i = 1; i < N; i++)
if (dp[i]) cout << i << " " << dp[i] << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long t = 1, i;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, mx = 0;
int res = 0;
int a[200001];
vector<int> tree[200001];
vector<int> prime;
vector<int> app[200001];
int dv[200001];
int o[200001];
int mdown[200001];
vector<int> mults[200001];
int DFS(int v, int p, int it) {
o[v] = it;
int m1 = 0, m2 = 0, l = 0, d;
for (size_t i = 0; i < tree[v].size(); i++) {
if (o[tree[v][i]] != it && a[tree[v][i]] % p == 0) {
l = max(l, DFS(tree[v][i], p, it));
d = mdown[tree[v][i]];
if (d > m1) {
m2 = m1;
m1 = d;
} else if (d > m2)
m2 = d;
}
}
mdown[v] = 1 + m1;
return max(l, 1 + m1 + m2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
app[a[i]].push_back(i);
mx = max(mx, a[i]);
}
int x, y;
for (int i = 0; i < n - 1; i++) {
cin >> x >> y;
tree[x].push_back(y);
tree[y].push_back(x);
}
for (int i = 2; i * i <= mx; i++) {
if (!dv[i]) {
for (int j = i * i; j <= mx; j += i) {
dv[j] = i;
}
}
}
for (int i = 2; i <= mx; i++) {
if (!dv[i]) {
prime.push_back(i);
}
}
for (int i = 2; i <= mx; i++) {
int a1 = i;
while (dv[a1] > 0) {
if (!mults[dv[a1]].size() || mults[dv[a1]].back() != i) {
mults[dv[a1]].push_back(i);
}
a1 /= dv[a1];
}
if (a1 > 1 && (!mults[a1].size() || mults[a1].back() != i)) {
mults[a1].push_back(i);
}
}
for (int i = 0; i < (int)prime.size(); i++) {
for (int j = 0; j < (int)mults[prime[i]].size(); j++) {
int j2 = mults[prime[i]][j];
for (int k = 0; k < (int)app[j2].size(); k++) {
if (o[app[j2][k]] != i + 1) {
res = max(res, DFS(app[j2][k], prime[i], i + 1));
}
}
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int mod = 998244353;
using namespace std;
template <typename T1, typename T2>
void ckmin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
void ckmax(T1 &a, T2 b) {
if (a < b) a = b;
}
template <typename T1, typename T2>
void addmo(T1 &a, T2 b) {
a += b;
if (a >= mod) a -= mod;
}
int n, a[maxn], vis[maxn], sz[maxn], mx[maxn], mi, o, ans, mx1, mx2, mxx;
vector<int> g[maxn];
void dfs_size(int x, int pre) {
sz[x] = 1, mx[x] = 0;
for (int i : g[x])
if (!vis[i] && pre ^ i)
dfs_size(i, x), sz[x] += sz[i], mx[x] = max(mx[x], sz[i]);
}
void dfs_findG(int r, int x, int pre) {
if (sz[r] - sz[x] > mx[x]) mx[x] = sz[r] - sz[x];
if (mx[x] < mi) mi = mx[x], o = x;
for (int i : g[x])
if (i ^ pre && !vis[i]) dfs_findG(r, i, x);
}
void dfs_dis(int x, int pre, int dep, int val) {
ckmax(mxx, dep);
for (int i : g[x])
if (!vis[i] && i ^ pre && a[i] % val == 0) dfs_dis(i, x, dep + 1, val);
}
void cal(int x, int val) {
mx1 = 0, mx2 = 0;
for (int i : g[x]) {
if (!vis[i] && a[i] % val == 0) {
mxx = 0;
dfs_dis(i, x, 1, val);
if (mx1 < mxx)
mx2 = mx1, mx1 = mxx;
else if (mx2 < mxx)
mx2 = mxx;
}
}
ckmax(ans, mx1 + mx2 + 1);
}
void dfs(int x) {
mi = 0x3f3f3f3f;
dfs_size(x, 0);
dfs_findG(x, x, 0);
vis[o] = 1;
int rt = o, val = a[o];
for (int i = 2; i * i <= val; i++) {
if (val % i == 0) {
cal(o, i);
while (val % i == 0) val /= i;
}
}
if (val > 1) cal(o, val);
for (int i : g[rt])
if (!vis[i]) dfs(i);
}
void solve() {
int f = 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), f &= a[i] == 1;
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y), g[y].push_back(x);
}
dfs(1);
printf("%d", ans);
}
signed main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
x *= f;
}
struct edge {
int to, v, next;
} e[400005];
int n, m, p, val[200005], head[200005], cnt, siz[200005], son[200005],
st[200005], top, root, maxson, vis[200005], dis[200005];
long long tot[200005], ma[200005];
void add(int a, int b) {
e[cnt].to = b;
e[cnt].next = head[a];
head[a] = cnt++;
}
void getroot(int u, int pre) {
siz[u] = 1;
son[u] = 0;
for (register int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre || vis[e[i].to]) continue;
getroot(e[i].to, u);
siz[u] += siz[e[i].to];
son[u] = max(son[u], siz[e[i].to]);
}
son[u] = max(son[u], maxson - siz[u]);
if (son[u] < son[root]) root = u;
}
int gcd(int a, int b) {
if (a % b == 0) return b;
return gcd(b, a % b);
}
void getans(int u, int pre) {
dis[u] = gcd(dis[pre], val[u]);
for (register int i = 1; i <= top; ++i) {
tot[gcd(dis[u], st[i])] += ma[st[i]];
}
for (register int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre || vis[e[i].to]) continue;
getans(e[i].to, u);
}
}
void getdis(int u, int pre) {
if (!ma[dis[u]]) {
st[++top] = dis[u];
}
ma[dis[u]]++;
for (register int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre || vis[e[i].to]) continue;
getdis(e[i].to, u);
}
}
void calc(int u) {
tot[val[u]]++;
top = 1;
dis[u] = val[u];
ma[val[u]] = 1;
st[1] = val[u];
for (register int i = head[u]; i; i = e[i].next) {
if (vis[e[i].to]) continue;
getans(e[i].to, u);
getdis(e[i].to, u);
}
for (register int i = 1; i <= top; ++i) {
ma[st[i]] = 0;
}
}
void dfs(int u) {
calc(u);
vis[u] = 1;
for (register int i = head[u]; i; i = e[i].next) {
if (vis[e[i].to]) continue;
root = 0;
maxson = siz[e[i].to];
getroot(e[i].to, u);
dfs(root);
}
}
int main() {
read(n);
cnt = 1;
for (register int i = 1; i <= n; ++i) read(val[i]);
int a, b;
for (register int i = 1; i < n; ++i) {
read(a);
read(b);
add(a, b);
add(b, a);
}
maxson = siz[0] = son[0] = n;
root = 0;
getroot(1, 0);
dfs(root);
for (register int i = 1; i <= 200000; ++i) {
if (tot[i]) printf("%d %lld\n", i, tot[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mx = 200000;
vector<long long> val[mx + 1];
vector<pair<long long, long long>> tr[mx + 1];
long long gcd(long long a, long long b) {
while (b) tie(a, b) = make_tuple(b, a % b);
return a;
}
template <typename t>
class DisjointSet {
public:
vector<t> dsu, SIZE;
DisjointSet(t n) {
dsu.resize(n + 1);
SIZE.assign(n + 1, 1);
iota(dsu.begin(), dsu.end(), 0);
}
t root(t a) { return dsu[a] == a ? a : dsu[a] = root(dsu[a]); }
void join(t a, t b, t &res) {
a = root(a);
b = root(b);
if (a == b) return;
res -= (SIZE[a] * (SIZE[a] + 1) >> 1);
res -= (SIZE[b] * (SIZE[b] + 1) >> 1);
if (SIZE[a] < SIZE[b])
dsu[a] = b, SIZE[b] += SIZE[a], res += (SIZE[b] * (SIZE[b] + 1) >> 1);
else
dsu[b] = a, SIZE[a] += SIZE[b], res += (SIZE[a] * (SIZE[a] + 1) >> 1);
}
};
void solve() {
long long n, x, y;
cin >> n;
long long a[n + 1], res[mx + 1];
memset(res, 0, sizeof res);
DisjointSet<long long> tree(n);
for (long long i = 1; i <= n; i++) cin >> a[i], val[a[i]].push_back(i);
for (long long i = 1; i < n; i++)
cin >> x >> y, tr[(gcd(a[x], a[y]))].push_back({x, y});
for (long long i = mx; i > 0; i--) {
res[i] = 0;
for (long long j = i; j <= mx; j += i) {
res[i] -= res[j];
res[i] += val[j].size();
for (auto &k : val[j]) tree.dsu[k] = k, tree.SIZE[k] = 1;
}
for (long long j = i; j <= mx; j += i)
for (auto &k : tr[j]) tree.join(k.first, k.second, res[i]);
}
for (long long i = 1; i <= mx; i++)
if (res[i] > 0) cout << i << " " << res[i] << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t(1);
for (long long i = 1; i <= t; solve(), i++)
;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Fread {
const long long 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 long long read() {
long long x(0), neg(1);
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch - '0');
ch = getchar();
}
return x * neg;
}
const long long MAXN = 2e5;
vector<long long> pri[MAXN + 5];
vector<long long> g[MAXN + 5];
long long dp[MAXN + 5][10];
long long ans;
inline void dfs(long long u, long long fa) {
for (long long i = 0; i < g[u].size(); ++i) {
long long v(g[u][i]);
if (v == fa) continue;
dfs(v, u);
for (long long j = 0; j < pri[u].size(); ++j) {
for (long long k = 0; k < pri[v].size(); ++k) {
if (pri[u][j] != pri[v][k]) continue;
ans = max(ans, dp[u][j] + dp[v][k] + 1);
dp[u][j] = max(dp[u][j], dp[v][k] + 1);
}
}
}
}
long long num[MAXN + 5];
long long p[MAXN + 5], prime[MAXN + 5];
long long cnt;
inline void PRIME(long long x) {
memset(prime, 1, sizeof(prime));
prime[0] = prime[1] = 0;
for (long long i = 2; i <= x; ++i) {
if (prime[i]) p[++cnt] = i;
for (long long j = 1; j <= cnt && p[j] * i <= x; ++j) {
prime[p[j] * i] = 0;
if (i % p[j] == 0) break;
}
}
}
signed main() {
long long n = read();
long long flag = 1;
for (long long i = 1; i <= n; ++i) {
num[i] = read();
if (num[i] != 1) flag = 0;
}
if (flag) {
puts("0");
return 0;
}
for (long long i = 1; i < n; ++i) {
long long u(read()), v(read());
g[u].push_back(v), g[v].push_back(u);
}
PRIME(200000);
for (long long i = 1; i <= n; ++i) {
long long tmp = num[i];
for (long long j = 1; p[j] * p[j] <= tmp; ++j) {
if (tmp <= 1) break;
if (tmp % p[j] == 0) {
pri[i].push_back(p[j]);
while (tmp % p[j] == 0) {
tmp /= p[j];
}
}
}
if (tmp != 1) pri[i].push_back(tmp);
}
dfs(1, 0);
printf("%lld\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> v[maxn], g[maxn];
int a[maxn], dv[maxn], fd, fr;
bool vis[maxn];
void dfs(int x, int y, int p, int d) {
vis[x] = true;
if (d > fd) {
fd = d;
fr = x;
}
for (const int &u : g[x]) {
if (u == p) continue;
if (a[u] % y) continue;
dfs(u, y, x, d + 1);
}
}
void sieve() {
vector<int> p;
for (int i = 2; i < maxn; ++i) {
if (!dv[i]) dv[i] = i, p.push_back(i);
for (int j = 0; i * p[j] < maxn; ++j) {
dv[i * p[j]] = p[j];
if (i % p[j] == 0) break;
}
}
}
vector<int> fact(int x) {
vector<int> res;
for (int y = x; y < maxn; y += x) {
for (int i = 0; i < (int)v[y].size(); ++i) res.push_back(v[y][i]);
}
return res;
}
int main() {
sieve();
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
v[a[i]].push_back(i);
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d%d", &x, &y);
--x, --y;
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 2; i < maxn; ++i) {
if (dv[i] != i) continue;
vector<int> p = fact(i);
for (int j = 0; j < (int)p.size(); ++j) {
int x = p[j];
if (vis[x]) continue;
fd = fr = -1;
dfs(x, i, -1, 1);
fd = -1;
dfs(fr, i, -1, 1);
ans = max(ans, fd);
}
for (int j = 0; j < (int)p.size(); ++j) {
int x = p[j];
vis[x] = false;
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], ans;
vector<int> g[200005], t[200005];
map<int, int> dp[200005], mx[200005], mx2[200005];
map<int, int>::iterator it;
void dfs(int node, int par) {
for (int i = 0; i < g[node].size(); i++) {
if (g[node][i] == par) continue;
dfs(g[node][i], node);
}
for (int i = 0; i < t[a[node]].size(); i++) dp[node][t[a[node]][i]] = 1;
for (int i = 0; i < g[node].size(); i++) {
if (g[node][i] == par) continue;
for (it = dp[g[node][i]].begin(); it != dp[g[node][i]].end(); it++) {
if (a[node] % it->first == 0) {
dp[node][it->first] = max(dp[node][it->first], it->second + 1);
mx2[node][it->first] = max(mx2[node][it->first], it->second);
if (mx2[node][it->first] > mx[node][it->first])
swap(mx2[node][it->first], mx[node][it->first]);
ans = max(ans, mx[node][it->first] + mx2[node][it->first] + 1);
} else {
ans = max(ans, it->second);
}
}
dp[g[node][i]].clear();
}
}
int main() {
for (int i = 2; i < 200005; i++)
if (t[i].empty())
for (int j = i; j < 200005; j += i) t[j].push_back(i);
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
if (n == 1) {
printf("%d\n", a[1] > 1);
return 0;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int rf() {
int r;
int s = 0, c;
for (; !isdigit(c = getchar()); s = c)
;
for (r = c ^ 48; isdigit(c = getchar()); (r *= 10) += c ^ 48)
;
return s ^ 45 ? r : -r;
}
vector<int> e[200000 + 5], pr[200000 + 5], ver[200000 + 5];
bool book[200000 + 5];
int a[200000 + 5], fa[200000 + 5], n, m, D, V, ans;
void Far(int p, int fa, int t) {
book[p] = false;
D < t ? D = t, V = p : 0;
for (auto v : e[p])
if (v ^ fa) Far(v, p, t + 1);
}
void DFS(int p) {
for (auto v : e[p])
if (v ^ fa[p]) fa[v] = p, DFS(v);
}
int main() {
n = rf();
generate(a + 1, a + n + 1, rf);
m = *max_element(a + 1, a + n + 1);
for (register int i = 2, j; i <= m; i++)
if (!book[i])
for (j = i; j <= m; book[j] = true, pr[j].push_back(i), j += i)
;
for (register int i = 2, u, v; i <= n;
u = rf(), v = rf(), e[u].push_back(v), e[v].push_back(u), i++)
;
for (register int i = 1; i <= n; i++)
for (auto j : pr[a[i]]) ver[j].push_back(i);
DFS(1);
memset(book, 0, m);
for (register int i = 2; i <= m; i++)
if (ver[i].size()) {
for (auto v : ver[i]) book[v] = true, e[v].clear();
for (auto v : ver[i])
if (book[fa[v]]) e[v].push_back(fa[v]), e[fa[v]].push_back(v);
for (auto v : ver[i])
if (book[v])
D = 1, V = v, Far(v, v, 1), Far(V, V, 1), ans = max(ans, D);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MXN = 200005;
ll sol[MXN];
int a[MXN], vis[MXN];
vector<int> adj[MXN];
vector<int> ver[MXN];
int dfs(int x, int d) {
if (vis[x] == d) return 0;
vis[x] = d;
int ret = 1;
for (int y : adj[x]) {
if (a[y] % d) continue;
if (vis[y] == d) continue;
ret += dfs(y, d);
}
return ret;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
ver[a[i]].push_back(i);
}
for (int i = 2; i <= n; ++i) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 200000; i >= 1; --i) {
for (int j = i; j <= 200000; j += i) {
sol[i] -= sol[j];
for (int x : ver[j]) {
int sz = dfs(x, i);
sol[i] += 1LL * sz * (sz + 1) / 2;
}
}
}
for (int i = 1; i <= 200000; ++i) {
if (sol[i]) cout << i << ' ' << sol[i] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200050;
vector<int> E[N];
int p[N], sz[N];
long long ans;
long long fir(int x) { return (long long)x * (x - 1) / 2; }
int Find(int x) { return p[x] == x ? x : p[x] = Find(p[x]); }
void Union(int x, int y) {
x = Find(x);
y = Find(y);
ans -= fir(sz[x]);
ans -= fir(sz[y]);
p[y] = x;
sz[x] += sz[y];
ans += fir(sz[x]);
}
vector<pair<int, int> > edges[N];
int a[N];
long long sol[N];
int gcd(int x, int y) { return x ? gcd(y % x, x) : y; }
int main() {
int n, i, j, k, u, v;
scanf("%i", &n);
for (i = 1; i <= n; i++) scanf("%i", &a[i]);
for (i = 1; i < n; i++) {
scanf("%i %i", &u, &v);
edges[gcd(a[u], a[v])].push_back(make_pair(u, v));
}
for (i = 1; i < N; i++) {
for (j = i; j < N; j += i) {
for (k = 0; k < edges[j].size(); k++) {
p[edges[j][k].first] = edges[j][k].first;
p[edges[j][k].second] = edges[j][k].second;
sz[edges[j][k].first] = 1;
sz[edges[j][k].second] = 1;
}
}
ans = 0;
for (j = i; j < N; j += i) {
for (k = 0; k < edges[j].size(); k++) {
Union(edges[j][k].first, edges[j][k].second);
}
}
sol[i] = ans;
}
for (i = 200000; i; i--) {
for (j = i * 2; j <= 200000; j += i) sol[i] -= sol[j];
}
for (i = 1; i <= n; i++) sol[a[i]]++;
for (i = 1; i <= 200000; i++) {
if (sol[i]) printf("%i %lld\n", i, sol[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
const int N = 2e5 + 6;
int arr[N];
vector<int> adj[N], mem[N];
long long dp[N];
int ata[N], sz[N], vis[N];
long long all = 0;
int tap(int x) {
if (ata[x] == x) return x;
return ata[x] = tap(ata[x]);
}
long long f(int x) { return (x * 1LL * (x + 1)) / 2; }
void merge(int x, int y) {
if ((x = tap(x)) == (y = tap(y))) return;
if (sz[x] < sz[y]) swap(x, y);
all -= f(sz[x]);
all -= f(sz[y]);
all += f(sz[x] + sz[y]);
sz[x] += sz[y];
ata[y] = x;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
mem[x].push_back(i);
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
stack<int> st;
for (int i = 1; i <= n; i++) ata[i] = i, sz[i] = 1;
all = 0;
for (int i = N - 4; i >= 1; i--) {
for (int j = i; j < N; j += i) {
if (i < j) dp[i] -= dp[j];
for (__typeof((mem[j]).begin()) it = (mem[j]).begin();
it != (mem[j]).end(); it++) {
int nd = *it;
vis[nd] = 1;
st.push(nd);
all++;
for (int k = 0; k < int(adj[nd].size()); k++) {
int to = adj[nd][k];
if (vis[to]) merge(to, nd);
}
}
}
dp[i] += all;
all = 0;
while (!st.empty()) {
int nd = st.top();
st.pop();
ata[nd] = nd;
sz[nd] = 1;
vis[nd] = 0;
}
}
for (int i = 1; i < N; i++)
if (dp[i]) printf("%d %lld\n", i, dp[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 15;
const int inf = 0x3f3f3f3f;
struct edge {
int v, nxt;
};
int sum[N], maxsum[N], val[N], head[N], tot;
edge e[N << 1];
bool used[N];
inline void init() { memset(head, -1, sizeof(head)); }
inline void addEdge(int u, int v) {
e[tot] = edge{v, head[u]};
head[u] = tot++;
}
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void getRoot(int u, int pre, int size, int& rt) {
sum[u] = 1, maxsum[u] = 0;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v;
if (v == pre || used[v]) {
continue;
}
getRoot(v, u, size, rt);
sum[u] += sum[v];
maxsum[u] = max(maxsum[u], sum[v]);
}
maxsum[u] = max(maxsum[u], size - sum[u]);
if (rt == -1 || maxsum[u] < maxsum[rt]) {
rt = u;
}
}
void getMaxDis(int u, int pre, int d, int k, int& ansd) {
ansd = max(ansd, d);
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v, nk = gcd(k, val[v]);
if (v == pre || used[v] || nk == 1) {
continue;
}
getMaxDis(v, u, d + 1, nk, ansd);
}
}
int dfs(int u) {
int ret = 0;
used[u] = true;
vector<int> vec;
for (int i = head[u]; ~i; i = e[i].nxt) {
int v = e[i].v;
if (used[v]) {
continue;
}
int nk = gcd(val[u], val[v]);
if (nk > 1) {
int ansd = 1;
getMaxDis(v, u, 1, nk, ansd);
vec.push_back(ansd);
}
int rt = -1;
getRoot(v, u, sum[v], rt);
ret = max(ret, dfs(rt));
}
sort(vec.begin(), vec.end(), greater<int>());
vec.emplace_back(0);
vec.emplace_back(0);
ret = max(ret, vec[0] + vec[1] + (val[u] > 1));
return ret;
}
int main() {
int n;
while (~scanf("%d", &n)) {
init();
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
int rt = -1;
getRoot(1, -1, n, rt);
printf("%d\n", dfs(rt));
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200000;
vector<int> divisors[MAX + 3];
void sieve() {
for (int i = 1; i <= MAX; i++) {
for (int j = i; j <= MAX; j += i) {
divisors[j].push_back(i);
}
}
}
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
int a[MAX + 3];
vector<int> edg[MAX + 3];
int bigChild[MAX + 3];
int sbtr[MAX + 3];
void dfs1(int u, int p = 0) {
sbtr[u] = 1;
bigChild[u] = 0;
for (int v : edg[u]) {
if (v == p) continue;
dfs1(v, u);
sbtr[u] += sbtr[v];
if (sbtr[v] > sbtr[bigChild[u]]) bigChild[u] = v;
}
}
long long F[MAX + 3];
long long G[MAX + 3];
long long fr[MAX + 3];
int timer;
int tstate[MAX + 3];
void update(int u, int p, int sgn, int g) {
g = gcd(g, a[u]);
for (int d : divisors[g]) {
if (tstate[d] != timer) {
tstate[d] = timer;
fr[d] = 0;
}
fr[d] += sgn;
}
for (int v : edg[u]) {
if (v == p) continue;
update(v, u, sgn, g);
}
}
void add(int u, int p, int g) {
g = gcd(g, a[u]);
for (int d : divisors[g]) {
G[d] += (tstate[d] == timer) * fr[d];
}
for (int v : edg[u]) {
if (v == p) continue;
add(v, u, g);
}
}
int tin[MAX + 3];
void dfs2(int u, int isBig = 1, int p = 0) {
for (int v : edg[u]) {
if (v == p || bigChild[u] == v) continue;
dfs2(v, 0, u);
}
if (bigChild[u]) dfs2(bigChild[u], 1, u);
timer++;
tin[u] = timer;
for (int d : divisors[a[u]]) {
if (tstate[d] != timer - 1) fr[d] = 0;
tstate[d] = timer;
G[d] += fr[d] + 1;
fr[d]++;
}
for (int v : edg[u]) {
if (v == p || bigChild[u] == v) continue;
add(v, u, a[u]);
update(v, u, 1, a[u]);
}
if (!isBig) {
update(u, p, -1, a[u]);
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
sieve();
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
edg[x].push_back(y);
edg[y].push_back(x);
}
dfs1(1);
dfs2(1);
for (int i = MAX; i > 0; i--) {
F[i] = G[i];
for (int j = i + i; j <= MAX; j += i) F[i] -= F[j];
}
for (int i = 1; i <= MAX; i++) {
if (F[i]) cout << i << " " << F[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Fread {
const long long 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 long long read() {
long long x(0), neg(1);
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch - '0');
ch = getchar();
}
return x * neg;
}
const long long MAXN = 2e5;
bool prime[MAXN + 5];
long long p[MAXN + 5], cnt;
long long a[MAXN + 5];
vector<long long> pr[MAXN + 5];
vector<long long> g[MAXN + 5];
inline void PRIME() {
memset(prime, 1, sizeof(prime));
prime[0] = prime[1] = 0;
for (long long i = 2; i <= MAXN; ++i) {
if (prime[i]) p[++cnt] = i;
for (long long j = 1; j <= cnt && i * p[j] <= MAXN; ++j) {
prime[i * p[j]] = 0;
if (i % p[j] == 0) break;
}
}
}
long long ans;
long long dp[MAXN + 5][25];
inline void dfs(long long u, long long fa) {
for (long long i = 0; i < g[u].size(); ++i) {
long long v = g[u][i];
if (v == fa) continue;
dfs(v, u);
for (long long j = 0; j < pr[u].size(); ++j) {
for (long long k = 0; k < pr[v].size(); ++k) {
long long pri1 = pr[u][j], pri2 = pr[v][k];
if (pri1 != pri2) continue;
ans = max(ans, dp[u][j] + dp[v][k] + 1);
dp[u][j] = max(dp[u][j], dp[v][k] + 1);
}
}
}
}
signed main() {
PRIME();
bool flag = true;
long long n = read();
for (long long i = 1; i <= n; ++i) {
a[i] = read();
if (a[i] != 1) flag = false;
long long tmp = a[i], now = 1;
for (long long j = 1; p[j] * p[j] <= tmp; ++j) {
if (tmp == 0) break;
if (tmp % p[j] == 0) {
pr[i].push_back(p[j]);
while (tmp % p[j] == 0) {
tmp /= p[j];
}
}
}
if (tmp != 1) pr[i].push_back(tmp);
}
if (flag) {
puts("0");
return 0;
}
for (long long i = 1; i < n; ++i) {
long long u(read()), v(read());
g[u].push_back(v), g[v].push_back(u);
}
dfs(1, 0);
printf("%lld\n", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
struct edge {
int u, v;
} E[maxn];
int n, q, m, a[maxn], fa[maxn];
bool vis[maxn];
long long siz[maxn], f[maxn];
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
vector<int> d[maxn], p[maxn], e[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i)
cin >> a[i], fa[i] = i, siz[i] = 1, m = max(a[i], m);
for (int i = 1; i < n; ++i) {
cin >> E[i].u >> E[i].v;
e[E[i].u].push_back(E[i].v);
e[E[i].v].push_back(E[i].u);
}
for (int i = 1; i <= m; ++i)
for (int j = i; j <= m; j += i) d[j].push_back(i);
for (int i = 1; i <= n; ++i)
for (int j = 0; j < d[a[i]].size(); ++j) p[d[a[i]][j]].push_back(i);
int u, v;
for (int i = m; i; --i) {
long long tmp = 0;
for (int j = 0; j < p[i].size(); ++j) vis[p[i][j]] = 1;
for (int j = 0; j < p[i].size(); ++j) {
u = p[i][j];
for (int k = 0; k < e[u].size(); ++k) {
v = e[u][k];
if (!vis[v]) continue;
int fu = getfa(u), fv = getfa(v);
if (fu == fv) continue;
tmp += siz[fu] * siz[fv];
fa[fv] = fu;
siz[fu] += siz[fv];
}
}
f[i] = tmp;
for (int j = i + i; j <= m; j += i) f[i] -= f[j];
for (int j = 0; j < p[i].size(); ++j) {
u = p[i][j];
fa[u] = u;
siz[u] = 1;
for (int k = 0; k < e[u].size(); ++k) {
v = e[u][k];
if (!vis[v]) continue;
fa[v] = v;
siz[v] = 1;
}
}
for (int j = 0; j < p[i].size(); ++j) vis[p[i][j]] = 0;
}
for (int i = 1; i <= n; ++i) ++f[a[i]];
for (int i = 1; i <= 200000; ++i)
if (f[i]) cout << i << ' ' << f[i] << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.