#define _CRT_SECURE_NO_WARNINGS
# include <cstdio>
# include <iostream>
# include <cmath>
# include <algorithm>
# include <stdio.h>
# include <cstdint>
# include <cstring>
# include <string>
# include <cstdlib>
# include <vector>
# include <bitset>
# include <map>
# include <queue>
# include <ctime>
# include <stack>
# include <set>
# include <list>
# include <random>
# include <deque>
# include <functional>
# include <iomanip>
# include <sstream>
# include <fstream>
# include <complex>
# include <numeric>
# include <immintrin.h>
# include <cassert>
# include <array>
# include <tuple>
using namespace std;
/** Interface */
inline int readChar();
template <class T = int> inline T readInt();
template <class T> inline void writeInt(T x, char end = 0);
inline void writeChar(int x);
inline void writeWord(const char *s);
/** Read */
static const int buf_size = 4096;
inline int getChar() {
static char buf[buf_size];
static int len = 0, pos = 0;
if (pos == len)
pos = 0, len = fread(buf, 1, buf_size, stdin);
if (pos == len)
return -1;
return buf[pos++];
}
inline int readChar() {
int c = getChar();
while (c <= 32)
c = getChar();
return c;
}
template <class T>
inline T readInt() {
int s = 1, c = readChar();
T x = 0;
if (c == '-')
s = -1, c = getChar();
while ('0' <= c && c <= '9')
x = x * 10 + c - '0', c = getChar();
return s == 1 ? x : -x;
}
/** Write */
static int write_pos = 0;
static char write_buf[buf_size];
inline void writeChar(int x) {
if (write_pos == buf_size)
fwrite(write_buf, 1, buf_size, stdout), write_pos = 0;
write_buf[write_pos++] = x;
}
template <class T>
inline void writeInt(T x, char end) {
if (x < 0)
writeChar('-'), x = -x;
char s[24];
int n = 0;
while (x || !n)
s[n++] = '0' + x % 10, x /= 10;
while (n--)
writeChar(s[n]);
if (end)
writeChar(end);
}
inline void writeWord(const char *s) {
while (*s)
writeChar(*s++);
}
struct Flusher {
~Flusher() {
if (write_pos)
fwrite(write_buf, 1, write_pos, stdout), write_pos = 0;
}
} flusher;
inline void readWord(char *s) {
int c = readChar();
while (c > 32)
*s++ = c, c = getChar();
*s = 0;
}
inline void writeDouble(double x, int output_len) {
if (x < 0)
writeChar('-'), x = -x;
int t = (int)x;
writeInt(t), x -= t;
writeChar('.');
for (int i = output_len - 1; i > 0; i--) {
x *= 10;
t = min(9, (int)x);
writeChar('0' + t), x -= t;
}
x *= 10;
t = min(9, (int)(x + 0.5));
writeChar('0' + t);
}
// Begin fast allocation
//const int max_mem = 2e8;
//int mpos = 0;
//char mem[max_mem];
//inline void * operator new ( size_t n ) {
// mpos += n;
// return (void *)(mem + mpos - n);
//}
//inline void operator delete ( void * ) noexcept { } // must have!
// end fast allocation
//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("O3")
//#define __GLIBCXX_DEBUG
#define shandom_ruffle random_shuffle
#define sz(a) (int)((a).size())
#define all(a) a.begin(), a.end()
#define pb push_back
#define fi first
#define se second
#define mp make_pair
#define x() real()
#define y() imag()
//#define int ll
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
using ull = unsigned long long;
using pnt = complex<ld>;
istream& operator >> (istream& in, pnt& p) {
ld a, b;
in >> a >> b;
p = { a, b };
return in;
}
ld crs(pnt a, pnt b) {
return a.x() * b.y() - a.y() * b.x();
}
ld dot(pnt a, pnt b) {
return a.x() * b.x() + a.y() * b.y();
}
const int M = 998244353;
const int mod = (int)1e9 + 7;
const int inf = (int)1e9 + 100;
const ll inf64 = (ll)1e18L;
const int di[] = { 0, 1,-1, 0 };
const int dj[] = { 1, 0, 0,-1 };
const int SQ = 1000;
const int LG = 19;
const int nax = (int)1e5 + 100; // угадайка
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); cout.precision(10); cout << fixed;
//freopen("in.txt", "r", stdin);
int n;
cin >> n;
vi vx(2 * n), vy(2 * n);
for (int i = 0; i < 2 * n; i++) {
cin >> vx[i] >> vy[i];
}
sort(all(vx));
sort(all(vy));
ll ans = 0;
for (int i = 0; i < n; i++) {
ans += abs(vx[2 * i] - (i + 1));
ans += abs(vx[2 * i + 1] - (i + 1));
ans += abs(vy[2 * i] - (1 + (2 * i > n - 1)));
ans += abs(vy[2 * i + 1] - (1 + (2 * i + 1 > n - 1)));
}
cout << ans;
}
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
2 ms |
384 KB |
Output is correct |
| 2 |
Correct |
2 ms |
384 KB |
Output is correct |
| 3 |
Correct |
2 ms |
384 KB |
Output is correct |
| 4 |
Correct |
3 ms |
384 KB |
Output is correct |
| 5 |
Correct |
2 ms |
384 KB |
Output is correct |
| 6 |
Incorrect |
2 ms |
384 KB |
Output isn't correct |
| 7 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
2 ms |
384 KB |
Output is correct |
| 2 |
Correct |
2 ms |
384 KB |
Output is correct |
| 3 |
Correct |
2 ms |
384 KB |
Output is correct |
| 4 |
Correct |
3 ms |
384 KB |
Output is correct |
| 5 |
Correct |
2 ms |
384 KB |
Output is correct |
| 6 |
Incorrect |
2 ms |
384 KB |
Output isn't correct |
| 7 |
Halted |
0 ms |
0 KB |
- |
| # |
Verdict |
Execution time |
Memory |
Grader output |
| 1 |
Correct |
2 ms |
384 KB |
Output is correct |
| 2 |
Correct |
2 ms |
384 KB |
Output is correct |
| 3 |
Correct |
2 ms |
384 KB |
Output is correct |
| 4 |
Correct |
3 ms |
384 KB |
Output is correct |
| 5 |
Correct |
2 ms |
384 KB |
Output is correct |
| 6 |
Incorrect |
2 ms |
384 KB |
Output isn't correct |
| 7 |
Halted |
0 ms |
0 KB |
- |
