text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long __gcd(long long a, long long b) {
if (b == 0) return a;
return __gcd(b, a % b);
}
vector<vector<int> > adj;
vector<int> a;
vector<map<int, int> > dp;
int ans = 0;
void dfs(int u, int p) {
for (auto x : adj[u]) {
if (x == p) continue;
dfs(x, u);
if (__gcd(a[x], a[u]) != 1) {
for (auto y : dp[x]) {
for (auto z : dp[u]) {
if (__gcd(y.first, z.first) != 1) {
ans = max(ans, y.second + z.second);
}
}
}
}
for (auto it : dp[x]) {
int gcd = __gcd(it.first, a[u]);
if (gcd != 1) {
dp[u][gcd] = max(dp[u][gcd], it.second + 1);
}
}
}
}
int main() {
std ::ios_base ::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
adj.assign(n, vector<int>());
dp.assign(n, map<int, int>());
a.assign(n, 0);
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 1) {
ans = max(ans, 1);
dp[i][a[i]] = 1;
}
}
int x, y;
for (int i = 0; i < n - 1; ++i) {
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0, -1);
for (int i = 0; i < n; ++i) {
for (auto it : dp[i]) {
ans = max(ans, it.second);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 100;
long long x[N], ans[N], used[N], can[N], now[N];
vector<long long> gr[N];
vector<long long> ids[N];
long long sz = 0, k = 0;
void dfs(long long v) {
used[v] = 1;
sz++;
for (long long u : gr[v]) {
if (can[u] && !used[u]) dfs(u);
}
}
void solve() {
long long n;
cin >> n;
for (long long i = (0); i < (n); ++i) {
cin >> x[i];
ids[x[i]].push_back(i);
}
for (long long i = (1); i < (n); ++i) {
long long u, v;
cin >> u >> v;
u--, v--;
gr[u].push_back(v);
gr[v].push_back(u);
}
for (long long i = 1; i < N; ++i) {
long long po = 0;
for (long long j = i; j < N; j += i) {
for (long long k : ids[j]) {
now[po++] = (k);
can[k] = true;
}
}
for (long long kk = (0); kk < (po); ++kk) {
long long k = now[kk];
if (!used[k]) {
sz = 0;
dfs(k);
ans[i] += sz * (sz + 1) / 2;
}
}
for (long long kk = (0); kk < (po); ++kk) {
long long k = now[kk];
used[k] = false;
can[k] = false;
}
}
for (long long i = N - 1; i >= 1; --i) {
for (long long x = 2 * i; x < N; x += i) {
ans[i] -= ans[x];
}
}
for (long long i = (0); i < (N); ++i) {
if (ans[i] != 0) {
cout << i << ' ' << ans[i] << "\n";
}
}
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
vector<int> g1[MAXN], g2[MAXN], p[MAXN];
int vis[MAXN];
int ar[MAXN];
int prime[MAXN];
int dis[MAXN];
int n, ans, kount = 0;
map<int, int> mp;
inline void init() {
prime[1] = 1;
for (long long int i = 2; i < MAXN; i++) {
if (!prime[i]) {
prime[i] = i;
for (long long int j = i * i; j < MAXN; j += i) prime[j] = i;
}
}
}
inline int bfs(int src) {
int ret;
kount++;
queue<int> q;
q.push(src);
vis[src] = kount;
dis[src] = 1;
while (!q.empty()) {
int f = q.front();
mp[f]++;
ret = f;
q.pop();
for (auto it : g2[f]) {
if (vis[it] != kount) {
vis[it] = kount;
dis[it] = dis[f] + 1;
q.push(it);
}
}
}
return ret;
}
inline void sol(int pr) {
for (auto it : p[pr]) {
g2[it].clear();
for (auto jt : g1[it]) {
if (ar[jt] % pr == 0) {
g2[it].push_back(jt);
}
}
}
mp.clear();
for (auto it : p[pr]) {
if (mp.find(it) == mp.end()) {
int src = bfs(it);
src = bfs(src);
ans = max(ans, dis[src]);
}
}
}
int main() {
init();
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &ar[i]);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
g1[x - 1].push_back(y - 1);
g1[y - 1].push_back(x - 1);
}
for (int i = 0; i < n; i++) {
int val = ar[i];
while (val > 1) {
int pr = prime[val];
p[pr].push_back(i);
while (val % pr == 0) val /= pr;
}
}
for (int i = 2; i < MAXN; i++) {
if (prime[i] == i) {
sol(i);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
using min_heap = priority_queue<T, vector<T>, greater<T>>;
const int MAX = 2e5 + 1;
vector<int> mult[MAX], adj[MAX];
bool in[MAX], mark[MAX];
long long ans[MAX];
void dfs(int u, int& sz) {
mark[u] = true;
sz++;
for (int v : adj[u]) {
if (!mark[v] && in[v]) dfs(v, sz);
}
}
template <class F>
void divisors(long long n, F get) {
long long i = 1;
while (i * i < n) {
if (n % i == 0) {
get(i);
get(n / i);
}
i++;
}
if (i * i == n) get(i);
}
char mu[MAX];
bool sieve[MAX];
void mobius(int n) {
memset(mu, char(1), sizeof mu);
memset(sieve, true, sizeof sieve);
for (int i = 2; i <= n; i++) {
if (sieve[i]) {
for (int j = i; j <= n; j += i) {
mu[j] *= -1;
sieve[j] = false;
}
long long sq = (long long)i * i;
for (long long j = sq; j <= n; j += sq) mu[j] = 0;
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
divisors(x, [&](int d) { mult[d].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);
}
for (int d = 1; d < MAX; d++) {
for (int v : mult[d]) in[v] = true;
for (int v : mult[d]) {
int sz = 0;
if (!mark[v]) dfs(v, sz);
ans[d] += (long long)sz * (sz + 1) >> 1;
}
for (int v : mult[d]) {
in[v] = false;
mark[v] = false;
}
}
mobius(MAX);
for (int d = 1; d < MAX; d++) {
long long sum = 0;
for (int m = d, i = 1; m < MAX; m += d, i++) {
sum += mu[i] * ans[m];
}
if (sum > 0) printf("%d %lld\n", d, sum);
}
}
|
#include <bits/stdc++.h>
using namespace std;
double PI = 3.141592653589793;
const double EPS = 1e-8;
const int N = 1e6 + 5;
const long long mod = 1e9 + 7;
const int oo = 1e9;
int dx[] = {0, 0, 1, -1, 1, -1, 1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
int n;
vector<vector<int> > g;
int t[N];
const int MAX = 2 * 1e5 + 5;
bool vis[MAX];
vector<int> d[MAX];
vector<int> v;
bool prime[N];
void generateprime(int n) {
int i;
for (i = 0; i <= n; i++) prime[i] = true;
for (i = 2; i * i <= n; i++)
if (prime[i] == true)
for (int j = i; i * j <= n; j++) prime[i * j] = false;
for (i = 2; i <= n; i++)
if (prime[i]) v.push_back(i);
}
int mx, curr, node;
void dfs(int u, int p, int d, int f) {
if (t[u] % curr != 0) return;
if (d > mx) {
mx = d;
node = u;
}
vis[u] = f;
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] != p) {
dfs(g[u][i], u, d + 1, f);
}
}
}
int main() {
scanf("%d", &n);
g.resize(n + 1);
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
for (int i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
generateprime(MAX);
for (int i = 1; i <= n; i++) {
if (prime[t[i]]) d[t[i]].push_back(i);
for (int j = 0; j <= v.size(); j++) {
if (v[j] * v[j] > t[i]) break;
if (t[i] % v[j] == 0) d[v[j]].push_back(i);
}
}
int ans = 0;
for (int i = 0; i < v.size(); i++) {
curr = v[i];
for (int j = 0; j < d[v[i]].size(); j++) {
int u = d[v[i]][j];
if (vis[u]) continue;
mx = -1;
dfs(u, -1, 1, 0);
mx = -1;
dfs(node, -1, 1, 1);
ans = max(ans, mx);
}
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
vector<int> ans[N];
int v[N], t[N], nl[N], sf[N], ant[N], vf[N], nc(0);
long long ras[N];
void adauga(int x, int y) {
vf[++nc] = y;
ant[nc] = sf[x];
sf[x] = nc;
}
int radacina(int nod) {
if (t[nod] == 0) {
return nod;
}
t[nod] = radacina(t[nod]);
return t[nod];
}
void reuniune(int x, int y) {
int rx(radacina(x)), ry(radacina(y));
if (rx == ry) {
return;
}
if (nl[rx] < nl[ry]) {
t[rx] = ry;
nl[ry] += nl[rx];
} else {
t[ry] = rx;
nl[rx] += nl[ry];
}
}
int main() {
int n, x, y, nod;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> v[i];
int a(1);
while (a * a < v[i]) {
if (v[i] % a == 0) {
ans[a].push_back(i);
ans[v[i] / a].push_back(i);
}
++a;
}
if (v[i] == a * a) {
ans[a].push_back(i);
}
}
for (int i = 1; i < n; ++i) {
cin >> x >> y;
if (x > y) {
swap(x, y);
}
adauga(x, y);
}
for (int val = 1; val < N; ++val) {
for (int i = 0; i < ans[val].size(); ++i) {
nod = ans[val][i];
nl[nod] = 1;
t[nod] = 0;
}
for (int i = 0; i < ans[val].size(); ++i) {
nod = ans[val][i];
for (int nodc = sf[nod]; nodc; nodc = ant[nodc]) {
int adj = vf[nodc];
if (v[adj] % val == 0) {
reuniune(nod, adj);
}
}
}
for (int i = 0; i < ans[val].size(); ++i) {
nod = ans[val][i];
if (t[nod] == 0) {
ras[val] += 1LL * nl[nod] * (nl[nod] + 1) / 2;
}
}
}
for (int i = N - 1; i >= 1; --i) {
for (int j = i + i; j < N; j += i) {
ras[i] -= ras[j];
}
}
for (int i = 1; i < N; ++i) {
if (ras[i] != 0) {
cout << i << " " << ras[i] << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void zeta(vector<T>& f) {
for (int n = f.size(), i = n - 1; i >= 1; i--)
for (int j = i; (j += i) < n;) f[j] += f[i];
}
template <typename T>
inline void mobius(vector<T>& F) {
for (int n = F.size(), i = 1; i < n; i++)
for (int j = i; (j += i) < n;) F[j] -= F[i];
}
template <typename T>
inline void zeta_p(vector<T>& f) {
for (int n = f.size(), i = 1; i < n; i++)
for (int j = i; (j += i) < n;) f[i] += f[j];
}
template <typename T>
inline void mobius_p(vector<T>& F) {
for (int n = F.size(), i = n - 1; i >= 1; i--)
for (int j = i; (j += i) < n;) F[i] -= F[j];
}
const int N = 2e5 + 10;
vector<int> ds[N];
void prep() {
for (int i = 1; i < N; i++) {
for (int j = i; j < N; j += i) {
ds[j].push_back(i);
}
}
}
using ll = long long;
void solve() {
prep();
int n;
cin >> n;
vector<int> a(n);
for (auto& x : a) {
cin >> x;
}
vector<vector<int>> g(n);
for (int _ = 1; _ < n; _++) {
int x, y;
cin >> x >> y;
x--;
y--;
g[x].push_back(y);
g[y].push_back(x);
}
vector<vector<int>> cnt(n);
vector<ll> F(N);
vector<int> dp(N);
function<void(int, int)> dfs = [&](int u, int p) {
for (int v : g[u])
if (v != p) dfs(v, u);
for (int d : ds[a[u]]) dp[d] = 1;
for (int v : g[u])
if (v != p) {
for (int _ = 0; _ < cnt[v].size(); _++) {
int d = ds[a[v]][_];
if (a[u] % d == 0) {
F[d] += 1ll * dp[d] * cnt[v][_];
dp[d] += cnt[v][_];
}
}
}
for (int d : ds[a[u]]) {
cnt[u].push_back(dp[d]);
dp[d] = 0;
}
};
dfs(0, -1);
mobius_p(F);
for (auto& x : a) {
F[x]++;
}
for (int i = 1; i <= 200000; i++) {
if (F[i]) {
cout << i << ' ' << F[i] << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int LIM = 200010;
int a[LIM], father[LIM], fa[LIM];
long long size[LIM];
vector<int> lis[LIM], E[LIM];
long long res[LIM];
int find(int x) { return (x == father[x] ? 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) {
res[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]);
res[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) res[i] -= res[j];
for (int i = 1; i <= 200000; ++i)
if (res[i]) printf("%d %I64d\n", i, res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int N = 2e5 + 10;
int power(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = 1LL * res * a % mod;
}
a = 1LL * a * a % mod;
b >>= 1;
}
return res;
}
int res = 0, val[N];
vector<int> best[N], d[N], adj[N];
void dfs(int node = 1, int par = 0) {
for (int i = 0; i < d[val[node]].size(); i++) {
best[node].push_back(1);
res = max(res, 1);
}
for (int child : adj[node]) {
if (child == par) continue;
dfs(child, node);
for (int i = 0; i < d[val[child]].size(); i++) {
int dd = d[val[child]][i];
auto it = lower_bound(d[val[node]].begin(), d[val[node]].end(), dd);
if (it != d[val[node]].end()) {
int idx = it - d[val[node]].begin();
if (d[val[node]][idx] == dd) {
res = max(res, best[node][idx] + best[child][i]);
best[node][idx] = max(best[node][idx], 1 + best[child][i]);
}
}
}
}
}
int main() {
int n, u, v;
for (int i = 2; i < N; i++) {
for (int j = i; j < N; j += i) {
d[j].push_back(i);
}
}
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &val[i]);
}
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs();
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200100;
using namespace std;
int n, a[N];
vector<int> g[N], fac[N], vec[N];
long long ans[N];
int vis[N];
int bfs(int u) {
vis[u] = 2;
int sz = 1;
for (auto& v : g[u]) {
if (vis[v] == 1) sz += bfs(v);
}
return sz;
}
int main() {
for (int i = 1; i <= 200000; ++i) {
for (int j = i; j <= 200000; j += i) {
fac[j].push_back(i);
}
}
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
for (auto& d : fac[a[i]]) {
vec[d].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 = 1; i <= 200000; ++i) {
for (size_t j = 0; j < vec[i].size(); ++j) {
int u = vec[i][j];
vis[u] = 1;
}
for (size_t j = 0; j < vec[i].size(); ++j) {
int u = vec[i][j];
if (vis[u] == 1) {
int cnt = bfs(u);
ans[i] += 1ll * cnt * (cnt + 1) / 2;
}
}
for (size_t j = 0; j < vec[i].size(); ++j) {
int u = vec[i][j];
vis[u] = 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 %lld\n", i, ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct edge {
int nxt, to;
} e[N << 1];
int fa[N], f[N], sz[N], head[N], id[N], lis[N], cnt;
vector<int> v[N];
long long res[N];
inline void add(int x, int y) {
e[++cnt].to = y;
e[cnt].nxt = head[x];
head[x] = cnt;
}
inline void dfs(int x) {
for (int i = head[x]; i; i = e[i].nxt)
if (e[i].to != fa[x]) {
fa[e[i].to] = x;
dfs(e[i].to);
}
}
inline int find(int x) {
if (f[x] == x) return x;
return f[x] = find(f[x]);
}
inline void merge(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (sz[x] < sz[y]) swap(x, y);
f[y] = x;
sz[x] += sz[y];
}
inline int read() {
int x = 0;
char ch = getchar();
while (!isdigit(ch)) ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
int main() {
int n = read(), mn = -1, x, y;
for (int i = 1; i <= n; ++i) x = read(), mn = max(mn, x), v[x].push_back(i);
for (int i = 1; i < n; ++i) {
x = read();
y = read();
add(x, y);
add(y, x);
}
dfs(1);
for (int i = 1; i <= mn; ++i) {
int tot = 0;
for (int j = i; j <= mn; j += i)
for (register int k = 0; k < v[j].size(); ++k)
++tot, lis[tot] = v[j][k], sz[tot] = 1, f[tot] = tot, id[v[j][k]] = tot;
if (!tot) continue;
res[i] = tot;
for (int j = 1; j <= tot; ++j) {
x = lis[j];
y = fa[x];
if (!id[y]) continue;
merge(id[x], id[y]);
}
for (int j = 1; j <= tot; ++j) {
x = find(j);
if (x == j) res[i] += 1ll * sz[j] * (sz[j] - 1) / 2;
}
for (int j = 1; j <= tot; ++j) id[lis[j]] = 0, lis[j] = 0;
}
for (register int i = mn; i >= 1; --i)
for (register int j = i + i; j <= mn; j += i) res[i] -= res[j];
for (register int i = 1; i <= mn; ++i)
if (res[i]) {
printf("%d %lld\n", i, res[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200100;
vector<int> pos[maxn], G[maxn];
int p[maxn], miu[maxn], val[maxn], vis[maxn], a[maxn];
long long f[maxn], g[maxn];
int DFS(int u, const int c) {
if (vis[u] == c || val[a[u]] != c) return 0;
vis[u] = c;
int rnt = 1;
for (auto v : G[u]) rnt += DFS(v, c);
return rnt;
}
int main() {
int n;
scanf("%d", &n);
for (int i = (1); i <= (n); i++) {
scanf("%d", &a[i]);
pos[a[i]].push_back(i);
}
for (int i = (1); i <= (n - 1); i++) {
int x, y;
scanf("%d%d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = (2); i <= (maxn - 1); i++) {
if (!p[i]) p[++p[0]] = i, miu[i] = -1;
for (int j = 1; j <= p[0] && p[j] <= (maxn - 1) / i; j++) {
p[p[j] * i] = true;
if (i % p[j] == 0)
break;
else
miu[p[j] * i] = miu[i] * -1;
}
}
miu[1] = 1;
for (int i = (1); i <= (maxn - 1); i++) {
for (int j = i; j < maxn; j += i) val[j] = i;
for (int j = i; j < maxn; j += i)
for (auto u : pos[j]) {
int t = DFS(u, i);
f[i] += t * (t + 1ll) / 2;
}
}
for (int i = (1); i <= (maxn - 1); i++)
for (int j = 1; j <= (maxn - 1) / i; j++) g[i] += f[i * j] * miu[j];
for (int i = (1); i <= (maxn - 1); i++)
if (g[i]) printf("%d %lld\n", i, g[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, v[200010], x, y, N = 2e5;
long long ans[200010], met[200010], cnt, ile;
vector<long long> tab[200010], t[200010];
void dfs(int w, int d) {
met[w] = -cnt;
ile++;
for (int ver : tab[w]) {
if (met[ver] == cnt) dfs(ver, d);
}
}
int main() {
scanf("%d", &n);
for (int a = 1; a <= n; a++) {
scanf("%d", &v[a]);
t[v[a]].push_back(a);
}
for (int a = 1; a < n; a++) {
scanf("%d %d", &x, &y);
tab[x].push_back(y);
tab[y].push_back(x);
}
for (int a = 1; a <= N; a++) {
++cnt;
for (int b = a; b <= N; b += a) {
for (int w : t[b]) {
met[w] = cnt;
}
}
for (int b = a; b <= N; b += a) {
for (int w : t[b]) {
if (met[w] != -cnt) {
ile = 0;
dfs(w, a);
ans[a] += (ile * (ile - 1) / 2) + ile;
}
}
}
}
for (int a = N; a >= 1; a--) {
for (int b = a + a; b <= N; b += a) ans[a] -= ans[b];
}
for (int a = 1; a <= N; a++) {
if (ans[a]) printf("%d %lld\n", a, ans[a]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const lint linf = 1e18 + 7;
const lint inf = 1e9 + 7;
const int MOD = 1000000007;
int calc(vector<int> const& list, vector<vector<int>> const& edge) {
int res = 1;
set<int> c;
map<int, int> dist, dist2;
for (auto& l : list) {
if (c.find(l) == c.end()) {
queue<int> que;
que.push(l);
dist[l] = 1;
int x = l;
int mx = -1;
while (!que.empty()) {
int buf = que.front();
que.pop();
c.insert(buf);
for (auto& e : edge[buf]) {
if (!binary_search(list.begin(), list.end(), e)) continue;
if (dist.find(e) != dist.end()) continue;
dist[e] = dist[buf] + 1;
que.push(e);
if (dist[e] > mx) {
mx = dist[e];
x = e;
}
}
}
que.push(x);
dist2[x] = 1;
while (!que.empty()) {
int buf = que.front();
que.pop();
for (auto& e : edge[buf]) {
if (!binary_search(list.begin(), list.end(), e)) continue;
if (dist2.find(e) != dist2.end()) continue;
dist2[e] = dist2[buf] + 1;
que.push(e);
if (dist2[e] > mx) {
mx = dist2[e];
x = e;
}
}
}
res = max(res, mx);
}
}
return res;
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
vector<vector<int>> edge(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
cin >> u >> v;
--u;
--v;
edge[u].push_back(v);
edge[v].push_back(u);
}
vector<int> primes;
vector<int> ee(200050, 0);
for (int i = 2; i < 200050; ++i) {
if (ee[i] == 0) {
primes.push_back(i);
for (int j = 1; i * j < 200050; ++j) {
ee[i * j] = 1;
}
}
}
map<int, vector<int>> memo;
for (int i = 0; i < n; ++i) {
int buf = a[i];
for (auto& p : primes) {
if (p * p > a[i]) break;
bool flag = true;
while (buf % p == 0) {
buf /= p;
if (flag) {
flag = false;
memo[p].push_back(i);
}
}
}
if (buf > 1) memo[buf].push_back(i);
}
int res = 0;
for (auto& v : memo) {
if (res >= v.second.size()) continue;
res = max(res, calc(v.second, edge));
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200200;
int a[N];
int W[N];
long long Ans[N];
bool Used[N];
vector<int> Adj[N];
int GCD(int x, int y) { return y ? GCD(y, x % y) : x; }
void CalcSize(int x, int p = 0) {
W[x] = 1;
for (int y : Adj[x])
if (y != p && !Used[y]) CalcSize(y, x), W[x] += W[y];
}
int FindCentroid(const int& TotalSize, int x, int p = 0) {
for (int y : Adj[x])
if (y != p && !Used[y])
if (2 * W[y] > TotalSize) return FindCentroid(TotalSize, y, x);
return Used[x] = true, x;
}
map<int, int> Dp1;
map<int, int> Dp2;
void DFS(int x, int G, int p = 0) {
G = GCD(G, a[x]);
Dp2[G]++;
for (int y : Adj[x])
if (y != p && !Used[y]) DFS(y, G, x);
}
void Solve(int x = 1) {
CalcSize(x);
x = FindCentroid(W[x], x);
Dp1.clear();
Dp2.clear();
Dp1[a[x]]++;
Ans[a[x]]++;
for (int y : Adj[x]) {
if (!Used[y]) {
DFS(y, a[x]);
for (pair<int, int> p1 : Dp1)
for (pair<int, int> p2 : Dp2)
Ans[GCD(p1.first, p2.first)] += (long long)p1.second * p2.second;
for (pair<int, int> p : Dp2) Dp1[p.first] += p.second;
Dp2.clear();
}
}
for (int y : Adj[x])
if (!Used[y]) Solve(y);
}
int main() {
int n;
cin >> n;
for (int x = 1; x <= n; x++) scanf("%d", a + x);
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);
}
Solve();
for (int x = 1; x < N; x++)
if (Ans[x]) printf("%d %I64d\n", x, Ans[x]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
const int P = 2e4 + 1;
int lp[N];
int p[P];
int cur;
int ans;
int n;
struct Graph {
int val[N];
bool vis[N];
vector<int> adj[N];
unordered_map<int, int> pr[N];
} graph;
void sieve() {
for (int i = 2; i < N; ++i) {
if (!lp[i]) {
lp[i] = p[cur++] = i;
}
for (int j = 0; j < cur && p[j] <= lp[i] && p[j] * i < N; ++j) {
lp[p[j] * i] = p[j];
}
}
}
void prime_divisors(int u) {
int k = graph.val[u];
while (k != 1) {
graph.pr[u][lp[k]] = 1;
ans = max(ans, 1);
k /= lp[k];
}
}
void input() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> graph.val[i];
}
for (int i = 1; i < n; ++i) {
int u;
cin >> u;
int v;
cin >> v;
graph.adj[u].push_back(v);
graph.adj[v].push_back(u);
}
}
void dfs(int u) {
graph.vis[u] = 1;
prime_divisors(u);
for (int v : graph.adj[u]) {
if (!graph.vis[v]) {
dfs(v);
for (auto it = graph.pr[u].begin(); it != graph.pr[u].end();
it = next(it)) {
int U = it->second;
int V = graph.pr[v][it->first];
ans = max(ans, U + V);
it->second = max(U, V + 1);
}
}
}
}
void solve() {
dfs(1);
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
sieve();
input();
solve();
}
|
#include <bits/stdc++.h>
const int N = 200100;
const int M = 200000;
using namespace std;
int n, a[N];
vector<int> g[N], fac[N], vec[N];
long long ans[N];
int vis[N];
int dfs(int u) {
vis[u] = 2;
int sz = 1;
for (auto& v : g[u]) {
if (vis[v] == 1) sz += dfs(v);
}
return sz;
}
int main() {
for (int i = 1; i <= M; ++i) {
for (int j = i; j <= M; j += i) {
fac[j].push_back(i);
}
}
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
for (auto& d : fac[a[i]]) {
vec[d].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 = 1; i <= M; ++i) {
for (size_t j = 0; j < vec[i].size(); ++j) {
int u = vec[i][j];
vis[u] = 1;
}
for (size_t j = 0; j < vec[i].size(); ++j) {
int u = vec[i][j];
if (vis[u] == 1) {
int cnt = dfs(u);
ans[i] += 1ll * cnt * (cnt + 1);
}
}
for (size_t j = 0; j < vec[i].size(); ++j) {
int u = vec[i][j];
vis[u] = 0;
}
}
for (int i = M; i >= 1; --i)
for (int j = 2 * i; j <= M; j += i) ans[i] -= ans[j];
for (int i = 1; i <= M; ++i) {
if (ans[i]) printf("%d %lld\n", i, (ans[i] >> 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200010];
long long A[200010];
int Point[200010], Next[400010], To[400010], q;
bool vis[200010];
void Add(int u, int v) {
Next[++q] = Point[u];
Point[u] = q;
To[q] = v;
Next[++q] = Point[v];
Point[v] = q;
To[q] = u;
}
vector<int> v[200010];
int dfs(int u) {
int sum = 1;
vis[u] = 0;
for (int j = Point[u]; j; j = Next[j])
if (vis[To[j]]) sum += dfs(To[j]);
return sum;
}
int main() {
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);
Add(u, v);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j * j <= a[i]; ++j)
if (a[i] % j == 0) {
if (j * j != a[i]) v[a[i] / j].push_back(i);
v[j].push_back(i);
}
for (int i = 1; i <= 200000; ++i) {
for (auto j : v[i]) vis[j] = 1;
for (auto j : v[i])
if (vis[j]) {
int sum = dfs(j);
A[i] += 1ll * sum * (sum - 1) / 2;
A[i] += sum;
}
}
for (int i = 200000; i > 1; --i) {
for (int j = 2; j * j <= i; ++j)
if (i % j == 0) {
if (j * j != i) A[i / j] -= A[i];
A[j] -= A[i];
}
A[1] -= A[i];
}
for (int i = 1; i <= 200000; ++i)
if (A[i]) printf("%d %I64d\n", i, A[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int maxn = 2e5 + 100;
map<int, int> dp1[maxn], dp2[maxn];
vector<int> v[maxn];
vector<int> pri(int x) {
vector<int> tp;
for (int i = 2; i * i <= x; ++i) {
if (x % i == 0) {
tp.push_back(i);
while (x % i == 0) x /= i;
}
}
if (x > 1) tp.push_back(x);
return tp;
}
int vis[maxn], mx, rt, sz[maxn], nowsz;
vector<int> val[maxn];
void getrt(int x, int pre) {
sz[x] = 1;
int sm = 0;
for (auto &u : v[x]) {
if (vis[u] || u == pre) continue;
getrt(u, x);
sz[x] += sz[u];
sm = max(sm, sz[u]);
}
sm = max(sm, nowsz - sz[x]);
if (sm < mx) mx = sm, rt = x;
}
vector<int> dis;
void getdis(int x, int pre, int &ans, int pv, int cnt) {
int flag = 0;
for (auto &u : val[x])
if (u == pv) flag = 1;
if (!flag) return;
ans = max(ans, cnt);
for (auto &u : v[x]) {
if (u == pre || vis[u]) continue;
getdis(u, x, ans, pv, cnt + 1);
}
}
int solve(int x) {
int ret = 0;
for (auto &nw : val[x]) {
vector<int> tp;
for (auto &u : v[x]) {
int ans = 0;
if (vis[u]) continue;
getdis(u, -1, ans, nw, 1);
tp.push_back(ans);
}
sort(tp.begin(), tp.end());
int m1 = 0;
int m2 = 0;
if (tp.size()) m1 = *tp.rbegin();
if (tp.size() > 1) tp.pop_back(), m2 = *tp.rbegin();
ret = max(ret, m1 + m2);
}
return ret;
}
int DV(int x) {
vis[x] = 1;
int ret = solve(x);
for (auto &u : v[x]) {
if (vis[u]) continue;
nowsz = sz[u];
mx = 2e9;
getrt(u, -1);
ret = max(ret, DV(rt));
}
return ret;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int x;
scanf("%d", &x);
val[i] = pri(x);
}
for (int i = 1; i < n; ++i) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
}
nowsz = n;
mx = 2e9;
getrt(1, -1);
int ans = DV(rt);
int flag = 0;
for (int i = 1; i <= n; ++i)
if (val[i].size()) flag = 1;
if (flag) ans++;
printf("%d\n", ans);
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); }
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);
if (x == y) continue;
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 int N = 200100;
struct node {
int to, nxt;
} h[N << 1];
int n, a[N], tot, head[N], fath[N], f[N], sz[N];
long long ans[N];
vector<int> ve[N];
int read() {
int aa = 0, bb = 1;
char cc = getchar();
while (cc > '9' || cc < '0') {
if (cc == '-') bb = -1;
cc = getchar();
}
while (cc >= '0' && cc <= '9') {
aa = (aa << 3) + (aa << 1) + (cc ^ '0');
cc = getchar();
}
return aa * bb;
}
void add(int x, int y) {
h[++tot].to = y;
h[tot].nxt = head[x];
head[x] = tot;
}
void dfs(int x, int fa) {
for (int i = head[x]; i; i = h[i].nxt) {
int y = h[i].to;
if (y == fa) continue;
dfs(y, x);
fath[y] = x;
}
}
int find(int x) {
if (x != f[x]) f[x] = find(f[x]);
return f[x];
}
int main() {
n = read();
for (int i = 1; i <= n; i++) ve[read()].push_back(i);
for (int i = 1, u, v; i < n; i++) {
u = read();
v = read();
add(u, v);
add(v, u);
}
dfs(1, 0);
for (int a = 1; a <= 200000; a++) {
for (int b = a; b <= 200000; b += a)
for (int i = 0; i < ve[b].size(); i++)
f[ve[b][i]] = ve[b][i], sz[ve[b][i]] = 1;
for (int b = a; b <= 200000; b += a) {
ans[a] += ve[b].size();
for (int i = 0; i < ve[b].size(); i++) {
int x = ve[b][i], y = fath[x];
if (!f[y]) continue;
int fx = find(x), fy = find(y);
ans[a] += 1ll * sz[fx] * sz[fy];
f[fx] = fy;
sz[fy] += sz[fx];
}
}
for (int b = a; b <= 200000; b += a)
for (int i = 0; i < ve[b].size(); i++) f[ve[b][i]] = 0, sz[ve[b][i]] = 0;
}
for (int i = 200000; i >= 1; i--)
for (int j = i + i; 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]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <typename T1, typename T2>
bool relax(T1& a, T2 b) {
if (a > b) return 1 * (a = b);
return 0;
}
const int MAX = 2e5 + 7;
int n, ans = 0;
vector<int> a, fact[MAX];
vector<map<int, int>> dp;
vector<list<int>> graph;
void dfs(int v, int parent = -1) {
for (int& i : fact[a[v]]) {
dp[v][i] = 1;
ans = max(ans, dp[v][i]);
}
for (const auto& to : graph[v]) {
if (to == parent) continue;
dfs(to, v);
for (const int& j : fact[a[to]]) {
auto x = dp[v].find(j);
if (x != dp[v].end()) {
int div = (*x).first;
ans = max(ans, dp[v][div] + dp[to][j]);
dp[v][div] = max(dp[v][div], dp[to][j] + 1);
}
}
}
}
void solve() {
cin >> n;
dp.resize(n);
graph.resize(n);
a.resize(n);
for (int i = 2; i < MAX; ++i) {
if (fact[i].size() == 0) {
for (int j = i; j < MAX; j += i) fact[j].push_back(i);
}
}
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;
graph[x].push_back(y);
graph[y].push_back(x);
}
dfs(0);
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long getint() {
long long num = 0, flag = 1;
char c;
while ((c = getchar()) < '0' || c > '9')
if (c == '-') flag = -1;
while (c >= '0' && c <= '9') num = num * 10 + c - 48, c = getchar();
return num * flag;
}
int n, m = 200000;
int a[200005], U[200005], V[200005];
vector<int> D[200005];
long long f[200005];
int pri[200005], mu[200005], np[200005], cnt;
int fa[200005], sz[200005];
inline int gcd(int p, int q) { return q ? gcd(q, p % q) : p; }
inline int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
inline void init() {
mu[1] = 1;
for (int i = 2; i < 200005; i++) {
if (!np[i]) pri[++cnt] = i, mu[i] = -1;
for (int j = 1; j <= cnt && i * pri[j] < 200005; j++) {
np[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
mu[i * pri[j]] = -mu[i];
}
}
}
int main() {
n = getint();
init();
for (int i = 1; i <= n; i++) {
a[i] = getint();
for (int j = 1; j * j <= a[i]; j++)
if (a[i] % j == 0) {
f[j]++;
if (j * j != a[i]) f[a[i] / j]++;
}
}
for (int i = 1; i < n; i++) {
U[i] = getint(), V[i] = getint();
int tmp = gcd(a[U[i]], a[V[i]]);
for (int j = 1; j * j <= tmp; j++)
if (tmp % j == 0) {
D[j].push_back(i);
if (j * j != tmp) D[tmp / j].push_back(i);
}
}
for (int d = 1; d <= m; d++) {
for (int i = 0; i < D[d].size(); i++) {
int u = U[D[d][i]], v = V[D[d][i]];
fa[u] = u, sz[u] = 1, fa[v] = v, sz[v] = 1;
}
for (int i = 0; i < D[d].size(); i++) {
int u = find(U[D[d][i]]), v = find(V[D[d][i]]);
f[d] += 1ll * sz[u] * sz[v];
sz[u] += sz[v], fa[v] = u;
}
}
for (int i = 1; i <= m; i++) {
long long ans = 0;
for (int j = 1; j * i <= m; j++) ans += 1ll * mu[j] * f[i * j];
if (ans) printf("%d %lld\n", i, ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename... Args>
void print(Args... args) {
((cout << args << " "), ...);
}
const int MAXN = 200200;
namespace Task {
int leastPrimeDivisor[MAXN + 1];
vector<int> primes;
void sieve() {
for (int i = 2; i <= MAXN; ++i) {
if (leastPrimeDivisor[i] == 0) {
leastPrimeDivisor[i] = i;
primes.push_back(i);
}
for (int j = 0; j < (int)primes.size() &&
primes[j] <= leastPrimeDivisor[i] && i * primes[j] <= MAXN;
++j)
leastPrimeDivisor[i * primes[j]] = primes[j];
}
}
int n, a[MAXN], mark[MAXN], optimalDiameter = 0;
vector<int> link[MAXN], g[MAXN];
int findDiameter(int i) {
mark[i] = 0;
int diameter = 1;
for (int j : g[i]) {
if (mark[j]) {
int childDiameter = findDiameter(j);
optimalDiameter = max(optimalDiameter, diameter + childDiameter);
diameter = max(diameter, childDiameter + 1);
}
}
return diameter;
}
void solve() {
sieve();
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
int x = a[i];
if (x > 1) {
optimalDiameter = 1;
}
while (x > 1) {
int d = leastPrimeDivisor[x];
while (x % d == 0) x /= d;
link[d].emplace_back(i);
}
}
for (int i = 2; i <= n; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[x].emplace_back(y);
g[y].emplace_back(x);
}
for (int prime : primes) {
if (link[prime].size() <= optimalDiameter) {
continue;
}
for (int i : link[prime]) {
mark[i] = 1;
}
for (int i : link[prime]) {
if (mark[i]) {
findDiameter(i);
}
}
}
printf("%d\n", optimalDiameter);
}
} // namespace Task
int main() {
Task::solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using v2d = vector<vector<T>>;
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
mt19937 rng(chrono::system_clock::now().time_since_epoch().count());
const int maxN = 2e5 + 10;
const int maxS = 2e5 + 10;
int n, a[maxN], num;
vector<int> adj[maxN], vec[maxS];
vector<pair<int, int>> edges[maxS];
long long cnt[maxS], ans[maxS];
bool flag[maxN];
long long GCD(long long a, long long b) { return b == 0 ? a : GCD(b, a % b); }
long long LCM(long long a, long long b) { return a / GCD(a, b) * b; }
void dfs(int u) {
flag[u] = 1;
num++;
for (auto &v : adj[u]) {
if (!flag[v]) {
dfs(v);
}
}
}
void solve() {
cin >> n;
for (int i = 1; i <= (int)(n); ++i) {
cin >> a[i];
vec[a[i]].emplace_back(i);
}
for (int i = 0; i < (int)(n - 1); ++i) {
int u, v;
cin >> u >> v;
int g = GCD(a[u], a[v]);
edges[g].emplace_back(u, v);
}
for (int g = 1; g <= (int)(2e5); ++g) {
for (int d = g; d <= 2e5; d += g) {
for (auto &e : edges[d]) {
int u, v;
tie(u, v) = e;
adj[u].emplace_back(v);
adj[v].emplace_back(u);
}
}
for (int d = g; d <= 2e5; d += g) {
for (auto &u : vec[d]) {
if (!flag[u]) {
num = 0;
dfs(u);
cnt[g] += (long long)num * (num + 1) / 2;
}
}
}
for (int d = g; d <= 2e5; d += g) {
for (auto &u : vec[d]) {
flag[u] = 0;
adj[u].clear();
}
}
}
for (int i = 2e5; i; i--) {
ans[i] = cnt[i];
for (int j = i * 2; j <= 2e5; j += i) {
ans[i] -= ans[j];
}
}
for (int i = 1; i <= (int)(2e5); ++i) {
if (ans[i] > 0) {
cout << i << " " << ans[i] << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
long long mod = 1000000007;
using namespace std;
long long int fast_exp(long long int base, long long int ex) {
long long int res = 1;
while (ex > 0) {
if (ex % 2 == 1) res = (res * base) % mod;
base = (base * base) % mod;
ex /= 2;
}
return res % mod;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int spf[200001];
void sieve() {
spf[1] = 1;
for (int i = 2; i < 200001; i++) spf[i] = i;
for (int i = 4; i < 200001; i += 2) spf[i] = 2;
for (int i = 3; i * i < 200001; i++) {
if (spf[i] == i) {
for (int j = i * i; j < 200001; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
vector<long long> getFactorization(int first) {
vector<long long> ret;
while (first != 1) {
ret.push_back(spf[first]);
first = first / spf[first];
}
return ret;
}
long long n;
long long a[200001];
vector<vector<long long> > adj(200001);
map<long long, long long> ma[200001];
vector<long long> di[200001];
long long ans = 1;
void dfs(long long a, long long p) {
for (auto ch : adj[a]) {
if (ch != p) dfs(ch, a);
}
for (auto nu : di[a]) {
ma[a][nu] = 1;
vector<long long> d;
for (auto ch : adj[a]) {
if (ch == p) continue;
if (ma[ch][nu]) d.push_back(ma[ch][nu]);
}
long long w = d.size();
if (w) {
sort(d.begin(), d.end());
if (w > 1) {
ans = max(ans, 1LL + d[w - 1] + d[w - 2]);
}
ma[a][nu] += d[w - 1];
ans = max(ma[a][nu], ans);
}
}
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
sieve();
long long fl = 0;
for (int i = 0; i < n; i++) {
cin >> a[i + 1];
if (a[i + 1] != 1) fl = 1;
if (a[i + 1] > 1) {
vector<long long> s = getFactorization(a[i + 1]);
di[i + 1].push_back(s[0]);
long long pr = s[0];
for (auto o : s) {
if (o == pr) continue;
di[i + 1].push_back(o);
pr = o;
}
}
}
for (int i = 0; i < n - 1; i++) {
long long first, second;
cin >> first >> second;
adj[first].push_back(second);
adj[second].push_back(first);
}
dfs(1, 0);
if (!fl) ans = 0;
cout << ans << "\n";
return 0;
}
|
#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];
for (auto &k : val[j]) tree.dsu[k] = k, tree.SIZE[k] = 1, res[i]++;
}
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;
const int maxn = 2e5 + 5;
int prime[maxn];
bool is_prime[maxn];
int pp[maxn];
int sieve(int n) {
int p = 0;
for (int i = 0; i <= n; ++i) is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; ++i) {
if (is_prime[i]) {
prime[p++] = i;
for (int j = i + i; j <= n; j += i) is_prime[j] = false;
}
}
return p;
}
int a[maxn];
vector<int> ve[maxn];
bool vis[maxn];
int ans = 0;
int dfs(int x, int p) {
if (a[x] % p != 0) return 0;
int res = 1;
while (a[x] % p == 0) a[x] /= p;
vector<int> temp;
for (auto m : ve[x]) {
if (a[m] % p) continue;
temp.push_back(dfs(m, p));
}
sort(temp.rbegin(), temp.rend());
if (temp.size()) res = res + temp[0];
if (temp.size() > 1)
ans = max(ans, res + temp[1]);
else
ans = max(ans, res);
return res;
}
int main() {
int la = sieve(ceil(sqrt(200000.0)));
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int u, v;
for (int i = 1; i < n; i++) {
scanf("%d %d", &u, &v);
ve[u].push_back(v);
ve[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j < la; j++) {
if (a[i] > 1) {
dfs(i, prime[j]);
}
}
if (a[i] > 1) {
dfs(i, a[i]);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 2e5 + 5;
int n, a[N], ans;
bool prime[N];
vector<int> v[N], d[N];
map<int, int> dp[N];
void dfs(int s, int p) {
int mx1, mx2;
for (auto e : v[s]) {
if (e != p) {
dfs(e, s);
}
}
for (auto t : d[s]) {
dp[s][t] = 1;
mx1 = 0, mx2 = 0;
for (auto e : v[s]) {
if (e != p) {
if (dp[e][t] > mx1) {
mx2 = mx1;
mx1 = dp[e][t];
} else if (dp[e][t] > mx2) {
mx2 = dp[e][t];
}
}
}
dp[s][t] = max(dp[s][t], mx1 + 1);
ans = max(ans, mx1 + mx2 + 1);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
int x = a[i];
int c = 2;
for (int j = 2; j * j <= a[i]; j++) {
if (x % j == 0) d[i].push_back(j);
while (x % j == 0) x /= j;
}
if (x > 1) d[i].push_back(x);
}
for (int i = 1; i <= n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 0);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char s) { return string(1, s); }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto &x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
inline int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline int mul(int a, int b) { return (int)((long long)a * b % MOD); }
inline int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
inline int inv(int a) { return binpow(a, MOD - 2); }
int gcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0, y = 1;
return b;
}
int x1, y1;
int d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
const int N = 2e5 + 5;
long long dp[N], n, a[N], cnt, vis[N];
vector<int> divs[N], g[N], v[N], store;
void dfs(int v, int d) {
vis[v] = 1;
cnt++;
store.push_back(v);
for (int u : g[v])
if (!vis[u] && a[u] % d == 0) dfs(u, d);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i < N; ++i)
for (int j = i; j < N; j += i) divs[j].push_back(i);
for (int i = 1; i <= n; ++i) {
cin >> a[i];
for (int d : divs[a[i]]) v[d].push_back(i);
}
for (int i = 1; i <= n - 1; ++i) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int d = 1; d < N; ++d) {
for (int id : v[d])
if (!vis[id]) {
cnt = 0;
dfs(id, d);
dp[d] += 1ll * cnt * (cnt + 1) / 2;
}
for (int x : store) vis[x] = 0;
store.clear();
}
for (int i = N - 1; i >= 1; --i)
for (int j = 2 * i; j < N; j += i) dp[i] -= dp[j];
for (int i = 1; i < N; ++i)
if (dp[i]) cout << i << " " << dp[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 10;
int n, b[maxn], f[maxn], len, ans;
vector<int> g[maxn], fac[maxn];
map<int, int> dp[maxn];
void init(int n) {
b[0] = b[1] = 1;
for (int i = 2; i <= n; i++) {
if (!b[i]) f[++len] = i;
for (int j = 1; j <= len; j++) {
if (i * f[j] > n) break;
b[i * f[j]] = 1;
if (i % f[j] == 0) break;
}
}
}
void dfs(int u, int fa) {
for (int y : fac[u]) dp[u][y] = max(dp[u][y], 1), ans = max(ans, 1);
for (int x : g[u]) {
if (x == fa) continue;
dfs(x, u);
for (int y : fac[u]) {
ans = max(ans, dp[u][y] + dp[x][y]);
dp[u][y] = max(dp[x][y] + 1, dp[u][y]);
ans = max(ans, dp[u][y]);
}
}
}
int main() {
ios::sync_with_stdio(false);
init(sqrt(2e5));
cin >> n;
for (int i = 1, x; i <= n; i++) {
cin >> x;
for (int j = 1; f[j] * f[j] <= x && j <= len; ++j) {
if (x % f[j] == 0) fac[i].push_back(f[j]);
while (x % f[j] == 0) x /= f[j];
}
if (x > 1) fac[i].push_back(x);
}
for (int i = 1, x, y; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using ll = long long;
using ull = unsigned long long;
using ld = long double;
constexpr ll INF = 2e18;
constexpr ld EPS = 1e-9;
constexpr int MOD = 1000000007;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
template <typename T1, typename T2>
using safe_map = unordered_map<T1, T2, custom_hash>;
template <typename T1, typename T2>
istream &operator>>(istream &istream, pair<T1, T2> &p) {
istream >> p.first >> p.second;
return istream;
}
template <typename T>
istream &operator>>(istream &istream, vector<T> &v) {
for (auto &it : v) cin >> it;
return istream;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &ostream, const pair<T1, T2> &p) {
ostream << p.first << " " << p.second;
return ostream;
}
template <typename T>
ostream &operator<<(ostream &ostream, const vector<T> &c) {
for (auto &it : c) cout << it << " ";
return ostream;
}
template <typename T>
T MIN(T first) {
return first;
}
template <typename T, typename... Args>
T MIN(T first, Args... args) {
return min(first, MIN(args...));
}
template <typename T>
T MAX(T first) {
return first;
}
template <typename T, typename... Args>
T MAX(T first, Args... args) {
return max(first, MAX(args...));
}
template <typename T>
void print(T &&t) {
cout << t << "\n";
}
template <typename T, typename... Args>
void print(T &&t, Args &&...args) {
cout << t << " ";
print(forward<Args>(args)...);
}
template <typename T>
int32_t size_i(T &container) {
return static_cast<int32_t>(container.size());
}
int GCD(int a, int b) {
if (!b) return a;
return GCD(b, a % b);
}
int LCM(int a, int b) { return (a * b) / GCD(a, b); }
int modpow(ll x, int n, int m = MOD) {
ll res = 1;
while (n > 0) {
if (n & 1) res = (res * x) % m;
x = (x * x) % m;
n >>= 1;
}
return res;
}
int binpow(int x, int n) {
int res = 1;
while (n > 0) {
if (n & 1) res = res * x;
x = (x * x);
n >>= 1;
}
return res;
}
int modinv(int x, int m = MOD) { return modpow(x, m - 2, m); }
constexpr int N = 2e5;
int a[N + 1];
int ans[N + 1];
int lps[N + 1];
vector<int> adj[N + 1];
void preSolve() {
lps[0] = lps[1] = 1;
for (ll i = 2; i <= N; i++) {
if (!lps[i]) {
lps[i] = i;
for (ll j = i * i; j <= N; j += i) lps[j] = i;
}
}
}
set<int> getPF(int n) {
set<int> ans;
while (n != 1) {
ans.insert(lps[n]);
n /= lps[n];
}
return ans;
}
safe_map<int, int> dfs(int u, int prev = 0) {
auto pfs = getPF(a[u]);
safe_map<int, int> res;
for (auto x : pfs) res[x] = 1;
safe_map<int, pair<int, int>> best;
for (auto &v : adj[u]) {
if (v == prev) continue;
auto sub = dfs(v, u);
for (auto [p, len] : sub) {
if (res[p]) {
res[p] = max(res[p], 1 + len);
if (len > best[p].first)
best[p] = {len, best[p].first};
else
best[p].second = max(best[p].second, len);
}
}
}
for (auto p : pfs) ans[p] = max(ans[p], best[p].first + best[p].second + 1);
return res;
}
void solve(int tc) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[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);
}
dfs(1);
cout << *max_element(ans, ans + N + 1);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(12) << fixed;
preSolve();
int tests = 1;
for (int t = 1; t <= tests; t++) solve(t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(423978);
const long long mod = 1e9 + 7;
const int mn = 2e5 + 10;
vector<int> g[mn], v[mn];
int a[mn], mu[mn];
bool p[mn];
int pa[mn], s[mn];
int f(int x) { return x == pa[x] ? x : (pa[x] = f(pa[x])); }
void u(int a, int b) {
a = f(a), b = f(b);
if (a == b) return;
if (s[a] < s[b]) swap(a, b);
s[a] += s[b];
pa[b] = a;
}
long long ans[mn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 0; i < n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
fill(p, p + mn, 1);
fill(mu, mu + mn, 1);
for (int i = 2; i < mn; i++)
if (p[i]) {
for (int j = i; j < mn; j += i) {
if (j / i % i == 0)
mu[j] = 0;
else
mu[j] *= -1;
p[j] = 0;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
v[j].push_back(i);
if (j * j != a[i]) v[a[i] / j].push_back(i);
}
}
}
iota(pa, pa + mn, 0);
for (int i = 1; i < mn; i++) {
for (int x : v[i]) s[x] = 1;
for (int x : v[i])
for (int y : g[x])
if (s[f(y)]) u(x, y);
for (int x : v[i]) ans[i] += s[f(x)] + 1;
ans[i] >>= 1;
for (int x : v[i]) s[x] = 0, pa[x] = x;
}
for (int i = 1; i < mn; i++) {
long long pr = 0;
for (int j = 1; j * i < mn; j++) pr += ans[i * j] * mu[j];
if (pr) printf("%d %lld\n", i, pr);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> d[200005 + 10], g[200005 + 10];
int dist, M[200005 + 10], MP[200005 + 10], x, y, val;
void dfs(int x, int m, int dis, int z) {
M[x] = m;
if (dis > dist) {
dist = dis;
val = x;
}
for (auto i : g[x]) {
if (M[i] == m || MP[i] != z) continue;
dfs(i, m, dis + 1, z);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (unsigned long long i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 1; j * j <= x; j++) {
if (x % j == 0) {
d[j].push_back(i + 1);
if (j * j != x) d[x / j].push_back(i + 1);
}
}
}
for (unsigned long long i = 1; i < n; i++) {
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 0;
for (int i = 2; i < 200005 - 1; i++) {
if (ans >= d[i].size()) continue;
for (auto it : d[i]) MP[it] = i;
for (auto it : d[i]) {
dist = 0;
val = 0;
if (M[it] == 2) continue;
dfs(it, 1, 1, i);
dfs(val, 2, 1, i);
ans = max(ans, dist);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 1;
map<int, long long> mp[MAX];
int n, arr[MAX];
vector<vector<int> > adjlist;
long long ans[MAX];
int Gcd(int a, int b) { return (b ? Gcd(b, a % b) : a); }
void dfs(int pos, int parent) {
mp[pos][arr[pos]] = 1;
ans[arr[pos]] += 1;
for (int v : adjlist[pos]) {
if (v != parent) {
dfs(v, pos);
for (auto x : mp[v]) {
for (auto y : mp[pos]) {
ans[Gcd(x.first, y.first)] += 1ll * x.second * y.second;
}
}
for (auto x : mp[v]) {
mp[pos][Gcd(x.first, arr[pos])] += x.second;
}
mp[v].clear();
}
}
}
signed main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
adjlist.resize(n + 1);
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
adjlist[u].push_back(v);
adjlist[v].push_back(u);
}
dfs(1, -1);
for (int i = 1; i <= 200000; i++) {
if (ans[i]) {
cout << i << " " << ans[i] << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int lim = 200 * 1000;
const int nmax = 200005;
vector<pair<int, int> > pp[nmax];
vector<int> ad[nmax], l[nmax];
int viz[nmax], a[nmax];
long long ans[nmax];
long long compo;
int val, d, i, j, n, x, y;
int gcd(int a, int b) {
if (!b) return a;
return gcd(b, a % b);
}
void dfs(int x) {
viz[x] = d;
++compo;
for (int ii = 0; ii < ad[x].size(); ii++)
if (viz[ad[x][ii]] != d) dfs(ad[x][ii]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
l[a[i]].push_back(i);
}
for (i = 1; i <= n - 1; i++) {
cin >> x >> y;
pp[gcd((a[x]), (a[y]))].push_back({x, y});
}
for (d = 1; d <= lim; d++) {
for (val = d; val <= lim; val += d)
for (int i = 0; i < pp[val].size(); i++) {
ad[pp[val][i].first].push_back(pp[val][i].second);
ad[pp[val][i].second].push_back(pp[val][i].first);
}
for (val = d; val <= lim; val += d) {
for (int i = 0; i < l[val].size(); i++) {
if (viz[l[val][i]] != d) {
compo = 0;
dfs(l[val][i]);
ans[d] += 1LL * compo * (compo + 1) / 2;
}
ad[l[val][i]].clear();
}
}
}
for (i = lim; i >= 1; i--)
for (j = 2 * i; j <= lim; j += i) ans[i] -= ans[j];
for (i = 1; i <= lim; i++)
if (ans[i]) cout << i << ' ' << ans[i] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
const int MAXVAL = 200000;
int n;
int val[MAXN];
vector<int> adj[MAXN];
int pmn[MAXVAL + 1];
vector<int> who[MAXVAL + 1];
int mark[MAXN];
int q[MAXN], qhead, qtail;
int d[MAXN];
pair<int, int> farthest(int p, int s) {
qhead = qtail = 0;
d[s] = 0, q[qhead++] = s;
while (qtail < qhead) {
int at = q[qtail++];
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (mark[to] != p || d[to] != -1) continue;
d[to] = d[at] + 1, q[qhead++] = to;
}
}
int u = q[qhead - 1];
pair<int, int> ret = make_pair(u, d[u]);
for (int i = (0); i < (qhead); ++i) {
int at = q[i];
d[at] = -1;
}
return ret;
}
int calc(int p, int s) {
qhead = qtail = 0;
q[qhead++] = s, mark[s] = p;
while (qtail < qhead) {
int at = q[qtail++];
for (int i = (0); i < (((int)(adj[at]).size())); ++i) {
int to = adj[at][i];
if (val[to] % p != 0 || mark[to] == p) continue;
q[qhead++] = to, mark[to] = p;
}
}
int u = farthest(p, s).first;
return farthest(p, u).second + 1;
}
int solve() {
memset(pmn, -1, sizeof(pmn));
for (int i = (2); i <= (MAXVAL); ++i)
if (pmn[i] == -1)
for (int j = i; j <= MAXVAL; j += i)
if (pmn[j] == -1) pmn[j] = i;
for (int i = (0); i <= (MAXVAL); ++i) who[i].clear();
for (int i = (0); i < (n); ++i) {
int x = val[i];
while (x != 1) {
int p = pmn[x];
while (x % p == 0) x /= p;
who[p].push_back(i);
}
}
int ret = 0;
for (int i = (0); i < (n); ++i) mark[i] = -1, d[i] = -1;
for (int p = (0); p <= (MAXVAL); ++p)
if (((int)(who[p]).size()) > 0) {
for (int i = (0); i < (((int)(who[p]).size())); ++i) {
int at = who[p][i];
if (mark[at] == p) continue;
int cur = calc(p, at);
ret = max(ret, cur);
}
}
return ret;
}
void run() {
scanf("%d", &n);
for (int i = (0); i < (n); ++i) scanf("%d", &val[i]);
for (int i = (0); i < (n - 1); ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
adj[a].push_back(b);
adj[b].push_back(a);
}
printf("%d\n", solve());
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double EPS = 1e-9;
const long double PI = acos(-1);
const int N = 2e5 + 5;
const int MOD = 1e9 + 7;
const int INF = 0x3f3f3f3f;
int n, x = 1, vis[N], a[N];
int u[N], sieve[N];
long long h[N], ans[N];
long long cnt;
vector<int> adj[N];
vector<int> nodes[N];
void dfs(int u, int i) {
cnt++;
vis[u] = x;
for (int v : adj[u])
if (a[v] % i == 0 and vis[v] != x) dfs(v, i);
}
int mob(int u) {
int cnt = 0;
while (u > 1) {
int v = u / sieve[u];
if (sieve[v] == sieve[u]) return 0;
u = v;
cnt++;
}
return cnt & 1 ? -1 : 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 1; j * j <= a[i]; j++)
if (a[i] % j == 0) {
nodes[j].push_back(i);
if (j * j != a[i]) nodes[a[i] / j].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);
}
for (int i = 2; i < N; i++)
if (!sieve[i]) {
sieve[i] = i;
for (int j = 2 * i; j < N; j += i) sieve[j] = i;
}
for (int i = 1; i < N; i++) {
u[i] = mob(i);
}
for (int i = 1; i <= 2e5; i++) {
for (int u : nodes[i])
if (vis[u] != x) {
cnt = 0;
dfs(u, i);
h[i] += (cnt * (cnt - 1)) / 2;
}
x++;
}
for (int i = 1; i <= n; i++) ans[a[i]]++;
for (int i = 1; i <= 2e5; i++) {
for (int j = i; j <= 2e5; j += i) {
ans[i] += h[j] * u[j / i];
}
if (ans[i]) printf("%d %lld\n", i, ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
const long long M = 1e7 + 5;
const long long mod = 998244353;
const long long inf = 1e9;
inline long long read() {
long long s = 0;
register bool neg = 0;
register char c = getchar();
for (; c < '0' || c > '9'; c = getchar()) neg |= (c == '-');
for (; c >= '0' && c <= '9'; s = s * 10 + (c ^ 48), c = getchar())
;
s = (neg ? -s : s);
return s;
}
long long a, s[N + 5], prime[N + 5], top, lst[N + 5], now, dp[N + 5], mx[N + 5];
bool vis[N + 5];
vector<long long> st[N + 5], q[N + 5], tmp;
void init() {
for (long long i = (2); i <= (N); ++i) {
if (!vis[i]) prime[++top] = i, lst[i] = i;
for (long long j = 1; i * prime[j] <= N && j <= top; j++) {
vis[i * prime[j]] = 1;
lst[i * prime[j]] = prime[j];
if (i % prime[j] == 0) break;
}
}
}
void dfs(long long n) {
vis[n] = 0;
mx[n] = dp[n] = 0;
for (long long i = (0); i <= (((long long)((st[n]).size())) - 1); ++i) {
long long v = st[n][i];
if (!vis[v]) continue;
dfs(v);
dp[n] = max(dp[n], max(mx[v] + 1 + mx[n], dp[v]));
mx[n] = max(mx[n], mx[v] + 1);
}
}
signed main() {
init();
a = read();
bool t = 0;
for (long long i = (1); i <= (a); ++i) s[i] = read(), t |= (s[i] != 1);
if (!t) {
puts("0");
return 0;
}
long long x, y;
for (long long i = (1); i <= (a - 1); ++i) {
x = read();
y = read();
st[x].push_back(y);
st[y].push_back(x);
}
for (long long i = (1); i <= (a); ++i) {
if (s[i] == 1) continue;
while (1) {
q[lst[s[i]]].push_back(i);
while ((s[i] / lst[s[i]]) % lst[s[i]] == 0) s[i] /= lst[s[i]];
s[i] /= lst[s[i]];
if (s[i] == 1) break;
}
}
memset(vis, 0, sizeof(vis));
long long ans = 0;
for (long long i = (1); i <= (top); ++i) {
now = prime[i];
tmp.clear();
for (long long j = (0); j <= (((long long)((q[now]).size())) - 1); ++j) {
vis[q[now][j]] = 1, tmp.push_back(q[now][j]);
}
for (long long j = (0); j <= (((long long)((tmp).size())) - 1); ++j)
if (vis[tmp[j]]) {
dfs(tmp[j]);
ans = max(ans, dp[tmp[j]]);
}
}
printf("%lld", ans + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int c[200003];
vector<int> adj[200003];
void read() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
}
long long ans[200003];
vector<int> d[200003];
bool marked[200003];
bool used[200003];
long long cnt;
void dfs(int ver) {
cnt++;
used[ver] = true;
for (auto i : adj[ver])
if (marked[i] && !used[i]) dfs(i);
}
void solve() {
for (int i = 1; i <= n; i++)
for (int j = 1; j * j <= c[i]; j++)
if (c[i] % j == 0) {
d[j].push_back(i);
if (j * j != c[i]) d[c[i] / j].push_back(i);
}
for (int i = 1; i <= 200000; i++) {
for (auto j : d[i]) marked[j] = true;
for (auto j : d[i])
if (!used[j]) {
cnt = 0;
dfs(j);
ans[i] += cnt * (cnt + 1) / 2;
}
for (auto j : d[i]) marked[j] = used[j] = false;
}
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]) cout << i << " " << ans[i] << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t, tot, book[200005 * 6], answer = 1, book2[200005 * 6],
book3[200005 * 6], cnt;
vector<int> a[200005];
bool flag = true;
vector<int> e[200005 * 6];
map<pair<int, int>, int> mp;
void dfs(int x) {
book[x] = 1;
int qwertyuiop = e[x].size(), asdfghjkl;
for (int i = 0; i < qwertyuiop; i++) {
asdfghjkl = e[x][i];
if (book[asdfghjkl]) continue;
dfs(asdfghjkl);
}
return;
}
int bfs(int x) {
cnt++;
queue<int> q;
q.push(x);
int cur, zxcvbnm, asdfghjkl;
book2[x] = cnt;
while (!q.empty()) {
cur = q.front();
q.pop();
zxcvbnm = e[cur].size();
for (int i = 0; i < zxcvbnm; i++) {
asdfghjkl = e[cur][i];
if (book2[asdfghjkl] != cnt) {
book2[asdfghjkl] = cnt;
q.push(asdfghjkl);
}
}
if (q.empty()) {
return cur;
}
}
return x;
}
int cheek(int x, int xx) {
queue<pair<int, int> > q;
q.push(make_pair(x, 1));
int zxcvbnm, asdfghjkl;
pair<int, int> cur;
while (!q.empty()) {
cur = q.front();
q.pop();
if (cur.first == xx) {
return cur.second;
}
zxcvbnm = e[cur.first].size();
for (int i = 0; i < zxcvbnm; i++) {
asdfghjkl = e[cur.first][i];
if (book2[asdfghjkl] != x) {
book2[asdfghjkl] = x;
q.push(make_pair(asdfghjkl, cur.second + 1));
}
}
}
return 1;
}
void solve(int x) {
dfs(x);
int asdfghjkl = bfs(x);
int qwertyuiop = bfs(asdfghjkl);
answer = max(answer, cheek(asdfghjkl, qwertyuiop));
return;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t;
if (t != 1) flag = false;
for (int j = 2; j * j <= t; j++) {
if (t % j == 0) {
while (t % j == 0) t /= j;
a[i].push_back(j);
tot++;
mp[make_pair(i, j)] = tot;
}
}
if (t != 1) {
tot++;
mp[make_pair(i, t)] = tot;
a[i].push_back(t);
}
}
for (int i = 1; i < n; i++) {
int x, y, xx, yy, xxx, yyy;
cin >> x >> y;
xx = a[x].size();
yy = a[y].size();
for (int i = 0; i < xx; i++) {
for (int j = 0; j < yy; j++) {
if (a[x][i] != a[y][j]) continue;
xxx = mp[make_pair(x, a[x][i])];
yyy = mp[make_pair(y, a[y][j])];
e[xxx].push_back(yyy);
e[yyy].push_back(xxx);
}
}
}
if (flag) {
cout << 0;
return 0;
}
for (int i = 1; i <= tot; i++) {
if (!book[i]) {
solve(i);
}
}
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int nxt, t;
} e[200010 << 1];
int head[200010], edge_cnt;
void add_edge(int x, int y) {
e[edge_cnt] = (edge){head[x], y};
head[x] = edge_cnt++;
}
int pri[200010], pri_cnt, mu[200010];
bool mark[200010];
void Sieve() {
int i, j;
mu[1] = 1;
for (i = 2; i < 200010; i++) {
if (!mark[i]) {
pri[++pri_cnt] = i;
mu[i] = -1;
}
for (j = 1; j <= pri_cnt; j++) {
int t = i * pri[j];
if (t >= 200010) {
break;
}
mark[t] = 1;
if ((i % pri[j]) == 0) {
mu[t] = 0;
break;
}
mu[t] = -mu[i];
}
}
}
int A[200010];
vector<int> B[200010];
long long sum[200010];
int Q[200010];
bool vis[200010];
long long bfs(int x, int y) {
int i, L = 1, R = 1;
vis[x] = 1;
Q[1] = x;
while (L <= R) {
int x = Q[L++];
for (i = head[x]; ~i; i = e[i].nxt) {
int to = e[i].t;
if (vis[to] || A[to] % y > 0) {
continue;
}
Q[++R] = to;
vis[to] = 1;
}
}
return 1LL * R * (R + 1) / 2;
}
int main() {
Sieve();
memset(head, -1, sizeof(head));
int n, i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &A[i]);
B[A[i]].push_back(i);
}
for (i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add_edge(x, y);
add_edge(y, x);
}
for (i = 1; i <= 200000; i++) {
for (j = i; j <= 200000; j += i) {
for (k = 0; k < (int)B[j].size(); k++) {
if (!vis[B[j][k]]) {
sum[i] += bfs(B[j][k], i);
}
}
}
for (j = i; j <= 200000; j += i) {
for (k = 0; k < (int)B[j].size(); k++) {
vis[B[j][k]] = 0;
}
}
}
for (i = 1; i <= 200000; i++) {
long long Ans = 0;
for (j = i; j <= 200000; j += i) {
Ans += sum[j] * mu[j / i];
}
if (Ans > 0) {
printf("%d %lld\n", i, Ans);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int arr = 1e6 + 100;
const int md = 1e9 + 7;
const int base = 1039;
int mx = 2e5;
long long cnt = 0;
vector<int> vec[300000];
vector<int> todo[300000];
bool ok[300000], use[300000];
void dfs(int &u) {
cnt++;
use[u] = 1;
for (auto &i : vec[u])
if (ok[i] && !use[i]) dfs(i);
}
long long a[300000], ans[300000];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n;
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 == 0) {
todo[j].push_back(i);
if (a[i] / j != j) todo[a[i] / j].push_back(i);
}
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
vec[x].push_back(y);
vec[y].push_back(x);
}
for (int i = 1; i <= mx; i++) {
for (auto j : todo[i]) ok[j] = 1;
for (auto j : todo[i])
if (!use[j]) {
cnt = 0;
dfs(j);
ans[i] += cnt * (cnt + 1) / 2;
}
for (auto j : todo[i]) {
ok[j] = 0;
use[j] = 0;
}
}
vector<pair<int, int> > dell;
for (int i = 1; i <= mx; i++) {
int now = i;
int cnt = 0;
bool ch = 1;
for (int j = 2; j * j <= now; j++) {
if (now % j == 0) {
cnt++;
if (now % (j * j) == 0) ch = 0;
now /= j;
}
}
if (now != 1) cnt++;
if (ch) {
if (cnt % 2 == 0)
dell.push_back({1, i});
else
dell.push_back({-1, i});
}
}
for (int i = 1; i <= mx; i++) {
long long now = 0;
for (auto j : dell) {
if (i * j.second > mx) break;
now += j.first * ans[j.second * i];
}
if (now != 0) cout << i << ' ' << now << '\n';
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int n, dst, ans;
pair<int, int> cur[200005];
vector<int> g[200005];
unordered_set<int> h[200005], z[200005];
bitset<200005> w;
void fact(int x, int y) {
if (!(x & 1)) h[2].insert(y);
while (!(x & 1)) x >>= 1;
for (int i = 3; i * i <= 300000; i += 2) {
if (!(x % i)) h[i].insert(y);
while (!(x % i)) x /= i;
}
if (x > 1) h[x].insert(y);
}
void dfs(int v, int d, int x) {
w[v] = 1;
if (d > cur[x].first) {
cur[x].first = d;
cur[x].second = v;
}
for (auto to : z[v]) {
if (w[to]) continue;
dfs(to, d + 1, x);
}
}
void calc(int v, int p, int end, int d) {
if (v == end) dst = d;
for (auto to : z[v]) {
if (to == p) continue;
calc(to, v, end, d + 1);
}
}
void cleanup(int i) {
for (auto v : h[i]) z[v].clear();
for (int j = 1; j <= (int)h[i].size(); j++) cur[j] = {-1, -1};
w.reset();
}
void rebuild(int i) {
for (auto v : h[i]) {
for (auto to : g[v]) {
if (h[i].find(to) != h[i].end()) z[v].insert(to), z[to].insert(v);
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cout.precision(30);
cerr.precision(7);
;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
fact(x, i);
}
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 2; i <= 200000; i++) {
if (!h[i].size()) continue;
cleanup(i);
rebuild(i);
int comp = 0;
for (auto v : h[i])
if (!w[v]) dfs(v, 0, ++comp);
w.reset();
comp = 0;
for (auto v : h[i]) {
if (!w[v]) {
int start = cur[++comp].second;
cur[comp] = {-1, -1};
dfs(start, 0, comp);
dst = 0;
calc(start, -1, cur[comp].second, 0);
ans = max(ans, dst + 1);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
vector<int> adj[N];
vector<int> a(N, 0);
int dzielniki[N][7];
int res[N][6];
vector<bool> visited(N, false);
void rozloz(int v) {
int n = a[v];
vector<int> ans;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
ans.push_back(i);
while (n % i == 0) n /= i;
}
}
if (n > 1) ans.push_back(n);
for (int i = 0; i < ans.size(); i++) {
dzielniki[v][i] = ans[i];
}
}
void dfs(int v, int p = -1) {
visited[v] = true;
if (adj[v].size() == 1) {
int i = 0;
while (dzielniki[v][i] != -1) {
res[v][i] = 1;
i++;
}
}
for (int i = 0; i < adj[v].size(); i++) {
if (visited[adj[v][i]] == false) dfs(adj[v][i], v);
}
int i = 0;
while (dzielniki[v][i] != -1) {
res[v][i] = 1;
for (int j = 0; j < adj[v].size(); j++) {
int akt = adj[v][j];
if (akt == p) continue;
int k = 0;
while (dzielniki[akt][k] != -1) {
if (dzielniki[akt][k] == dzielniki[v][i])
res[v][i] = max(res[v][i], res[akt][k] + 1);
k++;
}
}
i++;
}
}
int ans = 0;
void dfs2(int v, int p = -1) {
visited[v] = true;
for (int i = 0; i < adj[v].size(); i++) {
if (visited[adj[v][i]] == false) dfs2(adj[v][i], v);
}
int i = 0;
while (dzielniki[v][i] != -1) {
int x = 0, y = 0;
for (int j = 0; j < adj[v].size(); j++) {
int t = adj[v][j];
if (t == p) continue;
int k = 0;
while (dzielniki[t][k] != -1) {
if (dzielniki[t][k] == dzielniki[v][i]) {
x = max(x, res[t][k]);
if (x > y) swap(x, y);
}
k++;
}
ans = max(ans, x + y + 1);
}
ans = max(ans, 1);
i++;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n == 1) {
if (a[1] > 1)
cout << 1;
else
cout << 0;
return 0;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
memset(res, 0, sizeof res);
memset(dzielniki, -1, sizeof dzielniki);
for (int i = 1; i <= n; i++) rozloz(i);
dfs(1);
for (int i = 0; i < N; i++) visited[i] = false;
dfs2(1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300500;
const long long mod = 1e9 + 7;
int a[maxn];
vector<int> adj[maxn];
vector<int> prf[maxn];
void getpr(int x, vector<int> &vr) {
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) vr.push_back(i);
while (x % i == 0) x /= i;
}
if (x > 1) vr.push_back(x);
}
vector<pair<int, int>> dp[maxn];
int ret;
void dfs(int u, int p = -1) {
map<int, vector<int>> ma;
for (int i : prf[a[u]]) ma[i].emplace_back(0);
for (int v : adj[u])
if (v != p) {
dfs(v, u);
for (auto i : dp[v])
if (ma.count(i.first)) ma[i.first].emplace_back(i.second);
}
for (auto &i : ma) {
sort(i.second.begin(), i.second.end());
reverse(i.second.begin(), i.second.end());
if (i.second.size() > 1) {
ret = max(ret, i.second[0] + i.second[1] + 1);
}
dp[u].emplace_back(i.first, i.second[0] + 1);
}
}
int main() {
for (int i = 0; i < (int)(maxn); ++i) getpr(i, prf[i]);
int n;
scanf("%d", &n);
for (int i = (1); i < (int)(n + 1); ++i) scanf("%d", &a[i]);
for (int i = (1); i < (int)(n + 1); ++i)
if (a[i] > 1) ret = 1;
for (int i = 0; i < (int)(n - 1); ++i) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
printf("%d\n", ret);
}
|
#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];
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>
using namespace std;
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
int a[200200];
int f[200200];
vector<int> adj[200200], vec[200200];
int vst[200200], runs;
int flag[200200], ans;
int dfs(int u) {
vst[u] = runs;
int one = 0, two = 0;
for (int i = adj[u].size(); i--;) {
int v = adj[u][i];
if (flag[v] == runs && vst[v] != runs) {
int mx = dfs(v);
if (mx > two) {
two = mx;
if (one < two) swap(one, two);
}
}
}
smax(ans, one + two + 1);
return one + 1;
}
int main() {
for (int i = 2; i <= 200000; i++)
if (!f[i]) {
f[i] = i;
if ((long long)i * i >= 200200) continue;
for (int j = i * i; j <= 200000; j += i) f[j] = i;
}
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1, u, v; i < n; i++) {
scanf("%d %d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
int u = a[i];
while (u > 1) {
int first = f[u];
while (u > 1 && u % first == 0) u /= first;
vec[first].push_back(i);
}
}
for (int I = 2; I <= 200000; I++)
if (!vec[I].empty()) {
runs++;
for (int i = vec[I].size(); i--;) {
int u = vec[I][i];
flag[u] = runs;
}
for (int i = vec[I].size(); i--;) {
int u = vec[I][i];
if (vst[u] != runs) dfs(u);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int n;
cin >> n;
int a[n], sum = 0;
for(int i =0 ; i < n; i++){
cin >> a[i];
}
sort(a, a + n);
sum = a[n-1];
for(int i = 0; i < n-2; i++){
sum += a[n-2-i/2];
}
cout << sum << '\n';
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main()
{
ll n;
cin>>n;
ll a[n];
for(int i=0;i<n;i++)
cin>>a[i];
sort(a,a+n);
ll ans=a[n-1],j=n-2;
for(int i=n-3;i>=0;i--)
{
ans+=a[j];
i--;
if(i>=0)
ans+=a[j];
j--;
}
cout<<ans;
} |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int N;
cin>>N;
vector<long long> A(N);
for(int i=0;i<N;i++){
cin>>A[i];
}
sort(A.begin(),A.end());
long long result=0;
for(int i=1;i<N;i++){
result+=A[N-1-i/2];
}
cout<<result<<endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n;
cin >> n;
long long a[n];
for(int i=0;i<n;i++){
cin >> a[i];
}
sort(a, a+n, greater<int>());
long long sum = 0;
int k = 0;
for(int i=0;i<n-1;i++){
sum += a[k];
if(i%2==0) k++;
}
cout << sum << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll n;
cin>>n;
ll arr[n];
for(int i=0;i<n;i++) cin>>arr[i];
sort(arr,arr+n,greater<ll>());
ll i=1,ans=0;
for(;i<=n/2;i++){
if(i==1){
ans+=arr[0];
}
else{
ans=ans+2*arr[i-1];
}
}
if(n%2) ans+=arr[i-1];
cout<<ans;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int ar[200005];
int main()
{
ll n , i, ans=0;
cin>>n;
for(i=0; i<n; i++)
{
cin>>ar[i];
}
sort(ar,ar+n);
reverse(ar,ar+n);
for(i=1; i<n; i++)
{
ans+=ar[i/2];
}
cout<<ans<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pi;
typedef vector<ll> vll;
ll N,arr[200002];
int main(){
cin>>N;
for(int i=0; i<N; i++)cin>>arr[i];
sort(arr,arr+N);
ll total=0;
for(int i=0; i<N; i++){
if(i!=0){
total+=arr[N-1-i/2];
}
}
cout<<total<<'\n';
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.rbegin(), a.rend());
ll sum = 0;
for (int i = 1; i < n; i++) {
sum += (ll)a[i / 2];
}
cout << sum << endl;
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main() {
int N;
cin >> N;
vector<int> A(N);
int i;
for(i=0;i<N;i++)cin >> A[i];
sort(A.begin(),A.end(),greater<int>());
long long ans = 0;
for(i=1;i<N;i++) {
ans += A[i/2];
}
cout << ans << endl;
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> A(N);
for(int i = 0; i < N; i++){
cin >> A[i];
}
sort(A.begin(), A.end(), greater<int>());
long ans = 0;
for(int i = 0; i < N - 1;i++){
ans += A[(i + 1)/2];
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
//input
int N;
cin >> N;
int A[N];
for(int i=0;i<N;i++) cin >> A[i];
//setup
sort(A,A+N);
reverse(A,A+N);
long long Total=0;
for(int i=0;i<N;i++){
Total+=A[i/2];
}
Total-=A[0];
//output
cout << Total << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int a[n];
for (int i=0; i<n; i++) cin>>a[i];
sort(a, a + n);
long long sum = a[n-1];
int cnt = n - 2;
for (int i=n-2; i>=0 && cnt > 0; i--) {
sum += min(2, cnt) * a[i];
cnt -= 2;
}
cout<<sum<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
long long A[n];
long long ans=0;
for(int i=0;i<n;i++){
cin>>A[i];
}
sort(A,A+n);
ans=A[n-1];
for(int i=0;i<n-2;i++){
ans+=A[n-2-i/2];
//cout<<ans<<endl;
}
cout<<ans<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N; cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
sort(A.begin(), A.end(), greater<int>());
long long sum = 0;
for (int i = 0; i < N-1; i++) {
sum += A.at((i+1)/2);
}
cout << sum << endl;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ios::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
ll n,i,m,w,j,k,l,ans=0;
cin>>n;
ll arr[n+2];
for(i=1;i<=n;i++)
cin>>arr[i];
sort(arr+1,arr+n+1);
for(i=1;i<n;i++)
ans+=arr[n-i/2];
cout<<ans;
}
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int n;
cin >> n;
int a[n];
rep(i,n)cin >> a[i];
sort(a,a+n);
long long ans=0;
rep(i,n-1){
if(i%2==0)ans+=a[n-1-i/2];
else ans+=a[n-2-i/2];
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int64_t ans = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
sort(a, a + n, greater<int>());
for (int i = 1; i<n; i++)
ans += a[i/2];
cout << ans;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> a(n);
for(int i=0;i<n;i++)
cin>>a.at(i);
sort(a.begin(),a.end(),greater<int>());
int64_t s=0;
for(int i=1;i<n;i++)
s+=a.at(i/2);
cout<<s<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll N,i,ans;
ll A[222222];
cin >> N;
for(i=0;i<=N-1;i++)
cin >> A[i];
sort(A,A+N,greater<int>());
ans = A[0];
for(i=0;i<=N-3;i++)
ans += A[i/2+1];
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
vector<int> a;
int main() {
int n;
cin >> n;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
a.push_back(x);
}
sort(a.rbegin(), a.rend());
long ans = 0;
for (int i = 1; i < n; i++)
ans += a[i];
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main(void){
long n;
cin >> n;
long a[n];
for(int i=0;i<n;i++) cin >> a[i];
sort(a,a+n);
reverse(a,a+n);
long ans = a[0];
for(int i=1;i<n/2;i++){
ans += 2*a[i];
}
if(n%2) ans += a[n/2];
cout << ans << endl;
} |
#include <bits/stdc++.h>
#define rep(i,cc,n) for(int i=cc;i<=n;++i)
using namespace std;
using ll = long long;
int main() {
int N;
cin >> N;
vector<int> A(N);
rep(i,0,N-1) cin >> A[i];
sort(A.begin(), A.end());
ll ans = 0;
rep(i,0,N-2) {
ans += A[N-1-(i+1)/2];
}
cout << ans << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
int main() {
int n;
cin >> n;
vector<int> player(n);
for (auto &e : player) {
cin >> e;
}
sort(player.rbegin(), player.rend());
long long int ans = 0;
for (int k = 1; k < n; k++) {
ans += player[floor(k / 2)];
}
cout << ans << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N;
cin >> N;
vector<long long> A(N);
for(int i=0;i<N;i++) cin >> A[i];
sort(A.begin(),A.end());
reverse(A.begin(),A.end());
long long ans = 0;
for(int i=1;i<N;i++){
ans += A[i/2];
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll n,k;
cin>>n;
vector<int> a;
a.push_back(0);
for(ll i=0;i<n;i++){
cin>>k;
a.push_back(k);
}
sort(a.begin(),a.end());
ll c=0;
for(ll i=1;i<n;i++){
c += a[n - i/2];
}
cout<<c<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
vector<int>v(n);
for(int i=0;i<n;i++){
cin>>v[i];
}
sort(v.begin(),v.end(),greater<int>());
long long int sum=0;
for(int i=1;i<n;i++){
sum+=v[i/2];
}
cout<<sum<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){int s;cin>>s;vector<long>a(s);long long m=0;
for(int i=0;i<s;i++)cin>>a.at(i);
sort(a.rbegin(),a.rend());
for(int i=1;i<s;i++)m+=a.at(i/2);
cout<<m<<endl;} |
#include<bits/stdc++.h>
using namespace std;
int main() {
int N; cin >> N;
vector<int> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i];
}
sort(v.rbegin(), v.rend());
long long res = v[0];
for (int i = 2; i < N; i++) {
res += v[i/2];
}
cout << res << endl;
} |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll n,a[200050];
cin >> n;
for(int i=1; i<=n; i++){
cin >> a[i];
}
sort(a+1,a+n+1,greater<ll>());
ll jwb=0;
for(int i=2; i<=n; i++){
jwb+=a[(i+1)/2];
}
cout << jwb << endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
long N;
cin>>N;
vector<long> a(N);
for(int i=0;i<N;i++) cin>>a[i];
sort(a.begin(),a.end());
reverse(a.begin(),a.end());
long ans=0;
for(int i=0;i<N-1;i++){
ans+=a[(i+1)/2];
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> a(n);
for(int i=0; i<n; ++i) cin >> a[i];
sort(a.begin(),a.end(),greater<int>());
long long ans=a[0];
for(int i=2; i<n; ++i){
ans += a[i/2];
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=2e5+5;
int a[N];
int main(){
int n;scanf("%d",&n);
for(int i=0;i<n;i++)scanf("%d",a+i);
sort(a,a+n,greater<int>());
LL ans=a[0];
for(int i=n/2-1;i;i--)ans+=a[i]<<1;
if(n&1)ans+=a[n/2];
printf("%lld\n",ans);
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+10000;
typedef long long ll;
ll a[N];
int n;
int main()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
sort(a+1,a+1+n,greater<ll>());
ll sum=a[1];
int pos=2;
for(int i=2;i<n;i++)
{
if(i%2==0) sum+=a[pos];
else sum+=a[pos++];
}
cout<<sum<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
int n;
cin>>n;
vector<int> a(n);
for(int i=0;i<n;i++)
cin>>a.at(i);
sort(a.begin(),a.end(),greater<int>());
int64_t s=0;
for(int i=1;i<n;i++)
s+=a.at(i/2);
cout<<s<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int64_t n;
cin >> n;
vector<int64_t> as(n);
for (auto &&a : as)
{
cin >> a;
}
sort(as.rbegin(), as.rend());
int64_t ans = 0;
for (int64_t i = 1; i < n; i++)
{
ans += as[i / 2];
}
cout << ans << endl;
return 0;
} |
#include<iostream>
#include<algorithm>
using namespace std;
int a[200000];
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; ++i)
cin >> a[i];
sort(a, a + n);
reverse(a, a + n);
long long ans = 0;
for (int i = 1; i < n; ++i)
ans += a[i >> 1];
cout << ans;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(void){
int n;
cin>>n;
vector<int> A(n);
rep(i,n) cin>>A[i];
sort(A.begin(),A.end(),greater<int>());
long long sum=A[0];//初めの二人
rep(i,n-2) sum+=A[1+i/2];
cout<<sum<<endl;
return 0;
} |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
using ll = long long;
int main(){
ll n;
cin>>n;
vector<ll> a(n);
for(int i=0;i<n;i++) cin>>a[i];
sort(a.begin(),a.end());
ll ans=0;
for(int i=0;i<n-1;i++){
ans+=a[n-1-(i+1)/2];
}
cout<<ans<<endl;
} |
#include<bits/stdc++.h>
using namespace std;
bool f(int x ,int y)
{
return x>y;
}
int main()
{
int n;
cin>>n;
vector<int> v(n);
for(int i=0;i<n;i++)
{
cin>>v[i];
}
sort(v.begin(),v.end(),f);
long long int count = 0;
for(int j=1;j<n;j++)
{
count+=v[int(floor(j/2))];
}
cout<<count<<endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
ll n;
cin>>n;
ll a[n];
for(int i=0;i<n;i++)cin>>a[i];
sort(a,a+n);
reverse(a,a+n);
ll ans=0;
for(int i=0;i<n;i++){
ans+=a[i/2];
}
ans-=a[0];
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,m,n) for(int i=m;i<n;i++)
ll mod=1e9+7;
int main(){
int n;
cin>>n;
int a[n];
rep(i,0,n) cin>>a[i];
sort(a,a+n);
reverse(a,a+n);
ll ans=a[0];
rep(i,2,n){
ans+=a[i/2];
}
cout<<ans<<endl;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
long N;
cin >> N;
vector<long> A(N);
for (long i = 0; i < N; i++) cin >> A.at(i);
sort(A.rbegin(), A.rend());
long ans = A.at(0);
for (long i = 2; i < N; i++) {
ans += A.at(i / 2);
}
cout << ans << "\n";
} |
#include <iostream>
#include <algorithm>
typedef long long ll;
int N;
ll A[200005];
int main() {
std::cin >> N;
for (int i = 0; i < N; ++i)
std::cin >> A[i];
std::sort(A, A+N, std::greater<int>());
ll sum = -A[0];
for (int i = 0; i < N; ++i)
sum += A[i/2];
std::cout << sum << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main() {
int N; cin >> N;
vector<ll> A(N);
for(int i=0; i<N; i++) cin >> A[i];
sort(A.begin(), A.end(), greater<ll>());
ll sum=0;
for(int i=1; i<N; i++) sum+=A[i/2];
cout << sum;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10;
ll n,a[N],ans;
int main(){
cin>>n;
for(ll i=0;i<n;i++)
scanf("%lld",&a[i]);
sort(a,a+n,greater<ll>());
ans=a[0];
for(ll i=2;i<=n-1;i++){
ans+=a[i/2];
}
cout<<ans<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main () {
long long n; cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long sum = a[n - 1];
for (long long i = 0; i < n - 2; i++)
sum += a[n - (i / 2) - 2];
cout << sum;
} |
#include<bits/stdc++.h>
using namespace std;
int a[200005],n;
long long ans;
bool cmp(int s1,int s2)
{
return s1>s2;
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++)cin>>a[i];
sort(a+1,a+n+1,cmp);
//for(int i=1;i<=n;i++)cout<<a[i]<<" ";cout<<endl;
ans=a[1];
for(int i=3;i<=n;i++)ans+=a[(i+1)/2];
cout<<ans<<endl;
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,i;
long long int s;
cin>>n;
vector<long long>v(n);
for(i=0;i<n;i++)cin>>v[i];
sort(v.begin(),v.end());
s=0;
for(i=1;i<n;i++)
{
int l=n-1-i/2;
s +=v[l];
}
cout<<s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, greater<int>());
long long resp = a[0];
for (int i = 2; i < n; i++) {
resp += 1ll * a[i / 2];
}
cout << resp << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<long long> a(n);
for (auto &i : a) cin >> i;
sort(a.rbegin(), a.rend());
long long ans = 0;
for (int i = 1; i < n; i++) {
ans += a[i / 2];
}
cout << ans << endl;
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
#define LL long long
int main(){
LL n; cin>>n;
LL a[n];
for(int i=0; i<n; i++) cin>>a[i];
sort(a, a+n);
LL sum = a[n-1];
for(int i=n-2; i >= (n+1)/2; i--)
sum += a[i]*2;
if(n&1) sum += a[(n-1)/2];
cout<<sum<<"\n";
} |
#include<bits/stdc++.h>
#include<map>
using namespace std;
int main(){
int n;
cin>>n;
vector<int> v(n);
for(int i=0;i<n;i++){
cin>>v[i];
}
sort(v.begin(),v.end());
long long sum=0;
for(int i=1;i<n;i++){
sum+=v[n-1-i/2];
}
cout<<sum;
return 0;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.