text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int seg_tree_f[400000 * 4 + 9];
int lazy_f[400000 * 4 + 9];
void init_tree_f(int node, int beg, int end) {
if (beg == end) {
seg_tree_f[node] = 0;
lazy_f[node] = 0;
return;
}
int mid = (beg + end) >> 1;
init_tree_f((node << 1), beg, mid);
init_tree_f((node << 1) | 1, mid + 1, end);
seg_tree_f[node] = 0;
lazy_f[node] = 0;
}
inline void split_node_f(int node) {
if (lazy_f[node] == 0) return;
seg_tree_f[(node << 1)] += lazy_f[node];
lazy_f[(node << 1)] += lazy_f[node];
seg_tree_f[(node << 1) | 1] += lazy_f[node];
lazy_f[(node << 1) | 1] += lazy_f[node];
lazy_f[node] = 0;
}
inline void merge_node_f(int node) {
seg_tree_f[node] = min(seg_tree_f[(node << 1)], seg_tree_f[(node << 1) | 1]);
}
void update_f(int node, int beg, int end, int i, int j, int value) {
if (beg > j || end < i) return;
if (beg >= i && end <= j) {
seg_tree_f[node] += value;
lazy_f[node] += value;
return;
}
split_node_f(node);
int mid = (beg + end) >> 1;
update_f((node << 1), beg, mid, i, j, value);
update_f((node << 1) | 1, mid + 1, end, i, j, value);
merge_node_f(node);
}
int query_f_leftmost(int node, int beg, int end, int i, int j, int target) {
if (i > end || j < beg) return (1 << 30);
if (seg_tree_f[node] > target) return (1 << 30);
if (beg == end) return beg;
split_node_f(node);
int mid = (beg + end) >> 1;
int ind = query_f_leftmost((node << 1), beg, mid, i, j, target);
if (ind != (1 << 30)) return ind;
return query_f_leftmost(((node << 1) | 1), mid + 1, end, i, j, target);
}
int query_f_rightmost(int node, int beg, int end, int i, int j, int target) {
if (i > end || j < beg) return (-(1 << 30));
if (seg_tree_f[node] > target) return (-(1 << 30));
if (beg == end) return beg;
split_node_f(node);
int mid = (beg + end) >> 1;
int ind = query_f_rightmost(((node << 1) | 1), mid + 1, end, i, j, target);
if (ind != (-(1 << 30))) return ind;
return query_f_rightmost((node << 1), beg, mid, i, j, target);
}
int query_f(int node, int beg, int end, int i, int j) {
if (i > end || j < beg) return (1LL << 30);
if (beg >= i && end <= j) return seg_tree_f[node];
split_node_f(node);
int mid = (beg + end) >> 1;
int leftnode = query_f((node << 1), beg, mid, i, j);
int rightnode = query_f(((node << 1) | 1), mid + 1, end, i, j);
return min(leftnode, rightnode);
}
int seg_tree[400000 * 4 + 9];
int lazy[400000 * 4 + 9];
void init_tree(int node, int beg, int end) {
if (beg == end) {
seg_tree[node] = 0;
lazy[node] = 0;
return;
}
int mid = (beg + end) >> 1;
init_tree((node << 1), beg, mid);
init_tree((node << 1) | 1, mid + 1, end);
seg_tree[node] = 0;
lazy[node] = 0;
}
void split_node(int node) {
if (lazy[node] == 0) return;
seg_tree[(node << 1)] += lazy[node];
lazy[(node << 1)] += lazy[node];
seg_tree[(node << 1) | 1] += lazy[node];
lazy[(node << 1) | 1] += lazy[node];
lazy[node] = 0;
}
void merge_node(int node) {
seg_tree[node] = max(seg_tree[(node << 1)], seg_tree[(node << 1) | 1]);
}
void update(int node, int beg, int end, int i, int j, int value) {
if (beg > j || end < i) return;
if (beg >= i && end <= j) {
seg_tree[node] += value;
lazy[node] += value;
return;
}
split_node(node);
int mid = (beg + end) >> 1;
update((node << 1), beg, mid, i, j, value);
update((node << 1) | 1, mid + 1, end, i, j, value);
merge_node(node);
}
int query_leftmost(int node, int beg, int end, int i, int j, int target) {
if (i > end || j < beg) return (1 << 30);
if (seg_tree[node] < target) return (1 << 30);
if (beg == end) return beg;
split_node(node);
int mid = (beg + end) >> 1;
int ind = query_leftmost((node << 1), beg, mid, i, j, target);
if (ind != (1 << 30)) return ind;
return query_leftmost(((node << 1) | 1), mid + 1, end, i, j, target);
}
int query_rightmost(int node, int beg, int end, int i, int j, int target) {
if (i > end || j < beg) return (-(1 << 30));
if (seg_tree[node] < target) return (-(1 << 30));
if (beg == end) return beg;
split_node(node);
int mid = (beg + end) >> 1;
int ind = query_rightmost(((node << 1) | 1), mid + 1, end, i, j, target);
if (ind != (-(1 << 30))) return ind;
return query_rightmost((node << 1), beg, mid, i, j, target);
}
int query(int node, int beg, int end, int i, int j) {
if (i > end || j < beg) return (-(1LL << 30));
if (beg >= i && end <= j) return seg_tree[node];
split_node(node);
int mid = (beg + end) >> 1;
int leftnode = query((node << 1), beg, mid, i, j);
int rightnode = query(((node << 1) | 1), mid + 1, end, i, j);
return max(leftnode, rightnode);
}
int MAP[400000 + 9];
int ar[400000 + 9];
int ANC[400000 + 9];
void GO(int l, int r, int n, int carry) {
if (l > r) return;
int m = MAP[query_f(1, 1, n, l, r)];
ANC[m] = carry;
GO(l, m - 1, n, carry + 1);
GO(m + 1, r, n, carry + 1);
}
int main() {
int i, j, k, l, cas, ne, test, n, m, x, y, temp, val, now, q, w, e, root,
flag, ii, o, p, ans, r;
cin >> n;
for (i = 1; i <= n; i++) scanf("%lld", &ar[i]);
for (i = 1; i <= n; i++) MAP[ar[i]] = i;
init_tree_f(1, 1, n);
for (i = 1; i <= n; i++) update_f(1, 1, n, i, i, ar[i]);
GO(1, n, n, 0);
init_tree_f(1, 1, 2 * n);
for (i = 1; i <= n; i++) ar[i + n] = ar[i];
for (i = 1; i <= 2 * n; i++) update_f(1, 1, 2 * n, i, i, ar[i]);
init_tree(1, 1, 2 * n);
for (i = 1; i <= n; i++) ANC[i + n] = ANC[i];
for (i = 1; i <= 2 * n; i++) update(1, 1, 2 * n, i, i, ANC[i]);
ans = seg_tree[1];
val = 0;
for (i = 1; i < n; i++) {
l = query_f_leftmost(1, 1, 2 * n, i + 1, n + i - 1, ar[i]);
if (l != (1 << 30)) update(1, 1, 2 * n, i + 1, l - 1, -1);
r = query_f_rightmost(1, 1, 2 * n, i + 1, n + i - 1, ar[i]);
if (r != (-(1 << 30))) update(1, 1, 2 * n, r + 1, n + i - 1, 1);
update(1, 1, 2 * n, n + i, n + i, -(query(1, 1, 2 * n, n + i, n + i)));
if (r != (-(1 << 30)))
update(1, 1, 2 * n, n + i, n + i, (query(1, 1, 2 * n, r, r) + 1));
temp = query(1, 1, 2 * n, i + 1, i + n);
if (temp < ans) {
ans = temp;
val = i;
}
}
cout << ans + 1 << " " << val << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400005], l[400005], r[400005];
struct Segment_Tree {
int d[400005 * 4], add[400005 * 4];
void push_down(int idx, int l, int r) {
if (l == r) {
add[idx] = 0;
return;
}
d[idx << 1] += add[idx];
add[idx << 1] += add[idx];
d[idx << 1 | 1] += add[idx];
add[idx << 1 | 1] += add[idx];
add[idx] = 0;
d[idx] = max(d[idx << 1], d[idx << 1 | 1]);
}
void update(int idx, int l, int r, int a, int b, int x) {
push_down(idx, l, r);
if (l > b || r < a) return;
if (l >= a && r <= b) {
add[idx] += x;
d[idx] += x;
return;
}
int m = (l + r) / 2;
update(idx << 1, l, m, a, b, x);
update(idx << 1 | 1, m + 1, r, a, b, x);
d[idx] = max(d[idx << 1], d[idx << 1 | 1]);
}
int query(int idx, int l, int r, int a, int b) {
push_down(idx, l, r);
if (l > b || r < a) return 0;
if (l >= a && r <= b) return d[idx];
int m = (l + r) / 2;
return max(query(idx << 1, l, m, a, b),
query(idx << 1 | 1, m + 1, r, a, b));
}
} smt;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i + n] = a[i];
}
r[2 * n] = 2 * n;
for (int i = 2 * n - 1; i >= 1; i--) {
if (a[i] > a[i + 1])
r[i] = i;
else {
r[i] = r[i + 1];
while (a[i] < a[r[i] + 1]) r[i] = r[r[i] + 1];
}
}
l[1] = 1;
for (int i = 2; i <= 2 * n; i++) {
if (a[i] > a[i - 1])
l[i] = i;
else {
l[i] = l[i - 1];
while (a[i] < a[l[i] - 1]) l[i] = l[l[i] - 1];
}
}
for (int i = 1; i <= n; i++) smt.update(1, 1, 2 * n, l[i], r[i], 1);
int ans = INT_MAX;
int p = 0;
for (int i = 1; i <= n; i++) {
int now = smt.query(1, 1, 2 * n, i, i + n - 1);
if (now < ans) {
ans = now;
p = i - 1;
}
smt.update(1, 1, 2 * n, l[i], r[i], -1);
smt.update(1, 1, 2 * n, l[i + n], r[i + n], 1);
}
printf("%d %d\n", ans, p);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"avx,avx2,fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long MOD = 1e9 + 7;
long long INF = 1e18;
typedef pair<long long, long long> integer;
const int LG = 20, NN = 300007;
integer op(integer a, integer b) { return min(a, b); }
int logs[NN];
integer bin[LG][NN];
vector<integer> sparce_table;
integer find(int l, int r) {
int x = logs[r - l];
return op(bin[x][l], bin[x][r - (1 << x)]);
}
void buildBin(vector<pair<long long, long long> > b) {
sparce_table = b;
int n = sparce_table.size();
int cur = 0, x = 1;
for (int i = 0; i < n + 2; i++) {
if (2 * x == i) {
x *= 2;
cur++;
}
logs[i] = cur;
}
for (int i = 0; i < n; i++) bin[0][i] = sparce_table[i];
for (int i = 0; i + 1 < LG; i++)
for (int j = 0; j < n; j++)
bin[i + 1][j] = op(bin[i][j], bin[i][min(j + (1 << i), n - 1)]);
}
long long dfs(long long l, long long r) {
long long nu = find(l, r + 1).second;
if (r == l) {
return 1;
}
if (nu == l) {
return 1 + dfs(l + 1, r);
}
if (nu == r) {
return 1 + dfs(l, r - 1);
}
return 1 + max(dfs(l, nu - 1), dfs(nu + 1, r));
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0),
cout << fixed << setprecision(20);
long long n;
cin >> n;
vector<long long> a(n);
vector<long long> a_(n);
long long num = 0;
for (int i = 0; i < n; i++) {
cin >> a_[i];
if (a_[i] == 1) {
num = i;
}
}
for (int i = 0; i < n; i++) {
a[i] = a_[(i + num) % n];
}
vector<pair<long long, long long> > b(n);
long long L = 0, R = n;
while (R - L > 1) {
long long mid = (R + L) / 2;
for (int i = 0; i < n; i++) {
b[i] = {a[(i + mid) % n], (long long)i};
}
buildBin(b);
long long nu = find(0, n).second;
if (nu == 0) {
L = mid;
continue;
}
if (nu == n - 1) {
R = mid;
continue;
}
if (dfs(0, nu - 1) >= dfs(nu + 1, n - 1)) {
L = mid;
} else {
R = mid;
}
}
vector<pair<long long, long long> > bb(n);
long long hv = (num + L) % n;
for (int i = 0; i < n; i++) {
bb[i] = {a_[(i + hv) % n], (long long)i};
}
buildBin(bb);
cout << dfs(0, n - 1) << " " << hv << "\n";
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
mt19937_64 mt_rand(chrono::system_clock::now().time_since_epoch().count());
template <typename T1, typename T2>
inline bool upmax(T1& a, T2 b) {
return (a < b ? (a = b, true) : false);
}
template <typename T1, typename T2>
inline bool upmin(T1& a, T2 b) {
return (b < a ? (a = b, true) : false);
}
const int maxn = (int)4e5 + 100;
const int maxlog = 21;
const int base = 1e9 + 7;
const long double eps = (long double)1e-9;
const long double PI = acos(-1.);
const int inf = 2e9;
const long long llinf = 1e18;
int tmin[4 * maxn];
int tdep[4 * maxn];
int tmxdep[4 * maxn];
int table[22][maxn];
int numlog[maxn];
int n;
int a[maxn];
int L, R;
void buildTable() {
numlog[1] = 0;
for (int i = 2; i <= R; i++) numlog[i] = numlog[i / 2] + 1;
for (int i = 0; i <= numlog[R]; i++) {
int curlen = 1 << i;
for (int j = 1; j <= R; j++) {
if (i == 0) {
table[i][j] = a[j];
continue;
}
table[i][j] = min(table[i - 1][j], table[i - 1][j + curlen / 2]);
}
}
}
int GetMin(int l, int r) {
int curlog = numlog[r - l + 1];
return min(table[curlog][l], table[curlog][r - (1 << curlog) + 1]);
}
void bld(int v, int l, int r) {
if (l == r)
tmin[v] = inf;
else {
int m = (l + r) >> 1;
bld(v + v, l, m);
bld(v + v + 1, m + 1, r);
tmin[v] = min(tmin[v + v], tmin[v + v + 1]);
}
}
void push(int v, int l, int r) {
if (l != r && tdep[v]) {
tdep[v + v] += tdep[v];
tdep[v + v + 1] += tdep[v];
tmxdep[v + v] += tdep[v];
tmxdep[v + v + 1] += tdep[v];
tdep[v] = 0;
}
}
void add(int v, int l, int r, int pos, int val, int deps) {
if (l == r) {
tmin[v] = val;
tdep[v] = deps;
tmxdep[v] = deps;
} else {
push(v, l, r);
int m = (l + r) >> 1;
if (pos <= m)
add(v + v, l, m, pos, val, deps);
else
add(v + v + 1, m + 1, r, pos, val, deps);
tmin[v] = min(tmin[v + v], tmin[v + v + 1]);
tmxdep[v] = max(tmxdep[v + v], tmxdep[v + v + 1]);
}
}
void upd(int v, int tl, int tr, int l, int r, int kek) {
if (tl == l && tr == r) {
tdep[v] += kek;
tmxdep[v] += kek;
} else {
push(v, tl, tr);
int m = (tl + tr) >> 1;
if (l <= m) upd(v + v, tl, m, l, min(r, m), kek);
if (r > m) upd(v + v + 1, m + 1, tr, max(l, m + 1), r, kek);
tmxdep[v] = max(tmxdep[v + v], tmxdep[v + v + 1]);
}
}
int getmin(int v, int tl, int tr, int l, int r) {
if (tl == l && tr == r) {
return tmin[v];
} else {
push(v, tl, tr);
int m = (tl + tr) >> 1;
int mn = inf;
if (l <= m) upmin(mn, getmin(v + v, tl, m, l, min(r, m)));
if (r > m) upmin(mn, getmin(v + v + 1, m + 1, tr, max(l, m + 1), r));
return mn;
}
}
int getdep(int v, int l, int r, int pos) {
if (l == r) {
return tmxdep[v];
}
push(v, l, r);
int m = (l + r) >> 1;
if (pos <= m)
return getdep(v + v, l, m, pos);
else
return getdep(v + v + 1, m + 1, r, pos);
}
void add(int pos, int val) {
int l = 1;
int r = pos;
while (l != r) {
int m = (l + r) >> 1;
if (GetMin(m, pos) < val) {
l = m + 1;
} else {
r = m;
}
}
int dep = getdep(1, L, R, l - 1) + 1;
if (l <= pos - 1) {
upd(1, L, R, l, pos - 1, +1);
}
add(1, L, R, pos, val, dep);
}
void rem(int pos, int val) {
int l = pos;
int r = R;
while (l != r) {
int m = (l + r + 1) >> 1;
if (GetMin(pos, m) < val) {
r = m - 1;
} else {
l = m;
}
}
if (l >= pos + 1) {
upd(1, L, R, pos + 1, l, -1);
}
add(1, L, R, pos, val, 0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
L = 0;
R = 2 * n;
bld(1, L, R);
buildTable();
for (int i = 1; i <= n; i++) {
add(i, a[i]);
}
int ans = tmxdep[1];
int shift = 0;
for (int i = 1; i < n; i++) {
rem(i, a[i]);
a[i + n] = a[i];
add(i + n, a[i + n]);
if (upmin(ans, tmxdep[1])) {
shift = i;
}
}
cout << ans << ' ' << shift << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int num[400005];
pair<int, int> min(pair<int, int> a, pair<int, int> b) {
if (a.first <= b.first)
return a;
else
return b;
}
int lmn[400005][19], rmn[400005][19];
int leftMin(int i) {
int p = i;
for (int j = (18); j >= (0); j--) {
int tp = p - (1 << j);
if (tp >= max(0, i - n) && lmn[p][j] >= num[i]) p = tp;
}
return p;
}
int rightMin(int i) {
int p = i;
for (int j = (18); j >= (0); j--) {
int tp = p + (1 << j);
if (tp <= i + n && rmn[p][j] >= num[i]) p = tp;
}
return p;
}
template <typename T, typename T2>
class segmentTree {
public:
vector<T> seg;
vector<T2> lazy;
int mxs;
T sfill;
T2 lfill;
int ql, qr;
T2 qv;
segmentTree(int _mxs, T _sfill, T2 _lfill) : sfill(_sfill), lfill(_lfill) {
for (mxs = 1; mxs < _mxs; mxs <<= 1)
;
seg.assign((mxs << 1) + 5, sfill);
lazy.assign((mxs << 1) + 5, lfill);
}
T combine(T a, T b) { return max(a, b); }
void ppt(int i, int l, int r) {
if (lazy[i] == lfill) return;
seg[i] += lazy[i];
if (i < mxs) {
lazy[i << 1] += lazy[i];
lazy[i << 1 | 1] += lazy[i];
}
lazy[i] = lfill;
}
void merge(int i) { seg[i] = combine(seg[i << 1], seg[i << 1 | 1]); }
T query(int l, int r, int i) {
ppt(i, l, r);
if (qr < l || r < ql) return sfill;
if (ql <= l && r <= qr) return seg[i];
int m = (l + r) >> 1;
T lft = query(l, m, i << 1);
T rgt = query(m + 1, r, i << 1 | 1);
return merge(i), combine(lft, rgt);
}
T qry(int _ql, int _qr) {
ql = _ql;
qr = _qr;
return query(1, mxs, 1);
}
void update(int l, int r, int i) {
ppt(i, l, r);
if (qr < l || r < ql) return;
if (ql <= l && r <= qr) {
lazy[i] += qv;
ppt(i, l, r);
return;
}
int m = (l + r) >> 1;
update(l, m, i << 1);
update(m + 1, r, i << 1 | 1);
return merge(i);
}
void upd(int _ql, int _qr, T2 _qv) {
ql = _ql;
qr = _qr;
qv = _qv;
update(1, mxs, 1);
}
};
segmentTree<int, int> s(400000, 0, 0);
void remove(int i) {
int p = rightMin(i);
s.upd(i + 1, p - 1, -1);
s.upd(i, i, -s.qry(i, i));
}
void insert(int i) {
int p = leftMin(i);
int dh = (p == max(0, i - n) ? 0 : s.qry(p, p)) + 1;
s.upd(i, i, dh);
s.upd(p + 1, i - 1, 1);
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) {
scanf("%d", &num[i]);
num[i + n] = num[i];
}
for (int i = (1); i <= (n + n); i++) lmn[i][0] = rmn[i][0] = num[i];
for (int j = (1); j <= (18); j++) {
for (int i = (1); i <= (n + n); i++) {
lmn[i][j] = lmn[i][j - 1];
int p = i - (1 << (j - 1));
if (p >= 1) {
lmn[i][j] = min(lmn[i][j], lmn[p][j - 1]);
}
rmn[i][j] = rmn[i][j - 1];
p = i + (1 << (j - 1));
if (p <= n + n) {
rmn[i][j] = min(rmn[i][j], rmn[p][j - 1]);
}
}
}
pair<int, int> ans = {1000000000, 0};
for (int i = (1); i <= (n + n - 1); i++) {
if (i > n) remove(i - n);
insert(i);
if (i >= n) ans = min(ans, {s.seg[1], i - n});
}
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 7;
struct SegmentTree {
int a[N << 2], lazy[N << 2];
inline void pull(int rt) { a[rt] = max(a[rt << 1], a[rt << 1 | 1]); }
inline void push(int rt) {
if (lazy[rt]) {
a[rt << 1] += lazy[rt];
a[rt << 1 | 1] += lazy[rt];
lazy[rt << 1] += lazy[rt];
lazy[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
}
void build(int *depth, int l, int r, int rt) {
if (l == r) {
a[rt] = depth[l];
return;
}
int mid = l + r >> 1;
build(depth, l, mid, rt << 1);
build(depth, mid + 1, r, rt << 1 | 1);
pull(rt);
}
void update(int L, int R, int val, int l, int r, int rt) {
if (R < l || r < L || R < L) return;
if (L <= l && r <= R) {
a[rt] += val;
lazy[rt] += val;
return;
}
push(rt);
int mid = l + r >> 1;
update(L, R, val, l, mid, rt << 1);
update(L, R, val, mid + 1, r, rt << 1 | 1);
pull(rt);
}
void update2(int p, int val, int l, int r, int rt) {
if (l == r) {
a[rt] = val;
return;
}
push(rt);
int mid = l + r >> 1;
if (p <= mid)
update2(p, val, l, mid, rt << 1);
else
update2(p, val, mid + 1, r, rt << 1 | 1);
pull(rt);
}
int query(int L, int R, int l, int r, int rt) {
if (R < l || r < L || R < L) return 0;
if (L <= l && r <= R) return a[rt];
push(rt);
int mid = l + r >> 1;
return max(query(L, R, l, mid, rt << 1),
query(L, R, mid + 1, r, rt << 1 | 1));
}
} Tree;
int n;
int a[N << 1];
int stk[N << 1], top;
int L[N << 1], R[N << 1];
int ls[N], rs[N];
bool vis[N];
int depth[N];
void dfs(int u, int dep) {
depth[u] = dep;
if (ls[u]) dfs(ls[u], dep + 1);
if (rs[u]) dfs(rs[u], dep + 1);
}
void modify(int l, int r, int val) {
if (l > r) return;
if (l > n) l -= n;
if (r > n) r -= n;
if (l <= r)
Tree.update(l, r, val, 1, n, 1);
else {
Tree.update(1, r, val, 1, n, 1);
Tree.update(l, n, val, 1, n, 1);
}
}
void show() {
for (int i = 1; i <= n; i++) printf("%d: %d\n", i, Tree.query(i, i, 1, n, 1));
puts("");
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) a[i + n] = a[i];
top = 0;
for (int i = 1; i <= n * 2; i++) {
while (top && a[stk[top]] > a[i]) top--;
L[i] = top ? stk[top] : 0;
stk[++top] = i;
}
top = 0;
for (int i = n * 2; i >= 1; i--) {
while (top && a[stk[top]] > a[i]) top--;
R[i] = top ? stk[top] : (n * 2 + 1);
stk[++top] = i;
}
top = 0;
for (int i = 1; i <= n; i++) {
int tmp = top;
while (top && a[stk[tmp]] > a[i]) tmp--;
if (tmp) rs[stk[tmp]] = i;
if (tmp < top) ls[i] = stk[tmp + 1];
stk[++tmp] = i;
top = tmp;
}
for (int i = 1; i <= n; i++) vis[ls[i]] = vis[rs[i]] = true;
int Rt = -1;
for (int i = 1; i <= n; i++)
if (!vis[i]) Rt = i;
dfs(Rt, 1);
Tree.build(depth, 1, n, 1);
pair<int, int> ans = make_pair(Tree.query(1, n, 1, n, 1), 0);
for (int i = 1; i < n; i++) {
int l = i + 1;
int r = min(R[i], i + n) - 1;
modify(l, r, -1);
r = i + n - 1;
l = max(i, L[i + n]) + 1;
modify(l, r, 1);
int pos = (l - 1) > n ? (l - 1 - n) : (l - 1);
int now_depth = (l - 1 <= i) ? 1 : (Tree.query(pos, pos, 1, n, 1) + 1);
Tree.update2(i, now_depth, 1, n, 1);
ans = min(ans, make_pair(Tree.query(1, n, 1, n, 1), i));
}
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, ls[N], rs[N], vis[N], stk[N], rt;
int dg[N];
int a[N], b[N], c[N];
void build() {
int top = 0;
for (int i = 1; i <= n; i++) {
ls[i] = 0, rs[i] = 0, vis[i] = 0;
}
for (int i = 1; i <= n; i++) {
int k = top;
while (k > 0 && a[stk[k - 1]] > a[i]) k--;
if (k) rs[stk[k - 1]] = i;
if (k < top) ls[i] = stk[k];
stk[k++] = i;
top = k;
}
for (int i = 1; i <= n; i++) {
vis[ls[i]] = vis[rs[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (vis[i] == 0) rt = i;
}
}
void dfs(int u) {
dg[u] = 1;
if (ls[u]) dfs(ls[u]), dg[u] = max(dg[u], dg[ls[u]] + 1);
if (rs[u]) dfs(rs[u]), dg[u] = max(dg[u], dg[rs[u]] + 1);
}
pair<int, int> solve(int p) {
build();
dfs(rt);
if (dg[ls[rt]] <= dg[rs[rt]]) return pair<int, int>(dg[rt], 0);
int lo = 0, hi = p - 1, res, ans;
while (lo <= hi) {
int mid = lo + hi >> 1;
for (int i = mid % n + 1, j = 1; j <= n; j++, i = i % n + 1) {
b[j] = a[i];
c[j] = a[j];
}
for (int i = 1; i <= n; i++) a[i] = b[i];
build();
dfs(rt);
if (dg[ls[rt]] >= dg[rs[rt]])
res = mid, lo = mid + 1, ans = dg[rt];
else
hi = mid - 1;
for (int i = 1; i <= n; i++) a[i] = c[i];
}
lo = 0, hi = res;
while (lo <= hi) {
int mid = lo + hi >> 1;
for (int i = mid % n + 1, j = 1; j <= n; j++, i = i % n + 1) {
b[j] = a[i];
c[j] = a[j];
}
for (int i = 1; i <= n; i++) a[i] = b[i];
build();
dfs(rt);
if (dg[rt] == ans)
res = mid, hi = mid - 1;
else
lo = mid + 1;
for (int i = 1; i <= n; i++) a[i] = c[i];
}
return pair<int, int>(ans, res);
}
int main() {
scanf("%d", &n);
int p = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) p = i;
}
pair<int, int> ans1 = solve(p);
for (int i = p % n + 1, j = 1; j <= n; j++, i = i % n + 1) {
b[j] = a[i];
}
for (int i = 1; i <= n; i++) a[i] = b[i];
pair<int, int> ans2 = solve(n);
ans2.second += p;
if (ans1.first > ans2.first) swap(ans1, ans2);
if (ans1.first == ans2.first) {
if (ans1.second > ans2.second) swap(ans1, ans2);
}
printf("%d %d\n", ans1.first, ans1.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400005;
int n, lg[N], rid[N], a[N], b[N], st[N << 2], tg[N << 2], f[N][25];
void build(int x, int l, int r) {
if (l == r) {
st[x] = b[l];
return;
}
int mid = l + r >> 1;
build((x << 1), l, mid), build((x << 1 | 1), mid + 1, r);
st[x] = max(st[(x << 1)], st[(x << 1 | 1)]);
}
void pushdown(int x) {
if (!tg[x]) return;
tg[(x << 1)] += tg[x], tg[(x << 1 | 1)] += tg[x];
st[(x << 1)] += tg[x], st[(x << 1 | 1)] += tg[x];
tg[x] = 0;
}
void update(int x, int l, int r, int sl, int sr, int w) {
if (sl > sr) return;
if (sl <= l && r <= sr) {
st[x] += w, tg[x] += w;
return;
}
pushdown(x);
int mid = l + r >> 1;
if (sl <= mid) update((x << 1), l, mid, sl, sr, w);
if (sr > mid) update((x << 1 | 1), mid + 1, r, sl, sr, w);
st[x] = max(st[(x << 1)], st[(x << 1 | 1)]);
}
int qq(int x, int l, int r, int s) {
if (!s) return 0;
if (l == r) return st[x];
pushdown(x);
int mid = l + r >> 1;
return (s <= mid ? qq((x << 1), l, mid, s) : qq((x << 1 | 1), mid + 1, r, s));
}
int query(int x, int l, int r, int sl, int sr) {
if (sl <= l && r <= sr) return st[x];
pushdown(x);
int mid = l + r >> 1, ans = 0;
if (sl <= mid) ans = query((x << 1), l, mid, sl, sr);
if (sr > mid) ans = max(ans, query((x << 1 | 1), mid + 1, r, sl, sr));
return ans;
}
int qmin(int l, int r) {
int t = lg[r - l + 1];
return min(f[l][t], f[r - (1 << t) + 1][t]);
}
int findl(int l, int r, int w) {
while (l <= r) {
int mid = l + r >> 1;
if (qmin(l, mid) < w)
r = mid - 1;
else
l = mid + 1;
}
return r + 1;
}
int findr(int l, int r, int w) {
while (l <= r) {
int mid = l + r >> 1;
if (qmin(mid, r) < w)
l = mid + 1;
else
r = mid - 1;
}
return l - 1;
}
void init(int l, int r, int d) {
if (l > r) return;
int x = rid[qmin(l, r)];
b[x] = d;
init(l, x - 1, d + 1), init(x + 1, r, d + 1);
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) lg[i] = lg[i >> 1] + 1;
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), rid[a[i]] = i, a[i + n] = a[i];
for (int i = 1; i <= (n << 1); ++i) f[i][0] = a[i];
for (int j = 1; (1 << j) <= (n << 1); ++j)
for (int i = 1; i + (1 << j - 1) <= (n << 1); ++i)
f[i][j] = min(f[i][j - 1], f[i + (1 << j - 1)][j - 1]);
init(1, n, 1);
build(1, 1, (n << 1));
int del = 0, ans = query(1, 1, (n << 1), 1, n);
for (int i = 1; i < n; ++i) {
int lp = findl(i + 1, i + n - 1, a[i]), rp = findr(i + 1, i + n - 1, a[i]);
update(1, 1, (n << 1), i + 1, lp - 1, -1);
update(1, 1, (n << 1), rp + 1, i + n - 1, 1);
if (a[i] == 1)
update(1, 1, (n << 1), i + n, i + n, 1);
else
update(1, 1, (n << 1), i + n, i + n, qq(1, 1, (n << 1), rp) + 1);
int tmp = query(1, 1, (n << 1), i + 1, i + n);
if (tmp < ans) ans = tmp, del = i;
}
printf("%d %d\n", ans, del);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("2,Ofast,inline")
const long long N = 2e5 + 10;
const long long mod = 1e9 + 7;
const long long inf = 0x3f3f3f3f;
const double eps = 1e-9;
using namespace std;
template <typename tp>
inline void read(tp &x) {
x = 0;
char c = getchar();
bool f = 0;
for (; c < '0' || c > '9'; f |= (c == '-'), c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar())
;
if (f) x = -x;
}
int n, x[N << 1], root, dfns, ans, anss;
struct Node {
int ch[2], val, dfn, max_dfn;
} node[N << 1];
stack<int> st;
int tree[N << 3], tag[N << 3];
void push_down(int now) {
tree[now << 1] += tag[now];
tree[now << 1 | 1] += tag[now];
tag[now << 1] += tag[now];
tag[now << 1 | 1] += tag[now];
tag[now] = 0;
}
void change(int now, int l, int r, int ql, int qr, int k) {
if (ql <= l && r <= qr) {
tree[now] += k;
tag[now] += k;
return;
}
if (qr < l || r < ql) return;
int mid = (l + r) >> 1;
push_down(now);
change(now << 1, l, mid, ql, qr, k);
change(now << 1 | 1, mid + 1, r, ql, qr, k);
tree[now] = max(tree[now << 1], tree[now << 1 | 1]);
}
void dfs(int now, int dep) {
if (!now) return;
node[now].dfn = ++dfns;
dep += node[now].val;
change(1, 1, n * 2, node[now].dfn, node[now].dfn, dep);
dfs(node[now].ch[0], dep);
dfs(node[now].ch[1], dep);
node[now].max_dfn = dfns;
}
signed main() {
read(n);
for (int i = 1; i <= n; i++) read(x[i]), x[i + n] = x[i];
for (int i = 1; i <= n * 2; i++) {
if (x[i] == 1 && !root) root = i;
int flag = 0;
while (!st.empty() && x[st.top()] > x[i]) flag = st.top(), st.pop();
node[i].ch[0] = flag;
if (!st.empty()) node[st.top()].ch[1] = i;
st.push(i);
}
for (int i = 1; i <= n; i++) node[i].val = 1;
dfs(root, 0);
ans = tree[1];
for (int i = 1; i < n; i++) {
change(1, 1, n * 2, node[i].dfn, node[i].max_dfn, -1);
change(1, 1, n * 2, node[i + n].dfn, node[i + n].max_dfn, 1);
if (ans > tree[1]) ans = tree[1], anss = i;
}
printf("%d %d\n", ans, anss);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)4e5 + 7;
int n, a[N], lft[N], rgh[N], spawn[N];
vector<int> stk;
int tmax[4 * N];
int lazy[4 * N];
void push(int v, int tl, int tr) {
if (lazy[v]) {
tmax[v] += lazy[v];
if (tl < tr) {
lazy[2 * v] += lazy[v];
lazy[2 * v + 1] += lazy[v];
}
lazy[v] = 0;
}
}
void add(int v, int tl, int tr, int l, int r, int x) {
push(v, tl, tr);
if (tr < l || r < tl) return;
if (l <= tl && tr <= r) {
lazy[v] += x;
push(v, tl, tr);
return;
}
int tm = (tl + tr) / 2;
add(2 * v, tl, tm, l, r, x);
add(2 * v + 1, tm + 1, tr, l, r, x);
tmax[v] = max(tmax[2 * v], tmax[2 * v + 1]);
}
int get(int v, int tl, int tr, int l, int r) {
push(v, tl, tr);
if (tr < l || r < tl) return 0;
if (l <= tl && tr <= r) return tmax[v];
int tm = (tl + tr) / 2;
return max(get(2 * v, tl, tm, l, r), get(2 * v + 1, tm + 1, tr, l, r));
}
void add(int l, int r, int val) { add(1, 1, 2 * n, l, r, val); }
int max_dep(int l, int r) { return get(1, 1, 2 * n, l, r); }
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
for (int i = 1; i <= 2 * n; i++) {
while (!stk.empty() && a[stk.back()] >= a[i]) stk.pop_back();
lft[i] = (stk.empty() ? -1 : stk.back());
stk.push_back(i);
if (i <= n) {
add(i, i, (int)stk.size());
} else {
spawn[i] = (int)stk.size();
}
}
stk.clear();
for (int i = 2 * n; i >= 1; i--) {
while (!stk.empty() && a[stk.back()] >= a[i]) stk.pop_back();
rgh[i] = (stk.empty() ? -1 : stk.back());
stk.push_back(i);
}
stk.clear();
for (int i = n; i >= 1; i--) {
while (!stk.empty() && a[stk.back()] >= a[i]) stk.pop_back();
add(i, i, (int)stk.size());
stk.push_back(i);
}
for (int i = 1; i <= n; i++) {
assert((rgh[i] == -1) == (a[i] == 1));
}
for (int i = n + 1; i <= 2 * n; i++) {
assert((lft[i] == -1) == (a[i] == 1));
}
int ret = max_dep(1, n), shift = 0;
for (int l = 2; l <= n; l++) {
if (a[l - 1] == 1) {
add(l, l + n - 2, -1);
} else {
add(l, rgh[l - 1] - 1, -1);
}
int j = l + n - 1;
add(j, j, spawn[j]);
if (a[j] == 1) {
add(j - n + 1, j - 1, +1);
} else {
add(lft[j] + 1, j - 1, +1);
}
int val = max_dep(l, j);
if (val < ret) {
ret = val;
shift = l - 1;
}
}
cout << ret << " " << shift << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
struct SegTree {
struct node {
int mx, lazy;
node() { mx = lazy = 0; }
};
vector<node> tree;
void init(int n) {
tree.resize(4 * n);
for (int i = 0; i < ((int)tree.size()); i++) {
tree[i].mx = tree[i].lazy = 0;
}
}
void push(int tl, int tr, int h) {
if (tl < tr) {
tree[h * 2].lazy += tree[h].lazy;
tree[h * 2 + 1].lazy += tree[h].lazy;
}
tree[h].mx += tree[h].lazy;
tree[h].lazy = 0;
}
void update(int l, int r, int x, int tl, int tr, int h = 1) {
push(tl, tr, h);
if (l > r || tr < l || r < tl) return;
if (l <= tl && tr <= r) {
tree[h].lazy += x;
push(tl, tr, h);
return;
}
int mid = (tl + tr) / 2;
update(l, r, x, tl, mid, h * 2);
update(l, r, x, mid + 1, tr, h * 2 + 1);
tree[h].mx = max(tree[h * 2].mx, tree[h * 2 + 1].mx);
}
int query() { return tree[1].mx; }
int query(int p, int tl, int tr, int h = 1) {
push(tl, tr, h);
if (tr < p || p < tl) return 0;
if (tl == tr) return tree[h].mx;
int mid = (tl + tr) / 2;
return max(query(p, tl, mid, h * 2), query(p, mid + 1, tr, h * 2 + 1));
}
} mst;
int n;
int a[200010], rev[200010];
int dep[200010], L[200010], R[200010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int i, j;
cin >> n;
set<int> st;
for (i = 1; i <= n; i++) {
cin >> a[i];
rev[a[i]] = i;
}
for (i = 1; i <= n; i++) {
int pos = rev[i];
if (i > 1) {
auto it = st.lower_bound(pos);
if (it == st.end())
R[pos] = *st.begin();
else
R[pos] = *it;
if (it == st.begin())
L[pos] = *st.rbegin();
else
L[pos] = *prev(it, 1);
int par = -1;
if (it == st.end())
par = *prev(it, 1);
else if (it == st.begin())
par = *it;
else if (a[*prev(it, 1)] < a[*it])
par = *it;
else
par = *prev(it, 1);
dep[pos] = dep[par] + 1;
}
st.insert(pos);
}
mst.init(n + 1);
for (i = 1; i <= n; i++) {
mst.update(i, i, dep[i], 1, n);
}
int ans = mst.query(), ansk = 0;
for (i = 1; i < n; i++) {
if (a[i] == 1) continue;
int delta = mst.query(L[i], 1, n) + 1 - mst.query(i, 1, n);
mst.update(i, i, delta, 1, n);
if (i <= R[i]) {
mst.update(i + 1, R[i] - 1, -1, 1, n);
} else {
mst.update(i + 1, n, -1, 1, n);
mst.update(1, R[i] - 1, -1, 1, n);
}
if (L[i] <= i) {
mst.update(L[i] + 1, i - 1, 1, 1, n);
} else {
mst.update(1, i - 1, 1, 1, n);
mst.update(L[i] + 1, n, 1, 1, n);
}
int qry = mst.query();
if (qry < ans) {
ans = qry;
ansk = i;
}
}
cout << ans + 1 << ' ' << ansk;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) { return (!y ? x : gcd(y, x % y)); }
const int maxn = 4e5 + 10;
const int M = 19;
int a[maxn], b[maxn];
int rmq[M][maxn], lg[maxn];
inline int cmp(int i, int j) { return (a[i] < a[j] ? i : j); }
inline int get(int l, int r) {
int t = lg[r - l];
return cmp(rmq[t][l], rmq[t][r - (1 << t)]);
}
int n, lef, rig;
int solve(int l, int r) {
if (r - l <= 1) return r - l;
int mid = get(l, r);
int t1 = solve(l, mid);
int t2 = solve(mid + 1, r);
if (r - l == n) lef = t1, rig = t2;
return 1 + max(t1, t2);
}
int32_t main() {
cin >> n;
for (int i = 2; i < maxn; i++) lg[i] = lg[i / 2] + 1;
int pos = -1;
for (int i = 0; i < n; i++) {
cin >> b[i];
b[i]--;
if (b[i] == 0) pos = i;
}
assert(pos != -1);
if (n == 1) {
cout << "1 0" << '\n';
return 0;
}
int sz = 0;
for (int i = pos; i < n; i++) a[sz++] = b[i];
for (int i = 0; i < pos; i++) a[sz++] = b[i];
assert(sz == n);
for (int i = n; i < 2 * n; i++) a[i] = a[i - n];
int m = n;
n *= 2;
for (int i = 0; i < n; i++) rmq[0][i] = i;
for (int j = 1; j < M; j++)
for (int i = 0; i + (1 << j) <= n; i++)
rmq[j][i] = cmp(rmq[j - 1][i], rmq[j - 1][i + (1 << (j - 1))]);
n /= 2;
int hi = n, lo = 1;
while (hi - lo > 1) {
int mid = hi + lo >> 1;
solve(mid, mid + n);
if (rig >= lef)
hi = mid;
else
lo = mid;
}
int x = solve(hi, hi + n);
int y = solve(hi - 1, hi - 1 + n);
int ans = (x < y ? hi : hi - 1);
cout << min(x, y) << " ";
for (int i = 0; i < n; i++)
if (b[i] == a[ans]) cout << i << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1.01e9;
pair<int, int> solve(vector<int> a) {
int n = a.size();
int pos = min_element(a.begin(), a.end()) - a.begin();
for (int i = 0; i < n * 2; i++) a.push_back(a[i]);
vector<int> dp(a.size());
auto calc_h = [&](int l, int r) {
vector<int> st;
auto put = [&](int i) {
dp[i] = 1;
int last = 0;
while (!st.empty() && a[st.back()] > a[i]) {
dp[st.back()] = max(dp[st.back()], last + 1);
last = dp[st.back()];
st.pop_back();
}
dp[i] = last + 1;
st.push_back(i);
};
for (int i = l; i <= r; i++) {
put(i);
}
int old = a[r + 1];
a[r + 1] = -1;
put(r + 1);
a[r + 1] = old;
return dp[r + 1] - 1;
};
int L = -1, R = n;
while (R - L > 1) {
int M = (L + R) >> 1;
int elems_left = M;
int elems_right = n - 1 - elems_left;
int h_right = calc_h(pos + 1, pos + elems_right);
int h_left = calc_h(pos + elems_right + 1, pos + n - 1);
if (h_left < h_right) {
L = M;
} else {
R = M;
}
}
int first_pos = pos - R;
if (first_pos < 0) first_pos += n;
a.resize(n);
rotate(a.begin(), a.begin() + first_pos, a.end());
int res = calc_h(0, n - 1);
return make_pair(res, first_pos);
}
pair<int, int> slow(vector<int> a) {
auto subsolve = [&](vector<int> a) {
function<int(int, int)> rec = [&](int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
int m = l;
for (int i = l + 1; i <= r; i++)
if (a[i] < a[m]) m = i;
return 1 + max(rec(l, m - 1), rec(m + 1, r));
};
return make_pair(rec(0, a.size() - 1), -1);
};
pair<int, int> ans = make_pair(1e9, -1);
int n = a.size();
for (int i = 0; i < n; i++) {
ans = min(ans, subsolve(a));
rotate(a.begin(), a.begin() + 1, a.end());
}
return ans;
}
void stress() {
for (int it = 0;; it++) {
;
;
mt19937 rnd(it);
int n = rnd() % 100 + 1;
vector<int> p(n);
iota(p.begin(), p.end(), 0);
shuffle(p.begin(), p.end(), rnd);
auto ans1 = solve(p);
auto ans2 = slow(p);
;
;
assert(ans1.first == ans2.first);
}
}
int main() {
int n;
while (scanf("%d", &n) == 1) {
vector<int> a(n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i]--;
}
auto o = solve(a);
cout << o.first << " " << o.second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
struct SGT {
int val[MAXN * 4], lazy[MAXN * 4];
void push_down(int root) {
lazy[root << 1] += lazy[root];
lazy[root << 1 | 1] += lazy[root];
val[root << 1] += lazy[root];
val[root << 1 | 1] += lazy[root];
lazy[root] = 0;
}
void set(int root, int left, int right, int l, int r, int d) {
if (r < left || right < l) {
return;
} else if (l <= left && right <= r) {
lazy[root] = d;
val[root] = d;
} else {
int mid = (left + right) / 2;
push_down(root);
set(root << 1, left, mid, l, r, d);
set(root << 1 | 1, mid + 1, right, l, r, d);
val[root] = max(val[root << 1], val[root << 1 | 1]);
}
}
void update(int root, int left, int right, int l, int r, int d) {
if (r < left || right < l) {
return;
} else if (l <= left && right <= r) {
lazy[root] += d;
val[root] += d;
} else {
int mid = (left + right) / 2;
push_down(root);
update(root << 1, left, mid, l, r, d);
update(root << 1 | 1, mid + 1, right, l, r, d);
val[root] = max(val[root << 1], val[root << 1 | 1]);
}
}
int query(int root, int left, int right, int l, int r) {
if (r < left || right < l) {
return -1;
} else if (l <= left && right <= r) {
return val[root];
} else {
int mid = (left + right) / 2;
push_down(root);
return max(query(root << 1, left, mid, l, r),
query(root << 1 | 1, mid + 1, right, l, r));
}
}
};
int n, a[MAXN];
struct MyStack {
stack<int> stk;
void init(int val) {
while (!stk.empty()) {
stk.pop();
}
stk.push(val);
}
int insert(int val) {
while (a[stk.top()] > a[val]) {
stk.pop();
}
int res = stk.top();
stk.push(val);
return res;
}
};
int left_smaller[MAXN], right_smaller[MAXN];
int cnt_left[MAXN], cnt_right[MAXN], cnt[MAXN];
MyStack stk;
SGT sgt;
void cycle_update(int l, int r, int d) {
l = (l + n) % n;
r = (r + n) % n;
if (l <= r) {
sgt.update(1, 0, n - 1, l, r, d);
} else {
sgt.update(1, 0, n - 1, l, n - 1, d);
sgt.update(1, 0, n - 1, 0, r, d);
}
}
int main() {
scanf("%d", &n);
int pos_n, pos_1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) {
pos_1 = i;
}
}
stk.init(pos_1);
left_smaller[pos_1] = pos_1;
for (int i = 1; i < n; i++) {
int idx = (pos_1 + i) % n;
left_smaller[idx] = stk.insert(idx);
cnt[idx] = cnt[left_smaller[idx]] + 1;
}
stk.init(pos_1);
right_smaller[pos_1] = pos_1;
for (int i = 1; i < n; i++) {
int idx = (pos_1 + n - i) % n;
right_smaller[idx] = stk.insert(idx);
}
for (int i = 0; i < n; i++) {
if (left_smaller[i] < i) {
cnt_left[i] = cnt_left[left_smaller[i]] + 1;
}
}
for (int i = n - 1; i >= 0; i--) {
if (right_smaller[i] > i) {
cnt_right[i] = cnt_right[right_smaller[i]] + 1;
}
}
for (int i = 0; i < n; i++) {
sgt.update(1, 0, n - 1, i, i, cnt_left[i] + cnt_right[i]);
}
int ans = n, ans_idx;
for (int i = 0; i < n; i++) {
int cur = min(ans, sgt.query(1, 0, n - 1, 0, n - 1));
if (cur < ans) {
ans = cur;
ans_idx = i;
}
cycle_update(i, right_smaller[i] - 1, -1);
cycle_update(left_smaller[i] + 1, i, 1);
sgt.set(1, 0, n - 1, i, i, cnt[i]);
}
printf("%d %d\n", ans + 1, ans_idx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9, maxn = 262144;
struct tournament {
vector<int> t;
int sz;
tournament(int _sz) {
sz = _sz;
for (int i = 0; i < sz; i++) {
t.push_back(inf);
}
}
void update(int x, int val) {
t[x] = val;
for (x /= 2; x > 0; x /= 2) {
t[x] = min(t[x * 2], t[x * 2 + 1]);
}
}
int query(int L, int D, int x, int l, int d) {
if (L >= l && D <= d) {
return t[x];
}
int lijeva = 1e9, desna = 1e9;
if ((L + D) / 2 >= l) {
lijeva = query(L, (L + D) / 2, x * 2, l, d);
}
if ((L + D) / 2 + 1 <= d) {
desna = query((L + D) / 2 + 1, D, x * 2 + 1, l, d);
}
return min(lijeva, desna);
}
};
int n;
tournament T(maxn * 2);
int pos[maxn], l[maxn];
int shiftaj(int x, int y) {
if (x == y) {
return 0;
}
int z = pos[T.query(0, maxn - 1, 1, x, y - 1)];
return max(shiftaj(x, z), shiftaj(z + 1, y)) + 1;
}
int binary() {
int lo = 0, hi = n - 1, mid;
while (hi - lo > 1) {
mid = (lo + hi) / 2;
if (shiftaj(1, n - mid) > shiftaj(n - mid, n)) {
lo = mid;
} else {
hi = mid;
}
}
if (max(shiftaj(1, n - lo), shiftaj(n - lo, n)) >
max(shiftaj(1, n - hi), shiftaj(n - hi, n))) {
return hi;
}
return lo;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> l[i];
pos[l[i]] = i;
}
int br = 0;
int p = pos[1];
for (int i = p; i != (p - 1 + n) % n; i = (i + 1) % n) {
T.update(br + maxn, l[i]);
pos[l[i]] = br;
br++;
}
T.update(br + maxn, l[(p - 1 + n) % n]);
pos[l[(p - 1 + n) % n]] = br;
int x = binary();
cout << max(shiftaj(1, n - x), shiftaj(n - x, n)) + 1 << " "
<< (n - (x + n - p) % n) % n << '\n';
return 0;
}
|
#include <bits/stdc++.h>
int n, n2, st_t = 0, dep, ans;
int a[200002], l[200002], r[200002], fa[200002], st[200002], arr[800002] = {},
laz[800002] = {};
int mn[400002][22];
inline int min(int x, int y) { return x < y ? x : y; }
inline int max(int x, int y) { return x > y ? x : y; }
inline int lson(int x) { return (x << 1); }
inline int rson(int x) { return ((x << 1) | 1); }
inline void modify(int k, int l, int r, int l1, int r1, int d) {
if (l1 > r1) return;
if (l >= l1 && r <= r1) {
laz[k] += d;
return;
}
int mid = ((l + r) >> 1), ls = lson(k), rs = rson(k);
laz[ls] += laz[k], laz[rs] += laz[k], laz[k] = 0;
if (r1 <= mid)
modify(ls, l, mid, l1, r1, d);
else if (l1 > mid)
modify(rs, mid + 1, r, l1, r1, d);
else
modify(ls, l, mid, l1, mid, d), modify(rs, mid + 1, r, mid + 1, r1, d);
arr[k] = max(arr[ls] + laz[ls], arr[rs] + laz[rs]);
}
inline int query(int k, int l, int r, int l1, int r1) {
if (l >= l1 && r <= r1) return arr[k] + laz[k];
int mid = ((l + r) >> 1), ls = lson(k), rs = rson(k);
laz[ls] += laz[k], laz[rs] += laz[k], arr[k] += laz[k], laz[k] = 0;
if (r1 <= mid) return query(ls, l, mid, l1, r1);
if (l1 > mid) return query(rs, mid + 1, r, l1, r1);
return max(query(ls, l, mid, l1, mid), query(rs, mid + 1, r, mid + 1, r1));
}
inline int before_mn(int x) {
int t = mn[x][0];
for (int i = 18; ~i; --i)
if (x - (1 << i) > 0 && mn[x - (1 << i)][i] >= t) x -= (1 << i);
return x - 1;
}
inline int after_mn(int x) {
int t = mn[x][0];
++x;
for (int i = 18; ~i; --i)
if (x + (1 << i) <= n2 && mn[x][i] >= t) x += (1 << i);
if (mn[x][0] <= t) --x;
return x + 1 <= n2 ? x + 1 : 0;
}
int main() {
scanf("%d", &n), n2 = (n << 1), st[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]), mn[i][0] = mn[i + n][0] = a[i];
while (a[i] < a[st[st_t]]) --st_t;
modify(1, 1, n, i, i, st_t + 1), modify(1, 1, n, st[st_t] + 1, i - 1, 1);
l[i] = r[st[st_t]], fa[r[st[st_t]]] = i, r[st[st_t]] = i, fa[i] = st[st_t],
st[++st_t] = i;
}
for (int i = 1; i <= 18; ++i)
for (int j = 1; j <= n2; ++j)
mn[j][i] = min(mn[j][i - 1], mn[min(n2, j + (1 << (i - 1)))][i - 1]);
dep = arr[1] + laz[1], ans = 0;
for (int i = 1, t; i < n; ++i) {
t = after_mn(i);
if (t) {
l[t % n] = r[i];
if (r[i]) fa[r[i]] = t % n;
} else if (r[i])
r[0] = r[i], fa[r[i]] = 0;
r[i] = 0;
modify(1, 1, n, i, i, -query(1, 1, n, i, i));
if (!t)
modify(1, 1, n, 1, i - 1, -1), modify(1, 1, n, i + 1, n, -1);
else if (t - 1 > n)
modify(1, 1, n, i + 1, n, -1), modify(1, 1, n, 1, t - n - 1, -1);
else
modify(1, 1, n, i + 1, t - 1, -1);
t = before_mn(i + n);
l[i] = r[t ? (t - 1) % n + 1 : 0];
if (r[t ? (t - 1) % n + 1 : 0]) fa[r[t ? (t - 1) % n + 1 : 0]] = i;
r[t ? (t - 1) % n + 1 : 0] = i, fa[i] = t ? (t - 1) % n + 1 : 0;
modify(1, 1, n, i, i,
t ? query(1, 1, n, (t - 1) % n + 1, (t - 1) % n + 1) + 1 : 1);
if (!t)
modify(1, 1, n, 1, i - 1, 1), modify(1, 1, n, i + 1, n, 1);
else if (t + 1 <= n)
modify(1, 1, n, t + 1, n, 1), modify(1, 1, n, 1, i - 1, 1);
else
modify(1, 1, n, t + 1 - n, i - 1, 1);
if (arr[1] + laz[1] < dep) dep = arr[1] + laz[1], ans = i;
}
printf("%d %d", dep, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr int INF = INT32_MAX;
constexpr int MAXN = 2e5 + 10;
constexpr double eps = 1e-8;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
using Vec = vector<int>;
template <class T>
void Min(T &a, T b) {
if (b < a) a = b;
}
template <class T>
void Max(T &a, T b) {
if (b > a) a = b;
}
ll N, M, K, T;
Vec pre_max, pre_min;
Vec nxt_max, nxt_min;
Vec A;
Vec c;
int t[MAXN * 4], add[MAXN * 4];
void Build(int v, int l, int r) {
if (l == r) {
t[v] = c[l];
return;
}
int m = (l + r) >> 1;
Build(v * 2, l, m);
Build(v * 2 + 1, m + 1, r);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
void Push(int v, int l, int r) {
if (l == r) return;
if (add[v] != 0) {
add[v * 2] += add[v];
add[v * 2 + 1] += add[v];
t[v * 2] += add[v];
t[v * 2 + 1] += add[v];
add[v] = 0;
}
}
void Upd(int v, int l, int r, int L, int R, int val) {
Push(v, l, r);
if (l > R || r < L) return;
if (L <= l && r <= R) {
t[v] += val;
add[v] += val;
return;
}
int m = (l + r) / 2;
Upd(v * 2, l, m, L, R, val);
Upd(v * 2 + 1, m + 1, r, L, R, val);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
int Qry(int v, int l, int r, int p) {
Push(v, l, r);
if (l == p && r == p) return t[v];
int m = (l + r) / 2;
if (p <= m) {
return Qry(v * 2, l, m, p);
} else {
return Qry(v * 2 + 1, m + 1, r, p);
}
}
void Solution() {
for (int i = (int)(0); i < (int)(N); ++i) A.emplace_back(A[i]);
pre_max.assign(N, -1);
pre_min.assign(N, -1);
nxt_max.assign(N, -1);
nxt_min.assign(N, -1);
for (int i = (int)(1); i < (int)(2 * N); ++i) {
if (A[i - 1] < A[i]) {
pre_min[i % N] = (i - 1) % N;
} else {
int j = pre_min[(i - 1) % N];
while (j != -1 && A[j] > A[i]) {
j = pre_min[j];
}
if (j == -1 || A[i] == A[j])
pre_min[i % N] = -1;
else
pre_min[i % N] = j;
}
}
for (int i = (int)(2 * N - 2); i >= (int)(0); --i) {
if (A[i + 1] < A[i]) {
nxt_min[i % N] = (i + 1) % N;
} else {
int j = nxt_min[(i + 1) % N];
while (j != -1 && A[j] > A[i]) {
j = nxt_min[j];
}
if (j == -1 || A[i] == A[j])
nxt_min[i % N] = -1;
else
nxt_min[i % N] = j;
}
}
c.assign(N, 0);
Vec a(N, 0), b(N, 0);
for (int i = (int)(0); i < (int)(N); ++i) {
int j = pre_min[i];
if (j == -1 || j == i) continue;
if (j < i) {
a[i] = a[j] + 1;
}
}
for (int i = (int)(N - 1); i >= (int)(0); --i) {
int j = nxt_min[i];
if (j == -1 || j == i) continue;
if (j > i) {
b[i] = b[j] + 1;
}
}
for (int i = (int)(0); i < (int)(N); ++i) c[i] = a[i] + b[i];
Build(1, 0, N - 1);
int ans = t[1];
int shift = 0;
for (int i = (int)(1); i < (int)(N); ++i) {
int j = nxt_min[i - 1];
if (j == -1 || j == i - 1) {
continue;
} else {
if (j > i - 1)
Upd(1, 0, N - 1, i, j - 1, -1);
else {
Upd(1, 0, N - 1, i, N - 1, -1);
Upd(1, 0, N - 1, 0, j - 1, -1);
}
}
j = pre_min[i - 1];
if (j < i - 1) {
Upd(1, 0, N - 1, j + 1, i - 2, 1);
} else {
Upd(1, 0, N - 1, 0, i - 2, 1);
Upd(1, 0, N - 1, j + 1, N - 1, 1);
}
int v1 = Qry(1, 0, N - 1, j);
int v2 = Qry(1, 0, N - 1, i - 1);
Upd(1, 0, N - 1, i - 1, i - 1, v1 + 1 - v2);
if (ans > t[1]) {
ans = t[1];
shift = i;
}
}
cout << ans + 1 << ' ' << shift << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
while (cin >> N) {
A.resize(N);
for (int i = (int)(0); i < (int)(N); ++i) cin >> A[i];
Solution();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 2;
int n, a[maxn], val[maxn];
int ls[maxn], rs[maxn], stk[maxn], p, rt;
int dpl[maxn], dpr[maxn];
int tmp_dep[maxn];
void solve_dp(int* dp) {
p = 0;
int mx = 0;
for (int i = 1; i < n; i++) {
int tmp = 0;
while (p && val[i] < val[stk[p]]) {
tmp = max(tmp, tmp_dep[stk[p--]]);
}
stk[++p] = i;
if (tmp == 0) {
tmp_dep[i] = p;
} else {
tmp_dep[i] = tmp + 1;
}
dp[i] = (mx = max(mx, tmp_dep[i]));
}
}
int main() {
cin >> n;
int mn = 1;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] < a[mn]) {
mn = i;
}
}
for (int i = 1, j = (mn - 2 + n) % n + 1; i < n;
i++, j = (j - 2 + n) % n + 1) {
val[i] = a[j];
}
solve_dp(dpl);
for (int i = 1, j = mn % n + 1; i < n; i++, j = j % n + 1) {
val[i] = a[j];
}
solve_dp(dpr);
int res = 1, ans = 2e9;
for (int i = 1; i <= n; i++) {
if (max(dpl[i - 1], dpr[n - i]) + 1 < ans) {
res = i;
ans = max(dpl[i - 1], dpr[n - i]) + 1;
}
}
cout << ans << ' ' << (mn + n - res) % n << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
using u64 = uint64_t;
using u32 = uint32_t;
struct Node {
int idx;
Node *left = nullptr, *right = nullptr;
};
int depth(Node* v) {
if (!v) return 0;
return max(depth(v->left), depth(v->right)) + 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (auto& ai : a) cin >> ai;
auto it = min_element(begin(a), end(a));
int orig_shift = (n - (it - begin(a))) % n;
rotate(begin(a), it, end(a));
int left = 0, right = n;
vector<int> b(n);
vector<Node> nodes(n);
for (int i = 0; i < n; ++i) nodes[i].idx = i;
vector<Node*> stack;
int mind = n;
while (right - left > 1) {
for (auto& node : nodes) node.left = node.right = nullptr;
stack.clear();
int mid = (left + right) / 2;
int start = (n - mid) % n;
for (int i = start; i < n + start; ++i) {
Node* left = nullptr;
while (!stack.empty() && a[stack.back()->idx] > a[i % n]) {
left = stack.back();
stack.pop_back();
}
if (!stack.empty()) stack.back()->right = &nodes[i % n];
if (right) nodes[i % n].left = left;
stack.push_back(&nodes[i % n]);
}
Node* root = stack.front();
auto ldepth = depth(root->left);
auto rdepth = depth(root->right);
mind = min(mind, max(ldepth, rdepth) + 1);
if (ldepth == rdepth) {
cout << (ldepth + 1) << ' ' << ((n - mid - orig_shift + n) % n) << '\n';
return 0;
} else if (ldepth > rdepth) {
right = mid;
} else {
left = mid;
}
}
cout << mind << ' ' << ((n - left - orig_shift + n) % n) << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 2;
int dep_tree[MAXN * 4];
int add_down[MAXN * 4];
void push(int v) {
dep_tree[v] += add_down[v];
if (v * 2 < MAXN * 4) {
add_down[v * 2] += add_down[v];
add_down[v * 2 + 1] += add_down[v];
}
add_down[v] = 0;
}
void add_val(int v, int l, int r, int ql, int qr, int val) {
if (l >= qr || r <= ql) return;
push(v);
if (ql <= l && qr >= r) {
add_down[v] += val;
push(v);
return;
}
int m = (l + r) / 2;
add_val(v * 2, l, m, ql, qr, val);
add_val(v * 2 + 1, m, r, ql, qr, val);
dep_tree[v] = max(dep_tree[v * 2], dep_tree[v * 2 + 1]);
}
int get_max(int v, int l, int r, int ql, int qr) {
if (l >= qr || r <= ql) {
return 0;
}
push(v);
if (ql <= l && qr >= r) {
return dep_tree[v];
}
int m = (l + r) / 2;
auto left = get_max(v * 2, l, m, ql, qr);
auto right = get_max(v * 2 + 1, m, r, ql, qr);
return max(left, right);
}
struct node {
int prior, ind;
node *left = nullptr;
node *right = nullptr;
node *par = nullptr;
node(int prior, int ind) {
this->prior = prior;
this->ind = ind;
}
int get_dep() { return get_max(1, 0, MAXN, this->ind, this->ind + 1); }
};
void set_right(node *par, node *ch) {
if (par) par->right = ch;
if (ch) ch->par = par;
}
void set_left(node *par, node *ch) {
if (par) par->left = ch;
if (ch) ch->par = par;
}
node *add_back(node *n, node *root, node *new_node, int start) {
if (!n) return new_node;
if (n->prior < new_node->prior) {
set_right(n, new_node);
int dep = n->get_dep() + 1;
add_val(1, 0, MAXN, new_node->ind, new_node->ind + 1, dep);
return root;
}
while (n->par && n->par->prior > new_node->prior) n = n->par;
int from = start;
if (!n->par) {
root = new_node;
} else {
set_right(n->par, new_node);
int dep = n->get_dep();
add_val(1, 0, MAXN, new_node->ind, new_node->ind + 1, dep);
from = n->par->ind + 1;
}
set_left(new_node, n);
add_val(1, 0, MAXN, from, new_node->ind, 1);
return root;
}
node *remove_front(node *n, node *root, int fin) {
if (n == root) {
add_val(1, 0, MAXN, 0, fin, -1);
n->right->par = nullptr;
return n->right;
}
set_left(n->par, n->right);
add_val(1, 0, MAXN, n->ind, n->par->ind, -1);
return root;
}
int main() {
ios::sync_with_stdio(false);
cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<node *> nodes(n);
node *root = nullptr, *last = nullptr;
for (int i = 0; i < n; i++) {
nodes[i] = new node(a[i], i);
root = add_back(last, root, nodes[i], 0);
last = nodes[i];
}
int min_dep = get_max(1, 0, MAXN, 0, n), shift = 0;
for (int i = 0; i < n - 1; i++) {
root = remove_front(nodes[i], root, n + i);
nodes[i]->ind = n + i;
nodes[i]->left = nodes[i]->right = nodes[i]->par = nullptr;
root = add_back(last, root, nodes[i], i + 1);
last = nodes[i];
int dep = get_max(1, 0, MAXN, i + 1, i + n + 1);
if (dep < min_dep) {
min_dep = dep;
shift = i + 1;
}
}
cout << min_dep + 1 << ' ' << shift << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g;
vector<int> in, out;
int TIME = 0;
const int N = 1 << 19;
long long A[2 * N];
long long getval(int l) {
l += N;
long long s = 0;
while (l) {
s += A[l];
l /= 2;
}
return s;
}
long long t[2 * N];
long long add[2 * N];
void update(int v, int tl, int tr, int l, int r, int a) {
if (l > r) return;
if (l == tl && tr == r) {
t[v] += a;
add[v] += a;
} else {
int tm = (tl + tr) / 2;
add[2 * v] += add[v];
add[2 * v + 1] += add[v];
t[2 * v] += add[v];
t[2 * v + 1] += add[v];
add[v] = 0;
update(v * 2, tl, tm, l, min(r, tm), a);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, a);
t[v] = max(t[2 * v], t[2 * v + 1]);
}
}
void addval(int l, int r, int val) {
l += N;
r += N;
while (l <= r) {
if (l & 1) {
A[l] += val;
++l;
}
if (!(r & 1)) {
A[r] += val;
--r;
}
if (l > r) break;
l /= 2;
r /= 2;
}
}
long long get_max(int v, int tl, int tr, int l, int r) {
if (l > r) return -1e9;
if (l == tl && tr == r) {
return t[v];
} else {
int tm = (tl + tr) / 2;
add[2 * v] += add[v];
add[2 * v + 1] += add[v];
t[2 * v] += add[v];
t[2 * v + 1] += add[v];
add[v] = 0;
return max(get_max(v * 2, tl, tm, l, min(r, tm)),
get_max(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
}
void dfs(int v) {
in[v] = TIME++;
for (int nv : g[v]) {
dfs(nv);
}
out[v] = TIME++;
}
vector<int> f(vector<int> a) {
int n = a.size();
vector<int> res(n);
g.assign(n, vector<int>());
in.resize(n);
out.resize(n);
vector<int> pos(n), pr(n);
for (int i = 0; i < n; ++i) {
pos[a[i]] = i;
}
for (int t = 0; t < 2; ++t) {
vector<int> q;
for (int j = 0; j < n; ++j) {
int i = t == 0 ? j : n - 1 - j;
int cand = -1;
while (!q.empty() && a[q.back()] > a[i]) {
cand = q.back();
q.pop_back();
}
if (cand != -1) {
g[i].push_back(cand);
pr[cand] = i;
}
q.push_back(i);
}
}
TIME = 0;
dfs(0);
vector<vector<int> > g1(n);
for (int i = 0; i < 2 * N; ++i) t[i] = -n - 1;
memset(A, 0, sizeof(A));
memset(add, 0, sizeof(add));
for (int i = 0; i < n; ++i) {
update(1, 0, N - 1, in[i], in[i],
getval(in[i]) - get_max(1, 0, N - 1, in[i], in[i]));
update(1, 0, N - 1, in[i], out[i], 1);
res[i] = get_max(1, 0, N - 1, 0, TIME + 1);
addval(in[i], out[i], 1);
}
return res;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
int s = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
--a[i];
if (a[i] == 0) s = i;
}
vector<int> l, r;
for (int i = 0; i < n; ++i) {
l.push_back(a[(s - i + n) % n]);
r.push_back(a[(s + i + n) % n]);
}
vector<int> hl = f(l);
vector<int> hr = f(r);
int mi = n + 1, best = 0;
for (int i = 0; i < n; ++i) {
int cand = max(hl[i], hr[n - 1 - i]);
if (cand < mi) {
mi = cand;
best = (s - i + n) % n;
}
}
cout << mi << ' ' << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e9;
const long long INFF = (long long)1e18;
const int MXN = (int)1e6 + 7;
const int mod = (int)1e9 + 7;
int a[MXN], b[MXN];
struct Seg {
int ll[MXN << 2], rr[MXN << 2];
pair<int, int> v[MXN << 2];
void bd(int l, int r, int p) {
ll[p] = l, rr[p] = r;
if (l == r) {
v[p] = {a[l], l};
return;
}
int mid = (l + r) >> 1;
bd(l, mid, p << 1);
bd(mid + 1, r, p << 1 | 1);
v[p] = min(v[p << 1], v[p << 1 | 1]);
}
pair<int, int> qy(int l, int r, int p) {
if (l > rr[p] || ll[p] > r) return {INF, 0};
if (l <= ll[p] && rr[p] <= r) return v[p];
return min(qy(l, r, p << 1), qy(l, r, p << 1 | 1));
}
} sg1;
struct Seg2 {
int ll[MXN << 2], rr[MXN << 2], v[MXN << 2], d[MXN << 2];
void bd(int l, int r, int p) {
ll[p] = l, rr[p] = r;
if (l == r) {
v[p] = b[l];
return;
}
int mid = (l + r) >> 1;
bd(l, mid, p << 1);
bd(mid + 1, r, p << 1 | 1);
v[p] = max(v[p << 1], v[p << 1 | 1]);
}
inline void pushdown(int p) {
d[p << 1] += d[p];
d[p << 1 | 1] += d[p];
v[p << 1] += d[p];
v[p << 1 | 1] += d[p];
d[p] = 0;
}
void md(int l, int r, int val, int p) {
if (l > rr[p] || ll[p] > r) return;
if (l <= ll[p] && rr[p] <= r) {
d[p] += val;
v[p] += val;
return;
}
pushdown(p);
md(l, r, val, p << 1);
md(l, r, val, p << 1 | 1);
v[p] = max(v[p << 1], v[p << 1 | 1]);
}
int qy(int l, int r, int p) {
if (l > rr[p] || ll[p] > r) return 0;
if (l <= ll[p] && rr[p] <= r) return v[p];
pushdown(p);
return max(qy(l, r, p << 1), qy(l, r, p << 1 | 1));
}
} sg;
int ans;
void go(int l, int r, int dep) {
if (l > r) return;
pair<int, int> res = sg1.qy(l, r, 1);
b[res.second] = dep;
go(l, res.second - 1, dep + 1);
go(res.second + 1, r, dep + 1);
ans = max(ans, dep);
}
int ll[MXN], rr[MXN];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", a + i);
for (int i = 1; i <= n; i++) a[n + i] = a[i];
deque<pair<int, int> > stk;
for (int i = 2 * n - 1; i > n; i--) {
pair<int, int> val = {a[i], i};
while (!stk.empty() && val < stk.back()) stk.pop_back();
stk.push_back(val);
}
for (int i = n; i >= 1; i--) {
int lb = 0, rb = ((int)(stk).size()) - 1, ok = -1;
while (lb <= rb) {
int mid = (lb + rb) >> 1;
if (stk[mid].first < a[i]) {
ok = mid;
lb = mid + 1;
} else {
rb = mid - 1;
}
}
if (ok == -1)
ll[i] = i + n - 1;
else
ll[i] = stk[ok].second - 1;
pair<int, int> val = {a[i], i};
while (!stk.empty() && val < stk.back()) stk.pop_back();
stk.push_back(val);
if (!stk.empty() && stk.front().second == i + n - 1) stk.pop_front();
}
stk.clear();
for (int i = 2; i <= n; i++) {
pair<int, int> val = {a[i], i};
while (!stk.empty() && val < stk.back()) stk.pop_back();
stk.push_back(val);
}
for (int i = n + 1; i <= 2 * n; i++) {
int lb = 0, rb = ((int)(stk).size()) - 1, ok = -1;
while (lb <= rb) {
int mid = (lb + rb) >> 1;
if (stk[mid].first < a[i]) {
ok = mid;
lb = mid + 1;
} else {
rb = mid - 1;
}
}
if (ok == -1)
rr[i] = i - n + 1;
else
rr[i] = stk[ok].second + 1;
pair<int, int> val = {a[i], i};
while (!stk.empty() && val < stk.back()) stk.pop_back();
stk.push_back(val);
if (!stk.empty() && stk.front().second == i - n + 1) stk.pop_front();
}
sg1.bd(1, n, 1);
go(1, n, 1);
sg.bd(1, 2 * n, 1);
int pos = 0;
for (int i = 1; i < n; i++) {
sg.md(i + 1, ll[i], -1, 1);
int h = 0;
if (rr[i + n] != i + 1) h = sg.qy(rr[i + n] - 1, rr[i + n] - 1, 1);
sg.md(rr[i + n], i + n - 1, 1, 1);
sg.md(i + n, i + n, h + 1, 1);
int res = sg.qy(i + 1, i + n, 1);
if (res < ans) {
ans = res;
pos = i;
}
}
printf("%d %d\n", ans, pos);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], f[200005], g[200005];
int st[200005], dp[200005], tp;
int main() {
scanf("%d", &n);
int nw = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) nw = i;
}
int nans = 0;
tp = 0;
for (int i = nw, j = 1; j <= n; i = i % n + 1, j++) {
while (tp && a[st[tp]] > a[i]) {
dp[st[tp - 1]] = max(dp[st[tp - 1]], dp[st[tp]] + 1);
dp[i] = max(dp[i], dp[st[tp]] + 1);
tp--;
}
nans = max(nans, dp[i] + tp);
st[++tp] = i;
f[j] = nans;
}
tp = nans = 0;
for (int i = nw, j = 1; j <= n; i = (i == 1 ? n : (i + n - 1) % n), j++) {
dp[i] = 0;
while (tp && a[st[tp]] > a[i]) {
dp[st[tp - 1]] = max(dp[st[tp - 1]], dp[st[tp]] + 1);
dp[i] = max(dp[i], dp[st[tp]] + 1);
tp--;
}
nans = max(nans, dp[i] + tp);
st[++tp] = i;
g[j] = nans;
}
int ans = 1e9, id = 0;
for (int i = 1, j = n; i <= n; i++, j--) {
if (max(f[i], g[j]) < ans) {
ans = max(f[i], g[j]);
id = i;
}
}
id = (id + nw - 1) % n;
printf("%d %d\n", ans + 1, id);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[400069], lg2[400069], dh[400069], cdh = 1, inf = 1e18;
pair<long long, long long> sp[19][400069];
struct segtree {
long long l, r, mx, lz = 0;
segtree *p[2];
void bd(long long lh, long long rh) {
l = lh;
r = rh;
if (l == r) {
mx = dh[l];
} else {
long long ii, md = (l + r) / 2;
mx = -inf;
for (ii = 0; ii < 2; ii++) {
p[ii] = new segtree;
p[ii]->bd(!ii ? l : md + 1, !ii ? md : r);
mx = max(mx, p[ii]->mx);
}
}
}
void blc() {
long long ii;
for (ii = 0; ii < 2; ii++) {
p[ii]->mx += lz;
p[ii]->lz += lz;
}
lz = 0;
}
void ud(long long lh, long long rh, long long w) {
if (l > rh || r < lh)
;
else if (l >= lh && r <= rh) {
mx += w;
lz += w;
} else {
long long ii;
blc();
mx = -inf;
for (ii = 0; ii < 2; ii++) {
p[ii]->ud(lh, rh, w);
mx = max(mx, p[ii]->mx);
}
}
}
long long qr(long long lh, long long rh) {
if (l > rh || r < lh) {
return -inf;
} else if (l >= lh && r <= rh) {
return mx;
} else {
blc();
return max(p[0]->qr(lh, rh), p[1]->qr(lh, rh));
}
}
} sg;
long long qr(long long lh, long long rh) {
long long e = lg2[rh - lh + 1];
pair<long long, long long> tmp = min(sp[e][lh], sp[e][rh - (1ll << e) + 1]);
return tmp.second;
}
void bd(long long lh, long long rh) {
if (lh > rh) {
return;
}
long long p = qr(lh, rh);
dh[p] = cdh;
cdh++;
bd(lh, p - 1);
bd(p + 1, rh);
cdh--;
}
int main() {
long long i, j, k, lh, rh, md, zz;
pair<long long, long long> z = {inf, -1};
scanf("%lld", &n);
for (i = 1; i <= n * 2; i++) {
for (k = i; k > 1; k /= 2, lg2[i]++)
;
}
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
for (i = n + 1; i <= n * 2; i++) {
a[i] = a[i - n];
}
for (i = 0; i < 19; i++) {
for (j = 1; j <= n * 2 - (1ll << i) + 1; j++) {
if (!i) {
sp[i][j] = {a[j], j};
} else {
sp[i][j] = min(sp[i - 1][j], sp[i - 1][j + (1ll << i - 1)]);
}
}
}
bd(1, n);
sg.bd(1, n * 2);
for (i = 0; i < n;) {
z = min(z, {sg.mx, i});
for (lh = i + 1, rh = i + n; lh <= rh;) {
md = (lh + rh) / 2;
if (a[qr(i + 1, md)] >= a[i + 1]) {
zz = md;
lh = md + 1;
} else {
rh = md - 1;
}
}
sg.ud(i + 1, zz, -1);
sg.ud(i + 1, i + 1, -sg.qr(i + 1, i + 1));
i++;
for (lh = i + 1, rh = i + n; lh <= rh;) {
md = (lh + rh) / 2;
if (a[qr(md, i + n)] >= a[i + n]) {
zz = md;
rh = md - 1;
} else {
lh = md + 1;
}
}
sg.ud(i + n, i + n, sg.qr(zz - 1, zz - 1));
sg.ud(zz, i + n, 1);
}
printf("%lld %lld\n", z.first, z.second);
}
|
#include <bits/stdc++.h>
int se[4000001], mn[4000001], lazy[4000001];
int n, dfn[400001], p[400001], val[400001], top, stack[400001], lson[400001],
rson[400001], now;
int mx[400001];
void dfs(int x, int f) {
if (!x) return;
dfn[x] = ++now;
dfs(lson[x], x);
dfs(rson[x], x);
mx[x] = now;
}
void spread(int x) {
mn[x] += lazy[x];
lazy[x << 1] += lazy[x];
lazy[x << 1 | 1] += lazy[x];
lazy[x] = 0;
}
void update(int root, int l, int r, int el, int er, int x) {
spread(root);
if (el > r || er < l) return;
if (el <= l && er >= r) {
lazy[root] += x;
spread(root);
return;
}
spread(root);
update(root << 1, l, (l + r) >> 1, el, er, x);
update(root << 1 | 1, ((l + r) >> 1) + 1, r, el, er, x);
mn[root] = std::max(mn[root << 1], mn[root << 1 | 1]);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", p + i);
for (int i = 1; i <= n << 1; i++) {
val[i] = p[(i > n) ? (i - n) : i];
while (top && val[i] <= val[stack[top]]) {
lson[i] = stack[top];
top--;
}
if (top) rson[stack[top]] = i;
stack[++top] = i;
}
dfs(stack[1], 0);
for (int i = 1; i <= n; i++) update(1, 1, n << 1, dfn[i], mx[i], 1);
int ans = n + 1, p = 0;
for (int i = n + 1; i <= n << 1; i++) {
if (ans > mn[1]) ans = mn[1], p = i - n - 1;
update(1, 1, n << 1, dfn[i - n], mx[i - n], -1);
update(1, 1, n << 1, dfn[i], mx[i], 1);
}
printf("%d %d\n", ans, p);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
int n, m, a[N], tl[N], tr[N], dep[N], stk[N];
inline int add(int v) {
int d = 1;
while (m > 0 && stk[m - 1] > v) {
m--;
d = max(d, dep[m] + 1);
}
d = max(d, m + 1);
dep[m] = d;
stk[m++] = v;
return d;
}
int main() {
scanf("%d", &n);
int p1 = -1, mn = n + 1, ps = -1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) p1 = i;
}
rotate(a, a + p1, a + n);
m = 0;
for (int i = 1; i < n; i++) tr[i] = max(tr[i - 1], add(a[i]));
m = 0;
for (int i = n - 1; i >= 0; i--) tl[n - i] = max(tl[n - i - 1], add(a[i]));
for (int i = 0; i < n; i++)
if (max(tl[i], tr[n - 1 - i]) < mn) {
mn = max(tl[i], tr[n - 1 - i]);
ps = i;
}
printf("%d %d\n", mn + 1, (p1 - ps + n) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int arr = 2e5 + 10;
const int ar = 2e3 + 10;
const long double pi = acos(-1);
const long double eps = 1e-10;
const long long md = 1e9 + 7;
int a[2 * arr];
int t[8 * arr];
int push[8 * arr];
void make_push(int v) {
t[v * 2] += push[v];
t[v * 2 + 1] += push[v];
push[v * 2] += push[v];
push[v * 2 + 1] += push[v];
push[v] = 0;
}
void upd(int v, int l, int r, int tl, int tr, int val) {
if (l > tr || r < tl) {
return;
}
if (l >= tl && r <= tr) {
t[v] += val;
push[v] += val;
return;
}
make_push(v);
int m = (l + r) / 2;
upd(v * 2, l, m, tl, tr, val);
upd(v * 2 + 1, m + 1, r, tl, tr, val);
t[v] = max(t[v * 2], t[v * 2 + 1]);
}
void upd(int tl, int tr, int val) {
if (tl > tr) {
return;
}
upd(1, 1, 2 * arr, tl, tr, val);
}
int get(int v, int l, int r, int tl, int tr) {
if (l > tr || r < tl) {
return -1e9;
}
if (l >= tl && r <= tr) {
return t[v];
}
make_push(v);
int m = (l + r) / 2;
return max(get(v * 2, l, m, tl, tr), get(v * 2 + 1, m + 1, r, tl, tr));
}
int first_left[2 * arr];
int first_right[2 * arr];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = n + 1; i <= 2 * n; i++) {
a[i] = a[i - n];
}
if (1) {
deque<pair<int, int> > s;
s.push_back(make_pair(-1e9, 0));
for (int i = 1; i <= 2 * n; i++) {
while (s.back().first > a[i]) {
s.pop_back();
}
first_left[i] = s.back().second;
s.push_back(make_pair(a[i], i));
}
}
if (1) {
deque<pair<int, int> > s;
s.push_back(make_pair(-1e9, 2 * n + 1));
for (int i = 2 * n; i >= 1; i--) {
while (s.back().first > a[i]) {
s.pop_back();
}
first_right[i] = s.back().second;
s.push_back(make_pair(a[i], i));
}
}
pair<int, int> ans = make_pair(1e9, -1);
auto process = [&](int pos, int val) {
upd(first_left[pos] + 1, pos - 1, val);
upd(pos + 1, first_right[pos] - 1, val);
};
for (int i = 1; i <= n; i++) {
process(i, +1);
}
for (int i = 1, cyc = 0; i <= n; i++, cyc++) {
ans = min(ans, make_pair(get(1, 1, 2 * arr, i, i + n - 1), cyc));
process(i, -1);
process(i + n, +1);
}
cout << ans.first + 1 << " " << ans.second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 7;
int n;
int tmp[N];
int a[N], val[N], sta[N];
int dpl[N], dpr[N];
void init(int n, int *dp) {
int top = 0;
int mx = 0;
for (int i = 1; i <= n; i++) {
int ma = 0;
while (top && a[sta[top]] > a[i]) {
ma = max(ma, val[top]);
top--;
}
sta[++top] = i;
if (ma == 0)
val[top] = top;
else
val[top] = ma + 1;
mx = max(mx, val[top]);
dp[i] = mx;
}
}
int main() {
scanf("%d", &n);
if (n == 1) {
printf("%d %d\n", 1, 0);
return 0;
}
int mi = 1e9, rt;
for (int i = 1; i <= n; i++) {
scanf("%d", &tmp[i]);
if (tmp[i] < mi) mi = tmp[i], rt = i;
}
for (int i = 1, j = rt - 1; i < n; i++, j--) {
if (j < 1) j += n;
a[i] = tmp[j];
}
init(n - 1, dpl);
for (int i = 1, j = rt + 1; i < n; i++, j++) {
if (j > n) j -= n;
a[i] = tmp[j];
}
init(n - 1, dpr);
int ans = 1e9, shft;
for (int i = 0; i < n; i++) {
if (ans > max(dpl[i], dpr[n - 1 - i]) + 1) {
ans = max(dpl[i], dpr[n - 1 - i]) + 1;
shft = rt - (i + 1);
}
}
if (shft < 0) shft += n;
printf("%d %d\n", ans, shft);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200009;
const long long MOD = 998244353;
const int LOGN = 22;
class {
public:
int n, a[MAXN * 3], Max[MAXN * 3], son[MAXN * 3];
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
int pos = 0;
for (int i = 1; i <= n; ++i) {
a[i + n] = a[i];
a[i + n + n] = a[i];
if (a[i] == 1) pos = i + n;
}
stack<int> Q;
Q.push(pos);
Max[pos] = 1;
for (int i = pos - 1; i > pos - n; --i) {
son[i] = 1;
while (a[Q.top()] > a[i]) {
son[i] = max(++son[i], son[Q.top()] + 1);
Q.pop();
}
Max[i] = max(Max[i + 1], (int)Q.size() + son[i]);
Q.push(i);
}
while (!Q.empty()) Q.pop();
Q.push(pos);
for (int i = pos + 1; i < pos + n; ++i) {
son[i] = 1;
while (a[Q.top()] > a[i]) {
son[i] = max(++son[i], son[Q.top()] + 1);
Q.pop();
}
Max[i] = max(Max[i - 1], (int)Q.size() + son[i]);
Q.push(i);
}
int ans = n + n, P;
for (int i = 0; i < n; ++i) {
if (ans > max(Max[pos + i], Max[pos + i - n + 1])) {
ans = max(Max[pos + i], Max[pos + i - n + 1]);
P = i;
}
}
P -= 2 * n - pos;
if (P < 0) P += n;
cout << ans << " " << P << endl;
}
} NSPACE;
int main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
NSPACE.solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p[400005], onepos, depth[200005];
struct vnode {
int second, e, m;
pair<int, int> v;
vnode *l, *r;
vnode(int S, int E) {
second = S, e = E, m = (second + e) / 2;
if (second == e)
v = pair<int, int>(p[second], second);
else {
l = new vnode(second, m);
r = new vnode(m + 1, e);
v = min(l->v, r->v);
}
}
pair<int, int> query(int x, int y) {
if (second == x and e == y)
return v;
else if (y <= m)
return l->query(x, y);
else if (x > m)
return r->query(x, y);
else
return min(l->query(x, m), r->query(m + 1, y));
}
} * vseg;
void dfs(int x, int y, int d) {
if (x > y) return;
pair<int, int> m = vseg->query(x, y);
depth[m.first] = d;
dfs(x, m.second - 1, d + 1);
dfs(m.second + 1, y, d + 1);
}
struct node {
int second, e, m, v, mv, add;
node *l, *r;
node(int S, int E) {
second = S, e = E, m = (second + e) / 2, v = 0, mv = 0, add = 0;
if (second == e) {
if (second <= n) v = mv = depth[p[second]];
} else {
l = new node(second, m);
r = new node(m + 1, e);
v = min(l->v, r->v);
mv = max(l->mv, r->mv);
}
}
pair<int, int> value() {
v += add;
mv += add;
if (second != e) {
l->add += add;
r->add += add;
}
add = 0;
return pair<int, int>(v, mv);
}
void up(int x, int y, int nv) {
if (second == x and e == y) {
add += nv;
return;
} else if (y <= m)
l->up(x, y, nv);
else if (x > m)
r->up(x, y, nv);
else
l->up(x, m, nv), r->up(m + 1, y, nv);
v = min(l->value().first, r->value().first);
mv = max(l->value().second, r->value().second);
}
int query(int x, int y, bool small) {
value();
if (second == x and e == y)
return (small ? v : mv);
else if (y <= m)
return l->query(x, y, small);
else if (x > m)
return r->query(x, y, small);
else {
int le = l->query(x, m, small), ri = r->query(m + 1, y, small);
return (small ? min(le, ri) : max(le, ri));
}
}
} * seg;
int main() {
cin >> n;
for (int i = (int)1; i <= (int)n; i++) {
cin >> p[i];
if (p[i] == 1) onepos = i;
}
rotate(p + 1, p + onepos + 1, p + n + 1);
for (int i = (int)1; i <= (int)n; i++) p[n + i] = p[i];
vseg = new vnode(1, 2 * n);
dfs(1, n, 1);
seg = new node(1, 2 * n);
pair<int, int> ans = pair<int, int>(seg->query(1, n, 0), onepos);
for (int i = (int)0; i <= (int)n - 2; i++) {
int x = p[i + 1];
int lower = i + 1, upper = n + i;
while (upper - lower > 1) {
int mid = (lower + upper) / 2;
pair<int, int> val = vseg->query(lower + 1, mid);
if (val.first < x)
upper = val.second;
else
lower = mid;
}
seg->up(i + 1, upper - 1, -1);
lower = i + 1, upper = n + i + 1;
while (upper - lower > 1) {
int mid = (upper + lower) / 2;
pair<int, int> val = vseg->query(mid, upper - 1);
if (val.first < x)
lower = val.second;
else
upper = mid;
}
seg->up(i + n + 1, i + n + 1, seg->query(lower, lower, 1));
seg->up(lower + 1, i + n + 1, 1);
ans = min(ans,
pair<int, int>(seg->query(i + 2, i + n + 1, 0), i + onepos + 1));
}
cout << ans.first << " " << ans.second % n;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, a[N], b[N], st[N][20];
int RMQ(int l, int r) {
int k = log2(r - l + 1);
if (b[st[l][k]] < b[st[r - (1 << k) + 1][k]])
return st[l][k];
else
return st[r - (1 << k) + 1][k];
}
int calcheight(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
int mid = RMQ(l, r);
return max(calcheight(l, mid - 1), calcheight(mid + 1, r)) + 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
int pos1 = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
if (a[i] == 1) pos1 = i;
}
for (int i = pos1 + 1; i <= n; ++i) b[i - pos1] = a[i];
for (int i = 1; i < pos1; ++i) b[n - pos1 + i] = a[i];
n--;
for (int i = 1; i <= n; ++i) st[i][0] = i;
for (int k = 1; (1 << k) <= n; ++k) {
for (int i = 1; i + (1 << k) - 1 <= n; ++i) {
if (b[st[i][k - 1]] < b[st[i + (1 << (k - 1))][k - 1]])
st[i][k] = st[i][k - 1];
else
st[i][k] = st[i + (1 << (k - 1))][k - 1];
}
}
int l = 1, r = n, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (calcheight(1, mid) <= calcheight(mid + 1, n)) {
ans = mid;
l = mid + 1;
} else {
r = mid - 1;
}
}
int h1 = max(calcheight(1, ans), calcheight(ans + 1, n)) + 1;
int h2 = max(calcheight(1, ans + 1), calcheight(ans + 2, n)) + 1;
if (h1 <= h2) {
cout << h1 << " " << (pos1 + ans) % (n + 1);
} else {
cout << h2 << " " << (pos1 + ans + 1) % (n + 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long bip(long long x, long long n, long long mod) {
long long res = 1;
while (n) {
if (n & 1) {
res = (res * x) % mod;
}
x = (x * x) % mod;
n >>= 1;
}
return res;
}
const int ppr = 257;
const long long INF = 2e18;
const int inf = 2e9;
const int mod = 1e9 + 7;
const int N = 1e6 + 123;
const long double pi = 3.1741592653589793238462643;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int n, a[N], l[N], r[N], cnt[N], t[N], add[N];
stack<int> st;
void aza(int v, int tl, int tr) {
if (tl == tr) {
t[v] = cnt[tl];
return;
}
int tm = (tl + tr) >> 1;
aza(v << 1, tl, tm);
aza(v << 1 | 1, tm + 1, tr);
t[v] = max(t[v << 1], t[v << 1 | 1]);
}
inline void push(int v) {
if (add[v]) {
t[v << 1] += add[v];
t[v << 1 | 1] += add[v];
add[v << 1] += add[v];
add[v << 1 | 1] += add[v];
add[v] = 0;
}
}
int get(int v, int tl, int tr, int l, int r) {
if (l > r) return -inf;
if (tl == l && tr == r) return t[v];
push(v);
int tm = (tl + tr) >> 1;
return max(get(v << 1, tl, tm, l, min(tm, r)),
get(v << 1 | 1, tm + 1, tr, max(tm + 1, l), r));
}
void upd(int v, int tl, int tr, int l, int r, int val) {
if (l > r) return;
if (tl == l && tr == r) {
t[v] += val;
add[v] += val;
return;
}
push(v);
int tm = (tl + tr) >> 1;
upd(v << 1, tl, tm, l, min(tm, r), val);
upd(v << 1 | 1, tm + 1, tr, max(tm + 1, l), r, val);
t[v] = max(t[v << 1], t[v << 1 | 1]);
}
void upda(int v, int tl, int tr, int pos, int val) {
if (tl == tr) {
t[v] = val;
return;
}
push(v);
int tm = (tl + tr) >> 1;
if (pos <= tm)
upda(v << 1, tl, tm, pos, val);
else
upda(v << 1 | 1, tm + 1, tr, pos, val);
t[v] = max(t[v << 1], t[v << 1 | 1]);
}
int get_pos(int v, int tl, int tr, int pos) {
if (tl == tr) return t[v];
push(v);
int tm = (tl + tr) >> 1;
if (pos <= tm)
return get_pos(v << 1, tl, tm, pos);
else
return get_pos(v << 1 | 1, tm + 1, tr, pos);
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[i + n] = a[i];
for (int i = 1; i <= n + n; i++) {
r[i] = n + n + 1;
l[i] = i;
}
for (int i = n; i >= 1; i--) {
while (!st.empty() && a[i] < a[st.top()]) st.pop();
st.push(i);
cnt[i] += st.size();
}
while (!st.empty()) st.pop();
for (int i = n + n; i >= 1; i--) {
while (!st.empty() && a[i] < a[st.top()]) st.pop();
if (!st.empty()) r[i] = st.top();
st.push(i);
}
while (!st.empty()) st.pop();
for (int i = 1; i <= n; i++) {
while (!st.empty() && a[i] < a[st.top()]) st.pop();
if (!st.empty()) l[i] = st.top();
st.push(i);
cnt[i] += st.size();
}
while (!st.empty()) st.pop();
for (int i = 1; i <= n + n; i++) {
while (!st.empty() && a[st.top()] > a[i]) st.pop();
if (!st.empty()) l[i] = st.top();
st.push(i);
}
for (int i = 1; i <= n; i++) cnt[i]--;
aza(1, 1, n + n);
int mn = +inf, mx;
for (int i = n + 1; i <= n + n; i++) {
int L = i - n;
int R = i - 1;
int x = get(1, 1, n + n, L, R);
if (mn > x) {
mn = x;
mx = i - n - 1;
}
if (a[i] == 1) {
upda(1, 1, n + n, i, 1);
continue;
}
upd(1, 1, n + n, i - n, r[i - n] - 1, -1);
upd(1, 1, n + n, l[i] + 1, i - 1, +1);
int y = get_pos(1, 1, n + n, l[i]);
upda(1, 1, n + n, i, y + 1);
}
cout << mn << ' ' << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class SegTree {
public:
SegTree(int _n) : n(_n) {
x = vector<int>(_n * 4);
y = vector<int>(_n * 4);
}
void PushDown(int t, int l, int r) {
if (l == r) return;
if (y[t] == 0) return;
x[t + t] += y[t];
y[t + t] += y[t];
x[t + t + 1] += y[t];
y[t + t + 1] += y[t];
y[t] = 0;
}
void Insert(int t, int a, int l, int r, int p, int q) {
PushDown(t, l, r);
if (p <= l && r <= q) {
x[t] += a;
y[t] += a;
return;
}
int mid = (l + r) >> 1;
if (p <= mid) Insert(t + t, a, l, mid, p, q);
if (mid + 1 <= q) Insert(t + t + 1, a, mid + 1, r, p, q);
x[t] = max(x[t + t], x[t + t + 1]);
}
int Query(int t, int l, int r, int p, int q) {
PushDown(t, l, r);
if (p <= l && r <= q) return x[t];
int mid = (l + r) >> 1;
int ans = 0;
if (p <= mid) ans = max(ans, Query(t + t, l, mid, p, q));
if (mid + 1 <= q) ans = max(ans, Query(t + t + 1, mid + 1, r, p, q));
return ans;
}
int n;
vector<int> x, y;
};
int Find(deque<pair<int, int>>& q, int v) {
if (q.back().first < v) return q.back().second;
int L = 0, R = q.size() - 1;
while (L + 1 < R) {
int mid = (L + R) >> 1;
if (q[mid].first < v)
L = mid;
else
R = mid;
}
return q[L].second;
}
const int MAXN = 200010;
vector<pair<int, int>> rp[MAXN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> ox(n);
for (int i = 0; i < n; ++i) cin >> ox[i];
vector<int> x{0};
for (int i = 0; i < n; ++i) {
if (ox[i] != 1) continue;
for (int j = i + 1; j < n; ++j) x.push_back(ox[j]);
for (int j = 0; j <= i; ++j) x.push_back(ox[j]);
break;
}
deque<pair<int, int>> fq, bq;
for (int i = 1; i <= n; ++i) {
while (!fq.empty() && fq.back().first > x[i]) {
fq.pop_back();
}
fq.push_back({x[i], i});
}
for (int i = n; i >= 1; --i) {
while (!bq.empty() && bq.back().first > x[i]) {
rp[i].push_back(bq.back());
bq.pop_back();
}
reverse(rp[i].begin(), rp[i].end());
bq.push_back({x[i], i});
}
SegTree tree(n + n);
vector<int> p(n + 1);
for (int i = 1; i <= n; ++i) {
p[x[i]] = i;
}
set<int> s;
s.insert(0);
s.insert(n + 1);
for (int i = 1; i <= n; ++i) {
auto ib = s.lower_bound(p[i]);
auto ia = ib;
--ia;
tree.Insert(1, 1, 1, n + n, *ia + 1, *ib - 1);
s.insert(p[i]);
}
int ans = tree.Query(1, 1, n + n, 1, n), ansp = x[1];
for (int i = 1; i < n; ++i) {
int p = Find(bq, x[i]);
tree.Insert(1, -1, 1, n + n, i + 1, p - 1);
if (bq.back().second == i) bq.pop_back();
for (auto j : rp[i]) bq.push_back(j);
while (!fq.empty() && fq.back().first > x[i]) {
fq.pop_back();
}
fq.push_back({x[i], n + i});
int q = Find(fq, x[i]);
int dep = tree.Query(1, 1, n + n, q, q);
tree.Insert(1, 1, 1, n + n, q + 1, n + i - 1);
tree.Insert(1, dep + 1, 1, n + n, n + i, n + i);
int temp = tree.Query(1, 1, n + n, i + 1, n + i);
if (temp < ans) {
ans = temp;
ansp = x[i + 1];
}
}
cout << ans << " ";
for (int i = 0; i < n; ++i) {
if (ox[i] == ansp) {
cout << i << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ST {
int l, r;
int lazy = 0;
int mx = 0;
ST *left, *right;
ST(int l, int r) : l(l), r(r) {
if (l < r) {
left = new ST(l, (l + r) / 2);
right = new ST((l + r) / 2 + 1, r);
}
}
void fix() {
mx += lazy;
if (l < r) {
left->lazy += lazy;
right->lazy += lazy;
}
lazy = 0;
}
void set(int i, int w) {
fix();
if (l < r) {
if (i <= (l + r) / 2)
left->set(i, w);
else
right->set(i, w);
mx = max(left->mx, right->mx);
} else {
mx = w;
}
}
void add(int x, int y, int w) {
fix();
if (x <= l && r <= y) {
lazy += w;
return fix();
}
if (r < x || y < l) return;
left->add(x, y, w);
right->add(x, y, w);
mx = max(left->mx, right->mx);
}
int get(int i) {
fix();
if (l < r) {
if (i <= (l + r) / 2)
return left->get(i);
else
return right->get(i);
} else {
return mx;
}
}
} medis(0, 201010);
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
int p[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i]--;
p[a[i]] = i;
}
int ne[n];
int pr[n];
pr[0] = p[0];
ne[0] = p[0];
set<int> V;
int g[n];
g[0] = 0;
for (int i = 0; i < n; i++) {
int id = p[i];
if (i != 0) {
auto it = V.lower_bound(id);
if (it == V.end()) it = V.begin();
ne[i] = *it;
if (it != V.begin()) {
it--;
} else
it = --V.end();
pr[i] = *it;
g[i] = g[a[pr[i]]] + 1;
}
V.insert(id);
}
pair<int, int> ans = {1e6, 1e6};
for (int i = 0; i < n; i++) {
int l = (pr[a[i]] + 1) % n;
int r = (ne[a[i]] + n - 1) % n;
if (a[i] == 0) {
l = 0;
r = n - 1;
}
if (l > i) l = 0;
if (r < i) r = n - 1;
medis.add(l, r, 1);
medis.add(i, i, -1);
}
medis.fix();
ans = min(ans, {medis.mx, 0});
deque<int> b;
for (int i = 0; i < n; i++) b.push_back(a[i]);
for (int k = 1; k < n; k++) {
b.push_back(b.front());
b.pop_front();
int v = a[k - 1];
if (v != 0) {
int j = ne[v];
int i = p[v];
assert(i == k - 1);
if (i <= j) {
medis.add(i + 1, j - 1, -1);
} else {
medis.add(i + 1, n - 1, -1);
medis.add(0, j - 1, -1);
}
j = pr[v];
if (j <= i) {
medis.add(j + 1, i - 1, 1);
} else {
medis.add(j + 1, n - 1, 1);
medis.add(0, i - 1, 1);
}
medis.set(i, g[v]);
}
ans = min(ans, {medis.mx + medis.lazy, k});
}
cout << ans.first + 1 << " " << ans.second << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200500;
int n;
int shift;
int arr[2 * MAXN];
int tmp[2 * MAXN];
pair<int, int> tree[8 * MAXN];
pair<int, int> get_min(int v, int tl, int tr, int l, int r) {
if (tr == r && tl == l) {
return tree[v];
}
int tm = (tl + tr) / 2;
if (r <= tm) {
return get_min(2 * v, tl, tm, l, r);
}
if (tm <= l) {
return get_min(2 * v + 1, tm, tr, l, r);
}
return min(get_min(2 * v, tl, tm, l, tm), get_min(2 * v + 1, tm, tr, tm, r));
}
void build(int v, int tl, int tr) {
if (tr - tl == 1) {
tree[v] = make_pair(arr[tl], tl);
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm, tr);
tree[v] = min(tree[2 * v], tree[2 * v + 1]);
}
int get_ans(int l, int r) {
if (r - l == 0) {
return 0;
}
if (r - l == 1) {
return 1;
}
auto cur = get_min(1, 0, 2 * n, l, r);
int ind = cur.second;
return max(get_ans(l, ind), get_ans(ind + 1, r)) + 1;
}
int check(int sh) { return get_ans(sh, n + sh); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", tmp + i);
if (tmp[i] == 1) {
shift = i;
}
}
for (int i = 0; i < n; i++) {
arr[i] = tmp[(n + i - shift) % n];
}
for (int i = 0; i < n; i++) {
arr[i + n] = arr[i];
}
build(1, 0, 2 * n);
int bl = -1;
int br = n;
int lans = 2 * n;
int rans = 2 * n;
while ((br - bl) > 3) {
int m1 = bl + (br - bl) / 3;
int m2 = bl + 2 * (br - bl) / 3;
int m1ans = check(m1);
int m2ans = check(m2);
if (m1ans > m2ans) {
lans = m1ans;
bl = m1;
} else {
rans = m2ans;
br = m2;
}
}
int sol = 2 * n;
int sh = -1;
for (int i = bl + 1; i < br; i++) {
int cur = check(i);
if (cur < sol) {
sh = i;
sol = cur;
}
}
printf("%d %d\n", sol, (sh - shift + n) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400003, maxlog = 20;
int n, a[maxn], temp[maxn], st[maxn][maxlog], lg[maxn];
bool cmp(int x, int y) { return a[x] < a[y]; }
void initst() {
for (int i = 2; i <= (n << 1); i++) lg[i] = lg[i >> 1] + 1;
for (int i = 0; i < (n << 1); i++) st[i][0] = i;
for (int len = 1; (1 << len) <= (n << 1); len++) {
for (int i = 0; i + (1 << len) - 1 < (n << 1); i++) {
st[i][len] = min(st[i][len - 1], st[i + (1 << (len - 1))][len - 1], cmp);
}
}
}
int query(int l, int r) {
int tmp = lg[r - l + 1];
return min(st[l][tmp], st[r - (1 << tmp) + 1][tmp], cmp);
}
int build(int l, int r) {
if (l > r) return 0;
int mid = query(l, r);
return max(build(l, mid - 1), build(mid + 1, r)) + 1;
}
bool check(int x) {
int mid = query(x, x + n - 1);
return build(x, mid - 1) <= build(mid + 1, x + n - 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int d = min_element(a, a + n) - a;
for (int i = 0; i < n; i++) temp[i] = a[(i + d + 1) % n];
copy(temp, temp + n, a);
copy(a, a + n, a + n);
initst();
int l = 0, r = n - 1, mid, L = -1;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
L = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d %d\n", build(L, L + n - 1), (L + d + 1) % n);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops, no-stack-protector")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const long long maxn = 2e5 + 10;
const long long mod = 1e9 + 7;
const long long base = 4e18;
long long a[maxn];
long long b[maxn];
pair<long long, long long> st[4 * maxn];
long long n;
pair<long long, long long> mer(pair<long long, long long> a,
pair<long long, long long> b) {
if (a.first < b.first) return a;
return b;
}
void build(long long id, long long left, long long right) {
if (left == right) {
st[id] = make_pair(b[left], left);
return;
}
long long mid = (left + right) / 2;
build(id * 2, left, mid);
build(id * 2 + 1, mid + 1, right);
st[id] = mer(st[id * 2], st[id * 2 + 1]);
}
pair<long long, long long> get(long long id, long long left, long long right,
long long x, long long y) {
if (x > right || y < left) return make_pair(base, 0);
if (x <= left && y >= right) return st[id];
long long mid = (left + right) / 2;
return mer(get(id * 2, left, mid, x, y),
get(id * 2 + 1, mid + 1, right, x, y));
}
long long dfs(long long l, long long r) {
if (l > r) return 0;
pair<long long, long long> h = get(1, 1, n, l, r);
long long pos = h.second;
return max(dfs(l, pos - 1), dfs(pos + 1, r)) + 1;
}
void mov(long long pos) {
for (int i = pos; i <= n; i++) {
b[i] = a[i - pos + 1];
}
for (int i = 1; i <= pos - 1; i++) {
b[i] = a[i + n - pos + 1];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("t.inp", "r")) {
freopen("test.inp", "r", stdin);
freopen("test.out", "w", stdout);
}
cin >> n;
long long pos;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) pos = i;
}
for (int i = pos; i <= n; i++) {
b[i - pos + 1] = a[i];
}
for (int i = 1; i <= pos - 1; i++) {
b[i + n - pos + 1] = a[i];
}
for (int i = 1; i <= n; i++) {
a[i] = b[i];
}
long long l = 1, h = n;
while (l <= h) {
long long mid = (l + h) / 2;
mov(mid);
build(1, 1, n);
if (dfs(1, mid - 1) > dfs(mid + 1, n))
h = mid - 1;
else
l = mid + 1;
}
pair<long long, long long> ans = make_pair(base, -1);
mov(l);
build(1, 1, n);
long long t = dfs(1, l - 1) + 1;
if (ans.first > t) {
ans = make_pair(t, l);
}
if (l - 1 >= 1) {
mov(l - 1);
build(1, 1, n);
long long t = max(dfs(1, l - 2), dfs(l, n)) + 1;
if (ans.first > t) {
ans = make_pair(t, l - 1);
}
}
l = 1, h = n;
while (l <= h) {
long long mid = (l + h) / 2;
mov(mid);
build(1, 1, n);
if (dfs(1, mid - 1) < dfs(mid + 1, n))
l = mid + 1;
else
h = mid - 1;
}
mov(h);
build(1, 1, n);
t = dfs(h + 1, n) + 1;
if (ans.first > t) {
ans = make_pair(t, h);
}
if (ans.second <= pos) {
ans.second = pos - ans.second;
} else {
ans.second = pos + n - ans.second;
}
cout << ans.first << " " << ans.second << "\n";
}
|
#include <bits/stdc++.h>
template <typename T>
inline void read(T *x) {
int c;
while (!isdigit(c = getchar())) {
}
*x = c - '0';
while (isdigit(c = getchar())) {
(*x *= 10) += c - '0';
}
}
const int max_N = (int)2e5 + 21;
int n, Q[max_N], rk[max_N];
int ans1, ans2, dep[2][max_N];
int dp[max_N], st[max_N], top;
void solve(int *dep) {
memset(dp, 0, sizeof dp);
top = 0;
for (int i = 1; i <= n; ++i) {
dp[Q[i]] = 0;
while (top && st[top] > Q[i]) {
dp[Q[i]] = std::max(dp[Q[i]], dp[st[top--]] + 1);
}
st[++top] = Q[i];
dp[Q[i]] = std::max(top, dp[Q[i]]);
dep[i] = std::max(dep[i - 1], dp[Q[i]]);
}
}
int main() {
read(&n);
for (int i = 1; i <= n; ++i) {
read(&Q[i]);
rk[Q[i]] = i;
}
std::rotate(Q + 1, std::find(Q + 1, Q + 1 + n, 1), Q + 1 + n);
solve(dep[0]);
std::reverse(Q + 1, Q + 1 + n);
std::rotate(Q + 1, Q + n, Q + 1 + n);
solve(dep[1]);
ans1 = INT_MAX;
for (int i = 1; i <= n; ++i) {
int depth = std::max(dep[0][i], dep[1][n - i + 1]);
int head = Q[n - i + 1];
if (depth < ans1) {
ans1 = depth;
ans2 = rk[head] - 1;
}
}
printf("%d %d\n", ans1, ans2);
}
|
#include <bits/stdc++.h>
const int maxn = 3e6 + 9;
inline int Read() {
int x(0), f(1);
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
return x * f;
}
int n, m, pos1, pos2, l, r;
int mn[maxn], a[maxn];
void Build(int nw, int l, int r) {
if (l == r) {
mn[nw] = l;
return;
}
int mid(l + r >> 1);
Build(nw << 1, l, mid);
Build(nw << 1 | 1, mid + 1, r);
if (a[mn[nw << 1]] <= a[mn[nw << 1 | 1]])
mn[nw] = mn[nw << 1];
else
mn[nw] = mn[nw << 1 | 1];
}
int Query(int nw, int l, int r, int lt, int rt) {
if (lt <= l && rt >= r) return mn[nw];
int mid(l + r >> 1), ret(0);
if (lt <= mid) ret = Query(nw << 1, l, mid, lt, rt);
if (rt > mid) {
int tmp(Query(nw << 1 | 1, mid + 1, r, lt, rt));
if (!ret)
ret = tmp;
else if (a[tmp] < a[ret])
ret = tmp;
}
return ret;
}
int Dfs(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
int nw(Query(1, 1, 3 * n, l, r));
return std::max(Dfs(l, nw - 1), Dfs(nw + 1, r)) + 1;
}
inline int Check(int l, int r) {
int nw;
if (r >= pos2)
nw = pos2;
else
nw = pos1;
return Dfs(l, nw - 1) - Dfs(nw + 1, r);
}
int main() {
n = Read();
for (int i = 1; i <= n; ++i) a[i] = a[i + n] = a[i + (n << 1)] = Read();
Build(1, 1, n * 3);
for (int i = 1; i <= n; ++i)
if (a[i] == 1) l = i, r = i + n;
pos2 = r;
--r;
pos1 = l;
int nw(0);
while (l <= r) {
int mid(l + r >> 1);
if (Check(mid, mid + n - 1) >= 0)
nw = mid, l = mid + 1;
else
r = mid - 1;
}
printf("%d %d\n", Dfs(nw, nw + n - 1), (nw % n ? nw % n : n) - 1);
return 0;
}
|
#include <bits/stdc++.h>
int read() {
register int x = 0;
register char f = 1, ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f ^= 1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ '0');
return f ? x : -x;
}
int n, a[200005], tmp[200005], ls[200005], rs[200005], dep[200005];
int topr, star[200005], mxr[200005], ldep[200005], topl, stal[200005],
mxl[200005], ans, ansk;
void dfs(int u) {
if (!u) return;
dfs(ls[u]), dfs(rs[u]), dep[u] = std ::max(dep[ls[u]], dep[rs[u]]) + 1;
}
int main() {
n = read();
for (register int i = 0; i < n; ++i) a[i] = read() - 1;
int k = 0;
for (register int i = 0; i < n; ++i)
if (!a[i]) {
k = i;
break;
}
for (register int i = k; i < n; ++i) tmp[i - k] = a[i];
for (register int i = 0; i < k; ++i) tmp[n - k + i] = a[i];
for (register int i = 0; i < n; ++i) a[i] = tmp[i];
--n;
for (register int i = 1; i <= n; ++i) {
star[topr + 1] = 0;
while (topr && a[star[topr]] > a[i]) --topr;
ls[i] = star[topr + 1], rs[star[topr]] = i, star[++topr] = i;
}
dfs(star[1]), ans = dep[star[1]], ansk = k;
int u = star[1];
while (u)
stal[++topl] = u, mxl[topl] = std ::max(mxl[topl - 1], dep[rs[u]] + topl),
u = ls[u];
topr = 0;
for (register int i = 1; i < n; ++i) {
int rdep = 0;
while (topr && a[star[topr]] > a[i])
rdep = std ::max(rdep + 1, ldep[topr] + 1), --topr;
star[++topr] = i, ldep[topr] = rdep,
mxr[topr] = std ::max(mxr[topr - 1], ldep[topr] + topr);
int u = rs[stal[topl]];
--topl, ls[stal[topl]] = u;
while (u)
stal[++topl] = u, mxl[topl] = std ::max(mxl[topl - 1], dep[rs[u]] + topl),
u = ls[u];
int s = std ::max(mxl[topl], mxr[topr]);
if (s < ans) ans = s, ansk = k + i + 1;
}
printf("%d %d\n", ans + 1, ansk % (n + 1));
}
|
#include <bits/stdc++.h>
const int maxn = 1e6 + 3, lo = 0x100000;
int n, root, a[maxn];
int p[maxn], clk, lu[maxn], lv[maxn];
struct segmenttree {
struct node {
long long m, d;
void tag(const long long &u) {
m += u;
d += u;
}
void up(const node &l, const node &r) {
m = std::max(l.m, r.m);
d = 0;
}
void down(node &l, node &r) {
if (d) {
l.tag(d);
r.tag(d);
d = 0;
}
}
} a[lo * 2];
void build() {
for (int i = lo - 1; i > 0; --i) a[i].up(a[i * 2], a[i * 2 + 1]);
}
void down(int k) {
if (k < 0 || k >= lo) return;
for (int i = 1, j = lo / 2; i < lo;
i = (k & j) ? i * 2 + 1 : i * 2, j /= 2) {
a[i].down(a[i * 2], a[i * 2 + 1]);
}
}
void up(int k) {
if (k < 0 || k >= lo) return;
for (int i = (k + lo) / 2; i > 0; i /= 2) {
a[i].up(a[i * 2], a[i * 2 + 1]);
}
}
void modify(int l, int r, const long long &v) {
down(l - 1);
down(r);
for (int i = l + lo, j = r + lo; i < j; i /= 2, j /= 2) {
if (i % 2) a[i++].tag(v);
if (j % 2) a[--j].tag(v);
}
up(l - 1);
up(r);
}
long long query(int l, int r) {
long long ans = std::numeric_limits<long long>::min();
down(l - 1);
down(r);
for (int i = l + lo, j = r + lo; i < j; i /= 2, j /= 2) {
if (i % 2) ans = std::max(ans, a[i++].m);
if (j % 2) ans = std::max(ans, a[--j].m);
}
return ans;
}
} t;
void push(int u) {
long long w = clk ? t.a[clk - 1 + lo].m + bool(u < n) : bool(u < n);
t.a[clk + lo] = {w, 0};
clk += 1;
}
void pop(int u) {
long long w = clk ? t.a[clk - 1 + lo].m - bool(u < n) : -bool(u < n);
t.a[clk + lo] = {w, 0};
clk += 1;
}
void add(int u) {
t.modify(lu[u], clk, 1);
t.modify(lv[u], clk, -1);
}
void del(int u) {
t.modify(lu[u], clk, -1);
t.modify(lv[u], clk, 1);
}
int query() { return t.query(0, clk); }
std::vector<int> E[maxn];
void dfs(int u) {
lu[u] = clk;
push(u);
for (auto &&v : E[u]) {
dfs(v);
}
lv[u] = clk;
pop(u);
}
void addedge(int u, int v) { E[u].push_back(v); }
int lm[maxn], rm[maxn];
void init() {
memset(lm, -1, sizeof(lm));
memset(rm, -1, sizeof(rm));
std::stack<int> s;
for (int i = 0; i < n * 2; ++i) {
while (!s.empty() && a[s.top()] > a[i]) {
lm[i] = s.top();
s.pop();
}
if (!s.empty()) {
rm[s.top()] = i;
}
s.push(i);
}
while (!s.empty()) {
root = s.top();
s.pop();
}
for (int i = 0; i < n * 2; ++i) {
if (lm[i] != -1) {
addedge(i, lm[i]);
}
if (rm[i] != -1) {
addedge(i, rm[i]);
}
}
dfs(root);
t.build();
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
for (int i = 0; i < n; ++i) a[i + n] = a[i];
init();
int ans = query(), ansi = 0;
for (int i = 0; i < n; ++i) {
add(i + n);
del(i);
auto w = query();
if (w < ans) {
ans = w;
ansi = i + 1;
}
}
printf("%d %d\n", ans, ansi);
return 0;
}
|
#include <bits/stdc++.h>
int st[401000], dep[401000], top = 0;
int n;
int a[401000], ans1[401000], ans2[401000];
void solve(int *a, int *ans) {
int id;
top = 0;
for (int i = 1; i <= n; i++)
if (a[i] == 1) {
id = i;
break;
}
int now = 0;
for (int i = id; i <= n; i++) {
int Max = 0;
while (top && a[i] < st[top]) {
Max = std::max(Max, dep[top]);
top--;
Max++;
}
st[++top] = a[i];
dep[top] = Max;
now = std::max(now, top + Max);
ans[i % n] = now;
}
for (int i = 1; i < id; i++) {
int Max = 0;
while (top && a[i] < st[top]) {
Max = std::max(Max, dep[top]);
top--;
Max++;
}
st[++top] = a[i];
dep[top] = Max;
now = std::max(now, top + Max);
ans[i] = now;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
solve(a, ans1);
std::reverse(a + 1, a + n + 1);
solve(a, ans2);
int Ans = std::max(ans1[0], ans2[0]), id = 0;
for (int i = 1; i < n; i++) {
if (std::max(ans1[i], ans2[n - i]) < Ans)
Ans = std::max(ans1[i], ans2[n - i]), id = i;
}
printf("%d %d\n", Ans, id);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 400005;
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;
}
int n, nn, a[MAXN], stk[MAXN], top, L[MAXN], R[MAXN];
int mx[MAXN << 2], tag[MAXN << 2];
inline void puttag(int rt, int tg) {
mx[rt] += tg;
tag[rt] += tg;
}
inline void pushdown(int rt) {
if (!tag[rt]) return;
puttag((rt << 1), tag[rt]);
puttag((rt << 1) | 1, tag[rt]);
tag[rt] = 0;
}
void Update(int rt, int b, int e, int l, int r, int v) {
if (l <= b && e <= r) {
puttag(rt, v);
return;
}
int mid = (b + e) >> 1;
pushdown(rt);
if (l <= mid) Update((rt << 1), b, mid, l, r, v);
if (r > mid) Update((rt << 1) | 1, mid + 1, e, l, r, v);
mx[rt] = max(mx[(rt << 1)], mx[(rt << 1) | 1]);
}
int Query(int rt, int b, int e, int l, int r) {
if (l <= b && e <= r) return mx[rt];
int mid = (b + e) >> 1;
pushdown(rt);
if (r <= mid) return Query((rt << 1), b, mid, l, r);
if (l > mid) return Query((rt << 1) | 1, mid + 1, e, l, r);
return max(Query((rt << 1), b, mid, l, r),
Query((rt << 1) | 1, mid + 1, e, l, r));
}
void init() {
read(n);
nn = n + n;
for (int i = 1; i <= n; ++i) {
read(a[i]);
a[n + i] = a[i];
}
a[0] = a[nn + 1] = 0;
for (int i = 1; i <= nn + 1; ++i) {
while (top && a[stk[top]] >= a[i]) {
R[stk[top--]] = i - 1;
}
stk[++top] = i;
}
top = 0;
for (int i = nn; i >= 0; --i) {
while (top && a[stk[top]] >= a[i]) {
L[stk[top--]] = i + 1;
}
stk[++top] = i;
}
}
void solve() {
for (int i = 1; i <= n; ++i) {
Update(1, 1, nn, L[i], R[i], 1);
}
int ans = Query(1, 1, nn, 1, n), anspos = 0;
for (int i = 1; i < n; ++i) {
Update(1, 1, nn, L[i], R[i], -1);
Update(1, 1, nn, L[n + i], R[n + i], 1);
int cur = Query(1, 1, nn, i + 1, n + i);
if (cur < ans) {
ans = cur;
anspos = i;
}
}
printf("%d %d\n", ans, anspos);
}
int main() {
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 5;
struct segment_change {
int to_add;
segment_change(int _to_add = 0) : to_add(_to_add) {}
void reset() { to_add = 0; }
bool has_change() const { return to_add != 0; }
segment_change combine(const segment_change &other) const {
return segment_change(to_add + other.to_add);
}
};
struct segment {
int maximum;
segment(int _maximum = -INF) : maximum(_maximum) {}
void apply(int, const segment_change &change) { maximum += change.to_add; }
void join(const segment &other) { maximum = max(maximum, other.maximum); }
void join(const segment &a, const segment &b) {
*this = a;
join(b);
}
};
struct add_max_seg_tree {
int tree_n = 0;
vector<segment> tree;
vector<segment_change> changes;
add_max_seg_tree(int n = 0) {
if (n > 0) init(n);
}
void init(int n) {
tree_n = 1;
while (tree_n < n) tree_n *= 2;
tree.assign(2 * tree_n, segment());
changes.assign(tree_n, segment_change());
}
void build(const vector<segment> &initial) {
int n = initial.size();
assert(n <= tree_n);
for (int i = 0; i < n; i++) tree[tree_n + i] = initial[i];
for (int position = tree_n - 1; position > 0; position--)
tree[position].join(tree[2 * position], tree[2 * position + 1]);
}
void push_down(int position, int length) {
if (!changes[position].has_change()) return;
if (2 * position < tree_n) {
changes[2 * position] = changes[2 * position].combine(changes[position]);
changes[2 * position + 1] =
changes[2 * position + 1].combine(changes[position]);
}
tree[2 * position].apply(length / 2, changes[position]);
tree[2 * position + 1].apply(length / 2, changes[position]);
changes[position].reset();
}
void push_all(int a, int b) {
assert(0 <= a && a < b && b <= tree_n);
a += tree_n;
b += tree_n - 1;
for (int up = 31 - __builtin_clz(tree_n); up > 0; up--) {
int x = a >> up, y = b >> up;
push_down(x, 1 << up);
if (x != y) push_down(y, 1 << up);
}
}
void join_and_apply(int position, int length) {
tree[position].join(tree[2 * position], tree[2 * position + 1]);
tree[position].apply(length, changes[position]);
}
void join_all(int a, int b) {
assert(0 <= a && a < b && b <= tree_n);
a += tree_n;
b += tree_n - 1;
int length = 1;
while (a > 1) {
a /= 2;
b /= 2;
length *= 2;
join_and_apply(a, length);
if (a != b) join_and_apply(b, length);
}
}
pair<int, int> right_half[32];
template <typename T_range_op>
void process_range(int a, int b, bool needs_join, T_range_op &&range_op) {
if (a == b) return;
push_all(a, b);
int original_a = a, original_b = b;
int length = 1, r_size = 0;
for (a += tree_n, b += tree_n; a < b; a /= 2, b /= 2, length *= 2) {
if (a & 1) range_op(a++, length);
if (b & 1) right_half[r_size++] = {--b, length};
}
for (int i = r_size - 1; i >= 0; i--)
range_op(right_half[i].first, right_half[i].second);
if (needs_join) join_all(original_a, original_b);
}
segment query(int a, int b) {
assert(0 <= a && a <= b && b <= tree_n);
segment answer;
process_range(a, b, false,
[&](int position, int) { answer.join(tree[position]); });
return answer;
}
void update(int a, int b, const segment_change &change) {
assert(0 <= a && a <= b && b <= tree_n);
process_range(a, b, true, [&](int position, int length) {
tree[position].apply(length, change);
if (position < tree_n)
changes[position] = changes[position].combine(change);
});
}
void set_value(int index, int value) {
assert(0 <= index && index < tree_n);
int current = query(index, index + 1).maximum;
update(index, index + 1, segment_change(value - current));
}
};
int N;
vector<int> parent;
vector<vector<int>> children;
vector<int> tour_start, tour_end;
int tour;
void dfs(int node) {
tour_start[node] = tour++;
for (int child : children[node]) dfs(child);
tour_end[node] = tour;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (typename vector<T>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << *vi;
}
os << "}";
return os;
}
template <>
ostream &operator<<(ostream &os, const vector<string> &v) {
os << "{";
for (vector<string>::const_iterator vi = v.begin(); vi != v.end(); ++vi) {
if (vi != v.begin()) os << ", ";
os << "\"" << *vi << "\"";
}
os << "}";
return os;
}
vector<int> solve(vector<int> perm) {
assert((int)perm.size() == N);
assert(perm.front() == 1);
for (int &p : perm) p--;
parent.assign(N, -1);
vector<pair<int, int>> events;
vector<int> stack = {-1};
for (int x : perm) {
int erased = -1;
while (stack.back() > x) {
erased = stack.back();
stack.pop_back();
}
events.emplace_back(x, stack.back());
events.emplace_back(erased, x);
parent[x] = stack.back();
if (erased >= 0) parent[erased] = x;
stack.push_back(x);
}
children.assign(N, {});
tour_start.resize(N);
tour_end.resize(N);
for (int i = 0; i < N; i++)
if (parent[i] >= 0) children[parent[i]].push_back(i);
tour = 0;
dfs(0);
vector<int> answers(N, INF);
add_max_seg_tree tree(N);
for (int i = 0; i < N; i++) {
int a = events[2 * i].first;
int b = events[2 * i].second;
assert(a >= 0);
tree.set_value(
tour_start[a],
b < 0 ? 1 : tree.query(tour_start[b], tour_start[b] + 1).maximum + 1);
a = events[2 * i + 1].first;
b = events[2 * i + 1].second;
if (a >= 0) {
tree.update(tour_start[a], tour_end[a], segment_change(+1));
}
answers[i] = tree.query(0, N).maximum;
}
return answers;
}
vector<int> A;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
A.resize(N);
for (int &a : A) cin >> a;
int one = find(A.begin(), A.end(), 1) - A.begin();
vector<int> start_one, end_one;
for (int i = one; (int)start_one.size() < N; i = (i + 1) % N)
start_one.push_back(A[i]);
for (int i = one; (int)end_one.size() < N; i = (i + N - 1) % N)
end_one.push_back(A[i]);
vector<int> left = solve(end_one), right = solve(start_one);
int best_left = 0, best = INF;
for (int i = 0; i < N; i++) {
if (max(left[i], right[N - 1 - i]) < best) {
best = max(left[i], right[N - 1 - i]);
best_left = i;
}
}
cout << best << ' ' << (one - best_left + N) % N << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400001];
int l[800001], r[800001];
int mx[1600001], lz[1600001];
void push(int id) {
mx[id * 2] += lz[id];
mx[id * 2 + 1] += lz[id];
lz[id * 2] += lz[id];
lz[id * 2 + 1] += lz[id];
lz[id] = 0;
}
void upd(int id, int l, int r, int ql, int qr, int v) {
if (l > qr || r < ql) return;
if (ql <= l && r <= qr) {
lz[id] += v;
mx[id] += v;
return;
}
push(id);
int mid = (l + r) / 2;
upd(id * 2, l, mid, ql, qr, v);
upd(id * 2 + 1, mid + 1, r, ql, qr, v);
mx[id] = max(mx[id * 2], mx[id * 2 + 1]);
}
int qry(int id, int l, int r, int ql, int qr) {
if (l > qr || r < ql) return 0;
if (ql <= l && r <= qr) return mx[id];
push(id);
int mid = (l + r) / 2;
int v1 = qry(id * 2, l, mid, ql, qr);
int v2 = qry(id * 2 + 1, mid + 1, r, ql, qr);
return max(v1, v2);
}
int ans, mi;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i + n] = a[i];
r[i] = r[i + n] = 2 * n + 1;
}
stack<int> s;
for (int i = 1; i <= 2 * n; i++) {
while (!s.empty() && a[s.top()] > a[i]) {
r[s.top()] = i;
s.pop();
}
if (!s.empty()) l[i] = s.top();
s.push(i);
}
for (int i = 1; i <= n; i++) {
if (a[i] != 1) upd(1, 1, 2 * n, l[i] + 1, r[i] - 1, 1);
}
ans = qry(1, 1, 2 * n, 1, n);
mi = 0;
for (int i = 1; i <= n - 1; i++) {
if (a[i] == 1) continue;
upd(1, 1, 2 * n, l[i] + 1, r[i] - 1, -1);
upd(1, 1, 2 * n, l[i + n] + 1, r[i + n] - 1, 1);
int cur = qry(1, 1, 2 * n, i + 1, n + i);
if (cur < ans) {
ans = cur;
mi = i;
}
}
cout << ans + 1 << ' ' << mi << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
class SegTree {
private:
class Node {
void merge_info() {
if (ln != nullptr) {
auto ldata = ln->x + ln->add;
auto rdata = rn->x + rn->add;
x = max(ldata, rdata);
}
}
public:
Node *ln, *rn;
long long x, add;
Node(long long x) {
this->x = x;
this->add = 0;
this->ln = this->rn = nullptr;
}
Node(Node *ln, Node *rn) {
this->add = 0;
this->ln = ln;
this->rn = rn;
this->merge_info();
}
void norm() {
if (ln != nullptr) {
ln->add += add;
rn->add += add;
} else {
x += add;
}
add = 0;
merge_info();
}
};
Node *init(vector<long long> &v, int l, int r) {
if (l == r) return new Node(v[l]);
int k = l + (r - l) / 2;
Node *ln = init(v, l, k);
Node *rn = init(v, k + 1, r);
return new Node(ln, rn);
}
long long merge_query(long long *lret, long long *rret) {
if (lret == nullptr) return *rret;
if (rret == nullptr) return *lret;
return max(*lret, *rret);
}
long long query(Node *curr, int l, int r, int i, int j) {
curr->norm();
if (l >= i && r <= j) return curr->x;
int k = l + (r - l) / 2;
long long *lret = nullptr, *rret = nullptr;
if (k >= i && l <= j) lret = new long long(query(curr->ln, l, k, i, j));
if (k + 1 <= j && r >= i)
rret = new long long(query(curr->rn, k + 1, r, i, j));
auto ret = merge_query(lret, rret);
return ret;
}
void add(Node *curr, long long k, int i, int j, int l, int r) {
if (j < l || i > r) return;
if (l >= i && r <= j) {
curr->add += k;
} else {
int m = l + (r - l) / 2;
add(curr->ln, k, i, j, l, m);
add(curr->rn, k, i, j, m + 1, r);
}
curr->norm();
}
int n;
Node *root = nullptr;
void clean(Node *v) {
if (v == nullptr) return;
clean(v->ln);
clean(v->rn);
delete v;
}
public:
SegTree(vector<long long> &v) {
this->n = v.size();
this->root = init(v, 0, n - 1);
}
~SegTree() { clean(root); }
long long query(int i = 0, int j = -1) {
if (j == -1) j = n - 1;
return query(root, 0, n - 1, i, j);
}
void add(long long k, int i, int j = -1) {
if (j == -1) j = n - 1;
add(root, k, i, j, 0, n - 1);
}
};
vector<pair<int, int>> rSteps(vector<int> &p) {
int n = p.size(), i, j;
int pos1 = find((p).begin(), (p).end(), 1) - p.begin();
vector<pair<int, int>> rh(n);
rh[pos1] = {0, 0};
stack<pair<int, int>> d;
d.push({1, pos1});
j = pos1;
for (i = 1; i < n; i++) {
j = (j - 1 + n) % n;
while (d.top().first > p[j]) d.pop();
int pA = d.top().second;
int rJ = (pA - j + n) % n;
int hJ = pA > j ? rh[pA].second + 1 : 0;
rh[j] = {rJ, hJ};
d.push({p[j], j});
}
return rh;
}
int main() {
int n, i;
cin >> n;
vector<int> p(n);
for (i = 0; i < n; i++) cin >> p[i];
auto rh = rSteps(p);
reverse((p).begin(), (p).end());
auto lh = rSteps(p);
reverse((lh).begin(), (lh).end());
vector<long long> v(2 * n, 0);
for (i = 0; i < n; i++) v[i] = rh[i].second + lh[i].second;
SegTree s(v);
int minH = s.query(0, n - 1);
int bestS = 0;
for (i = 0; i < n - 1; i++) {
int lq = i + 1, rq = i + rh[i].first - 1;
if (lq <= rq) s.add(-1, lq, rq);
int lI = lh[i].first;
lq = i + n - lI + 1;
rq = i + n - 1;
if (lq <= rq) s.add(+1, lq, rq);
if (lI > 0) {
int newV = s.query(i + n - lI, i + n - lI) + 1;
s.add(newV, i + n, i + n);
}
int currH = s.query(i + 1, i + n);
if (currH < minH) {
minH = currH;
bestS = i + 1;
}
}
cout << (minH + 1) << " " << bestS << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int perm[N], cperm[2 * N], lsmaller[2 * N], rsmaller[2 * N], tree[4 * N],
lazy[4 * N], tree2[4 * N], n;
void propagate(int node, int l, int r) {
if (lazy[node] == 0) return;
tree[node] += lazy[node];
if (l != r) lazy[node * 2] += lazy[node], lazy[node * 2 + 1] += lazy[node];
lazy[node] = 0;
}
void update(int node, int l, int r, int st, int en, int val) {
propagate(node, l, r);
if (st > r || en < l || st > en) return;
if (st <= l && r <= en) {
lazy[node] += val;
propagate(node, l, r);
return;
}
int mid = (l + r) >> 1;
update(node * 2, l, mid, st, en, val);
update(node * 2 + 1, mid + 1, r, st, en, val);
tree[node] = max(tree[node * 2], tree[node * 2 + 1]);
}
int query(int node, int l, int r, int st, int en) {
propagate(node, l, r);
if (st > r || en < l || st > en) return 0;
if (st <= l && r <= en) return tree[node];
int mid = (l + r) >> 1;
return max(query(node * 2, l, mid, st, en),
query(node * 2 + 1, mid + 1, r, st, en));
}
void build(int node, int l, int r) {
if (l == r) {
tree2[node] = l;
return;
}
int mid = (l + r) >> 1;
build(node * 2, l, mid);
build(node * 2 + 1, mid + 1, r);
if (perm[tree2[node * 2]] < perm[tree2[node * 2 + 1]])
tree2[node] = tree2[node * 2];
else
tree2[node] = tree2[node * 2 + 1];
}
int query2(int node, int l, int r, int st, int en) {
if (st > r || en < l || st > en) return -1;
if (st <= l && r <= en) return tree2[node];
int mid = (l + r) >> 1;
int v1 = query2(node * 2, l, mid, st, en);
int v2 = query2(node * 2 + 1, mid + 1, r, st, en);
if (v1 == -1)
return v2;
else if (v2 == -1)
return v1;
else if (perm[v1] < perm[v2])
return v1;
else
return v2;
}
void dfs(int l, int r, int depth) {
if (l > r) return;
int idx = query2(1, 0, n - 1, l, r);
update(1, 0, n - 1, idx, idx, depth);
dfs(l, idx - 1, depth + 1);
dfs(idx + 1, r, depth + 1);
}
void update_range(int l, int r, int val) {
l %= n, r %= n;
if (l > r)
update(1, 0, n - 1, l, n - 1, val), update(1, 0, n - 1, 0, r, val);
else
update(1, 0, n - 1, l, r, val);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> perm[i];
for (int i = 0; i < 2 * n; i++) cperm[i] = perm[i % n];
build(1, 0, n - 1);
dfs(0, n - 1, 1);
stack<int> st;
memset(lsmaller, -1, sizeof lsmaller);
memset(rsmaller, -1, sizeof rsmaller);
for (int i = 0; i < 2 * n; i++) {
while (st.size() && cperm[st.top()] > cperm[i]) st.pop();
if (st.size()) lsmaller[i] = st.top();
st.push(i);
}
while (st.size()) st.pop();
for (int i = 2 * n - 1; i >= 0; i--) {
while (st.size() && cperm[st.top()] > cperm[i]) st.pop();
if (st.size()) rsmaller[i] = st.top();
st.push(i);
}
int mn = query(1, 0, n - 1, 0, n - 1), shift = 0;
for (int i = 0; i < n - 1; i++) {
int right = rsmaller[i];
right = min(right, i + n);
if (right != i + 1) update_range(i + 1, right - 1, -1);
int left = lsmaller[i + n];
if (left + 1 != i + n) update_range(left + 1, i + n - 1, 1);
int val = query(1, 0, n - 1, i, i);
update(1, 0, n - 1, i, i, -val);
if (lsmaller[i + n] == i)
val = 1;
else
val = query(1, 0, n - 1, lsmaller[i + n] % n, lsmaller[i + n] % n) + 1;
update(1, 0, n - 1, i, i, val);
val = query(1, 0, n - 1, 0, n - 1);
if (val < mn) {
mn = val;
shift = i + 1;
}
}
cout << mn << ' ' << shift;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int maxn = 200000;
int t[4 * maxn];
int p[maxn];
int n;
int mina(int x, int y) {
if (x == -1) return y;
if (y == -1) return x;
return (p[x] < p[y] ? x : y);
}
void build(int x, int cl, int cr) {
if (cr - cl > 1) {
build(2 * x, cl, (cl + cr) / 2);
build(2 * x + 1, (cl + cr) / 2, cr);
t[x] = mina(t[2 * x], t[2 * x + 1]);
} else
t[x] = cl;
}
int get(int x, int cl, int cr, int l, int r) {
if (cr <= l || r <= cl) return -1;
if (l <= cl && cr <= r) return t[x];
return mina(get(2 * x, cl, (cl + cr) / 2, l, r),
get(2 * x + 1, (cl + cr) / 2, cr, l, r));
}
int a[maxn], dpl[maxn], dpr[maxn];
int mx = 0;
void dfs(int i, int cl, int cr, int cd) {
dpl[i] = dpr[i] = 1;
if (i != cl) {
int u = get(1, 0, maxn, cl, i);
dfs(u, cl, i, cd + 1);
dpl[i] += max(dpl[u], dpr[u]);
}
if (cr - i > 1) {
int u = get(1, 0, maxn, i + 1, cr);
dfs(u, i + 1, cr, cd + 1);
dpr[i] += max(dpr[u], dpl[u]);
}
}
pair<int, int> solve(int sd) {
for (int i = sd; i < n; i++) p[i - sd] = a[i];
for (int i = n - sd; i < n; i++) p[i] = a[i - n + sd];
build(1, 0, maxn);
mx = 0;
int st = get(1, 0, maxn, 0, n);
dfs(st, 0, n, 1);
return {max(dpl[st], dpr[st]), dpl[st] - dpr[st]};
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int ans = solve(0).first;
int mi = 0;
int st = get(1, 0, maxn, 0, n);
int l = 0, r = st;
while (r - l > 10) {
int md = (l + r) / 2;
if (solve(md).second >= 0)
l = md;
else
r = md;
}
for (int i = l; i <= r; i++) {
int fuck = solve(i).first;
if (fuck < ans) {
mi = i;
}
ans = min(ans, fuck);
}
l = st;
r = n - 1;
while (r - l > 10) {
int md = (l + r) / 2;
if (solve(md).second >= 0)
l = md;
else
r = md;
}
for (int i = l; i <= r; i++) {
int fuck = solve(i).first;
if (fuck < ans) {
mi = i;
}
ans = min(ans, fuck);
}
cout << ans << ' ' << mi;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400003, maxlog = 20;
int n, a[maxn], temp[maxn], st[maxn][maxlog], lg[maxn];
bool cmp(int x, int y) { return a[x] < a[y]; }
void initst() {
for (int i = 2; i <= (n << 1); i++) lg[i] = lg[i >> 1] + 1;
for (int i = 0; i < (n << 1); i++) st[i][0] = i;
for (int len = 1; (1 << len) <= (n << 1); len++) {
for (int i = 0; i + (1 << len) - 1 < (n << 1); i++) {
st[i][len] = min(st[i][len - 1], st[i + (1 << (len - 1))][len - 1], cmp);
}
}
}
int query(int l, int r) {
int tmp = lg[r - l + 1];
return min(st[l][tmp], st[r - (1 << tmp) + 1][tmp], cmp);
}
int build(int l, int r) {
if (l > r) return 0;
int mid = query(l, r);
return max(build(l, mid - 1), build(mid + 1, r)) + 1;
}
bool check(int x) {
int mid = query(x, x + n - 1);
return build(x, mid - 1) <= build(mid + 1, x + n - 1);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int d = min_element(a, a + n) - a;
for (int i = 0; i < n; i++) temp[i] = a[(i + d + 1) % n];
copy(temp, temp + n, a);
copy(a, a + n, a + n);
initst();
int l = 0, r = n - 1, mid, L = -1;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid))
L = mid, r = mid - 1;
else
l = mid + 1;
}
printf("%d %d\n", build(L, L + n - 1), (L + d + 1) % n);
return 0;
}
|
#include <bits/stdc++.h>
const int kInf = 0x3f3f3f3f, kMod = 1e9 + 7;
const long long kInf64 = 0x3f3f3f3f3f3f3f3f;
template <typename T>
inline void UMin(T& x, const T& y) {
if (x > y) x = y;
}
template <typename T>
inline void UMax(T& x, const T& y) {
if (x < y) x = y;
}
inline int Add(int a, int b) { return (a += b) >= kMod ? a - kMod : a; }
inline int Sub(int a, int b) { return (a -= b) < 0 ? a + kMod : a; }
inline int Mul(int a, int b) { return 1ll * a * b % kMod; }
int FPow(int bs, int ex = kMod - 2) {
int res = 1;
for (; ex; bs = Mul(bs, bs), ex >>= 1)
if (ex & 1) res = Mul(res, bs);
return res;
}
const int kMaxn = 2e5 + 5;
int n, top, dfs_clock;
namespace smt {
struct Node {
int max, tag;
} T[kMaxn << 2];
inline int Id(int l, int r) { return l + r | l != r; }
inline int Query() { return T[Id(1, n * 2)].max; }
void Modify(int l, int r, int ql, int qr, int d);
} // namespace smt
int A[kMaxn << 1], S[kMaxn << 1], idfn[kMaxn << 1];
int ch[kMaxn << 1][2], fa[kMaxn << 1], odfn[kMaxn << 1];
void Dfs(int u);
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", A + i);
A[n + i] = A[i];
}
for (int i = 1, la; i <= n * 2; ++i) {
la = -1;
for (int v; top;) {
if (A[v = S[top - 1]] <= A[i]) {
if (ch[v][1]) {
ch[i][0] = ch[v][1];
fa[ch[v][1]] = i;
}
fa[ch[v][1] = i] = v;
break;
}
la = S[--top];
}
if (!top && ~la) fa[ch[i][0] = la] = i;
S[top++] = i;
}
Dfs(S[0]);
for (int i = 1; i <= n; i++) smt::Modify(1, n << 1, idfn[i], odfn[i], 1);
int ans = smt::Query(), k = 0;
for (int i = n + 1; i <= n * 2; i++) {
smt::Modify(1, n << 1, idfn[i - n], odfn[i - n], -1);
smt::Modify(1, n << 1, idfn[i], odfn[i], 1);
if (smt::Query() < ans) {
ans = smt::Query(), k = i - n;
}
}
printf("%d %d\n", ans, k);
return 0;
}
namespace smt {
void PushDown(int l, int mid, int r) {
int cur = Id(l, r);
if (T[cur].tag) {
int ls = Id(l, mid), rs = Id(mid + 1, r);
T[ls].max += T[cur].tag, T[ls].tag += T[cur].tag;
T[rs].max += T[cur].tag, T[rs].tag += T[cur].tag;
T[cur].tag = 0;
}
}
void Modify(int l, int r, int ql, int qr, int d) {
int cur = Id(l, r);
if (ql <= l && r <= qr) {
T[cur].max += d, T[cur].tag += d;
return;
}
int mid = l + r >> 1;
PushDown(l, mid, r);
if (ql <= mid) Modify(l, mid, ql, qr, d);
if (qr > mid) Modify(mid + 1, r, ql, qr, d);
T[cur].max = std::max(T[Id(l, mid)].max, T[Id(mid + 1, r)].max);
}
} // namespace smt
void Dfs(int u) {
idfn[u] = ++dfs_clock;
if (ch[u][0]) Dfs(ch[u][0]);
if (ch[u][1]) Dfs(ch[u][1]);
odfn[u] = dfs_clock;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int num[400005];
pair<int, int> min(pair<int, int> a, pair<int, int> b) {
if (a.first <= b.first)
return a;
else
return b;
}
int lmn[400005][19], rmn[400005][19];
int leftMin(int i) {
int p = i;
for (int j = (18); j >= (0); j--) {
int tp = p - (1 << j);
if (tp >= max(0, i - n) && lmn[p][j] >= num[i]) p = tp;
}
return p;
}
int rightMin(int i) {
int p = i;
for (int j = (18); j >= (0); j--) {
int tp = p + (1 << j);
if (tp <= i + n && rmn[p][j] >= num[i]) p = tp;
}
return p;
}
template <typename T, typename T2>
class segmentTree {
public:
vector<T> seg;
vector<T2> lazy;
int mxs;
T sfill;
T2 lfill;
int ql, qr;
T2 qv;
segmentTree(int _mxs, T _sfill, T2 _lfill) : sfill(_sfill), lfill(_lfill) {
for (mxs = 1; mxs < _mxs; mxs <<= 1)
;
seg.assign((mxs << 1) + 5, sfill);
lazy.assign((mxs << 1) + 5, lfill);
}
T combine(T a, T b) { return max(a, b); }
void ppt(int i, int l, int r) {
if (lazy[i] == lfill) return;
seg[i] += lazy[i];
if (i < mxs) {
lazy[i << 1] += lazy[i];
lazy[i << 1 | 1] += lazy[i];
}
lazy[i] = lfill;
}
void merge(int i) { seg[i] = combine(seg[i << 1], seg[i << 1 | 1]); }
T query(int l, int r, int i) {
ppt(i, l, r);
if (qr < l || r < ql) return sfill;
if (ql <= l && r <= qr) return seg[i];
int m = (l + r) >> 1;
T lft = query(l, m, i << 1);
T rgt = query(m + 1, r, i << 1 | 1);
merge(i);
return combine(lft, rgt);
}
T qry(int _ql, int _qr) {
ql = _ql;
qr = _qr;
return query(1, mxs, 1);
}
void update(int l, int r, int i) {
ppt(i, l, r);
if (qr < l || r < ql) return;
if (ql <= l && r <= qr) {
lazy[i] += qv;
ppt(i, l, r);
return;
}
int m = (l + r) >> 1;
update(l, m, i << 1);
update(m + 1, r, i << 1 | 1);
return merge(i);
}
void upd(int _ql, int _qr, T2 _qv) {
ql = _ql;
qr = _qr;
qv = _qv;
update(1, mxs, 1);
}
};
segmentTree<int, int> s(400000, 0, 0);
void remove(int i) {
int p = rightMin(i);
s.upd(i + 1, p - 1, -1);
s.upd(i, i, -s.qry(i, i));
}
void insert(int i) {
int p = leftMin(i);
int dh = (p == max(0, i - n) ? 0 : s.qry(p, p)) + 1;
s.upd(i, i, dh);
s.upd(p + 1, i - 1, 1);
}
int main() {
scanf("%d", &n);
for (int i = (1); i <= (n); i++) {
scanf("%d", &num[i]);
num[i + n] = num[i];
}
for (int i = (1); i <= (n + n); i++) lmn[i][0] = rmn[i][0] = num[i];
for (int j = (1); j <= (18); j++) {
for (int i = (1); i <= (n + n); i++) {
lmn[i][j] = lmn[i][j - 1];
int p = i - (1 << (j - 1));
if (p >= 1) {
lmn[i][j] = min(lmn[i][j], lmn[p][j - 1]);
}
rmn[i][j] = rmn[i][j - 1];
p = i + (1 << (j - 1));
if (p <= n + n) {
rmn[i][j] = min(rmn[i][j], rmn[p][j - 1]);
}
}
}
pair<int, int> ans = {1000000000, 0};
for (int i = (1); i <= (n + n - 1); i++) {
if (i > n) remove(i - n);
insert(i);
if (i >= n) ans = min(ans, {s.seg[1], i - n});
}
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 400010;
struct SegSingle {
static const int MAX = 1 << 19;
int seg[MAX << 1];
void add(int sit, int value) {
seg[sit += MAX] = value;
for (sit >>= 1; sit; sit >>= 1) {
seg[sit] = std::max(seg[sit << 1], seg[sit << 1 | 1]);
}
}
int query(int l, int r) {
int ret = INT_MIN;
for (l += MAX, r += MAX + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1) ret = std::max(ret, seg[l++]);
if (r & 1) ret = std::max(ret, seg[--r]);
}
return ret;
}
};
struct SegInter {
static const int MAX = 1 << 19;
int seg[MAX << 1], lazy[MAX << 1];
void push(int sit) {
if (!lazy[sit]) {
return;
}
seg[sit << 1] += lazy[sit];
lazy[sit << 1] += lazy[sit];
seg[sit << 1 | 1] += lazy[sit];
lazy[sit << 1 | 1] += lazy[sit];
lazy[sit] = 0;
}
void pull(int sit) { seg[sit] = std::max(seg[sit << 1], seg[sit << 1 | 1]); }
void add(int sit, int ql, int qr, int l, int r, int value) {
if (ql > r || qr < l) {
return;
}
if (ql <= l && qr >= r) {
seg[sit] += value;
lazy[sit] += value;
return;
}
push(sit);
int mid = (l + r) / 2;
add(sit << 1, ql, qr, l, mid, value);
add(sit << 1 | 1, ql, qr, mid + 1, r, value);
pull(sit);
}
int query(int sit, int ql, int qr, int l, int r) {
if (ql > r || qr < l) {
return INT_MIN;
}
if (ql <= l && qr >= r) {
return seg[sit];
}
push(sit);
int mid = (l + r) / 2;
return std::max(query(sit << 1, ql, qr, l, mid),
query(sit << 1 | 1, ql, qr, mid + 1, r));
}
void add(int ql, int qr, int value) { add(1, ql, qr, 0, MAX - 1, value); }
int query(int ql, int qr) { return query(1, ql, qr, 0, MAX - 1); }
};
int a[N], inv[N];
int dep[N];
SegSingle seg1, seg2, seg3;
SegInter segi;
void dfs(int l, int r, int cur) {
if (l > r) {
return;
}
int value = -seg3.query(l, r);
int pos = inv[value];
dep[pos] = cur;
dfs(l, pos - 1, cur + 1);
dfs(pos + 1, r, cur + 1);
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[i + n] = a[i];
inv[a[i]] = i;
}
for (int i = 1; i <= n; ++i) {
seg1.add(a[i], -i);
seg2.add(a[i], i);
seg3.add(i, -a[i]);
}
dfs(1, n, 1);
for (int i = 1; i <= n; ++i) {
segi.add(i, i, dep[i]);
}
int min = INT_MAX, pos = 0;
for (int i = 1; i <= n; ++i) {
int res = segi.query(i, i + n - 1);
if (res < min) {
min = res;
pos = i - 1;
}
int right = seg1.query(1, a[i] - 1);
if (right == INT_MIN) {
right = i + n;
} else {
right = -right;
}
segi.add(i + 1, right - 1, -1);
seg1.add(a[i], -(i + n));
seg2.add(a[i], i + n);
int left = seg2.query(1, a[i] - 1);
if (left == INT_MIN) {
segi.add(i + 1, i + n - 1, 1);
segi.add(i + n, i + n, 1);
} else {
segi.add(left + 1, i + n - 1, 1);
segi.add(i + n, i + n, segi.query(left, left) + 1);
}
}
printf("%d %d\n", min, pos);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 1e5 + 100;
long long n, k;
vector<pair<long long, long long>> sieve(long long n) {
vector<pair<long long, long long>> v;
for (long long i = 2; i * i <= n; i++)
if (n % i == 0) {
long long kk = 0;
while (n % i == 0) {
n /= i;
kk++;
}
v.push_back({i, kk});
}
if (n > 1) v.push_back({n, 1});
return v;
}
pair<long long, long long> check(long long x) {
long long u = 1, v = 1;
auto z = sieve(x);
for (auto it : z) {
it.second %= k;
if (it.second > 0) {
for (int i = 0; i < it.second; i++) u *= it.first;
for (int i = 0; i < k - it.second; i++) {
v *= it.first;
if (v > 1e5) return (make_pair(-1, -1));
}
}
}
return (make_pair(u, v));
}
void solve() {
map<long long, long long> hash;
long long res = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
pair<long long, long long> ok;
ok = check(x);
if (ok.second != -1) {
if (hash.count(ok.second)) res += hash[ok.second];
hash[ok.first]++;
}
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double Dlt = 0.97;
const int inf = 0x3f3f3f3f;
const long long INF = 1e18;
const int maxn = 100000 + 10;
const int maxm = 1000000 + 10;
const int mod = 1000000000 + 7;
int gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long read() {
char ch = getchar();
long long x = 0, f = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while ('0' <= ch && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, k;
map<vector<pair<int, int>>, int> cnt;
vector<pair<int, int>> p1, p2;
int a[maxn];
int vis[maxn + 5];
int minprime[maxn];
int prime[maxn];
void sieve(int n) {
vis[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!vis[i]) {
minprime[i] = i;
prime[++k] = i;
}
for (long long j = 1; j <= k && (long long)i * prime[j] <= n; j++) {
minprime[(long long)i * prime[j]] = prime[j];
vis[(long long)i * prime[j]] = 1;
if (!(i % prime[j])) break;
}
}
}
void divide(int x) {
if (!vis[x]) {
p1.push_back(make_pair(x, 1));
p2.push_back(make_pair(x, k - 1));
return;
}
while (x > 1) {
int t = minprime[x], u = 0;
while (x % t == 0 && x != 1) {
x /= t;
u = (u + 1) % k;
}
if (u != 0) {
p1.push_back(make_pair(t, u));
p2.push_back(make_pair(t, k - u));
}
}
}
int main() {
sieve(100000);
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
long long ans = 0;
long long res1 = 0;
for (int i = 1; i <= n; ++i) {
p1.clear();
p2.clear();
divide(a[i]);
ans += cnt[p2];
cnt[p1]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 42;
vector<pair<long long, long long>> k_factorization(long long x, long long k) {
vector<pair<long long, long long>> res;
for (long long p = 2; p * p <= x; ++p) {
long long cnt = 0;
while (x % p == 0) {
x /= p;
++cnt;
}
if (cnt % k != 0) {
res.emplace_back(p, cnt % k);
}
}
if (x != 1) {
res.emplace_back(x, 1);
}
return res;
}
vector<pair<long long, long long>> opposite(
vector<pair<long long, long long>> fact, long long k) {
vector<pair<long long, long long>> res;
for (auto el : fact) {
res.emplace_back(el.first, k - el.second);
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
map<vector<pair<long long, long long>>, long long> cnt;
for (long long i = 0; i < n; ++i) {
long long a;
cin >> a;
vector<pair<long long, long long>> fact = k_factorization(a, k);
++cnt[fact];
}
long long res = 0;
for (auto el : cnt) {
vector<pair<long long, long long>> op_fact = opposite(el.first, k);
if (op_fact != el.first) {
res += el.second * cnt[op_fact];
} else {
res += el.second * (el.second - 1);
}
}
cout << res / 2 << "\n";
cerr << 1.0 * clock() / CLOCKS_PER_SEC << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
int pri[MAXN];
void init() {
for (int i = 0; i < MAXN; i++) {
pri[i] = i;
}
for (int i = 2; i < MAXN; i++) {
if (pri[i] == i) {
for (int j = i + i; j < MAXN; j += i) {
pri[j] = min(pri[j], i);
}
}
}
}
void my_pow(long long &val, int a, int x) {
if (val == -1) {
return;
}
while (x--) {
val *= a;
if (val > MAXN) {
val = -1;
return;
}
}
}
void calc(long long a, long long &b, long long &c, int k) {
b = 1;
c = 1;
long long pre_val = 1, pre_cnt = 1;
while (a != 1) {
if (pri[a] == pre_val) {
pre_cnt++;
} else {
my_pow(b, pre_val, pre_cnt % k);
my_pow(c, pre_val, (k - pre_cnt % k) % k);
pre_val = pri[a];
pre_cnt = 1;
}
a /= pri[a];
}
my_pow(b, pre_val, pre_cnt % k);
my_pow(c, pre_val, (k - pre_cnt % k) % k);
}
int n, k, a[MAXN];
int main() {
init();
scanf("%d%d", &n, &k);
map<int, int> cnt;
long long ans = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
long long b, c;
calc(a[i], b, c, k);
if (c != -1) {
ans += cnt[c];
}
cnt[b]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<long long> v;
long long tim[100001];
bool nprime[401];
vector<long long> pr;
long long po(long long a, long long nn) {
long long res = 1;
long long aa = a;
while (nn) {
if (aa > 100000) return -1;
if (nn & 1) {
res *= aa;
if (res > 100000) return -1;
}
aa *= aa;
nn /= 2;
}
return res;
}
int main() {
for (int i = 2; i < 401; i++) {
if (!nprime[i]) {
pr.push_back(i);
for (int j = i + i; j < 401; j += i) {
nprime[j] = true;
}
}
}
scanf("%lld%lld", &n, &k);
v.resize(n);
for (int i = 0; i < n; i++) {
scanf("%lld", &v[i]);
tim[v[i]]++;
}
if (k >= 34) {
printf("%lld\n", tim[1] * (tim[1] - 1) / 2LL);
return 0;
}
long long ans = 0;
vector<long long> left;
for (int i = 0; i < n; i++) {
tim[v[i]]--;
long long sea = 1;
for (int j = 0; j < pr.size(); j++) {
long long cnt = 0;
while (!(v[i] % pr[j])) {
v[i] /= pr[j];
cnt++;
}
cnt %= k;
long long P = po(pr[j], (k - cnt) % k);
if (P == -1) {
sea = -1;
break;
}
sea *= P;
}
if (sea == -1) continue;
if (k != 2 && v[i] != 1) continue;
if (k == 2 && v[i] != 1) sea *= v[i];
if (sea > 100000) continue;
long long st = 1;
while (sea * po(st, k) <= 100000) {
if (po(st, k) < 0) break;
ans += tim[sea * po(st, k)];
st++;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
map<long long, long long> mp, anti;
void f(long long x, long long k) {
long long y = x;
long long w = 1;
long long an = 1;
for (int i = 2; i * i <= x; i++) {
if (y % i == 0) {
long long cnt = 0;
while (y % i == 0) {
y /= i;
cnt++;
}
cnt %= k;
for (long long j = 1; j <= cnt; j++) {
w *= i;
}
for (long long j = 1; j <= (k - cnt) % k; j++) {
an *= i;
if (an > 1e5) {
return;
}
}
}
}
if (y > 1) {
w *= y;
for (long long i = 1; i <= k - 1; i++) {
an *= y;
if (an > 1e5) {
return;
}
}
}
mp[w]++;
anti[w] = an;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
long long n, k;
cin >> n >> k;
a = vector<long long>(n + 1);
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) {
f(a[i], k);
}
long long ans = 0;
for (auto x : mp) {
long long w = x.first;
long long z = anti[w];
if (w < z) {
ans += x.second * mp[z];
} else if (w == z) {
ans += x.second * (x.second - 1) / 2;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int mod = 1e9 + 7;
ll binpow(ll a, ll p) {
ll res = 1;
while (p) {
if (p & 1) {
(res *= a) %= mod;
}
p >>= 1;
(a *= a) %= mod;
}
return res;
}
void solve() {
int n, k;
cin >> n >> k;
map<int, int> cnt;
vector<int> a(n);
ll ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
int m = a[i];
ll b = 1;
ll c = 1;
for (int j = 2; j * j <= m; j++) {
int cnt = 0;
while (a[i] % j == 0) {
a[i] /= j;
cnt++;
}
for (int t = 0; t < (k - (cnt % k)) % k && b < 1e5; t++) {
b *= j;
}
for (int t = 0; t < cnt % k; t++) {
c *= j;
}
}
if (a[i] > 1) {
int cnt = 1;
int j = a[i];
for (int t = 0; t < (k - (cnt % k)) % k && b < 1e5; t++) {
b *= j;
}
for (int t = 0; t < cnt % k; t++) {
c *= j;
}
}
ans += cnt[b];
cnt[c]++;
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[100005];
map<vector<pair<int, int> >, int> mt;
vector<pair<int, int> > get_vector(int x) {
vector<pair<int, int> > res;
for (int i = 2; i * i <= x; ++i)
if (x % i == 0) {
int cur = 0;
while (x % i == 0) {
++cur;
x /= i;
}
cur %= m;
if (cur > 0) res.push_back({i, cur});
}
if (x > 1 && m != 1) res.push_back({x, 1});
sort(res.begin(), res.end());
return res;
}
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
vector<pair<int, int> > v, vv;
long long res = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
v = get_vector(a[i]);
vv.clear();
for (int j = 0; j < v.size(); ++j)
vv.push_back({v[j].first, m - v[j].second});
if (mt.count(vv)) res += mt[vv];
mt[v]++;
}
cout << res << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, p[100005];
map<vector<int>, int> m;
long long ans;
int main() {
for (int i = 2; i < 100005; i++)
if (!p[i]) {
p[i] = i;
for (long long j = (long long)i * i; j < 100005; j += i) p[j] = i;
}
scanf("%d%d", &n, &k);
while (n--) {
int tmp;
scanf("%d", &tmp);
vector<pair<int, int>> v;
while (tmp != 1) {
int ta = p[tmp], tb = 0;
while (tmp % ta == 0) {
tmp /= ta;
tb++;
}
if (tb % k) v.emplace_back(ta, tb % k);
}
sort(v.begin(), v.end());
vector<int> va, vb;
for (auto& i : v) {
va.push_back(i.first * 100 + i.second);
vb.push_back(i.first * 100 + k - i.second);
}
ans += m[va];
m[vb]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ff[500005], f[500005], num[500005], isp[500005], x;
vector<int> pri[500005];
int main() {
cin >> n >> k;
f[1] = 1;
ff[1] = 1;
for (int i = (2); i <= (1e5); i++) {
if (isp[i]) continue;
for (int j = i; j <= 1e5; j += i) {
isp[j] = 1;
pri[j].push_back(i);
}
}
for (int i = (2); i <= (1e5); i++) {
int sum = 1, ss = 1;
for (int x : pri[i]) {
int y = i, b = 0;
while (y % x == 0) y /= x, b++;
b %= k;
if (!b) continue;
for (int j = (1); j <= (b); j++) sum *= x;
for (int j = (b + 1); j <= (k); j++)
if (1ll * ss * x > 1e5)
ss = 0;
else
ss *= x;
}
ff[i] = sum;
f[i] = ss;
}
long long ans = 0;
for (int i = (1); i <= (n); i++)
scanf("%d", &x), ans += num[f[x]], num[ff[x]]++;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long fexp(long long x, long long y) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans *= x;
x *= x;
if (x > 1e10 + 5) return 1e10 + 5 + 1;
y >>= 1;
}
return ans;
}
class Solution {
public:
void solve() {
vector<int> primes = {2, 3, 5, 7, 11, 13};
for (int i = 17; i * i <= 100005; i += 2) {
bool is_prime = true;
for (int j = 0; primes[j] * primes[j] <= i; ++j) {
if (i % primes[j] == 0) {
is_prime = false;
break;
}
}
if (is_prime) primes.emplace_back(i);
}
int n, k;
scanf("%d%d", &n, &k);
vector<long long> coeff = {1};
for (int i = 2; i < 100005; ++i) {
long long val = fexp(i, k);
if (val > 1e10 + 5) break;
coeff.emplace_back(val);
}
unordered_map<int, int> cnt;
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
cnt[a]++;
}
if (k <= 3) {
unordered_map<int, unordered_map<int, int>> factor;
for (const auto &p : cnt) {
int num = p.first;
for (int prime : primes) {
while (num % prime == 0) {
num /= prime;
factor[p.first][prime]++;
}
if (prime * prime >= num) break;
}
if (num != 1) factor[p.first][num]++;
}
long long ans = 0;
for (const auto &p : cnt) {
long long companion = 1;
bool ok = true;
for (const auto &q : factor[p.first]) {
long long need = fexp(q.first, (k - q.second % k) % k);
if (need > 100005) {
ok = false;
break;
}
companion *= need;
if (companion > 100005) {
ok = false;
break;
}
}
if (ok) {
for (long long i : coeff) {
long long val = companion * i;
if (val > p.first) break;
if (cnt.find(val) != cnt.end()) {
long long num = (long long)cnt[val] * p.second;
if (val == p.first)
num = (long long)cnt[val] * (cnt[val] - 1) / 2;
ans += num;
}
}
}
}
printf("%lld", ans);
return;
}
long long ans = 0;
for (const auto &p : cnt) {
for (long long i : coeff) {
if (i % p.first == 0) {
long long val = i / p.first;
if (val > p.first) break;
if (cnt.find(val) != cnt.end()) {
long long num = (long long)cnt[val] * p.second;
if (val == p.first) num = (long long)cnt[val] * (cnt[val] - 1) / 2;
ans += num;
}
}
}
}
printf("%lld", ans);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
Solution solution = Solution();
solution.solve();
}
|
#include <bits/stdc++.h>
using i64 = long long;
int main() {
int n, k;
scanf("%d%d", &n, &k);
std::vector<i64> v;
for (i64 i = 1, inf = 100000000; i < inf; i++) {
i64 t = 1;
for (int j = 0; j < k; j++) {
t = t * i;
if (t > 10000000000) {
i = inf;
goto brk;
}
}
v.push_back(t);
brk:;
}
std::map<i64, i64> cnt;
for (int i = 0; i < n; i++) {
i64 in;
scanf("%lld", &in);
int j = std::upper_bound(v.begin(), v.end(), in) - v.begin() - 1;
for (; j >= 0; j--) {
if (in % v[j]) continue;
in /= v[j];
break;
}
cnt[in]++;
}
i64 ret = 0;
if (k == 2) {
for (const auto [m, c] : cnt) {
ret += c * (c - 1);
}
} else {
for (const auto [mm, c] : cnt) {
i64 ot = 1, m = mm;
bool flg = true;
for (i64 i = 2; flg && i * i <= m; i++) {
if (m % i) continue;
int t = 0;
while (m % i == 0) {
t++;
m /= i;
}
for (int j = t; j < k; j++) {
ot *= i;
if (ot > 100000) {
flg = false;
break;
}
}
}
if (m > 1) {
for (int j = 1; j < k; j++) {
ot *= m;
if (ot > 100000) {
flg = false;
break;
}
}
}
if (!flg) continue;
if (ot == mm) {
ret += c * (c - 1);
} else {
auto it = cnt.find(ot);
if (it != cnt.end()) ret += c * it->second;
}
}
}
printf("%lld\n", ret / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10, M = 1 << 20 | 10;
const int mod = 1e9 + 7;
int n, m;
long long ans, x, y, z;
map<int, int> mp;
int main() {
scanf("%d%d", &n, &m);
int cant = 0;
while (pow(++cant, m) < 1e10 + 0.5)
;
cant--;
for (int i = 1, j, cnt; i <= n; i++) {
scanf("%lld", &x);
y = 1;
z = 1;
for (j = 2; j * j <= x; j++)
if (x % j == 0) {
cnt = 0;
while (x % j == 0) x /= j, cnt++;
cnt %= m;
if (j > cant) x = y = z = 0;
for (int k = cnt; k--;) y *= j;
for (int k = (m - cnt) % m; k--;) z *= j;
}
if (x > 1) {
j = x;
cnt = 0;
while (x % j == 0) x /= j, cnt++;
cnt %= m;
if (j > cant) x = y = z = 0;
for (int k = cnt; k--;) y *= j;
for (int k = (m - cnt) % m; k--;) z *= j;
}
if (x == 1) {
if (mp.count(z)) ans += mp[z];
mp[y]++;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
inline void print(int n) {
if (n == 0) {
putchar('0');
putchar('\n');
} else if (n == -1) {
putchar('-');
putchar('1');
putchar('\n');
} else {
char buf[11];
buf[10] = '\n';
int i = 9;
while (n) {
buf[i--] = n % 10 + '0';
n /= 10;
}
while (buf[i] != '\n') putchar(buf[++i]);
}
}
int read() {
int cc = getc(stdin);
for (; cc < '0' || cc > '9';) cc = getc(stdin);
int ret = 0;
for (; cc >= '0' && cc <= '9';) {
ret = ret * 10 + cc - '0';
cc = getc(stdin);
}
return ret;
}
long long power(long long num, long long g) {
if (g == 0) return 1;
if (g % 2 == 1) return (num * power((num * num), g / 2));
return power((num * num), g / 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k;
cin >> n >> k;
map<long long, long long> mp1;
long long ans = 0;
for (int i = 0; i < n; i++) {
long long g;
cin >> g;
long long h = 1, r = 1;
for (long long j = 2; j <= sqrt(g); j++) {
if (g % j == 0) {
long long f = 0;
while (g % j == 0) g /= j, f++;
f %= k;
r *= power(j, f);
f = k - f;
f %= k;
for (int q = 0; q < f; q++) {
if (h > 10000000000LL) break;
h *= j;
}
}
}
if (g > 1) {
for (int j = 0; j < k - 1; j++) {
if (h > 10000000000LL) break;
h *= g;
}
r *= g;
}
if (mp1.find(h) != mp1.end()) {
ans += mp1[h];
}
if (h > 10000000000LL)
continue;
else if (mp1.find(r) == mp1.end())
mp1[r] = 1;
else
mp1[r]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100100];
bool notp[100100];
vector<int> p;
vector<pair<int, int> > pc[100100];
long long AAA[100100];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 2; i < 100100; ++i) {
if (notp[i]) {
continue;
}
p.push_back(i);
if (i > 1000) {
continue;
}
for (int j = i * i; j < 100100; j += i) {
notp[j] = true;
}
}
int n = 100000, k = 2;
cin >> n >> k;
long long ans = 0;
map<long long, int> m;
for (int q = 0; q < (int)(n); ++q) {
int a = 30030;
cin >> a;
int aaa = a;
vector<pair<int, int> > v;
if (pc[a].size() == 0) {
for (auto x : p) {
if (x * x > a) {
break;
}
if (a % x) {
continue;
}
int cnt = 0;
while (a % x == 0) {
a /= x;
cnt++;
}
cnt %= k;
if (cnt) {
v.push_back(make_pair(x, cnt));
}
}
if (a > 1) {
v.push_back(make_pair(a, 1));
}
pc[aaa] = v;
} else {
v = pc[a];
}
long long A = 1;
for (auto x : v) {
for (int i = 0; i < (int)(k - x.second); ++i) {
A *= x.first;
if (A > 100000) {
break;
}
}
if (A > 100000) {
break;
}
}
ans += m[A];
A = 1;
for (auto x : v) {
for (int i = 0; i < (int)(x.second); ++i) {
A *= x.first;
}
}
m[A]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long prim[100009];
long long db[100009];
long long volt[100009];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (long long i = 2; i <= 100000; i++) {
if (prim[i] == 0) {
for (long long j = i; j <= 100000; j += i) {
if (prim[j] == 0) prim[j] = i;
}
}
}
long long ans = 0;
for (int u = 1; u <= n; u++) {
long long x;
cin >> x;
long long ez = 1;
long long kell = 1;
while (x > 1) {
long long p = prim[x];
int db = 0;
while (x % p == 0) {
db++;
x /= p;
}
db %= k;
if (db > 0) {
for (int i = 1; i <= db; i++) {
ez *= p;
}
for (int i = 1; i <= k - db; i++) {
kell *= p;
kell = min(kell, 100001LL);
}
}
}
ans += volt[kell];
volt[ez]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, M, K, a, b, c, t, tt, ans, P;
long long num[100007], cnt[100007];
int main() {
scanf("%I64d%I64d", &N, &K);
long long ans = 0;
if (K == 2) {
for (int i = 1; i <= N; i++) {
scanf("%I64d", &a);
for (long long j = 2; j * j <= a; j++)
while (a % (j * j) == 0) a /= j * j;
cnt[a]++;
}
for (int i = 1; i <= 100000; i++) ans += cnt[i] * (cnt[i] - 1) / 2;
} else {
for (int i = 1; i <= N; i++) {
scanf("%I64d", &a);
cnt[a]++;
}
for (int i = 1; i <= 100001; i++) {
long long ji = 1;
for (int j = 1; j <= K; j++) {
ji *= i;
if (ji > 1e10) break;
}
num[i] = ji;
if (ji > 1e10) {
t = i - 1;
break;
}
}
for (int i = 1; i <= t; i++) {
for (long long j = 1; j * j <= num[i]; j++)
if (num[i] % j == 0) {
if (j * j < num[i] && num[i] / j <= 100000)
ans += cnt[j] * cnt[num[i] / j];
else if (j * j == num[i])
ans += cnt[j] * (cnt[j] - 1) / 2;
}
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long n, k, a[N];
map<long long, long long> cnt;
long long w[N], ans;
long long qpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a;
b >>= 1;
a = a * a;
}
return r;
}
int32_t main() {
cin >> n >> k;
for (long long i = 1; i <= n; ++i) cin >> a[i];
long long LIM = 0;
if (k > 40)
LIM = 1;
else {
while (qpow(LIM, k) <= 1e10) ++LIM;
}
if (k > 2) {
for (long long i = 1; i <= LIM; ++i) w[i] = qpow(i, k);
for (long long i = 1; i <= n; ++i) {
for (long long j = 1; j <= LIM; ++j)
if (w[j] % a[i] == 0) ans += cnt[w[j] / a[i]];
cnt[a[i]]++;
}
} else {
for (long long i = 1; i <= n; ++i) {
long long x = a[i], w = 1;
for (long long j = 2; j * j <= x; ++j)
if (x % j == 0) {
long long c = 0;
while (x % j == 0) x /= j, c++;
if (c & 1) w *= j;
}
if (x > 1) w *= x;
ans += cnt[w];
cnt[w]++;
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100000];
map<long long int, int> M;
int main() {
int i;
int n, k;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) scanf("%d", &a[i]);
int j, kk;
long long int ans = 0;
for (i = 0; i < n; i++) {
vector<pair<int, int> > v;
for (j = 2; j * j <= a[i]; j++) {
if ((a[i] % j) == 0) {
int c = 0;
while ((a[i] % j) == 0) a[i] /= j, c++;
v.push_back(make_pair(j, c));
}
}
if (a[i] > 1) v.push_back(make_pair(a[i], 1));
int p = 1;
long long int p2 = 1;
for (j = 0; j < v.size(); j++) {
int x = v[j].second % k;
for (kk = 0; kk < x; kk++) p *= v[j].first;
x = (k - x) % k;
for (kk = 0; kk < x; kk++) {
if (p2 > 1e9) break;
p2 *= v[j].first;
}
}
ans += M[p2];
M[p]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mark[100005];
void build_seive() {
for (int i = 1; i <= 100000; i++) mark[i] = i;
for (int i = 2; i <= 100000; i += 2) mark[i] = 2;
for (int i = 3; i * i <= 100000; i++)
if (mark[i] == i)
for (int j = i * i; j <= 100000; j += i)
if (mark[j] == j) mark[j] = i;
}
int M[100005];
vector<pair<int, int> > f(int val) {
vector<pair<int, int> > arr;
int cnt = 0, pre = -1;
while (val > 1) {
if (pre != -1 && mark[val] != pre) {
arr.push_back({pre, cnt});
cnt = 0;
}
pre = mark[val];
cnt++;
val /= mark[val];
}
if (pre != -1) arr.push_back({pre, cnt});
return arr;
}
int a[100005];
int add(vector<pair<int, int> > a, int k) {
long long val = 1;
for (pair<int, int> u : a) {
int num = (k - u.second % k) % k;
for (int j = 1; j <= num; j++) {
if (1LL * val * u.first > 1e5) return -1;
val *= u.first;
}
}
return val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
build_seive();
int n, k;
cin >> n >> k;
long long res = 0;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
int x = a[i];
vector<pair<int, int> > a = f(x);
int x_new = 1;
for (pair<int, int> u : a) {
int num = u.second % k;
for (int j = 1; j <= num; j++) x_new *= u.first;
}
int val = add(a, k);
if (val != -1) res += M[val];
M[x_new]++;
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pf[2000005];
long long n, k;
long long conv(long long n) {
map<long long, long long> X;
while (pf[n] != 0) {
X[pf[n]]++;
X[pf[n]] %= k;
n /= pf[n];
}
long long ans = 1;
for (auto it : X) {
if (it.second == 0) continue;
for (long long i = 0; i < k - it.second; i++) {
ans *= it.first;
if (ans > 100000) return -1;
}
}
return ans;
}
long long con(long long n) {
map<long long, long long> X;
while (pf[n] != 0) {
X[pf[n]]++;
X[pf[n]] %= k;
n /= pf[n];
}
long long ans = 1;
for (auto it : X) {
if (it.second == 0) continue;
for (long long i = 0; i < it.second; i++) {
ans *= it.first;
if (ans > 100000) return -1;
}
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 2; i < 200000; i++) {
if (pf[i] == 0) {
for (long long j = i; j < 200000; j += i) {
if (pf[j] == 0) pf[j] = i;
}
}
}
long long A[n];
for (long long i = 0; i < n; i++) {
cin >> A[i];
}
map<long long, long long> ss;
long long u = con(A[0]);
ss[u]++;
long long cnt = 0;
for (long long i = 1; i < n; i++) {
long long a = A[i];
long long b = conv(a);
a = con(a);
auto it = ss.find(b);
if (it != ss.end()) {
cnt += it->second;
}
ss[a]++;
}
cout << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct outputer;
struct outputable {};
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T1, typename T2>
inline bool umx(T1& a, T2 b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T1, typename T2>
inline bool umn(T1& a, T2 b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
const int N = 100000;
const int X = 100000;
struct Input {
int n, m;
int a[N];
bool read() {
if (!(cin >> n >> m)) {
return 0;
}
for (int i = int(0); i < int(n); ++i) {
scanf("%d", &a[i]);
}
return 1;
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
int64_t ans;
void write() { cout << ans << endl; }
};
namespace Main {
struct Solution : Data {
int p[X + 1];
int64_t q[X + 1], r[X + 1];
int64_t calc_q(int i) {
if (i < 2) {
return i;
}
int t = p[i];
int cnt = 0;
while (i % t == 0) {
cnt++;
i /= t;
}
int64_t res = calc_q(i);
for (int j = int(0); j < int(cnt % m); ++j) {
res *= t;
}
return res;
}
int64_t calc_r(int i) {
if (i < 2) {
return i;
}
int t = p[i];
int cnt = 0;
while (i % t == 0) {
cnt++;
i /= t;
}
int64_t res = calc_r(i);
for (int j = int(0); j < int((m - cnt % m) % m); ++j) {
res *= t;
if (res > X) {
return 0;
}
}
return res;
}
map<int64_t, int> cnt_q;
void solve() {
memset(p, 0, sizeof p);
p[0] = p[1] = -1;
for (int i = int(0); i < int(X + 1); ++i) {
if (!p[i]) {
for (int j = i; j <= X; j += i) {
p[j] = i;
}
}
q[i] = calc_q(i);
r[i] = calc_r(i);
};
;
ans = 0;
for (int i = int(0); i < int(n); ++i) {
;
ans += cnt_q[r[a[i]]];
cnt_q[q[a[i]]]++;
}
}
void clear() { *this = Solution(); }
};
} // namespace Main
Main::Solution sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
sol.read();
sol.solve();
sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
char c = getchar();
long long x = 0;
bool f = 0;
for (; !isdigit(c); c = getchar()) f ^= !(c ^ 45);
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
return x;
}
long long n, k;
long long mp[100005];
inline long long work(long long x) {
long long res = 1;
for (register long long i = (2); i <= (x / i); ++i) {
if (x % i == 0) {
long long cnt = 0;
while (x % i == 0) x /= i, cnt++;
cnt %= k;
for (register long long j = (1); j <= (cnt); ++j) res *= i;
}
}
if (x > 1) res *= x;
return res;
}
inline long long rev(long long x) {
long long res = 1;
for (register long long i = (2); i <= (x / i); ++i) {
if (x % i == 0) {
long long cnt = 0;
while (x % i == 0) x /= i, cnt++;
for (register long long j = (1); j <= (k - cnt); ++j) {
res *= i;
if (res > 100000) return -1;
}
}
}
if (x > 1) {
for (register long long j = (1); j <= (k - 1); ++j) {
res *= x;
if (res > 100000) return -1;
}
}
return res;
}
signed main() {
n = read(), k = read();
for (register long long i = (1); i <= (n); ++i) {
long long x = read();
x = work(x);
mp[x]++;
}
long long res = 0;
for (register long long i = (1); i <= (100000); ++i)
if (mp[i]) {
long long j = rev(i);
if (j != -1) {
if (j == i)
res += 1ll * mp[i] * (mp[i] - 1) / 2;
else
res += mp[i] * mp[j];
mp[i] = mp[j] = 0;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const long long inf = 1e17;
long long a[100006];
map<long long, long long> fac(long long x) {
map<long long, long long> res;
for (long long i = 2; i * i <= x; i++) {
while (x % i == 0) {
x /= i;
res[i]++;
}
}
if (x > 1) res[x] = 1;
return res;
}
signed main() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) cin >> a[i];
map<long long, long long> M1, M2;
for (long long i = 0; i < n; i++) {
long long ans = 1, p = 1;
map<long long, long long> M = fac(a[i]);
for (auto itr = M.begin(); itr != M.end(); itr++) {
M[itr->first] %= k;
for (long long j = 0; j < itr->second; j++) ans *= itr->first;
for (long long j = 0; j < (k - itr->second) % k; j++) {
if (p > 100000)
p = 0;
else
p *= itr->first;
}
}
M1[ans]++;
M2[ans] = p;
}
long long res = 0;
for (auto itr = M1.begin(); itr != M1.end(); itr++) {
if (itr->first < M2[itr->first]) {
res += (itr->second) * M1[M2[itr->first]];
} else if (itr->first == M2[itr->first]) {
res += (itr->second) * (itr->second - 1) / 2;
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long gi() {
long long f = 1, sum = 0;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
sum = (sum << 3) + (sum << 1) + ch - '0';
ch = getchar();
}
return f * sum;
}
const long long N = 100010, Inf = 1e10, LIM = 1e5;
long long n, k, t[N], mx, X, ans;
long long qpow(long long a, long long b) {
long long ret = 1;
for (long long i = 1; i <= b; i++) {
if (ret * a > Inf) return -1;
ret *= a;
}
return ret;
}
vector<long long> vec;
void dfs(long long x, long long dep) {
if (x > LIM) return;
if (x > X / x) return;
if (x == X / x)
ans += 1ll * t[x] * (t[x] - 1) / 2;
else if (X / x <= LIM)
ans += t[x] * t[X / x];
for (long long i = dep; i < vec.size(); i++) {
long long T = vec[i], s = x * T;
for (; X % s == 0; s *= T) dfs(s, i + 1);
}
}
signed main() {
n = gi();
k = gi();
for (long long i = 1; i <= n; i++) t[gi()]++;
for (long long i = 1; i <= LIM; i++) {
X = qpow(i, k);
if (X == -1) continue;
vec.clear();
long long y = i;
for (long long j = 2; j * j <= y; j++)
if (!(y % j)) {
vec.push_back(j);
while (!(y % j)) y /= j;
}
if (y != 1) vec.push_back(y);
dfs(1, 0);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Pi = pair<int, int>;
using ll = long long;
string to_string(string s) { return s; }
template <class T>
string to_string(vector<T> v);
template <class S, class T>
string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
template <class S>
string to_string(unordered_set<S> s) {
string ret = "{";
for (S x : s) ret += to_string(x) + ",";
return ret + "}";
}
template <class S, class T>
string to_string(map<S, T> m) {
string ret = "{";
for (pair<S, T> x : m) ret += to_string(x) + ",";
return ret + "}";
}
template <class T>
string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < (int)v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail>
void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int n, k;
vector<Pi> dec(int n) {
map<int, int> ret;
for (int i = 2; i * i <= n; i++) {
while (n % i == 0) {
ret[i]++;
n /= i;
}
}
if (n != 1) ret[n] = 1;
vector<Pi> ret2;
for (Pi p : ret) {
if (p.second % k > 0) ret2.push_back(Pi(p.first, p.second % k));
}
sort((ret2).begin(), (ret2).end());
return ret2;
}
int main() {
cin.tie(0);
cin >> n >> k;
map<vector<Pi>, int> mp;
vector<int> a(n);
for (int i = 0; i < (int)n; i++) {
cin >> a[i];
mp[dec(a[i])]++;
}
ll ans = 0;
set<vector<Pi>> s;
for (pair<vector<Pi>, int> p : mp) {
if (s.count(p.first)) continue;
bool f = 0;
for (int i = 0; i < (int)p.first.size(); ++i) {
if (p.first[i].second * 2 != k) f = 1;
p.first[i].second = k - p.first[i].second;
}
if (f)
ans += p.second * (ll)mp[p.first];
else
ans += p.second * (ll)(p.second - 1) / 2;
s.insert(p.first);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int N = 500031;
int pr[N];
map<vector<pair<int, int> >, int> CNT;
int n, k;
vector<pair<int, int> > order, need;
long long ans;
int main() {
ios_base::sync_with_stdio(0);
pr[1] = 1;
for (int i = 2; i <= 100000; i++) {
if (pr[i] == 0)
for (int j = i; j <= 100000; j += i) {
pr[j] = i;
}
}
cin >> n >> k;
for (int i = 1; i <= n; i++) {
int val;
cin >> val;
order.clear();
while (val > 1) {
int x = pr[val];
int cnt = 0;
while (val % x == 0) {
cnt++;
val /= x;
}
if (cnt % k) order.push_back(make_pair(x, cnt % k));
}
sort(order.begin(), order.end());
need = order;
for (int j = 0; j < need.size(); j++) {
need[j].second = (k - need[j].second) % k;
}
ans += CNT[need];
CNT[order]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 7;
const int INF = 1e9;
const long long INFF = 1e18;
map<vector<pair<int, int> >, int> M;
int main() {
int n, k, x;
long long ans = 0;
cin >> n >> k;
for (int i = 1; i <= n; i++) {
vector<pair<int, int> > v1, v2;
cin >> x;
for (int j = 2; j * j <= x; j++) {
if (x % j == 0) {
int cnt = 0;
while (x % j == 0) {
x /= j;
cnt++;
}
if (cnt % k != 0) v1.push_back(make_pair(j, cnt % k));
}
}
if (x > 1) v1.push_back(make_pair(x, 1));
for (int j = 0; j < v1.size(); j++)
v2.push_back(make_pair(v1[j].first, k - v1[j].second));
ans += M[v2];
M[v1]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, k;
long long a[100005], v[100005];
long long ans;
vector<long long> ve;
int main() {
n = read();
k = read();
for (int i = 1; i <= n; i++) {
a[i] = read();
v[a[i]]++;
}
for (int i = 1; i <= 100000; i++) {
long long x = i;
for (int j = 1; j < k; j++) {
x = x * i;
if (x > 10000000000LL) break;
}
if (x <= 10000000000LL)
ve.push_back(x);
else
break;
}
if (k >= 3) {
for (int i = 1; i <= 100000; i++)
if (v[i])
for (int j = 0; j < ve.size() && ve[j] / i <= 100000; j++)
if (ve[j] % i == 0) {
int t = ve[j] / i;
if (t < i) continue;
if (i == t)
ans += v[i] * (v[i] - 1) / 2;
else
ans += v[i] * v[t];
}
} else {
for (int i = 1; i <= 100000; i++)
if (v[i]) {
long long x = i;
for (int j = 2; j <= 400; j++)
while (x % (j * j) == 0) x /= (j * j);
for (int j = 0; j < ve.size() && ve[j] * x <= 100000; j++) {
int t = ve[j] * x;
if (t < i) continue;
if (i == t)
ans += v[i] * (v[i] - 1) / 2;
else
ans += v[i] * v[t];
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 11;
int n;
long long k;
long long a[N];
long long b[N];
long long c[N];
long long prost[N];
long long imam[N];
long long res;
bool prosti(int x) {
if (x == 1) return 0;
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) return 0;
}
return 1;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
b[i] = 1;
c[i] = 1;
}
for (int i = 1; i < N; i++) {
prost[i] = prosti(i);
}
for (int i = 0; i < n; i++) {
int kor = sqrt(a[i]);
for (int j = 1; j <= kor; j++) {
long long sada = a[i];
if (a[i] % j == 0) {
long long p1 = j;
long long p2 = a[i] / j;
int br = 0;
if (prost[p1]) {
while (a[i] % p1 == 0) {
br++;
a[i] /= p1;
}
}
br %= k;
for (int l = 0; l < br; l++) b[i] *= p1;
if (br > 0) c[i] *= p1;
br = 0;
if (prost[p2]) {
while (a[i] % p2 == 0) {
br++;
a[i] /= p2;
}
}
br %= k;
for (int l = 0; l < br; l++) b[i] *= p2;
if (br > 0) c[i] *= p2;
}
a[i] = sada;
}
long long ci = c[i];
for (int l = 0; l < k - 1; l++) {
c[i] *= ci;
if (c[i] > 1e10) {
c[i] = -1;
break;
}
}
if (c[i] == -1) {
imam[b[i]]++;
continue;
}
c[i] /= b[i];
if (c[i] <= 1e5) res += imam[c[i]];
imam[b[i]]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool get_int(T &x) {
char t = getchar();
bool neg = false;
x = 0;
for (; (t > '9' || t < '0') && t != '-' && t != EOF; t = getchar())
;
if (t == '-') neg = true, t = getchar();
if (t == EOF) return false;
for (; t <= '9' && t >= '0'; t = getchar()) x = x * 10 + t - '0';
if (neg) x = -x;
return true;
}
template <typename T>
void print_int(T x) {
if (x < 0) putchar('-'), x = -x;
short a[20] = {}, sz = 0;
while (x > 0) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
const int inf = 0x3f3f3f3f;
const long long Linf = 1ll << 61;
const double pi = acos(-1.0);
const int maxn = 100111;
int n, k, a[maxn], cnt[maxn];
vector<int> dv[maxn];
int main() {
(get_int(n) && get_int(k));
for (int i = 1; i <= n; i++) get_int(a[i]);
for (int i = 2; i < maxn; i++)
if ((int)dv[i].size() == 0) {
for (int j = i; j < maxn; j += i) dv[j].push_back(i);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long need = 1, is = 1;
for (auto v : dv[a[i]]) {
int cnt = 0, tmp = a[i];
while (tmp % v == 0) {
cnt++;
tmp /= v;
}
cnt %= k;
for (int j = 0; j < cnt; j++) is *= v;
if (k > 40)
need = maxn - 1;
else if (cnt) {
for (int j = 0; j < k - cnt; j++) need = min(maxn - 1ll, need * v);
}
}
ans += cnt[need];
cnt[is]++;
}
print_int(ans), puts("");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void read(T &ret) {
T x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
ret = x * f;
}
const int N = 1e5 + 10;
const long long B = 6907, Z = 1e9 + 7;
int idx[N], lim;
long long pn[N];
void init() {
static bool flg[N];
memset(flg, 0, sizeof(flg));
int sz = 0;
for (int i = 2; i <= lim; i++)
if (!flg[i]) {
idx[i] = ++sz;
for (int j = 2; i * j <= lim; j++) flg[i * j] = 1;
}
pn[0] = 1;
for (long long i = (1); i <= (sz); i++) pn[i] = pn[i - 1] * B % Z;
}
void factor(int x, int k, int *p, int *cnt, int &sz, bool &flg) {
sz = 0;
for (int i = 2; i * i <= x; i++)
if (x % i == 0) {
int cur = 0;
for (; x % i == 0; x /= i) cur++;
cur %= k;
if (cur) p[++sz] = i, cnt[sz] = cur;
}
if (x != 1) p[++sz] = x, cnt[sz] = 1;
if (p[sz] > lim) flg = 1;
}
long long hash_v(int sz, int *p, int *cnt) {
long long ret = 0;
for (long long i = (1); i <= (sz); i++)
(ret += cnt[i] * pn[idx[p[i]] - 1]) %= Z;
return ret;
}
int sz[N], p[N][20], cnt[N][20];
bool flg[N];
int n, k;
void solv() {
long long ans = 0;
map<long long, int> mp;
for (long long i = (1); i <= (n); i++) {
if (flg[i]) continue;
long long cur_v = hash_v(sz[i], p[i], cnt[i]);
for (long long j = (1); j <= (sz[i]); j++) cnt[i][j] = (k - cnt[i][j]) % k;
long long rev_v = hash_v(sz[i], p[i], cnt[i]);
ans += mp[rev_v];
mp[cur_v] += 1;
}
cout << ans;
}
int main() {
read(n);
read(k);
lim = ceil(pow(1e5, 1.0 / int(ceil(k / 2.0))));
init();
for (long long i = (1); i <= (n); i++) {
int x;
read(x);
factor(x, k, p[i], cnt[i], sz[i], flg[i]);
}
solv();
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N], n, k, b[N];
vector<long long> v;
bool vis[N];
inline long long po(int x, int y) {
long long r = 1;
while (y--) r *= x;
return r;
}
int main() {
scanf("%d%d", &n, &k);
int m = 0;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]), ++b[a[i]], m = max(m, a[i]);
if (k == 2) {
for (int i = 1; i <= n; ++i)
for (int j = 2; j * j <= a[i]; ++j) {
if (a[i] % j == 0) {
int c = 0;
while (a[i] % j == 0) a[i] /= j, ++c;
if (c & 1) a[i] *= j;
}
}
sort(a + 1, a + 1 + n);
long long ans = 0, tmp = 1;
for (int i = 2; i <= n; ++i) {
if (a[i] == a[i - 1])
++tmp;
else
ans += tmp * (tmp - 1) / 2, tmp = 1;
}
ans += tmp * (tmp - 1) / 2, tmp = 1;
printf("%lld", ans);
return 0;
}
long long ans = 0;
if (k > 35) {
int x = 0;
for (int i = 1; i <= n; ++i) x += (a[i] == 1);
printf("%lld", 1ll * x * (x - 1) / 2);
return 0;
}
for (int i = 1; po(i, k) <= 10000000000ll; ++i) v.push_back(po(i, k));
for (int i = 1; i <= n; ++i)
for (auto x : v) {
if (x / a[i] > m) break;
if (x % a[i] == 0) {
if (x / a[i] == a[i]) {
if (!vis[a[i]])
vis[a[i]] = true, ans += 1ll * b[x / a[i]] * (b[x / a[i]] - 1);
} else
ans += b[x / a[i]];
}
}
printf("%lld", ans >> 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
const int N = 2E5 + 100;
map<vector<pair<int, int>>, int> M;
int a[N], pr[N];
vector<int> primes;
vector<pair<int, int>> get_fac(int t) {
vector<pair<int, int>> ret;
for (int p : primes) {
if (p * p > t) break;
int cnt = 0;
while (t % p == 0) {
t /= p;
cnt++;
}
ret.emplace_back(p, cnt);
}
if (t > 1) ret.emplace_back(t, 1);
return ret;
}
int main() {
fill(pr + 2, pr + N, 1);
for (int i = 2; i < N; ++i) {
if (pr[i] == 0) continue;
for (int j = i + i; j < N; j += i) pr[j] = 0;
primes.push_back(i);
}
int n, m;
cin >> n >> m;
LL ans = 0;
for (decay<decltype(n + 1)>::type i = (1), _i = (n + 1); i < _i; ++i) {
scanf("%d", &a[i]);
vector<pair<int, int>> fac = get_fac(a[i]);
vector<pair<int, int>> now, complement;
for (auto p : fac) {
int cnt = p.second % m;
if (cnt) {
now.emplace_back(p.first, cnt);
;
complement.emplace_back(p.first, m - cnt);
}
}
ans += M[complement];
M[now]++;
;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
char sl = '\n';
int power(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = ret * a;
a = a * a;
b >>= 1;
}
return ret;
}
int ans[100001 + 1];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, k;
cin >> n >> k;
long long ans1(0);
while (n--) {
int x;
map<int, int> tmp;
cin >> x;
for (int i = 2; i * i <= x; ++i) {
while (!(x % i)) {
tmp[i]++;
tmp[i] %= k;
x /= i;
}
}
if (x > 1) tmp[x]++;
long long number = 1LL;
long long other = 1LL;
for (auto i : tmp) {
if (i.second) {
number = number * power(i.first, i.second);
for (int j = 0; j < (k - i.second) && other <= (1LL * 100001 + 1); j++)
other *= i.first;
}
}
if (other < 100001) ans1 += ans[other];
ans[number]++;
}
cout << ans1 << sl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, K;
int a[100111];
long long po[100111];
bool vis[100111];
int p[100111], pcnt, cc[100111];
map<int, int> cnt;
int main() {
scanf("%d", &n);
scanf("%d", &K);
for (int i = 2; i < 100111; i++) {
if (!vis[i]) p[++pcnt] = i;
for (int j = 1, k; (k = i * p[j]) < 100111; j++) {
vis[k] = 1;
if (i % p[j] == 0) break;
}
}
for (int i = 1; i <= int(1e5 + 5); i++) {
po[i] = 1;
if (po[i - 1] > 1e13)
po[i] = po[i - 1];
else
for (int k = 1; k <= K; k++) {
po[i] *= i;
if (po[i] > 1e13) break;
}
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
for (int j = 2; po[j] <= a[i]; j++) {
while (a[i] % po[j] == 0) a[i] /= int(po[j]);
}
long long co = 1, cura = a[i];
for (int j = 2; co != -1 && j * j <= cura; j++)
if (!vis[j]) {
if (a[i] % j == 0) {
long long q = j;
while (a[i] % q == 0) q *= j;
q /= j;
cura /= q;
if ((double)co * po[j] / q > 100111)
co = -1;
else
co *= po[j] / q;
}
}
if (co > 0 && cura > 1) {
if ((double)co * po[cura] / cura > 100111)
co = -1;
else
co *= po[cura] / cura;
}
if (co > 0 && co < 100111) {
cc[i] = co;
}
}
long long ans = 0;
for (int i = n; i; i--) {
if (cc[i] > 0) ans += cnt[cc[i]];
cnt[a[i]]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
vector<long long> vec(n);
for (long long i = 0; i < n; ++i) cin >> vec[i];
map<vector<long long>, long long> ez;
vector<vector<long long> > mn_vec(n), nd(n), mn2(n);
vector<map<long long, long long> > rly(n);
for (long long i = 0; i < n; ++i) {
vector<long long> mn;
long long ch = vec[i];
for (long long q = 2; q * q <= ch; ++q) {
while (ch % q == 0) {
mn.push_back(q);
rly[i][q]++;
ch /= q;
}
}
if (ch != 1) mn.push_back(ch), rly[i][ch]++;
mn2[i] = mn;
}
long long ans = 0;
for (long long i = 0; i < n; ++i) {
vector<long long> cr, need;
for (long long j = 0; j < mn2[i].size(); ++j) rly[i][mn2[i][j]] %= k;
for (long long j = 0; j < mn2[i].size(); ++j) {
long long help = (k - rly[i][mn2[i][j]]) % k;
while (rly[i][mn2[i][j]] != 0) {
cr.push_back(mn2[i][j]);
--rly[i][mn2[i][j]];
}
while (help != 0) {
need.push_back(mn2[i][j]);
--help;
}
}
mn_vec[i] = cr;
nd[i] = need;
ez[cr]++;
}
for (long long i = 0; i < n; ++i) {
if (ez[nd[i]] == 0) continue;
if (nd[i] == mn_vec[i])
ans += ez[nd[i]] - 1;
else
ans += ez[nd[i]];
ez[mn_vec[i]]--;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k;
long long a[100005], cnt[100005], mcnt[100005];
map<long long, long long> mp[100005];
bool prime[1005];
vector<long long> pvec;
int main(void) {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i < 1005; i++) {
if (prime[i]) continue;
for (int j = 2 * i; j < 1005; j += i) prime[j] = true;
}
for (int i = 2; i < 1005; i++)
if (!prime[i]) pvec.push_back(i);
for (int i = 1; i <= n; i++) {
long long t = a[i];
for (int j = 0; j < pvec.size(); j++) {
long long p = pvec[j];
while (t % p == 0) {
mp[i][p]++;
t /= p;
}
}
if (t > 1) mp[i][t]++;
}
for (int i = 1; i <= n; i++) {
long long mul = 1;
for (auto it = mp[i].begin(); it != mp[i].end(); it++) {
it->second %= k;
for (int j = 0; j < it->second; j++) mul *= it->first;
}
a[i] = mul;
if (mul < 100005) cnt[mul]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long mul = 1;
for (auto it = mp[i].begin(); it != mp[i].end(); it++) {
long long x = (k - it->second) % k;
for (int j = 0; j < x; j++) {
mul *= it->first;
if (mul >= 100005) goto end;
}
}
if (mul < 100005) ans += cnt[mul];
if (a[i] == mul) ans--;
end:;
}
cout << ans / 2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAX_A = 1e5 + 5;
int n, k;
long long ans;
std::vector<int> p;
std::unordered_map<std::string, int> map;
int main() {
for (int i = 2; i < MAX_A; ++i) {
for (int j : p)
if (j * j > i)
break;
else if (i % j == 0)
goto skip;
p.push_back(i);
skip:
continue;
}
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) {
std::string cur, neg;
int x;
scanf("%d", &x);
for (int j : p)
if (j * j > x)
break;
else if (x % j == 0) {
std::pair<int, int> cnt = {j, 0};
while (x % j == 0) {
x /= j;
++cnt.second;
}
cnt.second %= k;
if (cnt.second) {
cur += "$" + std::to_string(cnt.first) + "$" +
std::to_string(cnt.second);
neg += "$" + std::to_string(cnt.first) + "$" +
std::to_string(k - cnt.second);
}
}
if (x != 1) {
cur += "$" + std::to_string(x) + "$" + std::to_string(1);
neg += "$" + std::to_string(x) + "$" + std::to_string(k - 1);
}
if (map.count(neg)) ans += map[neg];
++map[cur];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n, m;
set<int> answers;
map<vector<pair<int, int> >, int> primesCnt;
int main() {
int n, k;
scanf("%d%d", &n, &k);
long long cntOnes = 0, x;
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
vector<pair<int, int> > currPrimes;
for (int j = 2; 1LL * j * j <= x; j++) {
int cnt = 0;
while (x % j == 0) x /= j, cnt++;
if (cnt % k) currPrimes.push_back({j, cnt % k});
}
if (x > 1) currPrimes.push_back({x, 1});
sort(currPrimes.begin(), currPrimes.end());
if (currPrimes.empty())
cntOnes++;
else
primesCnt[currPrimes]++;
}
long long ans = cntOnes * (cntOnes - 1);
for (pair<vector<pair<int, int> >, int> p : primesCnt) {
vector<pair<int, int> > res;
for (pair<int, int> pr : p.first) res.push_back({pr.first, k - pr.second});
if (res == p.first)
ans += 1LL * p.second * (p.second - 1);
else if (primesCnt.count(res))
ans += 1LL * primesCnt[res] * p.second;
}
printf("%lld", ans >> 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = (long long)1e9 + 7;
const int64_t primm = 998244353;
long long dat, n, k, a[100005], ans;
bool prr[100008];
vector<long long> pr;
vector<pair<long long, long long>> absde[100005], lom;
map<vector<pair<long long, long long>>, long long> mp;
void prime() {
prr[0] = prr[1] = true;
for (long long i = (long long)2; i < (long long)100005; i++) {
if (prr[i] == false) {
pr.push_back(i);
if (i * i < 100001)
for (long long j = i * i; j <= 100001; j += i) prr[j] = true;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k;
for (long long i = 0; i < (long long)n; i++) {
cin >> a[i];
}
prime();
long long size = pr.size();
for (long long i = 0; i < (long long)n; i++) {
long long t = a[i];
for (long long j = 0; j < (long long)size; j++) {
if (t % pr[j] == 0) {
long long ups = 0;
while (t % pr[j] == 0) {
ups++;
t /= pr[j];
}
ups %= k;
if (ups > 0) absde[i].push_back(make_pair(pr[j], ups));
}
if (pr[j] * pr[j] > a[i]) {
if (t != 1) absde[i].push_back(make_pair(t, 1));
break;
}
}
if (!absde[i].empty()) {
lom = absde[i];
long long sizelom = lom.size();
for (long long j = 0; j < (long long)sizelom; j++) {
lom[j].second = k - lom[j].second;
}
ans += mp[lom];
mp[absde[i]]++;
} else {
ans += dat;
dat++;
}
}
cout << ans << endl;
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long mp[100000 + 10];
vector<long long> vec[100000 + 10];
vector<long long> c[100000 + 10];
bool vst[100000 + 10];
long long k;
long long v[100000 + 10];
void seive() {
memset(vst, 0, sizeof(vst));
for (long long i = 1; i <= 100000; i++) v[i] = i;
for (int i = 2; i <= 100000; i++)
if (vst[i] == false) {
for (int j = i; j <= 100000; j += i) {
vst[j] = true;
long long cnt = 0;
while (v[j] % i == 0) {
cnt++;
v[j] /= i;
}
if (cnt % k) {
vec[j].push_back(i);
c[j].push_back(cnt % k);
}
}
}
}
long long calc(long long ix, int ch) {
int sz = vec[ix].size();
long long ret = 1;
for (long long i = 0; i < sz; i++) {
int cnt = c[ix][i];
if (ch) cnt = k - cnt;
while (cnt--) {
ret *= vec[ix][i];
if (ret > 100000) return -1;
}
}
return ret;
}
int main() {
long long n, a, ans = 0;
cin >> n >> k;
seive();
for (long long i = 1; i <= n; i++) {
scanf("%I64d", &a);
long long need = calc(a, true);
if (need != -1) ans += mp[need];
need = calc(a, false);
mp[need]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T t) {
return t < 0 ? -t : t;
}
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
const int MAXN = 212345;
int n, m, k;
int s[MAXN];
int prv[MAXN];
map<long long, int> cnt;
map<int, int> factor(int x) {
map<int, int> pcnt;
while (x > 1) {
pcnt[prv[x]]++;
x /= prv[x];
}
return pcnt;
}
long long expo(long long base, long long e) {
if (e == 0) return 1;
long long ans = expo(base, e / 2);
ans = ans * ans;
if (e & 1) ans = ans * base;
return ans;
}
int main() {
prv[1] = 1;
for (int a = 2; a < MAXN; a++) {
if (!prv[a])
prv[a] = a;
else
continue;
for (long long b = a; a * b < MAXN; b++) {
if (!prv[a * b]) prv[a * b] = a;
}
}
scanf("%d%d", &n, &k);
long long ans = 0;
for (int a = 0; a < n; a++) {
scanf("%d", s + a);
map<int, int> f = factor(s[a]);
long long x = 1;
long long o = 1;
for (auto it : f) {
int e = it.second % k;
x *= expo(it.first, e);
if (e) o *= expo(it.first, k - e);
}
ans += cnt[o];
cnt[x]++;
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, k, a[N], x1[N], x2[N], cnt[N];
bool mark[N];
inline void read_input() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> a[i];
}
inline void solve() {
iota(x1, x1 + N, 0);
fill(x2, x2 + N, 1);
for (int i = 2; i < N; i++)
if (!mark[i])
for (int j = i; j < N; j += i) {
int p = 0;
mark[j] = true;
while (x1[j] % i == 0) x1[j] /= i, p++;
for (int x = 0; x < p % k; x++) x1[j] *= i;
while (p++ % k) x2[j] = min(1LL * x2[j] * i, N - 1LL);
}
}
inline void write_output() {
long long ans = 0;
for (int i = 0; i < n; i++) ans += cnt[x2[a[i]]], cnt[x1[a[i]]]++;
cout << ans;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
read_input(), solve(), write_output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long BIG = 1000000000000000000LL;
void solve();
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
const long long borne = (long long)(1e5) + 5;
long long tab[borne];
long long pdiv[borne];
long long occ[borne];
long long nbElem, ex;
void spec() {
for (long long p = 2; p < borne; ++p) {
if (pdiv[p] > 0) continue;
for (long long c = 2; p * c < borne; ++c) {
pdiv[p * c] = p;
}
}
long long rep = 0;
multiset<vector<long long>> vu;
for (long long iPos = (0); iPos < (nbElem); ++iPos) {
set<long long> cur;
long long val = tab[iPos];
rep += occ[val] * (occ[val] - 1) / 2;
while (val > 1) {
long long x = pdiv[val];
if (x == 0) x = val;
val /= x;
if (cur.find(x) != cur.end())
cur.erase(x);
else
cur.insert(x);
}
vector<long long> dc;
for (long long x : cur) {
dc.push_back(x);
}
rep += occ[tab[iPos]] * vu.count(dc);
for (long long i = (0); i < (occ[tab[iPos]]); ++i) vu.insert(dc);
}
cout << rep << "\n";
}
void tout() {
long long rep = 0;
for (long long small = 1;; small++) {
long long big = 1;
for (long long i = (0); i < (ex); ++i) big *= small;
if (big > borne * borne) break;
long long lo = 0, ri = nbElem - 1;
while (lo <= ri) {
if (tab[lo] * tab[ri] == big) {
long long x = occ[tab[lo]] * occ[tab[ri]];
if (lo == ri) x = occ[tab[lo]] * (occ[tab[lo]] - 1) / 2;
rep += x;
++lo;
--ri;
} else if (tab[lo] * tab[ri] < big)
++lo;
else
--ri;
}
}
cout << rep << "\n";
}
void solve() {
cin >> nbElem >> ex;
set<long long> wo;
for (long long i = (0); i < (nbElem); ++i) {
long long x;
cin >> x;
wo.insert(x);
occ[x]++;
}
nbElem = wo.size();
long long indPos = 0;
for (long long x : wo) tab[indPos++] = x;
if (ex == 2)
spec();
else
tout();
}
|
#include <bits/stdc++.h>
using namespace std;
const int mval = 100050;
bool isprime[mval + 1];
void upd_pow(long long &v, int a, int b) {
if (v > mval) {
v = 0;
return;
}
while (b--) {
v *= a;
if (v > mval) {
v = 0;
return;
}
}
}
int main() {
isprime[0] = isprime[1] = false;
for (int i = 2; i <= mval; i++) isprime[i] = true;
for (int p = 2; p <= mval; p++)
if (isprime[p])
for (int v = 2 * p; v <= mval; v += p) isprime[v] = false;
vector<int> primes;
for (int p = 2; p <= mval; p++)
if (isprime[p]) primes.push_back(p);
int n, k;
scanf("%d %d", &n, &k);
vector<int> a;
map<int, int> b;
long long ans = 0LL;
for (int i = 0; i < n; i++) {
int v;
long long av = 1LL, bv = 1LL;
scanf("%d", &v);
for (int p : primes) {
if (v % p == 0) {
int e = 0;
while (v % p == 0) {
e++;
v /= p;
}
int ae = e % k, be = (k - ae) % k;
upd_pow(av, p, ae);
upd_pow(bv, p, be);
}
if (p * p > v) break;
}
if (v > 1) {
assert(isprime[v]);
upd_pow(av, v, 1);
upd_pow(bv, v, k - 1);
}
if (av && bv) {
a.push_back(av);
b[bv]++;
if (av == bv) ans--;
}
}
for (int val : a) {
if (b.count(val)) ans += b[val];
}
ans /= 2LL;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 * 1000 + 10;
int mod = 1e9 + 7;
map<long long, long long> num;
vector<int> dv[N];
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 2; i < N; i++)
if (!dv[i].size())
for (int j = i; j < N; j += i) dv[j].push_back(i);
int n, k;
cin >> n >> k;
long long ans = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
long long cur = 1, x2 = 1;
for (auto u : dv[x]) {
int cnt = 0;
while (x % u == 0) {
x /= u;
cnt++;
}
cnt %= k;
long long cnt2 = (k - cnt) % k;
while (cnt2-- && cur < mod) cur *= u;
while (cnt--) x2 *= u;
}
ans += num[cur];
num[x2]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
bool flag[N];
int n, k;
vector<int> prime;
map<vector<int>, int> mps[N];
void init() {
for (int i = 2; i * i < N; ++i) {
if (flag[i]) continue;
prime.push_back(i);
for (int j = i + i; j < N; j += i) flag[j] = true;
}
}
int main() {
long long ans = 0;
init();
scanf("%d %d", &n, &k);
for (int i = 1, v; i <= n; ++i) {
scanf("%d", &v);
vector<int> cur, nex;
for (auto p : prime) {
int c = 0;
while (v % p == 0) v /= p, c++;
c %= k;
cur.push_back(c);
nex.push_back(c ? k - c : 0);
}
if (v == 1 || k == 2) ans += mps[v][nex];
mps[v][cur]++;
}
printf("%lld\n", ans);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.