#include using namespace std; using LL = long long int; // テンプレテスト中 #define incII(i, l, r) for(LL i = (l) ; i <= (r); i++) #define incID(i, l, r) for(LL i = (l) ; i < (r); i++) #define incCI(i, l, r) for(LL i = (l) + 1; i <= (r); i++) #define incCD(i, l, r) for(LL i = (l) + 1; i < (r); i++) #define decII(i, l, r) for(LL i = (r) ; i >= (l); i--) #define decID(i, l, r) for(LL i = (r) - 1; i >= (l); i--) #define decCI(i, l, r) for(LL i = (r) ; i > (l); i--) #define decCD(i, l, r) for(LL i = (r) - 1; i > (l); i--) #define inc(i, n) incID(i, 0, n) #define dec(i, n) decID(i, 0, n) #define inc1(i, n) incII(i, 1, n) #define dec1(i, n) decII(i, 1, n) auto inII = [](auto v, auto l, auto r) { return (l <= v && v <= r); }; auto inID = [](auto v, auto l, auto r) { return (l <= v && v < r); }; auto inCI = [](auto v, auto l, auto r) { return (l < v && v <= r); }; auto inCD = [](auto v, auto l, auto r) { return (l < v && v < r); }; #define PB push_back #define EB emplace_back #define MP make_pair #define MT make_tuple #define FI first #define SE second #define FR front() #define BA back() #define ALL(v) v.begin(), v.end() #define RALL(v) v.rbegin(), v.rend() auto setmin = [](auto & a, auto b) { return (b < a ? a = b, true : false); }; auto setmax = [](auto & a, auto b) { return (b > a ? a = b, true : false); }; auto setmineq = [](auto & a, auto b) { return (b <= a ? a = b, true : false); }; auto setmaxeq = [](auto & a, auto b) { return (b >= a ? a = b, true : false); }; #define SC static_cast #define SI(v) SC(v.size()) #define SL(v) SC(v.size()) #define RF(e, v) for(auto & e: v) #define until(e) while(! (e)) #define if_not(e) if(! (e)) #define ef else if #define UR assert(false) #define CT continue #define RV(v) reverse(ALL(v)) auto * IS = & cin; // input elements (as a tuple) template void in_(U & t) { } template void in_(U & t) { (* IS) >> get(t); in_(t); } template auto in() { tuple t; in_, 0, T ...>(t); return t; } // input an array template auto ain() { array a; inc(i, N) { (* IS) >> a[i]; } return a; } // input a (multi-dimensional) vector template T vin() { T v; (* IS) >> v; return v; } template auto vin(N n, M ... m) { vector(m ...))> v(n); inc(i, n) { v[i] = vin(m ...); } return v; } // input multi-column (as a tuple of vector) template void colin_(U & t) { } template void colin_(U & t) { A a; (* IS) >> a; get(t).push_back(a); colin_(t); } template auto colin(int n) { tuple ...> t; inc(i, n) { colin_ ...>, 0, T ...>(t); } return t; } auto * OS = & cout; // output elements void out_(string s) { } template void out_(string s, A && a ) { (* OS) << a; } template void out_(string s, A && a, B && ... b) { (* OS) << a << s; out_(s, b ...); } auto outF = [](auto x, auto y, auto z, auto ... a) { (* OS) << x; out_(y, a ...); (* OS) << z << flush; }; auto out = [](auto ... a) { outF("", " " , "\n", a ...); }; auto outS = [](auto ... a) { outF("", " " , " " , a ...); }; auto outL = [](auto ... a) { outF("", "\n", "\n", a ...); }; auto outN = [](auto ... a) { outF("", "" , "" , a ...); }; array SEQ_FMT = { "", " ", "" }; auto & SEQ_BEG = SEQ_FMT[0]; auto & SEQ_MID = SEQ_FMT[1]; auto & SEQ_END = SEQ_FMT[2]; // output a (multi-dimensional) vector template ostream & operator<<(ostream & os, vector const & v) { os << SEQ_BEG; inc(i, v.size()) { os << (i == 0 ? "" : SEQ_MID) << v[i]; } return (os << SEQ_END); } template void vout_(T && v ) { (* OS) << v; } template void vout_(T && v, A a, B ... b) { inc(i, v.size()) { (* OS) << (i == 0 ? "" : a); vout_(v[i], b ...); } } template void vout(T && v, A a, B ... b) { vout_(v, b ...); (* OS) << a << flush; } // ---- ---- template class SegmentTree { private: int n, s; vector a; function f; T e; bool ok; public: SegmentTree() { n = 0; } SegmentTree(int nn, function ff, T ee) { init(nn, ff, ee); } void init(int nn, function ff, T ee) { n = nn; f = ff; e = ee; s = 1; while(s < n) { s *= 2; } a = vector(2 * s, e); ok = true; } void shift(int & p) { assert(inID(p, 0, n)); p += s; } void apply(int p, function g) { shift(p); g(a[p]); while(p > 1) { p /= 2; a[p] = f(a[2 * p], a[2 * p + 1]); } } T fold_ID(int l, int r) { assert(ok); assert(inII(l, 0, n)); l += s; assert(inII(r, 0, n)); r += s; r--; T x = e, y = e; while(l <= r) { if(l % 2 == 1) { x = f(x, a[l]); l++; } if(r % 2 == 0) { y = f(a[r], y); r--; } l /= 2; r /= 2; } return f(x, y); } T fold_II(int l, int r) { return fold_ID(l + 0, r + 1); } T fold_CI(int l, int r) { return fold_ID(l + 1, r + 1); } T fold_CD(int l, int r) { return fold_ID(l + 1, r + 0); } const T & operator[](int p) { shift(p); return a[p]; } T & ref(int p) { shift(p); ok = false; return a[p]; } void update() { dec(i, s) { a[i] = f(a[2 * i], a[2 * i + 1]); } ok = true; } }; #define OP(s) [&](auto & A, auto & B) { return s; } #define AP(s) [&](auto & A) { s; } // ---- #define UQwoS(v) v.erase(unique(ALL(v)), v.end()) #define UQ(v) sort(ALL(v)); UQwoS(v) #define LB(v, x) (lower_bound(ALL(v), x) - v.begin()) #define UB(v, x) (upper_bound(ALL(v), x) - v.begin()) int main() { auto [n] = in(); auto v = vin(n); auto u = v; UQ(u); int h = SI(u); SegmentTree st1(h, OP(A + B), 0); SegmentTree st2(h, OP(A + B), 0); vector LI(n), LD(n), RI(n), RD(n); inc(i, n) { int x = LB(u, v[i]); LI[i] = st1.fold_ID(0, x) + 1; LD[i] = st1.fold_CD(x, h) + 1; st1.apply(x, AP(A = 1)); } dec(i, n) { int x = LB(u, v[i]); RI[i] = st2.fold_ID(0, x) + 1; RD[i] = st2.fold_CD(x, h) + 1; st2.apply(x, AP(A = 1)); } int ans = 0; inc(i, n) { setmax(ans, min(LI[i], RI[i]) - 1); setmax(ans, min(LD[i], RD[i]) - 1); } out(ans); }