text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
string s;
cin >> s;
double d = s.length();
long long k = ceil(d / 2);
bool f = 1;
if (s.length() % 2) {
for (long long i = 1; i < s.length(); i++) {
if (s[i] == '1') {
f = 0;
break;
}
}
if (f) k--;
}
cout << k << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400005];
int l[400005], r[400005];
int aintlz[1600005], lazy[1600005];
int aint[800005];
int h[400005];
void init(int nod, int l, int r) {
if (l == r)
aint[nod] = l;
else {
int mid = (l + r) / 2;
init(2 * nod, l, mid);
init(2 * nod + 1, mid + 1, r);
if (a[aint[2 * nod]] < a[aint[2 * nod + 1]])
aint[nod] = aint[2 * nod];
else
aint[nod] = aint[2 * nod + 1];
}
}
int query(int nod, int l, int r, int x, int y) {
if (l >= x && r <= y)
return aint[nod];
else {
int mid = (l + r) / 2;
int p1, p2;
if (x <= mid)
p1 = query(2 * nod, l, mid, x, y);
else
p1 = -1;
if (y > mid)
p2 = query(2 * nod + 1, mid + 1, r, x, y);
else
p2 = -1;
if (p1 == -1)
return p2;
else if (p2 == -1)
return p1;
else {
if (a[p1] < a[p2])
return p1;
else
return p2;
}
}
}
void tree(int x, int y, int lev) {
if (x == y)
h[x] = lev;
else {
int pmin = query(1, 1, n, x, y);
h[pmin] = lev;
if (pmin > x) tree(x, pmin - 1, lev + 1);
if (pmin < y) tree(pmin + 1, y, lev + 1);
}
}
void initlz(int nod, int l, int r) {
if (l == r)
aintlz[nod] = h[l];
else {
int mid = (l + r) / 2;
initlz(2 * nod, l, mid);
initlz(2 * nod + 1, mid + 1, r);
aintlz[nod] = max(aintlz[2 * nod], aintlz[2 * nod + 1]);
}
}
void updatelz(int nod, int l, int r, int x, int y, int val) {
if (l > r) return;
if (lazy[nod] != 0) {
aintlz[nod] += lazy[nod];
if (l < r) {
lazy[2 * nod] += lazy[nod];
lazy[2 * nod + 1] += lazy[nod];
}
lazy[nod] = 0;
}
if (l > y || r < x) return;
if (l >= x && r <= y) {
aintlz[nod] += val;
if (l < r) {
lazy[2 * nod] += val;
lazy[2 * nod + 1] += val;
}
return;
}
int mid = (l + r) / 2;
updatelz(2 * nod, l, mid, x, y, val);
updatelz(2 * nod + 1, mid + 1, r, x, y, val);
aintlz[nod] = max(aintlz[2 * nod], aintlz[2 * nod + 1]);
}
int querylz(int nod, int l, int r, int x, int y) {
if (x == 0) return 0;
if (lazy[nod] != 0) {
aintlz[nod] += lazy[nod];
if (l < r) {
lazy[2 * nod] += lazy[nod];
lazy[2 * nod + 1] += lazy[nod];
}
lazy[nod] = 0;
}
if (l >= x && r <= y)
return aintlz[nod];
else {
int mid = (l + r) / 2;
int v1 = -1, v2 = -1;
if (x <= mid) v1 = querylz(2 * nod, l, mid, x, y);
if (y > mid) v2 = querylz(2 * nod + 1, mid + 1, r, x, y);
return max(v1, v2);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i + n] = a[i];
}
init(1, 1, n);
tree(1, n, 1);
n *= 2;
initlz(1, 1, n);
l[1] = 0;
for (int i = 2; i <= n; ++i) {
l[i] = i - 1;
while (a[l[i]] >= a[i]) l[i] = l[l[i]];
}
r[n] = n + 1;
for (int i = n - 1; i >= 1; --i) {
r[i] = i + 1;
while (a[r[i]] >= a[i]) r[i] = r[r[i]];
}
int hmin = aintlz[1];
int shl = 0;
for (int i = 1; i < n / 2; ++i) {
if (r[i] < i + n / 2) updatelz(1, 1, n, i + 1, r[i] - 1, -1);
if (l[i + n / 2] > i) updatelz(1, 1, n, l[i + n / 2] + 1, i + n / 2 - 1, 1);
h[i + n / 2] = querylz(1, 1, n, l[i + n / 2], l[i + n / 2]) + 1;
updatelz(1, 1, n, i + n / 2, i + n / 2, h[i + n / 2]);
h[i] = -querylz(1, 1, n, i, i);
updatelz(1, 1, n, i, i, h[i]);
if (aintlz[1] < hmin) {
hmin = aintlz[1];
shl = i;
}
}
cout << hmin << " " << shl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[2 * 200007];
int l[2 * 200007];
int r[2 * 200007];
class Tree {
public:
int tr[8 * 200007];
int lazy[8 * 200007];
void init(int where, int IL, int IR) {
tr[where] = lazy[where] = 0;
if (IL == IR) {
return;
}
int mid = (IL + IR) / 2;
init(2 * where, IL, mid);
init(2 * where + 1, mid + 1, IR);
}
void push_lazy(int where, int IL, int IR) {
tr[where] += lazy[where];
if (IL != IR) {
lazy[2 * where] += lazy[where];
lazy[2 * where + 1] += lazy[where];
}
lazy[where] = 0;
}
void update(int where, int IL, int IR, int CURL, int CURR, int val) {
push_lazy(where, IL, IR);
if (IR < CURL || CURR < IL) {
return;
}
if (CURL <= IL && IR <= CURR) {
lazy[where] += val, push_lazy(where, IL, IR);
return;
}
int mid = (IL + IR) / 2;
update(2 * where, IL, mid, CURL, CURR, val);
update(2 * where + 1, mid + 1, IR, CURL, CURR, val);
tr[where] = max(tr[2 * where], tr[2 * where + 1]);
}
int query(int where, int IL, int IR, int CURL, int CURR) {
push_lazy(where, IL, IR);
if (IR < CURL || CURR < IL) {
return 0;
}
if (CURL <= IL && IR <= CURR) {
return tr[where];
}
int mid = (IL + IR) / 2;
return max(query(2 * where, IL, mid, CURL, CURR),
query(2 * where + 1, mid + 1, IR, CURL, CURR));
}
};
Tree w;
void add(int id, int coef) {
w.update(1, 1, 2 * n, l[id] + 1, r[id] - 1, coef);
}
void input() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
a[n + i] = a[i];
}
}
void solve() {
stack<int> s;
s.push(0);
for (int i = 1; i <= 2 * n; ++i) {
while (a[s.top()] >= a[i]) {
r[s.top()] = i;
s.pop();
}
l[i] = s.top();
s.push(i);
}
while (s.empty() == false) {
r[s.top()] = 2 * n + 1;
s.pop();
}
w.init(1, 1, 2 * n);
for (int i = 1; i <= n; ++i) {
add(i, 1);
}
int ans = w.query(1, 1, 2 * n, 1, n);
int id = 0;
for (int i = 1; i <= n; ++i) {
add(i, -1);
add(n + i, 1);
int ret = w.query(1, 1, 2 * n, i + 1, n + i);
if (ans > ret) {
ans = ret, id = i;
}
}
printf("%d %d\n", ans, id);
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
input();
solve();
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;
int ara[400005];
int pri[400005];
int lft[400005];
int rht[400005];
struct segTree {
int n;
vector<int> tree, lazy;
segTree(int n) : n(n), tree(4 * n, 0), lazy(4 * n, 0) {}
void propagate(int node, int l, int r) {
tree[node] += lazy[node];
if (l != r) lazy[2 * node] += lazy[node], lazy[2 * node + 1] += lazy[node];
lazy[node] = 0;
}
void treeUpdate(int node, int l, int r, int u, int v, int val) {
int mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return;
if (l >= u && r <= v) {
lazy[node] += val;
propagate(node, l, r);
return;
}
treeUpdate(2 * node, l, mid, u, v, val);
treeUpdate(2 * node + 1, mid + 1, r, u, v, val);
tree[node] = max(tree[2 * node], tree[2 * node + 1]);
}
void update(int l, int r, int val) {
if (l > r) return;
treeUpdate(1, 1, n, l, r, val);
}
int treeQuery(int node, int l, int r, int u, int v) {
int mid = (l + r) >> 1;
propagate(node, l, r);
if (l > v || r < u) return 0;
if (l >= u && r <= v) return tree[node];
return max(treeQuery(2 * node, l, mid, u, v),
treeQuery(2 * node + 1, mid + 1, r, u, v));
}
int query(int l, int r) { return treeQuery(1, 1, n, l, r); }
};
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", ara + i);
for (int i = 1; i <= n; i++) pri[ara[i]] = i;
for (int i = 1; i <= n; i++) ara[i + n] = ara[i];
stack<int> st;
st.push(0);
for (int i = 1; i <= 2 * n; i++) {
while (ara[st.top()] > ara[i]) st.pop();
lft[i] = st.top();
st.push(i);
}
while (st.size()) st.pop();
st.push(2 * n + 1);
for (int i = 2 * n; i; i--) {
while (ara[st.top()] > ara[i]) st.pop();
rht[i] = st.top();
st.push(i);
}
segTree tree(2 * n);
for (int i = 1; i <= n; i++) {
int j = pri[i];
int idx = lft[j];
if (rht[j] <= n && ara[rht[j]] > ara[idx]) idx = rht[j];
int x = tree.query(idx, idx);
tree.update(j, j, x + 1);
}
int ans = tree.query(1, n);
int ansi = 0;
for (int i = 2; i <= n; i++) {
int y = tree.query(i - 1, i - 1);
tree.update(i - 1, i - 1, -y);
int j = rht[i - 1];
tree.update(i, j - 1, -1);
j = lft[i + n - 1];
tree.update(j + 1, i + n - 2, 1);
int x = tree.query(j, j);
tree.update(i + n - 1, i + n - 1, x + 1);
int tmp = tree.query(i, i + n - 1);
if (tmp < ans) ans = tmp, ansi = i - 1;
}
printf("%d %d\n", ans, ansi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inline read() {
int num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const int maxn = 400010, mod = 998244353;
int n, a[maxn], stk[maxn], tp, fa[maxn], LS[maxn], RS[maxn], dep[maxn];
void dfs(int x) {
if (LS[x]) {
dep[LS[x]] = dep[x] + 1;
dfs(LS[x]);
}
if (RS[x]) {
dep[RS[x]] = dep[x] + 1;
dfs(RS[x]);
}
}
int f[maxn][20], lg2[maxn];
void init() {
lg2[0] = -1;
for (int i = 1; i <= 2 * n; i++) f[i][0] = i;
for (int i = 1; i <= 2 * n; i++) lg2[i] = lg2[i >> 1] + 1;
for (int i = 1; i <= lg2[2 * n]; i++)
for (int j = 1; j + (1 << i) - 1 <= 2 * n; j++)
if (a[f[j][i - 1]] < a[f[j + (1 << i - 1)][i - 1]])
f[j][i] = f[j][i - 1];
else
f[j][i] = f[j + (1 << i - 1)][i - 1];
}
int Q(int l, int r) {
int len = r - l + 1;
len = lg2[len];
if (a[f[l][len]] < a[f[r - (1 << len) + 1][len]]) return a[f[l][len]];
return a[f[r - (1 << len) + 1][len]];
}
int mx[maxn << 2], lzy[maxn << 2];
void pushup(int x) { mx[x] = max(mx[(x << 1)], mx[(x << 1 | 1)]); }
void Build(int x, int l, int r) {
if (l == r) {
mx[x] = dep[l];
return;
}
int mid = l + r >> 1;
Build((x << 1), l, mid);
Build((x << 1 | 1), mid + 1, r);
pushup(x);
}
void pushdown(int x) {
if (!lzy[x]) return;
mx[(x << 1)] += lzy[x];
mx[(x << 1 | 1)] += lzy[x];
lzy[(x << 1)] += lzy[x];
lzy[(x << 1 | 1)] += lzy[x];
lzy[x] = 0;
}
void update(int x, int l, int r, int L, int R, int k, int op) {
if (L > R) return;
if (l >= L && r <= R) {
if (op) {
mx[x] += k;
lzy[x] += k;
} else
mx[x] = k;
return;
}
int mid = l + r >> 1;
pushdown(x);
if (mid >= L) update((x << 1), l, mid, L, R, k, op);
if (mid < R) update((x << 1 | 1), mid + 1, r, L, R, k, op);
pushup(x);
}
int Query(int x, int l, int r, int pos) {
if (l == r) return mx[x];
int mid = l + r >> 1;
pushdown(x);
if (mid >= pos) return Query((x << 1), l, mid, pos);
return Query((x << 1 | 1), mid + 1, r, pos);
}
void upd(int l, int r, int k) {
if (l > r) return;
update(1, 1, 2 * n, l, r, k, 1);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) {
while (tp && a[stk[tp]] > a[i]) LS[i] = stk[tp], tp--;
fa[i] = stk[tp];
if (LS[i]) fa[LS[i]] = i;
if (tp) RS[stk[tp]] = i;
stk[++tp] = i;
}
for (int i = 1; i <= n; i++) a[i + n] = a[i];
for (int i = 1; i <= n; i++)
if (fa[i] == 0) dep[i] = 1, dfs(i);
init();
Build(1, 1, 2 * n);
int ans = mx[1], pos = 0;
for (int i = 1; i < n; i++) {
int l = i + 1, r = i + n - 1, flg = 0;
while (l < r) {
int mid = l + r >> 1;
if (Q(i + 1, mid) < a[i])
r = mid, flg = 1;
else
l = mid + 1;
}
flg |= Q(i + 1, l) < a[i];
if (flg)
upd(i + 1, l - 1, -1);
else
upd(i + 1, i + n - 1, -1);
l = i + 1;
r = i + n - 1;
flg = 0;
while (l < r) {
int mid = l + r + 1 >> 1;
if (Q(mid, i + n - 1) < a[i])
l = mid, flg = 1;
else
r = mid - 1;
}
flg |= Q(l, i + n - 1) < a[i];
int len;
if (flg)
len = Query(1, 1, 2 * n, l);
else
len = 0;
update(1, 1, 2 * n, i + n, i + n, len + 1, 0);
update(1, 1, 2 * n, i, i, 0, 0);
if (flg)
upd(l + 1, i + n - 1, 1);
else
upd(i + 1, i + n - 1, 1);
if (mx[1] < ans) ans = mx[1], pos = i;
}
cout << ans << " " << pos;
return 0;
}
|
#include <bits/stdc++.h>
inline int mmax(int x, int y) { return x > y ? x : y; }
inline int mmin(int x, int y) { return x < y ? x : y; }
int n, fs, pl[200005], del[200005], der[200005], stk[200005], rd[200005], top,
ans = 1e9, answ;
inline int ef(int key) {
int l = 0, r = top, mid, res;
while (l <= r) {
mid = (l + r) / 2;
if (pl[stk[mid]] < key)
res = mid, l = mid + 1;
else
r = mid - 1;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &pl[i]), fs = pl[i] == 1 ? i : fs;
for (int i = 1, nw = fs + 1; i <= n - 1; ++i, ++nw) {
if (nw > n) nw -= n;
int ny = ef(pl[nw]), dq = ny;
while (top > ny) dq = mmax(dq, rd[top]), --top;
stk[++top] = nw, rd[top] = dq + 1;
der[i] = mmax(der[i - 1], rd[top]);
}
top = 0;
for (int i = 1, nw = fs - 1; i <= n - 1; ++i, --nw) {
if (nw < 1) nw += n;
int ny = ef(pl[nw]), dq = ny;
while (top > ny) dq = mmax(dq, rd[top]), --top;
stk[++top] = nw, rd[top] = dq + 1;
del[i] = mmax(del[i - 1], rd[top]);
}
for (int i = 0; i <= n - 1; ++i)
if (mmax(del[i], der[n - 1 - i]) + 1 < ans)
ans = mmax(del[i], der[n - 1 - i]) + 1,
answ = i <= fs - 1 ? fs - 1 - i : fs + (n - 1 - i);
printf("%d %d", ans, answ);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class S, class T>
ostream& operator<<(ostream& o, const pair<S, T>& p) {
return o << "(" << p.first << "," << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& o, const vector<T>& vc) {
o << "{";
for (const T& v : vc) o << v << ",";
o << "}";
return o;
}
using ll = long long;
template <class T>
using V = vector<T>;
template <class T>
using VV = vector<vector<T>>;
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
struct segtree {
using D = int;
D inf = 1e9;
using P = pair<D, int>;
int N;
vector<P> val;
segtree() {}
segtree(int n) {
N = 1;
while (N < n) N *= 2;
val.assign(N * 2, P(inf, -1));
for (int i = 0; i < (int)(n); i++) val[i + N].second = i;
for (int i = N - 1; i > 0; i--) val[i] = min(val[i * 2], val[i * 2 + 1]);
}
segtree(const vector<D>& ds) {
int n = ds.size();
N = 1;
while (N < n) N *= 2;
val.assign(N * 2, P(inf, -1));
for (int i = 0; i < (int)(n); i++) val[i + N] = P(ds[i], i);
for (int i = N - 1; i > 0; i--) val[i] = min(val[i * 2], val[i * 2 + 1]);
}
void assign(int k, D d) {
k += N;
val[k] = P(d, k - N);
k /= 2;
while (k) {
val[k] = min(val[k * 2], val[k * 2 + 1]);
k /= 2;
}
}
P getmina(int a, int b) {
P res = P(inf, -1);
a += N, b += N;
while (a < b) {
if (a & 1) res = min(res, val[a++]);
if (b & 1) res = min(res, val[--b]);
a /= 2, b /= 2;
}
return res;
}
};
V<int> solve(V<int> p) {
int N = p.size();
int rot = 0;
{
for (int i = 0; i < (int)(N); i++)
if (p[i] == 0) {
rot = i + 1;
break;
}
rotate(p.begin(), p.begin() + rot, p.end());
}
true;
segtree seg(p);
V<int> depth(N, -1);
V<int> lch(N, -1), rch(N, -1);
function<int(int, int, int)> dfs = [&](int l, int r, int p) {
if (l >= r) return -1;
int m = seg.getmina(l, r).second;
if (p != -1 && p > m) lch[p] = m;
if (p != -1 && p < m) rch[p] = m;
depth[m] = max(depth[m], dfs(l, m, m) + 1);
depth[m] = max(depth[m], dfs(m + 1, r, m) + 1);
return depth[m];
};
dfs(0, N, -1);
V<int> A(N);
for (int i = 0; i < (int)(N); i++)
if (rch[i] != -1) A[i] = 1 + depth[rch[i]];
V<int> chain;
multiset<int> st;
for (int v = 0; v < (int)(N); v++) {
true;
true;
}
{
for (int x = N - 1, d = 0; x != -1; x = lch[x], d++) {
chain.push_back(x);
st.insert(A[x] + d);
}
}
V<int> res(N);
for (int i = 0; i < (int)(N); i++) {
res[i] = *st.rbegin();
if (i != N - 1) {
assert(chain.back() == i);
{
int er = A[i] + (int)chain.size() - 1;
auto it = st.find(er);
assert(it != st.end());
st.erase(it);
chain.pop_back();
}
for (int x = rch[i]; x != -1; x = lch[x]) {
int ad = A[x] + (int)chain.size();
st.insert(ad);
chain.push_back(x);
}
}
}
rotate(res.begin(), res.begin() + N - rot, res.end());
true;
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N;
cin >> N;
V<int> p(N);
for (int i = 0; i < (int)(N); i++) cin >> p[i], p[i]--;
V<int> a = solve(p);
reverse(p.begin(), p.end());
V<int> b = solve(p);
int ag = 0;
for (int i = 0; i < (int)(N); i++) {
if (max(a[i], b[(N - i) % N]) < max(a[ag], b[(N - ag) % N])) ag = i;
}
cout << max(a[ag], b[(N - ag) % N]) + 1 << " " << ag << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
void pre() {}
const int inf = numeric_limits<int>::max();
template <class T>
struct RMQ {
vector<vector<T>> jmp;
RMQ() {}
RMQ(const vector<T>& V) {
int N = (int)(V).size(), on = 1, depth = 1;
while (on < (int)(V).size()) on *= 2, depth++;
jmp.assign(depth, V);
for (int i = 0; i < (depth - 1); ++i)
for (int j = 0; j < (N); ++j)
jmp[i + 1][j] = min(jmp[i][j], jmp[i][min(N - 1, j + (1 << i))]);
}
T query(int a, int b) {
if (b <= a) return inf;
int dep = 31 - __builtin_clz(b - a);
return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
}
};
RMQ<int> R;
vector<int> z;
int solve(int l, int r) {
if (r - l <= 1) return r - l;
int x = R.query(l, r);
for (int i = 0; i < (r - l); ++i) {
if (z[l + i] == x) {
return 1 + max(solve(l, l + i), solve(l + i + 1, r));
}
if (z[r - 1 - i] == x) {
return 1 + max(solve(l, r - 1 - i), solve(r - i, r));
}
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
pre();
int n;
cin >> n;
vector<int> v(2 * n);
int ix = 0;
for (int i = 0; i < (n); ++i) {
cin >> v[i];
if (v[i] == 1) ix = i;
v[i + n] = v[i];
}
if (n == 1) {
cout << 1 << ' ' << 0 << '\n';
return 0;
}
z = vector<int>(v.begin() + ix + 1, v.begin() + ix + 1 + n - 1);
R = RMQ<int>(z);
int lo = 0, hi = (int)(z).size();
while (lo < hi) {
int m = (lo + hi) / 2;
if (solve(0, m) >= solve(m, (int)(z).size())) {
hi = m;
} else
lo = m + 1;
}
int ans = 1 + max(solve(0, lo), solve(lo, (int)(z).size()));
int ansix = lo, lstns = ans;
if (lo)
ans = min(ans, 1 + max(solve(0, lo - 1), solve(lo - 1, (int)(z).size())));
if (ans < lstns) ansix = lo - 1;
cout << ans << ' ';
for (int i = 0; i < (n); ++i) {
if (v[i] == z[ansix % ((int)(z).size())]) {
cout << i;
return 0;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> tree(900000, 0);
vector<int> lazy(900000, 0);
void update(int node, int start, int end, int l, int r, int val) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end || start > r || end < l) {
return;
}
if (start >= l && end <= r) {
tree[node] += val;
if (start != end) {
lazy[node * 2] += val;
lazy[node * 2 + 1] += val;
}
return;
}
int mid = (start + end) / 2;
update(node * 2, start, mid, l, r, val);
update(node * 2 + 1, mid + 1, end, l, r, val);
tree[node] = max(tree[2 * node], tree[2 * node + 1]);
}
int query(int node, int start, int end, int l, int r) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (start != end) {
lazy[node * 2] += lazy[node];
lazy[node * 2 + 1] += lazy[node];
}
lazy[node] = 0;
}
if (start > end || start > r || end < l) {
return 0;
}
if (start >= l && end <= r) {
return tree[node];
}
int mid = (start + end) / 2;
int p1 = query(node * 2, start, mid, l, r);
int p2 = query(node * 2 + 1, mid + 1, end, l, r);
return max(p1, p2);
}
int rot = 0;
void process(int n, vector<int> &a) {
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
rot = (n - i);
rotate(a.begin(), a.begin() + i, a.end());
a.push_back(1);
return;
}
}
}
vector<int> solve(int n, vector<int> a) {
for (auto &i : tree) i = 0;
for (auto &i : lazy) i = 0;
vector<int> res(n);
res[0] = 1;
stack<int> st;
st.push(0);
for (int i = 1; i < n; i++) {
while (a[i] < a[st.top()]) {
st.pop();
}
update(1, 0, n - 1, i, i, st.size());
update(1, 0, n - 1, st.top() + 1, i, 1);
st.push(i);
res[i] = query(1, 0, n - 1, 0, i);
}
res.push_back(0);
return res;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
process(n, a);
vector<int> pre = solve(n, a);
reverse(a.begin(), a.end());
vector<int> suf = solve(n, a);
reverse(a.begin(), a.end());
reverse(suf.begin(), suf.end());
int idx = 0, rl = 0;
for (int i = 0, j = n - 1; i < n; i++, j = (j - 1 + n) % n) {
if (max(pre[i], suf[i + 1]) < max(pre[idx], suf[idx + 1])) {
idx = i;
rl = j;
}
}
cout << max(pre[idx], suf[idx + 1]) << ' ' << (n - ((rl + rot) % n)) % n
<< '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
static int n;
static int a[200010];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
static int b[2][200010];
static int dpl[2][200010];
static int dpr[2][200010];
static int ans[2][200010];
int root = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) root = i;
}
for (int i = 0; i < n; i++) {
b[0][i] = a[(root + i) % n];
b[1][i] = a[(root + n - i) % n];
}
for (int t = 0; t < 2; t++) {
vector<int> vec;
dpl[t][0] = 1;
ans[t][0] = 1;
vec.push_back(0);
for (int i = 1; i < n; i++) {
int nex = -1;
while (vec.size() > 0 && b[t][vec[vec.size() - 1]] > b[t][i]) {
int j = vec[vec.size() - 1];
if (nex == -1) {
dpr[t][j] = dpl[t][j];
nex = j;
} else {
dpr[t][j] = max(dpr[t][nex] + 1, dpl[t][j]);
nex = j;
}
vec.pop_back();
}
if (nex == -1) {
dpl[t][i] = 1;
} else {
dpl[t][i] = dpr[t][nex] + 1;
}
vec.push_back(i);
ans[t][i] = max((int)vec.size() + dpl[t][i] - 1, ans[t][i - 1]);
}
}
int ret = 300000;
int k = -1;
for (int i = 0; i < n; i++) {
if (ret > max(ans[0][i], ans[1][n - 1 - i])) {
ret = max(ans[0][i], ans[1][n - 1 - i]);
k = (root + 1 + i) % n;
}
}
cout << ret << " " << k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 7;
int tr[4 * MAXN];
int lazy[4 * MAXN];
void propagate(int u, int l, int r) {
if (lazy[u]) {
tr[u] += lazy[u];
if (l != r) {
lazy[u * 2] += lazy[u];
lazy[u * 2 + 1] += lazy[u];
}
lazy[u] = 0;
}
}
int a[MAXN];
void build(int u, int l, int r) {
lazy[u] = 0;
if (l == r) {
tr[u] = a[l];
return;
}
int mid = (l + r) / 2;
build(u * 2, l, mid);
build(u * 2 + 1, mid + 1, r);
tr[u] = max(tr[u * 2], tr[u * 2 + 1]);
}
void update(int u, int l, int r, int x, int y, int v) {
propagate(u, l, r);
if (r < x || y < l) return;
if (x <= l && r <= y) {
lazy[u] += v;
propagate(u, l, r);
return;
}
int mid = (l + r) / 2;
update(u * 2, l, mid, x, y, v);
update(u * 2 + 1, mid + 1, r, x, y, v);
tr[u] = max(tr[u * 2], tr[u * 2 + 1]);
}
int query(int u, int l, int r, int x, int y) {
propagate(u, l, r);
if (x <= l && r <= y) return tr[u];
int mid = (l + r) / 2;
if (y <= mid) return query(u * 2, l, mid, x, y);
if (mid < x) return query(u * 2 + 1, mid + 1, r, x, y);
return max(query(u * 2, l, mid, x, y), query(u * 2 + 1, mid + 1, r, x, y));
}
const int MX = MAXN, K = 20;
int lg[MX];
void pre() {
lg[1] = 0;
for (int i = 2; i < MX; i++) lg[i] = lg[i / 2] + 1;
}
struct RMQ {
int N;
vector<int> v[K];
RMQ(const vector<int> &a) {
N = a.size();
v[0] = a;
for (int k = 0; (1 << (k + 1)) <= N; k++) {
v[k + 1].resize(N);
for (int i = 0; i - 1 + (1 << (k + 1)) < N; i++) {
v[k + 1][i] = min(v[k][i], v[k][i + (1 << k)]);
}
}
}
int findMin(int i, int j) {
int k = lg[j - i + 1];
return min(v[k][i], v[k][j + 1 - (1 << k)]);
}
} * rmq;
vector<int> per;
int place[MAXN];
int dan[MAXN];
void init(int lvl, int l, int r) {
if (l > r) return;
int mn = rmq->findMin(l, r);
mn = place[mn];
a[mn] = lvl;
dan[mn] = r;
init(lvl + 1, l, mn - 1);
init(lvl + 1, mn + 1, r);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
pre();
int n;
cin >> n;
per.resize(n + 1);
for (int i = 1; i <= n; i++) {
cin >> per[i];
place[per[i]] = i;
}
rmq = new RMQ(per);
init(1, 1, n);
build(1, 1, n + n);
int ans = tr[1];
int shift = 0;
per.resize(n + n);
stack<int> st;
for (int i = 1; i <= n; i++) {
while (!st.empty() && per[i] < per[st.top()]) st.pop();
st.push(i);
}
for (int k = 1; k < n; k++) {
per[n + k] = per[k];
while (!st.empty() && per[n + k] <= per[st.top()]) {
dan[st.top()] = n + k - 1;
st.pop();
}
if (!st.empty()) {
update(1, 1, n + n, k, dan[k], -1);
if (st.top() < n + k - 1) {
update(1, 1, n + n, st.top() + 1, n + k - 1, 1);
}
}
st.push(n + k);
update(1, 1, n + n, n + k, n + k, st.size());
int qq = query(1, 1, n + n, k + 1, n + k);
if (qq < ans) {
ans = qq;
shift = k;
}
}
cout << ans << " " << shift << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long seg_tree_f[400000 * 4 + 9];
long long 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, long long 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,
long long 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,
long long 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);
}
long long query_f(int node, int beg, int end, int i, int j) {
if (i > end || j < beg) return (1LL << 60);
if (beg >= i && end <= j) return seg_tree_f[node];
split_node_f(node);
int mid = (beg + end) >> 1;
long long leftnode = query_f((node << 1), beg, mid, i, j);
long long rightnode = query_f(((node << 1) | 1), mid + 1, end, i, j);
return min(leftnode, rightnode);
}
long long seg_tree[400000 * 4 + 9];
long long 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, long long 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);
}
long long query_leftmost(int node, int beg, int end, int i, int j,
long long 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);
}
long long query_rightmost(int node, int beg, int end, int i, int j,
long long 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);
}
long long query(int node, int beg, int end, int i, int j) {
if (i > end || j < beg) return (-(1LL << 60));
if (beg >= i && end <= j) return seg_tree[node];
split_node(node);
int mid = (beg + end) >> 1;
long long leftnode = query((node << 1), beg, mid, i, j);
long long rightnode = query(((node << 1) | 1), mid + 1, end, i, j);
return max(leftnode, rightnode);
}
long long MAP[400000 + 9];
long long ar[400000 + 9];
long long 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() {
long long 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;
using ll = long long;
mt19937 mt(736);
int up(int n) {
int r = 1;
while (r < n) r <<= 1;
return r;
}
class segtreepii {
vector<pair<int, int>> arr;
[[nodiscard]] pair<int, int> segmin(int l, int r, int cl, int cr,
int v) const {
if (r <= cl || cr <= l) return {numeric_limits<int>::max(), -1};
if (l <= cl && cr <= r) return arr[v];
int ct = (cl + cr) / 2;
return min(segmin(l, r, cl, ct, 2 * v), segmin(l, r, ct, cr, 2 * v + 1));
}
public:
segtreepii(const vector<pair<int, int>> &val)
: arr(2 * up(val.size()), {numeric_limits<int>::max(), -1}) {
copy(val.begin(), val.end(), arr.begin() + arr.size() / 2);
for (int i = (int)arr.size() / 2 - 1; i > 0; i--)
arr[i] = min(arr[2 * i], arr[2 * i + 1]);
}
[[nodiscard]] pair<int, int> segmin(int l, int r) const {
return segmin(l, r, 0, arr.size() / 2, 1);
}
[[nodiscard]] pair<int, int> segmin() const {
return segmin(0, arr.size() / 2, 0, arr.size() / 2, 1);
}
void set(int wh, const pair<int, int> &x) {
wh += arr.size() / 2;
arr[wh] = x;
while ((wh >>= 1) > 0) arr[wh] = min(arr[2 * wh], arr[2 * wh + 1]);
}
};
class segtreei {
vector<int> arr, laz;
[[nodiscard]] int segmax(int l, int r, int cl, int cr, int v) {
if (r <= cl || cr <= l) return 0;
push(v);
if (l <= cl && cr <= r) return arr[v];
int ct = (cl + cr) / 2;
auto ret =
max(segmax(l, r, cl, ct, 2 * v), segmax(l, r, ct, cr, 2 * v + 1));
upd(v);
return ret;
}
void push(int v) {
arr[v] += laz[v];
if (v < arr.size() / 2) {
laz[2 * v] += laz[v];
laz[2 * v + 1] += laz[v];
}
laz[v] = 0;
}
void upd(int v) {
push(v);
if (v < arr.size() / 2) {
push(2 * v);
push(2 * v + 1);
arr[v] = max(arr[2 * v], arr[2 * v + 1]);
}
}
void segadd(int l, int r, int cl, int cr, int v, int x) {
if (r <= cl || cr <= l) return;
if (l <= cl && cr <= r) {
laz[v] += x;
return;
}
push(v);
int ct = (cl + cr) / 2;
segadd(l, r, cl, ct, 2 * v, x);
segadd(l, r, ct, cr, 2 * v + 1, x);
upd(v);
}
public:
segtreei(const vector<int> &val)
: arr(2 * up(val.size())), laz(2 * up(val.size())) {
copy(val.begin(), val.end(), arr.begin() + arr.size() / 2);
for (int i = (int)arr.size() / 2 - 1; i > 0; i--)
arr[i] = max(arr[2 * i], arr[2 * i + 1]);
}
[[nodiscard]] int segmax(int l, int r) {
return segmax(l, r, 0, arr.size() / 2, 1);
}
void segadd(int l, int r, int x) { segadd(l, r, 0, arr.size() / 2, 1, x); }
[[nodiscard]] int segmax() {
return segmax(0, arr.size() / 2, 0, arr.size() / 2, 1);
}
void set(int wh, const int &x) {
wh += arr.size() / 2;
arr[wh] = x;
while ((wh >>= 1) > 0) arr[wh] = max(arr[2 * wh], arr[2 * wh + 1]);
}
};
void build(vector<int> &gr, vector<int> &le, vector<int> &ri,
const segtreepii &st, int l, int r, int d = 0) {
if (r <= l) return;
auto v = st.segmin(l, r);
auto t = v.second;
gr[t] = d;
le[t] = l - 1;
ri[t] = r;
build(gr, le, ri, st, l, t, d + 1);
build(gr, le, ri, st, t + 1, r, d + 1);
}
void solve(istream &cin = std::cin, ostream &cout = std::cout) {
int n;
cin >> n;
vector<pair<int, int>> arr(n);
int sh = 0;
for (int i = 0; i < n; i++) {
cin >> arr[i].first;
arr[i].first--;
arr[i].second = i;
if (arr[i].first == 0) sh = i;
}
for (auto &it : arr) {
it.second -= sh;
if (it.second < 0) it.second += n;
}
rotate(arr.begin(), arr.begin() + sh, arr.end());
segtreepii st(arr);
vector<int> tr(n);
vector<int> le(n, -1), ri(n, -1);
build(tr, le, ri, st, 0, n);
segtreei dep(tr);
pair<int, int> ans = {dep.segmax(), sh};
for (int p = n - 1; p > 0; p--) {
dep.segadd(le[p] + 1, p, -1);
dep.segadd(p, p + 1,
-dep.segmax(p, p + 1) + dep.segmax(ri[p], ri[p] + 1) + 1);
if (ri[p] > p)
dep.segadd(p + 1, ri[p], 1);
else {
dep.segadd(p + 1, n, 1);
assert(ri[p] == 0);
}
sh--;
ans = min(ans, {dep.segmax(), sh});
}
if (ans.second < 0) ans.second += n;
cout << ans.first + 1 << ' ' << ans.second << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed;
solve();
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);
}
void leftshift(int steps) {
for (int i = 1; i <= n; i++) {
int now = (((i - 1) - steps) % n + n) % n + 1;
a[now] = b[i];
}
}
void rightshift(int steps) {
for (int i = 1; i <= n; i++) {
int now = (((i - 1) - (n - 1 - steps + 1)) % n + n) % n + 1;
a[now] = b[i];
}
}
pair<int, int> solve() {
int lo, hi, res, ans, move;
build();
dfs(rt);
ans = dg[rt];
move = 0;
if (dg[ls[rt]] == dg[rs[rt]]) return pair<int, int>(ans, move);
if (dg[ls[rt]] < dg[rs[rt]]) {
lo = 1;
hi = n - rt;
while (lo < hi) {
int mid = (lo + hi) / 2;
rightshift(mid);
build();
dfs(rt);
if (dg[rt] < ans) {
ans = dg[rt];
move = (n - 1 - mid) + 1;
}
if (dg[ls[rt]] < dg[rs[rt]]) {
lo = mid + 1;
} else
hi = mid;
}
rightshift(lo);
build();
dfs(rt);
if (dg[rt] < ans) {
ans = dg[rt];
move = n - 1 - lo + 1;
}
}
if (dg[ls[rt]] > dg[rs[rt]]) {
lo = 1;
hi = rt - 1;
while (lo < hi) {
int mid = (lo + hi) / 2;
leftshift(mid);
build();
dfs(rt);
if (dg[rt] < ans) {
ans = dg[rt];
move = mid;
}
if (dg[ls[rt]] > dg[rs[rt]]) {
lo = mid + 1;
} else
hi = mid;
}
rightshift(lo);
build();
dfs(rt);
if (dg[rt] < ans) {
ans = dg[rt];
move = lo;
}
}
return pair<int, int>(ans, move);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
b[i] = a[i];
}
pair<int, int> ans2;
ans2 = solve();
printf("%d %d\n", ans2.first, ans2.second);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
const ll MOD = 1000000007;
const ll root = 62;
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
ll binpow(ll a, ll b) {
ll res = 1;
while (b) {
if (b & 1) res = (res * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return res;
}
ll modInv(ll a) { return binpow(a, MOD - 2); }
const double PI = acos(-1);
const double eps = 1e-6;
const int INF = 0x3f3f3f3f;
const int NINF = 0xc0c0c0c0;
const ll INFLL = 0x3f3f3f3f3f3f3f3f;
const ll NINFLL = 0xc0c0c0c0c0c0c0c0;
const int mxM = 262144;
const int mxN = 200001;
int sgmax[4 * mxM];
int del[4 * mxM];
int n;
int arr[2 * mxN];
int p[2 * mxN];
int to[2 * mxN];
int prv[2 * mxN];
void push(int i) {
del[2 * i] += del[i];
del[2 * i + 1] += del[i];
del[i] = 0;
}
void resolve(int i) {
sgmax[i] = max(sgmax[2 * i] + del[2 * i], sgmax[2 * i + 1] + del[2 * i + 1]);
}
void init(int i = 1, int l = 0, int r = 2 * n - 1) {
del[i] = 0;
if (l == r) {
sgmax[i] = arr[l];
return;
}
int mid = (l + r) >> 1;
init(2 * i, l, mid);
init(2 * i + 1, mid + 1, r);
resolve(i);
}
void upd(int l, int r, int ch, int i = 1, int le = 0, int rr = 2 * n - 1) {
if (r < l) {
return;
}
r = min(r, 2 * n - 1);
if (rr < l || le > r) {
return;
}
if (le >= l && rr <= r) {
del[i] += ch;
return;
}
push(i);
int mid = (le + rr) >> 1;
upd(l, r, ch, 2 * i, le, mid);
upd(l, r, ch, 2 * i + 1, mid + 1, rr);
resolve(i);
}
int qmax(int l, int r, int i = 1, int le = 0, int rr = 2 * n - 1) {
if (rr < l || le > r) return 0;
if (le >= l && rr <= r) return sgmax[i] + del[i];
push(i);
resolve(i);
int mid = (le + rr) >> 1;
return max(qmax(l, r, 2 * i, le, mid), qmax(l, r, 2 * i + 1, mid + 1, rr));
}
vector<int> comp(int *p) {
init();
vector<int> res(n);
vector<int> sv(n + 1);
for (int i = (0); i < (n); ++i) {
int tt = qmax(0, p[i] - 1);
res[i] = sv[tt] + 1;
upd(p[i], p[i], i + 1);
sv[i + 1] = res[i];
}
return res;
}
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
cin.tie(0)->sync_with_stdio(0);
cin >> n;
for (int i = (0); i < (n); ++i) {
cin >> p[i];
p[i + n] = p[i];
}
vector<int> left = comp(p);
reverse(p, p + n);
vector<int> right = comp(p);
reverse(right.begin(), right.end());
reverse(p, p + n);
for (int i = (0); i < (n); ++i) {
arr[i] = left[i] + right[i] - 1;
}
set<int> curr;
for (int i = (0); i < (2 * n); ++i) {
auto it = curr.lower_bound(p[i]);
while (it != curr.end()) {
to[*it] = i;
it = curr.erase(it);
}
if (i < n) {
curr.insert(p[i]);
}
}
curr.clear();
for (int i = (2 * n) - 1; i >= (0); --i) {
auto it = curr.lower_bound(p[i]);
while (it != curr.end()) {
prv[*it] = i;
it = curr.erase(it);
}
if (i >= n) {
curr.insert(p[i]);
}
}
init();
pair<int, int> ans = {qmax(0, n - 1), 0};
for (int i = (0); i < (n - 1); ++i) {
upd(i, to[p[i]] - 1, -1);
upd(i + n, i + n, qmax(prv[p[i]], prv[p[i]]));
upd(prv[p[i]] + 1, i + n, 1);
ans = min(ans, {qmax(i + 1, n + i), i + 1});
}
cout << ans.first << " " << ans.second << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[222222], tree[888888], dep[222222], mn, num, l, r, mid, lazy[888888];
pair<int, int> mtree[888888];
pair<int, int> query(int beg, int en, int l, int r, int node) {
if (l > en || r < beg) return make_pair(1e9, 1e9);
if (l >= beg && r <= en) return mtree[node];
int mid = (l + r) >> 1;
return min(query(beg, en, l, mid, node << 1),
query(beg, en, mid + 1, r, (node << 1) | 1));
}
void build(int l, int r, int node) {
if (l == r) {
mtree[node] = make_pair(a[l], l);
return;
}
int mid = (l + r) >> 1;
build(l, mid, node << 1);
build(mid + 1, r, (node << 1) | 1);
mtree[node] = min(mtree[node << 1], mtree[(node << 1) | 1]);
}
void build2(int l, int r, int d) {
int x = query(l, r, 1, n, 1).second;
dep[x] = d;
if (l < x) build2(l, x - 1, d + 1);
if (x < r) build2(x + 1, r, d + 1);
}
void pushup(int node) {
tree[node] = max(tree[node << 1], tree[(node << 1) | 1]);
}
void build3(int l, int r, int node) {
if (l == r) {
tree[node] = dep[l];
return;
}
int mid = (l + r) >> 1;
build3(l, mid, node << 1);
build3(mid + 1, r, (node << 1) | 1);
pushup(node);
}
void push(int node, int x) {
lazy[node] += x;
tree[node] += x;
}
void pushdown(int node) {
if (lazy[node]) {
push(node << 1, lazy[node]);
push((node << 1) | 1, lazy[node]);
lazy[node] = 0;
}
}
void update(int beg, int en, int l, int r, int node, int x) {
if (l > en || r < beg) return;
if (l >= beg && r <= en) {
push(node, x);
return;
}
int mid = (l + r) >> 1;
pushdown(node);
update(beg, en, l, mid, node << 1, x);
update(beg, en, mid + 1, r, (node << 1) | 1, x);
pushup(node);
}
void upd(int x, int l, int r, int node, int y) {
if (l == r) {
tree[node] = y;
return;
}
int mid = (l + r) >> 1;
pushdown(node);
if (x > mid)
upd(x, mid + 1, r, (node << 1) | 1, y);
else
upd(x, l, mid, node << 1, y);
pushup(node);
}
stack<int> s;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
build(1, n, 1);
build2(1, n, 1);
build3(1, n, 1);
mn = tree[1];
num = 0;
for (int i = 1; i <= n; i++) {
while (!s.empty() && s.top() >= a[i]) s.pop();
s.push(a[i]);
}
for (int i = 1; i < n; i++) {
if (query(i + 1, n, 1, n, 1).first < a[i]) {
l = i + 1;
r = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query(i + 1, mid, 1, n, 1).first > a[i])
l = mid + 1;
else
r = mid - 1;
}
update(i + 1, r, 1, n, 1, -1);
} else {
l = 1;
r = i - 1;
while (l <= r) {
mid = (l + r) >> 1;
if (query(1, mid, 1, n, 1).first > a[i])
l = mid + 1;
else
r = mid - 1;
}
update(i + 1, n, 1, n, 1, -1);
update(1, r, 1, n, 1, -1);
}
if (query(1, i - 1, 1, n, 1).first < a[i]) {
l = 1;
r = i - 1;
while (l <= r) {
mid = (l + r) >> 1;
if (query(mid, i - 1, 1, n, 1).first > a[i])
r = mid - 1;
else
l = mid + 1;
}
update(l, i - 1, 1, n, 1, 1);
} else {
l = i + 1;
r = n;
while (l <= r) {
mid = (l + r) >> 1;
if (query(mid, n, 1, n, 1).first > a[i])
r = mid - 1;
else
l = mid + 1;
}
update(l, n, 1, n, 1, 1);
update(1, i - 1, 1, n, 1, 1);
}
while (!s.empty() && s.top() >= a[i]) s.pop();
s.push(a[i]);
upd(i, 1, n, 1, (int)s.size());
if (tree[1] < mn) {
mn = tree[1];
num = i;
}
}
printf("%d %d\n", mn, num);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300000];
int b[300000];
int sparse[300000][20];
void shift_left(int t) {
for (int i = 0; i < n; i++) b[i] = a[(i + t) % n];
}
void construct_sparse() {
for (int i = 0; i < n; i++) sparse[i][0] = i;
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 0; i + (1 << j) <= n; i++) {
if (b[sparse[i + (1 << (j - 1))][j - 1]] < b[sparse[i][j - 1]])
sparse[i][j] = sparse[i + (1 << (j - 1))][j - 1];
else
sparse[i][j] = sparse[i][j - 1];
}
}
}
int find_min(int l, int r) {
int pmin = l;
int i = 0;
r++;
while (l < r) {
if ((r - l) & (1 << i)) {
if (b[pmin] > b[sparse[l][i]]) pmin = sparse[l][i];
l += (1 << i);
}
i++;
}
return pmin;
}
int find_depth(int l, int r) {
if (r < l) return 0;
if (r == l) return 1;
int m = find_min(l, r);
return 1 + max(find_depth(l, m - 1), find_depth(m + 1, r));
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int t = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
t = i;
break;
}
}
int l = t - (n - 1) + n;
int r = t + n;
shift_left(0);
construct_sparse();
pair<int, int> ans = {find_depth(0, n - 1), 0};
while (l < r) {
int m = (l + r) >> 1;
shift_left(m);
construct_sparse();
int depth_left = find_depth(0, t - (m - n) - 1);
int depth_right = find_depth(t - (m - n) + 1, n - 1);
int depth = max(depth_left, depth_right) + 1;
ans = min(ans, {depth, m - n});
if (depth_left < depth_right)
r = m;
else
l = m + 1;
}
int m = l;
shift_left(m);
construct_sparse();
int depth_left = find_depth(0, t - (m - n) - 1);
int depth_right = find_depth(t - (m - n) + 1, n - 1);
int depth = max(depth_left, depth_right) + 1;
ans = min(ans, {depth, m - n});
printf("%d %d", ans.first, (ans.second + 5 * n) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 10;
const int r = 1 << 18;
int treemin[2 * r];
int tmax[2 * r];
int tadd[2 * r];
int t0[maxN];
int t[maxN];
int N, shift0;
int last_idx;
int get_min_pos(int a, int b) {
a += r;
b += r;
int res = 0;
while (a < b) {
if (a & 1) {
if (t[res] > t[treemin[a]]) res = treemin[a];
a /= 2;
a++;
} else
a /= 2;
if (b & 1)
b /= 2;
else {
if (t[res] > t[treemin[b]]) res = treemin[b];
b /= 2;
b--;
}
}
if (a == b) {
if (t[res] > t[treemin[a]]) res = treemin[a];
}
return res;
}
void add(int za, int zb, int val, int ta = 0, int tb = r - 1, int x = 1) {
if (za <= ta && tb <= zb) {
tadd[x] += val;
tmax[x] += val;
return;
}
int avg = (ta + tb) / 2;
if (za <= avg) add(za, zb, val, ta, avg, 2 * x);
if (avg < zb) add(za, zb, val, avg + 1, tb, 2 * x + 1);
tmax[x] = tadd[x] + max(tmax[2 * x], tmax[2 * x + 1]);
}
int get_max(int za, int zb, int ta = 0, int tb = r - 1, int x = 1) {
if (za <= ta && tb <= zb) return tmax[x];
int avg = (ta + tb) / 2, res = -1e9;
if (za <= avg) res = max(res, get_max(za, zb, ta, avg, 2 * x));
if (avg < zb) res = max(res, get_max(za, zb, avg + 1, tb, 2 * x + 1));
return res + tadd[x];
}
int b0[maxN];
int b1[maxN];
void create_dep(int a, int b, int dp) {
int best = get_min_pos(a, b);
b0[best] = a;
b1[best] = b;
tmax[best + r] = dp;
if (a != best) create_dep(a, best - 1, dp + 1);
if (b != best) create_dep(best + 1, b, dp + 1);
}
void init() {
last_idx = N;
for (int i = 1; i <= N; ++i) {
treemin[i + r] = i;
}
for (int i = r - 1; i > 0; --i) {
treemin[i] = treemin[2 * i + 1];
if (t[treemin[i]] > t[treemin[2 * i]]) treemin[i] = treemin[2 * i];
}
create_dep(1, N, 1);
for (int i = r - 1; i > 0; --i) {
tmax[i] = max(tmax[2 * i], tmax[2 * i + 1]);
}
}
void move1() {
int idx = last_idx--;
if (b0[idx] != idx) add(b0[idx], idx - 1, -1);
int dep0 = get_max(idx, idx);
int dep1 = 2;
if (b1[idx] != N) dep1 = get_max(b1[idx] + 1, b1[idx] + 1) + 1;
add(idx, idx, dep1 - dep0);
if (b1[idx] != idx) add(idx + 1, b1[idx], 1);
}
void print_deps() {
for (int i = 0; i <= N; ++i) {
printf("%d ", get_max(i, i));
}
puts("");
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", t0 + i);
if (t0[i] == 1) shift0 = N - i;
}
for (int i = 0; i < N; ++i) t[1 + (i + shift0) % N] = t0[i];
t[0] = 1e9;
init();
int bestshift = 0, bestdep = tmax[1];
for (int i = 0; i < N - 1; ++i) {
move1();
if (tmax[1] < bestdep) {
bestdep = tmax[1];
bestshift = i + 1;
}
}
printf("%d %d\n", bestdep, (N - (bestshift + shift0) % N) % N);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
const int INF = 0x3f3f3f3f;
struct SegTree {
int t[N * 4], lazy[N * 4];
SegTree() {
memset(t, 0, sizeof(t));
memset(lazy, 0, sizeof(lazy));
};
void Pushdown(int o) {
if (!lazy[o]) return;
t[(o << 1)] += lazy[o];
t[(o << 1 | 1)] += lazy[o];
lazy[(o << 1)] += lazy[o];
lazy[(o << 1 | 1)] += lazy[o];
lazy[o] = 0;
}
void Maintain(int o) { t[o] = max(t[(o << 1)], t[(o << 1 | 1)]); }
void Modify(int o, int L, int R, int pos, int val) {
if (L == R) {
t[o] = val;
return;
}
Pushdown(o);
int M = (L + R) / 2;
if (pos <= M)
Modify((o << 1), L, M, pos, val);
else
Modify((o << 1 | 1), M + 1, R, pos, val);
Maintain(o);
}
void Add(int o, int L, int R, int qL, int qR, int det) {
if (qL > qR) return;
if (qL <= L && R <= qR) {
lazy[o] += det;
t[o] += det;
return;
}
Pushdown(o);
int M = (L + R) / 2;
if (qL <= M) Add((o << 1), L, M, qL, qR, det);
if (M + 1 <= qR) Add((o << 1 | 1), M + 1, R, qL, qR, det);
Maintain(o);
}
int Query(int o, int L, int R, int qL, int qR) {
if (qL > qR) return 0;
if (qL <= L && R <= qR) return t[o];
Pushdown(o);
int M = (L + R) / 2;
int ret = 0;
if (qL <= M) ret = max(ret, Query((o << 1), L, M, qL, qR));
if (M + 1 <= qR) ret = max(ret, Query((o << 1 | 1), M + 1, R, qL, qR));
Maintain(o);
return ret;
}
};
SegTree t;
int a[N];
int ch[N][2], pa[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
a[0] = -INF;
stack<int> stk;
stk.push(0);
for (int i = 1; i <= n; i++) {
while (a[stk.top()] > a[i]) stk.pop();
t.Add(1, 1, 2 * n, stk.top() + 1, i - 1, 1);
t.Modify(1, 1, 2 * n, i, stk.size());
int u = stk.top();
int v = ch[u][1];
ch[u][1] = i;
pa[i] = u;
ch[i][0] = v;
pa[v] = i;
stk.push(i);
}
int minAns = t.Query(1, 1, 2 * n, 1, n), minId = 0;
int bias = 0;
for (int i = n + 1; i <= 2 * n; i++) {
int u = pa[i - n];
int v = ch[i - n][1];
if (u == 0) {
bias++;
ch[u][1] = v;
pa[v] = u;
t.Add(1, 1, 2 * n, i - n + 1, i - 1, -1);
} else {
ch[u][0] = v;
pa[v] = u;
t.Add(1, 1, 2 * n, i - n + 1, u - 1, -1);
}
while (a[stk.top()] > a[i]) {
if (stk.top() <= i - n) bias--;
stk.pop();
}
t.Add(1, 1, 2 * n, stk.top() + 1, i - 1, 1);
t.Modify(1, 1, 2 * n, i, stk.size() - bias);
u = stk.top();
v = ch[u][1];
ch[u][1] = i;
pa[i] = u;
ch[i][0] = v;
pa[v] = i;
stk.push(i);
int nowAns = t.Query(1, 1, 2 * n, i - n + 1, i);
if (nowAns < minAns) {
minAns = nowAns;
minId = i - n;
}
}
cout << minAns << ' ' << minId;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static const long long L = 233333;
static char sxd[L], *sss = sxd, *ttt = sxd;
if (sss == ttt) {
ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
if (sss == ttt) {
return EOF;
}
}
return *sss++;
}
inline char readalpha() {
char c = gc();
for (; !isalpha(c); c = gc())
;
return c;
}
inline char readchar() {
char c = gc();
for (; c == ' '; c = gc())
;
return c;
}
template <class T>
inline bool read(T& x) {
bool flg = false;
char c = gc();
x = 0;
for (; !isdigit(c); c = gc()) {
if (c == '-') {
flg = true;
} else if (c == EOF) {
return false;
}
}
for (; isdigit(c); c = gc()) {
x = (x << 1) + (x << 3) + (c ^ 48);
}
if (flg) {
x = -x;
}
return true;
}
template <class T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10) {
putchar(x | 48);
return;
}
write(x / 10);
putchar((x % 10) | 48);
}
const int maxn = 200005;
const int inf = 0x3f3f3f3f;
int n;
int top;
int aa[maxn];
int bb[maxn];
int f[maxn];
int g[maxn];
int sta[maxn];
int dep[maxn];
int Ans[maxn];
inline int insert(int x) {
int ans = 0;
while (top && x < sta[top]) {
ans = max(dep[sta[top--]] + 1, ans);
}
ans = max(ans, top + 1);
dep[x] = ans;
ans = max(ans, Ans[sta[top]]);
return Ans[sta[++top] = x] = ans;
}
int main() {
read(n);
int pla = 0, cnt = 0;
for (int i = 1; i <= n; ++i) {
read(aa[i]);
if (aa[i] == 1) {
pla = i;
}
}
for (int i = pla + 1; i <= n; ++i) {
bb[++cnt] = aa[i];
}
for (int i = 1; i < n; ++i) {
bb[++cnt] = aa[i];
}
top = 0;
for (int i = 1; i < n; ++i) {
f[i] = insert(bb[i]);
}
top = 0;
for (int i = n - 1; i; --i) {
g[i] = insert(bb[i]);
}
int ans = g[1] + 1, xx = 0;
for (int i = 1; i < n - 1; ++i) {
int tx = max(f[i], g[i + 1]) + 1;
if (ans > tx) {
ans = tx;
xx = i;
}
}
xx++;
int fir = n - pla + 1;
int sec = n - xx;
int anss = (fir + sec) % n;
anss = (n - anss) % n;
printf("%d %d", ans, anss);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long seg_tree_f[400000 * 4 + 9];
long long 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, long long 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,
long long 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,
long long 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);
}
long long query_f(int node, int beg, int end, int i, int j) {
if (i > end || j < beg) return (1LL << 60);
if (beg >= i && end <= j) return seg_tree_f[node];
split_node_f(node);
int mid = (beg + end) >> 1;
long long leftnode = query_f((node << 1), beg, mid, i, j);
long long rightnode = query_f(((node << 1) | 1), mid + 1, end, i, j);
return min(leftnode, rightnode);
}
long long seg_tree[400000 * 4 + 9];
long long 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, long long 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);
}
long long query_leftmost(int node, int beg, int end, int i, int j,
long long 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);
}
long long query_rightmost(int node, int beg, int end, int i, int j,
long long 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);
}
long long query(int node, int beg, int end, int i, int j) {
if (i > end || j < beg) return (-(1LL << 60));
if (beg >= i && end <= j) return seg_tree[node];
split_node(node);
int mid = (beg + end) >> 1;
long long leftnode = query((node << 1), beg, mid, i, j);
long long rightnode = query(((node << 1) | 1), mid + 1, end, i, j);
return max(leftnode, rightnode);
}
long long MAP[400000 + 9];
long long ar[400000 + 9];
long long 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() {
long long 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;
const int N = 4e5 + 50;
int n, a[N];
int l[N], r[N];
int mx[N << 2], t[N << 2];
void up(int x) { mx[x] = max(mx[x << 1], mx[x << 1 | 1]) + t[x]; }
void mdf(int x, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) return mx[x] += v, t[x] += v, void();
if (L <= ((l + r) >> 1)) mdf(x << 1, l, ((l + r) >> 1), L, R, v);
if (R > ((l + r) >> 1)) mdf(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R, v);
up(x);
}
int ask(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) return mx[x];
int ans = 0;
if (L <= ((l + r) >> 1)) ans = max(ans, ask(x << 1, l, ((l + r) >> 1), L, R));
if (R > ((l + r) >> 1))
ans = max(ans, ask(x << 1 | 1, ((l + r) >> 1) + 1, r, L, R));
return ans + t[x];
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i + n] = a[i];
static int s[N];
int top = 0;
for (int i = 1; i <= n + n; i++) {
while (top && a[i] < a[s[top]]) --top;
l[i] = s[top];
s[++top] = i;
}
s[top = 0] = n + n + 1;
for (int i = n + n; i; i--) {
while (top && a[i] < a[s[top]]) --top;
r[i] = s[top];
s[++top] = i;
}
for (int i = 1; i <= n; i++) mdf(1, 1, n + n, l[i] + 1, r[i] - 1, 1);
int ans = n, mn = 0;
for (int i = 1; i <= n; i++) {
int z = ask(1, 1, n + n, i, i + n - 1);
if (z < ans) ans = z, mn = i - 1;
mdf(1, 1, n + n, l[i] + 1, r[i] - 1, -1);
mdf(1, 1, n + n, l[i + n] + 1, r[i + n] - 1, 1);
}
cout << ans << " " << mn << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], b[maxn], c[maxn], lson[maxn], rson[maxn], stk[maxn];
int vis[maxn];
int dep[maxn];
int rt, n;
void build() {
int top = 0;
for (int i = 1; i <= n; i++) {
lson[i] = rson[i] = 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) rson[stk[k - 1]] = i;
if (k < top) lson[i] = stk[k];
stk[k++] = i;
top = k;
}
for (int i = 1; i <= n; i++) {
vis[lson[i]] = vis[rson[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) rt = i;
}
}
void dfs(int u) {
dep[u] = 1;
if (lson[u]) dfs(lson[u]), dep[u] = max(dep[u], dep[lson[u]] + 1);
if (rson[u]) dfs(rson[u]), dep[u] = max(dep[u], dep[rson[u]] + 1);
}
pair<int, int> solve(int p) {
build();
dfs(rt);
if (dep[lson[rt]] <= dep[rson[rt]]) return {dep[rt], 0};
int l = 0, r = p - 1, shift, depth;
while (l <= r) {
int mid = l + r >> 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 (dep[lson[rt]] >= dep[rson[rt]]) {
l = mid + 1;
shift = mid;
depth = dep[rt];
} else
r = mid - 1;
for (int i = 1; i <= n; i++) a[i] = c[i];
}
l = 0, r = shift;
while (l <= r) {
int mid = l + r >> 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 (dep[rt] == depth) {
r = mid - 1;
shift = mid;
} else
l = mid + 1;
for (int i = 1; i <= n; i++) a[i] = c[i];
}
return {depth, shift};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
int p;
for (int i = 1; i <= n; i++) {
cin >> 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;
ans1 = min(ans1, ans2);
cout << ans1.first << " " << ans1.second << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 200005;
struct {
int L, R;
int pl, pr;
int mx, debt;
} T[4 * MX];
int tsz = 0;
int buildTree(int L, int R) {
int cur = tsz++;
T[cur].L = L;
T[cur].R = R;
if (L < R) {
T[cur].pl = buildTree(L, (L + R) / 2);
T[cur].pr = buildTree((L + R) / 2 + 1, R);
}
return cur;
}
void calcDebt(int cur) {
T[T[cur].pl].debt += T[cur].debt;
T[T[cur].pl].mx += T[cur].debt;
T[T[cur].pr].debt += T[cur].debt;
T[T[cur].pr].mx += T[cur].debt;
T[cur].debt = 0;
}
void add(int L, int R, int d, int cur) {
if (L <= T[cur].L && R >= T[cur].R) {
T[cur].debt += d;
T[cur].mx += d;
return;
}
calcDebt(cur);
if (L <= T[T[cur].pl].R) add(L, R, d, T[cur].pl);
if (R >= T[T[cur].pr].L) add(L, R, d, T[cur].pr);
T[cur].mx = max(T[T[cur].pl].mx, T[T[cur].pr].mx);
}
int get(int L, int R, int cur) {
if (L <= T[cur].L && R >= T[cur].R) return T[cur].mx;
calcDebt(cur);
int res = 0;
if (L <= T[T[cur].pl].R) res = max(res, get(L, R, T[cur].pl));
if (R >= T[T[cur].pr].L) res = max(res, get(L, R, T[cur].pr));
return res;
}
int pos[MX];
pair<int, int> seg[2 * MX];
int main() {
int n;
ignore = scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int a;
ignore = scanf("%d", &a);
pos[a] = i;
}
set<int> S;
S.insert(0);
S.insert(2 * n + 1);
for (int i = 1; i <= n; i++) {
auto ptr = S.lower_bound(pos[i]);
seg[pos[i]].second = *ptr - 1;
ptr = prev(ptr);
seg[pos[i]].first = *ptr + 1;
ptr = S.lower_bound(pos[i] + n);
seg[pos[i] + n].second = *ptr - 1;
ptr = prev(ptr);
seg[pos[i] + n].first = *ptr + 1;
S.insert(pos[i]);
S.insert(pos[i] + n);
}
int rt = buildTree(1, 2 * n);
for (int i = 1; i <= n; i++) {
add(seg[i].first, seg[i].second, 1, rt);
}
int ans = get(1, n, rt);
int ans_shift = 0;
for (int shift = 1; shift < n; shift++) {
add(seg[shift].first, seg[shift].second, -1, rt);
add(seg[shift + n].first, seg[shift + n].second, 1, rt);
int tmp = get(1 + shift, n + shift, rt);
if (tmp < ans) {
ans = tmp;
ans_shift = shift;
}
}
printf("%d %d\n", ans, ans_shift);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
template <typename T>
void read(T &x) {
char c = getchar();
int f = 0;
while (c < '0' || c > '9') f |= (c == '0'), c = getchar();
for (x = 0; c >= '0' && c <= '9'; c = getchar())
x = (x << 3) + (x << 1) + (c ^ '0');
if (f) x = -x;
}
int n, m;
int a[N], b[N], bl[N], br[N];
int mx[N], tag[N];
set<int> Set;
void pushdown(int x) {
mx[x << 1] += tag[x];
tag[x << 1] += tag[x];
mx[x << 1 | 1] += tag[x];
tag[x << 1 | 1] += tag[x];
tag[x] = 0;
}
void update(int x, int l, int r, int ql, int qr, int v) {
if (ql > qr) return;
if (ql <= l && r <= qr) {
mx[x] += v;
tag[x] += v;
return;
}
pushdown(x);
int mid = (l + r) >> 1;
if (mid >= ql) {
update(x << 1, l, mid, ql, qr, v);
}
if (mid < qr) {
update(x << 1 | 1, mid + 1, r, ql, qr, v);
}
mx[x] = max(mx[x << 1], mx[x << 1 | 1]);
}
int query(int x, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) {
return mx[x];
}
pushdown(x);
int mid = (l + r) >> 1, ans = 0;
if (mid >= ql) {
ans = max(ans, query(x << 1, l, mid, ql, qr));
}
if (mid < qr) {
ans = max(ans, query(x << 1 | 1, mid + 1, r, ql, qr));
}
return ans;
}
bool cmp(int x, int y) { return a[x] > a[y]; }
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(a[i]);
a[i] = n - a[i] + 1;
}
for (int i = 1; i <= n; ++i) a[i + n] = a[i];
for (int i = 1; i <= n; ++i) b[i] = i;
sort(b + 1, b + n + 1, cmp);
Set.insert(0);
Set.insert(2 * n + 1);
set<int>::iterator it;
for (int i = 1; i <= n; ++i) {
it = Set.lower_bound(b[i]);
br[b[i]] = *it;
bl[b[i]] = *(--it);
it = Set.lower_bound(b[i] + n);
br[b[i] + n] = *it;
bl[b[i] + n] = *(--it);
Set.insert(b[i]);
Set.insert(b[i] + n);
}
for (int i = 1; i <= n; ++i) {
update(1, 1, n * 2, bl[i] + 1, i - 1, 1);
update(1, 1, n * 2, i + 1, br[i] - 1, 1);
}
int ans = query(1, 1, n * 2, 1, n), del = 0;
for (int i = n + 1; i <= n * 2; ++i) {
update(1, 1, n * 2, bl[i - n] + 1, i - n - 1, -1);
update(1, 1, n * 2, i - n + 1, br[i - n] - 1, -1);
update(1, 1, n * 2, bl[i] + 1, i - 1, 1);
update(1, 1, n * 2, i + 1, br[i] - 1, 1);
int t = query(1, 1, n * 2, i - n + 1, i);
if (t < ans) {
ans = t;
del = i - n;
}
}
cout << ans + 1 << ' ' << del << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
const int oo = 1e9 + 5;
int du[] = {-1, 0, 0, 1};
int dv[] = {0, -1, 1, 0};
const long long mod = 1e9 + 7;
long long sqr(long long x) { return x * x; }
int n, vt, b[N + 5], a[N + 5], Pow[N + 5];
pair<int, int> f[18][N + 5];
void khoitao() {
Pow[1] = 0;
for (int i = 2; i <= n; i++) Pow[i] = Pow[i / 2] + 1;
for (int i = 1; i <= n; i++) f[0][i] = pair<int, int>(a[i], i);
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i + (1 << j) - 1 <= n; i++)
f[j][i] = min(f[j - 1][i], f[j - 1][i + (1 << (j - 1))]);
}
pair<int, int> getmin(int l, int r) {
int len = r - l + 1;
int g = Pow[len];
return min(f[g][l], f[g][r - (1 << g) + 1]);
}
int getdepth(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
int tmp = getmin(l, r).second;
return max(getdepth(l, tmp - 1), getdepth(tmp + 1, r)) + 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] == 1) vt = i;
}
for (int i = vt + 1; i <= n; i++) a[i - vt] = b[i];
for (int i = 1; i < vt; i++) a[n - vt + i] = b[i];
n--;
khoitao();
int l = 1, r = n;
int tmp1, tmp2;
while (l <= r) {
int mid = (l + r) / 2;
tmp1 = getdepth(1, mid);
tmp2 = getdepth(mid + 1, n);
if (tmp1 <= tmp2)
l = mid + 1;
else
r = mid - 1;
}
tmp1 = getdepth(1, r);
tmp2 = getdepth(r + 1, n);
int res = max(tmp1, tmp2);
tmp1 = getdepth(1, l);
tmp2 = getdepth(l + 1, n);
if (res < max(tmp1, tmp2)) {
cout << res + 1 << " " << (vt + r) % (n + 1);
} else
cout << max(tmp1, tmp2) + 1 << " " << (vt + l) % (n + 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400000 + 10;
int n, a[N];
namespace ZYH {
int n, T, stk[N], top;
struct Tree {
int lson, rson, val, id;
} tree[N];
struct Nod {
int l, r, rt, d;
};
int build() {
if (n == 0) return 0;
stk[top = 1] = 1;
for (int i = 2; i <= n; i++) {
while (top >= 1 && tree[i].val > tree[stk[top]].val) top--;
if (top)
tree[i].lson = tree[stk[top]].rson, tree[stk[top]].rson = i;
else
tree[i].lson = stk[1];
stk[++top] = i;
}
queue<Nod> q;
q.push((Nod){1, n, stk[1], 1});
int mx = 0;
while (q.size()) {
Nod now = q.front();
q.pop();
int l = now.l, r = now.r, rt = now.rt;
if (r == l) continue;
int mid = tree[rt].id;
if (l <= mid - 1) q.push((Nod){l, mid - 1, tree[rt].lson, now.d + 1});
if (r >= mid + 1) q.push((Nod){mid + 1, r, tree[rt].rson, now.d + 1});
mx = max(mx, now.d + 1);
}
return mx;
}
}; // namespace ZYH
int getDep(int l, int r) {
ZYH::n = r - l + 1;
for (int i = 1; i <= r - l + 1; i++) {
ZYH::tree[i].val = -a[i + l - 1];
ZYH::tree[i].id = i;
}
return ZYH::build();
}
int main() {
scanf("%d", &n);
int p1, p2;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i + n] = a[i];
if (a[i] == 1) {
p1 = i;
p2 = i + n;
}
}
int lef = 0, rig = n - 1;
while (rig - lef > 1) {
int mid = (lef + rig) >> 1;
int vL = getDep(p2 - mid, p2 - 1);
int vR = getDep(p1 + 1, p1 + n - 1 - mid);
if (vL <= vR) {
lef = mid;
} else {
rig = mid;
}
}
int ans = N, bst = 0;
for (int mid = max(lef - 2, 0); mid <= min(n - 1, lef + 2); mid++) {
int vL = getDep(p2 - mid, p2 - 1);
int vR = getDep(p1 + 1, p1 + n - 1 - mid);
if (ans > max(vL, vR) + 1) {
ans = max(vL, vR) + 1;
bst = mid;
}
}
printf("%d ", ans);
int id = bst + 1;
if (id < p1) {
printf("%d\n", p1 - id == n ? 0 : p1 - id);
} else {
printf("%d\n", p1 + n - id == n ? 0 : p1 + n - id);
}
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
const long long maxn = 4e5 + 5, N = 1e6 + 20, SQ = 450, base = 800287,
mod = 1e9 + 7, INF = 1e18 + 5, lg = 20;
const long double eps = 1e-4;
struct node {
long long mx, lazy;
};
stack<long long> st;
node seg[4 * maxn];
long long n, a[maxn], L[maxn], R[maxn];
void build(long long v = 1, long long s = 0, long long e = 2 * n) {
if (e - s == 1) {
long long x = (s < n ? 0 : -INF);
seg[v].mx = x;
seg[v].lazy = 0;
return;
}
build(2 * v, s, (s + e) / 2);
build(2 * v + 1, (s + e) / 2, e);
seg[v].lazy = 0;
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
}
void find_L() {
for (long long i = 0; i < 2 * n; ++i) {
while ((long long)st.size() && a[st.top()] > a[i]) {
st.pop();
}
L[i] = ((long long)st.size() ? st.top() : -1);
st.push(i);
}
while ((long long)st.size()) {
st.pop();
}
}
void find_R() {
for (long long i = 2 * n - 1; i >= 0; --i) {
while ((long long)st.size() && a[st.top()] > a[i]) {
st.pop();
}
R[i] = ((long long)st.size() ? st.top() : 2 * n);
st.push(i);
}
while ((long long)st.size()) {
st.pop();
}
}
inline void shift(long long v) {
seg[2 * v].mx += seg[v].lazy;
seg[2 * v + 1].mx += seg[v].lazy;
seg[2 * v].lazy += seg[v].lazy;
seg[2 * v + 1].lazy += seg[v].lazy;
seg[v].lazy = 0;
}
void add(long long l, long long r, long long x, long long v = 1,
long long s = 0, long long e = 2 * n) {
if (l >= e || s >= r) {
return;
}
if (l <= s && e <= r) {
seg[v].mx += x;
seg[v].lazy += x;
return;
}
shift(v);
add(l, r, x, 2 * v, s, (s + e) / 2);
add(l, r, x, 2 * v + 1, (s + e) / 2, e);
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
}
void modify(long long p, long long x, long long v = 1, long long s = 0,
long long e = 2 * n) {
if (e - s == 1) {
seg[v].mx = x;
return;
}
shift(v);
if (p < (s + e) / 2) {
modify(p, x, 2 * v, s, (s + e) / 2);
} else {
modify(p, x, 2 * v + 1, (s + e) / 2, e);
}
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
}
long long get(long long p, long long v = 1, long long s = 0,
long long e = 2 * n) {
if (e - s == 1) {
return seg[v].mx;
}
shift(v);
long long res;
if (p < (s + e) / 2) {
res = get(p, 2 * v, s, (s + e) / 2);
} else {
res = get(p, 2 * v + 1, (s + e) / 2, e);
}
seg[v].mx = max(seg[2 * v].mx, seg[2 * v + 1].mx);
return res;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; ++i) {
cin >> a[i];
a[i + n] = a[i];
}
build();
find_L();
find_R();
for (long long i = 0; i < n; ++i) {
add(L[i] + 1, i, 1);
add(i + 1, R[i], 1);
}
long long res = INF, id = -1;
for (long long i = 0; i < n; ++i) {
if (seg[1].mx < res) {
res = seg[1].mx;
id = i;
}
long long val = (L[i + n] <= i ? 0 : get(L[i + n]) + 1);
add(i + 1, R[i], -1);
add(L[i + n] + 1, i + n, 1);
modify(i, -INF), modify(i + n, val);
}
cout << res + 1 << ' ' << id << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
namespace output {
void __(short x) { cout << x; }
void __(unsigned x) { cout << x; }
void __(int x) { cout << x; }
void __(long long x) { cout << x; }
void __(unsigned long long x) { cout << x; }
void __(double x) { cout << x; }
void __(long double x) { cout << x; }
void __(char x) { cout << x; }
void __(const char* x) { cout << x; }
void __(const string& x) { cout << x; }
void __(bool x) { cout << (x ? "true" : "false"); }
template <class S, class T>
void __(const pair<S, T>& x) {
__(1 ? "(" : ""), __(x.first), __(1 ? ", " : " "), __(x.second),
__(1 ? ")" : "");
}
template <class T>
void __(const vector<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const set<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class T>
void __(const multiset<T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
template <class S, class T>
void __(const map<S, T>& x) {
__(1 ? "{" : "");
bool _ = 0;
for (const auto& v : x) __(_ ? 1 ? ", " : " " : ""), __(v), _ = 1;
__(1 ? "}" : "");
}
void pr() { cout << "\n"; }
template <class S, class... T>
void pr(const S& a, const T&... b) {
__(a);
if (sizeof...(b)) __(' ');
pr(b...);
}
} // namespace output
using namespace output;
const int MN = 2e5 + 5;
int n, ans, sh, i, x, arr[MN], st[3 * MN], id[3 * MN], dp[3 * MN], lz[3 * MN],
p[MN], l[MN], r[MN], f, s;
void build(int i, int s, int e) {
if (s != e) {
build(2 * i, s, (s + e) / 2);
build(2 * i + 1, (s + e) / 2 + 1, e);
id[i] = (st[2 * i] > st[2 * i + 1]) ? id[2 * i] : id[2 * i + 1];
st[i] = max(st[2 * i], st[2 * i + 1]);
} else
st[i] = -arr[s], id[i] = s;
}
pair<int, int> qu(int i, int s, int e, int ss, int se) {
if (s >= ss && e <= se)
return make_pair(st[i], id[i]);
else if ((s + e) / 2 < ss)
return qu(2 * i + 1, (s + e) / 2 + 1, e, ss, se);
else if ((s + e) / 2 >= se)
return qu(2 * i, s, (s + e) / 2, ss, se);
else {
pair<int, int> l = qu(2 * i, s, (s + e) / 2, ss, se),
r = qu(2 * i + 1, (s + e) / 2 + 1, e, ss, se);
return l.first > r.first ? l : r;
}
}
inline void upd_lz(int i, int s, int e) {
if (lz[i]) {
dp[i] += lz[i];
if (s != e) lz[2 * i] += lz[i], lz[2 * i + 1] += lz[i];
lz[i] = 0;
}
}
void upd(int i, int s, int e, int ss, int se, int val) {
if (ss > se) return;
upd_lz(i, s, e);
if (s >= ss && e <= se) {
lz[i] = val;
upd_lz(i, s, e);
} else {
if ((s + e) / 2 < ss) {
upd_lz(2 * i, s, (s + e) / 2);
upd(2 * i + 1, (s + e) / 2 + 1, e, ss, se, val);
} else if ((s + e) / 2 >= se) {
upd_lz(2 * i + 1, (s + e) / 2 + 1, e);
upd(2 * i, s, (s + e) / 2, ss, se, val);
} else {
upd(2 * i, s, (s + e) / 2, ss, se, val);
upd(2 * i + 1, (s + e) / 2 + 1, e, ss, se, val);
}
dp[i] = max(dp[2 * i], dp[2 * i + 1]);
}
}
int qur(int i, int s, int e, int ss, int se) {
upd_lz(i, s, e);
if (s >= ss && e <= se)
return dp[i];
else if ((s + e) / 2 < ss)
return qur(2 * i + 1, (s + e) / 2 + 1, e, ss, se);
else if ((s + e) / 2 >= se)
return qur(2 * i, s, (s + e) / 2, ss, se);
else
return max(qur(2 * i, s, (s + e) / 2, ss, se),
qur(2 * i + 1, (s + e) / 2 + 1, e, ss, se));
}
int init(int s, int e, int d) {
if (s > e) return 0;
int rt = qu(1, 1, n, s, e).second;
upd(1, 1, n, rt, rt, d);
int ls = init(s, rt - 1, d + 1), rs = init(rt + 1, e, d + 1);
p[ls] = p[rs] = rt;
l[rt] = ls, r[rt] = rs;
return rt;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
build(1, 1, n);
init(1, n, 1);
ans = qur(1, 1, n, 1, n);
int lst = 1;
for (i = 0; i < n - 1; i++) {
if (!p[n - i])
upd(1, 1, n, 1, n, -1);
else if (p[n - i] <= n - i)
upd(1, 1, n, p[n - i] + 1, n - i - 1, -1);
else
upd(1, 1, n, p[n - i] + 1, n, -1), upd(1, 1, n, 1, n - i - 1, -1);
upd(1, 1, n, n - i, n - i, -qur(1, 1, n, n - i, n - i));
r[p[n - i]] = l[n - i];
p[l[n - i]] = p[n - i];
l[n - i] = 0;
int c = lst;
while (arr[c] > arr[n - i] && p[c]) c = p[c];
if (arr[c] > arr[n - i]) {
upd(1, 1, n, 1, n, 1);
p[n - i] = 0;
r[n - i] = c;
p[c] = n - i;
} else {
p[n - i] = c;
r[n - i] = l[c];
l[c] = n - i;
p[r[n - i]] = n - i;
upd(1, 1, n, n - i, n - i, qur(1, 1, n, c, c) + 1);
if (c >= n - i)
upd(1, 1, n, n - i + 1, c - 1, 1);
else
upd(1, 1, n, n - i + 1, n, 1), upd(1, 1, n, 1, c - 1, 1);
}
int tmp = qur(1, 1, n, 1, n);
if (tmp < ans) {
ans = tmp;
sh = n - i - 1;
}
lst = n - i;
}
printf("%d %d\n", ans, sh);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 7;
const int inf = INT_MAX;
const long long inff = 1e18;
const long long mod = 1e9 + 7;
int n;
int a[maxn];
int seg[maxn], tag[maxn];
int L[maxn], R[maxn], P[maxn];
vector<int> v, u;
void push(int now, int l, int r) {
if (l == r) {
tag[now] = 0;
return;
}
seg[now * 2] += tag[now];
seg[now * 2 + 1] += tag[now];
tag[now * 2] += tag[now];
tag[now * 2 + 1] += tag[now];
tag[now] = 0;
}
void modify(int now, int l, int r, int ql, int qr, int v) {
if (r < ql || l > qr)
return;
else if (l >= ql && r <= qr) {
seg[now] += v;
tag[now] += v;
return;
}
int m = (l + r) >> 1;
push(now, l, r);
modify(now * 2, l, m, ql, qr, v);
modify(now * 2 + 1, m + 1, r, ql, qr, v);
seg[now] = max(seg[now * 2], seg[now * 2 + 1]);
}
int query(int now, int l, int r, int ql, int qr) {
if (r < ql || l > qr)
return -inf;
else if (l >= ql && r <= qr)
return seg[now];
int m = (l + r) >> 1;
push(now, l, r);
return max(query(now * 2, l, m, ql, qr),
query(now * 2 + 1, m + 1, r, ql, qr));
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
a[0] = a[n + 1] = -1;
v.push_back(0);
for (int i = 1; i <= n; i++) {
while (a[v.back()] > a[i]) v.pop_back();
if (v.back() + 1 != i) modify(1, 1, 2 * n, v.back() + 1, i - 1, 1);
v.push_back(i);
}
v.clear();
v.push_back(n + 1);
for (int i = n; i >= 1; i--) {
while (a[v.back()] > a[i]) v.pop_back();
if (v.back() - 1 != i) modify(1, 1, 2 * n, i + 1, v.back() - 1, 1);
v.push_back(i);
}
a[0] = a[2 * n + 1] = -1;
for (int i = 1; i <= n; i++) a[i + n] = a[i];
v.clear();
v.push_back(0), u.push_back(0);
for (int i = 1; i <= 2 * n; i++) {
while (a[v.back()] > a[i]) v.pop_back();
while (a[u.back()] >= a[i]) u.pop_back();
if (i > n) {
L[i - n] = v.back() + 1;
P[i - n] = ((int)(u).size()) - 1;
}
v.push_back(i);
u.push_back(i);
}
v.clear();
v.push_back(2 * n + 1);
for (int i = 2 * n; i >= 1; i--) {
while (a[v.back()] > a[i]) v.pop_back();
if (i <= n) R[i] = v.back() - 1;
v.push_back(i);
}
pair<int, int> ans = make_pair(query(1, 1, 2 * n, 1, n), 0);
for (int i = 1; i <= n - 1; i++) {
modify(1, 1, 2 * n, i, R[i], -1);
modify(1, 1, 2 * n, L[i], n + i, 1);
modify(1, 1, 2 * n, n + i, n + i, -query(1, 1, 2 * n, n + i, n + i) + P[i]);
ans = min(ans, make_pair(query(1, 1, 2 * n, i + 1, n + i), i));
}
cout << ans.first + 1 << ' ' << ans.second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXINT = numeric_limits<int>::max();
struct ans_t {
int depth, shift;
ans_t(int d, int s) : depth(d), shift(s) {}
};
class Solver {
public:
Solver(vector<int> const& a) : _a(a.size(), 0), _n(a.size()), _s(0) {
int m = a[0], s = 0;
for (int i = 0; i < _n; ++i) {
if (a[i] < m) {
m = a[i];
s = i;
}
}
_s = s + 1;
for (int i = 0; i < _n; ++i) _a[i] = a[(i + _s) % _n];
build_rmq();
}
ans_t solve() {
int a = 0, b = _n;
while (a + 1 < b) {
int c = (a + b) >> 1;
if (depth(0, c) <= depth(c, _n - 1))
a = c;
else
b = c;
}
int bestd = test_shift(a), bests = a;
if (a + 1 < _n) {
int d = test_shift(a + 1);
if (d < bestd) {
bestd = d;
bests = a + 1;
}
}
return ans_t(bestd, (_s + bests) % _a.size());
}
private:
void build_rmq() {
if (!_rmq.empty()) return;
int s = 1;
_rmq.emplace_back(_n);
for (int i = 0; i < _n; ++i) _rmq[0][i] = i;
for (int a = 0; 2 * s <= _n; ++a, s <<= 1) {
int n = _n - 2 * s;
_rmq.emplace_back(n + 1);
for (int i = 0; i <= n; ++i) {
int m0 = _rmq[a][i], m1 = _rmq[a][i + s];
_rmq[a + 1][i] = (_a[m1] < _a[m0]) ? m1 : m0;
}
}
}
int min_idx(int i, int j) {
int a = 31 - __builtin_clz(j - i);
int m0 = _rmq[a][i], m1 = _rmq[a][j - (1 << a)];
return (_a[m1] < _a[m0]) ? m1 : m0;
}
int depth(int i, int j) {
queue<segment_t> q;
int r = 0;
if (i < j) q.emplace(i, j, 1);
while (!q.empty()) {
const auto x = q.front();
q.pop();
r = max(r, x.depth);
int mid = min_idx(x.begin, x.end);
if (x.begin < mid) q.emplace(x.begin, mid, x.depth + 1);
if (mid + 1 < x.end) q.emplace(mid + 1, x.end, x.depth + 1);
}
return r;
}
int test_shift(int s) { return 1 + max(depth(0, s), depth(s, _n - 1)); }
private:
vector<int> _a;
vector<vector<int>> _rmq;
int _n, _s;
struct segment_t {
int begin, end, depth;
segment_t(int b, int e, int d) : begin(b), end(e), depth(d) {}
};
};
int main() {
int n, s;
cin >> n;
vector<int> a(n, 0);
for (int i = 0; i < n; ++i) cin >> a[i];
ans_t r = Solver(a).solve();
cout << r.depth << " " << r.shift << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long ool = 1e18 + 9;
const int oo = 1e9 + 9, base = 1e9 + 7;
const double eps = 1e-7;
const int N = 4e5 + 6;
struct SegTree {
int sz;
pair<int, int> mn[N * 4];
int mxd[N * 4], add[N * 4];
void recalc(int v) {
mn[v] = min(mn[v << 1], mn[v << 1 | 1]);
mxd[v] = max(mxd[v << 1], mxd[v << 1 | 1]);
}
void push(int v, int tl, int tr) {
if (tl != tr - 1) {
add[v << 1] += add[v];
add[v << 1 | 1] += add[v];
}
mxd[v] += add[v];
add[v] = 0;
}
void build(int *a, int _sz) {
sz = _sz;
_build(1, 1, sz + 1, a);
}
void _build(int v, int tl, int tr, int *a) {
if (tl == tr - 1) {
mn[v] = {a[tl], 0};
return;
}
int mid = (tl + tr) >> 1;
_build(v << 1, tl, mid, a);
_build(v << 1 | 1, mid, tr, a);
recalc(v);
}
void updDepth(int l, int r, int val) {
_updDepth(1, 1, sz + 1, l, r + 1, val);
}
void _updDepth(int v, int tl, int tr, int ql, int qr, int val) {
push(v, tl, tr);
if (qr <= tl || tr <= ql) return;
if (ql <= tl && tr <= qr) {
add[v] += val;
push(v, tl, tr);
return;
}
int mid = (tl + tr) >> 1;
_updDepth(v << 1, tl, mid, ql, qr, val);
_updDepth(v << 1 | 1, mid, tr, ql, qr, val);
recalc(v);
}
int getMaxDepth(int l, int r) { return _getMaxDepth(1, 1, sz + 1, l, r + 1); }
int _getMaxDepth(int v, int tl, int tr, int ql, int qr) {
push(v, tl, tr);
if (qr <= tl || tr <= ql) return -1;
if (ql <= tl && tr <= qr) return mxd[v];
int mid = (tl + tr) >> 1;
return max(_getMaxDepth(v << 1, tl, mid, ql, qr),
_getMaxDepth(v << 1 | 1, mid, tr, ql, qr));
}
pair<int, int> getMin(int l, int r) {
return _getMin(1, 1, sz + 1, l, r + 1);
}
pair<int, int> _getMin(int v, int tl, int tr, int ql, int qr) {
push(v, tl, tr);
if (qr <= tl || tr <= ql) return {oo, 0};
if (ql <= tl && tr <= qr) return mn[v];
int mid = (tl + tr) >> 1;
return min(_getMin(v << 1, tl, mid, ql, qr),
_getMin(v << 1 | 1, mid, tr, ql, qr));
}
} t;
int n, a[N], ind[N], prv[N], nxt[N];
void init(int l, int r, int depth) {
if (r < l) return;
int mn = t.getMin(l, r).first;
int pos = ind[mn];
t.updDepth(pos, pos, depth);
init(l, pos - 1, depth + 1);
init(pos + 1, r, depth + 1);
}
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];
ind[a[i]] = i;
}
for (int i = n + 1; i <= n + n; ++i) {
a[i] = a[i - n];
}
stack<int> st;
for (int i = 1; i <= n + n; ++i) {
while ((int)st.size() && a[st.top()] > a[i]) {
st.pop();
}
if ((int)st.size())
prv[i] = st.top();
else
prv[i] = 0;
st.push(i);
}
while ((int)st.size()) st.pop();
for (int i = n + n; i >= 1; --i) {
while ((int)st.size() && a[st.top()] > a[i]) {
st.pop();
}
if ((int)st.size())
nxt[i] = st.top();
else
nxt[i] = n + n + 1;
st.push(i);
}
t.build(a, n + n);
init(1, n, 0);
int ans = t.getMaxDepth(1, n);
int ansPos = 0;
for (int i = 1; i <= n - 1; ++i) {
int pos = i + n;
if (a[i] != 1) pos = nxt[i];
t.updDepth(i + 1, pos - 1, -1);
pos = i;
if (a[i] != 1) pos = prv[i + n];
t.updDepth(pos + 1, i + n - 1, 1);
int newDepth = t.getMaxDepth(pos, pos) + (a[i] != 1);
t.updDepth(i + n, i + n, newDepth);
int height = t.getMaxDepth(i + 1, i + n);
if (height < ans) {
ans = height;
ansPos = i;
}
}
cout << ans + 1 << " " << ansPos << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct segtree {
long long n, h;
vector<long long> t;
vector<long long> d;
segtree(vector<long long>& a) {
n = a.size();
t = vector<long long>(n << 1 | 1, 0);
d = vector<long long>(n << 1 | 1);
h = sizeof(long long) * 8 - __builtin_clz(n);
}
void apply(long long p, long long val) {
t[p] += val;
if (p < n) d[p] += val;
}
void build(long long p) {
while (p > 1) p >>= 1, t[p] = max(t[p << 1], t[p << 1 | 1]) + d[p];
}
void push(long long p) {
for (long long s = h; s > 0; --s) {
long long i = p >> s;
if (d[i] != 0) {
apply(i << 1, d[i]);
apply(i << 1 | 1, d[i]);
d[i] = 0;
}
}
}
void inc(long long l, long long r, long long val) {
if (l >= r) return;
l += n, r += n;
long long l0 = l, r0 = r;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) apply(l++, val);
if (r & 1) apply(--r, val);
}
build(l0);
build(r0 - 1);
}
long long query(long long l, long long r) {
if (l >= r) return 0;
l += n, r += n;
push(l), push(r - 1);
long long ret = 0;
while (l < r) {
if (l & 1) {
ret = max(ret, t[l++]);
}
if (r & 1) {
ret = max(ret, t[--r]);
}
l >>= 1, r >>= 1;
}
return ret;
}
};
int32_t main() {
long long n;
cin >> n;
vector<long long> a(2 * n);
for (long long i = 0; i < n; ++i) {
cin >> a[i];
a[i + n] = a[i];
}
stack<pair<long long, long long>> s;
vector<long long> nxt(2 * n, 2 * n), prev(n << 1, -1);
for (long long i = 0; i < 2 * n; ++i) {
while (!s.empty() && a[i] < s.top().first) s.pop();
if (!s.empty()) prev[i] = s.top().second;
s.push({a[i], i});
}
s = stack<pair<long long, long long>>();
for (long long i = 2 * n - 1; i >= 0; --i) {
while (!s.empty() && a[i] < s.top().first) s.pop();
if (!s.empty()) nxt[i] = s.top().second;
s.push({a[i], i});
}
vector<long long> h(2 * n);
segtree T = segtree(h);
for (long long i = 0; i < n; ++i) {
T.inc(i + 1, min(n, nxt[i]), 1);
T.inc(prev[i] + 1, i, 1);
}
long long hmin = INT_MAX, shift = 0;
for (long long s = 0; s < n; ++s) {
long long hs = T.query(s, s + n);
if (hmin > hs) {
hmin = hs;
shift = s;
}
T.inc(s + 1, min(s + n, nxt[s]), -1);
if (s < n) {
T.inc(prev[s + n] + 1, s + n, 1);
if (prev[s + n] >= s + 1) {
long long p = T.query(prev[s + n], prev[s + n] + 1);
T.inc(s + n, s + n + 1, 1 + p);
}
}
}
cout << hmin + 1 << " " << shift;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ul = unsigned long long;
using ld = long double;
const int N = 1 << 18;
int dp[2][N];
int tr[N * 2], mod[N * 2];
void push(int v) {
tr[v] += mod[v];
if (v < N) {
mod[v * 2] += mod[v];
mod[v * 2 + 1] += mod[v];
}
mod[v] = 0;
}
void rel(int v) { tr[v] = max(tr[v * 2], tr[v * 2 + 1]); }
void add(int cl, int cr, int d, int v = 1, int l = 0, int r = N) {
if (cr <= l || r <= cl) {
push(v);
return;
}
if (cl <= l && r <= cr) {
mod[v] += d;
push(v);
return;
}
push(v);
add(cl, cr, d, v * 2, l, (l + r) / 2);
add(cl, cr, d, v * 2 + 1, (l + r) / 2, r);
rel(v);
}
int get(int v) {
int res = tr[N + v];
for (int i = N + v; i; i /= 2) res += mod[i];
return res;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, mp = 0;
cin >> n;
deque<int> a(n);
for (int i = 0; i < (n); i++) {
cin >> a[i];
a[i]--;
if (a[i] == 0) mp = i;
}
for (int i = 0; i < (mp); i++) {
a.push_back(a[0]);
a.pop_front();
}
a.pop_front();
for (int z = 0; z < (2); z++) {
vector<int> st{-1};
memset(tr, 0, N * 2 * sizeof(int));
memset(mod, 0, N * 2 * sizeof(int));
for (int i = 0; i < (n - 1); i++) {
while (st.size() > 1 && a[st.back()] > a[i]) st.pop_back();
add(st.back() + 1, i, 1);
add(i, i + 1, st.size() == 1 ? 1 : get(st.back()) + 1);
dp[z][i + 1] = tr[1];
st.push_back(i);
}
reverse((a).begin(), (a).end());
}
int ans = n + 1, res = 0, ca;
for (int i = 0; i < (n); i++) {
ca = max(dp[0][i], dp[1][n - 1 - i]) + 1;
if (ca < ans) {
ans = ca;
res = i;
}
}
cout << ans << ' ' << (res + 1 + mp) % n;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2000011 * 2;
int n, m, k, a[M / 4], mn[M], pos1, pos2;
void built(int now, int l, int r) {
if (l == r) {
mn[now] = l;
return;
}
int mid = (l + r) >> 1;
built(now * 2, l, mid);
built(now * 2 + 1, mid + 1, r);
if (a[mn[now * 2]] < a[mn[now * 2 + 1]])
mn[now] = mn[now * 2];
else
mn[now] = mn[now * 2 + 1];
}
int ask(int now, int l, int r, int L, int R) {
if (l >= L && r <= R) return mn[now];
int mid = (l + r) >> 1, tmp = 0, k;
if (L <= mid) tmp = ask(now * 2, l, mid, L, R);
if (R > mid) {
k = ask(now * 2 + 1, mid + 1, r, L, R);
if (!tmp || a[k] < a[tmp]) tmp = k;
}
return tmp;
}
int dfs(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
int x = ask(1, 1, n + n + n, l, r);
return max(dfs(l, x - 1), dfs(x + 1, r)) + 1;
}
int check(int l, int r) {
int x;
if (r >= pos2)
x = pos2;
else
x = pos1;
int y = dfs(l, x - 1) - dfs(x + 1, r);
return y;
}
int main() {
scanf("%d", &n);
memset(mn, 0x3f, sizeof(mn));
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]), a[i + n] = a[i + n + n] = a[i];
for (int i = 1; i <= n; i++)
if (a[i] == 1) pos1 = i, pos2 = i + n;
built(1, 1, n + n + n);
int l = pos1, r = pos2 - 1, mid, tmp = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid, mid + n - 1) >= 0)
tmp = mid, l = mid + 1;
else
r = mid - 1;
}
l = 1, r = n, mid;
int tmp_ = 0;
while (l <= r) {
mid = (l + r) >> 1;
if (check(mid, mid + n - 1) <= 0)
tmp_ = mid, r = mid - 1;
else
l = mid + 1;
}
if (tmp_ && (!tmp || dfs(tmp, tmp + n - 1) > dfs(tmp_, tmp_ + n - 1)))
tmp = tmp_;
printf("%d %d", dfs(tmp, tmp + n - 1), (tmp - 1) % n);
}
|
#include <bits/stdc++.h>
using namespace std;
namespace SGT {
int maxn[1600000], addv[1600000];
inline void pushdown(int o) {
if (addv[o]) {
addv[o * 2] += addv[o];
addv[o * 2 + 1] += addv[o];
maxn[o * 2] += addv[o];
maxn[o * 2 + 1] += addv[o];
addv[o] = 0;
}
}
inline void pushup(int o) { maxn[o] = max(maxn[o * 2], maxn[o * 2 + 1]); }
void update(int l, int r, int o, int lx, int rx, int p) {
if (l >= lx && r <= rx) {
addv[o] += p;
maxn[o] += p;
} else {
pushdown(o);
int m = ((l + r) >> 1);
if (m >= lx) update(l, m, o * 2, lx, rx, p);
if (m < rx) update(m + 1, r, o * 2 + 1, lx, rx, p);
pushup(o);
}
}
int query() { return maxn[1]; }
} // namespace SGT
int num[400005];
int q[400005], r[400005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &num[i]);
num[n + i] = num[i];
}
int lx = 1, rx = 0;
for (int i = 2 * n; i > 0; i--) {
while (rx && num[q[rx]] > num[i]) rx--;
r[i] = q[rx] - 1;
q[++rx] = i;
}
rx = 0;
int minn = n, id = 0;
for (int i = 1; i < 2 * n; i++) {
while (lx <= rx && num[q[rx]] >= num[i]) rx--;
while (lx <= rx && q[lx] <= i - n) lx++;
if (i > n) {
SGT::update(1, 2 * n, 1, i - n, i - n, -n);
if (i - n < r[i - n]) SGT::update(1, 2 * n, 1, i - n + 1, r[i - n], -1);
}
if (lx <= rx) {
if (q[rx] + 1 < i) SGT::update(1, 2 * n, 1, q[rx] + 1, i - 1, 1);
} else if (i > 1)
SGT::update(1, 2 * n, 1, max(1, i - n + 1), i - 1, 1);
q[++rx] = i;
SGT::update(1, 2 * n, 1, i, i, rx - lx + 1);
if (i >= n) {
int v = SGT::query();
if (v < minn) {
minn = v;
id = i - n;
}
}
}
printf("%d %d\n", minn, id);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
int n, a[N], init[N];
int arr[N], tree[N], len = 0;
int inv[N];
int query(int l, int r) {
l += len;
r += len;
int answer = 1e9;
for (; l <= r; l /= 2, r /= 2) {
if (l % 2 == 1) {
answer = min(answer, tree[l++]);
}
if (r % 2 == 0) {
answer = min(answer, tree[r--]);
}
}
return answer;
}
int solve(int l, int r) {
if (l > r) {
return 0;
}
if (l == r) {
return 1;
}
int m = inv[query(l, r)];
assert(l <= m && m <= r);
return 1 + max(solve(l, m - 1), solve(m + 1, r));
}
int func() {
for (int i = len; i < 2 * len; ++i) {
tree[i] = arr[i - len];
}
for (int i = len - 1; i > 0; --i) {
tree[i] = min(tree[2 * i], tree[2 * i + 1]);
}
for (int i = 0; i < len; ++i) {
inv[arr[i]] = i;
}
return solve(0, len - 1);
}
int fl(int pos) {
len = 0;
for (int i = -pos; i < 0; ++i) {
arr[len++] = a[(i + n) % n];
}
return func();
}
int fr(int pos) {
len = 0;
for (int i = 1; i < n - pos; ++i) {
arr[len++] = a[i];
}
return func();
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
copy(begin(a), end(a), init);
rotate(a, min_element(a, a + n), a + n);
int lef = 0, rig = n - 1;
while (rig - lef > 1) {
int mid = (lef + rig) / 2;
if (fl(mid) > fr(mid)) {
rig = mid;
} else {
lef = mid;
}
}
int rec = -1;
int fir = a[(n - lef) % n];
for (int i = 0; i < n; ++i) {
if (init[i] == fir) {
rec = i;
}
}
cout << max(fl(lef), fr(lef)) + 1 << " " << rec << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 400010;
int n;
int a[N];
int T[N << 2];
void build(int x, int l, int r) {
if (l == r) {
T[x] = a[r];
return;
}
build(x + x, l, ((l + r) >> 1));
build(x + x + 1, ((l + r) >> 1) + 1, r);
T[x] = min(T[x + x], T[x + x + 1]);
}
int find_left(int x, int l, int r, int u, int v, int val) {
if (l > v || r < u || T[x] >= val) return -1;
if (l == r) return r;
int fl = find_left(x + x, l, ((l + r) >> 1), u, v, val);
if (fl != -1) return fl;
return find_left(x + x + 1, ((l + r) >> 1) + 1, r, u, v, val);
}
int find_right(int x, int l, int r, int u, int v, int val) {
if (l > v || r < u || T[x] >= val) return -1;
if (l == r) return r;
int fr = find_right(x + x + 1, ((l + r) >> 1) + 1, r, u, v, val);
if (fr != -1) return fr;
return find_right(x + x, l, ((l + r) >> 1), u, v, val);
}
int depth[N << 2];
int lazy[N << 3];
void toggle(int x) {
depth[x] += lazy[x];
lazy[x + x] += lazy[x];
lazy[x + x + 1] += lazy[x];
lazy[x] = 0;
}
void upd(int x, int l, int r, int u, int v, int val) {
if (u > v) return;
toggle(x);
if (l > v || r < u) return;
if (l >= u && r <= v) {
lazy[x] += val;
toggle(x);
return;
}
upd(x + x, l, ((l + r) >> 1), u, v, val);
upd(x + x + 1, ((l + r) >> 1) + 1, r, u, v, val);
depth[x] = max(depth[x + x], depth[x + x + 1]);
}
int query(int x, int l, int r, int pos) {
if (l == r) return depth[x] + lazy[x];
if (pos <= ((l + r) >> 1))
return query(x + x, l, ((l + r) >> 1), pos) + lazy[x];
return query(x + x + 1, ((l + r) >> 1) + 1, r, pos) + lazy[x];
}
int pos[N];
int ls[N], rs[N];
stack<int> st;
int height[N + N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
int m = n + n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
pos[a[i]] = i;
a[i + n] = a[i];
}
for (int i = 1; i <= n; ++i) {
while (!st.empty() && a[st.top()] > a[i]) {
rs[st.top()] = i;
st.pop();
}
if (st.empty())
ls[i] = -1;
else
ls[i] = st.top();
st.push(i);
}
while (!st.empty()) {
rs[st.top()] = -1;
st.pop();
}
height[pos[1]] = 1;
for (int i = 2; i <= n; ++i) {
int p = pos[i];
int par = ls[p];
if (par == -1) par = rs[p];
if (rs[p] != -1 && a[rs[p]] > a[par]) par = rs[p];
height[p] = height[par] + 1;
}
for (int i = 1; i <= n; ++i) {
upd(1, 1, m, i, i, height[i]);
}
build(1, 1, m);
pair<int, int> ans = make_pair(depth[1], 0);
for (int i = 1; i < n; ++i) {
int val = a[i];
{
int pos = find_left(1, 1, m, i, i + n, val);
if (pos == -1) pos = i + n;
upd(1, 1, m, i + 1, pos - 1, -1);
upd(1, 1, m, i, i, -N - N);
}
{
int pos = find_right(1, 1, m, i, i + n, val);
if (pos != -1)
upd(1, 1, m, pos + 1, i + n - 1, 1);
else
upd(1, 1, m, i + 1, i + n - 1, 1);
if (pos != -1)
upd(1, 1, m, i + n, i + n, query(1, 1, m, pos) + 1);
else
upd(1, 1, m, i + n, i + n, 1);
}
ans = min(ans, make_pair(depth[1], i));
}
cout << ans.first << " " << ans.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int N = 2E5;
int n;
int a[N];
int t[4 * N];
int lazy[4 * N];
void push(int v) {
lazy[2 * v] += lazy[v];
lazy[2 * v + 1] += lazy[v];
t[2 * v] += lazy[v];
t[2 * v + 1] += lazy[v];
lazy[v] = 0;
}
int query(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (tl == l && tr == r) return t[v];
push(v);
int tm = (tl + tr) / 2;
return max(query(2 * v, tl, tm, l, min(r, tm)),
query(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
void add(int v, int tl, int tr, int l, int r, int incr) {
if (l > r) return;
if (tl == l && tr == r) {
t[v] += incr;
lazy[v] += incr;
} else {
push(v);
int tm = (tl + tr) / 2;
add(2 * v, tl, tm, l, min(r, tm), incr);
add(2 * v + 1, tm + 1, tr, max(tm + 1, l), r, incr);
t[v] = max(t[2 * v], t[2 * v + 1]);
}
}
vector<int> succ_dep(vector<int> &v) {
for (int i = 0; i < 4 * N; i++) {
t[i] = 0;
lazy[i] = 0;
};
vector<pii> incr_chain = {{1, -1}};
vector<int> res = {0};
for (int i = 0; i < v.size(); i++) {
auto it =
--upper_bound(incr_chain.begin(), incr_chain.end(), make_pair(v[i], 0));
int new_prof = it - incr_chain.begin();
add(1, 0, n - 1, i, i, new_prof);
int l = it->second + 1;
incr_chain.erase(++it, incr_chain.end());
incr_chain.push_back({v[i], i});
int r = i;
add(1, 0, n - 1, l, r, 1);
res.push_back(query(1, 0, n - 1, 0, n - 1));
}
return res;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
int pos1 = 0;
for (int i = 0; i < n; i++)
if (a[i] == 1) pos1 = i;
vector<int> v;
for (int i = 0; i < n - 1; i++) v.push_back(a[(pos1 + 1 + i) % n]);
vector<int> dep_right = succ_dep(v);
reverse(v.begin(), v.end());
vector<int> dep_left = succ_dep(v);
int res = 1E6, resk = 0;
for (int i = 0; i < n; i++) {
if (max(dep_right[i], dep_left[n - 1 - i]) < res) {
res = max(dep_right[i], dep_left[n - 1 - i]);
resk = (pos1 + 1 + i) % n;
}
}
printf("%d %d\n", res + 1, resk);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
void ckmin(T &a, U b) {
if (a > b) a = b;
}
template <class T, class U>
void ckmax(T &a, U b) {
if (a < b) a = b;
}
const int MAXN = 400013;
const int INF = 1000000007;
int N;
int arr[MAXN];
pair<int, int> ans = {INF, INF};
int lt[MAXN], rt[MAXN];
int stor[20][MAXN];
int depth[MAXN];
int seg[3 * MAXN], lazy[3 * MAXN];
vector<int> vec;
int comb(int i, int j) {
if (arr[i] == arr[j]) return i;
return (arr[i] < arr[j] ? i : j);
}
int qry(int L, int R) {
int sz = 31 - __builtin_clz(R - L + 1);
return comb(stor[sz][L], stor[sz][R - (1 << sz) + 1]);
}
void solve(int L, int R, int d) {
if (L > R) return;
int idx = qry(L, R);
depth[idx] = d;
solve(L, idx - 1, d + 1);
solve(idx + 1, R, d + 1);
}
void build(int w, int L, int R) {
lazy[w] = 0;
if (L == R) {
seg[w] = depth[L];
return;
}
int mid = (L + R) >> 1;
build(w << 1, L, mid);
build(w << 1 | 1, mid + 1, R);
seg[w] = max(seg[w << 1], seg[w << 1 | 1]);
}
void push(int w, int L, int R) {
if (lazy[w] == 0) return;
seg[w] += lazy[w];
if (L != R) {
lazy[w << 1] += lazy[w];
lazy[w << 1 | 1] += lazy[w];
}
lazy[w] = 0;
return;
}
void update(int w, int L, int R, int a, int b, int v) {
push(w, L, R);
if (b < L || R < a) return;
if (a <= L && R <= b) {
lazy[w] += v;
push(w, L, R);
return;
}
int mid = (L + R) >> 1;
update(w << 1, L, mid, a, b, v);
update(w << 1 | 1, mid + 1, R, a, b, v);
seg[w] = max(seg[w << 1], seg[w << 1 | 1]);
}
int query(int w, int L, int R, int a, int b) {
push(w, L, R);
if (a <= L && R <= b) {
return seg[w];
}
int mid = (L + R) >> 1;
if (b <= mid) return query(w << 1, L, mid, a, b);
if (mid < a) return query(w << 1 | 1, mid + 1, R, a, b);
return max(query(w << 1, L, mid, a, b), query(w << 1 | 1, mid + 1, R, a, b));
}
int32_t main() {
cout << fixed << setprecision(12);
cerr << fixed << setprecision(4);
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (auto i = (1); i < (N + 1); i++) {
cin >> arr[i];
arr[i + N] = arr[i];
}
for (auto i = (0); i < (2 * N + 2); i++) {
stor[0][i] = i;
}
for (auto i = (1); i < (20); i++) {
for (auto j = (0); j < (2 * N + 2 - (1 << i) + 1); j++) {
stor[i][j] = comb(stor[i - 1][j], stor[i - 1][j + (1 << (i - 1))]);
}
}
vec.push_back(0);
for (auto i = (1); i < (2 * N + 2); i++) {
while (arr[vec.back()] > arr[i]) vec.pop_back();
lt[i] = vec.back();
vec.push_back(i);
}
vec.clear();
vec.push_back(2 * N + 1);
for (auto i = (2 * N + 1) - 1; i >= (0); i--) {
while (arr[vec.back()] > arr[i]) vec.pop_back();
rt[i] = vec.back();
vec.push_back(i);
}
solve(1, N, 1);
build(1, 0, 2 * N + 1);
for (auto i = (0); i < (N); i++) {
int res = query(1, 0, 2 * N + 1, i + 1, i + N);
if (res < ans.first) ans = {res, i};
int idx;
idx = rt[i + 1];
update(1, 0, 2 * N + 1, i + 1, idx - 1, -1);
idx = lt[i + N + 1];
update(1, 0, 2 * N + 1, idx + 1, i + N, 1);
int cur = 1 + (idx == i + 1 ? 0 : query(1, 0, 2 * N + 1, idx, idx));
update(1, 0, 2 * N + 1, i + N + 1, i + N + 1, cur);
}
cout << ans.first << ' ' << ans.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const int maxn = 2e5 + 9;
long long rd() {
long long ans = 0;
char last = ' ', ch = getchar();
while (!(ch >= '0' && ch <= '9')) last = ch, ch = getchar();
while (ch >= '0' && ch <= '9') ans = ans * 10 + ch - '0', ch = getchar();
if (last == '-') ans = -ans;
return ans;
}
int tmp[maxn];
int a[maxn];
int sta[maxn], top, val[maxn];
int dpl[maxn], dpr[maxn];
void init(int n, int *dp) {
top = 0;
int mx = 0;
for (int i = (int)(1); i <= (int)(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;
}
dp[i] = (mx = max(mx, val[top]));
}
}
int main() {
int n = rd();
if (n == 1) return 0 * printf("%d %d\n", 1, 0);
int mi = 1e9, rt;
for (int i = (int)(1); i <= (int)(n); i++) {
tmp[i] = rd();
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, __;
for (int i = (int)(0); i <= (int)(n - 1); i++) {
if (ans > 1 + max(dpl[i], dpr[n - 1 - i])) {
ans = 1 + max(dpl[i], dpr[n - 1 - i]);
__ = rt - (i + 1);
}
}
if (__ < 0) __ += n;
printf("%d %d\n", ans, __);
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while ((c < '0' || c > '9') && (c != '-')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
const int N = 4e5 + 10;
int n, a[N];
int top, stk[N], ls[N], rs[N], Tim, l[N], r[N], pos[N], dep[N];
inline void dfs(int u, int dep) {
l[u] = ++Tim, pos[Tim] = u, ::dep[u] = dep;
if (ls[u]) dfs(ls[u], dep + 1);
if (rs[u]) dfs(rs[u], dep + 1);
r[u] = Tim;
}
inline void Build() {
stk[top = 1] = 1;
for (register int i = (2); i <= (n * 2); i++) {
while (a[i] < a[stk[top]] && top) ls[i] = stk[top], --top;
if (top) rs[stk[top]] = i;
stk[++top] = i;
}
while (top > 1) rs[stk[top - 1]] = stk[top], --top;
dfs(stk[1], 1);
}
struct Seg {
int v[N << 2], lazy[N << 2];
inline void push_up(int u) { v[u] = max(v[u << 1], v[u << 1 ^ 1]); }
inline void Build(int u, int l, int r) {
if (l == r) return v[u] = dep[pos[l]], void(0);
int mid = l + r >> 1;
Build(u << 1, l, mid), Build(u << 1 ^ 1, mid + 1, r);
push_up(u);
}
inline void upd(int u, int x) { v[u] += x, lazy[u] += x; }
inline void push_down(int u) {
if (lazy[u]) upd(u << 1, lazy[u]), upd(u << 1 ^ 1, lazy[u]), lazy[u] = 0;
}
inline void update(int u, int l, int r, int ql, int qr, int x) {
if (l >= ql && r <= qr) return upd(u, x), void(0);
int mid = l + r >> 1;
push_down(u);
if (ql <= mid) update(u << 1, l, mid, ql, qr, x);
if (qr > mid) update(u << 1 ^ 1, mid + 1, r, ql, qr, x);
push_up(u);
}
} t;
inline void update(int x, int y) { t.update(1, 1, n * 2, l[x], r[x], y); }
int main() {
n = read();
for (register int i = (1); i <= (n); i++) a[i] = read();
for (register int i = (n + 1); i <= (n * 2); i++) a[i] = a[i - n];
Build(), t.Build(1, 1, n * 2);
for (register int i = (n + 1); i <= (n * 2); i++) update(i, -1);
pair<int, int> ans = make_pair(n, 0);
for (register int i = (1); i <= (n); i++) {
update(i, -1), update(i + n, 1);
ans = min(ans, make_pair(t.v[1], i));
}
printf("%d %d\n", ans.first, ans.second % n);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5;
int l, r, n, now, ql, qr, a[maxn], p[maxn], dep[maxn];
stack<int> s;
int qus(int t) {
int res = 0, k = 0;
p[0] = 0;
dep[0] = 1;
for (int i = 1; i <= n; i++) {
p[i] = a[(i + t - 1) % n + 1];
dep[i] = 1;
}
s.push(0);
for (int i = 1; i <= n; i++) {
while (p[s.top()] > p[i]) {
k = dep[s.top()];
s.pop();
dep[i] = max(k + 1, dep[i]);
dep[s.top()] = max(dep[s.top()], k + 1);
}
s.push(i);
}
k = 0;
while (!s.empty()) {
dep[s.top()] = max(dep[s.top()], k + 1);
k = dep[s.top()];
s.pop();
}
return dep[0] - 1;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) now = i;
}
l = 0;
r = n - 1;
ql = qus(l + now);
qr = qus(r + now);
while (l + 1 < r) {
int mid1 = (2 * l + r + 2) / 3, mid2 = (2 * r + l) / 3;
int q1 = qus(mid1 + now), q2 = qus(mid2 + now);
if (qr < q2) {
l = mid2;
ql = q2;
continue;
}
if (ql < q1) {
r = mid1;
qr = q1;
continue;
}
if (q1 <= q2 && q2 <= qr) {
r = mid2;
qr = q2;
continue;
}
if (q1 >= q2 && q1 <= ql) {
l = mid1;
ql = q1;
continue;
}
}
if (ql > qr) {
l = r;
} else {
r = l;
}
printf("%d %d", min(ql, qr), (now + (l + r) / 2) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int MAX_N = 4E5;
struct Node {
int mx, lazy;
};
Node t[4 * MAX_N];
void pushDown(int p) {
t[2 * p].mx += t[p].lazy;
t[2 * p].lazy += t[p].lazy;
t[2 * p + 1].mx += t[p].lazy;
t[2 * p + 1].lazy += t[p].lazy;
t[p].lazy = 0;
}
void rangeAdd(int p, int l, int r, int x, int y, int v) {
if (l >= y || r <= x) return;
if (l >= x && r <= y) {
t[p].mx += v;
t[p].lazy += v;
return;
}
int mid = (l + r) / 2;
pushDown(p);
rangeAdd(2 * p, l, mid, x, y, v);
rangeAdd(2 * p + 1, mid, r, x, y, v);
t[p].mx = max(t[2 * p].mx, t[2 * p + 1].mx);
}
void modify(int p, int l, int r, int x, int v) {
if (r - l == 1) {
t[p].mx = v;
return;
}
int mid = (l + r) / 2;
pushDown(p);
if (x < mid)
modify(2 * p, l, mid, x, v);
else
modify(2 * p + 1, mid, r, x, v);
t[p].mx = max(t[2 * p].mx, t[2 * p + 1].mx);
}
int getVal(int p, int l, int r, int x) {
if (r - l == 1) return t[p].mx;
int mid = (l + r) / 2;
pushDown(p);
if (x < mid) return getVal(2 * p, l, mid, x);
return getVal(2 * p + 1, mid, r, x);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
a.insert(a.end(), a.begin(), a.end());
vector<int> l(2 * n), r(2 * n);
stack<int> stk;
stk.push(-1);
for (int i = 0; i < 2 * n; ++i) {
while (stk.size() >= 2 && a[stk.top()] > a[i]) stk.pop();
l[i] = stk.top();
stk.push(i);
}
while (!stk.empty()) stk.pop();
stk.push(2 * n);
for (int i = 2 * n - 1; i >= 0; --i) {
while (stk.size() >= 2 && a[stk.top()] > a[i]) stk.pop();
r[i] = stk.top();
stk.push(i);
}
int ans = 1E9, pos = -1;
for (int i = 0; i < 2 * n; ++i) {
if (i >= n) {
if (t[1].mx < ans) {
ans = t[1].mx;
pos = i - n;
}
rangeAdd(1, 0, 2 * n, i - n, r[i - n], -1);
modify(1, 0, 2 * n, i - n, 0);
}
modify(1, 0, 2 * n, i, l[i] == -1 ? 1 : getVal(1, 0, 2 * n, l[i]) + 1);
rangeAdd(1, 0, 2 * n, l[i] + 1, i, 1);
}
assert(pos != -1);
cout << ans << " " << pos << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
struct node {
int dep, h, p;
};
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
vector<int> perm(n);
for (int& x : perm) cin >> x;
int off = find(begin(perm), end(perm), 1) - begin(perm);
rotate(begin(perm), begin(perm) + off, end(perm));
perm.push_back(1);
vector<int> rans(n + 1);
rans[0] = 1;
vector<node> rtree(n + 1);
rtree[1].dep = 1;
for (int i = 1; i < n; i++) {
int h = 0;
int p = perm[i - 1];
int v = perm[i];
while (v < p) {
h = max(rtree[p].h, h) + 1;
p = rtree[p].p;
}
int d = rtree[p].dep + 1;
rtree[v] = {d, h, p};
rans[i] = max(d + h, rans[i - 1]);
}
vector<int> lans(n + 1);
lans[0] = 1;
vector<node> ltree(n + 1);
ltree[1].dep = 1;
for (int i = 1; i < n; i++) {
int h = 0;
int p = perm[n - i + 1];
int v = perm[n - i];
while (v < p) {
h = max(ltree[p].h, h) + 1;
p = ltree[p].p;
}
int d = ltree[p].dep + 1;
ltree[v] = {d, h, p};
lans[i] = max(d + h, lans[i - 1]);
}
pair<int, int> best = {n, 0};
for (int i = 0; i < n; i++) {
pair<int, int> alt = {max(lans[i], rans[n - 1 - i]), i};
best = min(best, alt);
}
cout << best.first << ' ' << (n + off - best.second) % n << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 5;
int n, a[N], pos[N], dep[N], S, ans = 2e9, ct, R[N], L[N];
int s[N], top;
int mx[N << 2], mn[N << 2], add[N << 2];
void inline Add(int p, int k) { add[p] += k, mx[p] += k, mn[p] += k; }
void inline pushup(int p) {
mx[p] = max(mx[(p << 1)], mx[(p << 1 | 1)]);
mn[p] = min(mn[(p << 1)], mn[(p << 1 | 1)]);
}
void inline pushdown(int p) {
if (add[p]) {
Add((p << 1), add[p]);
Add((p << 1 | 1), add[p]);
add[p] = 0;
}
}
void build(int p, int l, int r, int *b) {
add[p] = 0;
if (l == r) {
mx[p] = mn[p] = b[r];
return;
}
int mid = (l + r) >> 1;
build((p << 1), l, mid, b);
build((p << 1 | 1), mid + 1, r, b);
pushup(p);
}
void inline change(int p, int l, int r, int x, int y, int k) {
if (x > y) return;
if (x <= l && r <= y) {
Add(p, k);
return;
}
pushdown(p);
int mid = (l + r) >> 1;
if (x <= mid) change((p << 1), l, mid, x, y, k);
if (mid < y) change((p << 1 | 1), mid + 1, r, x, y, k);
pushup(p);
}
int inline queryMn(int p, int l, int r, int x, int y) {
if (x <= l && r <= y) return mn[p];
pushdown(p);
int mid = (l + r) >> 1, res = 2e9;
if (x <= mid) res = min(res, queryMn((p << 1), l, mid, x, y));
if (mid < y) res = min(res, queryMn((p << 1 | 1), mid + 1, r, x, y));
return res;
}
int inline queryMx(int p, int l, int r, int x, int y) {
if (x <= l && r <= y) return mx[p];
pushdown(p);
int mid = (l + r) >> 1, res = -2e9;
if (x <= mid) res = max(res, queryMx((p << 1), l, mid, x, y));
if (mid < y) res = max(res, queryMx((p << 1 | 1), mid + 1, r, x, y));
return res;
}
void solve(int l, int r, int d) {
if (l > r) return;
int v = queryMn(1, 1, S, l, r);
int p = pos[v];
dep[p] = d;
solve(l, p - 1, d + 1);
solve(p + 1, r, d + 1);
}
int main() {
scanf("%d", &n);
S = 2 * n;
for (int i = 1; i <= n; i++) scanf("%d", a + i), pos[a[i]] = i;
build(1, 1, S, a);
solve(1, n, 1);
for (int i = 1; i <= n; i++) a[i + n] = a[i];
build(1, 1, S, dep);
ans = queryMx(1, 1, S, 1, n);
for (int i = 1; i <= 2 * n; i++) {
while (top && (s[top] <= i - n || a[s[top]] > a[i])) top--;
if (!top)
L[i] = i - n + 1;
else
L[i] = s[top] + 1;
s[++top] = i;
}
top = 0;
for (int i = 2 * n; i; i--) {
while (top && (s[top] >= i + n || a[s[top]] > a[i])) top--;
if (!top)
R[i] = i + n - 1;
else
R[i] = s[top] - 1;
s[++top] = i;
}
for (int i = 1; i < n; i++) {
change(1, 1, S, i + 1, R[i], -1);
change(1, 1, S, L[i + n], i + n - 1, 1);
if (L[i + n] <= i + n - 1) {
change(1, 1, S, i + n, i + n, queryMn(1, 1, S, L[i + n], i + n - 1) - 1);
} else {
change(1, 1, S, i + n, i + n, queryMn(1, 1, S, i + n - 1, i + n - 1) + 1);
}
int now = queryMx(1, 1, S, i + 1, i + n);
if (now < ans) ans = now, ct = i;
}
printf("%d %d\n", ans, ct);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400001];
int l[800001];
int r[800001];
int lz[1600001];
int mx[1600001];
void prop(int id) {
lz[id * 2] += lz[id];
lz[id * 2 + 1] += lz[id];
mx[id * 2] += lz[id];
mx[id * 2 + 1] += lz[id];
lz[id] = 0;
}
void update(int id, int l, int r, int ql, int qr, int val) {
if (l > qr || r < ql) {
return;
}
if (l >= ql && r <= qr) {
lz[id] += val;
mx[id] += val;
return;
}
prop(id);
int mid = (l + r) / 2;
update(id * 2, l, mid, ql, qr, val);
update(id * 2 + 1, mid + 1, r, ql, qr, val);
mx[id] = max(mx[id * 2], mx[id * 2 + 1]);
}
int query(int id, int l, int r, int ql, int qr) {
if (l > qr || r < ql) {
return 0;
}
if (l >= ql && r <= qr) {
return mx[id];
}
prop(id);
int mid = (l + r) / 2;
int q1 = query(id * 2, l, mid, ql, qr);
int q2 = query(id * 2 + 1, mid + 1, r, ql, qr);
return max(q1, q2);
}
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[n + i] = 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) {
update(1, 1, 2 * n, l[i] + 1, r[i] - 1, 1);
}
}
int ans = query(1, 1, 2 * n, 1, n);
int idx = 0;
for (int i = 1; i <= n - 1; i++) {
if (a[i] == 1) {
continue;
}
update(1, 1, 2 * n, l[i] + 1, r[i] - 1, -1);
update(1, 1, 2 * n, l[i + n] + 1, r[i + n] - 1, 1);
int cur = query(1, 1, 2 * n, i + 1, n + i);
if (cur < ans) {
ans = cur;
idx = i;
}
}
cout << ans + 1 << " " << idx << endl;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int test;
test = 1;
while (test--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int _ = 1e2;
const int maxn = 2e5 + _;
int top, sta[maxn], dep[maxn];
int push(int x) {
int mx = 0;
while (top && sta[top] > x) mx = max(mx, dep[sta[top]] + 1), top--;
sta[++top] = x, mx = max(mx, top), dep[x] = mx;
return mx;
}
int sc[maxn], a[maxn], L[maxn], R[maxn];
int main() {
int n, st;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &sc[i]);
if (sc[i] == 1) st = i;
}
for (int i = 0; i < n; i++) a[i] = sc[(i + st) % n];
top = 0;
for (int i = 1; i < n; i++) R[i] = max(R[i - 1], push(a[i]));
top = 0;
for (int i = n - 1; i > 0; i--) L[i] = max(L[i + 1], push(a[i]));
int mn = 2147483647, p;
for (int i = 0; i < n; i++) {
int t = max(R[i], L[i + 1]);
if (mn > t) mn = t, p = i;
}
printf("%d %d\n", mn + 1, (st - (n - p - 1) + n) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, bool maximum_mode = false>
struct RMQ {
int n = 0, levels = 0;
vector<T> values;
vector<vector<int>> range_low;
RMQ(const vector<T> &_values = {}) {
if (!_values.empty()) build(_values);
}
static int largest_bit(int x) { return 31 - __builtin_clz(x); }
int better_index(int a, int b) const {
return (values[a] < values[b]) ^ maximum_mode ? a : b;
}
void build(const vector<T> &_values) {
values = _values;
n = values.size();
levels = largest_bit(n) + 1;
range_low.resize(levels);
for (int k = 0; k < levels; k++) range_low[k].resize(n - (1 << k) + 1);
for (int i = 0; i < n; i++) range_low[0][i] = i;
for (int k = 1; k < levels; k++)
for (int i = 0; i <= n - (1 << k); i++)
range_low[k][i] = better_index(range_low[k - 1][i],
range_low[k - 1][i + (1 << (k - 1))]);
}
int query_index(int a, int b) const {
assert(0 <= a && a < b && b <= n);
int level = largest_bit(b - a);
return better_index(range_low[level][a],
range_low[level][b - (1 << level)]);
}
T query_value(int a, int b) const { return values[query_index(a, b)]; }
};
int N;
vector<int> A;
RMQ<int> rmq;
int evaluate(int start, int end) {
if (start >= end) return 0;
int minimum = rmq.query_index(start, end);
return 1 + max(evaluate(start, minimum), evaluate(minimum + 1, end));
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> N;
A.resize(N);
for (int &a : A) cin >> a;
for (int i = 0; i < 2 * N; i++) A.push_back(A[i]);
rmq.build(A);
int one = N + (find(A.begin(), A.end(), 1) - A.begin());
int low = 0, high = N - 1;
while (low < high) {
int mid = (low + high) / 2;
if (evaluate(one - mid, one + 1) < evaluate(one, one - mid + N))
low = mid + 1;
else
high = mid;
}
cout << evaluate(one - low, one - low + N) << ' ' << (one - low) % N << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int __i__, __j__;
class _Debug {
public:
template <typename T>
_Debug& operator,(T val) {
cout << val << endl;
return *this;
}
};
int a[200000];
vector<pair<int, int> > S;
int ans[200000], ans2[200000];
int main() {
int i;
int n;
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%d", &a[i]), a[i]--;
int s = 0;
for (i = 0; i < n; i++) {
if (a[i] == 0) break;
}
s = i;
rotate(a, a + s, a + n);
int c = 0;
for (i = 1; i < n; i++) {
if (S.empty())
S.push_back(make_pair(a[i], 1)), c = 1;
else {
int x = 0, c2 = 0;
while (!S.empty() && (a[i] < S.back().first))
c2 = max(c2 + 1, S.back().second), S.pop_back(), x++;
c = max(c, c2 + (int)S.size() + 1);
if (S.empty())
S.push_back(make_pair(a[i], c));
else
S.push_back(make_pair(a[i], c2 + 1));
}
ans[i] = c;
}
S.clear(), c = 0;
for (i = n - 1; i >= 1; i--) {
if (S.empty())
S.push_back(make_pair(a[i], 1)), c = 1;
else {
int x = 0, c2 = 0;
while (!S.empty() && (a[i] < S.back().first))
c2 = max(c2 + 1, S.back().second), S.pop_back(), x++;
c = max(c, c2 + (int)S.size() + 1);
if (S.empty())
S.push_back(make_pair(a[i], c));
else
S.push_back(make_pair(a[i], c2 + 1));
}
ans2[i] = c;
}
int bi = 0, b = 1e9;
for (i = 0; i < n; i++) {
int x = max(ans[i], ans2[i + 1]);
if (x < b) b = x, bi = i;
}
printf("%d %d\n", b + 1, (bi + s + 1) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void read(int &x) {
x = 0;
int f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -f;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
void print(int x) {
if (x < 0) putchar('-'), x = -x;
if (!x) return;
print(x / 10), putchar(x % 10 + 48);
}
void write(int x) {
if (!x)
putchar('0');
else
print(x);
putchar('\n');
}
const int maxn = 2e5 + 10;
const int inf = 1e9;
const double eps = 1e-8;
const int mod = 1e9 + 7;
int n, a[maxn], b[maxn], p, g[2][maxn];
struct segment_tree {
int mx[maxn << 2], tag[maxn << 2];
void clear() {
memset(mx, 0, sizeof mx);
memset(tag, 0, sizeof tag);
}
void push(int p, int x) { tag[p] += x, mx[p] += x; }
void pushdown(int p) {
if (tag[p]) push(p << 1, tag[p]), push(p << 1 | 1, tag[p]), tag[p] = 0;
}
void update(int p) { mx[p] = max(mx[p << 1], mx[p << 1 | 1]); }
void modify(int p, int l, int r, int x, int y, int v) {
if (y < x) return;
if (x <= l && r <= y) return push(p, v), void();
pushdown(p);
if (x <= ((l + r) >> 1)) modify(p << 1, l, ((l + r) >> 1), x, y, v);
if (y > ((l + r) >> 1)) modify(p << 1 | 1, ((l + r) >> 1) + 1, r, x, y, v);
update(p);
}
int query(int p, int l, int r, int x, int y) {
if (y < x) return 0;
if (x <= l && r <= y) return mx[p];
pushdown(p);
int ans = 0;
if (x <= ((l + r) >> 1))
ans = max(ans, query(p << 1, l, ((l + r) >> 1), x, y));
if (y > ((l + r) >> 1))
ans = max(ans, query(p << 1 | 1, ((l + r) >> 1) + 1, r, x, y));
return ans;
}
} T, w;
void solve(int *r, int *f) {
T.clear();
w.clear();
for (int i = 1; i <= n - 1; i++) {
int x = w.query(1, 1, n, 1, r[i]);
if (!x) {
w.modify(1, 1, n, r[i], r[i], i);
f[i] = T.query(1, 1, n - 1, 1, i - 1) + 1;
T.modify(1, 1, n - 1, 1, i, 1);
continue;
}
w.modify(1, 1, n, r[i], r[i], i);
T.modify(1, 1, n - 1, x + 1, i - 1, 1);
T.modify(1, 1, n - 1, i, i, T.query(1, 1, n - 1, x, x) + 1);
f[i] = T.query(1, 1, n - 1, 1, i);
}
}
int main() {
read(n);
for (int i = 1; i <= n; i++) {
read(b[i]);
if (b[i] == 1) p = i;
}
if (n == 1) {
puts("1 0");
return 0;
}
for (int i = p + 1; i <= n; i++) a[i - p] = b[i];
for (int i = 1; i < p; i++) a[n - p + i] = b[i];
int mn = 1e9, t = 0;
solve(a, g[0]);
reverse(a + 1, a + n);
solve(a, g[1]);
reverse(g[1] + 1, g[1] + n);
for (int i = 1; i < n - 1; i++) {
if (max(g[0][i], g[1][i + 1]) < mn) mn = max(g[0][i], g[1][i + 1]), t = i;
}
printf("%d %d\n", mn + 1, (p - 1 + t + 1) % n);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,mmx,avx,tune=native")
using namespace std;
const int MOD = 1000000007;
const int UNDEF = -1;
const int INF = 1 << 30;
template <typename T>
inline bool chkmax(T& aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T& aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
int rint();
char rch();
long long rlong();
template <int _SEGSZ>
class MinSegTree {
public:
static const int SEGSZ = _SEGSZ;
int segn = _SEGSZ;
pair<int, int> t[2 * SEGSZ];
const pair<int, int> identity = make_pair(INF, INF);
pair<int, int> combine(const pair<int, int>& lefts,
const pair<int, int>& rights) {
return min(lefts, rights);
}
pair<int, int>& operator[](int idx) { return t[segn + idx]; }
void init(int n) { segn = n; }
void build() {
int n = segn;
for (int i = n - 1; i > 0; --i) t[i] = combine(t[i << 1], t[i << 1 | 1]);
}
void sset(int p, const pair<int, int>& value) {
int n = segn;
for (t[p += n] = value; p >>= 1;) t[p] = combine(t[p << 1], t[p << 1 | 1]);
}
int query(int l, int r) {
if (l > r) return identity.second;
r++;
int n = segn;
pair<int, int> resl = identity, resr = identity;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) resl = combine(resl, t[l++]);
if (r & 1) resr = combine(t[--r], resr);
}
return combine(resl, resr).second;
}
};
class SegmentTreeFast {
public:
int modifyOperation(int x, int y) { return x + y; }
int queryOperation(int l, int r) { return max(l, r); }
int deltaEffectOnSegment(int delta, int segmentLength) { return delta; }
int initNeutralDelta() { return 0; }
bool isNeutralDelta(int delta) { return delta == 0; }
int getInitValue(int i) { return 0; }
int getNeutralValue() { return 0; }
int joinDeltas(int delta1, int delta2) { return delta1 + delta2; }
int _cache_neutral_delta;
int getNeutralDelta() { return _cache_neutral_delta; }
int* value;
int* delta;
int gn;
int joinValueWithDelta(int value, int delta) {
if (isNeutralDelta(delta)) return value;
return modifyOperation(value, delta);
}
void pushDelta(int i) {
int d = 0;
for (; (i >> d) > 0; d++) {
}
for (d -= 2; d >= 0; d--) {
int x = i >> d;
value[x >> 1] = joinNodeValueWithDelta(x >> 1, 1 << (d + 1));
delta[x] = joinDeltas(delta[x], delta[x >> 1]);
delta[x ^ 1] = joinDeltas(delta[x ^ 1], delta[x >> 1]);
delta[x >> 1] = getNeutralDelta();
}
}
SegmentTreeFast(int n) {
_cache_neutral_delta = initNeutralDelta();
gn = n;
value = new int[2 * n];
for (int i = 0; i < n; i++) {
value[i + n] = getInitValue(i);
}
for (int i = n - 1; i > 0; --i)
value[i] = queryOperation(value[i << 1], value[i << 1 | 1]);
delta = new int[2 * n];
fill(delta, delta + (2 * n), getNeutralDelta());
}
int joinNodeValueWithDelta(int i, int len) {
return joinValueWithDelta(value[i], deltaEffectOnSegment(delta[i], len));
}
int query(int from, int to) {
from += gn;
to += gn;
pushDelta(from);
pushDelta(to);
int resl = getNeutralValue();
int resr = getNeutralValue();
bool found = false;
for (int len = 1; from <= to;
from = (from + 1) >> 1, to = (to - 1) >> 1, len <<= 1) {
if ((from & 1) != 0) {
resl = found ? queryOperation(resl, joinNodeValueWithDelta(from, len))
: joinNodeValueWithDelta(from, len);
found = true;
}
if ((to & 1) == 0) {
resr = found ? queryOperation(joinNodeValueWithDelta(to, len), resr)
: joinNodeValueWithDelta(to, len);
found = true;
}
}
int res = queryOperation(resl, resr);
if (!found)
;
return res;
}
void modify(int from, int to, int delta) {
from += gn;
to += gn;
pushDelta(from);
pushDelta(to);
int a = from;
int b = to;
for (; from <= to; from = (from + 1) >> 1, to = (to - 1) >> 1) {
if ((from & 1) != 0) {
this->delta[from] = joinDeltas(this->delta[from], delta);
}
if ((to & 1) == 0) {
this->delta[to] = joinDeltas(this->delta[to], delta);
}
}
for (int i = a, len = 1; i > 1; i >>= 1, len <<= 1) {
int k = i >> 1;
value[k] = queryOperation(joinNodeValueWithDelta(k << 1, len),
joinNodeValueWithDelta((k << 1) | 1, len));
}
for (int i = b, len = 1; i > 1; i >>= 1, len <<= 1) {
int k = i >> 1;
value[k] = queryOperation(joinNodeValueWithDelta(k << 1, len),
joinNodeValueWithDelta((k << 1) | 1, len));
}
}
};
const int mn = (4e5) + 8;
int a[mn];
int vl[mn], vr[mn];
MinSegTree<mn> segmin;
int initdepth[mn];
void fdepth(int p, int L, int R, int d) {
initdepth[p] = d;
int pl = segmin.query(L, p - 1);
int pr = segmin.query(p + 1, R);
if (pl != segmin.identity.second) fdepth(pl, L, p - 1, d + 1);
if (pr != segmin.identity.second) fdepth(pr, p + 1, R, d + 1);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) a[n + i] = a[i];
{
vector<pair<int, int> > v;
v.push_back(make_pair(-INF, -1));
for (int p = 0; p < 2 * n; p++) {
int imin = 0, imax = v.size();
while (imin < imax) {
int imid = (imin + imax) / 2;
if (v[imid].first < a[p])
imin = imid + 1;
else
imax = imid;
}
v.resize(imin);
vl[p] = v.back().second;
v.push_back(make_pair(a[p], p));
}
}
{
vector<pair<int, int> > v;
v.push_back(make_pair(-INF, 2 * n));
for (int p = 2 * n - 1; p >= 0; p--) {
int imin = 0, imax = v.size();
while (imin < imax) {
int imid = (imin + imax) / 2;
if (v[imid].first < a[p])
imin = imid + 1;
else
imax = imid;
}
v.resize(imin);
vr[p] = v.back().second;
v.push_back(make_pair(a[p], p));
}
}
segmin.init(n);
for (int p = 0; p < n; p++) {
segmin[p] = make_pair(a[p], p);
}
segmin.build();
{
int p1 = segmin.query(0, n - 1);
fdepth(p1, 0, n - 1, 0);
}
SegmentTreeFast segmax(2 * n);
for (int p = 0; p < n; p++) {
segmax.modify(p, p, initdepth[p]);
}
pair<int, int> ans = make_pair(segmax.query(0, n - 1), 0);
for (int p = 0; p < n - 1; p++) {
{
int R = p + n - 1;
int r = vr[p];
segmax.modify(p + 1, min(R, r - 1), -1);
}
{
int l = vl[p + n];
int pdepth = 0;
if (l > p) {
pdepth = 1 + segmax.query(l, l);
}
segmax.modify(p + n, p + n, pdepth);
segmax.modify(l + 1, p + n - 1, 1);
}
int cand = segmax.query(p + 1, p + 1 + n - 1);
chkmin(ans, make_pair(cand, p + 1));
}
ans.first++;
printf("%d %d\n", ans.first, ans.second);
}
static char stdinBuffer[1024];
static char* stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char* stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200200 << 1], pre[200200], suf[200200], tot, st[200200], b[200200];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[n + i] = a[i];
int shift;
for (shift = 1; shift <= n; shift++)
if (a[shift] == 1) break;
for (int i = 1; i <= n; i++) a[i] = a[i + shift - 1];
a[n + 1] = 1;
tot = 0;
pre[1] = 1;
st[++tot] = 1;
for (int i = 2, cur = 0; i <= n; i++) {
int lst = 0;
while (tot && a[st[tot]] > a[i]) {
int u = st[tot];
tot--;
if (lst) b[u] = max(b[u], lst + 1);
lst = b[u];
}
b[i] = lst + 1;
pre[i] = max(pre[i - 1], b[i] + tot);
st[++tot] = i;
}
for (int i = 1; i <= n; i++) b[i] = 0;
tot = 0;
suf[n + 1] = 1;
st[++tot] = n + 1;
for (int i = n, cur = 0; i >= 2; i--) {
int lst = 0;
while (tot && a[st[tot]] > a[i]) {
int u = st[tot];
tot--;
if (lst) b[u] = max(b[u], lst + 1);
lst = b[u];
}
b[i] = lst + 1;
suf[i] = max(suf[i + 1], b[i] + tot);
st[++tot] = i;
}
int mn = n + 1;
for (int i = 1; i <= n; i++) mn = min(mn, max(pre[i], suf[i + 1]));
int k;
for (k = 1; k <= n; k++)
if (max(pre[k], suf[k + 1]) == mn) break;
printf("%d %d\n", mn, (k + shift - 1) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf;
const double eps = 1e-8;
const double pi = acos(-1.0);
template <class T>
int chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
int chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
T sqr(T a) {
return a * a;
}
template <class T>
T mmin(T a, T b) {
return a < b ? a : b;
}
template <class T>
T mmax(T a, T b) {
return a > b ? a : b;
}
template <class T>
T aabs(T a) {
return a < 0 ? -a : a;
}
template <class T>
int dcmp(T a, T b) {
return a > b;
}
template <int *a>
int cmp_a(int first, int second) {
return a[first] < a[second];
}
struct __INIT__ {
__INIT__() { memset(&inf, 0x3f, sizeof(inf)); }
} __INIT___;
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
qu[55];
int f, qr;
inline void flush() {
fwrite(obuf, 1, oS - obuf, stdout);
oS = obuf;
}
inline void putc(char first) {
*oS++ = first;
if (oS == oT) flush();
}
inline bool read(signed &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(long long &first) {
for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
c < '0' || c > '9';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
if (c == '-')
f = -1;
else if (c == EOF)
return 0;
for (first = 0; c <= '9' && c >= '0';
c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++))
first = first * 10 + (c & 15);
first *= f;
return 1;
}
inline bool read(char &first) {
first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
return first != EOF;
}
inline bool read(char *first) {
while ((*first = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++)) == '\n' ||
*first == ' ' || *first == '\r')
if (*first == EOF) return 0;
while (!(*first == '\n' || *first == ' ' || *first == '\r'))
*(++first) = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
(iS == iT ? EOF : *iS++))
: *iS++);
*first = 0;
return 1;
}
template <typename A, typename... B>
inline bool read(A &first, B &...second) {
return read(first) && read(second...);
}
inline bool write(signed first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(long long first) {
if (!first) putc('0');
if (first < 0) putc('-'), first = -first;
while (first) qu[++qr] = first % 10 + '0', first /= 10;
while (qr) putc(qu[qr--]);
return 0;
}
inline bool write(char first) {
putc(first);
return 0;
}
inline bool write(const char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
inline bool write(char *first) {
while (*first) {
putc(*first);
++first;
}
return 0;
}
template <typename A, typename... B>
inline bool write(A first, B... second) {
return write(first) || write(second...);
}
struct Flusher_ {
~Flusher_() { flush(); }
} io_flusher_;
} // namespace io
using io ::putc;
using io ::read;
using io ::write;
struct smt {
int ls, rs;
int mx;
int tag;
smt *l, *r;
smt(int la, int ra) {
ls = la;
rs = ra;
mx = tag = 0;
if (ls == rs) {
l = r = 0;
return;
}
int mid = (ls + rs) >> 1;
l = new smt(ls, mid);
r = new smt(mid + 1, rs);
}
void put_tag(int first) {
mx += first;
tag += first;
}
void push_down() {
l->put_tag(tag);
r->put_tag(tag);
tag = 0;
}
void update(int la, int ra, int first) {
if (la <= ls && rs <= ra) {
put_tag(first);
return;
}
push_down();
if (la <= l->rs) l->update(la, ra, first);
if (r->ls <= ra) r->update(la, ra, first);
mx = mmax(l->mx, r->mx);
}
int query(int la, int ra) {
if (la <= ls && rs <= ra) return mx;
push_down();
int mx = 0;
if (la <= l->rs) chkmax(mx, l->query(la, ra));
if (r->ls <= ra) chkmax(mx, r->query(la, ra));
return mx;
}
};
smt *rt;
vector<pair<pair<int, int>, int> > v[200005];
int a[400005], b[400005], t;
int ls[400005], rs[400005];
int n;
void work(int first) {
v[1].push_back(make_pair(
make_pair(first - 2 - ls[first + n], first - 2 + rs[first]), 1));
v[n - first + 2].push_back(make_pair(
make_pair(first - 2 - ls[first + n], first - 2 + rs[first]), -1));
if (first > 1) {
v[n - first + 2].push_back(
make_pair(make_pair(first - 1 - ls[first + n] - n - 1,
first - 1 + rs[first] - n - 1),
1));
}
}
signed main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(a[i]);
a[n + i] = a[i];
}
t = 0;
for (int i = 1; i <= n + n; ++i) {
while (t && a[b[t]] > a[i]) --t;
if (t)
ls[i] = i - b[t] - 1;
else
ls[i] = n;
b[++t] = i;
}
t = 0;
for (int i = n + n; i; --i) {
while (t && a[b[t]] > a[i]) --t;
if (t)
rs[i] = b[t] - i - 1;
else
rs[i] = n;
b[++t] = i;
}
for (int i = 1; i <= n; ++i) work(i);
rt = new smt(-n, n);
int id = 0, ans = n + 5;
for (int i = 1; i <= n; ++i) {
for (auto j : v[i]) {
rt->update(j.first.first, j.first.second, j.second);
}
if (chkmin(ans, rt->query(-i, n - i - 1))) id = (n + 1 - i) % n;
}
write(ans, ' ', id, '\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.1415926535897932384626433832795l;
template <typename T>
inline auto sqr(T x) -> decltype(x * x) {
return x * x;
}
template <typename T>
inline T abs(T x) {
return x > T() ? 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;
}
class RangeQuerySolver {
public:
RangeQuerySolver() {}
virtual int fnd(int l, int r) = 0;
};
class SegmentTree : public RangeQuerySolver {
public:
SegmentTree(vector<int> a) {
sz = 1;
int n = ((int)(a).size());
while (sz < n) sz <<= 1;
addend.assign(2 * sz, 0);
saved_a = a;
}
void init() {
t.assign(2 * sz, default_value());
for (int i = int(0); i < int(((int)(saved_a).size())); ++i) {
t[i + sz] = saved_a[i];
}
for (int i = int(sz) - 1; i >= int(1); --i) {
t[i] = relax(t[2 * i], t[2 * i + 1]);
}
}
virtual int default_value() = 0;
virtual int relax(int botva, int sdkfjsokdf) = 0;
void push(int v) {
if (v >= 2 * sz) {
return;
}
t[v] += addend[v];
if (v < sz) {
addend[2 * v] += addend[v];
addend[2 * v + 1] += addend[v];
}
addend[v] = 0;
}
void add(int l, int r, int k) {
if (l > r) {
return;
}
upd(1, 0, sz - 1, l, r, k);
}
void upd(int i, int k) {
int res = fnd(i, i);
add(i, i, k - res);
}
void upd(int i, int x, int y, int l, int r, int k) {
push(i);
if (x > r || y < l) {
return;
}
if (x >= l && y <= r) {
addend[i] += k;
push(i);
return;
}
upd(2 * i, x, (x + y) >> 1, l, r, k);
upd(2 * i + 1, ((x + y) >> 1) + 1, y, l, r, k);
if (i < sz) {
t[i] = relax(t[2 * i], t[2 * i + 1]);
}
}
int fnd(int l, int r) override { return fnd(1, 0, sz - 1, l, r); }
int fnd(int i, int x, int y, int l, int r) {
push(i);
if (x > r || y < l) {
return default_value();
}
if (x >= l && y <= r) {
return t[i];
}
return relax(fnd(2 * i, x, (x + y) >> 1, l, r),
fnd(2 * i + 1, ((x + y) >> 1) + 1, y, l, r));
}
protected:
vector<int> t;
vector<int> saved_a;
vector<int> addend;
int sz;
};
class MinTree : public SegmentTree {
public:
MinTree(vector<int> a) : SegmentTree(a) {}
int default_value() override { return (1 << 30); }
int relax(int botva, int sdkfjsokdf) { return min(botva, sdkfjsokdf); }
};
class MaxTree : public SegmentTree {
public:
MaxTree(vector<int> a) : SegmentTree(a) {}
int default_value() override { return 0; }
int relax(int botva, int sdkfjsokdf) { return max(botva, sdkfjsokdf); }
};
class SlowMinimumQuerySolver : public RangeQuerySolver {
public:
SlowMinimumQuerySolver(vector<int> a) : a(a) {}
int fnd(int l, int r) override {
int minn = a[l];
for (int i = l + 1; i <= r; ++i) {
umn(minn, a[i]);
}
return minn;
}
private:
vector<int> a;
};
void build_tree(int l, int r, int dist, vector<int>& a, const vector<int>& posp,
RangeQuerySolver& tree) {
if (r < l) {
return;
}
int val = tree.fnd(l, r);
int pos = posp[val];
a[pos] = dist;
build_tree(l, pos - 1, dist + 1, a, posp, tree);
build_tree(pos + 1, r, dist + 1, a, posp, tree);
}
struct Input {
int n;
vector<int> p;
vector<int> posp;
bool read() {
if (scanf("%d", &n) != 1) {
return 0;
}
p.resize(n);
posp.resize(n);
for (int i = int(0); i < int(n); ++i) {
cin >> p[i];
--p[i];
posp[p[i]] = i;
}
return 1;
}
void gen() {
n = 5;
p = vector<int>(n);
for (int i = int(0); i < int(n); ++i) {
p[i] = i;
}
random_shuffle((p).begin(), (p).end());
posp = vector<int>(n);
for (int i = int(0); i < int(n); ++i) {
posp[p[i]] = i;
}
}
void init(const Input& input) { *this = input; }
};
struct Data : Input {
pair<int, int> ans;
void write() { cout << ans.first << ' ' << ans.second << "\n"; }
virtual void solve() {}
virtual void clear() { *this = Data(); }
};
struct CleverSolution : Data {
vector<int> botva, sdkfjsokdf;
void solve() {
vector<int> a(n);
MinTree min_tree(p);
min_tree.init();
build_tree(0, n - 1, 0, a, posp, min_tree);
MaxTree max_tree(a);
max_tree.init();
ans.first = max_tree.fnd(0, n - 1);
ans.second = 0;
set<int> s;
botva.resize(n);
sdkfjsokdf.resize(n);
for (int i = int(0); i < int(n); ++i) {
if (i == 0) {
botva[posp[i]] = sdkfjsokdf[posp[i]] = -1;
s.insert(posp[i]);
continue;
}
s.insert(posp[i]);
if (*s.begin() != posp[i]) {
botva[posp[i]] = *(--s.lower_bound(posp[i]));
} else {
botva[posp[i]] = *(--s.end());
}
if (*(--s.end()) != posp[i]) {
sdkfjsokdf[posp[i]] = *(s.upper_bound(posp[i]));
} else {
sdkfjsokdf[posp[i]] = *s.begin();
}
};
;
for (int i = int(0); i < int(n); ++i) {
if (p[i] == 0) {
continue;
}
if (sdkfjsokdf[i] < i) {
max_tree.add(0, sdkfjsokdf[i] - 1, -1);
max_tree.add(i + 1, n - 1, -1);
} else {
max_tree.add(i + 1, sdkfjsokdf[i] - 1, -1);
}
max_tree.upd(i, max_tree.fnd(botva[i], botva[i]) + 1);
if (botva[i] > i) {
max_tree.add(0, i - 1, 1);
max_tree.add(botva[i] + 1, n - 1, 1);
} else {
max_tree.add(botva[i] + 1, i - 1, 1);
}
if (umn(ans.first, max_tree.fnd(0, n - 1))) {
ans.second = i + 1;
}
}
++ans.first;
}
void clear() { *this = CleverSolution(); }
};
struct StupidSolution : Data {
void solve() {
ans = make_pair(1 << 30, -1);
for (int i = int(0); i < int(n); ++i) {
vector<int> a(n);
SlowMinimumQuerySolver solver(p);
build_tree(0, n - 1, 0, a, posp, solver);
;
pair<int, int> res = make_pair(-1, -1);
for (int j = int(0); j < int(n); ++j) {
if (res.first < a[j]) {
res = make_pair(a[j], i);
}
}
umn(ans, res);
int p0 = p[0];
for (int j = int(0); j < int(((int)(p).size()) - 1); ++j) {
p[j] = p[j + 1];
}
p[n - 1] = p0;
for (int j = int(0); j < int(n); ++j) {
posp[p[j]] = j;
}
}
++ans.first;
}
void clear() { *this = StupidSolution(); }
};
CleverSolution clever_sol;
StupidSolution stupid_sol;
int main() {
cout.setf(ios::showpoint | ios::fixed);
cout.precision(20);
clever_sol.read();
clever_sol.solve();
clever_sol.write();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
template <typename T>
inline T read() {
T sum = 0, fl = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fl = -1;
for (; isdigit(ch); ch = getchar()) sum = (sum << 3) + (sum << 1) + ch - '0';
return sum * fl;
}
const int maxn = 4e5 + 5;
int n, tp, ans, pos;
int val[maxn], lmn[maxn], rmn[maxn], stk[maxn];
namespace SEG {
struct Info {
int mx, tag;
Info() {
tag = 0;
mx = 0;
}
} tr[maxn << 2];
inline void add_tag(int rt, int tag) {
tr[rt].mx += tag;
tr[rt].tag += tag;
}
inline void pushup(int rt) {
tr[rt].mx = max(tr[(rt << 1)].mx, tr[(rt << 1 | 1)].mx);
}
inline void pushdown(int rt) {
if (tr[rt].tag == 0) return;
int &tag = tr[rt].tag;
add_tag((rt << 1), tag);
add_tag((rt << 1 | 1), tag);
tag = 0;
}
void update(int rt, int l, int r, int ql, int qr, int v) {
if (l >= ql && r <= qr) return add_tag(rt, v);
pushdown(rt);
if (((l + r) >> 1) >= ql) update((rt << 1), l, ((l + r) >> 1), ql, qr, v);
if (((l + r) >> 1) < qr)
update((rt << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, v);
pushup(rt);
}
int query(int rt, int l, int r, int ql, int qr) {
if (l >= ql && r <= qr) return tr[rt].mx;
pushdown(rt);
int mx = 0;
if (((l + r) >> 1) >= ql) mx = query((rt << 1), l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) < qr)
mx = max(mx, query((rt << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr));
return mx;
}
} // namespace SEG
void Solve() {
n = read<int>();
for (int i = 1; i <= n; ++i) val[i] = val[i + n] = read<int>();
for (int i = 1; i <= n + n; ++i) {
while (tp && val[stk[tp]] > val[i]) --tp;
if (tp)
lmn[i] = stk[tp];
else
lmn[i] = 0;
stk[++tp] = i;
}
tp = 0;
for (int i = n + n; i >= 1; --i) {
while (tp && val[stk[tp]] > val[i]) --tp;
if (tp)
rmn[i] = stk[tp];
else
rmn[i] = n + n + 1;
stk[++tp] = i;
}
SEG ::update(1, 1, n + n, 1, n + n, 1);
for (int i = 1; i <= n; ++i) {
if (lmn[i] < i - 1) SEG ::update(1, 1, n + n, lmn[i] + 1, i - 1, 1);
if (rmn[i] > i + 1) SEG ::update(1, 1, n + n, i + 1, rmn[i] - 1, 1);
}
ans = SEG ::query(1, 1, n + n, 1, n), pos = 0;
for (int i = 1; i <= n - 1; ++i) {
if (rmn[i] > i + 1) SEG ::update(1, 1, n + n, i + 1, rmn[i] - 1, -1);
if (lmn[i + n] < i + n - 1)
SEG ::update(1, 1, n + n, lmn[i + n] + 1, i + n - 1, 1);
if (rmn[i + n] > i + 1)
SEG ::update(1, 1, n + n, i + n + 1, rmn[i + n] - 1, 1);
int now = SEG ::query(1, 1, n + n, i + 1, i + n);
if (now < ans) ans = now, pos = i;
}
printf("%d %d\n", ans, pos);
}
int main() {
Solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma optimize("TKACHENKO-GORYACHENKO")
#pragma GCC optimize("O3")
using namespace std;
const long long maxn = 2e5 + 100;
const long long inf = 1e15;
long long n, m, k;
long long V[4 * maxn];
vector<long long> A;
vector<long long> A1;
long long C[maxn];
void build(long long v, long long tl, long long tr) {
if (tl == tr) {
V[v] = A[tl];
return;
}
long long tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
V[v] = min(V[2 * v], V[2 * v + 1]);
}
long long getmn(long long v, long long tl, long long tr, long long l,
long long r) {
if (l > tr || tl > r || l > r) {
return inf;
}
if (tl == l && tr == r) {
return V[v];
}
long long tm = (tl + tr) / 2;
long long mn1 = getmn(2 * v, tl, tm, l, min(r, tm));
long long mn2 = getmn(2 * v + 1, tm + 1, tr, max(l, tm + 1), r);
return min(mn1, mn2);
}
long long root;
long long hl, hr;
long long C1[maxn];
void bld(long long p, long long l, long long r, bool is_left_part,
long long h) {
if (l > r) {
return;
}
long long mn = getmn(1, 0, n - 1, l, r);
long long mni = C1[mn];
if (is_left_part) {
hl = max(hl, h);
} else {
hr = max(hr, h);
}
bool is_left_part1 = is_left_part, is_left_part2 = is_left_part;
if (p == -1) {
is_left_part1 = 1;
is_left_part2 = 0;
}
bld(mn, l, mni - 1, is_left_part1, h + 1);
bld(mn, mni + 1, r, is_left_part2, h + 1);
}
long long ans = inf, ansi = 0;
void shift(long long i) {
reverse(A.begin(), A.begin() + n - i);
reverse(A.begin() + n - i, A.end());
reverse(A.begin(), A.end());
}
void make_tree(long long i) {
hl = hr = 0;
shift((i - C[0] + n) % n);
for (long long q = 0; q < n; q++) {
C1[A[q]] = q;
}
build(1, 0, n - 1);
bld(-1, 0, n - 1, 0, 0);
if (max(hl, hr) < ans) {
ansi = (i - C[0] + n) % n;
}
ans = min(ans, max(hl, hr));
A = A1;
}
int main() {
long long q, w, e, t, a, b, c;
cin >> n;
A.resize(n);
for (q = 0; q < n; q++) {
cin >> A[q];
A[q]--;
C[A[q]] = q;
}
A1 = A;
long long L = 0, R = n, M;
while (R - L > 1) {
M = (L + R) / 2;
make_tree(M);
if (hl > hr) {
R = M;
} else {
L = M;
}
}
make_tree(L);
cout << ans + 1 << " " << (n - ansi) % n << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
int n;
const int maxN = 4 * (int)1e5 + 100;
int a[maxN];
mt19937 rnd(228);
int t[4 * maxN];
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v] = a[tl];
return;
}
int tm = (tl + tr) / 2;
build(2 * v, tl, tm);
build(2 * v + 1, tm + 1, tr);
t[v] = min(t[2 * v], t[2 * v + 1]);
}
int find(int v, int tl, int tr, int l, int r, int val, bool left) {
if (r < 1) return -1;
if (l > r) return -1;
if (t[v] > val) return -1;
if (tl == tr) {
return tl;
}
int tm = (tl + tr) / 2;
if (left) {
int p = find(2 * v, tl, tm, l, min(r, tm), val, left);
if (p != -1) return p;
return find(2 * v + 1, tm + 1, tr, max(tm + 1, l), r, val, left);
} else {
int p = find(2 * v + 1, tm + 1, tr, max(tm + 1, l), r, val, left);
if (p != -1) return p;
return find(2 * v, tl, tm, l, min(r, tm), val, left);
}
}
pair<long long, int> tt[4 * maxN];
long long upd[4 * maxN];
void build2(int v, int tl, int tr) {
tt[v] = make_pair(0, tl);
if (tl == tr) return;
int tm = (tl + tr) / 2;
build2(2 * v, tl, tm);
build2(2 * v + 1, tm + 1, tr);
}
void push(int v, int tl, int tr) {
if (upd[v] == 0) return;
tt[v].first += upd[v];
if (tl != tr) {
upd[2 * v] += upd[v];
upd[2 * v + 1] += upd[v];
}
upd[v] = 0;
}
void add(int v, int tl, int tr, int l, int r, int val) {
if (l > r) return;
if (l <= tl && tr <= r) {
upd[v] += val;
push(v, tl, tr);
return;
}
push(v, tl, tr);
if (r < tl || l > tr) return;
int tm = (tl + tr) / 2;
add(2 * v, tl, tm, l, r, val);
add(2 * v + 1, tm + 1, tr, l, r, val);
tt[v] = max(tt[2 * v], tt[2 * v + 1]);
}
const long long INF = 2e9;
pair<int, int> get_mx(int v, int tl, int tr, int l, int r) {
push(v, tl, tr);
if (l <= tl && tr <= r) return tt[v];
if (l > r) return make_pair(-INF, -1);
int tm = (tl + tr) / 2;
return max(get_mx(2 * v, tl, tm, l, min(r, tm)),
get_mx(2 * v + 1, tm + 1, tr, max(l, tm + 1), r));
}
void add(int l, int r, int pos) {
int where = find(1, 1, n, l, r, a[pos], false);
if (where == -1) {
add(1, 1, n, l, r, 1);
add(1, 1, n, r + 1, r + 1, 1);
} else {
auto it = get_mx(1, 1, n, where, where);
add(1, 1, n, where + 1, r, 1);
add(1, 1, n, r + 1, r + 1, it.first + 1);
}
}
void del(int l, int r, int pos) {
int where = find(1, 1, n, l + 1, r, a[pos], true);
if (where == -1) {
add(1, 1, n, l + 1, r, -1);
} else {
add(1, 1, n, l + 1, where - 1, -1);
}
}
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];
}
n *= 2;
build(1, 1, n);
build2(1, 1, n);
for (int i = 1; i <= n / 2; i++) {
add(1, i - 1, i);
}
pair<int, int> best = make_pair(get_mx(1, 1, n, 1, n / 2).first, 0);
for (int i = n / 2 + 1; i < n; i++) {
del(i - n / 2, i - 1, i - n / 2);
add(i - n / 2 + 1, i - 1, i);
best = min(best,
make_pair(get_mx(1, 1, n, i - n / 2 + 1, i).first, i - n / 2));
}
cout << best.first << " " << best.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400000 + 50;
const int maxm = 1300000 + 100;
const int maxt = 3000000 + 100;
const int maxk = 10 + 3;
const int M = 2010;
const long long unit = 1LL;
const int INF = 0x3f3f3f3f;
const long long Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-8;
const double inf = 1e15;
const double pi = acos(-1.0);
const long long mod = 998244353LL, gg = 3LL, inv2 = 499122177LL;
inline long long read() {
long long x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
int n;
int a[maxn], b[maxn];
struct Node {
int lch, rch, fa;
} node[maxn];
struct ST {
int Min[maxn][20], lg2[maxn];
void init(int n) {
lg2[1] = 0;
for (int i = 2; i <= n; ++i) lg2[i] = lg2[i >> 1] + 1;
for (int l = 1; l < 20; ++l)
for (int i = 1; i + (1 << l) - 1 <= n; ++i)
Min[i][l] = min(Min[i][l - 1], Min[i + (1 << (l - 1))][l - 1]);
}
int QMin(int l, int r) {
int k = lg2[r - l + 1];
return min(Min[l][k], Min[r - (1 << k) + 1][k]);
}
} st;
int w[maxn], dep[maxn], pos[maxn];
struct SegTree {
int Max[maxn << 2], lazy[maxn << 2];
void PushUp(int rt) { Max[rt] = max(Max[rt << 1], Max[rt << 1 | 1]); }
void PushDown(int rt) {
if (lazy[rt]) {
Max[rt << 1] += lazy[rt], Max[rt << 1 | 1] += lazy[rt];
lazy[rt << 1] += lazy[rt], lazy[rt << 1 | 1] += lazy[rt];
lazy[rt] = 0;
}
}
void Build(int l, int r, int rt) {
if (l == r) {
Max[rt] = w[l];
return;
}
int m = (l + r) >> 1;
Build(l, m, rt << 1), Build(m + 1, r, rt << 1 | 1);
PushUp(rt);
}
int AskMax(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return Max[rt];
PushDown(rt);
int m = (l + r) >> 1, ans = 0;
if (L <= m) ans = max(ans, AskMax(L, R, l, m, rt << 1));
if (R > m) ans = max(ans, AskMax(L, R, m + 1, r, rt << 1 | 1));
PushUp(rt);
return ans;
}
void Add(int L, int R, int x, int l, int r, int rt) {
if (L <= l && r <= R) {
Max[rt] += x;
lazy[rt] += x;
return;
}
PushDown(rt);
int m = (l + r) >> 1;
if (L <= m) Add(L, R, x, l, m, rt << 1);
if (R > m) Add(L, R, x, m + 1, r, rt << 1 | 1);
PushUp(rt);
}
} seg;
int dfs(int le, int ri) {
if (le > ri) return 0;
int u = st.QMin(le, ri);
int p = pos[u];
node[u].lch = dfs(le, p - 1);
node[u].rch = dfs(p + 1, ri);
return u;
}
void dfs2(int u) {
if (node[u].lch) {
dep[node[u].lch] = dep[u] + 1;
node[node[u].lch].fa = u;
dfs2(node[u].lch);
}
if (node[u].rch) {
dep[node[u].rch] = dep[u] + 1;
node[node[u].rch].fa = u;
dfs2(node[u].rch);
}
}
deque<int> que;
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
int turn = 0;
if (a[n] != 1) {
int j = n;
while (a[j] != 1) --j;
turn = j;
++j;
copy(a + j, a + n + 1, b + 1);
copy(a + 1, a + j, b + n - j + 2);
copy(b + 1, b + n + 1, a + 1);
}
for (int i = 1; i <= n; ++i) pos[a[i]] = i, st.Min[i][0] = a[i];
st.init(n);
node[1].lch = dfs(1, n - 1);
node[1].rch = node[1].fa = 0;
dep[1] = 1;
dfs2(1);
for (int i = 1; i <= n; ++i) w[i] = dep[a[i]];
int le = 1, ri = n;
seg.Build(1, 2 * n, 1);
int ans = seg.AskMax(1, n, 1, 2 * n, 1), anst = turn;
int m = n - 1;
que.push_back(1);
while (m--) {
int x = a[le];
int fx = node[x].fa;
int pfx = pos[fx];
if (le + 1 <= pfx - 1) seg.Add(le + 1, pfx - 1, -1, 1, 2 * n, 1);
node[fx].lch = node[x].rch;
if (node[x].rch) node[node[x].rch].fa = fx;
while (!que.empty() && que.back() > x) que.pop_back();
int y = que.back();
que.push_back(x);
node[x].fa = y;
node[x].lch = node[y].rch;
node[y].rch = x;
node[x].rch = 0;
int py = pos[y];
if (py + 1 <= ri) seg.Add(py + 1, ri, 1, 1, 2 * n, 1);
int d = seg.AskMax(py, py, 1, 2 * n, 1);
seg.Add(ri + 1, ri + 1, d + 1, 1, 2 * n, 1);
++le, ++ri, ++turn, pos[x] = ri, a[ri] = x;
int tmp = seg.AskMax(le, ri, 1, 2 * n, 1);
if (tmp < ans) {
ans = tmp;
anst = turn;
}
}
while (anst >= n) anst -= n;
printf("%d %d\n", ans, anst);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 524288;
struct segtree_lazy {
int a[2 * maxn];
int b[2 * maxn];
void init() {
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
}
void push(int i) {
if (b[i]) {
a[i] += b[i];
if (i < maxn) {
b[2 * i] += b[i];
b[2 * i + 1] += b[i];
}
b[i] = 0;
}
}
int get(int l, int r, int node = 1, int nl = 1, int nr = maxn) {
push(node);
if (r < nl || nr < l) {
return -1;
}
if (l <= nl && nr <= r) {
return a[node];
}
int nm = (nl + nr) >> 1;
return max(get(l, r, 2 * node, nl, nm),
get(l, r, 2 * node + 1, nm + 1, nr));
}
void update(int l, int r, int val, int node = 1, int nl = 1, int nr = maxn) {
if (r < nl || nr < l) {
push(node);
return;
}
if (l <= nl && nr <= r) {
b[node] += val;
push(node);
return;
}
push(node);
int nm = (nl + nr) >> 1;
update(l, r, val, 2 * node, nl, nm);
update(l, r, val, 2 * node + 1, nm + 1, nr);
a[node] = max(a[2 * node], a[2 * node + 1]);
}
};
segtree_lazy drvo;
template <class T, class U>
void cartesian_tree(const T& a, int n, U& l, U& r, U& p) {
for (int i = 1; i <= n; i++) {
p[i] = i - 1;
r[i - 1] = i;
while (p[i] && a[i] < a[p[i]]) {
int j = p[i];
int k = p[j];
int v = l[i];
p[i] = k;
r[k] = i;
p[j] = i;
l[i] = j;
p[v] = j;
r[j] = v;
}
}
}
int n;
pair<int, int> aa[400005];
int a[200005], p[200005], l[200005], r[200005], dub[200005];
void dfs1(int x) {
if (l[x]) dub[l[x]] = dub[x] + 1, dfs1(l[x]);
if (r[x]) dub[r[x]] = dub[x] + 1, dfs1(r[x]);
}
int sol[200005];
int fl[400005], fr[400005];
void seek1() {
basic_string<int> st;
for (int i = 1; i <= 2 * n; i++) {
while (st.size() && aa[i] < aa[st.back()]) {
fr[st.back()] = i;
st.pop_back();
}
st += i;
}
}
void seek2() {
basic_string<int> st;
for (int i = 2 * n; i >= 1; i--) {
while (st.size() && aa[i] < aa[st.back()]) {
fl[st.back()] = i;
st.pop_back();
}
st += i;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
aa[i] = {a[i], 0};
aa[i + n] = {a[i], 1};
}
cartesian_tree(a, n, l, r, p);
dfs1(r[0]);
seek1();
seek2();
for (int i = 1; i <= n; i++) {
drvo.update(i, i, dub[i]);
}
for (int i = 1; i <= n; i++) {
sol[i - 1] = drvo.get(i, i + n - 1);
if (a[i] == 1) continue;
int j = fr[i];
drvo.update(i + 1, j - 1, -1);
int k = fl[i + n];
drvo.update(k + 1, i + n - 1, 1);
drvo.update(i + n, i + n, drvo.get(k, k) + 1);
}
auto it = min_element(sol, sol + n);
cout << *it + 1 << ' ' << it - sol << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200200 << 1], pre[200200], suf[200200], tot, st[200200], b[200200];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[n + i] = a[i];
int shift;
for (shift = 1; shift <= n; shift++)
if (a[shift] == 1) break;
for (int i = 1; i <= n; i++) a[i] = a[i + shift - 1];
a[n + 1] = 1;
tot = 0;
pre[1] = 1;
st[++tot] = 1;
for (int i = 2; i <= n; i++) {
int lst = 0;
while (tot && a[st[tot]] > a[i]) {
int u = st[tot];
tot--;
b[u] = max(b[u], lst + 1);
lst = b[u];
}
b[i] = lst + 1;
st[++tot] = i;
pre[i] = max(pre[i - 1], lst + tot);
}
for (int i = 1; i <= n; i++) b[i] = 0;
tot = 0;
suf[n + 1] = 1;
st[++tot] = n + 1;
for (int i = n; i >= 2; i--) {
int lst = 0;
while (tot && a[st[tot]] > a[i]) {
int u = st[tot];
tot--;
b[u] = max(b[u], lst + 1);
lst = b[u];
}
b[i] = lst + 1;
st[++tot] = i;
suf[i] = max(suf[i + 1], lst + tot);
}
int mn = n + 1;
for (int i = 1; i <= n; i++) mn = min(mn, max(pre[i], suf[i + 1]));
int k;
for (k = 1; k <= n; k++)
if (max(pre[k], suf[k + 1]) == mn) break;
printf("%d %d\n", mn, (k + shift - 1) % n);
return 0;
}
|
#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;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class Iterable,
class = typename enable_if<!is_same<string, Iterable>::value>::type>
auto operator<<(ostream &os, Iterable v) -> decltype(os << *begin(v)) {
os << "[";
for (auto vv : v) os << vv << ", ";
return os << "]";
}
const int inf = 0x3f3f3f3f;
const long long infll = 0x3f3f3f3f3f3f3f3fll;
template <class T>
int sign(T x) {
return (x > 0) - (x < 0);
}
template <class T>
T abs(const T &x) {
return (x < T(0)) ? -x : x;
}
int val[4 * 1123456];
int delta[4 * 1123456];
void prop(int id, int l, int r) {
if (l != r) {
delta[((id) << 1)] += delta[id];
delta[(((id) << 1) + 1)] += delta[id];
}
val[id] += delta[id];
delta[id] = 0;
}
void update(int id, int l, int r, int a, int b, int x) {
if (a == l && b == r) {
delta[id] += x;
prop(id, l, r);
} else {
prop(id, l, r);
int mid = (l + r) / 2;
if (b <= mid) {
update(((id) << 1), l, mid, a, b, x);
prop((((id) << 1) + 1), mid + 1, r);
} else if (a > mid) {
update((((id) << 1) + 1), mid + 1, r, a, b, x);
prop(((id) << 1), l, mid);
} else {
update(((id) << 1), l, mid, a, mid, x);
update((((id) << 1) + 1), mid + 1, r, mid + 1, b, x);
}
val[id] = max(val[((id) << 1)], val[(((id) << 1) + 1)]);
}
}
int get(int id, int l, int r, int a, int b) {
prop(id, l, r);
if (a == l && b == r)
return val[id];
else {
int mid = (l + r) / 2;
if (b <= mid)
return get(((id) << 1), l, mid, a, b);
else if (a > mid)
return get((((id) << 1) + 1), mid + 1, r, a, b);
else
return max(get(((id) << 1), l, mid, a, mid),
get((((id) << 1) + 1), mid + 1, r, mid + 1, b));
}
}
int a[1123456];
int pos[1123456];
int prox[1123456];
int ant[1123456];
int h[1123456];
int main(void) {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) a[i + n] = a[i];
for (int i = 1; i <= n; i++) pos[a[i]] = i;
for (int i = 1; i <= 2 * n; i++) {
int k = i - 1;
while (a[k] >= a[i]) k = ant[k];
ant[i] = k;
}
for (int i = 2 * n; i > 0; i--) {
int k = i + 1;
while (a[k] >= a[i]) k = prox[k];
prox[i] = k;
}
for (int i = 1; i <= n; i++) {
if (a[ant[pos[i]]] > a[prox[pos[i]]] || prox[pos[i]] > n)
h[pos[i]] = h[ant[pos[i]]] + 1;
else
h[pos[i]] = h[prox[pos[i]]] + 1;
}
for (int i = 1; i <= n; i++) update(1, 1, 2 * n, i, i, h[i]);
int ans = 0;
int v = get(1, 1, 2 * n, 1, n);
for (int i = 1; i + 1 <= n; i++) {
update(1, 1, 2 * n, i, min(i + n, prox[i]) - 1, -1);
int nh = (ant[i + n] <= i) ? (1)
: (get(1, 1, 2 * n, ant[i + n], ant[i + n]) + 1);
update(1, 1, 2 * n, i + n, i + n, nh - 1);
update(1, 1, 2 * n, max(ant[i + n], i) + 1, i + n, +1);
if (get(1, 1, 2 * n, i + 1, i + n) < v) {
v = get(1, 1, 2 * n, i + 1, i + n);
ans = i;
}
}
cout << v << " " << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 600005;
int n, lg[N], v[N], st[N][21];
int MIN(int x, int y) { return v[x] < v[y] ? x : y; }
void init() {
for (int i = 1; i <= n + n + n; i++) st[i][0] = i;
for (int i = 2; i <= n + n + n; i++) lg[i] = lg[i >> 1] + 1;
for (int i = 1; (1 << i) <= n + n + n; i++) {
for (int j = 1; j + (1 << i) - 1 <= n + n + n; j++) {
st[j][i] = MIN(st[j][i - 1], st[j + (1 << (i - 1))][i - 1]);
}
}
}
int que(int l, int r) {
int LG = lg[r - l + 1];
return MIN(st[l][LG], st[r - (1 << LG) + 1][LG]);
}
int dfs(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
int rt = que(l, r);
return max(dfs(l, rt - 1), dfs(rt + 1, r)) + 1;
}
int work(int x) {
int rt = que(x, x + n - 1);
return dfs(x, rt - 1) >= dfs(rt + 1, x + n - 1);
}
int main() {
int minn = 1;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", v + i);
if (v[minn] > v[i]) minn = i;
v[n + i] = v[n + n + i] = v[i];
}
init();
int l = minn + 1, r = minn + n, ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (work(mid))
l = mid + 1, ans = mid;
else
r = mid - 1;
}
printf("%d %d\n", dfs(ans, ans + n - 1), (ans - 1) % n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long md = 1000000007) {
long long res = 1;
x %= md;
while (y > 0) {
if (y & 1) res = (res * x) % md;
x = (x * x) % md;
y = y >> 1;
}
return res % md;
}
long long max1(long long a, long long b, long long c = -1000000000000000000LL,
long long d = -1000000000000000000LL) {
long long mx1 = (a > b) ? a : b, mx2 = (c > d) ? c : d;
return ((mx1 > mx2) ? mx1 : mx2);
}
long long tree[800005] = {0};
long long lazy[800005] = {0};
void update_tree(long long node, long long a, long long b, long long i,
long long j, long long value) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (a != b) {
lazy[node * 2 + 1] += lazy[node];
lazy[node * 2 + 2] += lazy[node];
}
lazy[node] = 0;
}
if (a > b || a > j || b < i) return;
if (a >= i && b <= j) {
tree[node] += value;
if (a != b) {
lazy[node * 2 + 1] += value;
lazy[node * 2 + 2] += value;
}
return;
}
update_tree(node * 2 + 1, a, (a + b) / 2, i, j, value);
update_tree(node * 2 + 2, (a + b) / 2 + 1, b, i, j, value);
tree[node] = max(tree[node * 2 + 1], tree[node * 2 + 2]);
}
long long query_tree(long long node, long long a, long long b, long long i,
long long j) {
if (a > b || a > j || b < i) return -1000000000000000000LL;
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (a != b) {
lazy[node * 2 + 1] += lazy[node];
lazy[node * 2 + 2] += lazy[node];
}
lazy[node] = 0;
}
if (a >= i && b <= j) return tree[node];
long long q1 = query_tree(node * 2 + 1, a, (a + b) / 2, i, j);
long long q2 = query_tree(node * 2 + 2, (a + b) / 2 + 1, b, i, j);
long long res = max(q1, q2);
return res;
}
long long seg[800005];
void update(long long index, long long ss, long long se, long long id,
long long val) {
if (ss == se) {
seg[index] = val;
return;
}
if (id > se || id < ss) return;
long long mid = (ss + se) / 2;
update(index * 2 + 1, ss, mid, id, val);
update(index * 2 + 2, mid + 1, se, id, val);
seg[index] = max(seg[index * 2 + 1], seg[index * 2 + 2]);
}
long long query(long long index, long long ss, long long se, long long qs,
long long qe) {
if (qs <= ss && se <= qe) return seg[index];
if (qs > se || qe < ss) return -1000000000000000000LL;
long long mid = (ss + se) / 2;
return max(query(index * 2 + 1, ss, mid, qs, qe),
query(index * 2 + 2, mid + 1, se, qs, qe));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
for (long long i = 0; i <= 800004; i++) seg[i] = 0;
long long n;
cin >> n;
vector<long long> v(n), vv;
map<long long, long long> make_pair;
for (long long i = 0; i < n; i++) cin >> v[i], make_pair[v[i] - 1] = i;
for (long long i = make_pair[0]; i < n; i++) vv.push_back(v[i]);
for (long long i = 0; i < make_pair[0]; i++) vv.push_back(v[i]);
v = vv;
vector<long long> ans(n, 0), ans1(n, 0);
for (long long i = 1; i < n; i++) {
long long prev = query(0, 0, n - 1, 0, v[i] - 2);
long long qq = query_tree(0, 0, n - 1, prev, prev);
update(0, 0, n - 1, v[i] - 1, i);
if (prev + 1 <= i - 1) update_tree(0, 0, n - 1, prev + 1, i - 1, 1);
update_tree(0, 0, n - 1, i, i, qq + 1);
ans[i] = query_tree(0, 0, n - 1, 0, i);
}
reverse(v.begin() + 1, v.end());
for (long long i = 0; i <= 800004; i++) seg[i] = lazy[i] = tree[i] = 0;
for (long long i = 1; i < n; i++) {
long long prev = query(0, 0, n - 1, 0, v[i] - 2);
long long qq = query_tree(0, 0, n - 1, prev, prev);
update(0, 0, n - 1, v[i] - 1, i);
if (prev + 1 <= i - 1) update_tree(0, 0, n - 1, prev + 1, i - 1, 1);
update_tree(0, 0, n - 1, i, i, qq + 1);
ans1[i] = query_tree(0, 0, n - 1, 0, i);
}
long long ff = 1000000000000000000LL;
long long mnx = -1;
for (long long i = 0; i < n; i++) {
if (max(ans[i], ans1[n - 1 - i]) < ff) {
ff = max(ans[i], ans1[n - 1 - i]);
mnx = i + 1;
}
}
mnx += make_pair[0];
mnx %= n;
cout << ff + 1 << " " << mnx;
}
|
#include <bits/stdc++.h>
using namespace std;
struct segTree {
int l, r;
segTree *tl, *tr;
int vl, lz;
segTree(int l, int r) : l(l), r(r) {
vl = lz = 0;
if (l != r) {
int mid = (l + r) / 2;
tl = new segTree(l, mid);
tr = new segTree(mid + 1, r);
}
}
void upd(int v) { vl += v, lz += v; }
void add(int a, int b, int v) {
if (b < l || r < a) return;
if (a <= l && r <= b) return upd(v);
tl->upd(lz), tr->upd(lz), lz = 0;
tl->add(a, b, v), tr->add(a, b, v);
vl = max(tl->vl, tr->vl);
}
};
const int mxn = 400001;
int n;
int a[mxn], l[mxn], r[mxn];
stack<int> second;
segTree tre(1, mxn);
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[n + i] = a[i];
second.push(0);
for (int i = 1; i <= 2 * n; i++) {
r[i] = 2 * n + 1;
while (a[second.top()] >= a[i]) r[second.top()] = i, second.pop();
l[i] = second.top(), second.push(i);
}
int r1 = n + 1, r2 = 0;
for (int i = 1; i < 2 * n; i++) {
tre.add(l[i] + 1, r[i] - 1, 1);
if (i >= n) {
tre.add(l[i - n] + 1, r[i - n] - 1, -1);
if (tre.vl < r1) r1 = tre.vl, r2 = i - n;
}
}
cout << r1 << " " << r2 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
deque<int> L;
int shift_cnt = 0, n;
void rshift() {
shift_cnt++;
shift_cnt %= n;
int g = L.front();
L.pop_front();
L.push_back(g);
}
void lshift() {
shift_cnt += (n - 1);
shift_cnt %= n;
int g = L.back();
L.pop_back();
L.push_front(g);
}
int rev[212121];
struct NODE {
int l, r, p;
} node[1212121];
int node_n;
int mxdepth;
int dfs(NODE now, int depth) {
return max(now.l == -1 ? depth : dfs(node[now.l], depth + 1),
now.r == -1 ? depth : dfs(node[now.r], depth + 1));
}
pair<int, int> build() {
for (int i = 0; i < n; i++) {
rev[L[i]] = i;
}
set<pair<int, pair<int, int>>> S;
node_n = 1;
node[1] = {-1, -1, -1};
S.insert({n - 1, {0, node_n}});
int root;
for (int i = 1; i <= n; i++) {
auto W = S.lower_bound({rev[i], {-1, -1}});
auto v = *W;
S.erase(W);
int l = v.second.first, r = v.first, w = v.second.second;
node_n++;
int now = node_n;
node[now] = {-1, -1, node[w].p};
if (i == 1)
root = now;
else {
if (node[node[w].p].l == w)
node[node[w].p].l = now;
else
node[node[w].p].r = now;
}
if (l <= rev[i] - 1) {
node_n++;
node[now].l = node_n;
node[node_n] = {-1, -1, now};
S.insert({rev[i] - 1, {l, node_n}});
}
if (rev[i] + 1 <= r) {
node_n++;
node[now].r = node_n;
node[node_n] = {-1, -1, now};
S.insert({r, {rev[i] + 1, node_n}});
}
}
int ldepth = node[root].l == -1 ? 0 : dfs(node[node[root].l], 1);
int rdepth = node[root].r == -1 ? 0 : dfs(node[node[root].r], 1);
return {ldepth + 1, rdepth + 1};
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
L.push_back(x);
}
while (L.front() != 1) rshift();
int bef = 0;
int s = 0, e = n;
int ans = 1e9, answ;
while (s <= e) {
int m = (s + e) / 2;
while (bef < m) rshift(), bef++;
while (m < bef) lshift(), bef--;
auto v = build();
if (ans > max(v.first, v.second)) {
ans = max(v.first, v.second);
answ = shift_cnt;
}
if (v.first == v.second) {
break;
}
if (v.first < v.second)
e = m - 1;
else
s = m + 1;
}
printf("%d %d\n", ans, answ);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, ar[8 * 200005 + 555], tr[8 * 200005 + 555], dr[8 * 200005 + 555],
up[8 * 200005 + 555];
long long query(long long, long long, long long, long long, long long),
q1(long long, long long, long long, long long, long long, long long),
q2(long long, long long, long long, long long, long long, long long),
qq(long long, long long, long long, long long, long long);
void build(long long, long long, long long),
func(long long, long long, long long),
upd(long long, long long, long long, long long, long long, long long);
int main() {
scanf("%lld", &n);
for (int i = 1; i < n + 1; i++) {
scanf("%lld", &ar[i]);
ar[n + i] = ar[i];
}
build(0, 1, 2 * n);
func(1, n, 1);
long long ans = qq(0, 1, 2 * n, 1, n), pos = 1;
for (int i = 1; i < n + 1; i++) {
if (ar[i + n] == 1) {
upd(0, 1, 2 * n, i + n, i + n, 1);
continue;
}
long long temp = qq(0, 1, 2 * n, i, i + n - 1);
if (ans > temp) ans = temp, pos = i;
long long x = q1(0, 1, 2 * n, i + 1, i + n - 1, ar[i]);
upd(0, 1, 2 * n, i, x - 1, -1);
x = q2(0, 1, 2 * n, i + 1, i + n - 1, ar[i]);
upd(0, 1, 2 * n, x + 1, i + n - 1, 1);
x = qq(0, 1, 2 * n, x, x);
upd(0, 1, 2 * n, i + n, i + n, x + 1);
}
cout << ans << " " << pos - 1;
}
void func(long long l, long long r, long long depth) {
if (l > r) return;
long long min_ = query(0, 1, 2 * n, l, r);
upd(0, 1, 2 * n, min_, min_, depth);
func(l, min_ - 1, depth + 1);
func(min_ + 1, r, depth + 1);
}
void upd(long long idx, long long l, long long r, long long low, long long high,
long long val) {
if (up[idx]) {
dr[idx] += up[idx];
if (l != r) {
up[2 * idx + 1] += up[idx];
up[2 * idx + 2] += up[idx];
}
up[idx] = 0;
}
if (r < low || l > high) return;
if (low <= l && r <= high) {
dr[idx] += val;
if (l != r) {
up[2 * idx + 1] += val;
up[2 * idx + 2] += val;
}
return;
}
long long mid = (l + r) / 2;
upd(2 * idx + 1, l, mid, low, high, val);
upd(2 * idx + 2, mid + 1, r, low, high, val);
dr[idx] = max(dr[2 * idx + 1], dr[2 * idx + 2]);
}
long long qq(long long idx, long long l, long long r, long long low,
long long high) {
if (up[idx]) {
dr[idx] += up[idx];
if (l != r) {
up[2 * idx + 1] += up[idx];
up[2 * idx + 2] += up[idx];
}
up[idx] = 0;
}
if (high < l || low > r) return 0;
if (low <= l && r <= high) return dr[idx];
long long mid = (l + r) / 2;
long long a = qq(2 * idx + 1, l, mid, low, high),
b = qq(2 * idx + 2, mid + 1, r, low, high);
return max(a, b);
}
long long query(long long idx, long long l, long long r, long long low,
long long high) {
if (r < low || high < l) return 0;
if (l == r) return l;
long long mid = (l + r) / 2;
if (low <= l && r <= high) {
if (tr[2 * idx + 1] < tr[2 * idx + 2])
return query(2 * idx + 1, l, mid, low, high);
return query(2 * idx + 2, mid + 1, r, low, high);
}
long long a = query(2 * idx + 1, l, mid, low, high);
long long b = query(2 * idx + 2, mid + 1, r, low, high);
if (!(a * b)) return a + b;
return (ar[a] < ar[b] ? a : b);
}
void build(long long idx, long long l, long long r) {
if (l == r) {
tr[idx] = ar[l];
return;
}
long long mid = (l + r) / 2;
build(2 * idx + 1, l, mid);
build(2 * idx + 2, mid + 1, r);
tr[idx] = min(tr[2 * idx + 1], tr[2 * idx + 2]);
}
long long q1(long long idx, long long l, long long r, long long low,
long long high, long long val) {
if (low > r || high < l) return -1;
if (tr[idx] > val) return -1;
if (l == r) return l;
long long mid = (l + r) / 2;
long long a = q1(2 * idx + 1, l, mid, low, high, val);
if (a == -1) return q1(2 * idx + 2, mid + 1, r, low, high, val);
return a;
}
long long q2(long long idx, long long l, long long r, long long low,
long long high, long long val) {
if (low > r || high < l) return -1;
if (tr[idx] > val) return -1;
if (l == r) return l;
long long mid = (l + r) / 2;
long long a = q2(2 * idx + 2, mid + 1, r, low, high, val);
if (a == -1) return q2(2 * idx + 1, l, mid, low, high, val);
return a;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int MAXN = 4e5 + 100;
const int fix = 19;
pair<int, int> dp[fix][MAXN];
int a[MAXN], pd[MAXN], n, res;
pair<int, int> sieve(int l, int r) {
int kk = pd[r - l];
return min(dp[kk][l], dp[kk][r - (1 << kk)]);
}
int check(int l, int r) {
if (l >= r) return 0;
pair<int, int> verdict_ok = sieve(l, r);
return max(check(l, verdict_ok.second), check(verdict_ok.second + 1, r)) + 1;
}
void solve() {
for (int i = 2; i < MAXN; i++) pd[i] = pd[i / 2] + 1;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == 1) res = i;
}
rotate(a, a + res, a + n);
for (int i = 0; i < 2 * n; i++) dp[0][i] = make_pair(a[i % n], i);
for (int i = 0; i < fix - 1; i++)
for (int j = 0; j + (1 << (i + 1)) <= 2 * n; j++)
dp[i + 1][j] = min(dp[i][j], dp[i][j + (1 << i)]);
int l, r;
l = 0;
r = n;
while (r - l > 1) {
int md = (l + r) >> 1;
int ok = check(n - md, n);
int ko = check(n + 1, 2 * n - md);
if (ok < ko)
l = md;
else
r = md;
}
int ok = check(n - l, 2 * n - l);
int ko = check(n - r, 2 * n - r);
if (ko < ok) {
l = r;
ok = ko;
}
res -= l;
if (res < 0) res += n;
cout << ok << " " << res << endl;
}
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 int MAXN = 400005;
int n;
int arr[MAXN];
int st[MAXN][20];
int idx[MAXN][20];
int pos = -1;
pair<int, int> getmin(int a, int b) {
int k = log(b - a + 1) / log(2);
int x = st[a][k];
int y = st[b - (1 << k) + 1][k];
if (x < y) {
return {x, idx[a][k]};
} else {
return {y, idx[b - (1 << k) + 1][k]};
}
}
int calc(int l, int r) {
if (l > r) return 0;
if (l == r) return 1;
pair<int, int> mm = getmin(l, r);
int v = mm.first;
int p = mm.second;
int a = calc(l, p - 1);
int b = calc(p + 1, r);
return max(a, b) + 1;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
if (arr[i] == 1) pos = i;
arr[i + n] = arr[i];
st[i][0] = st[i + n][0] = arr[i];
idx[i][0] = i;
idx[i + n][0] = i + n;
}
for (int j = 1; j <= 18; j++) {
for (int i = 1; i <= n * 2; i++) {
if (i + (1 << j) - 1 > n * 2) break;
if (st[i][j - 1] < st[i + (1 << j - 1)][j - 1]) {
st[i][j] = st[i][j - 1];
idx[i][j] = idx[i][j - 1];
} else {
st[i][j] = st[i + (1 << j - 1)][j - 1];
idx[i][j] = idx[i + (1 << j - 1)][j - 1];
}
}
}
int l = 0, r = n - 1;
int mi = 0x3f3f3f3f;
int ii = -1;
while (l <= r) {
int mid1 = l + (r - l) / 3;
int mid2 = r - (r - l) / 3;
int st1 = pos - mid1 + n;
if (st1 > n) st1 -= n;
int d1 = calc(st1, st1 + n - 1);
int st2 = pos - mid2 + n;
if (st2 > n) st2 -= n;
int d2 = calc(st2, st2 + n - 1);
if (d1 < d2) {
mi = d1;
ii = mid1;
r = mid2 - 1;
} else {
mi = d2;
ii = mid2;
l = mid1 + 1;
}
}
ii = pos - ii + n - 1;
if (ii >= n) ii -= n;
cout << mi << ' ' << ii << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sol, n, aa, best = INT_MAX, gde;
vector<pair<int, int> > stk;
void dodaj(int a) {
int mxLevo = 0;
while (stk.size() && stk.back().first < a)
mxLevo = max(mxLevo + 1, stk.back().second + 1), stk.pop_back();
sol = max(sol, (int)stk.size() + mxLevo + 1);
stk.push_back({a, mxLevo});
}
int main() {
scanf("%i", &n);
deque<int> a(n);
vector<int> koliko(n + 1), solL(n + 1), solR(n + 1);
for (int i = 0; i < n; i++)
scanf("%i", &a[i]), a[i] = n - a[i] + 1, koliko[a[i]] = i;
while (a[0] != n) aa = a[0], a.pop_front(), a.push_back(aa);
a.push_back(n);
for (int i = 1; i < n; i++) dodaj(a[i]), solL[i] = sol;
sol = 0;
stk.clear();
for (int i = n - 1; i > 0; i--) dodaj(a[i]), solR[i] = sol;
for (int i = 0; i < n; i++)
if (1 + max(solL[i], solR[i + 1]) < best)
best = 1 + max(solL[i], solR[i + 1]), gde = a[i + 1];
printf("%i %i\n", best, koliko[gde]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 21;
struct segtree {
int l[MAXN], r[MAXN], m[MAXN];
int val[MAXN], tadd[MAXN];
void pull(int o) { val[o] = max(val[(o << 1)], val[(o << 1 | 1)]); }
void push_add(int o, int x) {
val[o] += x;
tadd[o] += x;
}
void push(int o) {
if (l[o] == m[o]) return;
if (tadd[o]) {
push_add((o << 1), tadd[o]);
push_add((o << 1 | 1), tadd[o]);
tadd[o] = 0;
}
}
void build(int o, int ll, int rr) {
int mm = (ll + rr) / 2;
l[o] = ll;
r[o] = rr;
m[o] = mm;
if (ll == mm) return;
build((o << 1), ll, mm);
build((o << 1 | 1), mm, rr);
}
void add(int o, int ll, int rr, int x) {
if (ll <= l[o] and r[o] <= rr) {
push_add(o, x);
} else {
push(o);
if (m[o] > ll) add((o << 1), ll, rr, x);
if (m[o] < rr) add((o << 1 | 1), ll, rr, x);
pull(o);
}
}
void add(int l, int x) { add(1, l, l + 1, x); }
void add(int l, int r, int x) {
if (l < r) add(1, l, r, x);
}
int query(int o, int ll, int rr) {
if (ll <= l[o] and r[o] <= rr) {
return val[o];
} else {
push(o);
if (rr <= m[o]) return query((o << 1), ll, rr);
if (ll >= m[o]) return query((o << 1 | 1), ll, rr);
return max(query((o << 1), ll, rr), query((o << 1 | 1), ll, rr));
}
}
int query(int l) { return query(1, l, l + 1); }
int query(int l, int r) { return query(1, l, r); }
} seg;
int n;
int a[1 << 20];
int fla[1 << 20], llb[1 << 20];
int main() {
scanf("%d", &n);
seg.build(1, 0, n + n + 1);
for (int i = 0; i < int(n); i++) scanf("%d", a + i);
copy(a, a + n, a + n);
fill(begin(fla), end(fla), n + n);
fill(begin(llb), end(llb), -1);
stack<int> s;
s.push(0);
for (int i = 1; i < n + n; i++) {
while (s.size() and a[s.top()] >= a[i]) {
fla[s.top()] = i;
s.pop();
}
s.push(i);
}
s = stack<int>();
s.push(n + n - 1);
for (int i = n + n - 2; i >= 0; i--) {
while (s.size() and a[s.top()] >= a[i]) {
llb[s.top()] = i;
s.pop();
}
s.push(i);
}
for (int i = 0; i < n; i++) {
if (llb[i] >= 0) seg.add(i, seg.query(llb[i]) + 1);
seg.add(llb[i] + 1, i, 1);
}
int ans = INT_MAX, shift = -1;
for (int i = 0; i < n; i++) {
int cur = seg.query(i, i + n);
if (cur < ans) {
ans = cur;
shift = i;
}
seg.add(i + 1, fla[i], -1);
seg.add(llb[i + n] + 1, i + n, 1);
if (i + n - llb[i + n] < n) seg.add(i + n, seg.query(llb[i + n]) + 1);
}
cout << ans + 1 << ' ' << shift << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
const int INF = 1e9 + 7;
vector<int> ans(maxn);
vector<int> lista;
void solve_left() {
int n = lista.size();
vector<int> need(maxn);
vector<pair<int, int> > ativo;
int teto = n - 1;
int sz = 0;
for (int i = 0; i < maxn; i++) need[i] = 0;
need[0] = 1;
int custo = 0;
for (int i = 0; i < n; i++) {
int v = lista[teto];
int total = 0;
int esp = need[sz];
for (int i = sz - 1; i >= 0; i--) {
if (ativo[i].first > v) {
total = max(total + 1, ativo[i].second);
esp++;
sz--;
ativo.pop_back();
} else
break;
}
total++;
ativo.push_back({v, total});
if (total == esp) {
need[sz] = esp + 1;
need[sz + 1] = esp;
custo++;
ans[i] = custo;
} else {
need[sz] = esp;
need[sz + 1] = esp - 1;
ans[i] = custo;
}
sz++;
teto--;
}
}
void solve_right() {
int n = lista.size();
vector<int> need(maxn);
vector<pair<int, int> > ativo;
int teto = n - 1;
int sz = 0;
for (int i = 0; i < maxn; i++) need[i] = 0;
need[0] = 1;
int custo = 0;
for (int i = n - 1; i >= 0; i--) {
int v = lista[teto];
int total = 0;
int esp = need[sz];
for (int i = sz - 1; i >= 0; i--) {
if (ativo[i].first > v) {
total = max(total + 1, ativo[i].second);
esp++;
sz--;
ativo.pop_back();
} else
break;
}
total++;
ativo.push_back({v, total});
if (total == esp) {
need[sz] = esp + 1;
need[sz + 1] = esp;
custo++;
ans[i] = max(ans[i], custo);
} else {
need[sz] = esp;
need[sz + 1] = esp - 1;
ans[i] = max(ans[i], custo);
}
sz++;
teto++;
teto %= n;
}
}
void shift(int res) {
vector<int> aux(lista.size());
int n = lista.size();
for (int i = 0; i < lista.size(); i++) {
aux[(i - res + n) % n] = lista[i];
}
for (int i = 0; i < lista.size(); i++) {
lista[i] = aux[i];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int find;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
if (a == 1) find = i;
lista.push_back(a);
}
find++;
shift(find);
solve_left();
solve_right();
int mini = INF;
int des;
for (int i = 0; i < n; i++) {
if (ans[i] < mini) {
mini = ans[i];
des = (find + (n - i) - 1) % n;
} else if (ans[i] == mini) {
des = min(des, (find + (n - i) - 1) % n);
}
}
cout << mini << " " << des << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7, inf = 1061109567;
const long long infll = 4557430888798830399;
const int N = 4e5 + 5;
class SegTree {
int t[N << 2], lazy[N << 2];
void build(int l, int r, int x) {
if (l == r) {
t[x] = 0;
return;
}
int m = (l + r) >> 1;
build(l, m, x << 1), build(m + 1, r, x << 1 | 1);
t[x] = 0;
}
void push(int l, int r, int x) {
if (l != r) {
lazy[x << 1] += lazy[x];
lazy[x << 1 | 1] += lazy[x];
}
t[x] += lazy[x];
lazy[x] = 0;
}
void upd(int l, int r, int s, int e, int x, int val) {
push(l, r, x);
if (l > e || r < s) return;
if (s <= l && r <= e) {
lazy[x] += val;
push(l, r, x);
return;
}
int m = (l + r) >> 1;
upd(l, m, s, e, x << 1, val);
upd(m + 1, r, s, e, x << 1 | 1, val);
t[x] = max(t[x << 1], t[x << 1 | 1]);
}
int getMax(int l, int r, int s, int e, int x) {
push(l, r, x);
if (l > e || r < s) return -inf;
if (s <= l && r <= e) return t[x];
int m = (l + r) >> 1;
return max(getMax(l, m, s, e, x << 1), getMax(m + 1, r, s, e, x << 1 | 1));
}
public:
int n;
void init(int _n) {
n = _n;
build(0, n - 1, 1);
}
void upd(int l, int r, int val) { upd(0, n - 1, l, r, 1, val); }
int get(int l, int r) { return getMax(0, n - 1, l, r, 1); }
} st;
int n, a[N], ans[N], rangeL[N], rangeR[N], rmq[N][20], logy[N];
int answerMin(int l, int r) {
int tmp = logy[r - l + 1];
return min(rmq[l][tmp], rmq[r - (1 << tmp) + 1][tmp]);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i + n] = a[i];
}
for (int i = 0; i < 2 * n; i++) rmq[i][0] = a[i];
for (int j = 1; j < 20; j++)
for (int i = 0; i < 2 * n; i++)
if (i + (1 << (j - 1)) < 2 * n) {
rmq[i][j] = min(rmq[i][j - 1], rmq[i + (1 << (j - 1))][j - 1]);
}
for (int i = 0; i < 2 * n; i++) logy[i] = log2(i);
st.init(2 * n);
for (int i = 0; i < 2 * n; i++) {
int l = max(0, i - n + 1), r = i;
while (l < r) {
int m = (l + r) >> 1;
if (answerMin(m, i) >= a[i])
r = m;
else
l = m + 1;
}
rangeL[i] = l;
l = i, r = min(2 * n - 1, i + n - 1);
while (l < r) {
int m = (l + r) >> 1;
if (answerMin(i, m + 1) >= a[i])
l = m + 1;
else
r = m;
}
rangeR[i] = l;
}
for (int i = 0; i < n; i++) {
st.upd(rangeL[i], rangeR[i], 1);
}
ans[0] = st.get(0, n - 1);
for (int rotation = 1; rotation < n; rotation++) {
st.upd(rangeL[rotation - 1], rangeR[rotation - 1], -1);
st.upd(rangeL[rotation + n - 1], rangeR[rotation + n - 1], 1);
ans[rotation] = st.get(rotation, rotation + n - 1);
}
int mnAns = inf, mnInd = -1;
for (int rotation = 0; rotation < n; rotation++)
if (ans[rotation] < mnAns) {
mnAns = ans[rotation];
mnInd = rotation;
}
cout << mnAns << " " << mnInd;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int a[maxn], b[maxn], c[maxn], lson[maxn], rson[maxn], stk[maxn];
int vis[maxn];
int dep[maxn];
int rt, n;
void build() {
int top = 0;
for (int i = 1; i <= n; i++) {
lson[i] = rson[i] = vis[i] = 0;
}
stack<int> s;
for (int i = 1; i <= n; i++) {
int last = -1;
while (!s.empty() && a[i] < a[s.top()]) last = s.top(), s.pop();
if (!s.empty()) rson[s.top()] = i;
lson[i] = last;
s.push(i);
}
for (int i = 1; i <= n; i++) {
vis[lson[i]] = vis[rson[i]] = 1;
}
for (int i = 1; i <= n; i++) {
if (vis[i] != 1) rt = i;
}
}
void dfs(int u) {
dep[u] = 1;
if (lson[u] >= 1) dfs(lson[u]), dep[u] = max(dep[u], dep[lson[u]] + 1);
if (rson[u] >= 1) dfs(rson[u]), dep[u] = max(dep[u], dep[rson[u]] + 1);
}
pair<int, int> solve(int p) {
build();
dfs(rt);
if (dep[lson[rt]] <= dep[rson[rt]]) return {dep[rt], 0};
int l = 0, r = p - 1, shift, depth;
while (l <= r) {
int mid = l + r >> 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 (dep[lson[rt]] >= dep[rson[rt]]) {
l = mid + 1;
shift = mid;
depth = dep[rt];
} else
r = mid - 1;
for (int i = 1; i <= n; i++) a[i] = c[i];
}
l = 0, r = shift;
while (l <= r) {
int mid = l + r >> 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 (dep[rt] == depth) {
r = mid - 1;
shift = mid;
} else
l = mid + 1;
for (int i = 1; i <= n; i++) a[i] = c[i];
}
return {depth, shift};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
int p;
for (int i = 1; i <= n; i++) {
cin >> 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;
ans1 = min(ans1, ans2);
cout << ans1.first << " " << ans1.second << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
template <typename _T>
inline void read(_T &f) {
f = 0;
_T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') fu = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const int N = 2e5 + 5;
int a[N], st[N], l[N], r[N], dep[N];
int n, maxn, top, pos, tot, ans = N;
void add(int x) {
while (top && x < st[top]) {
dep[x] = max(dep[x], dep[st[top]]);
--top;
if (top) dep[st[top]] = max(dep[st[top]], dep[st[top + 1]] + 1);
}
st[++top] = x;
++dep[x];
maxn = max(maxn, dep[x] + top - 1);
}
int main() {
read(n);
for (register int i = 1; i <= n; i++) {
read(a[i]);
if (a[i] == 1) pos = i;
}
tot = 0;
for (register int i = pos - 1; i >= 1; i--) add(a[i]), l[++tot] = maxn;
for (register int i = n; i > pos; i--) add(a[i]), l[++tot] = maxn;
tot = maxn = top = 0;
memset(dep, 0, sizeof(dep));
for (register int i = pos + 1; i <= n; i++) add(a[i]), r[++tot] = maxn;
for (register int i = 1; i < pos; i++) add(a[i]), r[++tot] = maxn;
for (register int i = 0; i < n; i++)
ans = min(ans, max(l[i], r[n - i - 1]) + 1);
print(ans, ' ');
tot = 0;
for (register int i = pos - 1; i >= 0; i--) {
if (max(l[i], r[n - i - 1]) + 1 == ans) {
print(tot, '\n');
return 0;
}
++tot;
}
for (register int i = n - 1; i > pos - 1; i--) {
if (max(l[i], r[n - i - 1]) + 1 == ans) {
print(tot, '\n');
return 0;
}
++tot;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool mini(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
bool maxi(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const int N = 4e5 + 5;
const int oo = 1e9;
int mn[N][20];
int a[N];
int n, root;
int getmin(int l, int r) {
int d = log2(r - l + 1);
int i = mn[l][d];
int j = mn[r - (1 << d) + 1][d];
return (a[i] < a[j]) ? i : j;
}
int calc(int l, int r) {
if (l > r) return 0;
int mid = getmin(l, r);
return max(calc(l, mid - 1), calc(mid + 1, r)) + 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 1) root = i;
a[i + n] = a[i];
mn[i][0] = i;
mn[i + n][0] = i + n;
}
for (int j = 1; j < 20; j++)
for (int i = 1; i + (1 << j) - 1 <= (n << 1); i++) {
int x = mn[i][j - 1];
int y = mn[i + (1 << (j - 1))][j - 1];
mn[i][j] = (a[x] < a[y]) ? x : y;
}
int lo = 0;
int hi = n + 1;
while (hi - lo > 1) {
int mid = (lo + hi) >> 1;
int l = (root - mid + n) % n + 1;
int r = l + n - 1;
int pos = l + mid - 1;
if (calc(l, pos - 1) < calc(pos + 1, r))
lo = mid;
else
hi = mid;
}
int ans = oo;
int res = 0;
int l, r;
if (lo > 0) {
l = (root - lo + n) % n + 1;
r = l + n - 1;
if (mini(ans, calc(l, r))) res = l - 1;
}
if (hi <= n) {
l = (root - hi + n) % n + 1;
r = l + n - 1;
if (mini(ans, calc(l, r))) res = l - 1;
}
cout << ans << " " << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> rSteps(vector<int> &p) {
int n = p.size(), i, j;
int pos1 = find((p).begin(), (p).end(), 1) - p.begin();
vector<int> h(n), hr(n), ans(n);
h[pos1] = hr[pos1] = ans[pos1] = 0;
stack<pair<int, int>> d;
d.push({1, pos1});
j = pos1;
for (i = 1; i < n; i++) {
j = (j - 1 + n) % n;
hr[j] = 0;
while (d.top().first > p[j]) {
int hrK = hr[d.top().second];
hr[j] = max(1 + hrK, hr[j] + 1);
d.pop();
}
int pA = d.top().second;
h[j] = h[pA] + 1;
ans[j] = max(ans[(j + 1) % n], h[j] + hr[j]);
d.push({p[j], j});
}
return ans;
}
int main() {
int n, i;
cin >> n;
vector<int> p(n);
for (i = 0; i < n; i++) cin >> p[i];
auto ansR = rSteps(p);
reverse((p).begin(), (p).end());
auto ansL = rSteps(p);
reverse((ansL).begin(), (ansL).end());
int lI = 0, rI = n - 1;
int minH = max(ansR[lI], ansL[rI]);
int bestS = 0;
for (i = 0; i < n - 1; i++) {
lI = (lI + 1) % n;
rI = (rI + 1) % n;
int currH = max(ansR[lI], ansL[rI]);
if (currH < minH) {
minH = currH;
bestS = i + 1;
}
}
cout << (minH + 1) << " " << bestS << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 200200;
const int MM = MN * 2;
class SP {
private:
long long n, h;
vector<long long> lt, w;
vector<vector<long long> > st;
void pre() {
for (int i = 0; i < n; i++) {
st[i][0] = i;
}
for (int j = 1; j <= h; j++) {
for (int i = 0; i + (1 << j) <= n; i++) {
long long a = st[i][j - 1], b = st[i + (1 << (j - 1))][j - 1];
if (w[a] < w[b]) {
st[i][j] = a;
} else {
st[i][j] = b;
}
}
}
}
public:
SP(vector<long long> ar) {
n = ar.size();
w = ar;
h = 0;
lt.assign(2, 0);
for (int i = 2; i <= n; i++) {
lt.push_back(lt[i / 2] + 1);
}
h = lt[n] + 1;
st.assign(n, vector<long long>(h, -1));
pre();
}
long long qu(long long l, long long r) {
long long j = lt[r - l + 1];
long long a = st[l][j], b = st[(r - (1 << j) + 1)][j];
if (w[a] < w[b]) return a;
return b;
}
vector<long long> arr() { return w; }
};
class ST {
private:
int n, h;
vector<long long> st, lz;
const long long STV = -1LL << 62;
int log2(int v) {
if (v <= 1) return 1;
return log2(v / 2) + 1;
}
void ap(int p, int val) {
st[p] += val;
if (p < n) {
lz[p] += val;
}
}
void build(int p) {
while (p > 1) {
p >>= 1;
if (p >= n) continue;
st[p] = max(st[p << 1], st[p << 1 | 1]) + lz[p];
}
}
void psh(int p) {
for (int s = h; s > 0; s--) {
int i = p >> s;
if (lz[i] != 0) {
ap(i << 1, lz[i]);
ap(i << 1 | 1, lz[i]);
lz[i] = 0;
}
}
}
public:
ST(int _n) {
n = _n;
h = log2(n);
st.assign(2 * n, 0);
lz.assign(n, 0);
}
void up(int l, int r, long long val) {
if (l >= r) return;
l += n;
r += n;
int li = l, ri = r;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
ap(l++, val);
}
if (r & 1) {
ap(--r, val);
}
}
build(li);
build(ri - 1);
}
long long qu(int l, int r) {
l += n;
r += n;
psh(l);
psh(r - 1);
long long res = STV;
for (; l < r; l >>= 1, r >>= 1) {
if (l & 1) {
res = max(res, st[l++]);
}
if (r & 1) {
res = max(res, st[--r]);
}
}
return res;
}
};
ST sa(MM);
int w[MN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long> tv(2 * n);
for (int i = 0; i < n; i++) {
cin >> w[i];
tv[i] = tv[i + n] = w[i];
}
SP sb(tv);
for (int i = 0; i < n; i++) {
long long s = 0, e = i;
long long id = -1, lv;
while (s <= e) {
long long m = (s + e) / 2;
if (tv[sb.qu(m, i)] < w[i]) {
id = m;
s = m + 1;
} else {
e = m - 1;
}
}
if (id < 0) {
lv = 1;
} else {
lv = sa.qu(id, id + 1) + 1;
}
sa.up(id + 1, i, 1);
sa.up(i, i + 1, lv);
}
long long ma = sa.qu(0, n), mi = 0;
for (int i = 0; i < n; i++) {
long long s = i + 1, e = i + n;
long long x = -1, lv;
while (s <= e) {
long long m = (s + e) / 2;
if (tv[sb.qu(i + 1, m)] < w[i]) {
x = m;
e = m - 1;
} else {
s = m + 1;
}
}
if (x < 0) {
x = i + n;
}
long long id = -1;
s = i + 1, e = i + n;
while (s <= e) {
long long m = (s + e) / 2;
if (tv[sb.qu(m, i + n)] < w[i]) {
id = m;
s = m + 1;
} else {
e = m - 1;
}
}
if (id < 0) {
lv = 1;
} else {
lv = sa.qu(id, id + 1) + 1;
}
sa.up(i, x, -1);
sa.up(id + 1, i + n, 1);
sa.up(i + n, i + n + 1, lv);
long long nn = sa.qu(i + 1, i + n + 1);
if (nn < ma) {
ma = nn;
mi = i + 1;
}
}
cout << ma << " " << mi << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long md = 1000000007) {
long long res = 1;
x %= md;
while (y > 0) {
if (y & 1) res = (res * x) % md;
x = (x * x) % md;
y = y >> 1;
}
return res % md;
}
long long max1(long long a, long long b, long long c = -1000000000000000000LL,
long long d = -1000000000000000000LL) {
long long mx1 = (a > b) ? a : b, mx2 = (c > d) ? c : d;
return ((mx1 > mx2) ? mx1 : mx2);
}
long long tree[800005] = {0};
long long lazy[800005] = {0};
void update_tree(long long node, long long a, long long b, long long i,
long long j, long long value) {
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (a != b) {
lazy[node * 2 + 1] += lazy[node];
lazy[node * 2 + 2] += lazy[node];
}
lazy[node] = 0;
}
if (a > b || a > j || b < i) return;
if (a >= i && b <= j) {
tree[node] += value;
if (a != b) {
lazy[node * 2 + 1] += value;
lazy[node * 2 + 2] += value;
}
return;
}
update_tree(node * 2 + 1, a, (a + b) / 2, i, j, value);
update_tree(node * 2 + 2, (a + b) / 2 + 1, b, i, j, value);
tree[node] = max(tree[node * 2 + 1], tree[node * 2 + 2]);
}
long long query_tree(long long node, long long a, long long b, long long i,
long long j) {
if (a > b || a > j || b < i) return -1000000000000000000LL;
if (lazy[node] != 0) {
tree[node] += lazy[node];
if (a != b) {
lazy[node * 2 + 1] += lazy[node];
lazy[node * 2 + 2] += lazy[node];
}
lazy[node] = 0;
}
if (a >= i && b <= j) return tree[node];
long long q1 = query_tree(node * 2 + 1, a, (a + b) / 2, i, j);
long long q2 = query_tree(node * 2 + 2, (a + b) / 2 + 1, b, i, j);
return max(q1, q2);
}
long long seg[800005];
void update(long long index, long long ss, long long se, long long id,
long long val) {
if (ss == se) {
seg[index] = val;
return;
}
if (id > se || id < ss) return;
long long mid = (ss + se) / 2;
update(index * 2 + 1, ss, mid, id, val);
update(index * 2 + 2, mid + 1, se, id, val);
seg[index] = max(seg[index * 2 + 1], seg[index * 2 + 2]);
}
long long query(long long index, long long ss, long long se, long long qs,
long long qe) {
if (qs <= ss && se <= qe) return seg[index];
if (qs > se || qe < ss) return -1000000000000000000LL;
long long mid = (ss + se) / 2;
return max(query(index * 2 + 1, ss, mid, qs, qe),
query(index * 2 + 2, mid + 1, se, qs, qe));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
for (long long i = 0; i <= 800004; i++) seg[i] = 0;
long long n;
cin >> n;
vector<long long> v(n), vv;
map<long long, long long> make_pair;
for (long long i = 0; i < n; i++) cin >> v[i], make_pair[v[i] - 1] = i;
for (long long i = make_pair[0]; i < n; i++) vv.push_back(v[i]);
for (long long i = 0; i < make_pair[0]; i++) vv.push_back(v[i]);
v = vv;
vector<long long> ans(n, 0), ans1(n, 0);
for (long long i = 1; i < n; i++) {
long long prev = query(0, 0, n - 1, 0, v[i] - 2);
long long qq = query_tree(0, 0, n - 1, prev, prev);
update(0, 0, n - 1, v[i] - 1, i);
if (prev + 1 <= i - 1) update_tree(0, 0, n - 1, prev + 1, i - 1, 1);
update_tree(0, 0, n - 1, i, i, qq + 1);
ans[i] = query_tree(0, 0, n - 1, 0, i);
}
reverse(v.begin() + 1, v.end());
for (long long i = 0; i <= 800004; i++) seg[i] = lazy[i] = tree[i] = 0;
for (long long i = 1; i < n; i++) {
long long prev = query(0, 0, n - 1, 0, v[i] - 2);
long long qq = query_tree(0, 0, n - 1, prev, prev);
update(0, 0, n - 1, v[i] - 1, i);
if (prev + 1 <= i - 1) update_tree(0, 0, n - 1, prev + 1, i - 1, 1);
update_tree(0, 0, n - 1, i, i, qq + 1);
ans1[i] = query_tree(0, 0, n - 1, 0, i);
}
long long ff = 1000000000000000000LL;
long long mnx = -1;
for (long long i = 0; i < n; i++) {
if (max(ans[i], ans1[n - 1 - i]) < ff) {
ff = max(ans[i], ans1[n - 1 - i]);
mnx = i + 1;
}
}
mnx += make_pair[0];
mnx %= n;
cout << ff + 1 << " " << mnx;
}
|
#include <bits/stdc++.h>
using namespace std;
multiset<int> st;
int p[200010], num[200010], l[200010], r[200010], n, tt;
inline int rd() {
int x = 0;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x;
}
inline void del(int x) { st.erase(st.find(x)); }
inline void gao(int *ans) {
static int a[200010], f[200010];
st.clear();
int top = 0;
for (int i = 1; i <= tt; i++) {
int now = 0;
while (top > 0 && num[a[top]] < num[i]) {
del(f[top] + top);
now = max(now, f[top]) + 1;
top--;
}
a[++top] = i;
f[top] = now;
st.insert(now + top);
ans[i] = *st.rbegin();
}
}
int main() {
n = rd();
for (int i = 1; i <= n; i++) p[i] = n - rd() + 1;
if (n == 1) {
puts("1 0");
return 0;
}
int id = 0;
for (int i = 1; i <= n; i++)
if (p[i] > p[id]) id = i;
tt = 0;
for (int i = 1; i < n; i++) num[++tt] = p[(id + i - 1) % n + 1];
gao(r);
tt = 0;
for (int i = 1; i < n; i++) num[++tt] = p[(id - i + n - 1) % n + 1];
gao(l);
int ans = r[n - 1], res = 0;
for (int i = 1; i <= n - 1; i++) {
if (max(l[i], r[n - 1 - i]) < ans) ans = max(l[i], r[n - 1 - i]), res = i;
}
printf("%d %d\n", ans + 1, ((id - 1) - res + n) % 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);
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);
merge(i);
return;
}
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;
int n, a[400005], dep[200005], minn, ans;
int stk[400005], bot, top, fa[400005], ls[400005], rs[400005];
int maxx[1600005], tag[1600005];
void dfs(int u, int pre) {
dep[u] = dep[pre] + 1;
fa[u] = pre;
if (ls[u]) dfs(ls[u], u);
if (rs[u]) dfs(rs[u], u);
}
inline void pushup(int u) { maxx[u] = max(maxx[u << 1], maxx[u << 1 | 1]); }
void build(int u, int l, int r) {
if (l == r) {
maxx[u] = dep[l];
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
inline void calc(int u, int val) {
maxx[u] += val;
tag[u] += val;
}
inline void pushdown(int u) {
if (tag[u]) {
calc(u << 1, tag[u]);
calc(u << 1 | 1, tag[u]);
tag[u] = 0;
}
}
void modify(int u, int l, int r, int x, int y, int z) {
if (x <= l && r <= y) {
calc(u, z);
return;
}
pushdown(u);
int mid = (l + r) >> 1;
if (x <= mid) modify(u << 1, l, mid, x, y, z);
if (y > mid) modify(u << 1 | 1, mid + 1, r, x, y, z);
pushup(u);
}
int query(int u, int l, int r, int x, int y) {
if (x <= l && r <= y) return maxx[u];
pushdown(u);
int mid = (l + r) >> 1, res = 0;
if (x <= mid) res = max(res, query(u << 1, l, mid, x, y));
if (y > mid) res = max(res, query(u << 1 | 1, mid + 1, r, x, y));
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1, pre; i <= n; ++i) {
scanf("%d", a + i), a[i + n] = a[i];
pre = top;
while (top && a[stk[top]] > a[i]) --top;
if (top) rs[stk[top]] = i;
if (top != pre) ls[i] = stk[top + 1];
stk[++top] = i;
}
dfs(stk[1], 0);
build(2, 1, n);
minn = maxx[1] = maxx[2];
bot = 1;
for (int i = 1, pre, t; i < n; ++i) {
if (i == stk[bot]) {
modify(1, 1, n + n, i, i + n - 1, -1);
fa[rs[i]] = 0;
++bot;
} else {
modify(1, 1, n + n, i, fa[i] - 1, -1);
ls[fa[i]] = rs[i];
fa[rs[i]] = fa[i];
}
pre = top;
while (top >= bot && a[stk[top]] > a[i + n]) --top;
if (top >= bot) {
rs[stk[top]] = i + n, fa[i + n] = stk[top];
modify(1, 1, n + n, i + n, i + n,
query(1, 1, n + n, stk[top], stk[top]) + 1);
} else
modify(1, 1, n + n, i + n, i + n, 1);
if (top != pre) {
ls[i + n] = stk[top + 1], fa[stk[top + 1]] = i + n;
modify(1, 1, n + n, stk[top] + 1, i + n - 1, 1);
}
stk[++top] = i + n;
t = query(1, 1, n + n, i + 1, i + n);
if (t < minn) minn = t, ans = i;
}
printf("%d %d\n", minn, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using PII = pair<int, int>;
template <class T>
struct RangeST {
const int n, h;
vector<T> V, D;
vector<char> B;
function<T(T, T)> op;
function<T(T, T, int)> al;
RangeST(
const vector<T>& A, function<T(T, T)> op = plus<T>(),
function<T(T, T, int)> al = [](T v, T d, int k) { return v + d * k; })
: n(A.size()),
h(32 - __builtin_clz(n)),
V(n * 2),
D(n),
B(n),
op(op),
al(al) {
copy(A.begin(), A.end(), V.begin() + n), build(0, n);
}
void calc(int p, int k) {
T t = op(V[p << 1], V[p << 1 | 1]);
V[p] = B[p] ? al(t, D[p], k) : t;
}
void apply(int p, T val, int k) {
V[p] = al(V[p], val, k);
if (p < n) D[p] = B[p] ? al(D[p], val, 1) : val, B[p] = true;
}
void build(int l, int r) {
l += n, r += n - 1;
for (int k = 2; l > 1; k <<= 1) {
l >>= 1, r >>= 1;
for (int i = r; i >= l; i--) calc(i, k);
}
}
void push(int l, int r) {
int s = h, k = 1 << (h - 1);
for (l += n, r += n - 1; s > 0; --s, k >>= 1)
for (int i = l >> s; i <= r >> s; i++)
if (B[i])
apply(i << 1, D[i], k), apply(i << 1 | 1, D[i], k), B[i] = false;
}
void modify(int l, int r, T val) {
assert(l < r), push(l, l + 1), push(r - 1, r);
int l0 = l, r0 = r, k = 1;
for (l += n, r += n; l < r; l >>= 1, r >>= 1, k <<= 1) {
if (l & 1) apply(l++, val, k);
if (r & 1) apply(--r, val, k);
}
build(l0, l0 + 1), build(r0 - 1, r0);
}
T query(int l, int r) {
assert(l < r), push(l, l + 1), push(r - 1, r);
T left = T(), right = T();
bool b1 = false, b2 = false;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) left = b1 ? op(left, V[l++]) : V[l++], b1 = true;
if (r & 1) right = b2 ? op(V[--r], right) : V[--r], b2 = true;
}
return !b1 ? right : !b2 ? left : op(left, right);
}
};
const int N = 200003;
int n;
int main() {
cin >> n;
vector<int> a(n + n + 1), b(n + n + 1);
for (int i = (1); i <= (n); ++i) scanf("%d", &a[i]), a[i + n] = a[i];
auto st_min = RangeST<int>(
a, [](int x, int y) { return min(x, y); },
[](int x, int y, int k) { return x + y; });
deque<int> st;
for (int i = 1; i <= n; ++i) {
while (!st.empty() && a[st.back()] > a[i]) st.pop_back();
st.push_back(i);
b[i] += st.size();
}
st.clear();
for (int i = n; i >= 1; --i) {
while (!st.empty() && a[st.back()] > a[i]) st.pop_back();
b[i] += st.size();
st.push_back(i);
}
auto st_cnt = RangeST<int>(
b, [](int x, int y) { return max(x, y); },
[](int x, int y, int k) { return x + y; });
int ans = INT_MAX, shift = -1;
st.clear();
for (int i = 1; i <= n; ++i) {
while (!st.empty() && a[st.back()] > a[i]) st.pop_back();
st.push_back(i);
}
for (int i = 1; i <= n; ++i) {
int cur = st_cnt.query(i, i + n);
if (cur < ans) ans = cur, shift = i - 1;
int l = i, r = i + n;
while (l + 1 < r) {
int m = (l + r) >> 1;
if (st_min.query(i, m + 1) >= a[i])
l = m;
else
r = m;
}
if (l > i) st_cnt.modify(i + 1, l + 1, -1);
l = i, r = i + n;
while (l + 1 < r) {
int m = (l + r + 1) >> 1;
if (st_min.query(m, i + n + 1) >= a[i])
r = m;
else
l = m;
}
if (r < i + n) st_cnt.modify(r, i + n, 1);
while (!st.empty() && a[st.back()] >= a[i]) st.pop_back();
st.push_back(i);
st_cnt.modify(i + n, i + n + 1, st.size());
}
cout << ans << ' ' << shift << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long lazy[800010], segtree[800010];
void lazy_update(long long loc, bool nochild) {
if (lazy[loc]) {
segtree[loc] += lazy[loc];
if (!nochild) {
lazy[2 * loc] += lazy[loc];
lazy[2 * loc + 1] += lazy[loc];
}
lazy[loc] = 0;
}
}
void update(long long loc, long long st, long long en, long long l, long long r,
long long delta) {
lazy_update(loc, st == en);
if (st > r || en < l)
return;
else if (st >= l && en <= r) {
lazy[loc] += delta;
lazy_update(loc, st == en);
return;
}
long long mid = (st + en) >> 1;
update(2 * loc, st, mid, l, r, delta);
update(2 * loc + 1, mid + 1, en, l, r, delta);
segtree[loc] = max(segtree[2 * loc], segtree[2 * loc + 1]);
}
long long query(long long loc, long long st, long long en, long long idx) {
lazy_update(loc, st == en);
if (en < idx || st > idx) return 0;
if (st == en && en == idx) return segtree[loc];
long long mid = (st + en) / 2;
if (mid >= idx)
return query(2 * loc, st, mid, idx);
else
return query(2 * loc + 1, mid + 1, en, idx);
}
long long n;
void upd(long long l, long long r, long long delta) {
if (r < l) {
update(1, 0, n - 1, l, n - 1, delta);
update(1, 0, n - 1, 0, r, delta);
} else {
update(1, 0, n - 1, l, r, delta);
}
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<long long> v(n), idx(n + 1), l(n), r(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
idx[v[i]] = i;
}
set<long long> s;
for (long long i = 1; i <= n; i++) {
s.insert(idx[i]);
auto it = s.find(idx[i]);
r[idx[i]] = (next(it) == s.end()) ? *s.begin() : *next(it);
l[idx[i]] = ((it) == s.begin()) ? *s.rbegin() : *prev(it);
long long depth = 0;
if (l[idx[i]] < idx[i]) depth = query(1, 0, n - 1, l[idx[i]]);
if (r[idx[i]] > idx[i]) depth = max(depth, query(1, 0, n - 1, r[idx[i]]));
depth++;
update(1, 0, n - 1, idx[i], idx[i], depth);
l[idx[i]]++;
if (l[idx[i]] == n) l[idx[i]] = 0;
r[idx[i]]--;
if (r[idx[i]] == -1) r[idx[i]] = n - 1;
}
long long mina = n, minidx = 0;
for (long long i = 0; i < n; i++) {
if (segtree[1] < mina) {
mina = segtree[1];
minidx = i;
}
long long delta = query(1, 0, n - 1, (n + l[i] - 1) % n) -
query(1, 0, n - 1, (r[i] + 1) % n);
upd(i, r[i], -1);
upd(l[i], i, 1);
upd(i, i, delta);
}
cout << mina << " " << minidx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MN = 400001;
pair<int, int> t[MN * 4];
int sm[MN * 4];
int p[MN * 4];
int ar[MN];
int vec[MN];
int pmi[MN][2];
int pos[MN];
void build1(int v, int l, int r) {
if (l >= r) {
t[v] = {MN, MN};
}
if (l + 1 == r) {
t[v] = {ar[l], l};
return;
}
int m = (l + r) / 2;
build1(v * 2, l, m);
build1(v * 2 + 1, m, r);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
pair<int, int> un(pair<int, int> a, pair<int, int> b) {
auto [l1, r1] = a;
auto [l2, r2] = b;
pair<int, int> c;
if (l1 == -1)
c.first = l2;
else if (l2 == -1)
c.first = l1;
else if (vec[l1] == vec[l2]) {
c.first = min(l1, l2);
} else if (vec[l1] > vec[l2]) {
c.first = l1;
} else {
c.first = l2;
}
if (r1 == -1)
c.second = r2;
else if (r2 == -1)
c.second = r1;
else if (vec[r1] == vec[r2]) {
c.second = max(r1, r2);
} else if (vec[r1] > vec[r2]) {
c.second = r1;
} else {
c.second = r2;
}
return c;
}
void build3(int v, int l, int r) {
if (l >= r) {
t[v] = {-1, -1};
}
if (l + 1 == r) {
t[v] = {l, l};
return;
}
int m = (l + r) / 2;
build3(v * 2, l, m);
build3(v * 2 + 1, m, r);
t[v] = un(t[v * 2], t[v * 2 + 1]);
}
void build2(int v, int l, int r) {
if (l >= r) {
sm[v] = 0;
}
if (l + 1 == r) {
sm[v] = ar[l];
return;
}
int m = (l + r) / 2;
build2(v * 2, l, m);
build2(v * 2 + 1, m, r);
sm[v] = max(sm[v * 2], sm[v * 2 + 1]);
}
pair<int, int> get1(int v, int l, int r, int lf, int rf) {
if (l >= rf || lf >= r) {
return {MN, MN};
}
if (l >= lf && r <= rf) {
return t[v];
}
int m = (l + r) / 2;
return min(get1(v * 2, l, m, lf, rf), get1(v * 2 + 1, m, r, lf, rf));
}
pair<int, int> get3(int v, int l, int r, int lf, int rf) {
if (l >= rf || lf >= r) {
return {-1, -1};
}
if (l >= lf && r <= rf) {
return t[v];
}
int m = (l + r) / 2;
return un(get3(v * 2, l, m, lf, rf), get3(v * 2 + 1, m, r, lf, rf));
}
void st(int v, int l, int r, int lf, int rf) {
if (l >= rf || lf >= r) {
return;
}
if (l >= lf && r <= rf) {
vec[l] = 1;
return;
}
int m = (l + r) / 2;
st(v * 2, l, m, lf, rf);
st(v * 2 + 1, m, r, lf, rf);
t[v] = un(t[v * 2], t[v * 2 + 1]);
}
int get2(int v, int l, int r, int lf, int rf) {
if (l >= rf || lf >= r) {
return -MN;
}
if (l >= lf && r <= rf) {
return sm[v] + p[v];
}
int m = (l + r) / 2;
return max(get2(v * 2, l, m, lf, rf), get2(v * 2 + 1, m, r, lf, rf)) + p[v];
}
void add(int v, int l, int r, int lf, int rf, int x) {
if (lf >= rf) {
return;
}
if (l >= rf || lf >= r) {
return;
}
if (l >= lf && r <= rf) {
p[v] += x;
return;
}
int m = (l + r) / 2;
add(v * 2, l, m, lf, rf, x);
add(v * 2 + 1, m, r, lf, rf, x);
sm[v] = max(sm[v * 2] + p[v * 2], sm[v * 2 + 1] + p[v * 2 + 1]);
}
void dfs(int l, int r, int d = 0) {
if (l == r) {
return;
}
auto [m, ind] = get1(1, 0, MN, l, r);
ar[ind] = d;
dfs(l, ind, d + 1);
dfs(ind + 1, r, d + 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int v[n * 2];
for (int i = 0; i < n; i++) {
cin >> ar[i];
ar[i + n] = ar[i];
v[i] = ar[i];
v[i + n] = v[i];
pos[ar[i]] = i;
}
build1(1, 0, MN);
for (int i = 0; i < n * 2; i++) {
ar[i] = 0;
}
dfs(0, n);
build2(1, 0, MN);
int ans = get2(1, 0, MN, 0, n);
int ind = 0;
build3(1, 0, MN);
for (int i = 1; i <= n; i++) {
int j = pos[i];
st(1, 0, MN, j, j + 1);
st(1, 0, MN, j + n, j + n + 1);
if (j == 0) {
pmi[j][0] = -1;
} else {
pmi[j][0] = get3(1, 0, MN, 0, j).second;
if (!vec[pmi[j][0]]) pmi[j][0] = -1;
}
if (j == 2 * n - 1) {
pmi[j][1] = -1;
} else {
pmi[j][1] = get3(1, 0, MN, j + 1, n * 2).first;
if (!vec[pmi[j][1]]) pmi[j][1] = -1;
}
j += n;
if (j == 0) {
pmi[j][0] = -1;
} else {
pmi[j][0] = get3(1, 0, MN, 0, j).second;
if (!vec[pmi[j][0]]) pmi[j][0] = -1;
}
if (j == 2 * n - 1) {
pmi[j][1] = -1;
} else {
pmi[j][1] = get3(1, 0, MN, j + 1, n * 2).first;
if (!vec[pmi[j][1]]) pmi[j][1] = MN;
}
}
for (int i = 0; i < n - 1; i++) {
add(1, 0, MN, i, pmi[i][1], -1);
auto x = get2(1, 0, MN, pmi[i + n][0], pmi[i + n][0] + 1);
add(1, 0, MN, i + n, i + n + 1, x + 1);
add(1, 0, MN, pmi[i + n][0] + 1, i + n, 1);
x = get2(1, 0, MN, i + 1, i + 1 + n);
if (x < ans) {
ans = x;
ind = i + 1;
}
}
cout << ans + 1 << ' ' << ind;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
vector<long long> nv;
long long dirn;
long long calc(const vector<long long> &v) {
map<long long, long long> depth;
vector<long long> idx(n + 1);
for (long long i = 0; i < n; i++) {
idx[v[i]] = i;
}
long long l = 1, r = 1;
depth[idx[1]] = 1;
for (long long i = 2; i <= n; i++) {
long long val = 0;
auto it = depth.upper_bound(idx[i]);
if (it != depth.end()) val = max(val, it->second);
if (it != depth.begin()) {
--it;
val = max(val, it->second);
}
depth[idx[i]] = val + 1;
if (idx[i] > idx[1])
r = max(r, val + 1);
else
l = max(l, val + 1);
}
dirn = l - r;
return max(l, r);
}
vector<long long> newvec(const vector<long long> &v, long long mid) {
for (long long i = mid; i < n; i++) nv[i - mid] = v[i];
for (long long i = 0; i < mid; i++) nv[(n - mid) + i] = v[i];
return nv;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
vector<long long> v(n);
nv.resize(n);
for (long long i = 0; i < n; i++) {
cin >> v[i];
}
long long shft = 0;
for (long long i = 0; i < n; i++) {
if (v[i] == 1) {
v = newvec(v, i + 1);
shft = i + 1;
break;
}
}
long long st = 0, en = n - 1;
while (en - st > 1) {
long long mid = (st + en) / 2;
long long a = calc(newvec(v, mid));
if (dirn > 0)
st = mid;
else
en = mid;
}
long long mina = n, minidx = (st + shft) % n;
for (long long i = st; i <= en; i++) {
long long val = calc(newvec(v, i));
if (val < mina) {
minidx = (i + shft) % n;
mina = val;
}
}
cout << mina << " " << minidx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool chkmin(int &x, int y) { return x > y ? x = y, 1 : 0; }
bool chkmax(int &x, int y) { return x < y ? x = y, 1 : 0; }
int readint() {
int 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;
int a[200005], dep[200005];
namespace T1 {
pair<int, int> mina[600000];
void build(int id, int l, int r) {
if (l == r) return (void)(mina[id] = make_pair(a[l], l));
int mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
mina[id] = min(mina[id << 1], mina[id << 1 | 1]);
}
pair<int, int> query(int id, int l, int r, int ql, int qr) {
if (ql > qr) return make_pair(1 << 30, -1);
if (l == ql && r == qr) return mina[id];
int mid = (l + r) / 2;
if (qr <= mid)
return query(id << 1, l, mid, ql, qr);
else if (ql > mid)
return query(id << 1 | 1, mid + 1, r, ql, qr);
else
return min(query(id << 1, l, mid, ql, mid),
query(id << 1 | 1, mid + 1, r, mid + 1, qr));
}
pair<int, int> findnxt(int id, int l, int r, int x, int c) {
if (l == r) {
if (mina[id].first > c)
return make_pair(-1, l + 1);
else
return mina[id];
}
int mid = (l + r) / 2;
if (x <= mid - 1) {
if (mina[id << 1].first < c) {
pair<int, int> lson = findnxt(id << 1, l, mid, x, c);
if (lson.first == -1)
return findnxt(id << 1 | 1, mid + 1, r, mid, c);
else
return lson;
} else
return findnxt(id << 1 | 1, mid + 1, r, mid, c);
} else
return findnxt(id << 1 | 1, mid + 1, r, x, c);
}
pair<int, int> getnxt(int x, int c) {
if (T1::query(1, 1, n, x + 1, n).first > c)
return findnxt(1, 1, n, 0, c);
else
return findnxt(1, 1, n, x, c);
}
pair<int, int> findlst(int id, int l, int r, int x, int c) {
if (l == r) {
if (mina[id].first > c)
return make_pair(-1, l - 1);
else
return mina[id];
}
int mid = (l + r) / 2;
if (x > mid + 1) {
if (mina[id << 1 | 1].first < c) {
pair<int, int> rson = findlst(id << 1 | 1, mid + 1, r, x, c);
if (rson.first == -1)
return findlst(id << 1, l, mid, mid + 1, c);
else
return rson;
} else
return findlst(id << 1, l, mid, mid + 1, c);
} else
return findlst(id << 1, l, mid, x, c);
}
pair<int, int> getlst(int x, int c) {
if (T1::query(1, 1, n, 1, x - 1).first > c)
return findlst(1, 1, n, n + 1, c);
else
return findlst(1, 1, n, x, c);
}
} // namespace T1
namespace T2 {
struct node {
int maxa, lazy;
} t[600000];
void build(int id, int l, int r) {
if (l == r) return (void)(t[id].maxa = dep[l]);
int mid = (l + r) / 2;
build(id << 1, l, mid);
build(id << 1 | 1, mid + 1, r);
t[id].maxa = max(t[id << 1].maxa, t[id << 1 | 1].maxa);
}
void add(int id, int c) { t[id].maxa += c, t[id].lazy += c; }
void pushdown(int id) {
if (t[id].lazy)
add(id << 1, t[id].lazy), add(id << 1 | 1, t[id].lazy), t[id].lazy = 0;
}
void change(int id, int l, int r, int ql, int qr, int c) {
if (ql > qr) return;
if (l == ql && r == qr) return add(id, c);
pushdown(id);
int mid = (l + r) / 2;
if (qr <= mid)
change(id << 1, l, mid, ql, qr, c);
else if (ql > mid)
change(id << 1 | 1, mid + 1, r, ql, qr, c);
else
change(id << 1, l, mid, ql, mid, c),
change(id << 1 | 1, mid + 1, r, mid + 1, qr, c);
t[id].maxa = max(t[id << 1].maxa, t[id << 1 | 1].maxa);
}
void update(int id, int l, int r, int x, int c) {
if (l == r) return (void)(t[id].maxa = c);
pushdown(id);
int mid = (l + r) / 2;
if (x <= mid)
update(id << 1, l, mid, x, c);
else
update(id << 1 | 1, mid + 1, r, x, c);
t[id].maxa = max(t[id << 1].maxa, t[id << 1 | 1].maxa);
}
int getnum(int id, int l, int r, int x) {
if (l == r) return t[id].maxa;
pushdown(id);
int mid = (l + r) / 2;
if (x <= mid)
return getnum(id << 1, l, mid, x);
else
return getnum(id << 1 | 1, mid + 1, r, x);
}
} // namespace T2
void gettree(int l, int r, int fa) {
int tmp = T1::query(1, 1, n, l, r).second;
dep[tmp] = dep[fa] + 1;
if (l != tmp) gettree(l, tmp - 1, tmp);
if (r != tmp) gettree(tmp + 1, r, tmp);
}
int main() {
n = readint();
for (int i = 1; i <= n; i++) a[i] = readint();
T1::build(1, 1, n);
gettree(1, n, 0);
T2::build(1, 1, n);
int ans = T2::t[1].maxa, opt = 0;
for (int i = 1; i <= n; i++) {
if (a[i] == 1) continue;
int lpl = T1::getnxt(i, a[i]).second, rpl = T1::getlst(i, a[i]).second;
if (lpl < i)
T2::change(1, 1, n, i + 1, n, -1), T2::change(1, 1, n, 1, lpl - 1, -1);
else
T2::change(1, 1, n, i + 1, lpl - 1, -1);
if (rpl > i)
T2::change(1, 1, n, 1, i - 1, 1), T2::change(1, 1, n, rpl + 1, n, 1);
else
T2::change(1, 1, n, rpl + 1, i - 1, 1);
T2::update(1, 1, n, i, T2::getnum(1, 1, n, rpl) + 1);
if (chkmin(ans, T2::t[1].maxa)) opt = i % n;
}
cout << ans << ' ' << opt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pi = pair<int, int>;
struct Node {
int f, g;
};
const int nax = 200 * 1000 + 10, INF = 1e9;
int n;
int a[2 * nax];
int nxtl[nax], nxtr[nax], inv[nax];
Node T[(1 << 20)];
set<int> pos;
void propagate(int x) {
T[2 * x].g += T[x].g;
T[2 * x + 1].g += T[x].g;
T[x].g = 0;
}
void update(int a, int b, int x, int v, int l, int r) {
if (a <= l && r <= b) {
T[v].g += x;
return;
}
propagate(v);
int mid = (l + r) / 2;
if (a <= mid) update(a, b, x, v * 2, l, mid);
if (mid < b) update(a, b, x, v * 2 + 1, mid + 1, r);
T[v].f = max(T[2 * v].f + T[2 * v].g, T[2 * v + 1].f + T[2 * v + 1].g);
}
int query(int a, int b, int v, int l, int r) {
if (a <= l && r <= b) {
return T[v].f + T[v].g;
}
propagate(v);
int mid = (l + r) / 2;
int w = -1;
if (a <= mid) w = max(w, query(a, b, v * 2, l, mid));
if (mid < b) w = max(w, query(a, b, v * 2 + 1, mid + 1, r));
T[v].f = max(T[2 * v].f + T[2 * v].g, T[2 * v + 1].f + T[2 * v + 1].g);
return w;
}
pi ans = {INF, -1};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i + n] = a[i];
inv[a[i]] = i;
}
vi S = {2 * n + 1};
for (int i = n; i >= 1; --i) {
while (a[S.back()] > a[i]) S.pop_back();
nxtr[i + n] = S.back();
S.push_back(i + n);
}
for (int i = n; i >= 1; --i) {
while (a[S.back()] > a[i]) S.pop_back();
nxtr[i] = S.back();
S.push_back(i);
}
S = {0};
for (int i = 1; i <= n; i++) {
while (a[S.back()] > a[i]) S.pop_back();
S.push_back(i);
}
for (int i = n + 1; i <= 2 * n; i++) {
while (a[S.back()] > a[i]) S.pop_back();
nxtl[i] = S.back();
S.push_back(i);
}
pos.insert(0);
pos.insert(n + 1);
for (int i = 1; i <= n; i++) {
auto it = pos.lower_bound(inv[i]);
it--;
int x = (*it);
it++;
int y = (*it);
update((x) + 1, y - 1, 1, 1, 1, 2 * n);
pos.insert(inv[i]);
}
for (int i = 0; i < n; i++) {
int w = query(i + 1, n + i, 1, 1, 2 * n);
ans = min(ans, {w, i});
update(i + 1, nxtr[i + 1] - 1, -1, 1, 1, 2 * n);
update(nxtl[i + 1 + n] + 1, i + 1 + n, 1, 1, 1, 2 * n);
int val = query(nxtl[i + 1 + n], nxtl[i + 1 + n], 1, 1, 2 * n);
update(i + 1 + n, i + 1 + n, val, 1, 1, 2 * n);
}
cout << ans.first << " " << ans.second;
}
|
#include <bits/stdc++.h>
using namespace std;
void per() { cerr << endl; }
template <typename Head, typename... Tail>
void per(Head H, Tail... T) {
cerr << H << ' ';
per(T...);
}
template <class T>
bool uin(T& a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T& a, T b) {
return a < b ? (a = b, true) : false;
}
template <class U, class V>
ostream& operator<<(ostream& out, const pair<U, V>& a) {
return out << "(" << a.first << ", " << a.second << ")";
}
template <class U, class V>
istream& operator>>(istream& in, pair<U, V>& a) {
return in >> a.first >> a.second;
}
template <typename W,
typename T = typename enable_if<!is_same<W, string>::value,
typename W::value_type>::type>
ostream& operator<<(ostream& out, const W& v) {
out << "{ ";
for (const auto& first : v) out << first << ", ";
return out << '}';
}
template <class T>
void readArr(T from, T to) {
for (auto i = from; i != to; ++i) cin >> *i;
}
mt19937 mrand(1337);
unsigned int myRand32() { return mrand() & (unsigned int)(-1); }
unsigned long long myRand64() {
return ((unsigned long long)myRand32() << 32) ^ myRand32();
}
const int mod = 1000000007;
void add(int& a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void dec(int& a, int b) {
a -= b;
if (a < 0) a += mod;
}
int mult(int a, int b) { return a * (long long)b % mod; }
int bp(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mult(res, a);
a = mult(a, a);
b >>= 1;
}
return res;
}
struct Tree {
int t[400007 * 4];
int p[400007 * 4];
void push(int v) {
if (p[v]) {
t[v] += p[v];
if (v * 2 + 1 < 400007 * 4) p[v * 2 + 1] += p[v];
if (v * 2 + 2 < 400007 * 4) p[v * 2 + 2] += p[v];
p[v] = 0;
}
}
void add(int v, int vl, int vr, int l, int r, int val) {
push(v);
if (l > r) return;
if (r < vl || l > vr) return;
if (vl >= l && vr <= r) {
p[v] += val;
push(v);
} else {
int vm = (vl + vr) >> 1;
add(v * 2 + 1, vl, vm, l, r, val);
add(v * 2 + 2, vm + 1, vr, l, r, val);
t[v] = max(t[v * 2 + 1], t[v * 2 + 2]);
}
}
int get(int v, int vl, int vr, int l, int r) {
if (r < vl || l > vr) return -1;
if (vl >= l && vr <= r) return t[v];
int vm = (vl + vr) >> 1;
return max(get(v * 2 + 1, vl, vm, l, r), get(v * 2 + 2, vm + 1, vr, l, r));
}
} tr;
struct Tree2 {
pair<int, int> t[400007 * 4];
void up(int v, int vl, int vr, int pos, int val) {
if (vl == vr) {
t[v] = make_pair(val, vl);
} else {
int vm = (vl + vr) >> 1;
if (pos <= vm)
up(v * 2 + 1, vl, vm, pos, val);
else
up(v * 2 + 2, vm + 1, vr, pos, val);
t[v] = min(t[v * 2 + 1], t[v * 2 + 2]);
}
}
pair<int, int> get(int v, int vl, int vr, int l, int r) {
if (r < vl || l > vr) return make_pair(1e9, -1);
if (vl >= l && vr <= r) return t[v];
int vm = (vl + vr) >> 1;
return min(get(v * 2 + 1, vl, vm, l, r), get(v * 2 + 2, vm + 1, vr, l, r));
}
} f2;
int n;
int a[400007];
void build(int vl, int vr) {
if (vl != vr) {
auto [_, vm] = f2.get(0, 0, n, vl, vr);
if (vl < vm) tr.add(0, 0, 2 * n, vl, vm - 1, 1), build(vl, vm - 1);
if (vm + 1 <= vr) tr.add(0, 0, 2 * n, vm + 1, vr, 1), build(vm + 1, vr);
}
}
int prv[400007];
int nxt[400007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
readArr(a, a + n);
for (int i = 0; i < n; ++i) --a[i], f2.up(0, 0, n, i, a[i]);
copy(a, a + n, a + n);
int best = 1e9, best_pos = -1;
fill(prv, prv + 400007, -1);
fill(nxt, nxt + 400007, -1);
vector<pair<int, int> > st;
for (int i = 0; i < n * 2; ++i) {
while (st.size()) {
if (st.back().first >= a[i])
st.pop_back();
else {
prv[i] = st.back().second;
break;
}
}
st.push_back(make_pair(a[i], i));
}
st.clear();
for (int i = 2 * n - 1; i >= 0; --i) {
while (st.size()) {
if (st.back().first >= a[i])
st.pop_back();
else {
nxt[i] = st.back().second;
break;
}
}
st.push_back(make_pair(a[i], i));
}
build(0, n - 1);
for (int i = 0; i < n; ++i) {
auto now = tr.get(0, 0, 2 * n, i, i + n - 1);
if (now < best) {
best = now;
best_pos = i;
}
if (a[i] == 0) continue;
int nx = nxt[i];
int pr = prv[i + n];
tr.add(0, 0, 2 * n, i + 1, nx - 1, -1);
tr.add(0, 0, 2 * n, pr + 1, i + n - 1, 1);
tr.add(0, 0, 2 * n, i + n, i + n, tr.get(0, 0, 2 * n, pr, pr) + 1);
}
cout << best + 1 << ' ' << best_pos;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
int a[400010];
int ddz[400010], ddz_p;
int las[400010], nxt[400010];
struct SEG {
int l, r, MAX, lz;
} seg[1600010];
void push_down(int m) {
if (seg[m].lz != 0) {
int ls = m << 1;
int rs = m << 1 | 1;
seg[ls].MAX += seg[m].lz;
seg[rs].MAX += seg[m].lz;
seg[ls].lz += seg[m].lz;
seg[rs].lz += seg[m].lz;
seg[m].lz = 0;
}
}
int fin(int l, int r, int m) {
if (seg[m].l == l && seg[m].r == r) return seg[m].MAX;
push_down(m);
int mid = (seg[m].l + seg[m].r) >> 1;
if (r <= mid) return fin(l, r, m << 1);
if (l > mid) return fin(l, r, m << 1 | 1);
return max(fin(l, mid, m << 1), fin(mid + 1, r, m << 1 | 1));
}
void modi(int l, int r, int val, int m) {
if (l > r) return;
if (seg[m].l == l && seg[m].r == r) {
seg[m].MAX += val;
seg[m].lz += val;
return;
}
push_down(m);
int mid = (seg[m].l + seg[m].r) >> 1;
if (r <= mid)
modi(l, r, val, m << 1);
else {
if (l > mid)
modi(l, r, val, m << 1 | 1);
else {
modi(l, mid, val, m << 1);
modi(mid + 1, r, val, m << 1 | 1);
}
}
seg[m].MAX = max(seg[m << 1].MAX, seg[m << 1 | 1].MAX);
}
void build(int l, int r, int m) {
seg[m].l = l;
seg[m].r = r;
if (l == r) return;
int mid = (seg[m].l + seg[m].r) >> 1;
build(l, mid, m << 1);
build(mid + 1, r, m << 1 | 1);
seg[m].MAX = max(seg[m << 1].MAX, seg[m << 1 | 1].MAX);
}
int main() {
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];
for (int j = 1; j <= 20; ++j) {
for (int i = 1; i <= N; ++i) {
if (i + (1 << j) > N) break;
}
}
for (int i = N + N; i >= 1; --i) {
while (ddz_p && a[ddz[ddz_p]] > a[i]) {
las[ddz[ddz_p]] = i;
--ddz_p;
}
ddz[++ddz_p] = i;
}
ddz_p = 0;
for (int i = 1; i <= N + N; ++i) {
while (ddz_p && a[ddz[ddz_p]] > a[i]) {
nxt[ddz[ddz_p]] = i;
--ddz_p;
}
ddz[++ddz_p] = i;
}
build(0, N + N, 1);
for (int i = 1; i <= N; ++i) {
modi(las[i] + 1, ((nxt[i] == 0 || nxt[i] > N) ? N + 1 : nxt[i]) - 1, 1, 1);
}
int ans1, ans2;
ans1 = 0;
ans2 = fin(1, N, 1);
for (int i = 1; i < N; ++i) {
modi(i + 1, nxt[i] - 1, -1, 1);
modi(i + N, i + N, fin(las[i + N], las[i + N], 1) + 1, 1);
if (las[i + N] != 0) modi(las[i + N] + 1, i + N - 1, 1, 1);
int t = fin(i + 1, i + N, 1);
if (t < ans2) {
ans2 = t;
ans1 = i;
}
}
printf("%d %d\n", ans2, ans1);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
const int MX = 1 << 18;
int N;
int A[MAXN];
vector<int> v;
int dp1[MAXN], dp2[MAXN];
int seg[MX * 2];
int lazy[MX * 2];
void mkseg(int idx, int l, int r) {
lazy[idx] = 0;
if (l == r)
seg[idx] = (l == 0 ? 1 : 0);
else {
int m = (l + r) / 2;
mkseg(idx * 2, l, m);
mkseg(idx * 2 + 1, m + 1, r);
seg[idx] = max(seg[idx * 2], seg[idx * 2 + 1]);
}
}
void updseg(int idx, int l, int r, int x, int y, int z) {
if (x <= l && r <= y) {
seg[idx] += z;
lazy[idx] += z;
} else if (l <= y && x <= r) {
int m = (l + r) / 2;
updseg(idx * 2, l, m, x, y, z);
updseg(idx * 2 + 1, m + 1, r, x, y, z);
seg[idx] = max(seg[idx * 2], seg[idx * 2 + 1]) + lazy[idx];
}
}
void updseg(int x, int y, int z) { updseg(1, 0, N - 1, x, y, z); }
int gseg(int idx, int l, int r, int x) {
if (l == r) return seg[idx];
int m = (l + r) / 2;
return (x <= m ? gseg(idx * 2, l, m, x) : gseg(idx * 2 + 1, m + 1, r, x)) +
lazy[idx];
}
int gseg(int x) { return gseg(1, 0, N - 1, x); }
void f(int dp[]) {
vector<int> r;
r.push_back(0);
mkseg(1, 0, N - 1);
dp[0] = 1;
for (int i = 1; i < N; i++) {
while (v[r.back()] > v[i]) r.pop_back();
updseg(r.back() + 1, i - 1, 1);
updseg(i, i, gseg(r.back()) + 1);
dp[i] = seg[1];
r.push_back(i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
int one = 0;
for (int i = 1; i < N; i++)
if (A[i] == 1) one = i;
for (int i = one; i < N; i++) v.push_back(A[i]);
for (int i = 0; i < one; i++) v.push_back(A[i]);
f(dp1);
for (int i = 1; i <= (N - 1) / 2; i++) swap(v[i], v[N - i]);
f(dp2);
int mx = 0;
for (int i = 1; i < N; i++)
if (max(dp1[i], dp2[N - 1 - i]) < max(dp1[mx], dp2[N - 1 - mx])) mx = i;
cout << max(dp1[mx], dp2[N - 1 - mx]) << " " << ((one + mx + 1) % N);
return 0;
}
|
#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("%d", &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;
vector<int> Shift(vector<int> &v, int first) {
vector<int> t;
int start = n - first;
for (int i = 0; i < n; ++i) {
t.push_back(v[(i + start) % n]);
}
return t;
}
vector<pair<int, int> > rmq;
void build(int i, int l, int r, vector<int> &v) {
if (r - l == 1) {
rmq[i] = {v[l], l};
return;
}
int mid = (l + r) / 2;
build(2 * i + 1, l, mid, v), build(2 * i + 2, mid, r, v);
rmq[i] = min(rmq[2 * i + 1], rmq[2 * i + 2]);
}
pair<int, int> get_min(int i, int l, int r, int l1, int r1) {
if (l1 >= r1) return {1e9, 1e9};
if (l == l1 && r == r1) return rmq[i];
int mid = (l + r) / 2;
return min(get_min(2 * i + 1, l, mid, l1, min(r1, mid)),
get_min(2 * i + 2, mid, r, max(l1, mid), r1));
}
pair<int, int> solve(int l, int r) {
if (l > r) return {0, 0};
if (l == r) return {1, 0};
pair<int, int> index = get_min(0, 0, n, l, r + 1);
if (l == 0 && r == n - 1) {
int A = solve(l, index.second - 1).first,
B = solve(index.second + 1, r).first;
return {A, B};
}
return {1 + max(solve(l, index.second - 1).first,
solve(index.second + 1, r).first),
0};
}
pair<int, int> get(vector<int> &v) {
build(0, 0, n, v);
return solve(0, n - 1);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
if (n == 1) {
cout << 1 << " " << 0 << endl;
return 0;
}
rmq.assign(4 * n, {-1, -1});
vector<int> v(n);
for (int i = 0; i < n; ++i) cin >> v[i];
int index = -1;
for (int i = 0; i < n; ++i)
if (v[i] == 1) index = i;
int shift = index;
vector<int> t;
for (int i = 0; i < n; ++i) {
t.push_back(v[(i + index) % n]);
}
v = t;
int L = -1, R = n;
while (R - L > 1) {
int M = (L + R) / 2;
vector<int> a = Shift(v, M);
pair<int, int> A = get(a);
if (A.first <= A.second)
L = M;
else
R = M;
}
vector<int> T = Shift(v, L);
int res = (shift + 3 * n - L) % n;
pair<int, int> Q = get(T);
cout << max(Q.first + 1, Q.second + 1) << " " << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class SegmentTreeMin {
public:
inline T MinValue(T val1, T val2) { return min(val1, val2); }
inline void Push(int v) {
if (set_data[v] != -inf_value) {
tree_data[v << 1] = tree_data[(v << 1) | 1] = set_data[v] + add_data[v];
set_data[v << 1] = set_data[(v << 1) | 1] = set_data[v];
add_data[v << 1] = add_data[(v << 1) | 1] = add_data[v];
set_data[v] = -inf_value;
add_data[v] = T{};
} else {
if (add_data[v] != T{}) {
tree_data[v << 1] += add_data[v];
tree_data[(v << 1) | 1] += add_data[v];
add_data[v << 1] += add_data[v];
add_data[(v << 1) | 1] += add_data[v];
add_data[v] = T{};
}
}
}
T UpdateRange(int v, int tl, int tr, int l, int r, T new_val) {
if (l > r) {
return tree_data[v];
}
if (l == tl && tr == r) {
set_data[v] = new_val;
add_data[v] = T{};
return tree_data[v] = new_val;
} else {
Push(v);
int tm = (tl + tr) >> 1;
T left_val = UpdateRange(v << 1, tl, tm, l, min(r, tm), new_val);
T right_val =
UpdateRange((v << 1) | 1, tm + 1, tr, max(l, tm + 1), r, new_val);
return tree_data[v] = MinValue(left_val, right_val);
}
}
inline void UpdateRange(int l, int r, T new_val) {
UpdateRange(1, 0, n - 1, l, r, new_val);
}
inline void Update(int ind, T new_val) {
UpdateRange(1, 0, n - 1, ind, ind, new_val);
}
T AddRange(int v, int tl, int tr, int l, int r, T add_val) {
if (l > r) {
return tree_data[v];
}
if (l == tl && tr == r) {
add_data[v] += add_val;
tree_data[v] += add_val;
return tree_data[v];
} else {
Push(v);
int tm = (tl + tr) >> 1;
T left_val = AddRange(v << 1, tl, tm, l, min(r, tm), add_val);
T right_val =
AddRange((v << 1) | 1, tm + 1, tr, max(l, tm + 1), r, add_val);
return tree_data[v] = MinValue(left_val, right_val);
}
}
inline void AddRange(int l, int r, T add_val) {
AddRange(1, 0, n - 1, l, r, add_val);
}
inline void Add(int ind, T add_val) {
AddRange(1, 0, n - 1, ind, ind, add_val);
}
T GetMin(int v, int tl, int tr, int l, int r) {
if (l > r) {
return inf_value;
}
if (l == tl && r == tr) {
return tree_data[v];
}
int tm = (tl + tr) >> 1;
return MinValue(GetMin(v << 1, tl, tm, l, min(r, tm)),
GetMin((v << 1) | 1, tm + 1, tr, max(l, tm + 1), r));
}
inline T GetMin(int l, int r) { return GetMin(1, 0, n - 1, l, r); }
inline void SetInf(T new_inf_value) { inf_value = new_inf_value; }
inline void Assign(int new_n, T value) {
n = new_n;
tree_data.assign(n << 2, value);
set_data.assign(n << 2, -inf_value);
add_data.assign(n << 2, T{});
}
inline void Resize(int new_n) {
n = new_n;
tree_data.assign(n << 2, inf_value);
set_data.assign(n << 2, -inf_value);
add_data.assign(n << 2, T{});
}
inline void Clear() {
n = 0;
tree_data.clear();
set_data.clear();
add_data.clear();
}
inline SegmentTreeMin() {
n = 0;
SetInf(numeric_limits<T>::max());
}
inline SegmentTreeMin(int new_n) {
SetInf(numeric_limits<T>::max());
Resize(new_n);
}
inline SegmentTreeMin(int new_n, T init_value) {
SetInf(numeric_limits<T>::max());
Assign(new_n, init_value);
}
int n;
T inf_value;
vector<T> tree_data;
vector<T> set_data;
vector<T> add_data;
};
int n;
vector<int> a;
vector<int> unmap;
SegmentTreeMin<int> t;
int s;
inline void init() {
scanf("%d", &n);
t.Assign(n << 1, n);
a.resize(n << 1);
unmap.resize(n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
--a[i];
unmap[a[i]] = i;
if (!a[i]) {
s = i;
}
}
for (int i = 0; i < (n << 1); ++i) {
if (i >= n) {
a[i] = a[i - n];
}
t.Update(i, a[i]);
}
}
pair<pair<int, int>, int> q[1 << 20];
inline int att(int l, int r) {
if (l > r) {
return 0;
}
if (l < 0) {
l += n;
r += n;
}
int res = 0;
int k = 0;
int m = 0;
int lvl = 0;
int ll = 0;
int rr = 0;
q[k++] = pair<pair<int, int>, int>(pair<int, int>(l, r), 1);
for (int i = 0; i < k; ++i) {
ll = q[i].first.first;
rr = q[i].first.second;
lvl = q[i].second;
res = max(res, lvl);
++lvl;
if (ll != rr) {
m = t.GetMin(ll, rr);
m = unmap[m];
if (m < ll) {
m += n;
}
if (ll < m) {
q[k++] = pair<pair<int, int>, int>(pair<int, int>(ll, m - 1), lvl);
}
if (rr > m) {
q[k++] = pair<pair<int, int>, int>(pair<int, int>(m + 1, rr), lvl);
}
}
}
return res + 1;
}
inline int check(int lim) {
int l = 0, r = n - 1;
int cur = 0, cur2 = 0, mid = 0, lft = 0, rgt = 0;
while (l <= r) {
mid = (l + r) >> 1;
lft = s - mid;
rgt = s - 1;
cur = att(lft, rgt);
if (cur > lim) {
r = mid - 1;
} else {
lft = s + 1;
rgt = s + (n - mid - 1);
cur2 = att(lft, rgt);
if (cur2 <= lim) {
return (s - mid + n) % n;
}
l = mid + 1;
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
init();
if (n == 1) {
printf("1 0\n");
return 0;
}
int res = n, shift = 0;
int l = 2, r = n - 1;
while (l <= r) {
int mid = (l + r) >> 1;
int cur = check(mid);
if (cur != -1) {
res = mid;
shift = cur;
r = mid - 1;
} else {
l = mid + 1;
}
}
printf("%d %d\n", res, shift);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 400005;
int t[N << 2], tag[N << 2], n, a[N], tp, st[N], ans, kans, l[N], r[N];
void pushdown(int k) {
if (tag[k]) {
t[k << 1] += tag[k], tag[k << 1] += tag[k];
t[k << 1 | 1] += tag[k], tag[k << 1 | 1] += tag[k];
tag[k] = 0;
}
}
void modify(int k, int L, int R, int l, int r, int x) {
if (L == l && R == r) {
t[k] += x, tag[k] += x;
return;
}
int mid = (L + R) >> 1;
pushdown(k);
if (r <= mid)
modify(k << 1, L, mid, l, r, x);
else if (l > mid)
modify(k << 1 | 1, mid + 1, R, l, r, x);
else {
modify(k << 1, L, mid, l, mid, x);
modify(k << 1 | 1, mid + 1, R, mid + 1, r, x);
}
t[k] = std::max(t[k << 1], t[k << 1 | 1]);
}
int query(int k, int L, int R, int l, int r) {
if (L == l && R == r) return t[k];
int mid = (L + R) >> 1;
pushdown(k);
if (r <= mid) return query(k << 1, L, mid, l, r);
if (l > mid) return query(k << 1 | 1, mid + 1, R, l, r);
return std::max(query(k << 1, L, mid, l, mid),
query(k << 1 | 1, mid + 1, R, mid + 1, r));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = n + 1; i <= 2 * n; i++) a[i] = a[i - n];
for (int i = 1; i <= 2 * n; i++) {
while (tp && a[st[tp]] >= a[i]) tp--;
l[i] = tp ? st[tp] + 1 : 1;
st[++tp] = i;
}
tp = 0;
for (int i = 2 * n; i >= 1; i--) {
while (tp && a[st[tp]] >= a[i]) tp--;
r[i] = tp ? st[tp] - 1 : 2 * n;
st[++tp] = i;
}
for (int i = 1; i <= n; i++) modify(1, 1, 2 * n, l[i], r[i], 1);
ans = query(1, 1, 2 * n, 1, n);
kans = 0;
for (int i = 1; i < n; i++) {
modify(1, 1, 2 * n, l[i], r[i], -1);
modify(1, 1, 2 * n, l[i + n], r[i + n], 1);
int t = query(1, 1, 2 * n, i + 1, i + n);
if (t < ans) ans = t, kans = i;
}
printf("%d %d\n", ans, kans);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
unsigned int logceil(long long first) {
return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
template <typename T, typename Op>
class ConstTree {
public:
explicit ConstTree(const vector<T>& V)
: D(logceil(int(V.size()))), N(V.size()), A{V}, L(N, 0) {
for (unsigned int b = 1; b < D; ++b) {
A.emplace_back(N - (1 << b) + 1);
for (unsigned int i = 0; i + (1 << b) <= N; ++i) {
A[b][i] = op(A[b - 1][i], A[b - 1][i + (1 << (b - 1))]);
}
}
for (unsigned int i = 2; i < N; ++i)
L[i] = L[i - 1] + ((1 << L[i - 1]) == i / 2);
}
void update(const vector<T>& V) {
A[0] = V;
for (unsigned int b = 1; b < D; ++b) {
for (unsigned int i = 0; i + (1 << b) <= N; ++i) {
A[b][i] = op(A[b - 1][i], A[b - 1][i + (1 << (b - 1))]);
}
}
}
T get(unsigned int i, unsigned int j) const {
return op(A[L[j - i]][i], A[L[j - i]][j + 1 - (1 << L[j - i])]);
}
private:
Op op;
unsigned int D, N;
vector<vector<T>> A;
vector<unsigned int> L;
};
template <typename F>
struct MinQOp {
F operator()(F a, F b) const { return std::min(a, b); }
};
template <typename F>
struct MaxQOp {
F operator()(F a, F b) const { return std::max(a, b); }
};
class FGardenerAlex {
public:
vector<int> A, I;
ConstTree<int, MinQOp<int>> MQ{vector<int>{1}};
bool canBeDone(int l, int r, int k) {
if (l > r) return true;
if (k < 20 && (r - l + 1) >= (1 << k)) return false;
if (k == 0) return false;
int m = MQ.get(l, r);
int i = I[m];
return canBeDone(l, i - 1, k - 1) && canBeDone(i + 1, r, k - 1);
}
void solve(istream& cin, ostream& cout) {
int N;
cin >> N;
if (N == 1) {
cout << 1 << ' ' << 0 << endl;
return;
}
A.resize(N);
cin >> A;
int one = -1;
for (int i = 0; i < N; ++i) {
if (A[i] == 1) one = i;
--A[i];
}
rotate(A.begin(), A.begin() + one, A.end());
I.resize(N);
for (int i = 0; i < N; ++i) I[A[i]] = i;
MQ = ConstTree<int, MinQOp<int>>{A};
vector<int> Z(N);
int K = bsl(1, N / 2, [&](int k) {
int w = bsh(1, N - 1, [&](int r) { return canBeDone(1, r, k); });
Z[k] = w;
return canBeDone(w + 1, N - 1, k);
});
cout << K + 1 << ' ' << (Z[K] + one + 1) % N << endl;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
FGardenerAlex solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int SUM = 0, ff = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') ff = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
SUM = (SUM << 3) + (SUM << 1) + (ch ^ 48);
ch = getchar();
}
return SUM * ff;
}
const int N = 400010;
int n, m;
int a[N], l[N], r[N];
int stk[N], tops;
struct segment {
int val, tag;
} tree[N << 2];
inline void pushup(int rt) {
tree[rt].val = max(tree[(rt << 1)].val, tree[((rt << 1) | 1)].val);
}
inline void pushdown(int rt) {
if (!tree[rt].tag) return;
tree[(rt << 1)].val += tree[rt].tag;
tree[(rt << 1)].tag += tree[rt].tag;
tree[((rt << 1) | 1)].val += tree[rt].tag;
tree[((rt << 1) | 1)].tag += tree[rt].tag;
tree[rt].tag = 0;
}
inline void modify(int rt, int l, int r, int L, int R, int val) {
if (L <= l && r <= R) {
tree[rt].val += val;
tree[rt].tag += val;
return;
}
pushdown(rt);
int mid = (l + r) >> 1;
if (L <= mid) modify((rt << 1), l, mid, L, R, val);
if (R > mid) modify(((rt << 1) | 1), mid + 1, r, L, R, val);
pushup(rt);
}
inline int query(int rt, int l, int r, int L, int R) {
if (L <= l && r <= R) return tree[rt].val;
pushdown(rt);
int mid = (l + r) >> 1;
int res = 0;
if (L <= mid) res = max(res, query((rt << 1), l, mid, L, R));
if (R > mid) res = max(res, query(((rt << 1) | 1), mid + 1, r, L, R));
return res;
}
int ans, pos;
int main() {
n = read(), m = 2 * n;
for (int i = 1; i <= n; i++) {
a[i] = read();
a[i + n] = a[i];
r[i] = r[i + n] = m + 1;
}
for (int i = 1; i <= m; i++) {
while (tops && a[stk[tops]] > a[i]) {
r[stk[tops]] = i;
tops--;
}
if (tops) l[i] = stk[tops];
stk[++tops] = i;
}
for (int i = 1; i <= n; i++) {
if (a[i] != 1) modify(1, 1, m, l[i] + 1, r[i] - 1, 1);
}
ans = query(1, 1, m, 1, n);
pos = 0;
for (int i = 1; i <= n - 1; i++) {
if (a[i] == 1) continue;
modify(1, 1, m, l[i] + 1, r[i] - 1, -1);
modify(1, 1, m, l[i + n] + 1, r[i + n] - 1, 1);
int now = query(1, 1, m, i + 1, i + n);
if (now < ans) {
ans = now;
pos = i;
}
}
printf("%d %d\n", ans + 1, pos);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[400005];
int dep[400005];
int l[400005], r[400005];
vector<int> atl[400005], atr[400005];
stack<int> s;
int tree[4 * 400005], lazy[4 * 400005];
void lazify(int s, int e, int i) {
if (lazy[i]) {
tree[i] += lazy[i];
if (s != e) {
lazy[2 * i] += lazy[i];
lazy[2 * i + 1] += lazy[i];
}
lazy[i] = 0;
}
}
void upd(int l, int r, int s, int e, int i, int x) {
lazify(s, e, i);
if (s > r || e < l || l > r) return;
if (s >= l && e <= r) {
lazy[i] += x;
lazify(s, e, i);
return;
}
int mid = (s + e) >> 1;
upd(l, r, s, mid, 2 * i, x);
upd(l, r, mid + 1, e, 2 * i + 1, x);
tree[i] = max(tree[2 * i + 1], tree[2 * i]);
}
int qur(int l, int r, int s, int e, int i) {
if (l == 0 || s > r || e < l) return 0;
lazify(s, e, i);
if (s >= l && e <= r) return tree[i];
int mid = (s + e) >> 1;
return max(qur(l, r, s, mid, 2 * i), qur(l, r, mid + 1, e, 2 * i + 1));
}
void rec(int i, int d) {
dep[i] = d;
int x = -1, y = -1;
if (atr[i].size()) x = atr[i][0];
if (atl[i].size()) y = atl[i].back();
if (x != -1) rec(x, d + 1);
if (y != -1) rec(y, d + 1);
}
void preprocess() {
for (int i = 1; i <= 2 * n; i++) {
while (s.size() && a[s.top()] >= a[i]) s.pop();
if (s.size())
l[i] = s.top();
else
l[i] = 0;
if (i <= n) atl[l[i]].push_back(i);
s.push(i);
}
while (s.size()) s.pop();
for (int i = 2 * n; i >= 1; i--) {
while (s.size() && a[s.top()] >= a[i]) s.pop();
if (s.size())
r[i] = s.top();
else
r[i] = 2 * n + 1;
if (i <= n) atr[r[i]].push_back(i);
s.push(i);
}
for (int i = 0; i <= 2 * n + 1; i++) {
sort(atr[i].begin(), atr[i].end());
sort(atl[i].begin(), atl[i].end());
}
for (int i = 1; i <= n; i++)
if (a[i] == 1) rec(i, 1);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], a[n + i] = a[i];
preprocess();
for (int i = 1; i <= n; i++) upd(i, i, 1, 2 * n, 1, dep[i]);
int ans = qur(1, n, 1, 2 * n, 1);
int shift = 0;
for (int i = 1; i < n; i++) {
int L = i + 1;
int R = min(i + n - 1, r[i] - 1);
upd(L, R, 1, 2 * n, 1, -1);
L = max(i + 1, l[i + n] + 1);
R = i + n - 1;
upd(L, R, 1, 2 * n, 1, 1);
upd(i + n, i + n, 1, 2 * n, 1, qur(l[i + n], l[i + n], 1, 2 * n, 1) + 1);
int cur = qur(i + 1, i + n, 1, 2 * n, 1);
if (ans > cur) ans = cur, shift = i;
}
cout << ans << " " << shift << '\n';
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.