Problem:
コイン集め(Coin Collecting)
JOI 氏のコレクションルームには非常に大きな机があり，その上には何枚もの貴重なコインがある．机の掃除をするために，JOI 氏はコインを整理して並べることにした．
机は2 000 000 001 $\times$ 2 000 000 001 のマス目になっている．列には左から順に-1 000 000 000 から1 000 000 000までの番号がつけられており，行には下から順に-1 000 000 000 から1 000 000 000 までの番号がつけられている．列の番号が$x$，行の番号が$y$ であるマスを($x, y$) で表すことにする．
コインは$2N$ 枚あり，現在，$i$ 番目($1 \leq i \leq 2N$) のコインはマス($X_i, Y_i$) に置かれている．JOI 氏の目標は，$1 \leq x \leq N$ かつ$1 \leq y \leq 2$ を満たす($x, y$) で表される$2N$ 個のマスに，それぞれコインが1 枚ずつ置かれている状態にすることである．コインを傷つけないようにするため，「コインを1 枚選び，それが置かれているマスと辺で隣り合ったマスのいずれかに，そのコインを移動させる」という操作のみができる．途中，複数のコインが同じマスに置かれていてもよい．JOI 氏は，できるだけ少ない回数の操作で目標を達成したい．
コインの枚数と，現在コインが置かれているマスが与えられたとき，目標を達成するために必要な操作回数の最小値を求めるプログラムを作成せよ．
入力
入力は以下の形式で標準入力から与えられる．
$N$
$X_1$ $Y_1$
:
$X_{2N}$ $Y_{2N}$
出力
標準出力に，目標を達成するために必要な操作回数の最小値を1 行で出力せよ．
制約
$ 1 \leq N \leq 100 000$．
$ -1 000 000 000 \leq X_i \leq 1 000 000 000 (1 \leq i \leq 2N)$．
$ -1 000 000 000 \leq Y_i \leq 1 000 000 000 (1 \leq i \leq 2N)$．
入出力例
入力例1
3
0 0
0 4
4 0
2 1
2 5
-1 1
出力例1
15
この入力例では，6 個のコインが下図のように置かれている．太枠で示した位置にコインを集めるのが目標である．
例えば，コインを以下のように移動させると，15 回の操作で目標を達成できる：
1 番目のコイン：(0, 0) → (1, 0) → (1, 1) → (1, 2)
2 番目のコイン：(0, 4) → (1, 4) → (1, 3) → (2, 3) → (3, 3) → (3, 2)
3 番目のコイン：(4, 0) → (4, 1) → (3, 1)
5 番目のコイン：(2, 5) → (2, 4) → (2, 3) → (2, 2)
6 番目のコイン：(-1, 1) → (0, 1) → (1, 1)
14 回以下の操作で目標を達成することはできないので，15 を出力する．
入力例2
4
2 1
2 1
2 1
3 1
3 1
3 1
3 1
3 1
出力例2
9
同じマスに複数のコインが置かれているかもしれない．
入力例3
5
1000000000 1000000000
-1000000000 1000000000
-1000000000 -1000000000
1000000000 -1000000000
-1 -5
-2 2
2 8
4 7
-2 5
7 3
出力例3
8000000029
情報オリンピック日本委員会作 『第18 回日本情報オリンピック(JOI 2018/2019) 本選』

Submitted solutions:

code_snippet: #include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <cstdio>

typedef long long int ll;
using namespace std;

#define SIZE 100005

ll N;
ll table[3][SIZE];

int main() {
    scanf("%lld", &N);

    for (ll y = 1; y <= 2; y++) {
        fill(table[y] + 1, table[y] + N + 1, 0);
    }

    ll X, Y;
    ll ans = 0;

    for (ll i = 0; i < 2 * N; i++) {
        scanf("%lld %lld", &X, &Y);

        if (X < 1) { // 左側
            if (Y > 2) { // 上
                table[2][1]++;
                ans += abs(X - 1) + abs(Y - 2);
            } else if (Y < 1) { // 下
                table[1][1]++;
                ans += abs(X - 1) + abs(Y - 1);
            } else { // 範囲内
                table[Y][1]++;
                ans += abs(X - 1);
            }
        } else if (X > N) { // 右側
            if (Y > 2) { // 上
                table[2][N]++;
                ans += abs(X - N) + abs(Y - 2);
            } else if (Y < 1) { // 下
                table[1][N]++;
                ans += abs(X - N) + abs(Y - 1);
            } else { // 範囲内
                table[Y][N]++;
                ans += abs(X - N);
            }
        } else { // 範囲内
            if (Y > 2) { // 上
                table[2][X]++;
                ans += abs(Y - 2);
            } else if (Y < 1) { // 下
                table[1][X]++;
                ans += abs(Y - 1);
            } else { // 範囲内
                table[Y][X]++;
            }
        }
    }

    ll d1 = 0, d2 = 0;
    for (int x = 1; x <= N; x++) {
        d1 += table[1][x] - 1;
        d2 += table[2][x] - 1;
        if (d1 > 0 && d2 < 0) {
            ll tmp = min(d1, -d2);
            ans += tmp;
            d1 -= tmp;
            d2 += tmp;
        }
        if (d1 < 0 && d2 > 0) {
            ll tmp = min(-d1, d2);
            ans += tmp;
            d1 += tmp;
            d2 -= tmp;
        }
        ans += abs(d1) + abs(d2);
    }

    printf("%lld\n", ans);

    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 5132
final_rank: 3

code_snippet: #include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;



#define SIZE 100005

ll N;
ll table[3][SIZE];

int main(){

	scanf("%lld",&N);

	for(ll y = 1; y <= 2; y++){
		for(ll x = 1; x <= N; x++){

			table[y][x] = 0;
		}
	}

	ll X,Y;

	ll ans = 0;

	for(ll i = 0; i < 2*N; i++){

		scanf("%lld %lld",&X,&Y);

		if(X < 1){ //板の左側

			if(Y > 2){ //板より上

				table[2][1]++;
				ans += abs(X-1)+abs(Y-2);

			}else if(Y < 1){ //板より下

				table[1][1]++;
				ans += abs(X-1)+abs(Y-1);

			}else{ //板の範囲

				if(Y == 1){

					table[1][1]++;
					ans += abs(X-1);

				}else{ //Y==2

					table[2][1]++;
					ans += abs(X-1);
				}
			}

		}else if(X > N){ //板の右側

			if(Y > 2){ //板より上


				table[2][N]++;
				ans += abs(X-N)+abs(Y-2);

			}else if(Y < 1){ //板より下

				table[1][N]++;
				ans += abs(X-N)+abs(Y-1);

			}else{ //板の範囲

				if(Y == 1){

					table[1][N]++;
					ans += abs(X-N);

				}else{ //Y==2

					table[2][N]++;
					ans += abs(X-N);
				}
			}


		}else{ //板の範囲


			if(Y > 2){ //板より上


				table[2][X]++;
				ans += abs(Y-2);

			}else if(Y < 1){ //板より下

				table[1][X]++;
				ans += abs(Y-1);

			}else{ //板の範囲

				table[Y][X]++;
			}
		}
	}

	ll d1 = 0,d2 = 0;

	for(int x = 1; x <= N; x++){

		d1 += table[1][x]-1;
		d2 += table[2][x]-1;
		if(d1 > 0 && d2 < 0){

			int tmp = min(d1,-d2);
			ans += tmp;

			d1 -= tmp;
			d2 += tmp;
		}
		if(d1 < 0 && d2 > 0){

			int tmp = min(-d1,d2);
			ans += tmp;
			d1 += tmp;
			d2 -= tmp;
		}
		ans += abs(d1)+abs(d2);
	}

	printf("%lld\n",ans);

	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 4792
final_rank: 6

code_snippet: #include<bits/stdc++.h>
using namespace std;
using UL = unsigned int;
using ULL = unsigned long long;
using LL = long long;
#define rep(i,n) for(UL i=0; i<(n); i++)

UL N;
LL C[100001][2]={};
LL ans=0;

int main(){
 scanf("%u",&N);
 rep(i,N+N){
  int x,y; scanf("%d%d",&x,&y);
  if(x<1){ ans += 1-x; x=1; }
  if(x>N){ ans += x-N; x=N; }
  if(y<1){ ans += 1-y; y=1; }
  if(y>2){ ans += y-2; y=2; }
  C[x-1][y-1]++;
 }
 rep(x,N){
  C[x][0]--; C[x][1]--;
  if(C[x][0]<0 && C[x][1]>0){
   LL c=min(-C[x][0],C[x][1]);
   ans+=c;
   C[x][0]+=c; C[x][1]-=c;
  }
  if(C[x][0]>0 && C[x][1]<0){
   LL c=min(C[x][0],-C[x][1]);
   ans+=c;
   C[x][0]-=c; C[x][1]+=c;
  }
  rep(y,2){
   if(C[x][y]>0){
    LL c=C[x][y];
    ans+=c;
    C[x+1][y]+=c; C[x][y]-=c;
   }
   if(C[x][y]<0){
    LL c=-C[x][y];
    ans+=c;
    C[x+1][y]-=c; C[x][y]+=c;
   }
  }
 }
 printf("%lld\n",ans);
 return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4776
final_rank: 1

code_snippet: #include <bits/stdc++.h>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;

const int N = 100010;

int cnt[N][2];

void solve() {
    memset(cnt, 0, sizeof(cnt));
    ll ans = 0;
    int n;
    scanf("%d", &n);
    for (int rep = 0; rep < n * 2; ++rep) {
        int x, y;
        scanf("%d%d", &x, &y);
        if (y < 1) {
            ans += 1 - y;
            y = 1;
        }
        if (y > 2) {
            ans += y - 2;
            y = 2;
        }
        if (x < 1) {
            ans += 1 - x;
            x = 1;
        }
        if (x > n) {
            ans += x - n;
            x = n;
        }
        ++cnt[x][y - 1];
    }
    for (int i = 1; i <= n; ++i) {
#define A cnt[i][0]
#define B cnt[i][1]
        --A;
        --B;
        if (A > 0 && B > 0) {
            ans += A + B;
            cnt[i + 1][0] += A;
            cnt[i + 1][1] += B;
        } else if (A <= 0 && B <= 0) {
            ans -= A + B;
            cnt[i + 1][0] += A;
            cnt[i + 1][1] += B;
        } else if (A <= 0 && B > 0) {
            if (-A > B) {
                ans += B;
                A += B;
                ans += abs(A);
                cnt[i + 1][0] += A;
            } else {
                ans += -A;
                B += A;
                ans += abs(B);
                cnt[i + 1][1] += B;
            }
        } else if (A > 0 && B <= 0) {
            if (A > -B) {
                ans += -B;
                A += B;
                ans += abs(A);
                cnt[i + 1][0] += A;
            } else {
                ans += A;
                B += A;
                ans += abs(B);
                cnt[i + 1][1] += B;
            }
        }
    }
    printf("%lld\n", ans);
}

int main() {
    solve();
}
accuracy: 1
time_ms: 30
memory_kb: 4004
final_rank: 4

code_snippet: #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#pragma warning (disable: 4996)

long long N, X[1 << 18], Y[1 << 18], S[1 << 18], A[1 << 18][2], V1, V2;
long long FinalAns = 0;

int main() {
	scanf("%lld", &N);
	for (int i = 1; i <= 2 * N; i++) {
		scanf("%lld%lld", &X[i], &Y[i]);
		FinalAns += abs(X[i] - max(1LL, min(N, X[i])));
		FinalAns += abs(Y[i] - max(1LL, min(2LL, Y[i])));
		X[i] = max(1LL, min(N, X[i]));
		Y[i] = max(1LL, min(2LL, Y[i]));
		S[X[i]]++; A[X[i]][Y[i]]++;
	}
	for (int i = 1; i <= N; i++) S[i] += S[i - 1];
	for (int i = 2; i <= N; i++) FinalAns += abs(2LL * (i - 1LL) - S[i - 1]);

	long long D1 = 0, D2 = 0;
	for (int i = 1; i <= N; i++) {
		D1 += (A[i][1] - 1LL);
		D2 += (A[i][2] - 1LL);
		if (D1 > 0LL && 0LL > D2) {
			long long K = min(D1, -D2);
			D1 -= K; D2 += K;
			FinalAns += K;
		}
		if (D1 < 0LL && 0LL < D2) {
			long long K = min(-D1, D2);
			D1 += K; D2 -= K;
			FinalAns += K;
		}
	}
	cout << FinalAns << endl;
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 8716
final_rank: 8

code_snippet: #include<cstdio>
#include<vector>
#include<algorithm>
#include<cmath>
using namespace std;
typedef long long int ll;
static const int MAX_N = 100000;
static const ll INF = 1LL << 60;
struct Point{ll x, y;};

int N;
Point p[2 * MAX_N];

bool comp(const Point &a, const Point &b){
	return a.x == b.x ? a.y < b.y : a.x < b.x;
}

ll subtask1(){
	vector<ll> memo(1 << (2 * N), INF);
	memo[0] = 0;
	for(int i = 0; i < (1 << (2 * N)); i++){
		int cnt = 0;
		for(int j = 0; j < 2 * N; j++){
			if(i & (1 << j)) cnt++;
		}
		for(int j = 0; j < 2 * N; j++){
			if(!(i & (1 << j))){
				if(j < N) memo[i + (1 << j)] = min(memo[i + (1 << j)], memo[i] + abs(1 + j - p[cnt].x) + abs(1 - p[cnt].y));
				else memo[i + (1 << j)] = min(memo[i + (1 << j)], memo[i] + abs(1 + (j - N) - p[cnt].x) + abs(2 - p[cnt].y));
			}
		}
	}
	return memo[(1 << (2 * N)) - 1];
}

ll subtask2(){
	vector<vector<ll> > memo(N + 1, vector<ll>(N + 1, INF));
	sort(p, p + 2 * N, comp);
	memo[0][0] = 0;
	for(int i = 0; i <= N; i++){
		for(int j = 0; j <= N; j++){
			if(i + 1 <= N) memo[i + 1][j] = min(memo[i + 1][j], memo[i][j] + abs(1 + i - p[i + j].x) + abs(1 - p[i + j].y));
			if(j + 1 <= N) memo[i][j + 1] = min(memo[i][j + 1], memo[i][j] + abs(1 + j - p[i + j].x) + abs(2 - p[i + j].y));
		}
	}
	return memo[N][N];
}

ll subtask3(){
	ll ret = 0;
	int cnt = 0, cnt2 = 0;
	vector<int> num(N, 0);
	for(int i = 0; i < 2 * N; i++){
		if(p[i].x <= 1){
			ret += 1 - p[i].x;
			num[0]++;
		}else if(p[i].x >= N){
			ret += p[i].x - N;
			num[N - 1]++;
		}else{
			num[p[i].x - 1]++;
		}
		if(p[i].y <= 1){
			ret += 1 - p[i].y;
			cnt++;
		}else if(p[i].y >= 2){
			ret += p[i].y - 2;
			cnt2++;
		}
	}
	ret += abs(cnt - cnt2) / 2;
	sort(p, p + 2 * N, comp);
	int num2 = 0;
	for(int i = 0; i < N; i++){
		num2 += num[i];
		num2 -= 2;
		ret += abs(num2);
	}
	return ret;
}

int  main(){
	scanf("%d", &N);
	for(int i = 0; i < 2 * N; i++) scanf("%lld %lld", &p[i].x, &p[i].y);
	if(N <= 10) printf("%lld\n", subtask1());
	else if(N <= 1000) printf("%lld\n", subtask2());
	else printf("%lld\n", subtask3());
	return 0;
}
accuracy: 0.6509433962264151
time_ms: 70
memory_kb: 10572
final_rank: 9

code_snippet: #include <bits/stdc++.h>
 
//    #include <boost/multiprecision/cpp_int.hpp>
 #define int long long
 #define inf  1000000007
 #define pa pair<int,int>
 #define ll long long
 #define pal pair<double,double>
 #define ppap pair<pa,int>
  #define PI 3.14159265358979323846
  #define paa pair<int,char>
  #define  mp make_pair
  #define  pb push_back
  #define EPS (1e-8)
                                          
    int dx[8]={0,1,0,-1,1,1,-1,-1};
    int dy[8]={1,0,-1,0,-1,1,1,-1};
                                            using namespace std;
                                   			class pa3{
                                            	public:
                                            	int x;
                                   				int y,z;
                                            	pa3(int x=0,int y=0,int z=0):x(x),y(y),z(z) {}
                                            	bool operator < (const pa3 &p) const{
                                            		if(x!=p.x) return x<p.x;
                                            		if(y!=p.y) return y<p.y;
                                            		 return z<p.z;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                   				bool operator > (const pa3 &p) const{
                                            		if(x!=p.x) return x>p.x;
                                            		if(y!=p.y) return y>p.y;
                                            		 return z>p.z;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa3 &p) const{
                                            		return x==p.x && y==p.y && z==p.z;
                                            	}
                                            		bool operator != (const pa3 &p) const{
                                            			return !( x==p.x && y==p.y && z==p.z);
                                            	}
                                            
                                            };
                                            
                                            class pa4{
                                            	public:
                                            	int x;
                                            	int y,z,w;
                                            	pa4(int x=0,int y=0,int z=0,int w=0):x(x),y(y),z(z),w(w) {}
                                            	bool operator < (const pa4 &p) const{
                                            		if(x!=p.x) return x<p.x;
                                            		if(y!=p.y) return y<p.y;
                                            		if(z!=p.z)return z<p.z;
                                            		return w<p.w;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator > (const pa4 &p) const{
                                            		if(x!=p.x) return x>p.x;
                                            		if(y!=p.y) return y>p.y;
                                            		if(z!=p.z)return z>p.z;
                                            		return w>p.w;
                                            		//return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa4 &p) const{
                                            		return x==p.x && y==p.y && z==p.z &&w==p.w;
                                            	}
                                            		
                                            
                                            };
                                            class pa2{
                                            	public:
                                            	int x,y;
                                            	pa2(int x=0,int y=0):x(x),y(y) {}
                                            	pa2 operator + (pa2 p) {return pa2(x+p.x,y+p.y);}
                                            	pa2 operator - (pa2 p) {return pa2(x-p.x,y-p.y);}
                                            	bool operator < (const pa2 &p) const{
                                            		return y != p.y ? y<p.y: x<p.x;
                                            	}
                                            	bool operator > (const pa2 &p) const{
                                            		return x != p.x ? x<p.x: y<p.y;
                                            	}
                                            	bool operator == (const pa2 &p) const{
                                            		return abs(x-p.x)==0 && abs(y-p.y)==0;
                                            	}
                                            	bool operator != (const pa2 &p) const{
                                            		return !(abs(x-p.x)==0 && abs(y-p.y)==0);
                                            	}
                                            		
                                            
                                            };
                                            
 
                      
                                string itos( int i ) {
                                ostringstream s ;
                                s << i ;
                                return s.str() ;
                                }
                                 
                                int gcd(int v,int b){
                                	if(v==0) return b;
                                	if(b==0) return v;
                                	if(v>b) return gcd(b,v);
                                	if(v==b) return b;
                                	if(b%v==0) return v;
                                	return gcd(v,b%v);
                                }
                 
                            
                                int mod;
int extgcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = extgcd(b, a%b, y, x);
    y -= a/b * x;
    return d;
}
pa operator+(const pa & l,const pa & r) {   
    return {l.first+r.first,l.second+r.second};                                    
}    
pa operator-(const pa & l,const pa & r) {   
    return {l.first-r.first,l.second-r.second};                                    
}  
                                
                int pr[10000100];
                int inv[10000010];
                
                int beki(int wa,int rr,int warukazu){
                	if(rr==0) return 1%warukazu;
                	if(rr==1) return wa%warukazu;
                	wa%=warukazu;
                	if(rr%2==1) return ((ll)beki(wa,rr-1,warukazu)*(ll)wa)%warukazu;
                	ll zx=beki(wa,rr/2,warukazu);
                	return (zx*zx)%warukazu;
                }
 
                
    			int comb(int nn,int rr){
    				if(rr<0 || rr>nn || nn<0) return 0;
    				int r=pr[nn]*inv[rr];
    				r%=mod;
    				r*=inv[nn-rr];
    				r%=mod;
    				return r;
    			}
               
                void gya(int ert){
                	pr[0]=1;
                	for(int i=1;i<=ert;i++){
                		pr[i]=(pr[i-1]*i)%mod;
                	}
                		inv[ert]=beki(pr[ert],mod-2,mod);
                	for(int i=ert-1;i>=0;i--){
                		inv[i]=inv[i+1]*(i+1)%mod;
                	}
                }
                
              //   cin.tie(0);
    		//	ios::sync_with_stdio(false);
    			//priority_queue<pa3,vector<pa3>,greater<pa3>> pq;            
                 //sort(ve.begin(),ve.end(),greater<int>());
 //   mt19937(clock_per_sec);
  //  mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count()) ;
      

int memo[200020][2]={};

signed main(){
	
	
   cin.tie(0);
	ios::sync_with_stdio(false);
	
	int n;
	cin>>n;
	int ans=0;
	vector<pa>ve(n);
	
	for(int i=0;i<2*n;i++){
		int x,y;
		cin>>x>>y;
		if(x<=0){
			ans+=1-x;
			x=1;
		}
		if(x>n){
			ans+=x-n;
			x=n;
		}
		if(y<=0){
			ans+=1-y;
			y=1;
		}
		if(y>2){
			ans+=y-2;
			y=2;
		}
		memo[x][y]++;
	//	cout<<x<<" "<<y<<endl;
	}
	//cout<<ans<<endl;
	int X=0,Y=0;
	for(int i=1;i<=n;i++){
	
		ans+=abs(X)+abs(Y);
		X+=memo[i][1];
		Y+=memo[i][2];
		X--,Y--;
	//	cout<<X<<" "<<Y<<endl;
		if(X>0 && Y<0){
			int T=min(X,-Y);
			ans+=T;
			X-=T;
			Y+=T;
		}
		if(Y>0 && X<0){
			int T=min(-X,Y);
			ans+=T;
			X+=T;
			Y-=T;	
		}
	}
cout<<ans<<endl;
	
	return 0;
	

 
 }
accuracy: 1
time_ms: 20
memory_kb: 6016
final_rank: 7

code_snippet: #include<bits/stdc++.h>
#define maxn 100005
#define int long long
using namespace std;
int cnt[maxn][2];
int32_t main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	int n;
	cin >> n;
	
	int ans = 0;
	for(int i=1;i<=2*n;i++) {
		int x,y;
		cin >> x >> y;

		int nx = x;
		if(x<1)
			ans += 1-x , nx = 1;
		else if(x>n)
			ans += x-n , nx = n;
		
		int ny = y-1;
		if(y<1)
			ans += 1-y , ny = 0;
		else if(y>2)
			ans += y-2 , ny = 1;
			
		cnt[nx][ny] ++;
	}
	
	for(int i=1;i<=n;i++) {
		int y[] = {0,1};
		if(cnt[i][0] < cnt[i][1])	swap(y[0],y[1]);
		int need = 1 - cnt[i][y[0]];
		ans += abs(need);
		if(-need > 0 && cnt[i][y[1]] < 1) {
			int tem = min(-need,1-cnt[i][y[1]]);
			need += tem;
			cnt[i][y[1]] += tem;
		}
		cnt[i+1][y[0]] -= need;
		
		need = 1 - cnt[i][y[1]];
		ans += abs(need);
		cnt[i+1][y[1]] -= need;
	}
	
	cout << ans << endl;
	return 0;
}
accuracy: 1
time_ms: 30
memory_kb: 4764
final_rank: 5

code_snippet: #include <bits/stdc++.h>
#define err(args...) {}
#ifdef DEBUG
#include "_debug.cpp"
#endif
using namespace std;
using ll = long long;
int clamp(int x, int lb, int ub) {
    return max(lb, min(x, ub));
}
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<vector<int>> need(2, vector<int>(n, 1));
    vector<vector<int>> have(2, vector<int>(n));
    ll ans = 0;
    for(int i = 0; i < 2 * n; i++) {
        int x, y;
        cin >> x >> y;
        int nx = clamp(x, 1, n);
        int ny = clamp(y, 1, 2);
        ans += abs(x - nx) + abs(y - ny);
        have[ny - 1][nx - 1]++;
    }
    for(int x = 0; x < n; x++) {
        if(have[0][x] < need[0][x] and have[1][x] > need[1][x]) {
            int transfer = min(need[0][x] - have[0][x], have[1][x] - need[1][x]);
            ans += transfer;
            have[1][x] -= transfer;
            have[0][x] += transfer;
        }
        if(have[0][x] > need[0][x] and have[1][x] < need[1][x]) {
            int transfer = min(have[0][x] - need[0][x], need[1][x] - have[1][x]);
            ans += transfer;
            have[0][x] -= transfer;
            have[1][x] += transfer;
        }
        if(x < n - 1) {
            for(int y : {0, 1}) {
                if(have[y][x] < need[y][x]) {
                    ans += need[y][x] - have[y][x];
                    need[y][x + 1] += need[y][x] - have[y][x];
                }
                if(have[y][x] > need[y][x]) {
                    ans += have[y][x] - need[y][x];
                    have[y][x + 1] += have[y][x] - need[y][x];
                }
            }
        }
    }
    cout << ans << endl;
    return 0;
}
accuracy: 1
time_ms: 20
memory_kb: 4880
final_rank: 2

code_snippet: #include <bits/stdc++.h>
#define err(args...) {}
#ifdef DEBUG
#include "_debug.cpp"
#endif
using namespace std;
using ll = long long;
const int N = 1'000;
ll mem[N+1][N+1];
int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<pair<int, int>> coin(2 * n);
    for(int i = 0; i < 2 * n; i++) {
        int x, y;
        cin >> x >> y;
        coin[i] = {x, y};
    }
    sort(coin.begin(), coin.end());
    auto d = [&](int i, int x, int y) {
        ll dx = coin[i].first - (x + 1);
        ll dy = coin[i].second - y;
        return abs(dx) + abs(dy);
    };
    function<ll(int, int)> opt = [&](int x_top, int x_bot) {
        ll& ans = mem[x_top][x_bot];
        if(ans == -1) {
            int i = x_top + x_bot;
            if(i == 2 * n) {
                ans = 0;
            } else if(x_top < n and x_bot < n) {
                ans = min(d(i, x_top, 2) + opt(x_top + 1, x_bot),
                          d(i, x_bot, 1) + opt(x_top, x_bot + 1));
            } else if(x_top < n) {
                ans = d(i, x_top, 2) + opt(x_top + 1, x_bot);
            } else { // x_bot < n
                ans = d(i, x_bot, 1) + opt(x_top, x_bot + 1);
            }
        }
        return ans;
    };
    memset(mem, -1, sizeof mem);
    cout << opt(0, 0) << endl;
    return 0;
}
accuracy: 0.6320754716981132
time_ms: 10
memory_kb: 11248
final_rank: 10