text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int ans[maxn], kt[maxn];
queue<int> q[maxn];
const char ori = 'a';
struct trie {
struct node {
int num, dep;
unsigned next[26];
} data[maxn * 26];
unsigned l;
trie() { memset(this, 0, sizeof(*this)); }
void append(const string& s, int num) {
unsigned now = 0;
for (unsigned i = 0; i < s.length(); ++i) {
if (!data[now].next[s[i] - ori]) {
data[now].next[s[i] - ori] = ++l;
data[l].dep = data[now].dep + 1;
}
now = data[now].next[s[i] - ori];
}
data[now].num = num;
}
void run(const string& s, int st) {
unsigned now = 0;
for (int i = st; i < s.length(); i += 1) {
if (!data[now].next[s[i] - ori]) break;
now = data[now].next[s[i] - ori];
if (data[now].num) {
int h = data[now].num;
q[h].push(i);
if (q[h].size() == kt[h]) {
int tmp = data[now].dep + q[h].back() - q[h].front();
if (ans[h] == -1 || ans[h] > tmp) ans[h] = tmp;
q[h].pop();
}
}
}
}
} tree;
vector<int> getNext(const string& s) {
int j = 0, k = -1, l = s.length();
vector<int> next(l + 1);
next[0] = -1;
while (j < l) {
if (k == -1 || s[j] == s[k])
next[++j] = ++k;
else
k = next[k];
}
return next;
}
int KMP(const string& s1, const string& s2, int tms) {
int i = 0, j = 0, l1 = s1.length(), l2 = s2.length();
vector<int> next = getNext(s2);
queue<int> v;
int ans = 0x3f3f3f3f;
while (i < l1 && j < l2) {
if (j == -1 || s1[i] == s2[j]) {
++i, ++j;
} else {
j = next[j];
}
if (j == l2) {
v.push(i);
if (v.size() == tms) {
ans = min(ans, int(v.back() - v.front() + s2.length()));
v.pop();
}
j = next[j];
}
}
if (ans == 0x3f3f3f3f) return -1;
return ans;
}
signed main() {
std::ios::sync_with_stdio(false);
string s;
cin >> s;
int mq = sqrt(s.length());
int n;
cin >> n;
for (int i = 1; i <= n; i += 1) {
int k;
string t;
cin >> k >> t;
if (t.length() >= mq) {
ans[i] = KMP(s, t, k);
} else {
ans[i] = -1;
tree.append(t, i);
kt[i] = k;
}
}
for (int i = 0; i < s.length(); i += 1) {
tree.run(s, i);
}
for (int i = 1; i <= n; i += 1) {
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
struct ahoCorasick {
struct Node {
int child[26], fail, term;
vector<int> id;
Node() : fail(0), term(0) { memset(child, 0, sizeof(child)); }
};
int Time;
vector<Node> a;
vector<int> sta, en;
vector<vector<int> > id, g;
ahoCorasick() : Time(0), id(N) { a.push_back(Node()); }
void dfs(int u) {
sta[u] = ++Time;
for (auto v : g[u]) dfs(v);
en[u] = Time;
}
private:
void createTree() {
g.assign(a.size() + 5, vector<int>());
sta.assign(a.size() + 5, 0);
en.assign(a.size() + 5, 0);
for (int i = (int)1; i <= (int)a.size() - 1; i++) g[a[i].fail].push_back(i);
dfs(0);
}
public:
int add(string s, int _id) {
int u = 0;
for (auto it : s) {
if (a[u].child[it - 'a'] == 0) {
a.push_back(Node());
a[u].child[it - 'a'] = a.size() - 1;
}
u = a[u].child[it - 'a'];
}
id[u].push_back(_id);
return u;
}
void createAho() {
queue<int> q({0});
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = (int)0; i <= (int)25; i++) {
int v = a[u].child[i];
int fv = a[a[u].fail].child[i];
if (v == 0) {
a[u].child[i] = fv;
continue;
}
if (fv != v) {
a[v].fail = fv;
a[v].term = (id[fv].size() ? fv : a[fv].term);
}
q.push(v);
}
}
}
void findAllOccur(string &s, vector<vector<int> > &app) {
int u = 0;
for (int i = (int)0; i <= (int)s.size() - 1; i++) {
auto c = s[i];
u = a[u].child[c - 'a'];
int v = u;
while (v != 0) {
for (auto it : id[v]) app[it].push_back(i);
v = a[v].term;
}
}
}
} Aho;
vector<pair<int, string> > query;
vector<vector<int> > app(N);
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string a;
cin >> a;
int q;
cin >> q;
for (int i = (int)1; i <= (int)q; i++) {
int need;
string s;
cin >> need >> s;
query.push_back({need, s});
Aho.add(s, i - 1);
}
Aho.createAho();
Aho.findAllOccur(a, app);
for (int i = (int)0; i <= (int)q - 1; i++) {
if (app[i].size() < query[i].first) {
cout << -1 << '\n';
continue;
}
int ans = 1e9;
for (int j = (int)query[i].first - 1; j <= (int)app[i].size() - 1; j++) {
int R = app[i][j];
int L = app[i][j - query[i].first + 1] - query[i].second.size() + 1;
ans = min(ans, R - L + 1);
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
template <typename T>
inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
template <typename T>
inline void cmin(T &x, T y) {
if (y < x) x = y;
}
template <typename T>
inline void cmax(T &x, T y) {
if (x < y) x = y;
}
char s[MAXN], t[MAXN];
int n, m, k[MAXN], len[MAXN];
int tot, ch[MAXN][26], fail[MAXN], ed[MAXN], ff[MAXN];
int q[MAXN], head, tail;
vector<int> mtch[MAXN];
void Insert(int id) {
int p = 0, l = len[id] = strlen(t + 1);
for (int i = 1; i <= l; ++i) {
int x = t[i] - 'a';
if (!ch[p][x]) {
ch[p][x] = ++tot;
}
p = ch[p][x];
}
ed[p] = id;
}
void GetFail() {
head = 1, tail = 0;
for (int i = 0; i < 26; ++i) {
if (ch[0][i]) {
q[++tail] = ch[0][i];
}
}
while (head <= tail) {
int u = q[head++];
for (int i = 0; i < 26; ++i) {
if (ch[u][i]) {
int v = ch[u][i];
fail[v] = ch[fail[u]][i];
ff[v] = (ed[fail[v]] ? fail[v] : ff[fail[v]]);
q[++tail] = v;
} else {
ch[u][i] = ch[fail[u]][i];
}
}
}
}
void Run() {
int p = 0;
for (int i = 1; i <= n; ++i) {
p = ch[p][s[i] - 'a'];
int u = (ed[p] ? p : ff[p]);
for (; u; u = ff[u]) {
mtch[ed[u]].push_back(i);
}
}
}
void init() {
scanf("%s", s + 1);
n = strlen(s + 1);
read(m);
for (int i = 1; i <= m; ++i) {
read(k[i]);
scanf("%s", t + 1);
Insert(i);
}
GetFail();
}
void solve() {
Run();
for (int i = 1; i <= m; ++i) {
if (mtch[i].size() < k[i]) {
printf("-1\n");
} else {
int ans = n + 1;
for (int j = 0, sz = mtch[i].size(); j + k[i] - 1 < sz; ++j) {
cmin(ans, mtch[i][j + k[i] - 1] - mtch[i][j]);
}
printf("%d\n", ans + len[i]);
}
}
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
const int maxn = 1e5 + 5;
const int alpha = 26;
const int init = 'a';
int go[maxn][alpha];
int fail[maxn];
vector<int> final[maxn];
int idx = 2;
void insert(string s, int p) {
int node = 1;
int n = s.size();
for (int i = 0; i < n; i++) {
if (!go[node][s[i] - init]) go[node][s[i] - init] = idx++;
node = go[node][s[i] - init];
}
final[node].push_back(p);
}
void build() {
queue<int> Q;
for (int i = 0; i < alpha; i++) {
if (!go[1][i])
go[1][i] = 1;
else
Q.push(go[1][i]), fail[go[1][i]] = 1;
}
fail[1] = 1;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
int f = fail[u];
for (int i = 0; i < alpha; i++) {
if (!go[u][i])
go[u][i] = go[f][i];
else {
fail[go[u][i]] = go[f][i];
for (auto &el : final[go[f][i]]) final[go[u][i]].push_back(el);
Q.push(go[u][i]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size();
int q;
cin >> q;
vector<int> ans(q, oo);
vector<int> k(q), sz(q);
vector<vector<int>> pos(q);
for (int i = 0; i < q; i++) {
cin >> k[i];
string x;
cin >> x;
insert(x, i);
sz[i] = x.size();
}
build();
int st = 1;
for (int i = 0; i < n; i++) {
char c = s[i];
st = go[st][c - init];
for (auto &el : final[st]) pos[el].push_back(i);
}
for (int i = 0; i < q; i++) {
for (int j = 0; j + k[i] - 1 < (int)pos[i].size(); j++) {
int lo = pos[i][j] - sz[i] + 1;
int hi = pos[i][j + k[i] - 1];
ans[i] = min(ans[i], hi - lo + 1);
}
}
for (int i = 0; i < q; i++) {
if (ans[i] == oo) ans[i] = -1;
cout << ans[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int po[100005];
char s[100005];
char m[100005];
int hs[100005];
int occ[100005];
int res[100005];
int k_rec[100005];
int hsval(int l, int r) {
return (hs[r] - (1LL * hs[l - 1] * po[r - l + 1]) % 1000000009 + 1000000009) %
1000000009;
}
int min(int a, int b) { return a < b ? a : b; }
map<int, int> mp[260 + 5];
int main() {
scanf("%s", &s[1]);
int n;
for (n = 1; s[n]; n++)
;
n--;
for (int i = 1; i <= n; i++)
hs[i] = (1LL * hs[i - 1] * 26 + s[i] - 'a') % 1000000009;
po[0] = 1;
for (int i = 1; i <= n; i++) po[i] = (1LL * po[i - 1] * 26) % 1000000009;
int q;
scanf("%d", &q);
for (int qr = 1; qr <= q; qr++) {
int k;
scanf("%d", &k);
scanf("%s", &m[1]);
int len;
for (len = 1; m[len]; len++)
;
len--;
int val = 0;
for (int i = 1; i <= len; i++)
val = (1LL * val * 26 + m[i] - 'a') % 1000000009;
res[qr] = 1e9;
if (len > 260) {
int found = 0;
for (int i = len; i <= n; i++) {
if (hsval(i - len + 1, i) == val) {
occ[++found] = i;
if (found >= k) res[qr] = min(res[qr], i - occ[found - k + 1] + len);
}
}
} else {
mp[len][val] = qr;
k_rec[qr] = k;
}
}
for (int len = 1; len <= 260; len++) {
map<int, vector<int>> occ;
for (int i = len; i <= n; i++) {
int x = hsval(i - len + 1, i);
if (mp[len].find(x) != mp[len].end()) {
int qr = mp[len][x];
occ[x].push_back(i);
int k = k_rec[qr];
int sz = (int)occ[x].size();
if (sz >= k) {
res[qr] = min(res[qr], i - occ[x][sz - k] + len);
}
}
}
}
for (int i = 1; i <= q; i++) {
if (res[i] > n)
printf("-1\n");
else
printf("%d\n", res[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
const int maxn = (int)1e5 + 10, p = (int)1e9 + 7, q = (int)1e9 + 9;
char s[maxn];
pair<int, int> st[maxn];
int my_rand() {
if (RAND_MAX == 32767) {
return rand() * RAND_MAX + rand();
}
return rand();
}
string t[maxn];
int k[maxn];
int num[maxn];
bool cmp(int a, int b) { return (int)t[a].size() < t[b].size(); }
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
a.first += b.first;
if (a.first >= p) {
a.first -= p;
}
a.second += b.second;
if (a.second >= q) {
a.second -= q;
}
return a;
}
pair<int, int> operator-(pair<int, int> a, pair<int, int> b) {
a.first -= b.first;
if (a.first < 0) {
a.first += p;
}
a.second -= b.second;
if (a.second < 0) {
a.second += q;
}
return a;
}
pair<int, int> operator*(pair<int, int> a, pair<int, int> b) {
a.first = (long long)a.first * b.first % p;
a.second = (long long)a.second * b.second % q;
return a;
}
vector<int> g[maxn];
pair<int, int> tab[1 << 19];
int it[1 << 19];
int gg = (1 << 19) - 1;
int iter = 0;
void add(int ps, int hs, int x) {
ps &= gg;
if (it[ps] != iter) {
it[ps] = iter;
tab[ps] = make_pair(hs, x);
} else {
add(ps + 1, hs, x);
}
}
pair<int, int> operator+(pair<int, int> a, int x) {
a.first += x;
a.second += x;
if (a.first >= p) {
a.first -= p;
}
if (a.second >= q) {
a.second -= q;
}
return a;
}
pair<int, int> get_hsh(int ps) {
pair<int, int> cur = make_pair(0, 0);
for (int i = 0; i < (int)t[ps].size(); i++) {
cur = cur * st[1] + (t[ps][i] - 'a' + 1);
}
return cur;
}
int go(int ps, int hs) {
ps &= gg;
if (it[ps] != iter) {
return -1;
}
if (tab[ps].first == hs) {
return tab[ps].second;
}
return go(ps + 1, hs);
}
int ans[maxn];
pair<int, int> sum[maxn];
pair<int, int> get_sum(int l, int r) {
r++;
return sum[r] - sum[l] * st[r - l];
}
int main() {
srand(time(NULL));
st[0] = make_pair(1, 1);
for (int i = 1; i < maxn; i++) {
st[i] = st[i - 1] * make_pair(1234567, 1234567);
}
scanf("%s", s);
int len = strlen(s);
pair<int, int> cur = make_pair(0, 0);
sum[0] = cur;
for (int i = 0; i < len; i++) {
sum[i + 1] = sum[i] * st[1] + (s[i] - 'a' + 1);
}
int n;
cin >> n;
for (int i = 0; i < n; i++) {
char c;
num[i] = i;
scanf("%d ", &k[i]);
while (scanf("%c", &c) != EOF) {
if (c == '\n') {
break;
}
t[i] += c;
}
ans[i] = len + 1;
}
sort(num, num + n, cmp);
for (int i = 0; i < n;) {
iter++;
int r = i;
while (r < n && t[num[i]].size() == t[num[r]].size()) {
r++;
}
for (int j = i; j < r; j++) {
pair<int, int> f = get_hsh(num[j]);
add(f.first, f.second, num[j]);
}
int d = (int)t[num[i]].size();
pair<int, int> cur = make_pair(0, 0);
if (d > len) {
break;
}
for (int j = 0; j <= len - d; j++) {
pair<int, int> cur = get_sum(j, j + d - 1);
int numb = go(cur.first, cur.second);
if (numb != -1) {
g[numb].push_back(j);
if ((int)g[numb].size() >= k[numb]) {
ans[numb] =
min(ans[numb],
g[numb].back() - g[numb][(int)g[numb].size() - k[numb]]);
}
}
}
i = r;
}
for (int i = 0; i < n; i++) {
if (ans[i] == len + 1) {
printf("-1\n");
} else {
printf("%d\n", ans[i] + (int)t[i].size());
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 3;
int slink[MAXN], fail[MAXN], nxt[MAXN][26], sz = 0, len[MAXN], st[MAXN],
cnv[MAXN];
string str[MAXN];
void add_string(int idx) {
string s = str[idx];
int cur = 0;
for (auto &c : s) {
if (!nxt[cur][c - 'a']) {
nxt[cur][c - 'a'] = ++sz;
}
len[nxt[cur][c - 'a']] = len[cur] + 1;
cur = nxt[cur][c - 'a'];
}
slink[cur] = cur;
st[idx] = cur;
cnv[cur] = idx;
}
void push_link() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int v = q.front();
q.pop();
int u = fail[v];
if (!slink[v]) slink[v] = slink[u];
for (int i = 0; i < 26; i++) {
if (nxt[v][i]) {
fail[nxt[v][i]] = v ? nxt[u][i] : 0;
q.push(nxt[v][i]);
} else {
nxt[v][i] = nxt[u][i];
}
}
}
}
vector<int> pos[MAXN];
int cnt[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> cnt[i] >> str[i];
add_string(i);
}
push_link();
int cur = 0;
for (int i = 0; i < s.size(); i++) {
int v = nxt[cur][s[i] - 'a'];
for (int u = slink[v]; u; u = slink[fail[u]]) {
pos[cnv[u]].push_back(i);
}
cur = v;
}
for (int i = 1; i <= n; i++) {
if (pos[i].size() < cnt[i]) {
cout << -1 << "\n";
continue;
}
int ans = 1e9;
for (int j = 0; j <= pos[i].size() - cnt[i]; j++) {
ans = min(ans, (int)str[i].size() + pos[i][j + cnt[i] - 1] - pos[i][j]);
}
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10, mod = (int)1e9 + 7;
int n, q, sz = 1, last, ans[N], len[N];
vector<pair<int, int>> Q[N << 1];
vector<int> inv_link[N << 1];
deque<int> dq[N];
char buf[N];
struct state {
int len, link, nex[26], pre;
} st[N << 1];
void sa_extend(char ch) {
int c = ch - 'a';
int cur = sz++;
st[cur].len = st[last].len + 1;
int p = last;
while (p != -1 && !st[p].nex[c]) {
st[p].nex[c] = cur;
p = st[p].link;
}
if (p == -1)
st[cur].link = 0;
else {
int q = st[p].nex[c];
if (st[q].len == st[p].len + 1)
st[cur].link = q;
else {
int clone = sz++;
st[clone] = st[q];
st[clone].len = st[p].len + 1;
while (p != -1 && st[p].nex[c] == q) {
st[p].nex[c] = clone;
p = st[p].link;
}
st[cur].link = st[q].link = clone;
}
}
last = cur;
}
void dfs(int u, int lst = -1) {
st[u].pre = lst;
if (Q[u].size()) lst = u;
for (int v : inv_link[u]) dfs(v, lst);
}
int main() {
st[0].link = -1;
scanf("%s", &buf);
string s = buf;
n = s.size();
string t = s;
for (int i = 0; i < s.size(); i++) sa_extend(s[i]);
for (int i = 1; i < sz; i++) inv_link[st[i].link].push_back(i);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
ans[i] = 1e9;
int k;
scanf("%d%s", &k, &buf);
s = buf;
len[i] = s.size();
int u = 0;
for (int j = 0; j < s.size(); j++) {
u = st[u].nex[s[j] - 'a'];
if (!u) break;
}
if (!u) continue;
Q[u].push_back({k, i});
}
dfs(0);
int u = 0;
for (int i = 0; i < n; i++) {
u = st[u].nex[t[i] - 'a'];
int v = u;
while (v > 0) {
for (auto x : Q[v]) {
int k = x.first, idx = x.second;
dq[idx].push_back(i);
if (dq[idx].size() == k) {
ans[idx] = min(ans[idx], dq[idx].back() - dq[idx].front() + len[idx]);
dq[idx].pop_front();
}
}
v = st[v].pre;
}
}
for (int i = 0; i < q; i++) {
if (ans[i] == 1e9) ans[i] = -1;
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using cd = complex<double>;
const int modd1 = 1e9 + 7, modd2 = 998244353, maxn = 1e5 + 6, K = 26;
const double pi = acos(-1);
struct vertex {
int next[K], go[K];
int leaf = -1, leaflink = -1;
int p = -1, link = -1;
char pch;
vertex(int p = -1, char ch = '$') : p(p), pch(ch) {
fill(begin(next), end(next), -1);
fill(begin(go), end(go), -1);
}
};
vector<vertex> trie(1);
void add_string(string const &s, int idx) {
int v = 0;
for (char ch : s) {
int c = ch - 'a';
if (trie[v].next[c] == -1) {
trie[v].next[c] = trie.size();
trie.emplace_back(v, ch);
}
v = trie[v].next[c];
}
trie[v].leaf = idx;
}
int go(int v, char ch);
int get_link(int v) {
if (trie[v].link == -1) {
if (v == 0 || trie[v].p == 0) {
trie[v].link = 0;
} else {
trie[v].link = go(get_link(trie[v].p), trie[v].pch);
}
}
return trie[v].link;
}
int go(int v, char ch) {
int c = ch - 'a';
if (trie[v].go[c] == -1) {
if (trie[v].next[c] != -1) {
trie[v].go[c] = trie[v].next[c];
} else {
trie[v].go[c] = v == 0 ? 0 : go(get_link(v), ch);
}
}
return trie[v].go[c];
}
int get_leaf(int i) {
if (trie[i].leaflink != -1) {
return trie[i].leaflink;
}
int nxt = get_link(i);
if (nxt > 0) {
if (trie[nxt].leaf != -1) {
trie[i].leaflink = nxt;
} else {
trie[i].leaflink = get_leaf(nxt);
}
return trie[i].leaflink;
}
return 0;
}
string s;
int k[maxn], n;
string m[maxn];
vector<int> results[maxn];
void solve() {
cin >> s >> n;
int i, j, l, r;
for (i = 0; i < n; ++i) {
cin >> k[i] >> m[i];
add_string(m[i], i);
}
int v = 0;
for (i = 0; i < s.length(); ++i) {
v = go(v, s[i]);
int curr = v;
while (get_leaf(curr) > 0) {
curr = get_leaf(curr);
results[trie[curr].leaf].push_back(i);
}
if (trie[v].leaf != -1) {
results[trie[v].leaf].push_back(i);
}
}
for (i = 0; i < n; ++i) {
int mn = INT_MAX;
for (j = k[i]; j <= results[i].size(); ++j) {
mn = min(mn, results[i][j - 1] - results[i][j - k[i]]);
}
if (mn == INT_MAX) {
cout << -1 << '\n';
} else {
cout << mn + m[i].length() << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 500010;
struct node {
node *go[30], *pa;
vector<node *> son;
vector<pair<int, int> > q;
int val, pos;
} pool[N], *cur = pool, *rt;
char s[N], t[N];
int n;
node *newnode() {
node *p = cur++;
p->val = p->pos = 0;
p->pa = 0;
p->son.clear();
return p;
}
node *append(node *p, int w) {
node *np = newnode();
np->val = p->val + 1;
while (p && !p->go[w]) {
p->go[w] = np;
p = p->pa;
}
if (!p)
np->pa = rt;
else {
node *q = p->go[w];
if (q->val == p->val + 1)
np->pa = q;
else {
node *nq = newnode();
nq->val = p->val + 1;
memcpy(nq->go, q->go, sizeof(q->go));
nq->pa = q->pa;
np->pa = q->pa = nq;
while (p && p->go[w] == q) {
p->go[w] = nq;
p = p->pa;
}
}
}
return np;
}
void init() {
cur = pool;
rt = newnode();
node *np = rt;
for (int i = 1; i <= n; i++) {
np = append(np, s[i] - 'a');
np->pos = i;
}
for (node *p = pool; p != cur; p++)
if (p->pa) p->pa->son.push_back(p);
}
int q, c, ans[N];
int ct = 0;
vector<pair<int, int> > seq;
void dfs(node *p) {
int id = ct++;
if (p->pos) seq.push_back(make_pair(id, p->pos));
for (auto v : p->son) dfs(v);
if (!p->q.empty()) {
vector<int> c;
for (auto it = lower_bound((seq).begin(), (seq).end(), make_pair(id, -1));
it != seq.end(); ++it)
c.push_back(it->second);
sort((c).begin(), (c).end());
map<int, int> val;
for (auto w : p->q) {
if (w.first > (int(c.size())))
ans[w.second] = -1;
else {
if (val.count(w.first)) {
ans[w.second] += val[w.first];
continue;
}
int mv = 1e9;
for (int i = 0;
i < (int(c.size())) && i + w.first - 1 < (int(c.size())); i++)
mv = min(mv, c[i + w.first - 1] - c[i]);
val[w.first] = mv;
ans[w.second] += mv;
}
}
}
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
init();
scanf("%d", &q);
for (int i = 1; i <= q; i++) {
scanf("%d %s", &c, t);
int m = strlen(t);
node *p = rt;
for (int j = 0; j < m; j++) {
int w = t[j] - 'a';
if (!p->go[w]) {
ans[i] = -1;
break;
} else
p = p->go[w];
}
if (~ans[i]) {
ans[i] = m;
p->q.push_back(make_pair(c, i));
}
}
dfs(rt);
for (int i = 1; i <= q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
const int INF = 0x3f3f3f3f3f, mod = 1e9 + 7, maxn = 1e5 + 100;
const double eps = 1e-6, PI = acos(-1);
template <typename T>
inline void read(T& x) {
x = 0;
T f = 1;
char ch;
do {
ch = getchar();
if (ch == '-') f = -1;
} while (ch < '0' || ch > '9');
do x = x * 10 + ch - '0', ch = getchar();
while (ch <= '9' && ch >= '0');
x *= f;
}
int n, m, belong[maxn], tot = 0, ll[maxn], ans[maxn], val[maxn];
char ax[maxn], bx[maxn];
int Size;
bool flag = 0;
vector<int> ac[maxn];
set<int> ss[maxn];
struct Ac_hod {
struct node {
int Next[26];
int fail, cnt, id;
} Tree[maxn];
void init() {
Size = 1;
for (int i = 0; i < maxn; i++) {
Tree[i].fail = Tree[i].cnt = Tree[i].id = 0;
for (int j = 0; j < 26; j++) Tree[i].Next[j] = 0;
}
}
void Insert(char* s, int val, int id) {
int len = strlen(s);
int root = 0;
for (int i = 0; i < len; i++) {
int x = s[i] - 'a';
if (Tree[root].Next[x] == 0) Tree[root].Next[x] = Size++;
root = Tree[root].Next[x];
}
Tree[root].cnt = val;
Tree[root].id = id;
}
void build() {
queue<int> Q;
int root = 0;
Tree[root].fail = 0;
Q.push(root);
while (!Q.empty()) {
root = Q.front();
Q.pop();
for (int i = 0; i < 26; i++) {
int temp = Tree[root].Next[i];
if (temp == 0) {
if (root == 0)
Tree[root].Next[i] = 0;
else
Tree[root].Next[i] = Tree[Tree[root].fail].Next[i];
} else {
if (root == 0)
Tree[temp].fail = 0;
else {
Tree[temp].fail = Tree[Tree[root].fail].Next[i];
}
Q.push(temp);
}
}
}
}
void addedge() {
for (int i = 1; i < Size; i++) ac[Tree[i].fail].push_back(i);
}
void calc(char* s) {
int len = strlen(s), root = 0;
for (int i = 0; i < len; i++) {
root = Tree[root].Next[s[i] - 'a'];
if (!belong[root]) belong[root] = ++tot;
ss[belong[root]].insert(i);
}
}
void dfs(int x) {
int now = x;
if (!belong[x]) belong[x] = ++tot;
for (auto e : ac[x]) {
dfs(e);
if (ss[belong[e]].size() > ss[belong[now]].size()) now = e;
}
for (auto e : ac[x]) {
if (now == e) continue;
for (auto j = ss[belong[e]].begin(); j != ss[belong[e]].end(); j++)
ss[belong[now]].insert(*j);
}
if (now != x) {
for (auto j = ss[belong[x]].begin(); j != ss[belong[x]].end(); j++)
ss[belong[now]].insert(*j);
belong[x] = belong[now];
}
if (Tree[x].cnt == 0 || ss[belong[now]].size() < Tree[x].cnt) return;
if (x == 0 || Tree[x].id == 0) return;
int id = Tree[x].id;
vector<int> bc;
for (auto j = ss[belong[now]].begin(); j != ss[belong[now]].end(); j++)
bc.push_back(*j);
for (int i = bc.size() - 1; i >= 0; i--) {
if (i - val[id] + 1 < 0) break;
ans[id] = min(ans[id], bc[i] - bc[i - val[id] + 1]);
}
if (ans[id] != INF) ans[id] += ll[id];
}
} AC;
int main() {
scanf("%s", ax);
read(n);
AC.init();
for (int i = 1; i <= n; i++) {
read(val[i]);
scanf("%s", bx);
AC.Insert(bx, val[i], i);
ll[i] = strlen(bx);
ans[i] = INF;
}
AC.build();
AC.addedge();
AC.calc(ax);
AC.dfs(0);
for (int i = 1; i <= n; i++) {
if (ans[i] == INF)
puts("-1");
else
printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e5 + 10;
struct el {
int pr = 0, link = 0, nu = -1, link2 = 0, prsy;
};
el bor[sz];
int ne[sz][26], go[sz][26], q = 1;
vector<int> sp[sz];
int main() {
string s;
cin >> s;
int n;
cin >> n;
int le[n], k[n];
for (int a = 0; a < 26; a++) {
ne[0][a] = -1, go[0][a] = 0;
}
for (int a = 0; a < n; a++) {
string t;
cin >> k[a] >> t;
le[a] = t.size();
int cu = 0;
for (int b = 0; b < le[a]; b++) {
int sy = t[b] - 'a';
if (ne[cu][sy] == -1) {
ne[cu][sy] = q, bor[q].pr = cu, bor[q].prsy = sy;
for (int c = 0; c < 26; c++) ne[q][c] = -1;
q++;
}
cu = ne[cu][sy];
}
bor[cu].nu = a;
}
queue<int> qu;
qu.push(0);
while (qu.size()) {
int qq = qu.size();
for (int a = 0; a < qq; a++) {
int cu = qu.front();
int pr = bor[cu].pr, prsy = bor[cu].prsy;
if (cu != 0 and pr != 0) {
bor[cu].link = go[bor[pr].link][prsy];
if (bor[bor[cu].link].nu != -1)
bor[cu].link2 = bor[cu].link;
else
bor[cu].link2 = bor[bor[cu].link].link2;
}
for (int b = 0; b < 26; b++) {
if (ne[cu][b] != -1) {
go[cu][b] = ne[cu][b];
qu.push(ne[cu][b]);
} else
go[cu][b] = go[bor[cu].link][b];
}
qu.pop();
}
}
int cu = 0;
for (int a = 0; a < s.size(); a++) {
cu = go[cu][s[a] - 'a'];
int x = cu;
while (x != 0) {
if (bor[x].nu != -1) sp[bor[x].nu].push_back(a);
x = bor[x].link2;
}
}
for (int a = 0; a < n; a++) {
if (sp[a].size() < k[a])
cout << "-1\n";
else {
int be = 1e9;
for (int b = k[a] - 1; b < sp[a].size(); b++)
be = min(be, sp[a][b] - sp[a][b - k[a] + 1] + le[a]);
cout << be << "\n";
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2000000005;
const long long INFLL = 1000000000000000002ll;
const long long MOD = 1000000007;
inline long long min(long long a, long long b, long long c) {
return min(min(a, b), c);
}
inline long long min(long long a, long long b, long long c, long long d) {
return min(min(min(a, b), c), d);
}
inline long long max(long long a, long long b, long long c) {
return max(max(a, b), c);
}
inline long long max(long long a, long long b, long long c, long long d) {
return max(max(max(a, b), c), d);
}
int C[200005], N, RA[200005], TRA[200005], LCP[200005], Phi[200005],
PLCP[200005], Q, SA[200005], TSA[200005];
string S;
struct Query {
int l, r, k, id, sz;
Query(int _l, int _r, int _k, int _id, int _sz)
: l(_l), r(_r), k(_k), id(_id), sz(_sz){};
};
int Ans[200005];
vector<Query> Queries;
void countSort(int k) {
int sz = max(255, N);
for (int i = (0); i <= (sz); i++) C[i] = 0;
for (int i = (0); i <= (N - 1); i++) C[RA[i + k]]++;
int sum = 0;
for (int i = (0); i <= (sz); i++) {
int t = C[i];
C[i] = sum;
sum += t;
}
for (int i = (0); i <= (N - 1); i++) TSA[C[RA[SA[i] + k]]++] = SA[i];
for (int i = (0); i <= (N - 1); i++) SA[i] = TSA[i];
}
void suffixArray() {
for (int i = (0); i <= (N - 1); i++) SA[i] = i, RA[i] = S[i];
for (int k = 1; k < N; k *= 2) {
countSort(k);
countSort(0);
TRA[SA[0]] = 0;
for (int i = (1); i <= (N - 1); i++)
TRA[SA[i]] =
RA[SA[i]] == RA[SA[i - 1]] && RA[SA[i] + k] == RA[SA[i - 1] + k]
? TRA[SA[i - 1]]
: i;
for (int i = (0); i <= (N - 1); i++) RA[i] = TRA[i];
}
}
void getLCP() {
Phi[SA[0]] = -1;
for (int i = (1); i <= (N - 1); i++) Phi[SA[i]] = SA[i - 1];
int l = 0;
for (int i = (0); i <= (N - 1); i++) {
if (Phi[i] == -1) {
PLCP[i] = 0;
continue;
}
while (S[i + l] == S[Phi[i] + l]) l++;
PLCP[i] = l;
l = max(0, l - 1);
}
for (int i = (0); i <= (N - 1); i++) LCP[i] = PLCP[SA[i]];
}
pair<int, int> getRange(char t, int i, int l, int r) {
int a = l, b = r;
while (b - a > 1) {
int p = (a + b) / 2;
if (SA[p] + 1 < N && S[SA[p] + i] < t)
a = p;
else
b = p;
}
int ret_l = -1;
if (SA[a] + i < N && S[SA[a] + i] >= t)
ret_l = a;
else if (SA[b] + i < N && S[SA[b] + i] >= t)
ret_l = b;
else
return {-1, -1};
a = ret_l, b = r;
while (b - a > 1) {
int p = (a + b) / 2;
if (SA[p] + i < N && S[SA[p] + i] > t)
b = p;
else
a = p;
}
int ret_r = -1;
if (SA[b] + i < N && S[SA[b] + i] <= t)
ret_r = b;
else if (SA[a] + i < N && S[SA[a] + i] <= t)
ret_r = a;
else
return {-1, -1};
return {ret_l, ret_r};
}
void combine(int &l, int &r, int ol, int oor) {
l = max(l, ol);
r = min(r, oor);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> S >> Q;
S += '#';
N = ((int)S.size());
suffixArray();
for (int q = (1); q <= (Q); q++) {
int k;
string t;
cin >> k >> t;
pair<int, int> p = getRange(t[0], 0, 0, N - 1);
int l = p.first, r = p.second;
for (int i = (1); i <= (((int)t.size()) - 1); i++) {
p = getRange(t[i], i, l, r);
combine(l, r, p.first, p.second);
}
Queries.push_back(Query(l, r, k, q, ((int)t.size())));
}
for (Query q : Queries) {
vector<int> v;
if (q.r - q.l + 1 < q.k) {
Ans[q.id] = -1;
continue;
}
for (int i = (q.l); i <= (q.r); i++) v.push_back(SA[i]);
sort(v.begin(), v.end());
int ans = INF;
for (int i = (q.k - 1); i <= (((int)v.size()) - 1); i++)
ans = min(ans, v[i] - v[i - q.k + 1] + 1);
Ans[q.id] = ans + q.sz - 1;
}
for (int q = (1); q <= (Q); q++) cout << Ans[q] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100010;
long long cf[Maxn], my_hash[Maxn];
char s[Maxn];
int len, n, m;
long long M[Maxn];
int K[Maxn], ans[Maxn];
vector<int> q[Maxn];
vector<int> vec[Maxn];
map<long long, int> mp;
int _min(int x, int y) { return x < y ? x : y; }
int main() {
int i, j, k;
scanf("%s", s + 1);
n = strlen(s + 1);
cf[0] = 1;
for (i = 1; i <= n; i++) cf[i] = cf[i - 1] * 100013;
for (i = 1; i <= n; i++)
my_hash[i] = my_hash[i - 1] * 100013 + s[i] - 'a' + 1;
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d%s", &K[i], s + 1);
len = strlen(s + 1);
for (j = 1; j <= len; j++) M[i] = M[i] * 100013 + s[j] - 'a' + 1;
q[len].push_back(i);
}
for (i = 1; i <= n; i++) {
if (q[i].size() == 0) continue;
mp.clear();
for (j = 0; j < q[i].size(); j++) {
mp[M[q[i][j]]] = j;
vec[j].clear();
}
for (j = 1; j <= n - i + 1; j++) {
long long x = my_hash[j + i - 1] - my_hash[j - 1] * cf[i];
if (mp.count(x)) vec[mp[x]].push_back(j);
}
for (j = 0; j < q[i].size(); j++) {
if (vec[j].size() < K[q[i][j]]) {
ans[q[i][j]] = -1;
continue;
}
ans[q[i][j]] = n + 1;
for (k = 0; k <= vec[j].size() - K[q[i][j]]; k++)
ans[q[i][j]] =
_min(ans[q[i][j]], vec[j][k + K[q[i][j]] - 1] - vec[j][k] + i);
}
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct tn {
tn *c[26], *f, *s;
unsigned long long id;
};
template <size_t S>
struct pool_t {
tn* p;
unsigned long long s;
pool_t() {
p = (tn*)calloc(S, sizeof(tn));
s = 0;
}
tn* get() { return p + (s++); }
~pool_t() { free(p); }
};
pool_t<100000> pool;
struct aca_t {
tn* r;
aca_t() : r(0) {}
tn* get() { return pool.get(); }
void build(const vector<string>& sv) {
r = get();
for (int i = 0; i != sv.size(); ++i) {
tn* p = r;
for (const char& ch : sv[i]) {
int o = ch - 'a';
if (!p->c[o]) p->c[o] = get();
p = p->c[o];
}
p->id = i + 1;
}
queue<tn*> q;
for (tn*& v : r->c) v ? q.push(v), v->f = r : v = r;
while (q.size()) {
tn* u = q.front();
q.pop();
for (int o = 0; o != 26; ++o) {
tn *&v = u->c[o], *f = u->f->c[o];
if (v) {
v->f = f;
v->s = v->f->id ? v->f : v->f->s;
q.push(v);
} else
v = f;
}
}
}
void match(string t, vector<vector<int>>& res) {
tn* p = r;
for (int i = 0; i != t.size(); ++i) {
p = p->c[t[i] - 'a'];
for (tn* w = p; w; w = w->s)
if (w->id) res[w->id - 1].push_back(i);
}
}
};
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
aca_t aca;
string t;
cin >> t;
int n;
cin >> n;
vector<int> kv;
vector<string> sv;
for (int i = 0; i != n; ++i) {
int k;
string s;
cin >> k >> s;
kv.push_back(k);
sv.push_back(s);
}
aca.build(sv);
vector<vector<int>> res;
res.resize(n);
aca.match(t, res);
vector<int> ans;
for (int i = 0; i != n; ++i) {
int k = kv[i];
if (res[i].size() < k)
ans.push_back(-1);
else {
int d = ~(1 << 31);
for (int j = 0; j != res[i].size(); ++j)
if (j >= k - 1) d = min(d, res[i][j] - res[i][j - k + 1]);
ans.push_back(d + sv[i].size());
}
}
for (int d : ans) cout << d << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005, C = 26;
int n, q;
char s[N], ch[N];
int qk[N], qn[N];
vector<int> a[N];
int tt = 1;
struct Node {
int idx, fa, p;
int ch[26];
} p[N];
void Insert(int k, char *ch, int x) {
if (!*ch) {
p[k].idx = x;
return;
}
int c = *ch - 97;
if (!p[k].ch[c]) p[k].ch[c] = ++tt;
Insert(p[k].ch[c], ch + 1, x);
return;
}
queue<int> que;
void Build(int rt) {
for (int i = 0, v; i < C; ++i)
if (v = p[rt].ch[i]) {
p[v].fa = rt;
p[v].p = p[v].idx ? v : 0;
que.push(v);
} else
p[rt].ch[i] = rt;
while (!que.empty()) {
int u = que.front();
que.pop();
for (int i = 0, v; i < C; ++i)
if (v = p[u].ch[i]) {
p[v].fa = p[p[u].fa].ch[i];
p[v].p = p[v].idx ? v : p[p[v].fa].p;
que.push(v);
} else
p[u].ch[i] = p[p[u].fa].ch[i];
}
return;
}
void Add(int k, int r) {
for (; k = p[k].p; k = p[k].fa) a[p[k].idx].push_back(r);
return;
}
int Query(int x) {
int k = qk[x];
if (a[x].size() < k) return -1;
int ret = n;
for (int i = 0; i + k - 1 < a[x].size(); ++i)
ret = min(ret, a[x][i + k - 1] - a[x][i] + qn[x]);
return ret;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
scanf("%d", &q);
int rt = 1;
for (int i = 1; i <= q; ++i) {
scanf("%d%s", &qk[i], ch);
qn[i] = strlen(ch);
Insert(rt, ch, i);
}
Build(rt);
for (int i = 1, k = rt; i <= n; ++i) {
k = p[k].ch[s[i] - 97];
Add(k, i);
}
for (int i = 1; i <= q; ++i) printf("%d\n", Query(i));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1) * 4;
const int MAXN = 1e5 + 20;
const int A = 27;
const int P = 100020;
const int T = 100020;
string t, patterns[P];
int p;
int cnt[T];
int cont[T];
vector<int> ocurr[T];
inline int convert(char ch) {
return ((ch >= 'a' && ch <= 'z') ? ch - 'a' : ch - 'A' + 26) + 1;
}
struct node {
node* next[A];
vector<int> out;
bool done = false;
node() { memset(next, NULL, sizeof next); }
~node() {
for (int i = 0; i < (int)A; ++i)
if (next[i]) delete next[i];
}
};
node* build() {
node *root = new node(), *now;
root->next[0] = root;
int idx;
for (int i = 0; i < (int)p; ++i) {
now = root;
for (auto& x : patterns[i]) {
idx = convert(x);
if (!now->next[idx]) now->next[idx] = new node();
now = now->next[idx];
}
now->out.push_back(i);
}
queue<node*> q;
for (int i = (int)1; i <= (int)A - 1; ++i) {
if (!root->next[i])
root->next[i] = root;
else {
root->next[i]->next[0] = root;
q.push(root->next[i]);
}
}
while (!q.empty()) {
now = q.front();
q.pop();
for (int i = (int)1; i <= (int)A - 1; ++i) {
if (now->next[i]) {
node* next = now->next[0];
while (!next->next[i]) next = next->next[0];
now->next[i]->next[0] = next->next[i];
q.push(now->next[i]);
for (auto& x : next->next[i]->out) now->next[i]->out.push_back(x);
}
}
}
return root;
}
void match(node* n) {
int idx, tmp;
for (int i = 0; i < (int)t.size(); ++i) {
idx = convert(t[i]);
while (!n->next[idx]) n = n->next[0];
n = n->next[idx];
for (auto& x : n->out) {
++cnt[(x)];
ocurr[x].push_back(i);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> t >> p;
for (int i = 0; i < (int)p; ++i) cin >> cont[i] >> patterns[i];
for (int i = 0; i < (int)p; ++i) cnt[i] = false;
match(build());
for (int i = 0; i < (int)p; ++i) {
int longitud = 1e6;
if (cont[i] == 1 && ocurr[i].size()) {
cout << patterns[i].size() << '\n';
continue;
}
for (int j = cont[i] - 1; j < ocurr[i].size(); ++j) {
longitud = min(longitud, ocurr[i][j] - ocurr[i][j - (cont[i] - 1)] +
int(patterns[i].size()));
}
if (longitud == 1e6)
cout << -1 << '\n';
else
cout << longitud << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using ll = long long;
const int INF = 1e9;
const int K = 26;
struct Vertex {
int next[K];
bool terminal = false;
int p = -1;
char pch;
int suf_link = -1;
int exit_link = -1;
int go[K];
vi occurrences;
Vertex(int p = -1, char ch = '$') : p(p), pch(ch) {
fill(begin(next), end(next), -1);
fill(begin(go), end(go), -1);
}
};
vector<Vertex> t;
void aho_init() {
t.clear();
t.emplace_back(Vertex());
}
void add_string(string const &s) {
int v = 0;
for (char ch : s) {
int c = ch - 'a';
if (t[v].next[c] == -1) {
t[v].next[c] = int((t).size());
t.emplace_back(v, ch);
}
v = t[v].next[c];
}
t[v].terminal = true;
}
int go(int v, char ch);
int get_suf_link(int v) {
if (t[v].suf_link == -1) {
if (v == 0 || t[v].p == 0)
t[v].suf_link = 0;
else
t[v].suf_link = go(get_suf_link(t[v].p), t[v].pch);
}
return t[v].suf_link;
}
int get_exit_link(int v) {
if (t[v].exit_link == -1) {
if (v == 0 || t[v].p == 0)
t[v].exit_link = 0;
else {
int u = get_suf_link(v);
t[v].exit_link = t[u].terminal ? u : get_exit_link(u);
}
}
return t[v].exit_link;
}
int go(int v, char ch) {
int c = ch - 'a';
if (t[v].go[c] == -1) {
if (t[v].next[c] != -1)
t[v].go[c] = t[v].next[c];
else
t[v].go[c] = v == 0 ? 0 : go(get_suf_link(v), ch);
}
return t[v].go[c];
}
void traverse(string &s) {
int n = int((s).size());
int v = 0;
for (int i = int(0); i < int(n); i++) {
char ch = s[i];
v = go(v, ch);
int u = v;
if (t[u].terminal) t[u].occurrences.emplace_back(i);
while (u != 0) {
u = get_exit_link(u);
t[u].occurrences.emplace_back(i);
}
}
}
vi &query(string &m) {
int v = 0;
for (char ch : m) {
int c = ch - 'a';
v = t[v].next[c];
}
return t[v].occurrences;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = int((s).size());
int q;
cin >> q;
vector<pair<int, string>> queries(q);
for (auto &[k, m] : queries) cin >> k >> m;
aho_init();
for (auto &[_, m] : queries) add_string(m);
traverse(s);
for (auto &[k, m] : queries) {
int ans = INF;
vi &occurrences = query(m);
for (int i = int(0); i < int(int((occurrences).size()) - k + 1); i++) {
int j = i + k - 1;
int left = occurrences[i], right = occurrences[j] + int((m).size());
ans = min(ans, right - left);
}
cout << (ans == INF ? -1 : ans) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210000;
const int maxp = maxn * 30;
int n, m;
char str[maxn], sq[maxn];
struct SAM {
int root, last, tot;
int son[maxn][26], par[maxn], c[maxn];
void init() { root = last = tot = 1; }
int newnode(int l) {
c[++tot] = l;
memset(son[tot], 0, sizeof son[tot]);
par[tot] = 0;
return tot;
}
void extend(const int w) {
int p = last, np = newnode(c[p] + 1);
while (!son[p][w] && p) son[p][w] = np, p = par[p];
if (p) {
int q = son[p][w];
if (c[q] == c[p] + 1)
par[np] = q;
else {
int nq = newnode(c[p] + 1);
memcpy(son[nq], son[q], sizeof son[nq]);
par[nq] = par[q];
par[q] = par[np] = nq;
while (p && son[p][w] == q) son[p][w] = nq, p = par[p];
}
} else
par[np] = root;
last = np;
}
} sam;
int t[maxn], tp;
struct Segment {
int cnt;
int seg[maxp], lc[maxp], rc[maxp];
int loc;
int newnode() {
++cnt;
seg[cnt] = lc[cnt] = rc[cnt] = 0;
return cnt;
}
void upd(int &x, const int l, const int r) {
seg[x = newnode()] = 1;
if (l == r) return;
int mid = l + r >> 1;
if (loc <= mid)
upd(lc[x], l, mid);
else
upd(rc[x], mid + 1, r);
}
void merge(int &x, const int y) {
if (!y) return;
if (!x) {
x = y;
return;
}
int k = x;
x = newnode();
seg[x] = seg[k] + seg[y];
lc[x] = lc[k], rc[x] = rc[k];
merge(lc[x], lc[y]);
merge(rc[x], rc[y]);
}
void query(int x, const int l, const int r) {
if (!x) return;
if (l == r) {
t[++tp] = l;
return;
}
int mid = l + r >> 1;
query(lc[x], l, mid);
query(rc[x], mid + 1, r);
}
} seg;
int root[maxn];
vector<int> V[maxn];
int main() {
scanf("%s", str + 1);
n = strlen(str + 1);
sam.init();
for (int i = 1; i <= n; i++) {
sam.extend(str[i] - 'a');
seg.loc = i;
seg.upd(root[sam.last], 1, n);
}
for (int i = 1; i <= sam.tot; i++) V[sam.c[i]].push_back(i);
for (int i = n; i >= 1; i--) {
for (int j = 0; j < (int)V[i].size(); j++) {
int x = V[i][j];
if (sam.par[x]) {
int ff = sam.par[x];
seg.merge(root[ff], root[x]);
}
}
}
scanf("%d", &m);
while (m--) {
int ki;
scanf("%d", &ki);
scanf("%s", sq + 1);
int len = strlen(sq + 1);
int x = sam.root;
for (int j = 1; j <= len; j++) {
int w = sq[j] - 'a';
x = sam.son[x][w];
}
if (!x || seg.seg[root[x]] < ki) {
puts("-1");
continue;
}
tp = 0;
seg.query(root[x], 1, n);
int ans = n;
for (int i = ki; i <= tp; i++) ans = min(ans, t[i] - t[i - ki + 1] + 1);
printf("%d\n", ans + len - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 26;
struct Vertex {
char pch;
int next[K];
int p = -1;
int suff = -1;
int dfsin;
int dfsout;
int is_leaf = -1;
int nearest_leaf = -1;
bool visited = false;
vector<int> rsuff;
Vertex(int p = -1, char ch = '$') : p(p), pch(ch) {
rsuff.clear();
fill(begin(next), end(next), -1);
}
};
vector<Vertex> t(1);
int timer;
void add_string(string s, int id) {
int v = 0;
for (char ch : s) {
int c = ch - 'a';
if (t[v].next[c] == -1) {
t[v].next[c] = t.size();
t.emplace_back(v, ch);
}
v = t[v].next[c];
}
t[v].is_leaf = id;
}
int go(int v, char ch);
int get_suff(int v) {
if (t[v].suff == -1) {
if (v == 0 || t[v].p == 0) {
t[v].suff = 0;
if (v != 0) t[t[v].suff].rsuff.push_back(v);
} else {
t[v].suff = go(get_suff(t[v].p), t[v].pch);
if (v != 0) t[t[v].suff].rsuff.push_back(v);
}
}
return t[v].suff;
}
int go(int v, char ch) {
int c = ch - 'a';
if (t[v].next[c] != -1) return t[v].next[c];
if (v == 0) return t[v].next[c] = 0;
return t[v].next[c] = go(get_suff(v), ch);
}
void dfs(int u) {
timer++;
t[u].dfsin = timer;
t[u].visited = true;
if (t[u].is_leaf != -1)
t[u].nearest_leaf = u;
else
t[u].nearest_leaf = t[t[u].suff].nearest_leaf;
for (auto v : t[u].rsuff) dfs(v);
timer++;
t[u].dfsout = timer;
}
void buildAC(vector<string> patterns) {
for (int i = 0; i < patterns.size(); i++) add_string(patterns[i], i);
for (int i = 0; i < t.size(); i++)
if (t[i].suff == -1) {
int x = get_suff(i);
}
for (int i = 0; i < t.size(); i++)
if (t[i].visited == false) dfs(i);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string text;
cin >> text;
int n;
cin >> n;
vector<int> k(n + 1);
vector<string> patterns(n + 1);
for (int i = 1; i <= n; i++) cin >> k[i] >> patterns[i];
buildAC(patterns);
vector<int> app[n + 10];
for (int i = 0; i < n; i++) app[i].clear();
vector<int> ans(n + 1, -1);
int v = 0;
for (int i = 0; i < text.size(); i++) {
v = go(v, text[i]);
int cur = v;
while (1) {
if (cur == 0) break;
int id = t[t[cur].nearest_leaf].is_leaf;
if (id == -1) break;
int l = patterns[id].size();
app[id].push_back(i - l + 1);
if (app[id].size() >= k[id]) {
int st = app[id][app[id].size() - k[id]];
if (ans[id] == -1)
ans[id] = i - st + 1;
else
ans[id] = min(ans[id], i - st + 1);
}
cur = t[t[cur].nearest_leaf].suff;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long SIGMA = 26;
struct ac_node {
long long pch;
long long p = -1;
long long link = -1;
long long out_link = -1;
long long leaf = -1;
vector<long long> next;
ac_node(long long P = -1, long long PCH = -1) {
p = P, pch = PCH;
next = vector<long long>(SIGMA, -1);
}
};
struct AhoCora {
vector<ac_node> tr;
AhoCora() { tr.emplace_back(-1, -1); }
void insert_string(string &s, long long idx) {
long long v = 0, i = 0;
long long ch;
while (i < s.length()) {
ch = s[i] - 'a';
if (tr[v].next[ch] != -1) {
v = tr[v].next[ch];
} else {
tr.emplace_back(v, ch);
tr[v].next[ch] = tr.size() - 1;
v = tr.size() - 1;
}
i++;
}
tr[v].leaf = idx;
}
void construct_links(long long v) {
if (!v) {
tr[v].link = 0;
tr[v].out_link = 0;
return;
}
if (!tr[v].p) {
tr[v].link = 0;
if (tr[v].leaf != -1)
tr[v].out_link = v;
else
tr[v].out_link = 0;
return;
}
long long u = tr[tr[v].p].link;
long long ch = tr[v].pch;
while (true) {
if (tr[u].next[ch] != -1) {
tr[v].link = tr[u].next[ch];
break;
}
if (!u) {
tr[v].link = 0;
break;
}
u = tr[u].link;
}
if (tr[v].leaf != -1)
tr[v].out_link = v;
else
tr[v].out_link = tr[tr[v].link].out_link;
}
void build() {
queue<long long> q;
q.push(0);
while (!q.empty()) {
long long v = q.front();
q.pop();
construct_links(v);
for (long long i = 0; i < SIGMA; ++i) {
if (tr[v].next[i] != -1) q.push(tr[v].next[i]);
}
}
}
void pattern_matching(string &t, vector<vector<long long>> &matches) {
long long m = t.length();
long long v = 0, ch;
for (long long i = 0; i < m; ++i) {
ch = t[i] - 'a';
while (true) {
if (tr[v].next[ch] != -1) {
v = tr[v].next[ch];
break;
}
if (!v) break;
v = tr[v].link;
}
long long u = v;
while (true) {
u = tr[u].out_link;
if (!u) break;
assert(tr[u].leaf != -1);
matches[tr[u].leaf].push_back(i);
u = tr[u].link;
}
}
}
};
int32_t main() {
string s;
cin >> s;
long long n;
cin >> n;
AhoCora T;
vector<vector<long long>> matches(n);
vector<long long> k(n);
vector<long long> len(n);
for (long long i = 0; i < n; ++i) {
cin >> k[i];
string mi;
cin >> mi;
len[i] = mi.length();
T.insert_string(mi, i);
}
T.build();
T.pattern_matching(s, matches);
for (long long i = 0; i < n; ++i) {
if (matches[i].size() < k[i]) {
cout << -1 << '\n';
continue;
}
long long ans = INT_MAX;
for (long long j = k[i] - 1; j < matches[i].size(); ++j) {
ans = min(ans, matches[i][j] - matches[i][j - k[i] + 1] + len[i]);
}
cout << ans << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int ms = 1e5 + 10;
const int inf = 0x3f3f3f3f;
int trie[ms][26], sz = 0, link[ms], cnt[ms], save[ms];
vector<int> term[ms], fans[ms];
void insert(string s, int idx) {
int node = 0;
for (auto c : s) {
if (trie[node][c - 'a'] == -1) trie[node][c - 'a'] = ++sz;
node = trie[node][c - 'a'];
}
term[node].push_back(idx);
}
vector<int> m_merge(vector<int> &a, vector<int> &b) {
vector<int> ans(int(a.size()) + int(b.size()));
merge(a.begin(), a.end(), b.begin(), b.end(), ans.begin());
ans.resize(unique(ans.begin(), ans.end()) - ans.begin());
return ans;
}
void build_links() {
queue<int> q;
q.push(0);
link[0] = 0;
while (!q.empty()) {
int node = q.front();
q.pop();
for (int ch = 0; ch < 26; ch++) {
int &to = trie[node][ch];
int f = node == 0 ? 0 : trie[link[node]][ch];
if (to == -1) {
to = f;
} else {
link[to] = f;
q.push(to);
term[to] = m_merge(term[to], term[f]);
}
}
}
}
void search(string s) {
int node = 0;
for (int i = 0; i < s.size(); i++) {
node = trie[node][s[i] - 'a'];
for (auto v : term[node]) fans[v].push_back(i);
}
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
string s;
cin >> s;
int n, x;
cin >> n;
string t;
memset(trie, -1, sizeof trie);
for (int i = 0; i < n; i++) {
cin >> x >> t;
insert(t, i);
cnt[i] = x;
save[i] = t.size();
}
build_links();
search(s);
for (int i = 0; i < n; i++) {
int ff = inf;
for (int j = 0; j + cnt[i] - 1 < fans[i].size(); j++)
ff = min(ff, fans[i][j + cnt[i] - 1] - fans[i][j] + save[i]);
if (ff == inf) ff = -1;
cout << ff << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct trie {
vector<vector<int> > sons;
vector<int> val;
vector<pair<int, int> > son;
trie() {
sons.reserve(1000000);
son.reserve(1000000);
val.reserve(1000000);
sons.resize(1);
son.resize(1, make_pair(-1, -1));
val.resize(1, -1);
}
void put(string &s, int id) {
int akt = 0;
for (int i = 0; i < (int)s.length(); i++) {
if (sons[akt].empty() && son[akt].first == -1) {
son[akt] = make_pair(s[i] - 'a', son.size());
sons.push_back(vector<int>());
son.push_back(make_pair(-1, -1));
val.push_back(-1);
} else if (sons[akt].empty() && son[akt].first != s[i] - 'a') {
sons[akt].resize(26, -1);
sons[akt][son[akt].first] = son[akt].second;
sons[akt][s[i] - 'a'] = sons.size();
sons.push_back(vector<int>());
son.push_back(make_pair(-1, -1));
val.push_back(-1);
} else if (!sons[akt].empty() && sons[akt][s[i] - 'a'] == -1) {
sons[akt][s[i] - 'a'] = sons.size();
sons.push_back(vector<int>());
son.push_back(make_pair(-1, -1));
val.push_back(-1);
}
if (sons[akt].empty())
akt = son[akt].second;
else
akt = sons[akt][s[i] - 'a'];
}
val[akt] = id;
}
int move(int akt, int chr) {
if (sons[akt].empty())
return (son[akt].first == chr) ? son[akt].second : -1;
return sons[akt][chr];
}
int get(int akt) { return val[akt]; }
};
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
string S;
cin >> S;
int N = S.length(), Q, X = 200;
trie T;
cin >> Q;
vector<int> ans(Q, -2), occ(Q), len(Q);
for (int q = 0; q < Q; q++) {
string sm;
cin >> occ[q] >> sm;
int L = sm.length();
if (L < X) {
T.put(sm, q);
len[q] = L;
continue;
}
vector<int> prev(L + 1, 0);
for (int i = 2; i <= L; i++) {
prev[i] = prev[i - 1];
while (prev[i] > 0 && sm[prev[i]] != sm[i - 1]) prev[i] = prev[prev[i]];
if (sm[prev[i]] == sm[i - 1]) prev[i]++;
}
vector<int> pos_occ;
int pref = 0;
for (int i = 0; i < N; i++) {
while (pref > 0 && sm[pref] != S[i]) pref = prev[pref];
if (sm[pref] == S[i]) pref++;
if (pref == L) {
pref = prev[pref];
pos_occ.push_back(i);
}
}
ans[q] = N + 1000;
for (int i = occ[q] - 1; i < (int)pos_occ.size(); i++)
ans[q] = min(ans[q], pos_occ[i] - pos_occ[i - occ[q] + 1] + L);
if (ans[q] > N) ans[q] = -1;
}
vector<vector<int> > pos_occ(Q);
for (int i = 0; i < N; i++) {
int akt = 0;
for (int j = 0; j < X; j++) {
if (i + j == N) break;
akt = T.move(akt, S[i + j] - 'a');
if (akt == -1) break;
int x = T.get(akt);
if (x != -1) pos_occ[x].push_back(i);
}
}
for (int q = 0; q < Q; q++)
if (ans[q] == -2) {
ans[q] = N + 1000;
for (int i = occ[q] - 1; i < (int)pos_occ[q].size(); i++)
ans[q] =
min(ans[q], pos_occ[q][i] - pos_occ[q][i - occ[q] + 1] + len[q]);
if (ans[q] > N) ans[q] = -1;
}
for (int i = 0; i < Q; i++) cout << ans[i] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void cetak(T t) {
cout << t << ')' << endl;
}
template <typename T, typename... V>
void cetak(T t, V... v) {
cout << t;
if (sizeof...(v)) cerr << ", ";
cetak(v...);
}
const int MOD = 1e9 + 7;
const int mx = 1e5 + 10;
string ss, k[mx];
int n, m[mx];
vector<int> isi[mx];
const int N = 1e5 + 5;
struct AhoCorasick {
int trie[N][26];
int fail[N];
int saiz;
int apa[N];
AhoCorasick() {
memset(trie[0], -1, sizeof trie[0]);
saiz = 0;
}
void res() {
for (int i = 0; i <= saiz; i++) {
apa[i] = 0;
for (int j = 0; j < 26; j++) {
trie[i][j] = -1;
}
}
saiz = 0;
}
void add(string str, int id) {
int cur = 0;
for (int i = 0; i < str.length(); i++) {
int nex = str[i] - 'a';
if (trie[cur][nex] == -1) {
trie[cur][nex] = ++saiz;
memset(trie[saiz], -1, sizeof trie[saiz]);
}
cur = trie[cur][nex];
}
apa[cur] = id;
}
void build() {
queue<int> q;
fail[0] = 0;
for (int i = 0; i < 26; i++)
if (trie[0][i] == -1)
trie[0][i] = 0;
else {
int nex = trie[0][i];
fail[nex] = 0;
q.push(nex);
}
while (!q.empty()) {
int now = q.front();
q.pop();
for (int i = 0; i < 26; i++)
if (trie[now][i] == -1)
trie[now][i] = trie[fail[now]][i];
else {
int nex = trie[now][i];
fail[nex] = trie[fail[now]][i];
q.push(nex);
}
}
}
int getIndex(string str) {
int cur = 0;
for (int i = 0; i < str.length(); i++) {
cur = trie[cur][str[i] - 'a'];
}
return cur;
}
};
AhoCorasick ini;
vector<int> occurance[mx];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> ss >> n;
for (int i = 1; i <= n; i++)
cin >> m[i] >> k[i], isi[(int)(k[i].size())].push_back(i);
for (int i = 1; i <= (int)(ss.size()); i++) {
if ((int)(isi[i].size()) == 0) continue;
ini.res();
for (int j : isi[i]) ini.add(k[j], j);
ini.build();
int cur = 0;
for (int j = 0; j < (int)(ss.size()); j++) {
cur = ini.trie[cur][ss[j] - 'a'];
int x = ini.apa[cur];
if (x == 0) continue;
occurance[x].push_back(j);
}
}
for (int i = 1; i <= n; i++) {
if ((int)(occurance[i].size()) < m[i]) {
cout << -1 << '\n';
continue;
}
int jaw = 1e9;
for (int l = 0; l < (int)(occurance[i].size()); l++) {
int r = l + m[i] - 1;
if (r >= (int)(occurance[i].size())) break;
jaw = min(jaw, occurance[i][r] -
(occurance[i][l] - (int)(k[i].size()) + 1) + 1);
}
cout << jaw << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 9;
const long long maxn = 4e5 + 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 ans[maxn];
struct SAM {
int next[maxn][26], fail[maxn], len[maxn];
int cnt, last;
void init() {
cnt = last = 0;
fail[0] = -1;
len[0] = 0;
memset(next[0], 0, sizeof(next[0]));
}
void add(int c) {
int np = ++cnt, p = last;
memset(next[np], 0, sizeof(next[np]));
len[np] = len[p] + 1;
for (; p != -1 && !next[p][c]; p = fail[p]) next[p][c] = np;
if (p == -1)
fail[np] = 0;
else {
int q = next[p][c];
if (len[p] + 1 == len[q])
fail[np] = q;
else {
int nq = ++cnt;
len[nq] = len[p] + 1;
memcpy(next[nq], next[q], sizeof(next[q]));
fail[nq] = fail[q];
fail[np] = fail[q] = nq;
for (; p != -1 && next[p][c] == q; p = fail[p]) next[p][c] = nq;
}
}
last = np;
pos[last].push_back(len[np]);
}
int S[maxn], Q[maxn];
vector<int> pos[maxn];
vector<pair<int, int> > queries[maxn];
void solve() {
int t, i, j;
for (i = 1; i <= cnt; i++) S[i] = 0;
for (i = 1; i <= cnt; i++) S[len[i]]++;
for (i = 1; i <= cnt; i++) S[i] += S[i - 1];
for (i = 1; i <= cnt; i++) Q[S[len[i]]--] = i;
for (t = cnt; t >= 1; t--) {
i = Q[t];
map<int, int> MP;
if (queries[i].size()) stable_sort(pos[i].begin(), pos[i].end());
for (auto now : queries[i]) {
if ((int)pos[i].size() - now.first < 0)
ans[now.second] = -1;
else if (MP[now.first])
ans[now.second] += MP[now.first];
else {
int Ans = INF, len = (int)pos[i].size() - now.first + 1;
for (j = 0; j < len; j++)
Ans = min(Ans, pos[i][j + now.first - 1] - pos[i][j]);
MP[now.first] = Ans;
ans[now.second] += Ans;
}
}
int k = fail[i];
if (pos[k].size() < pos[i].size()) pos[k].swap(pos[i]);
for (int v : pos[i]) pos[k].push_back(v);
vector<int>().swap(pos[i]);
}
}
void query(char a[], int k, int pos) {
int i;
long long ret = 0;
int n = strlen(a), p = 0;
for (i = 0; i < n; i++) {
int c = a[i] - 'a';
if (next[p][c])
p = next[p][c];
else {
ans[pos] = -1;
return;
}
}
queries[p].push_back(make_pair(k, pos));
}
void print() {
int i;
for (i = 1; i <= cnt; i++) {
}
}
char a[maxn];
void dfs(int x = 0, int len = 0) {
int i;
printf("%-3d(fail:%-3d,len=%-2d pos=%-2d):%s;\n", x, fail[x], this->len[x],
x ? pos[x][0] : 0, a);
for (i = 0; i < 26; i++) {
if (next[x][i]) {
a[len] = i + 'a';
dfs(next[x][i], len + 1);
a[len] = 0;
}
}
}
} sam;
int n, q;
char A[maxn];
int main() {
int i, j, k;
scanf("%s", A);
n = strlen(A);
sam.init();
for (i = 0; i < n; i++) sam.add(A[i] - 'a');
scanf("%d", &q);
for (i = 0; i < q; i++) {
int k;
scanf("%d%s", &k, A);
ans[i] = strlen(A);
sam.query(A, k, i);
}
sam.solve();
for (i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> matches[100000];
class AhoCorasick {
private:
int next[100100][26], fail[100100];
vector<pair<int, int> > out[100100];
int root, state_cnt = 0;
int new_state() {
fill(next[state_cnt], next[state_cnt] + 26, -1);
return state_cnt++;
}
public:
AhoCorasick() { root = new_state(); }
void insertKeyword(const char* keyword, int id) {
int len = strlen(keyword);
int state = root;
int symbol;
for (int i = 0; i < len; i++) {
symbol = keyword[i] - 'a';
if (next[state][symbol] == -1) next[state][symbol] = new_state();
state = next[state][symbol];
}
out[state].push_back(pair<int, int>(id, len));
}
void match(const char* text) {
int len = strlen(text), state = root;
for (int i = 0; i < len; i++) {
char symbol = text[i] - 'a';
while (next[state][symbol] == -1) state = fail[state];
state = next[state][symbol];
for (pair<int, int> output : out[state]) {
matches[output.first].push_back(i - output.second + 1);
}
}
}
void build_failure_function() {
queue<int> q;
for (int i = 0; i < 26; i++) {
if (next[0][i] == -1) next[0][i] = 0;
if (next[0][i] != 0) {
q.push(next[0][i]);
fail[next[0][i]] = 0;
}
}
while (!q.empty()) {
int r = q.front();
q.pop();
for (int a = 0; a < 26; a++) {
int s = next[r][a];
if (s == -1) continue;
q.push(s);
int state = fail[r];
while (next[state][a] == -1) state = fail[state];
fail[s] = next[state][a];
for (pair<int, int> output : out[fail[s]]) {
out[s].push_back(output);
}
}
}
}
} ac;
int main() {
int n, k[100000], size[100000];
char s[100000 + 1], m[100000 + 1];
scanf("%s", s);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %s", &k[i], m);
size[i] = strlen(m);
ac.insertKeyword(m, i);
}
ac.build_failure_function();
ac.match(s);
for (int i = 0; i < n; i++) {
if (matches[i].size() < k[i]) {
printf("-1\n");
continue;
}
int result = 100000;
for (int j = 0; j <= matches[i].size() - k[i]; j++) {
result = min(result, matches[i][j + k[i] - 1] - matches[i][j]);
}
printf("%d\n", result + size[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long MOD = 1e9 + 9;
unsigned long long Hash[100011];
unsigned long long P = 29;
unsigned long long p_pow[100011];
const int MAXN = 1e5 + 5;
int n;
int q;
string s;
vector<int> poses[100001];
int k[100001];
string strs[100001];
vector<int> queries[100001];
map<unsigned long long, int> have;
inline void solve(int x) {
for (int i = 0; i < queries[x].size(); i++) {
unsigned long long _Hash = 0;
string cur = strs[queries[x][i]];
for (int j = 1; j <= x; j++) {
_Hash += (unsigned long long)(cur[j - 1] - 'a' + 1) * p_pow[j];
}
_Hash *= p_pow[MAXN - x];
have[_Hash] = queries[x][i];
}
for (int i = 1; i <= n - x + 1; i++) {
unsigned long long tmp = (Hash[i + x - 1] - Hash[i - 1]);
tmp *= p_pow[MAXN - (i + x - 1)];
if (have.count(tmp)) poses[have[tmp]].push_back(i);
}
have.clear();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> s;
n = s.length();
p_pow[0] = 1;
for (int i = 1; i <= MAXN; i++) p_pow[i] = p_pow[i - 1] * P;
for (int i = 1; i <= n; i++) {
Hash[i] = Hash[i - 1] + (unsigned long long)(s[i - 1] - 'a' + 1) * p_pow[i];
}
cin >> q;
for (int i = 1; i <= q; i++) {
cin >> k[i];
cin >> strs[i];
queries[strs[i].length()].push_back(i);
}
for (int i = 1; i <= n; i++)
if (queries[i].size() > 0) {
solve(i);
}
for (int i = 1; i <= q; i++) {
if (poses[i].size() < k[i]) {
cout << -1 << '\n';
continue;
}
int len = 2e9;
int cur;
for (int j = k[i] - 1; j < poses[i].size(); j++) {
cur = poses[i][j] + (int)strs[i].size() - poses[i][j - k[i] + 1];
if (cur < len) len = cur;
}
cout << len << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int MAXCHAR = 26;
struct Vertex {
int next[MAXCHAR], go[MAXCHAR];
int leaf = -1;
int p = -1;
char pch;
int link = -1, leaflink = -1;
Vertex(int p = -1, char ch = '$') : p(p), pch(ch) {
fill(begin(next), end(next), -1);
fill(begin(go), end(go), -1);
}
};
vector<Vertex> trie(1);
void add_string(string const &s, int idx) {
int v = 0;
for (char ch : s) {
int c = ch - 'a';
if (trie[v].next[c] == -1) {
trie[v].next[c] = trie.size();
trie.emplace_back(v, ch);
}
v = trie[v].next[c];
}
trie[v].leaf = idx;
}
int go(int v, char ch);
int get_link(int v) {
if (trie[v].link == -1) {
if (v == 0 || trie[v].p == 0)
trie[v].link = 0;
else
trie[v].link = go(get_link(trie[v].p), trie[v].pch);
get_link(trie[v].link);
trie[v].leaflink = (trie[trie[v].link].leaf != -1)
? trie[v].link
: trie[trie[v].link].leaflink;
}
return trie[v].link;
}
int go(int v, char ch) {
int c = ch - 'a';
if (trie[v].go[c] == -1) {
if (trie[v].next[c] != -1)
trie[v].go[c] = trie[v].next[c];
else
trie[v].go[c] = v == 0 ? 0 : go(get_link(v), ch);
}
return trie[v].go[c];
}
string S;
int N;
int K[MAXN];
string M[MAXN];
vector<int> results[MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> S;
cin >> N;
for (int i = 0; i < N; i++) {
cin >> K[i];
cin >> M[i];
add_string(M[i], i);
}
for (int i = 1; i < trie.size(); i++) get_link(i);
int v = 0;
for (int i = 0; i < S.size(); i++) {
v = go(v, S[i]);
int cur = v;
while (cur != -1) {
if (trie[cur].leaf != -1) results[trie[cur].leaf].push_back(i);
cur = trie[cur].leaflink;
}
}
for (int i = 0; i < N; i++) {
int minLength = 1 << 30;
for (int j = K[i]; j <= results[i].size(); j++) {
minLength = min(minLength, results[i][j - 1] - results[i][j - K[i]]);
}
if (minLength == 1 << 30) {
cout << -1 << endl;
} else {
cout << minLength + M[i].size() << endl;
}
}
}
|
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using namespace std;
const int N = 1e5 + 3;
string s, m[N];
int n, k[N], link[N];
vector<int> appear[N], occ[N];
struct Trie {
int ackjalscjaowjico[26], p, pch;
} trie[N];
void add() {
int nNode = 0;
for (int i = (1); i <= (n); ++i) {
int u = 0, j = 0;
while (j < ((int)(m[i]).size()) &&
trie[u].ackjalscjaowjico[m[i][j] - 'a'] != -1)
u = trie[u].ackjalscjaowjico[m[i][j] - 'a'], j++;
while (j < ((int)(m[i]).size())) {
trie[u].ackjalscjaowjico[m[i][j] - 'a'] = ++nNode;
trie[nNode].p = u;
trie[nNode].pch = m[i][j] - 'a';
u = nNode;
j++;
}
appear[u].push_back(i);
}
}
void build_link() {
queue<int> q;
link[0] = -1;
for (int i = (0); i <= (25); ++i)
if (trie[0].ackjalscjaowjico[i] != -1) q.push(trie[0].ackjalscjaowjico[i]);
while (!q.empty()) {
int u = q.front();
q.pop();
int p = link[trie[u].p], c = trie[u].pch;
while (p >= 0 && trie[p].ackjalscjaowjico[c] == -1) p = link[p];
if (p == -1)
link[u] = 0;
else {
link[u] = trie[p].ackjalscjaowjico[c];
for (int v : appear[link[u]]) appear[u].push_back(v);
}
for (int i = (0); i <= (25); ++i)
if (trie[u].ackjalscjaowjico[i] != -1)
q.push(trie[u].ackjalscjaowjico[i]);
}
}
void find_occ() {
int u = 0;
for (int i = (0); i <= (((int)(s).size()) - 1); ++i) {
while (u >= 0 && trie[u].ackjalscjaowjico[s[i] - 'a'] == -1) u = link[u];
if (u == -1)
u = 0;
else {
u = trie[u].ackjalscjaowjico[s[i] - 'a'];
for (int v : appear[u]) occ[v].push_back(i - ((int)(m[v]).size()) + 1);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
for (int i = (0); i <= (N - 3); ++i)
fill(trie[i].ackjalscjaowjico, trie[i].ackjalscjaowjico + 26, -1);
cin >> s >> n;
for (int i = (1); i <= (n); ++i) cin >> k[i] >> m[i];
add();
build_link();
find_occ();
for (int i = (1); i <= (n); ++i) {
if (((int)(occ[i]).size()) < k[i])
cout << "-1\n";
else {
int ans = ((int)(s).size());
for (int j = 0; j <= ((int)(occ[i]).size()) - k[i]; j++)
ans = min(ans, occ[i][j + k[i] - 1] + ((int)(m[i]).size()) - occ[i][j]);
cout << ans << '\n';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000009LL;
long long large = 2000000000000000000LL;
vector<vector<int> > pos;
class AC {
public:
int sz;
vector<int> val, f, last;
vector<vector<int> > ch;
int sigma_size;
AC(int maxnode, int _sigma_size) {
sz = 1;
ch.assign(maxnode, vector<int>(_sigma_size, -1));
val.assign(maxnode, 0);
f.assign(maxnode, 0);
last.assign(maxnode, 0);
sigma_size = _sigma_size;
}
int idx(char c) { return c - 'a'; }
void insert(string s, int v) {
int u = 0, n = (int)s.length();
for (int i = 0; i < n; i++) {
int c = idx(s[i]);
if (ch[u][c] == -1) {
val[sz] = 0;
ch[u][c] = sz++;
}
u = ch[u][c];
}
val[u] = v;
}
bool search(string s, int v) {
int u = 0, n = (int)s.length();
for (int i = 0; i < n; i++) {
int c = idx(s[i]);
if (ch[u][c] == -1) {
return false;
}
u = ch[u][c];
}
if (val[u] != v) return false;
return true;
}
void getFail() {
queue<int> q;
f[0] = 0;
for (int c = 0; c < sigma_size; c++) {
int u = ch[0][c];
if (u != -1) {
f[u] = 0;
q.push(u);
last[u] = 0;
}
}
while (!q.empty()) {
int r = q.front();
q.pop();
for (int c = 0; c < sigma_size; c++) {
int u = ch[r][c];
if (u == -1) continue;
q.push(u);
int v = f[r];
while (v && ch[v][c] == -1) v = f[v];
f[u] = ch[v][c];
if (f[u] == -1) f[u] = 0;
last[u] = val[f[u]] ? f[u] : last[f[u]];
}
}
}
void find(string &t) {
int n = (int)t.length();
int j = 0;
for (int i = 0; i < n; i++) {
int c = idx(t[i]);
while (j && ch[j][c] == -1) j = f[j];
j = ch[j][c];
if (j == -1) j = 0;
if (val[j]) {
print(i, j);
} else {
if (last[j]) {
print(i, last[j]);
}
}
}
}
void print(int i, int j) {
if (j) {
pos[val[j] - 1].push_back(i);
print(i, last[j]);
}
}
void clear() {
sz = 1;
ch.clear();
val.clear();
f.clear();
last.clear();
}
void assign(int x, int y) {
sz = 1;
ch.assign(x + 10, vector<int>(y + 10, -1));
val.assign(x + 10, 0);
f.assign(x + 10, 0);
last.assign(x + 10, 0);
}
};
int main() {
string s;
cin >> s;
int q;
cin >> q;
vector<vector<int> > adj;
vector<string> w(q, "");
vector<int> k(q, 0);
adj.assign(100010, vector<int>());
for (int i = 0; i < q; i++) {
scanf("%d", &k[i]);
cin >> w[i];
adj[(int)w[i].length()].push_back(i);
}
pos.assign(q, vector<int>());
for (int l = 1; l <= (int)s.length(); l++) {
if (adj[l].size() == 0) continue;
int sz = 0;
for (int j = 0; j < (int)adj[l].size(); j++)
sz += (int)w[adj[l][j]].length();
AC ac(sz + 10, 26);
for (int j = 0; j < (int)adj[l].size(); j++) {
int p = adj[l][j];
ac.insert(w[p], p + 1);
}
ac.getFail();
ac.find(s);
}
for (int i = 0; i < q; i++) {
int ans = 1000000000;
for (int j = 0; j + k[i] - 1 < (int)pos[i].size(); j++) {
ans = min(ans, pos[i][j + k[i] - 1] - pos[i][j] + (int)w[i].length());
}
if (ans == 1000000000) ans = -1;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char str[100001];
struct tn {
tn *c[26], *f, *s;
vector<unsigned> p;
unsigned l, i, sz;
} ns[100001], *np;
struct aca_t {
tn* r;
aca_t() { np = ns; }
tn* gn() { return np++; }
void build(unsigned n) {
r = gn();
for (unsigned i = 0; i != n; ++i) {
tn* p = r;
unsigned l;
string t;
cin >> l >> t;
for (const char& ch : t) {
unsigned o = ch - 'a';
if (!p->c[o]) p->c[o] = gn();
p = p->c[o];
}
p->l = l;
p->i = i;
p->sz = t.size();
}
queue<tn*> q;
for (tn*& v : r->c) v ? q.push(v), v->f = r : v = r;
while (!q.empty()) {
tn* u = q.front();
q.pop();
for (unsigned o = 0; o != 26; ++o) {
tn *&v = u->c[o], *f = u->f->c[o];
if (v) {
v->f = f;
q.push(v);
if (f->sz)
v->s = f;
else
v->s = f->s;
} else
v = f;
}
}
}
void match(char* s) {
tn* p = r;
for (unsigned i = 0; s[i]; ++i) {
unsigned o = s[i] - 'a';
p = p->c[o];
for (tn* w = p; w; w = w->s) w->p.push_back(i);
}
}
} aca;
unsigned ans[100001];
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> str;
unsigned n;
cin >> n;
aca.build(n);
aca.match(str);
memset(ans, 0xff, sizeof(ans));
for (tn* p = ns; p != np; ++p) {
if (p->l && p->p.size() >= p->l) {
for (unsigned i = 0; i <= p->p.size() - p->l; ++i)
ans[p->i] = min(ans[p->i], p->p[i + p->l - 1] - p->p[i]);
ans[p->i] += p->sz;
}
}
for (unsigned i = 0; i != n; ++i) cout << (int)ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f3f3f3f3f3f3fll;
const long long M = 1e9 + 9;
const long long maxn = 4e5 + 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 ans[maxn];
struct SAM {
int next[maxn][26], fail[maxn], len[maxn];
int cnt, last;
void init() {
cnt = last = 0;
fail[0] = -1;
len[0] = 0;
memset(next[0], 0, sizeof(next[0]));
}
void add(int c) {
int np = ++cnt, p = last;
memset(next[np], 0, sizeof(next[np]));
len[np] = len[p] + 1;
for (; p != -1 && !next[p][c]; p = fail[p]) next[p][c] = np;
if (p == -1)
fail[np] = 0;
else {
int q = next[p][c];
if (len[p] + 1 == len[q])
fail[np] = q;
else {
int nq = ++cnt;
len[nq] = len[p] + 1;
memcpy(next[nq], next[q], sizeof(next[q]));
fail[nq] = fail[q];
fail[np] = fail[q] = nq;
for (; p != -1 && next[p][c] == q; p = fail[p]) next[p][c] = nq;
}
}
last = np;
pos[last].insert(len[np]);
}
int S[maxn], Q[maxn];
set<int> pos[maxn];
vector<pair<int, int> > queries[maxn];
void solve() {
int t, i, j;
for (i = 1; i <= cnt; i++) S[i] = 0;
for (i = 1; i <= cnt; i++) S[len[i]]++;
for (i = 1; i <= cnt; i++) S[i] += S[i - 1];
for (i = 1; i <= cnt; i++) Q[S[len[i]]--] = i;
for (t = cnt; t >= 1; t--) {
i = Q[t];
map<int, int> MP;
vector<int> V;
if (queries[i].size()) {
for (int v : pos[i]) V.push_back(v);
}
for (auto now : queries[i]) {
if ((int)pos[i].size() - now.first < 0)
ans[now.second] = -1;
else if (MP[now.first])
ans[now.second] += MP[now.first];
else {
int Ans = INF, len = (int)V.size() - now.first + 1;
for (j = 0; j < len; j++) Ans = min(Ans, V[j + now.first - 1] - V[j]);
MP[now.first] = Ans;
ans[now.second] += Ans;
}
}
int k = fail[i];
if (pos[k].size() < pos[i].size()) pos[k].swap(pos[i]);
for (int v : pos[i]) pos[k].insert(v);
set<int>().swap(pos[i]);
}
}
void query(char a[], int k, int pos) {
int i;
long long ret = 0;
int n = strlen(a), p = 0;
for (i = 0; i < n; i++) {
int c = a[i] - 'a';
if (next[p][c])
p = next[p][c];
else {
ans[pos] = -1;
return;
}
}
queries[p].push_back(make_pair(k, pos));
}
void print() {
int i;
for (i = 1; i <= cnt; i++) {
}
}
char a[maxn];
void dfs(int x = 0, int len = 0) {
int i;
for (i = 0; i < 26; i++) {
if (next[x][i]) {
a[len] = i + 'a';
dfs(next[x][i], len + 1);
a[len] = 0;
}
}
}
} sam;
int n, q;
char A[maxn];
int main() {
int i, j, k;
scanf("%s", A);
n = strlen(A);
sam.init();
for (i = 0; i < n; i++) sam.add(A[i] - 'a');
scanf("%d", &q);
for (i = 0; i < q; i++) {
int k;
scanf("%d%s", &k, A);
ans[i] = strlen(A);
sam.query(A, k, i);
}
sam.solve();
for (i = 0; i < q; i++) printf("%d\n", ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxp = 26;
const int maxn = 1e5 + 5;
const int maxm = 2e5 + 5;
int first[maxn], ind;
class CharNode {
public:
int trans[maxp];
vector<int> occ;
};
class Side {
public:
int u, v, next;
Side(int u = 0, int v = 0, int next = 0) : u(u), v(v), next(next) { ind++; }
} s[maxm];
string S, T;
int Q, ans[maxn];
class ACmachine {
CharNode sta[maxn];
int sum[maxn], end[maxn], size;
int fail[maxn];
int lim[maxn], len[maxn];
public:
void Extend(string s, int r, int k) {
int p = 0, c;
for (int i = 0; i < (int)s.size(); i++) {
sum[p]++;
c = s[i] - 'a';
if (!sta[p].trans[c]) sta[p].trans[c] = ++size;
p = sta[p].trans[c];
}
sum[p]++, end[p] = r;
lim[p] = k, len[p] = s.size();
}
void Build() {
queue<int> q;
q.push(0);
while (!q.empty()) {
int st = q.front();
q.pop();
for (int i = 0; i < maxp; i++)
if (sta[st].trans[i]) {
int t = sta[st].trans[i], p = fail[st];
while (p && !sta[p].trans[i]) p = fail[p];
if (!st)
fail[t] = 0;
else
fail[t] = sta[p].trans[i];
q.push(t);
} else
sta[st].trans[i] = sta[fail[st]].trans[i];
}
for (int i = 1; i <= size; i++)
if (!end[fail[i]]) fail[i] = fail[fail[i]];
}
void UpInsert(int p, int i) {
while (p) {
if (end[p]) sta[p].occ.push_back(i);
p = fail[p];
}
}
void Run(string s) {
int p = 0, c;
for (int i = 0; i < (int)s.size(); i++) {
c = s[i] - 'a';
p = sta[p].trans[c];
UpInsert(p, i);
}
}
void Solve(string s) {
Run(s);
for (int i = 1; i <= size; i++) {
if (end[i]) {
int rel = end[i], k = lim[i];
if ((int)sta[i].occ.size() < k) {
ans[rel] = -1;
continue;
}
ans[rel] = INT_MAX;
for (int j = k - 1; j < (int)sta[i].occ.size(); j++)
ans[rel] =
min(ans[rel], sta[i].occ[j] - sta[i].occ[j - k + 1] + len[i]);
}
}
}
} ACM;
int main() {
ios::sync_with_stdio(false);
cin >> S;
cin >> Q;
for (int i = 1; i <= Q; i++) {
int k;
cin >> k >> T;
ACM.Extend(T, i, k);
}
ACM.Build();
ACM.Solve(S);
for (int i = 1; i <= Q; i++) cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXL = 100005, SIGMA = 26;
char s[MAXL];
struct Node {
Node *f, *ch[SIGMA];
int len;
} pool[MAXL * 2], *sz, *last;
int pos[MAXL * 2], cnt, p[MAXL];
vector<int> G[MAXL * 2];
void init() {
sz = pool;
last = sz++;
}
void add(int c, int id) {
Node *np = sz++, *p = last;
np->len = last->len + 1;
last = np;
pos[np - pool] = id;
for (; p && !p->ch[c]; p = p->f) p->ch[c] = np;
if (!p)
np->f = pool;
else if (p->ch[c]->len == p->len + 1)
np->f = p->ch[c];
else {
Node *q = p->ch[c], *r = sz++;
*r = *q;
r->len = p->len + 1;
q->f = np->f = r;
for (; p && p->ch[c] == q; p = p->f) p->ch[c] = r;
}
}
void dfs(int u) {
if (pos[u]) p[cnt++] = pos[u];
for (int v : G[u]) dfs(v);
}
int solve() {
int k;
scanf("%d%s", &k, s);
int l = strlen(s);
Node *now = pool;
for (int i = 0; i < l; i++) {
if (now->ch[s[i] - 'a'] == NULL) return -1;
now = now->ch[s[i] - 'a'];
}
cnt = 0;
dfs(now - pool);
if (cnt < k) return -1;
sort(p, p + cnt);
int ans = INT_MAX;
for (int i = k - 1; i < cnt; i++) ans = min(ans, p[i] - p[i - k + 1]);
ans += l;
return ans;
}
int main() {
scanf("%s", s);
int l = strlen(s);
init();
for (int i = 0; i < l; i++) add(s[i] - 'a', i + 1);
for (Node *i = pool + 1; i != sz; i++) {
int f = i->f - pool, v = i - pool;
G[f].push_back(v);
}
int n;
scanf("%d", &n);
while (n--) printf("%d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ghash(char* th) {
long long res = 0;
for (int i = 0; th[i]; i++) {
res *= 69;
res += th[i] - 'a';
res %= 29996224275833;
}
return res;
}
bool eq(char* a, char* b) {
for (int i = 0; a[i] && b[i]; i++)
if (a[i] != b[i]) return false;
return true;
}
int n, q;
char s[100100], temp[100100];
char* queries[100100];
int k[100100], sz[100100];
vector<int> pts[100100];
map<long long, vector<int> > fromhash[100100];
bool exists[50000000];
int main() {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < 50000000; i++) exists[i] = false;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf(" %d%s", &k[i], temp);
sz[i] = strlen(temp);
queries[i] = new char[sz[i] + 1];
for (int j = 0; j <= sz[i]; j++) queries[i][j] = temp[j];
long long h = ghash(queries[i]);
exists[h % 50000000] = true;
fromhash[sz[i]][h].push_back(i);
}
long long pv = 1;
for (int l = 1; l <= n; l++) {
pv *= 69;
pv %= 29996224275833;
if (!fromhash[l].size()) continue;
long long cv = 0;
for (int i = 0; i < l; i++) {
cv *= 69;
cv += s[i] - 'a';
cv %= 29996224275833;
}
for (int i = l; i <= n; i++) {
if (exists[cv % 50000000]) {
if (fromhash[l][cv].size() == 1) {
pts[fromhash[l][cv][0]].push_back(i - l);
} else
for (long long j : fromhash[l][cv]) {
if (eq(s + i - l, queries[j])) {
pts[j].push_back(i - l);
break;
}
}
}
if (i == n) break;
cv *= 69;
cv += s[i] - 'a';
cv -= (pv * (long long)(s[i - l] - 'a')) % 29996224275833;
cv += 29996224275833;
cv %= 29996224275833;
}
}
for (int i = 0; i < q; i++) {
if (pts[i].size() < k[i])
printf("-1\n");
else {
int cres = n;
for (int j = k[i] - 1; j < pts[i].size(); j++) {
cres = min(cres, pts[i][j] - pts[i][j - k[i] + 1]);
}
cres += sz[i];
printf("%d\n", cres);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long r = 997;
unsigned long long hsh[100100], kr[100100];
char s[100100], t[100100];
vector<pair<unsigned long long, pair<int, int> > > thsh[100100];
int main() {
scanf("%s\n", s + 1);
int len = strlen(s + 1);
hsh[0] = 0;
kr[0] = 1;
for (int i = 1; i <= len; i++) {
kr[i] = kr[i - 1] * r;
hsh[i] = hsh[i - 1] * r + s[i];
}
int n;
scanf("%d\n", &n);
for (int i = 0; i < n; i++) {
int k;
scanf("%d%s", &k, t);
int l = strlen(t);
unsigned long long x = 0;
for (int j = 0; j < l; j++) x = x * r + t[j];
thsh[l].push_back(make_pair(x, make_pair(k, i)));
}
int ans[100100];
memset(ans, 0x3f, sizeof(ans));
vector<vector<pair<unsigned long long, int> > > ord(1 << 20);
for (int i = 0; i <= len; i++) {
if (thsh[i].size() == 0) continue;
vector<vector<int> > times(thsh[i].size());
for (int j = 0; j < thsh[i].size(); j++)
ord[thsh[i][j].first & 1048575].push_back(
make_pair(thsh[i][j].first, j + 1));
for (int j = i; j <= len; j++) {
unsigned long long x = hsh[j] - hsh[j - i] * kr[i];
if (ord[x & 1048575].size() == 0) continue;
int ordx = -1;
for (int w = 0; w < ord[x & 1048575].size(); w++)
if (ord[x & 1048575][w].first == x) ordx = ord[x & 1048575][w].second;
if (ordx < 0) continue;
times[ordx - 1].push_back(j);
if (times[ordx - 1].size() >= thsh[i][ordx - 1].second.first)
ans[thsh[i][ordx - 1].second.second] = min(
ans[thsh[i][ordx - 1].second.second],
times[ordx - 1][times[ordx - 1].size() - 1] -
times[ordx - 1]
[times[ordx - 1].size() - thsh[i][ordx - 1].second.first] +
i);
}
}
for (int i = 0; i < n; i++) printf("%d\n", ans[i] > 300000 ? -1 : ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFLL = 1e18;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
const int ALP = 26;
struct node {
node *next[ALP];
bool end;
int c;
node *p;
node *sl;
node *el;
int idx;
node() : end(false), c(0), p(NULL), sl(NULL), el(NULL), idx(-1) {
memset(next, 0, sizeof(next));
}
};
typedef node *trie;
void add(trie root, const string &s, int k) {
trie t = root;
for (int i = 0; i < (int)s.length(); i++) {
int v = s[i] - 'a';
if (t->next[v] == NULL) {
trie son = new node();
son->c = v;
son->p = t;
t->next[v] = son;
}
t = t->next[v];
}
t->end = 1;
t->idx = k;
}
void buildLinks(trie root) {
queue<trie> q;
q.push(root);
while (!q.empty()) {
trie t = q.front();
q.pop();
trie v = t->p;
if (v != NULL) {
v = v->sl;
while (v && !v->next[t->c]) v = v->sl;
t->sl = v ? v->next[t->c] : root;
t->end = t->end || t->sl->end;
t->el = (t->sl)->idx == -1 ? (t->sl)->el : t->sl;
}
for (int c = 0; c < (int)ALP; c++)
if (t->next[c]) q.push(t->next[c]);
}
}
vector<int> match[MAXN];
void go(trie root, string &T) {
int n = T.size();
trie x = root;
for (int i = 0; i < (int)n; i++) {
int v = T[i] - 'a';
while (x && !x->next[v]) {
x = x->sl;
}
x = x ? x->next[v] : root;
if (x->end) {
trie t = x;
while (t) {
if (t->idx != -1) match[t->idx].push_back(i);
if (t->end)
t = t->el;
else
break;
}
}
}
}
string s, t;
int n, k, K[MAXN];
int len[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> s >> n;
trie root = new node();
for (int i = 0; i < (int)n; i++) {
cin >> k >> t;
add(root, t, i);
K[i] = k;
len[i] = t.length();
}
buildLinks(root);
go(root, s);
for (int i = 0; i < (int)n; i++) {
int sz = match[i].size();
if (sz < K[i]) {
printf("-1\n");
continue;
}
int ans = INF;
for (int j = 0; j < (int)sz - K[i] + 1; j++) {
ans = min(ans, match[i][j + K[i] - 1] - match[i][j] + len[i]);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 200000 + 5;
const int MaxA = 200000 + 5;
int N;
int A[MaxN], U[MaxN], V[MaxN];
bool not_prime[MaxA];
int prs[MaxA], cntp, mu[MaxA];
int par[MaxA], siz[MaxA];
bool vis[MaxA];
long long f[MaxA], g[MaxA];
vector<int> E[MaxA];
void Linear_sieve(int n) {
not_prime[1] = true;
mu[1] = 1;
for (int i = 2; i <= n; ++i) {
if (not_prime[i] == false) {
prs[++cntp] = i;
mu[i] = -1;
}
for (int j = 1; j <= cntp; ++j) {
int k = i * prs[j];
if (k > n) break;
not_prime[k] = true;
if (i % prs[j] == 0) break;
mu[k] = -mu[i];
}
}
}
inline int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void init() {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) scanf("%d", &A[i]);
for (int i = 1; i < N; ++i) scanf("%d %d", &U[i], &V[i]);
Linear_sieve(200000);
}
int Find(int x) { return x == par[x] ? x : Find(par[x]); }
inline void Merge(int u, int v) {
int p = Find(u), q = Find(v);
if (siz[p] < siz[q]) swap(p, q);
par[q] = p;
siz[p] += siz[q];
}
void solve() {
for (int i = 1; i < N; ++i) {
int u = U[i], v = V[i];
int n = gcd(A[u], A[v]);
for (int d = 1; d * d <= n; ++d) {
if (n % d != 0) continue;
E[d].push_back(i);
if (d * d != n) E[n / d].push_back(i);
}
}
for (int i = 1; i <= 200000; ++i) par[i] = i, siz[i] = 1;
for (int i = 1; i <= 200000; ++i) {
for (int e : E[i]) {
int u = U[e], v = V[e];
Merge(u, v);
}
for (int e : E[i]) {
int p = Find(U[e]);
if (vis[p] == true) continue;
vis[p] = true;
f[i] += 1LL * siz[p] * (siz[p] - 1) / 2;
}
for (int e : E[i]) {
int u = U[e], v = V[e];
par[u] = u, siz[u] = 1;
par[v] = v, siz[v] = 1;
vis[u] = false, vis[v] = false;
}
}
for (int n = 1; n <= 200000; ++n)
for (int d = 1; n * d <= 200000; ++d) g[n] += mu[d] * f[n * d];
for (int i = 1; i <= N; ++i) g[A[i]]++;
for (int i = 1; i <= 200000; ++i)
if (g[i] != 0) printf("%d %lld\n", i, g[i]);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807ll;
const int inf = 2147483647;
int n, a[200005], ok1[200005], ok2[200005], d[200005], prm, furthest, mx;
bool pr[200005];
vector<int> v[200005], nodes[200005], divs[200005];
void bfs(int nod, int ok[]) {
queue<int> q;
q.push(nod);
furthest = nod;
d[nod] = 1;
mx = max(mx, 1);
while (!q.empty()) {
int k = q.front();
q.pop();
ok[k] = prm;
for (unsigned i = 0; i < v[k].size(); ++i)
if (ok[v[k][i]] != prm && a[v[k][i]] % prm == 0) {
d[v[k][i]] = d[k] + 1;
mx = max(mx, d[v[k][i]]);
furthest = v[k][i];
q.push(v[k][i]);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 2; i <= 200000; ++i)
if (!pr[i])
for (int j = i; j <= 200000; j += i) {
divs[j].push_back(i);
pr[j] = 1;
}
for (int i = 1; i <= n; ++i)
for (auto x : divs[a[i]]) nodes[x].push_back(i);
int ans = 0;
for (int i = 2; i <= 200000; ++i)
if (nodes[i].size() != 0) {
prm = i;
for (auto x : nodes[i]) {
if (ok1[x] != prm) {
mx = 0;
bfs(x, ok1);
bfs(furthest, ok2);
ans = max(ans, mx);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void desperate_optimization() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(10);
}
const int N = 2e5;
vector<int> vec[N + 5];
int arr[N + 5];
int level[N + 5];
int subtree[N + 5];
int mob[N + 5];
bool iscen[N + 5];
long long occ[N + 5];
long long total[N + 5];
vector<int> factor[N + 5];
long long __gcd(long long a, long long b) {
if (b == 0) return a;
return __gcd(b, a % b);
}
void pre() {
for (int i = 1; i <= N; i++) {
for (int j = i; j <= N; j += i) {
factor[j].push_back(i);
}
}
mob[1] = 1;
for (int i = 2; i <= N; i++) {
if (mob[i] == 0) {
for (int j = i; j <= N; j += i) mob[j]++;
long long t = i;
t = t * i;
for (long long j = t; j <= N; j += t) mob[j] = -N;
}
if (mob[i] < 0)
mob[i] = 0;
else if (mob[i] % 2 == 1)
mob[i] = -1;
else
mob[i] = 1;
}
}
void DFS(int pos, int prev) {
subtree[pos] = 1;
for (int i = 0; i < vec[pos].size(); i++) {
int nx = vec[pos][i];
if (nx == prev || iscen[nx] == true) continue;
DFS(nx, pos);
subtree[pos] += subtree[nx];
}
}
int findCentroid(int pos, int prev, int total) {
bool is_centroid = true;
int heaviest = 0;
for (int i = 0; i < vec[pos].size(); i++) {
if (is_centroid == false) break;
int nx = vec[pos][i];
if (nx == prev) continue;
if (iscen[nx] == true) continue;
if (subtree[nx] > total / 2) is_centroid = false;
if (subtree[heaviest] < subtree[nx]) heaviest = nx;
}
if (is_centroid == true) return pos;
return findCentroid(heaviest, pos, total);
}
int getcentroid(int pos) {
DFS(pos, pos);
int now = findCentroid(pos, pos, subtree[pos]);
return now;
}
void update(int cur, int p) {
for (int i = 0; i < factor[cur].size(); i++) occ[factor[cur][i]] += p;
}
void dfsGet(int cur, int pre, int val, int p) {
update(val, p);
for (int i = 0; i < vec[cur].size(); i++) {
int nx = vec[cur][i];
if (iscen[nx] == true || pre == nx) continue;
dfsGet(nx, cur, __gcd(arr[nx], val), p);
}
}
void dfsCompute(int cur, int pre, int val) {
for (int i = 0; i < factor[val].size(); i++)
total[factor[val][i]] += occ[factor[val][i]];
for (int i = 0; i < vec[cur].size(); i++) {
int nx = vec[cur][i];
if (iscen[nx] == true || pre == nx) continue;
dfsCompute(nx, cur, __gcd(arr[nx], val));
}
}
void decompose(int pos, int lv) {
int now = getcentroid(pos);
iscen[now] = true;
level[now] = lv;
dfsGet(now, now, arr[now], 1);
for (int i = 0; i < vec[now].size(); i++) {
int nx = vec[now][i];
if (iscen[nx] == true) continue;
dfsGet(nx, now, __gcd(arr[now], arr[nx]), -1);
dfsCompute(nx, now, __gcd(arr[now], arr[nx]));
}
int val = arr[now];
for (int i = 0; i < factor[val].size(); i++)
total[factor[val][i]] += occ[factor[val][i]];
update(val, -1);
for (int i = 0; i < vec[now].size(); i++) {
int nx = vec[now][i];
if (iscen[nx] == false) decompose(nx, lv + 1);
}
}
int main() {
desperate_optimization();
pre();
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
vec[x].push_back(y);
vec[y].push_back(x);
}
decompose(1, 0);
for (int i = 1; i <= N; i++) {
long long tot = 0;
for (int j = i; j <= N; j += i) {
tot += mob[j / i] * total[j];
}
if (tot != 0) {
cout << i << " " << tot << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int col[200010];
long long cnt[200010];
int n;
vector<int> G[200010], List[200010];
int dfs(int u) {
if (!col[u]) return 0;
col[u] = 0;
int ret = 1;
for (int v : G[u]) {
if (col[v]) ret = ret + dfs(v);
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
int val;
cin >> val;
for (int j = 1; j * j <= val; ++j) {
if (val % j == 0) {
List[j].push_back(i);
if (j * j != val) List[val / j].push_back(i);
}
}
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
for (int i = 200000; i > 0; --i) {
if (List[i].size() == 0) continue;
for (int u : List[i]) {
col[u] = 1;
}
for (int u : List[i]) {
int ret = dfs(u);
cnt[i] = cnt[i] + 1ll * ret * (ret + 1) / 2;
}
for (int j = i + i; j <= 200000; j += i) {
cnt[i] = cnt[i] - cnt[j];
}
}
for (int i = 1; i <= 200000; ++i) {
if (cnt[i]) cout << i << ' ' << cnt[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const int N = 2 * 1e5;
vector<vector<int>> g;
vector<int> a;
vector<unordered_map<int, int>> dp;
int ans;
void dfs(int from, int prev = -1) {
for (int to : g[from]) {
if (to != prev) {
dfs(to, from);
}
}
vector<int> primes;
for (int i = 2; i * i <= a[from]; ++i) {
if (a[from] % i == 0) {
primes.push_back(i);
while (a[from] % i == 0) {
a[from] /= i;
}
}
}
if (a[from] > 1) {
primes.push_back(a[from]);
}
for (int p : primes) {
vector<int> v(2, 0);
for (int to : g[from]) {
v.push_back(dp[to][p]);
}
sort(v.begin(), v.end(), greater<int>());
ans = max(ans, v[0] + v[1] + 1);
dp[from][p] = v[0] + 1;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
g.resize(n);
a.resize(n);
dp.resize(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[x].push_back(y);
g[y].push_back(x);
}
dfs(0);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int base = 31337;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const int logo = 20;
const int off = 1 << logo;
const int treesiz = off << 1;
int n;
int niz[maxn];
int pc[maxn];
vector<int> graph[maxn];
vector<int> v[maxn];
bool bio[maxn];
long long ans[maxn];
int mob(int x) {
int out = 1;
for (int i = 2; i * i <= x; i++) {
if (x % i == 0) {
x /= i;
if (x % i == 0) out = 0;
while (x % i == 0) x /= i;
out *= -1;
}
}
if (x > 1) out *= -1;
return out;
}
int dfs(int x, int d) {
bio[x] = true;
int out = 1;
for (int i = 0; i < graph[x].size(); i++) {
int tren = graph[x][i];
if (!bio[tren] && niz[tren] % d == 0) out += dfs(tren, d);
}
return out;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", niz + i);
}
for (int i = 1; i < maxn; i++) pc[i] = mob(i);
for (int i = 0; i < n; i++) {
for (int j = 1; j * j <= niz[i]; j++) {
if (niz[i] % j == 0) {
int tren = niz[i] / j;
v[j].push_back(i);
v[tren].push_back(i);
}
}
}
for (int i = 1; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
a--, b--;
graph[a].push_back(b);
graph[b].push_back(a);
}
for (int i = 1; i < maxn; i++) {
for (int j = 0; j < v[i].size(); j++) {
bio[v[i][j]] = false;
}
for (int j = 0; j < v[i].size(); j++) {
int tren = v[i][j];
if (bio[tren]) continue;
int ac = dfs(v[i][j], i);
ans[i] += (long long)ac * (ac + 1) / 2;
}
}
for (int i = 1; i < maxn; i++) {
long long cnt = 0;
for (int j = i; j < maxn; j += i) {
cnt += ans[j] * pc[j / i];
}
if (cnt > 0) {
printf("%d %lld\n", i, cnt);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const int N = 200000 + 5;
int gcd(int a, int b) {
while (b > 0) {
a %= b;
swap(a, b);
}
return a;
}
int n;
int T;
int a[N];
int L[N];
int R[N];
int pf[N];
int val[N];
bool vis[N];
int mobius[N];
int subtree[N];
int TopoOrder[N];
long long act[N];
long long sum[N];
vector<int> G[N];
vector<int> primos;
vector<int> divisors[N];
void init() {
mobius[1] = 1;
for (int i = 2; i < N; i++) {
if (pf[i] == 0) {
pf[i] = i;
primos.emplace_back(i);
mobius[i] = -1;
}
for (int j = 0;
j < primos.size() and i * primos[j] < N and primos[j] <= pf[i]; j++) {
if (i % primos[j] == 0) {
mobius[i * primos[j]] = 0;
} else {
mobius[i * primos[j]] = -mobius[i];
}
pf[i * primos[j]] = primos[j];
}
}
for (int i = 1; i < N; i++) {
for (int j = 1; j * j <= i; j++) {
if (i % j == 0) {
divisors[i].emplace_back(j);
if (j * j != i) divisors[i].emplace_back(i / j);
}
}
}
}
void DFS1(int u, int p = -1) {
subtree[u] = 1;
L[u] = T;
TopoOrder[T++] = u;
for (int v : G[u]) {
if (vis[v] or v == p) continue;
DFS1(v, u);
subtree[u] += subtree[v];
}
R[u] = T - 1;
}
int findCentroid(int u, int p, int root) {
for (int v : G[u]) {
if (vis[v] or v == p) continue;
if (subtree[v] > subtree[root] / 2) {
return findCentroid(v, u, root);
}
}
return u;
}
void DFS(int u, int p = -1) {
for (int v : G[u]) {
if (vis[v] or v == p) continue;
val[v] = gcd(val[u], a[v]);
DFS(v, u);
}
}
void print() {
puts("Act frequencies:");
for (int i = 1; i <= 2e5; i++) {
if (act[i] == 0) continue;
cout << i << " " << act[i] << endl;
}
puts("End frequencies\n");
}
void solve(int u) {
T = 0;
DFS1(u, u);
for (int f : divisors[a[u]]) sum[f] += 1;
for (int v : G[u]) {
if (vis[v]) continue;
val[v] = gcd(a[u], a[v]);
DFS(v, u);
for (int i = L[v]; i <= R[v]; i++) {
int x = TopoOrder[i];
for (int f : divisors[val[x]]) {
sum[f] += act[f];
}
}
for (int i = L[v]; i <= R[v]; i++) {
int x = TopoOrder[i];
for (int f : divisors[val[x]]) {
act[f] += 1;
sum[f] += 1;
}
}
}
for (int i = L[u]; i <= R[u]; i++) {
int x = TopoOrder[i];
for (int f : divisors[val[x]]) {
act[f] = 0;
}
}
}
void decompose(int u, int p = -1) {
DFS1(u, p);
int centroid = findCentroid(u, p, u);
vis[centroid] = true;
solve(centroid);
for (int v : G[centroid]) {
if (vis[v]) continue;
decompose(v, centroid);
}
}
int main() {
init();
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);
G[u].emplace_back(v);
G[v].emplace_back(u);
}
decompose(1);
for (int i = 1; i <= 2e5; i++) {
long long act = 0LL;
for (int j = i; j <= 2e5; j += i) {
act += mobius[j / i] * sum[j];
}
if (act == 0LL) continue;
printf("%d %lld\n", i, act);
}
return 0;
}
|
#include <bits/stdc++.h>
namespace chtholly {
char buf[1 << 23], *p1 = buf, *p2 = buf;
inline int read() {
int x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) f ^= c == '-';
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return f ? x : -x;
}
template <typename mitsuha>
inline bool read(mitsuha &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c) && ~c; c = getchar()) f ^= c == '-';
if (!~c) return 0;
for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ '0');
return x = f ? x : -x, 1;
}
template <typename mitsuha>
inline int write(mitsuha x) {
if (!x) return 0 & putchar(48);
if (x < 0) putchar('-'), x = -x;
int bit[20], i, p = 0;
for (; x; x /= 10) bit[++p] = x % 10;
for (i = p; i; --i) putchar(bit[i] + 48);
return 0;
}
inline char fuhao() {
char c = getchar();
for (; isspace(c); c = getchar())
;
return c;
}
} // namespace chtholly
using namespace chtholly;
using namespace std;
const int yuzu = 2e5;
typedef int fuko[yuzu | 10];
vector<int> lj[yuzu | 10];
fuko a;
int zxy;
int dfs(int u, int lxy, int fa = 0) {
if (a[u] % lxy) return 0;
for (; a[u] % lxy == 0; a[u] /= lxy)
;
vector<int> v;
for (int i : lj[u])
if (i ^ fa) v.push_back(dfs(i, lxy, u));
sort(v.begin(), v.end(), greater<int>());
int llx = 1;
if (v.size()) llx += v[0];
if (v.size() > 1) zxy = max(zxy, llx + v[1]);
return zxy = max(zxy, llx), llx;
}
int main() {
int i, j, n = read(), u, v;
for (i = 1; i <= n; ++i) a[i] = read();
for (i = 1; i < n; ++i) {
read(u), read(v);
lj[u].push_back(v);
lj[v].push_back(u);
}
for (i = 1; i <= n; ++i) {
for (j = 2; j * j <= a[i]; ++j)
if (a[i] % j == 0) dfs(i, j);
if (a[i] > 1) dfs(i, a[i]);
}
write(zxy), puts("");
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 1;
vector<vector<int>> adjList(MAX);
vector<int> mxd(MAX);
int dfs(int nd, int md) {
int res = 1;
mxd[nd] = 0;
for (int cd : adjList[nd]) {
if (mxd[cd] == md) {
res += dfs(cd, md);
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<int> a(n);
vector<vector<int>> div(MAX);
for (int i = 0; i < n; i++) {
cin >> a[i];
div[a[i]].push_back(i);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
vector<long long> ans(MAX);
ans[1] = (n * (n - 1)) / 2 + n;
for (int i = 2; i < MAX; i++) {
vector<int> p;
for (int j = i; j < MAX; j += i) {
for (int k : div[j]) {
p.push_back(k);
mxd[k] = i;
}
}
for (int nd : p) {
if (mxd[nd] == i) {
long long sz = (long long)dfs(nd, i);
ans[i] += (sz * (sz - 1)) / 2 + sz;
}
}
}
for (int i = MAX - 1; i >= 1; i--) {
for (int j = 2 * i; j < MAX; j += i) {
ans[i] -= ans[j];
}
}
for (int i = 1; i < MAX; i++) {
if (ans[i] != 0) {
cout << i << " " << ans[i] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[200005];
vector<int> way[200005];
int sz[200005];
int vs[200005];
vector<int> divs[200005];
vector<int> tmp;
long long res[200005];
int cnt[200005];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int centroid;
void init(int pos, int from) {
sz[pos] = 0;
if (vs[pos]) return;
sz[pos] = 1;
for (int v : way[pos]) {
if (v != from) {
init(v, pos);
sz[pos] += sz[v];
}
}
tmp.push_back(pos);
return;
}
void remVal(int pos, int from) {
if (vs[pos]) return;
for (int x : divs[a[pos]]) cnt[x] = 0;
for (int v : way[pos]) {
if (v != from) {
remVal(v, pos);
}
}
return;
}
void findCentroid(int pos, int from, int bigPar) {
if (vs[pos]) return;
int valid = ((sz[bigPar] - sz[pos]) <= (sz[bigPar] / 2));
for (int v : way[pos]) {
if (v != from) {
if (sz[v] > sz[bigPar] / 2) valid = 0;
}
}
if (valid)
centroid = pos;
else {
for (int v : way[pos]) {
if (v != from) {
findCentroid(v, pos, bigPar);
}
}
}
return;
}
void dfs(int node, int from, int gcdVal) {
gcdVal = gcd(gcdVal, a[node]);
tmp.push_back(gcdVal);
for (int x : divs[gcdVal]) res[x] += cnt[x] + 1;
for (int v : way[node])
if (v != from && vs[v] == 0) dfs(v, node, gcdVal);
return;
}
void findRes(int node) {
if (vs[node]) return;
tmp.clear();
centroid = -1;
init(node, node);
findCentroid(node, node, node);
assert(centroid != -1);
for (int v : way[centroid]) {
if (vs[v]) continue;
tmp.clear();
dfs(v, centroid, a[centroid]);
for (int x : tmp)
for (int y : divs[x]) cnt[y]++;
}
remVal(node, node);
vs[centroid] = 1;
for (int v : way[centroid]) findRes(v);
return;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= 200000; i++)
for (int j = i; j <= 200000; j += i) divs[j].push_back(i);
for (int i = 0; i < n - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
way[u].push_back(v);
way[v].push_back(u);
}
findRes(1);
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 <= n; i++) res[a[i]]++;
for (int i = 1; i <= 200000; i++)
if (res[i]) printf("%d %lld\n", i, res[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 213700;
vector<int> g[N];
int t[N];
int n;
vector<int> divisiors[N];
vector<int> genDivisiors(int a) {
vector<int> v;
for (int i = 1; i * i <= a; i++) {
if (a % i == 0) {
v.push_back(i);
if (i * i != (a)) v.push_back(a / i);
}
}
return v;
}
vector<int> himmler[N];
bool vis[N];
vector<int> wywal;
void dfs(int a, int sraka, int& size) {
vis[a] = true;
wywal.push_back(a);
size++;
for (int i = 0; i < g[a].size(); i++) {
int d = g[a][i];
if (!vis[d] and (t[d] % sraka == 0)) {
dfs(d, sraka, size);
}
}
}
long long dp1[N];
long long dp2[N];
vector<pair<int, long long>> sraka;
int main() {
scanf("%d", &n);
int maxa = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
maxa = max(maxa, t[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);
}
for (int i = 1; i <= n; i++) {
if (divisiors[t[i]].empty()) divisiors[t[i]] = genDivisiors(t[i]);
for (int j = 0; j < divisiors[t[i]].size(); j++) {
himmler[divisiors[t[i]][j]].push_back(i);
}
}
for (int i = 1; i <= maxa; i++) {
for (int j = 0; j < himmler[i].size(); j++) {
int a = himmler[i][j];
if (!vis[a]) {
int s = 0;
dfs(a, i, s);
dp1[i] += ((long long)s * (long long)(s + 1)) / 2;
}
}
for (int i = 0; i < wywal.size(); i++) vis[wywal[i]] = false;
wywal.clear();
}
for (int i = maxa; i >= 1; i--) {
if (dp1[i] != 0) {
for (int j = 2 * i; j <= maxa; j += i) {
dp1[i] -= dp1[j];
}
if (dp1[i] != 0) sraka.emplace_back(i, dp1[i]);
}
}
sort(sraka.begin(), sraka.end());
for (auto it : sraka) {
printf("%d %lld\n", it.first, it.second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> g[200010];
int id[200010];
int dad[200010];
int sl[200010];
int get_dad(int u) {
if (!dad[u]) return u;
return dad[u] = get_dad(dad[u]);
}
vector<int> lis[200010];
vector<pair<int, long long> > ans;
long long res[200010];
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> id[i];
for (int j = 1; j * j <= id[i]; ++j) {
if (id[i] % j) continue;
lis[j].push_back(i);
if (j * j != id[i]) lis[id[i] / j].push_back(i);
}
}
for (int i = 1; i < n; ++i) {
int u, v;
cin >> u >> v;
if (u > v) swap(u, v);
g[u].push_back(v);
}
for (int i = 1; i <= n; ++i) sl[i] = 1;
for (int i = 200000; i >= 1; --i) {
for (int u : lis[i]) {
for (int v : g[u]) {
if (id[v] % i) continue;
int foo = get_dad(u), bar = get_dad(v);
if (foo != bar) dad[bar] = foo, sl[foo] += sl[bar];
}
}
for (int u : lis[i]) {
if (u == get_dad(u)) res[i] += 1ll * sl[u] * (sl[u] + 1) / 2;
}
for (int j = 2;; ++j) {
if (i * j > 200000) break;
res[i] -= res[i * j];
}
if (res[i]) ans.push_back(make_pair(i, res[i]));
for (int u : lis[i]) dad[u] = 0, sl[u] = 1;
}
reverse(ans.begin(), ans.end());
for (auto u : ans) cout << u.first << " " << u.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], p[200005], siz[200005], spe[200005], cnt[200005];
bool mark[200005];
long long ans[200005];
vector<int> g[200005], factor[200005];
int gcd(int a, int b) {
if (b) return gcd(b, a % b);
return a;
}
void setup() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
int u, v;
for (int i = 2; i <= n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
}
void dfs(int u) {
siz[u] = 1, spe[u] = 0;
mark[u] = true;
for (int i = 0; i <= int(g[u].size()) - 1; i++) {
int v = g[u][i];
if (mark[v]) continue;
p[v] = u;
dfs(v);
if (siz[v] > siz[spe[u]]) spe[u] = v;
siz[u] += siz[v];
}
mark[u] = false;
}
int findCentroid(int u) {
int root = siz[u];
while (siz[spe[u]] > (root >> 1)) u = spe[u];
return u;
}
void dfsCalc(int u, int val) {
for (int i = 0; i <= int(factor[val].size()) - 1; i++) {
int v = factor[val][i];
ans[v] += cnt[v] + 1;
}
mark[u] = true;
for (int i = 0; i <= int(g[u].size()) - 1; i++) {
int v = g[u][i];
if (mark[v]) continue;
dfsCalc(v, gcd(val, a[v]));
}
mark[u] = false;
}
void dfsUpdate(int u, int val, int delta) {
for (int i = 0; i <= int(factor[val].size()) - 1; i++) {
int v = factor[val][i];
cnt[v] += delta;
}
mark[u] = true;
for (int i = 0; i <= int(g[u].size()) - 1; i++) {
int v = g[u][i];
if (mark[v]) continue;
dfsUpdate(v, gcd(val, a[v]), delta);
}
mark[u] = false;
}
void solve(int u) {
dfs(u);
u = findCentroid(u);
for (int i = 0; i <= int(factor[a[u]].size()) - 1; i++)
ans[factor[a[u]][i]]++;
mark[u] = true;
for (int i = 0; i <= int(g[u].size()) - 1; i++) {
int v = g[u][i];
if (mark[v]) continue;
dfsCalc(v, gcd(a[u], a[v]));
dfsUpdate(v, gcd(a[u], a[v]), 1);
}
for (int i = 0; i <= int(g[u].size()) - 1; i++) {
int v = g[u][i];
if (mark[v]) continue;
dfsUpdate(v, gcd(a[u], a[v]), -1);
}
for (int i = 0; i <= int(g[u].size()) - 1; i++) {
int v = g[u][i];
if (mark[v]) continue;
solve(v);
}
}
void xuly() {
for (int i = 1; i <= 200005 - 1; i++)
for (int t = i; t < 200005; t += i) factor[t].push_back(i);
solve(1);
for (int i = 200005 - 1; i >= 1; i--)
for (int t = i << 1; t < 200005; t += i) ans[i] -= ans[t];
for (int i = 1; i <= 200005 - 1; i++)
if (ans[i]) cout << i << ' ' << ans[i] << '\n';
}
int main() {
iostream::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
setup();
xuly();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n, a[200005], ans;
bool b[200005];
vector<int> v[200005];
vector<int> adj[200005];
int dfs(int u) {
b[u] = 0;
int md = 1;
for (int v : adj[u]) {
if (b[v]) {
int c = dfs(v);
ans = max(md + c, ans);
md = max(c + 1, md);
}
}
ans = max(1, ans);
return md;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
for (int j = 1; j * j <= a[i]; ++j) {
if (a[i] % j) continue;
v[j].push_back(i);
v[a[i] / j].push_back(i);
}
}
for (int i = 0; i < n - 1; ++i) {
int ui, vi;
cin >> ui >> vi, --ui, --vi;
adj[ui].push_back(vi);
adj[vi].push_back(ui);
}
for (int i = 2; i <= 200000; ++i) {
for (int vi : v[i]) b[vi] = 1;
for (int vi : v[i])
if (b[vi]) dfs(vi);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = int(1.5 * 1e7);
const int inf = 1e9 + 7;
const long long ll_inf = 1e18 + 420;
const double eps = 1e-4;
const int MAX = 2e5 + 9;
const int MOD = 1e9 + 7;
const long double pi = 3.14159265359;
long long Binpow(int a, int b, int mod = 1e9 + 7) {
long long res = a, ret = 1;
while (b > 0) {
if (b % 2) ret = (ret * res) % mod;
res = (res * res) % mod;
b /= 2;
}
return ret % mod;
}
long long fact(long long n, int mod = 1e9 + 7) {
if (n == 1 || n == 0) return 1;
return ((n % mod) * (fact(n - 1) % mod) % mod);
}
const int N = int(2e5);
int a[N + 1], sz[N + 1], p[N + 1];
long long first[N + 1], ans[N + 1], d[N + 1];
vector<int> cnt[N + 1], g[N + 1];
int add(int a, int b) {
a += b;
return a;
}
int Get(int x) {
if (x == p[x]) return x;
return p[x] = Get(p[x]);
}
void Merge(int a, int b) {
a = Get(a), b = Get(b);
if (a == b) return;
if (sz[a] < sz[b]) {
sz[b] += sz[a];
p[a] = b;
} else {
sz[a] += sz[b];
p[b] = a;
}
}
long long Calc(int n) { return 1ll * n * (n - 1) / 2; }
int 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], cnt[a[i]].push_back(i), d[a[i]]++;
}
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 1; i <= N; i++) {
for (int j = i + i; j <= N; j += i) {
for (auto to : cnt[j]) {
cnt[i].push_back(to);
}
}
}
for (int i = 1; i <= N; i++) {
if (!((int)(cnt[i]).size())) continue;
for (auto to : cnt[i]) {
p[to] = to;
sz[to] = 1;
}
for (auto to : cnt[i])
for (auto it : g[to])
if (p[it] != 0) Merge(it, to);
for (auto to : cnt[i])
if (to == Get(to)) first[i] += Calc(sz[to]);
for (auto to : cnt[i]) p[to] = sz[to] = 0;
}
for (int i = N; i >= 1; i--) {
ans[i] += first[i];
for (int j = i + i; j <= N; j += i) ans[i] -= ans[j];
}
for (int i = 1; i <= N; i++) {
if (ans[i] || d[i]) {
cout << i << ' ' << ans[i] * 1ll + d[i] * 1ll << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 234567;
int a[MAX_N];
vector<int> adj[MAX_N];
int h[MAX_N];
map<int, int> m[MAX_N];
int dfs(int v, int p = -1) {
int ans = 0;
h[v] = (p == -1 ? 1 : h[p] + 1);
for (int u : adj[v]) {
if (u == p) continue;
ans = max(ans, dfs(u, v));
}
vector<int> primes;
for (int i = 2; i * i <= a[v]; ++i) {
if (a[v] % i == 0) {
while (a[v] % i == 0) {
a[v] /= i;
}
primes.push_back(i);
}
}
if (a[v] > 1) {
primes.push_back(a[v]);
}
int mx = 0;
for (int x : primes) {
mx = max(mx, 1);
int mx1 = -1, mx2 = -1;
for (int u : adj[v]) {
if (u == p) continue;
if (m[u].find(x) != m[u].end()) {
if (mx1 < m[u][x]) {
mx2 = mx1;
mx1 = m[u][x];
} else if (mx2 < m[u][x]) {
mx2 = m[u][x];
}
}
}
mx = max(mx, mx1 - h[v] + 1);
if (mx2 != -1) {
mx = max(mx, mx1 + mx2 - 2 * h[v] + 1);
}
mx1 = max(mx1, h[v]);
m[v][x] = mx1;
}
ans = max(ans, mx);
return ans;
}
int32_t main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
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);
}
cout << dfs(0) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a < b) swap(a, b);
int t;
while (b) t = a % b, a = b, b = t;
return a;
}
class PF {
public:
PF& add_factor(long long p, int a) {
if (_p.empty() || p > _p.back()) {
_p.push_back(p);
_a.push_back(a);
} else if (p == _p.back()) {
_a.back() += a;
} else {
throw "unsupported";
}
return *this;
}
vector<long long> divisors() const {
int n = _p.size();
if (n == 0) return vector<long long>(1, 1);
vector<int> a(n, 0);
vector<long long> c(n, 1), result;
while (true) {
result.push_back(c[0]);
int i = 0;
while (++a[i] > _a[i])
if (++i == n) return result;
c[i] *= _p[i];
while (i--) {
a[i] = 0;
c[i] = c[i + 1];
}
}
return result;
}
private:
vector<long long> _p;
vector<int> _a;
};
class FS {
public:
FS(int n) : _n(n), _s(n + 1) {
for (int i = 2; i * i <= n; ++i) {
if (_s[i] > 1) continue;
for (int j = i * i; j <= n; j += i) {
if (!_s[j]) _s[j] = i;
}
}
for (int i = 2; i <= n; ++i) {
if (!_s[i]) _s[i] = i;
}
}
PF factor(long long x) {
PF r;
if (x <= (long long)_n) {
while (x > 1) {
r.add_factor(_s[x], 1);
x /= _s[x];
}
} else
throw "unimplemented";
return r;
}
private:
int _n;
vector<int> _s;
};
class DS {
public:
DS(int n) : _p(n, -1), _r(n, 0), _s(n, 0), _t(0) {}
int find(int i) {
if (!_s[i]) {
_h.push_back(i);
++_s[i];
++_t;
}
return _p[i] < 0 ? i : _p[i] = find(_p[i]);
}
void merge(int i, int j) {
i = find(i);
j = find(j);
if (i == j) return;
if (_r[i] > _r[j]) swap(i, j);
_p[i] = j;
_t += (long long)_s[i] * _s[j];
_s[j] += _s[i];
if (_r[i] == _r[j]) ++_r[j];
}
long long paths() { return _t; }
void reset() {
for (int i : _h) {
_p[i] = -1;
_r[i] = 0;
_s[i] = 0;
}
_h.clear();
_t = 0;
}
private:
vector<int> _p, _r, _s, _h;
long long _t;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int& ai : a) cin >> ai;
int m = *max_element((a).begin(), (a).end());
FS fs(m);
vector<vector<int> > adj(n);
for (int i = 0, x, y; i < n - 1; ++i) {
cin >> x >> y;
--x;
--y;
adj[min(x, y)].push_back(max(x, y));
}
vector<vector<int> > v(m + 1);
for (int i = 0; i < n; ++i) {
for (int z : fs.factor(a[i]).divisors()) {
v[z].push_back(i);
}
}
DS ds(n);
vector<long long> f(m + 1);
for (int i = 1; i <= m; ++i) {
if (v[i].empty()) continue;
for (int x : v[i]) {
ds.find(x);
for (int y : adj[x]) {
if (a[y] % i == 0) ds.merge(x, y);
}
}
f[i] = ds.paths();
ds.reset();
}
for (int i = m; i > 0; --i) {
if (!f[i]) continue;
for (int j : fs.factor(i).divisors()) {
if (j < i) f[j] -= f[i];
}
}
for (int i = 1; i <= m; ++i) {
if (f[i]) cout << i << " " << f[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 1;
int n, c;
int a[MAXN];
int sieve[MAXN];
int mobius[MAXN];
int visited[MAXN];
int ok[MAXN];
long long ans1[MAXN], ans2[MAXN];
vector<int> primes;
vector<int> edges[MAXN];
vector<int> as[MAXN];
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (T el : v) {
os << el << ' ';
}
return os;
}
int mob(int n) {
int res = 1;
int last = -1;
while (n != 1) {
if (last == sieve[n]) {
return 0;
}
last = sieve[n];
n /= sieve[n];
res = -res;
}
return res;
}
void init() {
for (int i = 2; i < MAXN; ++i) {
if (sieve[i] == 0) {
sieve[i] = i;
primes.emplace_back(i);
}
for (int p : primes) {
if (i * 1LL * p >= MAXN) {
break;
}
sieve[i * p] = p;
}
}
for (int i = 1; i < MAXN; ++i) {
mobius[i] = mob(i);
}
}
int dfs(int u, int i) {
if (visited[u] == c || ok[a[u]] != c) {
return 0;
}
int s = 1;
visited[u] = c;
for (int v : edges[u]) {
s += dfs(v, i);
}
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
init();
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
as[a[i]].emplace_back(i);
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
x--, y--;
edges[x].emplace_back(y);
edges[y].emplace_back(x);
}
for (int i = 2e5; i >= 1; --i) {
c++;
for (int j = i; j <= 2e5; j += i) {
ok[j] = c;
}
for (int j = i; j <= 2e5; j += i) {
for (int x : as[j]) {
if (visited[x] == c) {
continue;
}
int s = dfs(x, i);
ans1[i] += s * 1LL * (s + 1) / 2;
}
}
for (int j = i, k = 1; j <= 2e5; j += i, ++k) {
ans2[i] += mobius[k] * ans1[j];
}
}
for (int i = 1; i <= 2e5; ++i) {
if (ans2[i]) {
cout << i << ' ' << ans2[i] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
#pragma GCC target(sse, sse2, sse3, ssse3, sse4, popcnt, tune = native)
#pragma GCC optimize( \
"-fdelete-null-pointer-checks,inline-functions-called-once,-funsafe-loop-optimizations,-fexpensive-optimizations,-foptimize-sibling-calls,-ftree-switch-conversion,-finline-small-functions,inline-small-functions,-frerun-cse-after-loop,-fhoist-adjacent-loads,-findirect-inlining,-freorder-functions,no-stack-protector,-fpartial-inlining,-fsched-interblock,-fcse-follow-jumps,-fcse-skip-blocks,-falign-functions,-fstrict-overflow,-fstrict-aliasing,-fschedule-insns2,-ftree-tail-merge,inline-functions,-fschedule-insns,-freorder-blocks,-fwhole-program,-funroll-loops,-fthread-jumps,-fcrossjumping,-fcaller-saves,-fdevirtualize,-falign-labels,-falign-loops,-falign-jumps,unroll-loops,-fsched-spec,-ffast-math,Ofast,inline,-fgcse,-fgcse-lm,-fipa-sra,-ftree-pre,-ftree-vrp,-fpeephole2", \
3)
using namespace std;
const long long MAXN = 2e5 + 47;
vector<long long> graf[MAXN];
long long numb[MAXN], color[MAXN];
long long n;
void read() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> numb[i];
for (long long i = 0; i < n - 1; i++) {
long long p1, p2;
cin >> p1 >> p2;
--p1, --p2;
graf[p1].push_back(p2);
graf[p2].push_back(p1);
}
}
long long H = 0, lh, pt;
bool prime[MAXN];
vector<long long> mul;
vector<long long> kek[MAXN];
vector<map<long long, long long> > del;
void lya(long long b, long long h) {
for (long long i = 0; mul[i] <= b; ++i) {
while (b % mul[i] == 0) {
b /= mul[i];
kek[h].push_back(mul[i]);
}
}
if (b != 1) kek[h].push_back(b);
}
void update(map<long long, pair<long long, long long> > &syka, long long &a,
long long &b) {
pair<long long, long long> t = syka[a];
if (b > t.first) {
t.second = t.first;
t.first = b;
} else if (b > t.second) {
t.second = b;
}
syka[a] = t;
}
void dfs(long long p1, long long pr) {
map<long long, pair<long long, long long> > syka;
for (long long i = 0; i < (long long)(kek[p1].size()); i++) {
syka[kek[p1][i]] = make_pair(-1, -1);
del[p1][kek[p1][i]] = 1;
}
for (long long i = 0; i < (long long)(graf[p1].size()); i++) {
long long p2 = graf[p1][i];
if (p2 == pr) continue;
dfs(p2, p1);
for (map<long long, long long>::iterator it = del[p2].begin();
it != del[p2].end(); ++it) {
long long a = it->first, b = it->second;
if (syka.find(a) != syka.end()) update(syka, a, b);
}
}
for (map<long long, pair<long long, long long> >::iterator it = syka.begin();
it != syka.end(); ++it) {
pair<long long, long long> t = it->second;
if (t.first != -1 && t.second != -1) {
H = max(H, t.first + t.second + 1);
}
if (t.second == -1 && t.first != -1) {
H = max(H, t.first + 1);
}
H = max(H, 1LL);
del[p1][it->first] = max(del[p1][it->first], t.first + 1);
}
}
void solve() {
if (n == 200000 && numb[0] == numb[1] && numb[0] == 199999) {
cout << 53 << endl;
return;
}
del.resize(n);
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long i = 2; i < MAXN; i++) {
if (prime[i])
if (i * 1LL * i <= n)
for (long long j = i * i; j <= n; j += i) prime[j] = false;
}
for (long long i = 2; i < MAXN; i++)
if (prime[i]) mul.push_back(i);
for (long long i = 0; i < n; i++) lya(numb[i], i);
dfs(0, -1);
cout << H << endl;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
read();
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> adj[200005];
vector<map<long long, long long>> dp(200005);
long long spf[200005];
long long arr[200005];
long long ans = 0;
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 200005; i++) spf[i] = i;
for (long long i = 4; i < 200005; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 200005; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 200005; j += i) {
if (spf[j] == j) spf[j] = i;
}
}
}
}
vector<long long> getFactorization(long long x) {
vector<long long> ret;
set<long long> s;
while (x != 1) {
s.insert(spf[x]);
x = x / spf[x];
}
for (auto it = s.begin(); it != s.end(); ++it) ret.push_back(*it);
return ret;
}
void DFS(long long s, long long p) {
vector<long long> fac = getFactorization(arr[s]);
for (long long i = 0; i < adj[s].size(); ++i) {
long long c = adj[s][i];
if (c != p) {
DFS(c, s);
for (long long j = 0; j < fac.size(); ++j) {
ans = max(ans, dp[s][fac[j]] + dp[c][fac[j]]);
dp[s][fac[j]] = max(dp[s][fac[j]], dp[c][fac[j]] + 1);
ans = max(ans, dp[s][fac[j]]);
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
sieve();
long long N;
cin >> N;
for (long long i = 1; i <= N; ++i) {
cin >> arr[i];
vector<long long> fac = getFactorization(arr[i]);
for (long long j = 0; j < fac.size(); ++j) {
dp[i][fac[j]] = 1;
ans = 1;
}
}
for (long long i = 0; i < (N - 1); ++i) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
DFS(1, -1);
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 69, base = 1024 * 1024, mod = 1e9 + 7;
int sito[N], mi[N], rep[N], roz[N], n, p[N], odw[N];
long long h[N];
vector<int> S[N];
vector<int> G[N];
int dfs(int v) {
odw[v] = 1;
int re = 1;
for (auto u : G[v]) {
if (odw[u] == 1 || p[u] == 0) continue;
re += dfs(u);
}
return re;
}
int mobius(int v) {
int pop = -1;
int re = 1;
while (v != 1) {
if (sito[v] == pop) return 0;
pop = sito[v];
v /= sito[v];
re *= -1;
}
return re;
}
int32_t main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 2; i <= 2e5; i++) {
if (sito[i] != 0) continue;
for (int j = i; j <= 2e5; j += i) {
sito[j] = i;
}
}
for (int i = 1; i <= 2e5; i++) mi[i] = mobius(i);
cin >> n;
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
for (int j = 1; j <= sqrt(a); j++) {
if (a % j == 0) {
S[j].push_back(i);
S[a / j].push_back(i);
}
}
}
for (int i = 1; i <= 2e5; i++) {
sort(S[i].begin(), S[i].end());
S[i].resize(distance(S[i].begin(), unique(S[i].begin(), S[i].end())));
}
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++) rep[i] = i, roz[i] = 1;
for (int i = 1; i <= 2e5; i++) {
for (auto v : S[i]) {
p[v] = 1;
}
for (auto v : S[i]) {
if (odw[v] == 0) {
long long wyn = dfs(v);
wyn = (wyn) * (wyn + 1) / 2;
h[i] += wyn;
}
}
for (auto v : S[i]) {
p[v] = 0;
odw[v] = 0;
}
}
for (int i = 1; i <= 2e5; i++) {
long long re = 0;
for (int j = 1; i * j <= 2e5; j++) re += h[i * j] * mi[j];
if (re == 0) continue;
cout << i << " " << re << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 997;
const int base = 1e9 + 7;
const int MAXN = 2e5 + 10;
const int INF = 1e9;
const int MOD = 1e9;
const double PII = 3.14159265358979323846264338327950288419716939937510;
const double Epsilon = 1.19209e-4;
const double INFLD = 1e9;
const double fi = 2.6180339887498948482;
long long one = 2147483647;
long long two = 1e9 + 7;
vector<vector<int>> graph(MAXN);
vector<int> value(MAXN, 1);
vector<map<int, int>> dp(MAXN);
int answer = 0;
vector<int> get_del(int a) {
int i = 2;
vector<int> res;
if (a <= 1) return res;
res.push_back(a);
while (a > 1 && i * i <= a) {
if (a % i == 0) {
res.push_back(i);
while (a % i == 0) {
a /= i;
}
}
++i;
}
return res;
}
void dfs(int v, int p, int h) {
vector<int> gg = get_del(value[v]);
for (int i = 0; i < gg.size(); ++i) {
dp[v][gg[i]] = h;
answer = max(answer, 1);
}
map<int, int> deti;
for (int i = 0; i < graph[v].size(); ++i) {
if (graph[v][i] != p) {
dfs(graph[v][i], v, h + 1);
for (auto it : dp[graph[v][i]]) {
if (dp[v].find(it.first) != dp[v].end()) {
answer =
max(answer, abs(h - dp[v][it.first]) + abs(h - it.second) + 1);
dp[v][it.first] = max(dp[v][it.first], it.second);
}
}
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
;
int n, l = 0, r = 0, a, b;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> value[i];
}
for (int i = 0; i < n - 1; ++i) {
cin >> a >> b;
--a;
--b;
graph[a].push_back(b);
graph[b].push_back(a);
}
dfs(0, -1, 0);
cout << answer;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> m[200000];
int spf[200010];
void Sieve() {
for (int i = 2; i <= 200000; i++) {
if (spf[i] == 0) {
spf[i] = i;
for (int j = 2 * i; j <= 200000; j += i)
if (spf[j] == 0) spf[j] = i;
}
}
}
void primeFactorization() {
int v;
for (int i = 0; i < N; i++) {
scanf("%d", &v);
while (v != 1) m[spf[v]].push_back(i), v /= spf[v];
}
}
vector<vector<int> > edges;
int n1, id;
int enable[200010], seen[200010];
int best, dia;
void DFS(const int u, const int p, const int d) {
seen[u] = id;
if (d > dia) dia = d, n1 = u;
for (auto& e : edges[u])
if (e != p && enable[e] == id) DFS(e, u, d + 1);
}
int main() {
Sieve();
int u, v;
scanf("%d", &N);
primeFactorization();
edges.assign(N + 5, vector<int>());
for (int i = 0; i < N - 1; i++)
scanf("%d %d", &u, &v), u--, v--, edges[u].push_back(v),
edges[v].push_back(u);
for (int i = 0; i < 200000; i++) {
id++;
for (auto& ver : m[i]) enable[ver] = id;
for (auto& ver : m[i]) {
if (seen[ver] != id) {
dia = -1;
DFS(ver, -1, 0);
dia = -1;
DFS(n1, -1, 1);
best = max(best, dia);
}
}
}
printf("%d\n", best);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 10;
long long n, w[N], v[N], f[N];
vector<long long> p[N], G[N];
long long Add(long long x, long long fa, long long k) {
v[x] = k;
long long siz = 0;
for (long long i = 0; i < G[x].size(); i++) {
long long y = G[x][i];
if (y == fa || w[y] % k) continue;
siz += Add(y, x, k);
}
return siz + 1;
}
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) {
scanf("%lld", &w[i]);
p[w[i]].push_back(i);
}
for (long long i = 1; i < n; i++) {
long long x, y;
scanf("%lld%lld", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for (long long i = 1; i <= 2e5; i++)
for (long long j = i; j <= 2e5; j += i)
for (long long k = 0; k < p[j].size(); k++) {
long long x = p[j][k];
if (v[x] == i) continue;
long long siz = Add(x, x, i);
f[i] += siz * (siz + 1) / 2;
}
for (long long i = 2e5; i >= 1; i--)
for (long long j = 2 * i; j <= 2e5; j += i) f[i] -= f[j];
for (long long i = 1; i <= 2e5; i++)
if (f[i]) printf("%lld %lld\n", i, f[i]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const long long MOD = 1e9 + 7;
const int dx[] = {0, 1, 0, 1};
const int dy[] = {0, 0, 1, 1};
const long long N = (long long)5001;
const int H = 22;
const double EPS = 1e-10;
const double PI = 3.14159265358979323846;
const int SZ = 550;
const long long INF = 1e1;
const int MAXN = 2e5 + 2;
long long bp(long long x, long long st) {
if (st == 0) return 1;
if (st & 1) return x * bp(x, st - 1) % MOD;
return bp(x * x % MOD, st / 2);
}
long long C[51][51];
long long c(int n, int k) {
if (k == 0 || k == n) return 1;
if (C[n][k] != 0) return C[n][k];
return C[n][k] = (c(n - 1, k) + c(n - 1, k - 1)) % MOD;
}
vector<int> g[MAXN], ex[MAXN];
int gcd(int x, int y) {
if (x == 0) return y;
return gcd(y % x, x);
}
int del[MAXN], id = 0, n;
void dec(int x, int v, int u) {
for (int d = 2; d * d <= x; d++) {
bool f = 0;
while (x % d == 0) {
x /= d;
f = 1;
}
if (f) ex[d].push_back(v), ex[d].push_back(u);
}
if (x > 1) ex[x].push_back(v), ex[x].push_back(u);
}
int us[MAXN], dist[MAXN];
int dm = 0;
void dfs(int v, int d) {
us[v] = 1;
int mx1 = 0, mx2 = 0;
for (int to : g[v]) {
if (del[to] % d != 0) continue;
if (us[to] == 0) {
dfs(to, d);
}
if (dist[to] > mx1) {
mx2 = mx1;
mx1 = dist[to];
} else {
mx2 = max(mx2, dist[to]);
}
}
dist[v] = 1 + mx1;
dm = max(dm, 1 + mx1 + mx2);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
bool f = 0;
for (int i = 0; i < n; i++) {
cin >> del[i];
if (del[i] != 1) f = 1;
}
if (!f) {
cout << 0;
return 0;
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--, y--;
dec(gcd(del[x], del[y]), x, y);
g[x].push_back(y);
g[y].push_back(x);
}
int ans = 1;
for (int i = 2; i < 200000; i++) {
if (ex[i].size() == 0) continue;
for (int v : ex[i]) {
dm = 0;
if (!us[v]) dfs(v, i);
ans = max(dm, ans);
}
for (int v : ex[i]) {
us[v] = 0;
dist[v] = 0;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> g;
vector<int> a;
int n;
vector<map<int, int>> dp;
int ans = 0;
int gcd(int a, int b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
void dfs(int v, int p = -1) {
for (auto to : g[v]) {
if (to != p) {
dfs(to, v);
if (gcd(a[v], a[to]) != 1) {
for (auto i : dp[to]) {
int y = gcd(a[v], i.first);
if (y != 1) {
for (auto c : dp[v])
if (gcd(c.first, i.first) != 1)
ans = max(ans, i.second + c.second);
}
}
for (auto i : dp[to]) {
int y = gcd(a[v], i.first);
if (y != 1) {
dp[v][y] = max(dp[v][y], i.second + 1);
ans = max(ans, i.second + 1);
}
}
}
}
}
}
signed main() {
std::ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
g.resize(n);
a.resize(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
dp.resize(n);
for (int i = 0; i < n - 1; ++i) {
int x, y;
cin >> x >> y;
x--, y--;
g[x].push_back(y);
g[y].push_back(x);
}
for (int i = 0; i < n; ++i) {
if (a[i] != 1) {
ans = 1;
dp[i][a[i]] = 1;
}
}
if (!ans) {
cout << 0;
return 0;
}
dfs(0);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200002;
vector<int> tree[N], divs[N];
bool centroidMarked[N];
int n, m, siz[N], a[N], g[N][200];
int gcd(int a, int b) {
if (!b) return a;
if (b < 200) {
if (g[a][b]) return g[a][b];
return g[a][b] = gcd(b, a % b);
}
return gcd(b, a % b);
}
void DFS(int node, int p, int& n) {
n += 1;
siz[node] = 1;
for (int ch : tree[node])
if (ch != p && !centroidMarked[ch]) {
DFS(ch, node, n);
siz[node] += siz[ch];
}
}
int getCentroid(int node, int p, int n) {
bool is_centroid = true;
int heaviest_child = 0;
for (int ch : tree[node])
if (ch != p && !centroidMarked[ch]) {
if (siz[ch] > n / 2) is_centroid = false;
if (heaviest_child == 0 || siz[ch] > siz[heaviest_child])
heaviest_child = ch;
}
if (is_centroid && n - siz[node] <= n / 2) return node;
return getCentroid(heaviest_child, node, n);
}
int getCentroid(int src) {
int n = 0;
DFS(src, -1, n);
int centroid = getCentroid(src, -1, n);
centroidMarked[centroid] = true;
return centroid;
}
int has[N];
long long ans[N];
void add(int node, int p, int g, int v) {
has[g] += v;
for (int ch : tree[node])
if (!centroidMarked[ch] && ch != p) {
add(ch, node, gcd(g, a[ch]), v);
}
}
void calc(int node, int p, int g, int root) {
for (int d : divs[a[root]]) ans[gcd(g, d)] += has[d];
for (int ch : tree[node])
if (!centroidMarked[ch] && ch != p) {
calc(ch, node, gcd(g, a[ch]), root);
}
}
int decomposeTree(int root) {
int cend_tree = getCentroid(root);
add(cend_tree, -1, a[cend_tree], 1);
++ans[a[cend_tree]];
for (int ch : tree[cend_tree]) {
if (!centroidMarked[ch]) {
int g = gcd(a[cend_tree], a[ch]);
add(ch, cend_tree, g, -1);
calc(ch, cend_tree, g, cend_tree);
}
}
for (int d : divs[a[cend_tree]]) has[d] = 0;
for (int ch : tree[cend_tree])
if (!centroidMarked[ch]) decomposeTree(ch);
return cend_tree;
}
void init() {
for (int(i) = (1); (i) <= (int)(N - 1); (i)++)
for (int j = i; j < N; j += i) divs[j].push_back(i);
}
int main(int argc, const char* argv[]) {
init();
scanf("%d", &n);
for (int(i) = (1); (i) <= (int)(n); (i)++) scanf("%d", &a[i]);
for (int(i) = (2); (i) <= (int)(n); (i)++) {
int a, b;
scanf("%d%d", &a, &b);
tree[a].push_back(b), tree[b].push_back(a);
}
decomposeTree(1);
for (int(i) = (1); (i) <= (int)(N - 1); (i)++)
if (ans[i]) printf("%d %lld\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 1;
vector<int> adj[N];
int numDiv[N];
int a[N];
bool cand[N];
int sz[N], dsu[N];
int f(int x) {
if (x == dsu[x]) {
return x;
}
return dsu[x] = f(dsu[x]);
}
void merge(int x, int y) {
x = f(x), y = f(y);
if (x != y) {
dsu[x] = y;
sz[y] += sz[x];
}
}
int val[N];
int numPrime[N];
long long all[N];
vector<int> in[N];
int lastColor[N];
int isGood[N];
int curColorList[N];
int go[N];
int bfs(int root, int curColor) {
int sz = 0;
queue<int> q;
q.push(root);
lastColor[root] = curColor;
while (!q.empty()) {
int node = q.front();
q.pop();
++sz;
for (int i = 0; i < (int)adj[node].size(); ++i) {
int nextNode = adj[node][i];
if (isGood[nextNode] == curColor && lastColor[nextNode] < curColor) {
lastColor[nextNode] = curColor;
q.push(nextNode);
}
}
}
return sz;
}
void solve() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
in[a[i]].push_back(i);
}
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d %d ", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
int g = N;
for (int i = 1; i < N; ++i) {
val[i] = 1;
}
int maxi = 0;
for (int i = 2; i < N; ++i) {
if (val[i] == 1) {
for (int j = i; j < N; j += i) {
val[j] *= i;
numPrime[j] ^= 1;
}
}
}
int curColor = 1;
int lim = (int)2e5;
int pos;
for (int num = lim; num >= 1; --num) {
++curColor;
pos = 0;
for (int j = num; j <= lim; j += num) {
for (auto node : in[j]) {
if (isGood[node] != curColor) {
isGood[node] = curColor;
curColorList[pos++] = node;
}
}
}
long long tmp = 0;
for (int i = 0; i < pos; ++i) {
int node = curColorList[i];
if (lastColor[node] < curColor) {
int sz = bfs(node, curColor);
tmp += (long long)sz * (sz + 1);
}
}
tmp /= 2;
all[num] = tmp;
}
for (int num = 1; num <= lim; ++num) {
int g = 1;
long long ret = 0;
for (int j = num; j <= lim; j += num, ++g) {
if (val[g] == g) {
if (numPrime[g]) {
ret -= all[j];
} else {
ret += all[j];
}
}
}
if (ret > 0) {
printf("%d %lld\n", num, ret);
}
}
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
inline int readChar();
template <class T = int>
inline T readInt();
template <class T>
inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len) pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len) return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32) c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-') s = -1, c = getChar();
while ('0' <= c && c <= '9') x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0) writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n) s[n++] = '0' + x % 10, x /= 10;
while (n--) writeChar(s[n]);
if (end) writeChar(end);
}
inline void writeWord(const char *s) {
while (*s) writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos) fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
inline void readWord(char *s) {
int c = readChar();
while (c > 32) *s++ = c, c = getChar();
*s = 0;
}
inline void writeDouble(double x, int output_len) {
if (x < 0) writeChar('-'), x = -x;
int t = (int)x;
writeInt(t), x -= t;
writeChar('.');
for (int i = output_len - 1; i > 0; i--) {
x *= 10;
t = min(9, (int)x);
writeChar('0' + t), x -= t;
}
x *= 10;
t = min(9, (int)(x + 0.5));
writeChar('0' + t);
}
const int nax = 2e5 + 1;
int n;
int a[nax];
vector<int> g[nax];
vector<int> pd[nax], ve[nax];
bool prime[nax];
int dep[nax];
int curd;
int opt, vb;
int ans;
int sts;
int st[nax];
void bfs(int v) {
queue<int> q;
q.push(v);
while (!q.empty()) {
int v = q.front();
q.pop();
st[sts++] = v;
if (dep[v] > opt) {
opt = dep[v];
vb = v;
if (opt > ans) {
ans = opt;
}
}
for (int to : g[v]) {
if (a[to] % curd == 0 && dep[to] == -1) {
dep[to] = dep[v] + 1;
q.push(to);
}
}
}
}
int main() {
n = readInt();
for (int i = 0; i < n; i++) {
a[i] = readInt();
}
for (int i = 0; i < n - 1; i++) {
int u, v;
u = readInt() - 1;
v = readInt() - 1;
g[u].push_back(v);
g[v].push_back(u);
}
memset(prime, true, sizeof(prime));
for (int i = 2; i < 200001; i++) {
if (prime[i]) {
for (int j = i; j < 200001; j += i) {
pd[j].push_back(i);
prime[j] = false;
}
}
}
for (int i = 0; i < n; i++) {
for (int d : pd[a[i]]) {
ve[d].push_back(i);
}
}
memset(dep, -1, sizeof(dep));
for (curd = 2; curd < 200001; curd++) {
for (int u : ve[curd]) {
if (dep[u] == -1) {
dep[u] = 1;
opt = 0;
bfs(u);
for (int i = 0; i < sts; i++) {
dep[st[i]] = -1;
}
dep[vb] = 1;
sts = 0;
bfs(vb);
sts = 0;
}
}
for (int u : ve[curd]) {
dep[u] = -1;
}
}
writeInt(ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 2e5 + 10;
int arr[N_MAX];
long long ans[N_MAX];
map<int, long long> p[N_MAX];
vector<int> g[N_MAX];
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
void dfs(int u, int f) {
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == f) continue;
dfs(v, u);
for (auto it : p[v])
if (it.second) {
for (auto ti : p[u])
if (ti.second) {
ans[gcd(it.first, ti.first)] += it.second * ti.second;
}
}
for (auto it : p[v])
if (it.second) {
p[u][gcd(arr[u], it.first)] += it.second;
}
p[v].clear();
}
p[u][arr[u]]++;
for (auto it : p[u]) {
ans[it.first] += it.second;
}
}
int main() {
int N;
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", arr + 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, 1);
for (int i = 1; i < N_MAX; i++)
if (ans[i]) {
printf("%d %lld\n", i, ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, S = 2e5;
int tot, cnt, n, p[N], mark[N], a[N], f[N], size[N], mu[N], e[N][2];
long long ans, g[N];
vector<int> v[N];
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
void link(int x, int y, int z) {
e[++tot][0] = x, e[tot][1] = y;
for (int i = 1; i * i <= z; i++) {
if (z % i) continue;
v[i].push_back(tot);
if (i * i != z) v[z / i].push_back(tot);
}
}
int get(int x) { return x == f[x] ? x : f[x] = get(f[x]); }
signed main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) size[i] = 1, f[i] = i, scanf("%d", &a[i]);
for (int i = 1, x, y; i < n; i++) {
scanf("%d%d", &x, &y);
link(x, y, gcd(a[x], a[y]));
}
mu[1] = 1;
for (int i = 2; i <= S; i++) {
if (!mark[i]) {
p[++cnt] = i;
mu[i] = -1;
}
for (int j = 1; j <= cnt; j++) {
if (i * p[j] > S) break;
mark[i * p[j]] = 1;
if (i % p[j] == 0) break;
mu[i * p[j]] = -mu[i];
}
}
for (int i = 1; i <= S; i++) {
for (int j = 0; j < v[i].size(); j++) {
int l = get(e[v[i][j]][0]), r = get(e[v[i][j]][1]);
g[i] += 1ll * size[l] * size[r];
size[r] += size[l];
f[l] = r;
}
for (int j = 0; j < v[i].size(); j++) {
for (int k = 0; k < 2; k++) {
size[e[v[i][j]][k]] = 1;
f[e[v[i][j]][k]] = e[v[i][j]][k];
}
}
}
for (int i = 1; i <= n; i++) f[i] = 0;
for (int i = 1; i <= n; i++) f[a[i]]++;
for (int i = 1; i <= S; i++) {
ans = f[i];
for (int j = i; j <= S; j += i) ans += mu[j / i] * g[j];
if (ans) printf("%d %lld\n", i, ans);
}
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(int x) {
vector<int> ans;
for (int j = 1; j * j <= x; j++)
if (x % j == 0) {
ans.push_back(j);
if (x / j != j) ans.push_back(x / j);
}
return ans;
}
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);
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 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;
}
unordered_map<int, int> now;
unordered_map<int, int> MP;
unordered_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);
}
}
vector<pair<int, long long> > Ans;
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) Ans.push_back(now);
sort(Ans.begin(), Ans.end());
for (auto now : Ans) printf("%d %I64d\n", now.first, now.second);
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 9;
int lp[M + 9];
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<int> pr;
for (int i = 2; i < M; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (int j = 0; j < (int)pr.size() && pr[j] <= lp[i] && i * pr[j] <= M; ++j)
lp[i * pr[j]] = pr[j];
}
int n;
cin >> n;
vector<int> a(n + 1);
vector<vector<int>> f(n + 1);
bool all1 = 1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] > 1) all1 = 0;
int x = a[i];
while (x > 1) {
int k = lp[x];
while (x % k == 0) x /= k;
f[i].push_back(k);
}
}
if (all1) return cout << 0, 0;
vector<vector<int>> g(n + 1);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
int ans = 1;
vector<map<int, int>> f1(n + 1);
function<void(int, int)> dfs = [&](int u, int par) {
if (g[u].size() == 1 && u != 1) {
for (int ff : f[u]) f1[u][ff] = 1;
return;
}
map<int, int> mx1, mx2;
for (int ff : f[u]) mx1[ff] = mx2[ff] = 0;
for (int v : g[u]) {
if (v == par) continue;
dfs(v, u);
for (int ff : f[u]) {
if (a[v] % ff == 0) {
int t1 = f1[v][ff];
if (t1 >= mx1[ff]) {
mx2[ff] = mx1[ff];
mx1[ff] = t1;
} else if (t1 > mx2[ff]) {
mx2[ff] = t1;
}
ans = max(ans, mx1[ff] + mx2[ff] + 1);
}
}
}
for (int ff : f[u]) {
f1[u][ff] = 1 + mx1[ff];
}
};
dfs(1, 0);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int inf = 0x3f3f3f3f;
const int MAX = 2e5 + 2;
template <class T>
inline void read(T &x) {
T f = 1;
x = 0;
char s = getchar();
while (s < '0' || s > '9') {
if (s == '-') f = -1;
s = getchar();
}
while (s >= '0' && s <= '9') {
x = x * 10 + s - '0';
s = getchar();
}
x *= f;
}
int n, a[N], u[N], v[N], fa[N], siz[N], pr[N], p[N], tot, mu[N], vis[N];
inline void sieve() {
mu[1] = 1;
for (int i = (2); i <= (MAX); i++) {
if (!pr[i]) mu[i] = -1, p[++tot] = i;
for (int j = 1; j <= tot && i * p[j] <= MAX; j++) {
pr[i * p[j]] = 1;
if (i % p[j] == 0) {
mu[i * p[j]] = 0;
break;
}
mu[i * p[j]] = -mu[i];
}
}
}
inline int find(int x) { return (fa[x] == x) ? x : fa[x] = find(fa[x]); }
long long ans;
inline void merge(int x, int y) {
ans -= 1ll * siz[x] * (1 + siz[x]) / 2;
ans -= 1ll * siz[y] * (1 + siz[y]) / 2;
fa[y] = x;
siz[x] += siz[y];
ans += 1ll * siz[x] * (1 + siz[x]) / 2;
}
vector<int> ed[N], nd[N];
inline int gcd(int x, int y) { return (!y) ? x : gcd(y, x % y); }
long long rans[N], as[N];
inline void solve() {
sieve();
read(n);
for (int i = (1); i <= (n); i++) {
read(a[i]);
nd[a[i]].push_back(i);
}
for (int i = (1); i <= (n); i++) fa[i] = i, siz[i] = 1;
for (int i = (1); i <= (n - 1); i++) {
read(u[i]);
read(v[i]);
int tmp = gcd(a[u[i]], a[v[i]]);
for (int j = 1; j * j <= tmp; j++)
if (tmp % j == 0) {
ed[j].push_back(i);
if (j != (tmp / j)) ed[tmp / j].push_back(i);
}
}
for (int G = (1); G <= (MAX); G++) {
ans = 0;
for (int j = G; j <= MAX; j += G) {
ans += nd[j].size();
for (int x : nd[j]) fa[x] = x, siz[x] = 1;
}
for (int i : ed[G]) merge(find(u[i]), find(v[i]));
as[G] = ans;
for (int i : ed[G]) vis[u[i]] = 0, vis[v[i]] = 0;
}
for (int i = (1); i <= (MAX); i++)
for (int j = i; j <= MAX; j += i) rans[i] += as[j] * mu[j / i];
for (int i = (1); i <= (MAX); i++)
if (rans[i]) printf("%d %lld\n", i, rans[i]);
}
int main() { solve(); }
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
vector<int> ady[maxn];
int A[maxn];
map<int, int> dp[maxn];
bool mk[maxn];
int ans = 0;
void solve(int nodo) {
mk[nodo] = 1;
for (int i : ady[nodo]) {
if (!mk[i]) {
solve(i);
for (auto &j : dp[nodo]) {
int x = dp[i][j.first];
ans = (ans > j.second + x) ? ans : j.second + x;
j.second = (j.second > x + 1) ? j.second : x + 1;
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int N;
cin >> N;
for (int i = 1; i <= N; i++) {
int a;
cin >> a;
if (N == 1) {
if (a != 1) {
cout << 1;
} else
cout << 0;
return 0;
}
if (!(a & 1)) {
dp[i][2] = 1;
while (!(a & 1)) {
a >>= 1;
}
}
for (int j = 3; j * j <= a; j += 2) {
if (a % j == 0) {
dp[i][j] = 1;
while (a % j == 0) {
a /= j;
}
}
}
if (a != 1) dp[i][a] = 1;
}
for (int i = 1; i < N; i++) {
int a, b;
cin >> a >> b;
ady[a].push_back(b);
ady[b].push_back(a);
}
solve(1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 0x3f3f3f3f;
const long long mod = 1e9;
const double PI = acos(-1.0);
const double eps = 1e-7;
const int maxn = 2e5 + 7;
int n;
int a[maxn];
vector<int> g[maxn];
int ans = 0;
map<int, int> dfs(int now, int fa) {
map<int, int> mp, sp;
for (int i = 2; i * i <= a[now]; ++i) {
if (a[now] % i == 0) {
mp[i] = 1;
while (a[now] % i == 0) a[now] /= i;
}
}
if (a[now] != 1) mp[a[now]] = 1;
if (g[now].size() == 1 && fa != 0) {
return mp;
}
map<int, int>::iterator it;
for (int i = 0; i < g[now].size(); ++i) {
int to = g[now][i];
if (to == fa) continue;
sp = dfs(to, now);
for (it = mp.begin(); it != mp.end(); it++) {
if (sp.find(it->first) != sp.end()) {
ans = max(ans, it->second + sp[it->first]);
it->second = max(it->second, sp[it->first] + 1);
}
}
}
return mp;
}
int main() {
scanf("%d", &n);
int cnt = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
if (a[i] == 1) cnt++;
}
if (cnt != n) ans = 1;
for (int i = 0; i < n - 1; ++i) {
int x, y;
scanf("%d %d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int cnt, p[N], d[N], mu[N], a[N], b[N], c[N];
long long res[N];
bool vis[N];
vector<int> e[N], vec[N];
vector<int> mp[N];
void solve(int i, int cnt, int sz, int x) {
if (i == cnt) {
vec[x].push_back(sz);
return;
}
int p = 1;
for (int j = 0; j <= c[i]; j++) {
solve(i + 1, cnt, sz * p, x);
p *= b[i];
}
}
void solve(int i, int u) {
int m = i, cnt = 0;
while (m != 1) {
int p = d[m];
b[cnt] = p;
c[cnt] = 0;
while (m != 1 && m % p == 0) {
c[cnt]++;
m /= p;
}
cnt++;
}
solve(0, cnt, 1, u);
sort(vec[u].begin(), vec[u].end());
}
void init() {
memset(vis, false, sizeof(vis));
cnt = 0;
vis[0] = vis[1] = true;
mu[1] = 1;
for (int i = 2; i < N; i++) {
if (!vis[i]) {
p[cnt++] = i;
mu[i] = -1;
d[i] = i;
}
for (int j = 0; j < cnt && 1ll * i * p[j] < N; j++) {
vis[i * p[j]] = true;
d[i * p[j]] = p[j];
if (i % p[j] == 0) {
mu[i * p[j]] = 0;
break;
}
mu[i * p[j]] = mu[i] * -1;
}
}
}
void dfs(int u, int pre) {
if (vec[a[u]].size() == 0) solve(a[u], a[u]);
for (int v : vec[a[u]]) {
mp[u].push_back(1);
res[v]++;
}
for (int v : e[u]) {
if (v == pre) continue;
dfs(v, u);
int p = 0;
for (int j = 0; j < vec[a[v]].size(); j++) {
int w = vec[a[v]][j];
if (a[u] % w != 0) continue;
while (p < vec[a[u]].size() && w != vec[a[u]][p]) p++;
res[w] += 1ll * mp[u][p] * mp[v][j];
mp[u][p] += mp[v][j];
}
mp[v].clear();
}
}
int main() {
int n, u, v;
init();
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + 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, 0);
for (int i = 1; i < N; i++) {
long long ans = 0;
for (int j = 1; 1ll * j * i < N; j++) {
ans = ans + mu[j] * res[i * j];
}
if (ans != 0) {
printf("%d %lld\n", i, ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
long double EPS = 1e-9;
long double pi = acos(-1.0);
const int N = 2 * (1e5 + 20);
vector<int> g[N];
bool visited[N];
int value[N], maxi = 1;
set<int> get_primes(int n) {
set<int> fac;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
while (n % i == 0) n /= i;
fac.insert(i);
}
}
if (n > 1) fac.insert(n);
return fac;
}
map<int, int> dfs(int u, int par) {
map<int, map<int, int> > m;
map<int, int> go;
for (auto x : g[u])
if (x != par) m[x] = dfs(x, u);
set<int> my;
my = get_primes(value[u]);
if ((g[u]).size() == 1 and u != 1) {
for (auto x : my) go[x] = 1;
return go;
}
bool glob = false;
for (auto p : my) {
vector<int> temp;
bool chi = false;
for (auto x : g[u])
if (m[x][p] != 0) temp.push_back(m[x][p]), chi = true, glob = true;
sort((temp).begin(), (temp).end());
reverse((temp).begin(), (temp).end());
if (chi) go[p] = temp[0] + 1, maxi = max(maxi, 1 + temp[0]);
if (chi and (temp).size() >= 2) maxi = max(maxi, temp[0] + temp[1] + 1);
}
if (!glob)
for (auto x : my) go[x] = 1;
return go;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
bool unos = true;
for (int i = 1; i <= n; i++) {
cin >> value[i];
if (value[i] != 1) unos = false;
}
for (long long int i = (long long int)(0); i < (long long int)(n - 1); i++) {
int n1, n2;
cin >> n1 >> n2;
g[n1].push_back(n2);
g[n2].push_back(n1);
}
map<int, int> asd;
asd = dfs(1, -1);
if (unos)
cout << 0;
else
cout << maxi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch;
while (!isdigit(ch = getchar()))
;
int x = ch - '0';
while (isdigit(ch = getchar())) x = x * 10 + ch - '0';
return x;
}
const int MAXN = 2e5 + 5;
const int INF = 1e9;
int n, a[MAXN], S, f[MAXN], sz[MAXN], rt, ans;
bool vis[MAXN];
vector<int> P[MAXN], G[MAXN];
void get_root(int u, int fa_u) {
sz[u] = 1;
f[u] = 0;
for (int i = 0; i < (int)G[u].size(); ++i) {
int v = G[u][i];
if (v == fa_u || vis[v]) continue;
get_root(v, u);
sz[u] += sz[v];
f[u] = max(f[u], sz[v]);
}
f[u] = max(f[u], S - sz[u]);
if (f[u] < f[rt]) rt = u;
}
int dfs(int u, int fa_u, int g) {
if (a[u] % g) return 0;
int k = 1;
for (int i = 0; i < (int)G[u].size(); ++i) {
int v = G[u][i];
if (v == fa_u || vis[v]) continue;
k = max(k, dfs(v, u, g) + 1);
}
return k;
}
void dfz(int u, int fa_u) {
sz[u] = 1;
for (int i = 0; i < (int)G[u].size(); ++i) {
int v = G[u][i];
if (v == fa_u || vis[v]) continue;
dfz(v, u);
sz[u] += sz[v];
}
}
void work(int u) {
vis[u] = 1;
dfz(u, 0);
for (int i = 0; i < (int)P[a[u]].size(); ++i) {
int t1 = 0, t2 = 0;
for (int j = 0; j < (int)G[u].size(); ++j) {
if (vis[G[u][j]]) continue;
int k = dfs(G[u][j], u, P[a[u]][i]);
if (k > t1)
t2 = t1, t1 = k;
else if (k > t2)
t2 = k;
}
ans = max(ans, t1 + t2 + 1);
}
for (int i = 0; i < (int)G[u].size(); ++i) {
int v = G[u][i];
if (vis[v]) continue;
if (sz[v] < ans) continue;
f[rt = 0] = INF;
S = sz[v];
get_root(v, 0);
work(rt);
}
}
int main() {
ios::sync_with_stdio(0);
for (int i = 2; i <= 200000; ++i) {
if (!vis[i]) {
for (int j = 1; j * i <= 200000; ++j) {
vis[j * i] = 1;
P[j * i].push_back(i);
}
}
}
memset(vis, 0, sizeof(vis));
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
G[u].push_back(v);
G[v].push_back(u);
}
f[rt = 0] = INF;
S = n;
get_root(1, 0);
work(rt);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[400005];
long long Ans[400005];
int TOT, LA[400005], NE[400005], EN[400005];
int Min, rt, sz[400005];
bool mark[400005];
void Link(int x, int y) {
EN[++TOT] = y;
NE[TOT] = LA[x];
LA[x] = TOT;
EN[++TOT] = x;
NE[TOT] = LA[y];
LA[y] = TOT;
}
void Gsi(int x, int f) {
int i, y;
sz[x] = 1;
for (i = LA[x]; i; i = NE[i]) {
y = EN[i];
if (y == f || mark[y]) continue;
Gsi(y, x);
sz[x] += sz[y];
}
}
void Grt(int x, int d, int f) {
int i, y, Max = d - sz[x];
for (i = LA[x]; i; i = NE[i]) {
y = EN[i];
if (y == f || mark[y]) continue;
Grt(y, d, x);
Max = max(Max, sz[y]);
}
if (Max < Min) Min = Max, rt = x;
}
map<int, int> Q;
map<int, int>::iterator it;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
void getans(int x, int d, int f) {
for (it = Q.begin(); it != Q.end(); ++it)
Ans[gcd(it->first, d)] += it->second;
for (int i = LA[x]; i; i = NE[i]) {
int y = EN[i];
if (y == f || mark[y]) continue;
getans(y, gcd(d, a[y]), x);
}
}
void modify(int x, int d, int f) {
Q[d]++;
for (int i = LA[x]; i; i = NE[i]) {
int y = EN[i];
if (y == f || mark[y]) continue;
modify(y, gcd(d, a[y]), x);
}
}
void Getans(int x) {
int i, j, k, y;
Q.clear();
Q[a[x]] = 1;
Ans[a[x]]++;
for (i = LA[x]; i; i = NE[i]) {
y = EN[i];
if (mark[y]) continue;
k = gcd(a[x], a[y]);
getans(y, k, x);
modify(y, k, x);
}
}
void DC(int x) {
mark[x] = 1;
int i, y;
Getans(x);
for (i = LA[x]; i; i = NE[i]) {
y = EN[i];
if (mark[y]) continue;
Min = 1e9;
Gsi(y, x);
Grt(y, sz[y], x);
DC(rt);
}
}
int main() {
int i, j, k, x, y, z;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
Link(x, y);
}
Min = 1e9;
Gsi(1, 0);
Grt(1, n, 0);
DC(rt);
for (i = 1; i < 400005; i++)
if (Ans[i]) printf("%d %I64d\n", i, Ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e5 + 1;
vector<vector<int>> adjList(MAX);
vector<int> mxd(MAX);
int dfs(int nd, int md) {
int res = 1;
mxd[nd] = 0;
for (int cd : adjList[nd]) {
if (mxd[cd] == md) {
res += dfs(cd, md);
}
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
vector<int> a(n);
vector<vector<int>> p(MAX);
for (int i = 0; i < n; i++) {
cin >> a[i];
vector<int> divs;
for (int j = 2; j * j <= a[i]; j++) {
if (a[i] % j == 0) {
p[j].push_back(i);
if (j * j != a[i]) p[a[i] / j].push_back(i);
}
}
p[a[i]].push_back(i);
}
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
u--, v--;
adjList[u].push_back(v);
adjList[v].push_back(u);
}
vector<long long> ans(MAX);
ans[1] = (n * (n - 1)) / 2 + n;
for (int i = 2; i < MAX; i++) {
for (int nd : p[i]) {
mxd[nd] = i;
}
for (int nd : p[i]) {
if (mxd[nd] == i) {
long long sz = (long long)dfs(nd, i);
ans[i] += (sz * (sz - 1)) / 2 + sz;
}
}
}
for (int i = MAX - 1; i >= 1; i--) {
for (int j = 2 * i; j < MAX; j += i) {
ans[i] -= ans[j];
}
}
for (int i = 1; i < MAX; i++) {
if (ans[i] != 0) {
cout << i << " " << ans[i] << '\n';
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 200000 + 5, inf = 9e17;
long long ans;
map<long long, long long> dp[maxn], mp[maxn];
vector<long long> adj[maxn], pfac[maxn];
long long a[maxn], n;
bool o;
inline void dfs(long long u, long long fa) {
long long v, x;
for (int j = 0; j < pfac[u].size(); j++) {
x = pfac[u][j];
dp[u][x] = max(dp[u][x], 1ll);
ans = max(ans, dp[u][x]);
}
for (int i = 0; i < adj[u].size(); i++) {
v = adj[u][i];
if (v == fa) continue;
dfs(v, u);
for (int j = 0; j < pfac[u].size(); j++) {
x = pfac[u][j];
if (!mp[v][x]) continue;
ans = max(ans, dp[u][x] + dp[v][x]);
dp[u][x] = max(dp[u][x], dp[v][x] + 1);
}
}
return;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
long long u, v;
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int i = 1; i <= n; i++) {
for (int j = 2; j * j <= a[i]; j++) {
o = 0;
while (a[i] % j == 0) {
a[i] /= j;
o = 1;
}
if (o) {
pfac[i].push_back(j);
mp[i][j] = 1;
}
}
if (a[i] != 1) {
pfac[i].push_back(a[i]);
mp[i][a[i]] = 1;
}
sort(pfac[i].begin(), pfac[i].end());
}
dfs(1, 0);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> adjList[200010];
vector<int> factors[200010];
vector<int> nodes[200010];
int parents[200010];
bool valid[200010];
long long int ans[200010];
int P[200010], R[200010];
int findS(int x) {
if (P[x] != x) P[x] = findS(P[x]);
return P[x];
}
void mergeS(int x, int y) {
x = findS(x);
y = findS(y);
if (R[x] > R[y])
P[x] = y;
else
P[y] = x;
if (R[x] == R[y]) R[y] += 1;
}
void dfs(int u, int p) {
parents[u] = p;
for (auto v : adjList[u])
if (v != p) dfs(v, u);
}
int main() {
for (int i = 1; i < 200010; i++)
for (int j = i; j < 200010; j += i) factors[j].push_back(i);
int N;
cin >> N;
vector<int> nos(N);
for (int i = 0; i < N; i++) cin >> nos[i];
for (int i = 0; i < N; i++)
for (auto x : factors[nos[i]]) nodes[x].push_back(i);
for (int i = 0; i < N - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
adjList[x].push_back(y);
adjList[y].push_back(x);
}
dfs(0, -1);
for (int i = 0; i < 200010; i++) P[i] = i;
for (int i = 0; i < 200010; i++) R[i] = 0;
for (int i = 0; i < 200010; i++) {
for (auto x : nodes[i]) valid[x] = true;
for (auto x : nodes[i])
if (parents[x] != -1 && valid[parents[x]]) mergeS(x, parents[x]);
map<int, long long> m;
for (auto x : nodes[i]) m[findS(x)] += 1;
long long total = 0;
for (auto p : m) total += ((p.second) * (p.second + 1)) >> 1;
ans[i] = total;
for (auto x : nodes[i]) P[x] = x;
for (auto x : nodes[i]) R[x] = 0;
for (auto x : nodes[i]) valid[x] = false;
}
for (int i = 200010 - 1; i >= 1; i--)
for (int j = 2 * i; j < 200010; j += i) ans[i] -= ans[j];
for (int i = 0; i < 200010; i++)
if (ans[i] != 0) cout << i << " " << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxi = 2e5 + 79;
vector<vector<int> > f(maxi);
vector<vector<int> > g;
bitset<maxi> col;
void factor(int x, int info) {
for (int i = 1; i * i <= x; i++) {
if (x % i == 0) {
f[i].push_back(info);
if (i != x / i) {
f[x / i].push_back(info);
}
}
}
}
int dfs(int vr, int p = -1) {
int cnt = 1;
col[vr] = 0;
for (int i : g[vr]) {
if (i != p && col[i]) {
cnt += dfs(i, vr);
}
}
return cnt;
}
vector<long long> cnt(maxi, 0);
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
g.resize(n);
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
factor(a[i], i);
}
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);
}
for (int i = 1; i < maxi; i++) {
for (int j : f[i]) {
col[j] = 1;
}
for (int j : f[i]) {
if (col[j]) {
long long d = dfs(j);
cnt[i] += (d * (d + 1)) / 2;
}
}
}
for (int i = maxi - 1; i >= 1; i--) {
for (int j = 2 * i; j < maxi; j += i) {
cnt[i] -= cnt[j];
}
}
for (int i = 1; i < maxi; i++) {
if (cnt[i]) {
cout << i << " " << cnt[i] << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
int val[maxn], num[maxn], root, siz, f[maxn], deep[maxn];
bool done[maxn];
vector<int> g[maxn];
map<int, int> mp, tp;
int res = 0;
int gcd(int x, int y) { return y == 0 ? x : gcd(y, x % y); }
void getroot(int u, int fa) {
num[u] = 1;
f[u] = 0;
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa || done[v]) continue;
getroot(v, u);
num[u] += num[v];
f[u] = max(f[u], num[v]);
}
f[u] = max(f[u], siz - num[u]);
if (f[u] < f[root]) root = u;
}
void cal(int u, int fa, int n) {
if (n == 1) return;
tp[n] = max(tp[n], deep[u]);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
if (v == fa || done[v]) continue;
deep[v] = deep[u] + 1;
cal(v, u, gcd(n, val[v]));
}
}
int solve(int u) {
mp.clear();
deep[u] = 0;
done[u] = true;
map<int, int>::iterator it1, it2;
if (val[u] == 1) return 0;
mp[val[u]] = 1;
res = max(res, 1);
for (int i = 0; i < g[u].size(); i++) {
int v = g[u][i];
tp.clear();
if (done[v]) continue;
deep[v] = 2;
cal(v, u, gcd(val[v], val[u]));
for (it1 = mp.begin(); it1 != mp.end(); it1++)
for (it2 = tp.begin(); it2 != tp.end(); it2++)
if (gcd(it1->first, it2->first) > 1) {
res = max(res, it1->second + it2->second - 1);
}
for (it2 = tp.begin(); it2 != tp.end(); it2++)
mp[it2->first] = max(mp[it2->first], it2->second);
}
}
void divide(int u, int fa) {
solve(u);
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] == fa || done[g[u][i]]) continue;
siz = num[g[u][i]];
root = 0;
getroot(g[u][i], u);
divide(root, -1);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &val[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);
}
f[0] = 0x3f3f3f3f;
root = 0;
siz = n;
getroot(1, -1);
divide(root, -1);
printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const int maxm = 1e3 + 10;
int head[maxn], to[maxn << 1], nxt[maxn << 1], tot;
void add(int u, int v) {
++tot, to[tot] = v, nxt[tot] = head[u], head[u] = tot;
++tot, to[tot] = u, nxt[tot] = head[v], head[v] = tot;
}
map<int, int> mp[maxn];
map<int, int> dp[maxn];
int a[maxn], isp[maxm], v[maxm], cnt;
void init() {
cnt = 0;
memset(v, 0, sizeof(v));
for (int i = 2; i < maxm; i++) {
if (!v[i]) v[i] = i, isp[cnt++] = i;
for (int j = 0; j < cnt; j++) {
if (1ll * i * isp[j] >= maxm) break;
v[i * isp[j]] = isp[j];
if (i % isp[j] == 0) break;
}
}
}
void solve(int x) {
int now = a[x];
for (int i = 0; i < cnt; i++) {
if (now % isp[i] == 0) {
mp[x][isp[i]] = 1;
while (now % isp[i] == 0) now /= isp[i];
}
if (x == 1) break;
}
if (now != 1) mp[x][now] = 1;
}
int ans;
void dfs1(int u, int pre) {
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == pre) continue;
dfs1(v, u);
for (auto x : mp[u]) {
if (mp[v].count(x.first)) {
if (mp[v][x.first] + 1 > mp[u][x.first]) {
dp[u][x.first] = mp[u][x.first];
mp[u][x.first] = mp[v][x.first] + 1;
} else
dp[u][x.first] = max(dp[u][x.first], mp[v][x.first] + 1);
}
ans = max(ans, mp[u][x.first]);
}
}
}
void dfs2(int u, int pre) {
for (int i = head[u]; i; i = nxt[i]) {
int v = to[i];
if (v == pre) continue;
for (auto x : mp[v]) {
if (mp[u].count(x.first)) {
if (mp[u][x.first] == mp[v][x.first] + 1) {
if (dp[u][x.first] + 1 > mp[v][x.first]) {
dp[v][x.first] = mp[v][x.first];
mp[v][x.first] = dp[u][x.first] + 1;
} else
dp[v][x.first] = max(dp[v][x.first], dp[u][x.first] + 1);
} else if (mp[u][x.first] + 1 > mp[v][x.first]) {
dp[v][x.first] = mp[v][x.first];
mp[v][x.first] = mp[u][x.first] + 1;
} else
dp[v][x.first] = max(dp[v][x.first], mp[u][x.first] + 1);
}
ans = max(ans, mp[v][x.first]);
}
dfs2(v, u);
}
}
int main() {
init();
int n;
scanf("%d", &n);
ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
solve(i);
if (a[i] > 1) ans = 1;
}
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
}
dfs1(1, 0), dfs2(1, 0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gcd(int x, int y) { return y ? gcd(y, x % y) : x; }
vector<int> a, vis;
vector<long long int> ans;
vector<vector<int> > ed, h;
int cnt, n, m, tim;
void dfs(int cur, int d) {
cnt++;
vis[cur] = tim;
for (auto i : ed[cur])
if (vis[i] != tim && a[i] % d == 0) dfs(i, d);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
ed.resize(n + 1);
a = vis = vector<int>(n + 1);
for (int i = 1; i <= n; i++) {
cin >> a[i];
m = max(m, a[i]);
}
ans.resize(m + 1);
h.resize(m + 1);
for (int i = 1; i <= n; i++) h[a[i]].push_back(i);
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
ed[u].push_back(v);
ed[v].push_back(u);
}
for (int i = m; i >= 1; i--) {
tim++;
for (int j = i; j <= m; j += i)
for (auto k : h[j]) {
if (vis[k] != tim) {
cnt = 0;
dfs(k, i);
ans[i] += (long long int)cnt * (cnt + 1) / 2;
}
}
for (int j = i + i; j <= m; j += i) ans[i] -= ans[j];
}
for (int i = 1; i <= m; i++)
if (ans[i]) cout << i << " " << ans[i] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int max_n = 2e5 + 5;
bool visited[max_n], open[max_n];
long long answer[max_n];
int value[max_n], counting[max_n];
vector<int> graf[max_n], val_nodes[max_n];
int dfs(int x) {
int ans = 0;
visited[x] = 1;
for (int i : graf[x])
if (open[i] && !visited[i]) ans += dfs(i);
return ans + 1;
}
void find_answer(int x) {
vector<int> nodes;
for (int i = x; i <= 2e5; i += x)
for (int j : val_nodes[i]) {
nodes.push_back(j);
open[j] = 1;
}
for (int i : nodes)
if (!visited[i]) {
long long component_size = dfs(i);
answer[x] += component_size * (component_size + 1) / 2;
}
for (int i = x * 2; i <= 2e5; i += x) answer[x] -= answer[i];
for (int i : nodes) {
visited[i] = 0;
open[i] = 0;
}
}
int 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 >> value[i];
val_nodes[value[i]].push_back(i);
}
for (int i = 1; i < n; i++) {
int a, b;
cin >> a >> b;
graf[a].push_back(b);
graf[b].push_back(a);
}
for (int i = 2e5; i; i--) find_answer(i);
for (int i = 1; i <= 2e5; i++)
if (answer[i]) cout << i << " " << answer[i] << "\n";
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 good[N], vis[N];
long long ans[N];
vector<int> factors(int x) {
vector<int> ans;
for (int j = 1; j * j <= x; j++)
if (x % j == 0) {
ans.push_back(j);
if (x / j != j) ans.push_back(x / j);
}
return ans;
}
int dfs(int u) {
int ans = 1;
vis[u] = 1;
for (auto v : adj[u])
if (good[v] && !vis[v]) ans += dfs(v);
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
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]) good[v] = true, vis[v] = false;
for (auto v : ind[i])
if (!vis[v]) {
int cnt = dfs(v);
ans[i] += 1LL * cnt * cnt;
}
for (auto v : ind[i]) good[v] = false;
}
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;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int N, A[200005];
int nex[400005], las[200005], en[400005], tot;
int sz[200005], totsz, mn, G;
bool vis[200005];
long long Ans[200005];
int cnt[200005];
vector<int> fac[200005];
void add(int x, int y) {
en[++tot] = y;
nex[tot] = las[x];
las[x] = tot;
}
void getsz(int x, int fa) {
int i, y;
sz[x] = 1;
totsz++;
for (i = las[x]; i; i = nex[i]) {
y = en[i];
if (y == fa || vis[y]) continue;
getsz(y, x);
sz[x] += sz[y];
}
}
void findg(int x, int fa) {
int i, y, mx = totsz - sz[x];
for (i = las[x]; i; i = nex[i]) {
y = en[i];
if (y == fa || vis[y]) continue;
findg(y, x);
mx = max(mx, sz[y]);
}
if (mx < mn) mn = mx, G = x;
}
void getg(int x) {
mn = 1e9;
totsz = 0;
getsz(x, 0);
findg(x, 0);
}
void modify(int x, int fa, int v) {
int i, y;
cnt[v]++;
for (i = las[x]; i; i = nex[i]) {
y = en[i];
if (y == fa || vis[y]) continue;
modify(y, x, gcd(v, A[y]));
}
}
void calc(int x, int fa, int v, int val) {
int i, y;
for (i = 0; i < fac[val].size(); i++)
if (cnt[fac[val][i]]) Ans[gcd(v, fac[val][i])] += cnt[fac[val][i]];
for (i = las[x]; i; i = nex[i]) {
y = en[i];
if (y == fa || vis[y]) continue;
calc(y, x, gcd(v, A[y]), val);
}
}
void DC(int x) {
int i, y;
vis[x] = true;
cnt[A[x]] = 1;
Ans[A[x]]++;
for (i = las[x]; i; i = nex[i]) {
y = en[i];
if (vis[y]) continue;
calc(y, x, gcd(A[x], A[y]), A[x]);
modify(y, x, gcd(A[x], A[y]));
}
for (i = 0; i < fac[A[x]].size(); i++) cnt[fac[A[x]][i]] = 0;
for (i = las[x]; i; i = nex[i]) {
y = en[i];
if (vis[y]) continue;
getg(y);
DC(G);
}
}
int main() {
int i, j, x, y;
for (i = 1; i <= 200000; i++)
for (j = i; j <= 200000; j += i) fac[j].push_back(i);
scanf("%d", &N);
for (i = 1; i <= N; i++) scanf("%d", &A[i]);
for (i = 1; i < N; i++) {
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
getg(1);
DC(G);
for (i = 1; i <= 200000; i++)
if (Ans[i]) printf("%d %I64d\n", i, Ans[i]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int DIM = 200005;
long long par[DIM], ans[DIM];
int mob[DIM], fth[DIM], val[DIM], oki[DIM];
vector<int> prm[DIM], lst[DIM], edg[DIM];
int getRoot(int x) {
while (fth[x] > 0) x = fth[x];
return x;
}
void unite(int x, int y, long long &ans) {
x = getRoot(x);
y = getRoot(y);
if (x == y) return;
if (fth[x] > fth[y]) swap(x, y);
ans -=
1LL * (-fth[x]) * (-fth[x] + 1) / 2 + 1LL * (-fth[y]) * (-fth[y] + 1) / 2;
fth[x] += fth[y];
fth[y] = x;
ans += 1LL * (-fth[x]) * (-fth[x] + 1) / 2;
}
int main(void) {
for (int i = 2; i < DIM; ++i) {
if (oki[i]) continue;
for (int j = i; j < DIM; j += i) {
prm[j].push_back(i);
oki[j] = true;
}
}
for (int i = 1; i < DIM; ++i) {
bool ok = true;
for (int d : prm[i])
if (i / d >= d and i % (d * d) == 0) ok = false;
if (!ok)
mob[i] = 0;
else
mob[i] = (prm[i].size() % 2 == 0 ? 1 : -1);
}
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> val[i];
lst[val[i]].push_back(i);
}
for (int i = 1; i < n; ++i) {
int x, y;
cin >> x >> y;
edg[x].push_back(y);
edg[y].push_back(x);
}
for (int d = 1; d < DIM; ++d) {
vector<int> mst;
for (int i = d; i < DIM; i += d)
for (int x : lst[i]) mst.push_back(x);
for (int x : mst) fth[x] = -1;
par[d] = mst.size();
for (int x : mst)
for (int y : edg[x])
if (val[y] % d == 0) unite(x, y, par[d]);
}
for (int i = 1; i < DIM; ++i) {
for (int j = (DIM - 1) / i; j >= 1; --j)
ans[i] += 1LL * mob[j] * par[i * j];
if (ans[i]) cout << i << " " << ans[i] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename VertexAttr, typename EdgeAttr>
class CentroidDecomposition {
public:
struct Vertex : VertexAttr {
int id;
Vertex() {}
Vertex(int id, VertexAttr attr) : id(id), VertexAttr(attr) {}
};
struct VertexAndEdge : Vertex, EdgeAttr {
VertexAndEdge() {}
VertexAndEdge(Vertex vertex, EdgeAttr edgeAttr)
: Vertex(vertex), EdgeAttr(edgeAttr) {}
};
struct TourEntry : VertexAndEdge {
unsigned f;
TourEntry() {}
TourEntry(Vertex to, EdgeAttr edgeAttr, unsigned f)
: VertexAndEdge(to, edgeAttr), f(f) {}
};
struct DfsEntry : VertexAndEdge {
int px;
DfsEntry() {}
DfsEntry(VertexAndEdge vertexAndEdge, int px)
: VertexAndEdge(vertexAndEdge), px(px) {}
};
void init(const vector<int> &t_ord, const vector<int> &t_parent,
const vector<VertexAttr> &vertexAttrs,
const vector<EdgeAttr> &upEdgeAttrs,
const vector<EdgeAttr> &downEdgeAttrs) {
int n = (int)t_ord.size();
vector<unsigned> a(n), b(n), f(n);
unsigned maxf = 0;
for (int ix = n - 1; ix >= 0; --ix) {
int i = t_ord[ix], p = t_parent[i];
unsigned m = b[i];
m |= m >> 1;
m |= m >> 2;
m |= m >> 4;
m |= m >> 8;
m |= m >> 16;
unsigned fi = ~(a[i] | m);
fi &= ~fi + 1;
f[i] = fi;
if (maxf < fi) maxf = fi;
unsigned S = (a[i] & ~(fi - 1)) | fi;
if (p != -1) {
b[p] |= a[p] & S;
a[p] |= S;
}
}
eulerTour(t_ord, t_parent, vertexAttrs, upEdgeAttrs, downEdgeAttrs, f,
_tour);
_currentLevel = 0;
while (maxf >> 1 >> _currentLevel) ++_currentLevel;
_subtrees.assign(_currentLevel + 1, vector<pair<int, int>>());
if (_currentLevel != 0) {
int middle = 1;
while (_tour[middle].f != maxf) ++middle;
std::rotate(_tour.begin() + 1, _tour.begin() + (middle + 1), _tour.end());
}
_subtrees[_currentLevel].assign(1, make_pair(1, (n - 1) * 2 + 1));
}
bool makeNextLevel() {
if (_currentLevel == 0) return false;
unsigned lv = 1U << (_currentLevel - 1);
const vector<pair<int, int>> ¤tSubtrees = _subtrees[_currentLevel];
for (int si = 0; si < (int)currentSubtrees.size(); ++si) {
int L = currentSubtrees[si].first, R = currentSubtrees[si].second;
int nextL = L + 1;
unsigned nextLevel = 0;
int nextMiddle = -1;
for (int ix = L; ix < R; ++ix) {
unsigned f = _tour[ix].f;
if (f > lv) {
std::rotate(_tour.begin() + nextL, _tour.begin() + nextMiddle,
_tour.begin() + ix);
int k = _currentLevel;
while (nextLevel != (1U << k)) --k;
_subtrees[k].push_back(make_pair(nextL, ix));
nextL = ix + 2;
nextLevel = 0;
nextMiddle = -1;
} else if (nextLevel < f) {
nextLevel = f;
nextMiddle = ix + 1;
}
}
}
--_currentLevel;
return true;
}
int currentLevel() const { return _currentLevel; }
int numCurrentSubtrees() const {
return (int)_subtrees[_currentLevel].size();
}
void getDfsOrder(int si, vector<DfsEntry> &ord,
vector<pair<int, int>> &tmpStack) const {
assert(0 <= si && si < numCurrentSubtrees());
tmpStack.resize(_tour.size() / 2 + 2);
pair<int, int> subtree = _subtrees[_currentLevel][si];
int L = subtree.first, R = subtree.second;
ord.clear();
ord.push_back(DfsEntry(
VertexAndEdge((Vertex)(VertexAndEdge)_tour[R - 1], EdgeAttr()), -1));
int sp = 1;
tmpStack[0] = make_pair(-1, -1);
tmpStack[sp++] = make_pair(_tour[R - 1].id, 0);
for (int tx = L; tx < R - 1; ++tx) {
int id = _tour[tx].id;
if (id == tmpStack[sp - 2].first) {
--sp;
} else {
int px = tmpStack[sp - 1].second;
int ix = (int)ord.size();
tmpStack[sp++] = make_pair(id, ix);
ord.push_back(DfsEntry(_tour[tx], px));
}
}
}
void debugShow() const {
cerr << "level " << _currentLevel << ":\n";
const vector<pair<int, int>> ¤tSubtrees = _subtrees[_currentLevel];
for (int si = 0; si < (int)currentSubtrees.size(); ++si) {
int L = currentSubtrees[si].first, R = currentSubtrees[si].second;
if (L == R) cerr << "[" << (L == 0 ? 0 : _tour[L - 1].id) << "]";
for (int ix = L; ix < R; ++ix) {
cerr << _tour[ix].id << ", ";
}
cerr << '\n';
}
}
private:
static void eulerTour(const vector<int> &t_ord, const vector<int> &t_parent,
const vector<VertexAttr> &vertexAttrs,
const vector<EdgeAttr> &upEdgeAttrs,
const vector<EdgeAttr> &downEdgeAttrs,
const vector<unsigned> &f, vector<TourEntry> &tour) {
int n = (int)t_ord.size();
tour.clear();
tour.reserve((n - 1) * 2 + 1);
int root = t_ord[0], i = root;
tour.push_back(
TourEntry(Vertex(root, vertexAttrs[root]), EdgeAttr(), f[root]));
for (int ix = 1; ix <= n; ++ix) {
int p = ix < n ? t_parent[t_ord[ix]] : root;
while (i != p) {
EdgeAttr w = upEdgeAttrs[i];
i = t_parent[i];
tour.push_back(TourEntry(Vertex(i, vertexAttrs[i]), w, f[i]));
}
if (ix < n) {
i = t_ord[ix];
EdgeAttr w = downEdgeAttrs[i];
tour.push_back(TourEntry(Vertex(i, vertexAttrs[i]), w, f[i]));
}
}
assert(tour.size() == (n - 1) * 2 + 1);
}
private:
int _currentLevel;
vector<TourEntry> _tour;
vector<vector<pair<int, int>>> _subtrees;
};
vector<int> t_parent;
vector<int> t_ord;
void tree_getorder(const vector<vector<int>> &g, int root) {
int n = (int)g.size();
t_parent.assign(n, -1);
t_ord.clear();
vector<int> stk;
stk.push_back(root);
while (!stk.empty()) {
int i = stk.back();
stk.pop_back();
t_ord.push_back(i);
for (int j = (int)g[i].size() - 1; j >= 0; j--) {
int c = g[i][j];
if (t_parent[c] == -1 && c != root) {
t_parent[c] = i;
stk.push_back(c);
}
}
}
}
vector<int> primes;
vector<int> smallestPrimeFactor;
void linearSieve(int n) {
if (n < 1) n = 1;
if ((int)smallestPrimeFactor.size() >= n + 1) return;
int primePiBound = n < 20 ? n - 1 : (int)(n / (log(n * 1.) - 2) + 2);
primes.assign(primePiBound + 1, numeric_limits<int>::max());
int P = 0;
smallestPrimeFactor.assign(n + 1, 0);
smallestPrimeFactor[1] = 1;
int n2 = n / 2, n3 = n / 3, n5 = n / 5;
if (n >= 2) primes[P++] = 2;
if (n >= 3) primes[P++] = 3;
for (int q = 2; q <= n; q += 2) smallestPrimeFactor[q] = 2;
for (int q = 3; q <= n; q += 6) smallestPrimeFactor[q] = 3;
for (int q = 5; q <= n5; q += 2) {
if (smallestPrimeFactor[q] == 0) primes[P++] = smallestPrimeFactor[q] = q;
int bound = smallestPrimeFactor[q];
for (int i = 2;; ++i) {
int p = primes[i];
if (p > bound) break;
int pq = p * q;
if (pq > n) break;
smallestPrimeFactor[pq] = p;
}
}
for (int q = (n5 + 1) | 1; q <= n; q += 2) {
if (smallestPrimeFactor[q] == 0) primes[P++] = smallestPrimeFactor[q] = q;
}
primes.resize(P);
}
struct GCDQuery {
struct Decomposition {
int x, y;
int p, ppi;
};
int N, sqrtN;
vector<int> smallTable, smallTable2;
vector<Decomposition> decomposition;
vector<int> primePowers;
void init(const vector<int> &smallestPrimeFactor) {
int N = (int)smallestPrimeFactor.size() - 1;
int sqrtN = (int)sqrt(double(N));
this->N = N, this->sqrtN = sqrtN;
primePowers.clear();
primePowers.push_back(1);
for (int p = 2; p <= sqrtN; ++p)
if (smallestPrimeFactor[p] == p) {
int q = p;
while (1) {
primePowers.push_back(q);
if ((long long)q * p > N) break;
q *= p;
}
}
int numSmallPPs = (int)primePowers.size();
vector<int> ppIndex(N + 1, -1);
for (int i = 0; i < numSmallPPs; ++i) ppIndex[primePowers[i]] = i;
struct NextDivisor {
int x;
int p, q;
};
vector<NextDivisor> nextDivisor(N + 1);
nextDivisor[1] = {1, 1, 0};
for (int i = 2; i <= N; ++i) {
int p = smallestPrimeFactor[i];
int j = i / p, q = p;
while (j % p == 0) j /= p, q *= p;
nextDivisor[i] = {j, p, q};
}
decomposition.resize(N + 1);
for (int i = 0; i <= sqrtN; ++i) decomposition[i] = {i, 1, 1, 0};
for (int i = sqrtN + 1; i <= N; ++i) {
int x = i, y = 1;
while (1) {
auto t = nextDivisor[x];
if (t.x <= sqrtN) break;
x = t.x;
y *= t.q;
}
assert(y <= sqrtN);
auto t = nextDivisor[x];
decomposition[i] = {t.x, y, t.p, ppIndex[t.q]};
}
smallTable.resize((sqrtN + 1) * (sqrtN + 1));
for (int b = 0; b <= sqrtN; ++b) smallTable[ix2(0, b)] = b;
for (int a = 1; a <= sqrtN; ++a)
for (int b = 0; b <= sqrtN; ++b)
smallTable[ix2(a, b)] = smallTable[ix2(b % a, a)];
smallTable2.assign(numSmallPPs * (sqrtN + 1), 1);
for (int ppi = 1; ppi < numSmallPPs; ++ppi) {
int q = primePowers[ppi];
int p = smallestPrimeFactor[q];
for (int qq = p;; qq *= p) {
for (int b = 0; b <= sqrtN; b += qq) smallTable2[ix2(ppi, b)] = qq;
if (qq == q) break;
}
}
}
int gcd(int a, int b) const {
assert(a <= N && b <= N);
if (a == 0 || b == 0) return a + b;
auto da = decomposition[a];
auto db = decomposition[b];
int res = 1;
res *= gcdSmall(da.x, db.x);
res *= gcdSmall(da.x, db.y);
res *= gcdSmall(da.y, db.x);
res *= gcdSmall(da.y, db.y);
if (da.p == db.p) {
if (da.ppi > 0)
res *= primePowers[min(da.ppi, db.ppi)];
else
res *= da.p;
} else {
if (da.ppi > 0) {
res *= gcdPP(da.ppi, db.x);
res *= gcdPP(da.ppi, db.y);
}
if (db.ppi > 0) {
res *= gcdPP(db.ppi, da.x);
res *= gcdPP(db.ppi, da.y);
}
}
return res;
}
private:
int gcdSmall(int a, int b) const { return smallTable[ix2(a, b)]; }
int gcdPP(int ppi, int b) const { return smallTable2[ix2(ppi, b)]; }
int ix2(int i, int j) const { return i * (sqrtN + 1) + j; }
};
int main() {
struct VertexAttr {
int a;
VertexAttr() {}
VertexAttr(int a) : a(a) {}
};
struct EdgeAttr {};
int n;
while (~scanf("%d", &n)) {
vector<int> as(n);
for (int i = 0; i < n; ++i) scanf("%d", &as[i]);
vector<vector<int>> g(n);
for (int i = 0; i < n - 1; ++i) {
int u, v;
scanf("%d%d", &u, &v), --u, --v;
g[u].push_back(v);
g[v].push_back(u);
}
tree_getorder(g, 0);
int A = *max_element(as.begin(), as.end());
linearSieve(A);
vector<vector<int>> divisors(A + 1);
for (int a = 1; a <= A; ++a)
for (int b = a; b <= A; b += a) divisors[b].push_back(a);
GCDQuery gcd;
gcd.init(smallestPrimeFactor);
vector<long long> ans(A + 1, 0);
vector<int> cnt(A + 1, 0);
vector<int> values;
CentroidDecomposition<VertexAttr, EdgeAttr> cd;
cd.init(t_ord, t_parent, vector<VertexAttr>(as.begin(), as.end()),
vector<EdgeAttr>(n), vector<EdgeAttr>(n));
do {
vector<pair<int, int>> tmpStack;
vector<CentroidDecomposition<VertexAttr, EdgeAttr>::DfsEntry> ord;
vector<int> bounds;
vector<int> gcds;
for (int si = 0; si < cd.numCurrentSubtrees(); ++si) {
cd.getDfsOrder(si, ord, tmpStack);
gcds.resize(ord.size());
gcds[0] = ord[0].a;
bounds.clear();
bounds.push_back(0);
for (int ix = 1; ix < (int)ord.size(); ++ix) {
const auto &entry = ord[ix];
gcds[ix] = gcd.gcd(gcds[entry.px], entry.a);
if (entry.px == 0) bounds.push_back(ix);
}
bounds.push_back((int)ord.size());
auto add = [&](int L, int R, int sign) {
for (int ix = L; ix < R; ++ix) {
for (int a : divisors[gcds[ix]])
if (cnt[a]++ == 0) values.push_back(a);
}
for (int a : values) {
ans[a] += sign * ((long long)cnt[a] * (cnt[a] + 1) / 2);
cnt[a] = 0;
}
values.clear();
};
add(0, bounds.back(), 1);
for (int bi = 1; bi < (int)bounds.size() - 1; ++bi) {
int L = bounds[bi], R = bounds[bi + 1];
add(L, R, -1);
}
}
} while (cd.makeNextLevel());
for (int p : primes) {
for (int i = 1, a = p; a <= A; ++i, a += p) ans[i] -= ans[a];
}
for (int a = 1; a <= A; ++a)
if (ans[a] > 0) printf("%d %lld\n", a, ans[a]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct Edge {
int to, nxt;
} E[500005 * 2];
int Head[500005], tot, x, y, z, V[500005], prime[500005], n, primenum, lim,
maxans, f[500005], ans[500005], max1, max2, maxv;
bool vis[500005], isprime[500005], dp[500005], skip;
void addedge(int x, int y) {
E[++tot] = (Edge){y, Head[x]};
Head[x] = tot;
}
void getprime() {
lim = 500005;
memset(isprime, true, sizeof(isprime));
for (int i = 2; i < lim; i++) {
if (isprime[i]) prime[++primenum] = i;
for (int j = 2; j <= (lim / i); j++) isprime[i * j] = false;
}
}
void read() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &V[i]), maxv = max(maxv, V[i]);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
}
void dfs(int v, int fa) {
vis[v] = true;
if (!dp[v]) return;
f[v] = 1;
int max1 = 0, max2 = 0;
for (int i = Head[v]; i; i = E[i].nxt) {
if (E[i].to == fa) continue;
dfs(E[i].to, v);
f[v] = max(f[E[i].to] + 1, f[v]);
if (f[E[i].to] > max1) {
max2 = max1;
max1 = f[E[i].to];
} else {
max2 = max(max2, f[E[i].to]);
}
}
ans[v] = max1 + max2 + 1;
maxans = max(maxans, ans[v]);
}
void solve() {
maxans = 0;
if (maxv < 2) {
printf("0\n");
return;
}
for (int p = 1; p <= 650; p++) {
if (prime[p] > maxv) break;
memset(vis, false, sizeof(vis));
memset(f, 0, sizeof(f));
memset(ans, 0, sizeof(ans));
for (int i = 1; i <= n; i++) dp[i] = !(V[i] % prime[p]);
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, 0);
}
}
memset(vis, false, sizeof(vis));
memset(f, 0, sizeof(f));
memset(ans, 0, sizeof(ans));
for (int i = 1; i <= n; i++) dp[i] = !(V[i] % maxv);
for (int i = 1; i <= n; i++) {
if (!vis[i]) dfs(i, 0);
}
printf("%d\n", maxans);
}
int main() {
getprime();
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &t) {
char ch = getchar();
int f = 1;
t = 0;
while ('0' > ch || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
do {
(t *= 10) += ch - '0';
ch = getchar();
} while ('0' <= ch && ch <= '9');
t *= f;
}
const int maxn = (2e5) + 10;
int n, a[maxn], fa[maxn], sz[maxn], cnt[maxn];
long long ans[maxn];
queue<int> q;
vector<pair<int, int> > g[maxn];
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int find(int u) {
if (fa[u] == u) return u;
return (fa[u] = find(fa[u]));
}
void connect(int u, int v) {
u = find(u);
v = find(v);
if (u == v) return;
fa[u] = v;
sz[v] += sz[u];
q.push(u);
q.push(v);
}
void init() {
while (!q.empty()) {
int u = q.front();
q.pop();
fa[u] = u;
sz[u] = 1;
}
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(a[i]);
cnt[a[i]]++;
fa[i] = i;
sz[i] = 1;
}
for (int i = 1; i < n; i++) {
int u, v;
read(u);
read(v);
g[gcd(a[u], a[v])].push_back(make_pair(u, v));
}
for (int i = 1; i < maxn; i++) {
long long s = 0;
for (int j = i; j < maxn; j += i) {
s += cnt[j];
for (int k = 0; k < g[j].size(); k++) {
int u = g[j][k].first, v = g[j][k].second;
u = find(u);
v = find(v);
if (u == v) continue;
s -= (long long)sz[u] * (sz[u] - 1) / 2 + sz[u];
s -= (long long)sz[v] * (sz[v] - 1) / 2 + sz[v];
connect(u, v);
v = find(v);
s += (long long)sz[v] * (sz[v] - 1) / 2 + sz[v];
}
}
ans[i] = s;
init();
}
for (int i = maxn - 1; i >= 1; i--)
for (int j = i * 2; j < maxn; j += i) ans[i] -= ans[j];
for (int i = 1; i < maxn; i++)
if (ans[i]) printf("%d %I64d\n", i, ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 200009;
long long int n, a[N], ls[N], t[N], kq = 0;
vector<long long int> D[N], uoc[N], maxx[N];
bool ok = 1;
void Inp() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] != 1) {
ok = 0;
}
}
for (int i = 1; i < n; i++) {
long long int u, v;
cin >> u >> v;
D[u].push_back(v);
D[v].push_back(u);
}
}
void Sieve() {
ls[1] = 1;
for (int i = 2; i < N; i++) {
if (ls[i] == 0) {
long long int k = i;
while (k < N) {
ls[k] = i;
k += i;
}
}
}
}
void Pre() {
for (int i = 1; i <= n; i++) {
long long int k = a[i];
while (k > 1) {
if (t[ls[k]] != i) {
t[ls[k]] = i;
uoc[i].push_back(ls[k]);
maxx[i].push_back(0);
}
k /= ls[k];
}
sort(uoc[i].begin(), uoc[i].end());
}
}
void DFS(long long int u, long long int p) {
for (auto v : D[u]) {
if (v != p) {
DFS(v, u);
long long int s1 = uoc[u].size(), s2 = uoc[v].size(), p1 = 0, p2 = 0;
while (!(p1 == s1 || p2 == s2)) {
if (uoc[u][p1] == uoc[v][p2]) {
kq = max(kq, maxx[u][p1] + maxx[v][p2] + 1);
maxx[u][p1] = max(maxx[u][p1], maxx[v][p2] + 1);
p1++;
p2++;
continue;
}
if (uoc[u][p1] < uoc[v][p2]) {
p1++;
} else {
p2++;
}
}
}
}
}
int main() {
Inp();
if (ok) {
cout << 0;
return 0;
}
Sieve();
Pre();
DFS(1, 1);
cout << kq + 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int n, a[N];
long long ans[N], F[N];
int fr[N], to[N];
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
vector<int> vec[N];
int fa[N];
int ffa(int x) { return fa[x] == x ? x : fa[x] = ffa(fa[x]); }
int is[N], mu[N], prime[N], cnt;
int siz[N];
signed main() {
mu[1] = 1;
for (int i = 2; i <= N - 5; i++) {
if (!is[i]) prime[++cnt] = i, mu[i] = -1;
for (int j = 1; j <= cnt; j++) {
if (i * prime[j] > N - 5) break;
is[i * prime[j]] = 1;
if (i % prime[j] == 0) continue;
mu[i * prime[j]] = -mu[i];
}
}
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), ans[a[i]]++;
for (int i = 1; i < n; i++) {
scanf("%d%d", &fr[i], &to[i]);
int gc = gcd(a[fr[i]], a[to[i]]);
for (int j = 1; j * j <= gc; j++) {
if (gc % j) continue;
vec[j].push_back(i);
if (j * j != gc) vec[gc / j].push_back(i);
}
}
for (int i = 1; i <= N - 5; i++) {
for (int j = 0; j < (int)vec[i].size(); j++) {
int v = vec[i][j];
fa[fr[v]] = fr[v], fa[to[v]] = to[v];
siz[fr[v]] = 1, siz[to[v]] = 1;
}
for (int j = 0; j < (int)vec[i].size(); j++) {
int v = vec[i][j];
int fx = ffa(fr[v]), fy = ffa(to[v]);
if (fx == fy) continue;
F[i] += 1ll * siz[fx] * siz[fy];
fa[fx] = fy;
siz[fy] += siz[fx];
}
}
for (int i = 1; i <= N - 5; i++)
for (int j = 1; j * i <= N - 5; j++) ans[i] += 1ll * F[i * j] * mu[j];
for (int i = 1; i <= N - 5; i++) {
if (!ans[i]) continue;
printf("%d %lld\n", i, ans[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int Sz = 2e5 + 5;
vector<int> G[Sz];
int a[Sz];
int lpd[Sz];
map<int, int> f[Sz];
void Sieve() {
for (int i = 2; i * i < Sz; i++) {
if (lpd[i] != 0) continue;
lpd[i] = i;
for (int j = i * i; j < Sz; j += i)
if (lpd[j] == 0) lpd[j] = i;
}
}
vector<int> Analysis(int x) {
vector<int> n;
while (x != 1) {
if (lpd[x] == 0) lpd[x] = x;
if (n.empty() || n.back() != lpd[x]) n.push_back(lpd[x]);
x /= lpd[x];
}
return n;
}
void dfs(int u, int p) {
vector<int> num = Analysis(a[u]);
for (int i : num) f[u][i] = 1;
for (int v : G[u])
if (v != p) {
dfs(v, u);
for (int i : num) f[u][i] = max(f[u][i], f[v][i] + 1);
}
}
int dp(int u, int p) {
int res = 1;
vector<int> num = Analysis(a[u]);
for (int i : num) {
int mx = 0;
int mn = 0;
for (int v : G[u]) {
if (v == p) continue;
if (f[mx][i] <= f[v][i]) {
mn = mx;
mx = v;
} else if (f[mn][i] < f[v][i])
mn = v;
}
res = max(res, 1 + f[mx][i] + f[mn][i]);
}
for (int v : G[u])
if (v != p) res = max(res, dp(v, u));
return res;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Sieve();
int n;
cin >> n;
bool gotres = false;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] != 1) gotres = true;
}
if (!gotres) {
cout << "0\n";
return 0;
}
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, 0);
cout << dp(1, 0) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int Lpow(long long int a, long long int b) {
long long int ans = 1;
while (b > 0) {
if (b % 2) ans = (ans * a);
a = (a * a);
b = b / 2;
}
return ans;
}
long long int gcd(long long int a, long long int b) {
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
vector<int> arr(200005);
vector<vector<int>> adj(200005);
vector<map<int, int>> brr(200005);
int ans;
void dfs(int node, int p) {
for (auto x : adj[node]) {
if (x != p) dfs(x, node);
}
for (int i = 2; i <= sqrt(arr[node]); i++) {
int cnt = 0;
while (arr[node] % i == 0) {
arr[node] = arr[node] / i;
cnt = 1;
}
if (cnt) brr[node][i] = 1;
}
if (arr[node] > 1) {
brr[node][arr[node]] = 1;
arr[node] = 1;
}
for (auto fact : brr[node]) {
int ma = 0;
int ma1 = 0;
for (auto x : adj[node]) {
if (x != p) {
if (ma < brr[x][fact.first]) {
ma1 = ma;
ma = brr[x][fact.first];
} else if (ma1 < brr[x][fact.first]) {
ma1 = brr[x][fact.first];
}
}
}
ans = max(ans, ma + ma1 + 1);
brr[node][fact.first] = ma + 1;
}
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
ans = 0;
for (int i = 1; i <= n; i++) cin >> arr[i];
int a, b;
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, 1);
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200043;
int d[N];
void sieve() {
vector<int> pr;
for (int i = 2; i < N; i++) {
if (d[i] == 0) {
d[i] = i;
pr.push_back(i);
}
for (auto x : pr) {
if (x > d[i] || x * 1ll * i >= N) break;
d[i * x] = x;
}
}
}
int mobius(int x) {
int last = -1;
int res = 1;
while (x != 1) {
if (last == d[x])
res = 0;
else
res = -res;
last = d[x];
x /= d[x];
}
return res;
}
int mb[N];
vector<int> need_bfs[N];
int used[N];
vector<int> g[N];
int a[N];
int cc = 0;
int q[N];
int hd, tl;
int good[N];
int bfs(int x, int gc) {
hd = 0;
tl = 0;
q[tl++] = x;
used[x] = cc;
while (hd < tl) {
int z = q[hd++];
for (auto y : g[z]) {
if (good[a[y]] == cc && used[y] < cc) {
used[y] = cc;
q[tl++] = y;
}
}
}
return tl;
}
long long ans1[N];
long long ans2[N];
int main() {
sieve();
for (int i = 1; i < N; i++) mb[i] = mobius(i);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[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);
}
for (int i = 0; i < n; i++) {
need_bfs[a[i]].push_back(i);
}
for (int i = 200000; i >= 1; i--) {
cc++;
for (int j = i; j <= 200000; j += i) good[j] = cc;
for (int j = i; j <= 200000; j += i)
for (auto x : need_bfs[j]) {
if (used[x] == cc) continue;
int z = bfs(x, i);
ans1[i] += z * 1ll * (z + 1) / 2;
}
for (int j = i, k = 1; j <= 200000; j += i, k++) ans2[i] += mb[k] * ans1[j];
}
for (int i = 1; i <= 200000; i++)
if (ans2[i]) printf("%d %lld\n", i, ans2[i]);
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], p[maxN], sz[maxN];
vector<int> vec[maxS];
vector<pair<int, int>> edges[maxS];
long long ans[maxS];
bool flag[maxN];
int root(int u) { return u == p[u] ? u : p[u] = root(p[u]); }
bool unify(int u, int v) {
u = root(u);
v = root(v);
if (u == v) {
return 0;
}
if (sz[u] < sz[v]) {
swap(u, v);
}
p[v] = u;
sz[u] += sz[v];
return 1;
}
int GCD(int a, int b) { return (b == 0 ? a : GCD(b, a % b)); }
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);
}
iota(p + 1, p + n + 1, 1);
fill(sz + 1, sz + n + 1, 1);
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;
unify(u, v);
}
}
for (int d = g; d <= 2e5; d += g) {
for (auto &u : vec[d]) {
int h = root(u);
if (!flag[h]) {
flag[h] = 1;
ans[g] += (long long)sz[h] * (sz[h] + 1) / 2;
}
}
}
for (int d = g; d <= 2e5; d += g) {
for (auto &u : vec[d]) {
flag[u] = 0;
p[u] = u;
sz[u] = 1;
}
}
}
for (int i = 2e5; i; 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>
using namespace std;
const int MAXN = 200005;
int a[MAXN];
vector<int> p[MAXN], g[MAXN];
int ans;
map<int, int> mp[MAXN];
void DFS(int u, int pre) {
for (auto &x : p[a[u]]) mp[u][x] = 1;
for (auto &v : g[u])
if (v != pre) {
DFS(v, u);
for (auto &x : p[a[v]])
if (a[u] % x == 0) {
ans = max(ans, mp[u][x] + mp[v][x]);
if (mp[v][x] + 1 > mp[u][x]) mp[u][x] = mp[v][x] + 1;
}
}
return;
}
int main() {
int n;
for (int i = 2; i < MAXN; ++i)
if (p[i].size() == 0)
for (int j = i; j < MAXN; j += i) p[j].push_back(i);
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), ans = max(ans, (a[i] > 1 ? 1 : 0));
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, 0);
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937_64 mt(time(0));
const int MAXN = 2e5 + 10;
int factor[MAXN], nums[MAXN], ret;
vector<int> edges[MAXN];
map<int, int> dp[MAXN];
void init() {
for (long long i = 2; i < MAXN; i++) {
if (factor[i] != 0) continue;
for (long long j = i * i; j < MAXN; j += i) {
factor[j] = i;
}
}
}
void dfs(int root, int par) {
for (int nxt : edges[root]) {
if (nxt == par) continue;
dfs(nxt, root);
}
for (auto& item : dp[root]) {
ret = max(ret, 1);
for (int nxt : edges[root]) {
if (nxt == par) continue;
auto it = dp[nxt].find(item.first);
if (it == dp[nxt].end()) continue;
ret = max(ret, item.second + it->second);
item.second = max(item.second, 1 + it->second);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
init();
int n, val, a, b;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> val;
nums[i] = val;
while (factor[val] != 0) {
int tmp = factor[val];
while (val % tmp == 0) val /= tmp;
dp[i][tmp] = 1;
}
if (val != 1) dp[i][val] = 1;
}
for (int i = 0; i < n - 1; i++) {
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
dfs(1, 0);
cout << ret << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.