text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[n];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
int mn = min(a[n - 1] - 1, 1000000 - a[0]);
for (int i = 0; i < n - 1; i++) {
mn = min(mn, max(a[i] - 1, 1000000 - a[i + 1]));
}
printf("%d\n", mn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000], ans = numeric_limits<int>::max();
void solve() {
cin >> n;
a[0] = 1;
a[n + 1] = 1000000;
for (int i = int(1); i <= int(n); i++) {
cin >> a[i];
}
for (int i = int(0); i <= int(n); i++) {
ans = min(ans, max(a[i] - 1, 1000000 - a[i + 1]));
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int l = 0, r = 1e6;
while (r - l > 1) {
int m = (r + l) / 2;
bool flag = true;
for (int i = 0; i < n; i++) {
if (!(a[i] <= 1 + m || a[i] >= 1e6 - m)) {
flag = false;
break;
}
}
if (flag)
r = m;
else
l = m;
}
cout << r;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
while (cin >> n) {
int minn = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
int a = x - 1;
int b = 1000000 - x;
int tm = min(a, b);
minn = max(minn, tm);
}
cout << minn << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
long long a[100005];
int main(int argc, char** argv) {
string s;
int n;
cin >> n;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
long long mx = a[n] - 1;
for (int i = 1; i <= n; i++) {
mx = min(mx, max(1000000 - a[i], a[i - 1] - 1));
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, ans = 1e7;
cin >> n;
int arr[n];
for (int i = 0; i < (int)(n); i++) cin >> arr[i];
ans = min(arr[n - 1] - 1, 1000000 - arr[0]);
for (int i = 0; i < (int)(n - 1); i++) {
ans = min(ans, max(arr[i] - 1, 1000000 - arr[i + 1]));
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n) {
vector<int> v;
long long res, me = 0, mf = 0;
for (int i = 0; i < n; i++) {
int c;
cin >> c;
v.push_back(c);
}
long long res1 = 1000000 - v[0];
res = 1000007;
v.push_back(1000000);
for (int i = 0; i < v.size() - 1; i++) {
me = v[i] - 1;
mf = 1000000 - v[i + 1];
if (i == n - 1) {
res = min(res, me);
continue;
}
res = min(res, max(me, mf));
}
cout << min(res, res1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int p = 1000000;
int n, m;
int a[maxn], maxa;
int res;
void solve() {
if (n == 1) {
res = min(a[1] - 1, abs(p - a[1]));
} else {
res = p;
for (int i = 0; i < n; i++) {
if (a[i + 1] > p) break;
res = min(res, max(a[i] - 1, m + p - a[i + 1]));
}
res = min(res, a[n] - 1);
}
printf("%d\n", res);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
maxa = (a[i], maxa);
}
if (maxa > p) m = (maxa - p) * 2;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n;
long long a[100005];
bool check(long long t) {
for (long long i = 1; i <= n; i++) {
if (((a[i] - 1) > t) && ((1000000LL - a[i]) > t)) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
long long hi = 1e6;
long long lo = 0;
while (hi > lo) {
long long mid = lo + (hi - lo) / 2;
if (check(mid))
hi = mid;
else
lo = mid + 1;
}
cout << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k;
cin >> n;
long long int x, ans = LLONG_MIN;
for (i = 0; i < n; i++) {
cin >> x;
ans = max(ans, min(abs(x - 1), abs(1000000 - x)));
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long fpow(long long n, long long k, long long p = 1000000007) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
long long inv(long long a, long long p = 1000000007) {
return fpow(a, p - 2, p);
}
long long Sqrt(long long x) {
if (x == 0 || x == 1) return x;
long long start = 1, end = x, ans;
while (start <= end) {
long long mid = (start + end) / 2;
if (mid * mid == x) return mid;
if (mid * mid < x) {
start = mid + 1;
ans = mid;
} else
end = mid - 1;
}
return ans;
}
long long power(long long x, long long y) {
if (y == 0)
return 1;
else if (y % 2 == 0)
return power(x, y / 2) * power(x, y / 2);
else
return x * power(x, y / 2) * power(x, y / 2);
}
long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void in(long long &no) {
bool neg = false;
register long long c;
no = 0;
c = getchar();
if (c == '-') {
neg = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) no = no * 10 + c - 48;
if (neg) no *= -1;
}
long long maxx(long long a, long long b) {
if (a > b) return a;
return b;
}
int main() {
long long i, n, k, x;
cin >> n;
vector<long long> v1, v2;
v1.push_back(1);
v2.push_back(1e6);
for (int i = (0); i < (n); i++) {
cin >> x;
if (x > 500000) {
v2.push_back(x);
} else
v1.push_back(x);
}
long long a, b;
a = (*max_element(v1.begin(), v1.end()));
b = (*min_element(v2.begin(), v2.end()));
cout << maxx(1e6 - b, a - 1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long isvowel(char c) {
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' || c == 'y')
return 1;
else
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i, j;
long long n;
cin >> n;
long long s = 1000000;
vector<long long> v(s + 1);
for (i = 1; i <= n; i++) {
long long a;
cin >> a;
v[a] = 1;
}
long long tot = 0;
long long me = 1, he = 1000000;
long long time = 0;
while (1) {
time++;
me++;
if (v[me] == 1) tot++;
if (tot == n || me == he - 1) break;
he--;
if (v[he] == 1) tot++;
if (tot == n || me == he - 1) break;
}
cout << time << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x, ans1, ans2;
int main() {
ios::sync_with_stdio();
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
if (x <= 500000) {
ans1 = max((x - 1), ans1);
} else {
ans2 = max((1000000 - x), ans2);
}
}
cout << max(ans1, ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 * 100 * 2 + 10;
long long int ans[MAXN];
long long int mark[MAXN];
long long int s = 1000 * 1000;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
int ind = 0, x = 0;
int mx = 0;
for (int i = 0; i < n; i++) {
int m;
cin >> m;
if (m > s / 2) {
m = s - m;
} else {
m--;
}
if (m > mx) {
mx = m;
}
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int a[n];
for (i = 0; i < n; i++) cin >> a[i];
vector<int> b;
for (i = 0; i < n; i++) {
if (a[i] <= 1e6 - a[i])
b.push_back(a[i] - 1);
else
b.push_back(1e6 - a[i]);
}
sort(b.begin(), b.end());
cout << b[b.size() - 1];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> arr(n);
long long int minval = INT_MIN;
for (int i = 0; i < n; ++i) {
cin >> arr[i];
minval = max(minval, min(abs(arr[i] - 1), abs(1000000 - arr[i])));
}
cout << minval << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int bmod(int a, int b, int m) {
if (b == 0) return 1;
int x = bmod(a, b / 2, m);
x = (x * x) % m;
if (b % 2 == 1) x = (x * a) % m;
return x;
}
long long int a[3000007];
long long int mapp[3000007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n, ans = -1, cnt1 = 1, cnt2 = 1, an1 = -1, an2 = -1;
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
mapp[a[i]] = 1;
}
for (int i = 2, j = 999999; i < j; i++, j--) {
if (mapp[i] == 1) {
an1 = cnt1;
}
if (mapp[j] == 1) {
an2 = cnt2;
}
cnt1++;
cnt2++;
}
ans = max(an1, an2);
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
stringstream ss, ss1, ss2, ssx[1001];
string s, s1, s2, sx[1001];
char c[10001], c1, c2, cx[1001];
long long n, k, m, i, j, q, w, e, x, y, z, mx = -1e9, mn = +1e9, ans, sum,
a[1000001], b[1000001];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
x = a[i];
b[x] = x;
}
for (i = 2, sum = 1, ans = 0, j = 999999; i <= 500002; i++, j--, sum++) {
if (i == 2) ans = 0;
if (b[i] != 0) {
ans++;
}
if (b[j] != 0) {
ans++;
}
if (ans == n) {
cout << sum << endl;
return 0;
}
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
int main() {
long long t;
t = 1;
for (long long cs = 1; cs <= t; cs++) {
long long m, n, b, c, d, i, j, k, x, y, z, l, r, p, q;
string s, s1, s2, s3, s4;
long long cnt = 0, cn = 0, ans = 0, sum = 0;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) cin >> a[i];
vector<long long> v;
for (long long i = 0; i < n; i++) {
x = a[i] - 1;
y = 1000000 - a[i];
ans = min(x, y);
v.push_back(ans);
}
sort((v).rbegin(), (v).rend());
ans = v[0];
cout << ans;
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
set<int> s;
cin >> n;
long long g;
long long a, b;
a = 1;
b = 1000000;
for (int c = 0; c < n; c++) {
cin >> g;
s.insert(g);
}
long long p = 0;
long long c = 0;
for (c;; c++) {
if (s.find(a) != s.end()) p++;
if (s.find(b) != s.end()) p++;
a++;
b--;
if (p == n) break;
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6;
int main() {
int n;
scanf("%d", &n);
int maximum = -maxn, m;
while (n--) {
scanf("%d", &m);
maximum = max(maximum, min(m - 1, maxn - m));
}
printf("%d\n", maximum);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int pt, ans1 = 0, ans2 = 0;
cin >> pt;
int pos[pt];
for (int i = 0; i < pt; i++) {
cin >> pos[i];
}
for (int i = 0; i < pt; i++) {
if (pos[i] > 500000) {
if (ans2 < 1000000 - (pos[i])) ans2 = 1000000 - (pos[i]);
} else if (pos[i] < 500000) {
if (ans1 < pos[i] - 1) {
ans1 = pos[i] - 1;
}
} else {
cout << 500000 - 1 << endl;
return 0;
}
}
cout << max(ans1, ans2) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int main() {
v.assign(1000001, 0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v[a] = 1;
}
int cont = 0;
int me = 1, fri = 1000000;
int answer = 0;
while (cont < n) {
if (v[me] == 1) {
v[me] = 0;
++cont;
}
if (v[fri] == 1) {
v[fri] = 0;
++cont;
}
--fri;
++me;
++answer;
}
cout << answer - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char a[100005], b[100005];
int main() {
int n;
scanf("%d", &n);
int ans = 0, x;
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
ans = max(ans, min(x - 1, 1000000 - x));
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int u = 1000000;
int ans;
int n;
int main() {
scanf("%d", &n);
while (n--) {
int x;
scanf("%d", &x);
ans = max(ans, min(x - 1, u - x));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 5;
int n, a, b, x, ar[MX];
string str;
char stt[] = {'a', 'e', 'i', 'o', 'u', 'y'};
bool isvowel(char ch) {
int k;
for (k = 0; k < 6; k++)
if (stt[k] == ch) {
break;
}
if (k == 6) return 0;
return 1;
}
int main() {
while (cin >> n) {
for (int i = 0; i < n; i++) scanf("%d", &ar[i]);
if (n == 1) {
printf("%d\n", min(ar[0] - 1, 1000000 - ar[0]));
continue;
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans = max(ans, min(ar[i] - 1, 1000000 - ar[i]));
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0;
int r = 1000000;
cin >> n;
for (int i = 0; i < n; i++) {
int pos;
cin >> pos;
ans = max(ans, min(pos - 1, r - pos));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, ara[100009];
scanf("%d", &n);
for (int i = 2; i <= n + 1; i++) {
scanf("%d", &ara[i]);
}
std::sort(ara + 2, ara + n + 1);
int t1 = 0, t2 = 0;
for (int i = 2; i <= n + 1; i++) {
int x = ara[i] - 1;
int y = 1000000 - ara[i];
if (x < y)
t1 = x;
else {
t2 = y;
break;
}
}
if (t1 > t2)
printf("%d\n", t1);
else
printf("%d\n", t2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, q, mn, ml, mr;
cin >> n;
vector<int> a(1000000);
ml = 0;
mr = 0;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) {
if (a[i] - 1 < 1000000 - a[i]) {
if (a[i] - 1 > ml) ml = a[i] - 1;
} else if (1000000 - a[i] > mr)
mr = 1000000 - a[i];
}
cout << max(ml, mr);
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
void seriy() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
signed main() {
seriy();
long long n;
cin >> n;
long long a;
long long maxd = 0;
for (long long i = 0; i < n; i++) {
cin >> a;
maxd = max(maxd, min(a - 1, 1000000 - a));
}
cout << maxd;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100005];
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + 1 + n);
for (int i = 1; i <= n; i++) {
if (a[1] > 500000) {
cout << 1000000 - a[1];
return 0;
}
if (a[i] > 500000) {
if (a[i - 1] - 1 > 1000000 - a[i])
cout << a[i - 1] - 1;
else
cout << 1000000 - a[i];
return 0;
}
}
cout << a[n] - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool In(T &a) {
return (bool)(cin >> a);
}
template <class T1, class T2>
inline bool In(T1 &a, T2 &b) {
return (bool)(cin >> a >> b);
}
template <class T1, class T2, class T3>
inline bool In(T1 &a, T2 &b, T3 &c) {
return (bool)(cin >> a >> b >> c);
}
template <class T1, class T2, class T3, class T4>
inline bool In(T1 &a, T2 &b, T3 &c, T4 &d) {
return (bool)(cin >> a >> b >> c >> d);
}
inline bool Line(string &a) { return (bool)(getline(cin, a)); }
template <class _T>
inline void ina(_T a[], int n) {
int i;
for (i = 0; i < n; i++) In(a[i]);
}
template <class T>
inline bool Pr(T a) {
return (bool)(cout << a);
}
template <class T1, class T2>
inline bool Pr(T1 a, T2 b) {
return (bool)(cout << a << " " << b);
}
template <class T1, class T2, class T3>
inline bool Pr(T1 a, T2 b, T3 c) {
return (bool)(cout << a << " " << b << " " << c);
}
template <class T1, class T2, class T3, class T4>
inline bool Pr(T1 a, T2 b, T3 c, T4 d) {
return (bool)(cout << a << " " << b << " " << c << " " << d);
}
template <class T>
inline void Cr(T a) {
cerr << a << endl;
}
template <class T1, class T2>
inline void Cr(T1 a, T2 b) {
cerr << a << " " << b << endl;
}
int TEST_CASE = 0;
template <class _T>
inline _T pow(_T a, _T b, _T m) {
a %= m;
_T ans = 1 % m;
while (b) {
if (b & 1) ans *= a, ans %= m;
a *= a;
a %= m;
b >>= 1;
}
return ans;
}
template <class _T>
inline _T pow(_T a, _T b) {
_T ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
b >>= 1;
}
return ans;
}
template <class _T>
inline _T add(_T a, _T b, _T m) {
return a >= m - b ? a - (m - b) : a + b;
}
template <class _T>
inline _T multiply(_T a, _T b, _T m) {
_T ans = 0;
if (b > a) swap(a, b);
while (b) {
if (b & 1) ans = add(ans, a, m);
b >>= 1;
a = add(a, a, m);
}
return ans;
}
template <class _T>
inline _T bigpow(_T a, _T b, _T m) {
a %= m;
_T ans = 1 % m;
while (b) {
if (b & 1) ans = multiply(ans, a, m);
a = multiply(a, a, m);
b >>= 1;
}
return ans;
}
template <class _T>
inline _T modinvers(_T a, _T m) {
return m > 2000000000LL ? bigpow(a, m - 2, m) : pow(a, m - 2, m);
}
template <class _T>
_T _egcd(_T a, _T b, _T &x, _T &y) {
if (!b) {
x = 1, y = 0;
return a;
}
_T _g = _egcd(b, a % b, x, y);
_T xt = x;
x = y, y = xt - (a / b) * y;
return _g;
}
template <class _T>
inline _T fmodinvers(_T a, _T m) {
_T x, y;
_egcd(a, m, x, y);
x %= m;
if (x < 0) x += m;
return x;
}
template <class _T>
inline _T _lcm(_T a, _T b) {
return (a * b) / __gcd(a, b);
}
template <class T>
inline T SQ(T a) {
return a * a;
}
long long SQRT(long long n) {
long long e = sqrt(n * 1.0);
long long l = max(0LL, e - 2), r = min(n, e + 2);
long long ans = 0;
while (l <= r) {
long long m = ((l + r) >> 1);
if (m * m <= n)
ans = m, l = m + 1;
else
r = m - 1;
}
return ans;
}
long long CBRT(long long n) {
long long e = cbrt(n * 1.0);
long long l = max(0LL, e - 2), r = min(n, e + 2);
long long ans = 0;
while (l <= r) {
long long m = ((l + r) >> 1);
if (m * m * m <= n)
ans = m, l = m + 1;
else
r = m - 1;
}
return ans;
}
const long double EPS = 1e-9;
const long double PI = acos(-1.0);
const int SIZE = 1e6;
long long mod = 1e9 + 7;
int a[100099];
int main() {
int n, m;
In(n);
ina(a, n);
sort(a, a + n);
m = 1e6 + 1;
m /= 2;
int *x = upper_bound(a, a + n, m) - 1;
int *y = x + 1;
int ans = x == a + n ? 0 : *x - 1;
ans = max(ans, y == a + n ? 0 : 1000000 - *y);
Pr(ans);
cout << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m = (1000000 + 1 >> 1), n, a[100005], ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] <= m)
ans = max(ans, a[i] - 1);
else
ans = max(ans, 1000000 - a[i]);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (~scanf("%d", &n)) {
int res, ans = 0;
int st = 1, ed = 1000000, x;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
res = min(x - st, ed - x);
ans = max(res, ans);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, time, a[100001];
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
time = min(1000000 - a[1], a[n] - 1);
for (int i = 1; i <= n; i++)
if (i != 1)
time = min(time, min(max(a[i - 1] - 1, 1000000 - a[i]),
max(a[i] - 1, 1000000 - a[i + 1])));
cout << time;
}
|
#include <bits/stdc++.h>
int main() {
int ans = 0;
int count;
scanf("%d", &count);
for (int i = 0; i < count; i++) {
int prize;
scanf("%d", &prize);
int minTimeToPrize = std::min(prize - 1, 1000000 - prize);
ans = std::max(ans, minTimeToPrize);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int ans = 0;
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
ans = max(ans, min(x - 1, 1000000 - x));
}
return printf("%d\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(int x, int y) { return x > y; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int ma = INT_MIN;
int mi = INT_MAX;
for (int i = 0; i < n; i++) {
if (a[i] <= 500000) {
ma = max(ma, a[i]);
}
}
for (int i = 0; i < n; i++) {
if (a[i] > 500000) {
mi = min(mi, a[i]);
}
}
int ans = 0;
if (ma != INT_MIN) {
ans += (ma - 1);
}
if (mi != INT_MAX) {
ans = max(ans, 1000000 - mi);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool priz[1000000];
signed main() {
long long n, x, time = 0;
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> x;
if (x <= 500000) {
if (x > time) time = x;
} else {
if (1000000 - x >= time) time = 1000000 - x + 1;
}
}
cout << time - 1;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXX = 1e5 + 10, inf = 1e6;
int n, a[MAXX], ans;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
(a[i] > inf / 2) ? (a[i] = inf - a[i]) : (a[i] -= 1);
ans = max(ans, a[i]);
}
return cout << ans << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int search(int arr[], int n) {
for (int i = 0; i < n; ++i) {
if (arr[i] > 500000) return i;
}
return -1;
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int t = search(a, n);
int ans;
if (t >= 0) {
if (t == 0)
ans = (1000000 - a[t]);
else
ans = max(1000000 - a[t], a[t - 1] - 1);
} else
ans = a[n - 1] - 1;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans = 0;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
int cur = min(x - 1, (int)1e6 - x);
ans = max(cur, ans);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, j, k, l, t, x, y;
x = 1;
y = 1e6;
scanf("%lld", &n);
long long int sum = 0;
for (i = 0; i < n; i++) {
scanf("%lld", &m);
j = m - x;
k = y - m;
sum = max(sum, min(j, k));
}
printf("%lld\n", sum);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000000;
int long long n, l, r, ll, rr, i, ans = 1e9, a[100005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
r = 1e6;
a[0] = 1;
a[n + 1] = r;
for (i = 1; i <= n; i++) {
cin >> a[i];
ans =
min(ans, min(max(a[i] - 1, r - a[i + 1]), max(a[i - 1] - 1, r - a[i])));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[100005];
int main() {
int n;
cin >> n;
arr[0] = 1;
for (int i = 1; i <= n; i++) cin >> arr[i];
arr[n + 1] = 1000000;
int ans = 999999;
for (int i = 0; i <= (n); i++) {
ans = min(ans, max(arr[i] - 1, 1000000 - arr[i + 1]));
}
cout << ans;
}
|
#include <bits/stdc++.h>
int main() {
int count;
scanf("%d", &count);
int lastPrize1 = 1;
int lastPrize2 = 1000000;
for (int i = 0; i < count; i++) {
int prize;
scanf("%d", &prize);
if (prize <= 500000) {
lastPrize1 = std::max(lastPrize1, prize);
} else {
lastPrize2 = std::min(lastPrize2, prize);
}
}
int maxTime = std::max(lastPrize1 - 1, 1000000 - lastPrize2);
printf("%d", maxTime);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pos[1000000 + 5];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &pos[i]);
int k = lower_bound(pos, pos + n, 500000) - pos;
if (k == n)
printf("%d\n", pos[n - 1] - 1);
else if (1000000 - pos[k] == 500000)
printf("499999\n");
else
printf("%d\n", max(pos[k - 1] - 1, 1000000 - pos[k]));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000006] = {}, b[1000006] = {}, c[1000006] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int i = 0, j = n - 1;
int q = 1, w = 1000000;
long long sec = 0;
for (int k = 0; k < n;) {
long long dis = (a[k] - q);
long long ss = (w - a[n - 1]);
if (dis < ss) {
sec += dis;
q = a[k];
w = w - dis;
k++;
} else if (ss < dis) {
sec += ss;
w = a[n - 1];
q = q + ss;
n--;
} else {
sec += ss;
w = a[n - 1];
q = a[k];
k++;
n--;
}
}
cout << sec << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
int a[100005];
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + n);
int time1 = 0, time2 = 1000000;
for (i = 1; i <= n; i++) {
if (a[i] <= 500000) {
time1 = a[i];
}
}
for (i = n; i >= 1; i--) {
if (a[i] > 500000) {
time2 = a[i];
}
}
time1 = time1 - 1;
time2 = 1000000 - time2;
printf("%d\n", max(time1, time2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans, ne;
ans = ne = 0;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
ne = min(t - 1, 1000000 - t);
ans = max(ans, ne);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")\n";
}
template <class T>
ostream &operator<<(ostream &os, set<T> V) {
os << "[";
for (auto vv : V) os << vv << ", ";
return os << "\b\b]\n";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
for (auto vv : V) os << vv << ' ';
return os << "\n";
}
template <class K, class X>
ostream &operator<<(ostream &os, map<K, X> V) {
os << "[";
for (auto vv : V) os << vv << ", ";
return os << "\b\b]\n";
}
long long int ceildiv(long long int n, long long int f) {
if (n % f) {
return n / f + 1;
} else
return n / f;
}
int main() {
int n;
cin >> n;
int pos;
int time = 0;
for (int i = 0; i < n; i++) {
cin >> pos;
int left = 1 + time, right = 1000000 - time;
if (pos > left && pos < right) time += min(pos - left, right - pos);
}
cout << time << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a, b;
long long time_a, time_b;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
if (x <= 5e5)
a.push_back(x);
else
b.push_back(x);
}
if (a.size() != 0) {
time_a = a.back() - 1;
}
if (b.size() != 0) {
time_b = 1e6 - b.front();
}
if (time_a > time_b)
cout << time_a;
else
cout << time_b;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a = 1, b = 1000000, max = 0, temp;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n; i++) {
if (arr[i] <= (b / 2))
temp = arr[i] - a;
else
temp = b - arr[i];
if (temp > max) max = temp;
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b = 1000000, c, min, n, ans = 1e9, arr[100005];
int main() {
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> arr[i];
}
if (n == 1) {
ans = (arr[1] - 1 < b - arr[1]) ? arr[1] - 1 : b - arr[1];
cout << ans;
return 0;
}
for (int i = 1; i < n; i++) {
a = (arr[i] - 1 > 1000000 - arr[i + 1]) ? arr[i] - 1 : 1000000 - arr[i + 1];
ans = (ans < a) ? ans : a;
}
ans = (ans < arr[n] - 1) ? ans : arr[n] - 1;
ans = (ans < b - arr[1]) ? ans : b - arr[1];
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[100005];
template <typename Malfurion>
void read(Malfurion &x) {
x = 0;
char ch = getchar();
while (!isdigit(ch)) {
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
}
void init() {
read(n);
for (register int i = 1; i <= n; i++) read(a[i]);
}
bool cmp(int cmp1, int cmp2) { return cmp1 < cmp2; }
int main() {
init();
sort(a + 1, a + 1 + n, cmp);
a[0] = 1;
a[n + 1] = 1000000;
int ans = INT_MAX, totr, totl;
for (register int i = 0; i <= n; i++) {
totl = a[i] - a[0];
totr = a[n + 1] - a[i + 1];
ans = min(ans, max(totr, totl));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int a[N];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, i, j, n, m, l, r;
cin >> n;
for (i = 0; i < n; i++) {
cin >> l;
a[l] = 1;
}
l = r = 0;
if (a[1] == 1) l++;
if (a[(int)1e6] == 1) l++;
for (i = 2, j = 1e6 - 1; i < j && l < n; i++, j--, r++) {
if (a[i] == 1) l++;
if (a[j] == 1) l++;
}
cout << r << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
void task_solver() {
long long n;
while (cin >> n) {
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long ans1 = 0, ans2 = 0;
long long right = 1e6, left = 1;
sort((a).begin(), (a).end());
for (long long i = 0; i < n; i++) {
if (a[i] <= 500000) {
ans1 = a[i];
left = a[i];
} else {
ans2 = max(1000000 - a[i], ans2);
right = a[i];
}
}
cout << max(ans1 - 1, ans2) << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
task_solver();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 0;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
long long a = abs(x - 1), b = abs(1000000 - x);
long long c = min(a, b);
ans = max(c, ans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void ggg() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int INF = 10e6;
const int N = 1e6;
int main() {
ggg();
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int ans = 0;
for (int i = 0; i < n; i++) {
a[i] = min(a[i] - 1, N - a[i]);
}
for (int i = 0; i < n; i++) {
if (a[i] > ans) ans = a[i];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const long long INF = 1e18;
const long long MOD = 1000000007;
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int &i : v) cin >> i;
int i = 0, j = n - 1;
int vc = 1, amigo = 1e6;
long long ans = 0;
while (i <= j) {
int dist1 = 0, dist2 = 0;
if (abs(vc - v[i]) <= abs(amigo - v[i]) &&
abs(amigo - v[j]) <= abs(vc - v[j])) {
dist1 = abs(vc - v[i]);
dist2 = abs(amigo - v[j]);
if (dist2 > dist1) {
ans += dist2;
amigo = v[j--];
while (abs(vc - v[i]) < dist2) {
i++;
}
vc = vc + dist2;
} else {
ans += dist1;
vc = v[i++];
while (abs(amigo - v[j] < dist1)) {
j--;
}
amigo = amigo - dist1;
}
} else if (abs(vc - v[j]) <= abs(amigo - v[j])) {
ans += abs(vc - v[j]);
break;
} else if (abs(amigo - v[i]) <= abs(vc - v[i])) {
ans += abs(amigo - v[i]);
break;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 1e9 + 5;
const long long LINF = LLONG_MAX;
int main() {
int n;
cin >> n;
int a[n];
int r1 = 0, r2 = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= 500000) {
r1 = max(r1, a[i] - 1);
}
if (a[i] > 500000) {
r2 = max(r2, 1000000 - a[i]);
}
}
cout << max(r1, r2) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxx = 0x3f3f3f3f;
int main() {
int n;
cin >> n;
vector<int> p(n);
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
p[i] = x;
}
int ans = maxx;
for (int i = 0; i < n + 1; ++i) {
int cur = 0;
if (i) cur = max(cur, p[i - 1] - 1);
if (i != n) cur = max(cur, 1000000 - p[i]);
ans = min(ans, cur);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e6;
int n, a, b;
int main() {
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) {
int in;
cin >> in;
if (in - 1 < INF - in)
a = max(a, in - 1);
else
b = max(b, INF - in);
}
cout << max(a, b) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n;
int a[N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int mid = (1 + (int)(1e6)) >> 1;
int t = 0;
int ans = 0;
for (int i = 1; i <= n; ++i) {
if (a[i] <= mid)
t = a[i];
else
break;
}
ans += t - 1;
t = 1e6;
for (int i = n; i >= 1; --i) {
if (a[i] > mid)
t = a[i];
else
break;
}
ans = max(ans, (int)(1e6) - t);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
deque<long long> dq;
for (long long i = 1; i <= n; i++) {
long long x;
cin >> x;
dq.push_back(x);
}
for (long long i = 1; i <= 2e6; i++) {
while ((long long)dq.size()) {
if (dq.front() - 1 <= i) {
dq.pop_front();
} else
break;
}
while ((long long)dq.size()) {
if (1e6 - dq.back() <= i) {
dq.pop_back();
} else
break;
}
if (dq.empty()) {
cout << i << '\n';
break;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int mid = ((int)pow(10, 6)) / 2;
int l = 1, r = 1000000;
for (int i = 0; i < n; i++) {
if (a[i] <= mid)
l = a[i];
else
break;
}
for (int i = n - 1; i >= 0; i--) {
if (a[i] > mid)
r = a[i];
else
break;
}
l -= 1;
r = 1000000 - r;
cout << max(l, r);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n;
cin >> n;
long long mid = 500000;
long long maxi = 0, mini = 0;
long long x;
for (long long i = 1; i <= n; ++i) {
cin >> x;
if (x <= mid)
maxi = x - 1;
else if (mini != 0)
continue;
else
mini = 1000000 - x;
}
cout << max(maxi, mini) << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
string ds = "RLDU";
long long int abm(long long int a, long long int b, long long int m) {
long long int ans = 1;
a = a % m;
while (b > 0) {
if (b & 1) ans = (ans * a) % m;
a = (a * a) % m;
b = b / 2;
}
return ans % m;
}
long long int ncr(long long int n, long long int r, long long int m) {
if (r == 0) return 1;
long long int fac[n + 5];
fac[0] = 1;
for (long long int i = 1; i < n + 1; i++) {
fac[i] = fac[i - 1] * i % m;
}
return (((fac[n] * abm(fac[r], m - 2, m)) % m) *
(abm(fac[n - r], m - 2, m))) %
m;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
long long int ans = 1e9;
for (long long int i = 0; i < n + 1; i++) {
long long int cur = 0;
if (i != 0) {
cur = max(cur, a[i - 1] - 1);
}
if (i != n) {
cur = max(cur, 1000000 - a[i]);
}
ans = min(ans, cur);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, idx = 0, ans = 0, ans1 = 0;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++) {
if (a[i] <= 500000) {
ans = a[i] - 1;
}
}
for (int i = n - 1; i >= 0; i--) {
if (a[i] > 500000) {
ans1 = 1000000 - a[i];
}
}
cout << max(ans, ans1);
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int maxl = 1, minr = 1e6;
for (int i = 0; i < n; i++) {
int t;
cin >> t;
if (t <= 5e5)
maxl = max(maxl, t);
else
minr = min(minr, t);
}
cout << max(maxl - 1, (int)1e6 - minr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int mid = 1000000 / 2;
int min_mid = INT_MAX, max_mid = INT_MIN;
int flag = 0, flag1 = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x > mid) {
flag = 1;
min_mid = min(min_mid, x);
} else if (x < min_mid) {
flag1 = 1;
max_mid = max(max_mid, x);
}
}
int time;
if (flag == 0) {
time = max_mid - 1;
} else if (flag1 == 0) {
time = (long long)1000000 - (long long)min_mid;
} else {
time = max((long long)1000000 - (long long)min_mid, (long long)max_mid - 1);
}
cout << time;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXINT = 2147483640;
const long long MAXLL = 9223372036854775800LL;
const long long MAXN = 423456;
const long long MOD = 1123456769;
using namespace std;
int a[MAXN];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
srand(time(0));
int n, i, ans = MAXINT;
cin >> n;
a[0] = 1;
for (i = 1; i <= n; i++) cin >> a[i];
a[n + 1] = 1000000;
for (i = 0; i <= n; i++) ans = min(ans, max(a[i] - 1, 1000000 - a[i + 1]));
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n;
int Max1, Max2;
int main(int argc, char const *argv[]) {
scanf("%d", &n);
int Pos;
for (int i = 1; i <= n; i++) {
scanf("%d", &Pos);
if (Pos <= 500000) {
Max1 = max(Max1, Pos - 1);
} else {
Max2 = max(Max2, 1000000 - Pos);
}
}
printf("%d\n", max(Max1, Max2));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') c = getchar(), f = -1;
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ '0');
return x * f;
}
inline long long readll() {
long long x;
char c;
int f = 1;
while ((c = getchar()) != '-' && (c > '9' || c < '0'))
;
if (c == '-') c = getchar(), f = -1;
x = c ^ '0';
while ((c = getchar()) >= '0' && c <= '9')
x = (x << 1ll) + (x << 3ll) + (c ^ '0');
return x * f;
}
int x = 1, y = 1e6, Mid = (x + y) >> 1;
int main() {
int n = read(), u = 0, v = 0;
for (register int i = 1, iend = n; i <= iend; ++i) {
int x = read();
if (x > Mid)
u = max(u, y - x);
else
v = max(v, x - 1);
}
printf("%d\n", max(u, v));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
int main() {
long long n;
cin >> n;
long long ans = 0;
while (n--) {
long long temp;
cin >> temp;
ans = max(ans, min(temp - 1, 1000000LL - temp));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[100001];
int main() {
int n, p(0);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> v[i];
if (v[i] <= 500000) {
p = i;
}
}
int x = v[p] - 1, y(0);
if (p < n - 1) {
y = 1000000 - v[p + 1];
}
if (v[p] > 500000) {
cout << 1000000 - v[p] << "\n";
return 0;
}
cout << max(x, y);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 7;
const long long inf = 1e9 + 7;
const long double eps = (long double)1e-12;
const double pi = 3.141592653;
const long long linf = 1e18 + 7;
const int logn = 20;
int n, a[maxn], tim, ans;
map<int, int> cnt;
int fir, sec;
int res;
int main() {
fir = 1;
sec = 1e6;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
cnt[a[i]] = 1;
res++;
}
while (fir <= sec) {
fir++;
sec--;
if (cnt[fir]) cnt[fir] = 0, res--;
if (cnt[sec]) cnt[sec] = 0, res--;
tim++;
if (!res) break;
}
cout << tim;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, k = 0, k1 = 1000000, v = 0;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a;
v = max(min(a - 1, 1000000 - a), v);
}
cout << v;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("O2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const double pi =
3.141592653589793238462643383279502884197169399375105820974944;
const double e = 2.71828182845904523536028747135266249775724709369995;
const long long mod = 1e9 + 7;
const long long inf = 2e18;
const long long ninf = -2e18;
const long long nax = 1e6;
long long power(long long x, long long y, long long mod) {
long long ans = 1;
x = x % mod;
while (y) {
if (y & 1) ans = (x * ans) % mod;
x = (x * x) % mod;
y >>= 1;
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int total = nax;
long long ans = min(a[n - 1] - 1, total - a[0]);
for (int i = 0; i < n - 1; i++) {
ans = min(ans, max(a[i] - 1, total - a[i + 1]));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
vector<long> myv;
int m = 1;
int temp_m = 1;
int f = 1000000;
int temp_f = 1000000;
long total_m = 0, total_f = 0;
for (int i = 0; i < n; ++i) {
if (abs(v[i] - m) < abs(v[i] - f)) {
myv.push_back(abs(v[i] - m));
} else {
myv.push_back(abs(v[i] - f));
}
}
cout << (*max_element(myv.begin(), myv.end()));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool way[1000009];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 1000009; i++) {
way[i] = false;
}
int n;
cin >> n;
int x;
for (int i = 0; i < n; i++) {
cin >> x;
way[x] = true;
}
long long int i;
for (i = 1; i <= 1000000 && n > 0; i++) {
if (way[i]) {
n--;
}
if (way[1000001 - i]) {
n--;
}
}
cout << i - 2 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
int ans = abs((int)1e6 - a[0]);
for (int i = 0; i + 1 < n; ++i) {
int cur = max(abs(a[i] - 1), abs((int)1e6 - a[i + 1]));
ans = min(cur, ans);
}
ans = min(ans, a[n - 1] - 1);
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int a[maxn];
int maxx = 1, minn = 1000000;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] <= 500000)
maxx = max(maxx, a[i]);
else
minn = min(minn, a[i]);
}
printf("%d", max(maxx - 1, 1000000 - minn));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int E = 1e6;
const int F = 1;
int n, a[E], ans;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) ans = max(ans, min(E - a[i], a[i] - F));
return cout << ans, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 5;
int n, a, b, x, ar[MX];
string str;
char stt[] = {'a', 'e', 'i', 'o', 'u', 'y'};
bool isvowel(char ch) {
int k;
for (k = 0; k < 6; k++)
if (stt[k] == ch) {
break;
}
if (k == 6) return 0;
return 1;
}
int main() {
while (cin >> n) {
for (int i = 0; i < n; i++) scanf("%d", &ar[i]);
if (n == 1) {
printf("%d\n", min(ar[0] - 1, 1000000 - ar[0]));
continue;
}
int ans = min(1000000 - ar[0], ar[n - 1] - 1);
for (int i = 0; i < n; i++) {
if (i + 1 < n) ans = min(ans, max(ar[i] - 1, 1000000 - ar[i + 1]));
if (i - 1 >= 0) ans = min(ans, max(ar[i - 1] - 1, 1000000 - ar[i]));
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
int main() {
int n;
scanf("%d", &n);
long long result = INF, last = 1LL;
for (int i = 0; i < n; ++i) {
long long x;
scanf("%lld", &x);
result = min(result, max((long long)1e6 - x, (long long)last - 1LL));
last = x;
}
printf("%lld", min(result, last - 1LL));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int sum = 0, tmp3, tmp = 0, tmp2 = 0, comb = 0;
vector<long long int> ans, check, arr;
vector<vector<int>> g;
vector<pair<char, char>> sol;
long long int n, m;
string s;
int a = 0, b = 0, c = 0;
int main() {
cin >> n;
int x, maxi = 0;
for (int i = 0; i < n; i++) {
cin >> x;
maxi = max(maxi, min(x - 1, 1000000 - x));
}
cout << maxi;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int ansa = 0;
int ansb = 0;
int a;
for (int i = 0; i < n; i++) {
scanf("%d", &a);
if (a <= 500000) {
ansa = ansa > (a - 1) ? ansa : (a - 1);
} else {
ansb = ansb > (1000000 - a) ? ansb : (1000000 - a);
}
}
printf("%d", ansa > ansb ? ansa : ansb);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e3 + 4;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, i, x, t = 1000000, l = 0;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
x = 0;
for (int i = 0; i < n; i++) {
x = min(a[i] - 1, t - a[i]);
l = max(l, x);
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, pas = 12312332;
int a[100002];
int main() {
cin >> n;
a[n + 1] = 1000000;
a[0] = 1;
for (int i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1);
for (int i = 0; i <= n; i++) {
pas = min(pas, max(a[i] - 1, 1000000 - a[i + 1]));
}
cout << pas;
cin >> n;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MAX = 1e9 + 7;
int main() {
int n;
cin >> n;
std::vector<int> v(n);
int count = n;
std::vector<long long> cnt(1e6 + 1, 0);
for (int i = 0; i < n; i++) {
cin >> v[i];
cnt[v[i]] = 1;
}
int a = 1, b = 1e6;
if (cnt[1] == 1) cnt[1] = 0;
if (cnt[b] == 1) cnt[b] = 0;
a++;
b--;
int res = 0;
while (count != 0) {
if (cnt[a] == 1) {
count--;
}
if (cnt[b] == 1) {
count--;
}
res++;
a++;
b--;
if (count == 0) break;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = ((int)2e5) + 5;
vector<int> adj[maxn];
vector<int> del[maxn];
int INDEX = 0;
bool onStack[maxn];
int index_[maxn], lowLink[maxn];
stack<int> stk;
vector<vector<int> > components;
void getConnectedComponent(int i);
void getConnectedComponent(int i) {
index_[i] = INDEX;
lowLink[i] = INDEX;
INDEX++;
stk.push(i);
onStack[i] = true;
for (int nxt : adj[i]) {
if (index_[nxt] == -1) {
getConnectedComponent(nxt);
lowLink[i] = min(lowLink[i], lowLink[nxt]);
} else if (onStack[nxt]) {
lowLink[i] = min(lowLink[i], index_[nxt]);
}
}
if (lowLink[i] == index_[i]) {
vector<int> comp;
int poped;
do {
poped = stk.top();
stk.pop();
onStack[poped] = false;
comp.push_back(poped);
} while (poped != i);
if (comp.size() > 0) {
components.push_back(comp);
}
}
}
void tarjan(int n) {
memset(onStack, false, sizeof(onStack));
fill(index_, index_ + n, -1);
for (int i = 0; i < n; i++) {
if (index_[i] == -1) {
getConnectedComponent(i);
}
}
}
int dfs(int curr, int par = -1) {
int mustDel = 0;
for (int nxt : del[curr]) {
if (nxt != par) {
mustDel += dfs(nxt, curr);
}
}
if (par == -1) {
if (mustDel & 1)
return 1;
else
return 0;
}
if (mustDel % 2 == 0) {
adj[par].push_back(curr);
return 1;
} else {
adj[curr].push_back(par);
return 0;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < n + 1; i++) {
int x;
cin >> x;
x--;
if (x == -1) continue;
del[x].push_back(i - 1);
del[i - 1].push_back(x);
}
if (dfs(0) == 1) {
cout << "NO";
} else {
cout << "YES\n";
tarjan(n);
reverse(components.begin(), components.end());
for (vector<int> comp : components) {
cout << comp[0] + 1 << endl;
}
tarjan(n);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200002;
bool dp[N];
vector<int> Ord;
bool ok = 1;
vector<int> gr[N];
void dfs(int u, int p) {
int deg = (int)gr[u].size() - 1;
int solved = 0;
for (const auto &v : gr[u]) {
if (v == p) continue;
dfs(v, u);
if (dp[v]) solved++;
}
if (!(solved & 1)) {
dp[u] = 1;
}
}
void dfs2(int u, int p) {
for (const auto &v : gr[u]) {
if (v == p) continue;
if (!dp[v]) {
dfs2(v, u);
}
}
Ord.push_back(u);
for (const auto &v : gr[u]) {
if (v == p) continue;
if (dp[v]) {
dfs2(v, u);
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
int p;
cin >> p;
if (!p) continue;
gr[i].push_back(p);
gr[p].push_back(i);
}
dfs(1, 0);
dfs2(1, 0);
if (dp[1]) {
cout << "YES\n";
for (const auto &i : Ord) {
cout << i << "\n";
}
} else {
cout << "NO\n";
}
return 0;
}
|
#include <bits/stdc++.h>
std::vector<int> node[262144];
int w[262144];
std::vector<int> sta;
void dfs1(int u) {
w[u] = 1;
for (auto v : node[u]) dfs1(v), w[u] += w[v];
}
void dfs2(int u) {
for (auto v : node[u])
if (!(w[v] & 1)) dfs2(v);
printf("%d\n", u);
for (auto v : node[u])
if (w[v] & 1) dfs2(v);
}
int main() {
int n, k, p;
scanf("%d", &n);
if (!(n & 1)) return puts("NO"), 0;
puts("YES");
for (int i = 1; i <= n; ++i) {
scanf("%d", &p);
if (p)
node[p].push_back(i);
else
k = i;
}
dfs1(k);
dfs2(k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> v[200000];
vector<long long> w;
long long f[200000];
stack<long long> s;
void dfs(long long x, long long p) {
for (auto y : v[x])
if (y != p) dfs(y, x);
if (f[x] % 2 == 0) {
w.push_back(x + 1), f[x] = 0;
for (auto y : v[x]) f[y]--;
} else
s.push(x + 1);
}
int main() {
long long n, i, x;
memset(f, 0, sizeof(f));
scanf("%lld", &n);
for (i = 0; i <= n - 1; i++) {
scanf("%lld", &x);
if (x != 0) x--, v[x].push_back(i), v[i].push_back(x), f[x]++, f[i]++;
}
dfs(0, -1);
if (f[0] % 2 == 1)
printf("NO\n");
else {
printf("YES\n");
for (auto x : w) printf("%lld\n", x);
while (!s.empty()) printf("%lld\n", s.top()), s.pop();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& out, const pair<A, B>& a) {
return out << "(" << a.first << ", " << a.second << ")";
}
template <class A>
ostream& operator<<(ostream& out, const vector<A>& a) {
out << "[";
for (auto it = a.begin(); it != a.end(); ++it) {
if (it != a.begin()) out << ", ";
out << *it;
}
return out << "]";
}
const int INF = 1e9;
const long long INF64 = 1e18;
const int MOD = 1e9 + 7;
const long double PI = acosl(-1.0);
const long double EPS = 1e-9;
mt19937 rnd(time(NULL));
mt19937_64 rnd64(time(NULL));
const int N = 200 * 1000 + 11;
int n;
int root;
int deg[N];
int dep[N];
bool used[N];
vector<int> g[N];
bool read() {
if (scanf("%d", &n) != 1) return false;
for (int i = 0; i < int(n); ++i) {
int p;
scanf("%d", &p);
--p;
if (p != -1) {
g[i].push_back(p);
g[p].push_back(i);
++deg[i];
++deg[p];
} else {
root = i;
}
}
return true;
}
void dfs(int v, int p, int curd) {
dep[v] = curd;
for (auto to : g[v])
if (to != p) dfs(to, v, curd + 1);
}
void solve() {
dfs(root, -1, 0);
set<pair<int, int> > cur;
for (int i = 0; i < int(n); ++i)
if (deg[i] % 2 == 0) cur.insert(make_pair(-dep[i], i));
vector<int> ans;
while (!cur.empty()) {
int v = cur.begin()->second;
used[v] = true;
cur.erase(cur.begin());
ans.push_back(v + 1);
for (auto to : g[v]) {
if (used[to]) continue;
--deg[to];
if (deg[to] & 1) {
cur.erase(make_pair(-dep[to], to));
} else {
cur.insert(make_pair(-dep[to], to));
}
}
}
if (int((ans).size()) != n)
puts("NO");
else {
puts("YES");
for (auto it : ans) printf("%d\n", it);
}
}
int main() {
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
while (read()) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 11;
int n, par[maxn], siz[maxn], deg[maxn], odd[maxn];
bool mark[maxn], seen[maxn];
vector<int> g[maxn];
vector<int> q;
void dfs(int u) {
siz[u] = 1;
bool ok = 1;
for (auto x : g[u]) {
if (x != par[u]) {
par[x] = u;
dfs(x);
siz[u] ^= siz[x];
if (siz[x]) odd[u]++;
ok &= siz[x] & 1;
}
}
deg[u] = (int)(g[u]).size() - (u != 0);
ok &= ((int)(g[u]).size() % 2 == 0);
if (ok) q.push_back(u);
}
void recheck(int u) {
int d = deg[u];
if (u && !mark[par[u]]) d++;
if (deg[u] == odd[u] && d % 2 == 0) q.push_back(u);
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
if (n % 2 == 0)
return cout << "NO" << endl, 0;
else
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cin >> par[i];
par[i]--;
if (par[i] == -1) continue;
g[par[i]].push_back(i);
g[i].push_back(par[i]);
}
memset(par, 0, sizeof par);
dfs(0);
q.reserve(maxn);
while (!q.empty()) {
int now = q.back();
q.pop_back();
if (mark[now]) continue;
mark[now] = 1;
cout << now + 1 << endl;
if (now) deg[par[now]]--;
for (auto x : g[now]) {
if (!mark[x]) {
recheck(x);
}
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
vector<int> g[N];
int du[N], fa[N];
bool vis[N];
queue<int> q;
void dfs(int r, int f) {
fa[r] = f;
for (int i = 0; i < g[r].size(); i++) {
int v = g[r][i];
if (v != f) dfs(v, r);
}
q.push(r);
}
vector<int> ans;
void del(int x) {
vis[x] = true;
ans.push_back(x);
for (int i = 0; i < g[x].size(); i++) {
int v = g[x][i];
if (!vis[v] && fa[x] != v) del(v);
}
}
int main() {
int n;
scanf("%d", &n);
int x;
memset(du, 0, sizeof(du));
memset(vis, false, sizeof(vis));
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x == 0) continue;
du[x] += 1;
du[i] += 1;
g[i].push_back(x);
g[x].push_back(i);
}
dfs(1, -1);
while (!q.empty()) {
int x = q.front();
q.pop();
if (du[x] % 2 == 0) {
del(x);
du[fa[x]] -= 1;
}
}
if (ans.size() != n)
printf("NO\n");
else {
printf("YES\n");
for (int i = 0; i < n; i++) printf("%d\n", ans[i]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p[200003], edge[200003], cnt[200003], level[200003];
vector<int> ve, g[200003];
bool sudah[200003], ya[200003], yy[200003];
void dfs(int now) {
ya[now] = true;
ve.push_back(now);
for (int i : g[now]) {
if (ya[i]) continue;
dfs(i);
}
}
void aa(int now) {
yy[now] = true;
for (int i : g[now]) {
if (yy[i]) continue;
level[i] = level[now] + 1;
aa(i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
g[p[i]].push_back(i);
if (p[i] == 0) continue;
edge[i]++;
edge[p[i]]++;
cnt[p[i]]++;
}
for (int i = 1; i <= n; i++) {
if (p[i] == 0) aa(i);
}
priority_queue<pair<int, int>> q;
for (int i = 1; i <= n; i++) {
if (!cnt[i]) {
q.push({level[i], i});
sudah[i] = true;
}
}
while (!q.empty()) {
auto now = q.top();
q.pop();
if (edge[now.second] % 2 == 0) {
if (!ya[now.second]) {
dfs(now.second);
edge[p[now.second]]--;
}
}
if (!sudah[p[now.second]] && p[now.second] != 0) {
q.push({level[p[now.second]], p[now.second]});
sudah[p[now.second]] = true;
}
}
if (ve.size() != n) {
cout << "NO\n";
return 0;
}
cout << "YES\n";
for (int i : ve) cout << i << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 9;
int n, tr[N], de[N], cnt, ans[N], eid, p[N];
struct edge {
int v, nxt;
} e[N << 1];
bool vis[N];
void add(int u, int v) {
eid++, de[v]++;
e[eid].v = v, e[eid].nxt = p[u], p[u] = eid;
}
void out(int u, int fa) {
ans[++cnt] = u;
int ccnt = cnt;
vis[u] = true;
for (int i = p[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v != fa && !vis[v]) out(v, u);
}
}
void dfs(int u, int fa) {
int child = 0;
for (int i = p[u]; i; i = e[i].nxt) {
int v = e[i].v;
if (v != fa) dfs(v, u), child += (!vis[v]);
}
if (de[u] % 2 == 0 && !vis[u]) out(u, fa), de[fa]--;
}
int main() {
scanf("%d", &n);
int now, x;
for (int i = (1); i <= (n); i++) {
scanf("%d", &x);
if (x == 0)
now = i;
else
add(i, x), add(x, i);
}
dfs(now, 0);
if (cnt != n)
printf("NO");
else {
printf("YES\n");
for (int i = (1); i <= (n); i++) printf("%d\n", ans[i]);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.