Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Problem Statement

You have just arrived in a small country. Unfortunately a huge hurricane swept across the country a few days ago.

The country is made up of $n$ islands, numbered $1$ through $n$. Many bridges connected the islands, but all the bridges were washed away by a flood. People in the islands need new bridges to travel among the islands again.

The problem is cost. The country is not very wealthy. The government has to keep spending down. They asked you, a great programmer, to calculate the minimum cost to rebuild bridges. Write a program to calculate it!

Each bridge connects two islands bidirectionally. Each island $i$ has two parameters $d_i$ and $p_i$. An island $i$ can have at most $d_i$ bridges connected. The cost to build a bridge between an island $i$ and another island $j$ is calculated by $|p_i - p_j|$. Note that it may be impossible to rebuild new bridges within given limitations although people need to travel between any pair of islands over (a sequence of) bridges.

Input

The input is a sequence of datasets.
The number of datasets is less than or equal to $60$.
Each dataset is formatted as follows.

$n$
$p_1$ $d_1$
$p_2$ $d_2$
:
:
$p_n$ $d_n$

Everything in the input is an integer.
$n$ ($2 \leq n \leq 4{,}000$) on the first line indicates the number of islands.
Then $n$ lines follow, which contain the parameters of the islands.
$p_i$ ($1 \leq p_i \leq 10^9$) and $d_i$ ($1 \leq d_i \leq n$) denote the parameters of the island $i$.

The end of the input is indicated by a line with a single zero.

Output

For each dataset, output the minimum cost in a line if it is possible to rebuild bridges within given limitations in the dataset. Otherwise, output $-1$ in a line.

Sample Input

4
1 1
8 2
9 1
14 2
4
181 4
815 4
634 4
370 4
4
52 1
40 1
81 2
73 1
10
330 1
665 3
260 1
287 2
196 3
243 1
815 1
287 3
330 1
473 4
0

Output for the Sample Input

18
634
-1
916

Solution in C++ (judge verdict: Time Limit Exceeded)

#include <bits/stdc++.h>
#define INF 1LL<<60
using namespace std;
typedef long long ll;
typedef pair<ll,int> P;

class segtree{
public:
	static const int N=1<<12;
	ll dp[1<<13];
	ll lazy[1<<13];
	segtree(){
		memset(dp,0,sizeof(dp));
		memset(lazy,0,sizeof(lazy));
	}

	void init(){
		memset(dp,0,sizeof(dp));
		memset(lazy,0,sizeof(lazy));
	}

	void lazy_eval(int k){
		dp[k]+=lazy[k];
		if(k<N-1){
			lazy[k*2+1]+=lazy[k];
			lazy[k*2+2]+=lazy[k];
		}
		lazy[k]=0;
	}

	void lazy_upd(int k){
		dp[k]=min(dp[k*2+1],dp[k*2+2]);
	}

	void update(int a,int b,ll v,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(b<=l || r<=a)return;
		if(a<=l && r<=b){
			lazy[k]+=v;
			lazy_eval(k);
			return;
		}
		int mid=(l+r)/2;
		update(a,b,v,k*2+1,l,mid);
		update(a,b,v,k*2+2,mid,r);
		lazy_upd(k);
	}

	ll query(int a,int b,int k=0,int l=0,int r=N){
		lazy_eval(k);
		if(b<=l || r<=a)return INF;
		if(a<=l && r<=b)return dp[k];
		int mid=(l+r)/2;
		ll vl=query(a,b,k*2+1,l,mid);
		ll vr=query(a,b,k*2+2,mid,r);
		lazy_upd(k);
		return min(vl,vr);
	}
};

ll labs(ll v){
	if(v<0LL)return -v;
	return v;
}

int n;
ll dp[4001][4001];
vector<ll> d1;
vector<P> vec;
segtree seg;

void solve(){
	d1.clear();
	vec.clear();
	ll sum=2;
	for(int i=0;i<n;i++){
		int p,d;
		scanf("%d%d",&p,&d);
		sum+=d-2;
		if(d==1){
			d1.push_back(p);
		}else{
			vec.push_back(P(p,d));
		}
	}
	sort(d1.begin(),d1.end());
	sort(vec.begin(),vec.end());
	if(sum<0){
		printf("-1\n");
		return;
	}
	if(vec.size()==0){
		printf("%lld\n",d1[1]-d1[0]);
	}
	for(int i=0;i<=d1.size();i++){
		dp[0][i]=INF;
	}
	dp[0][0]=0;
	for(int i=0;i<vec.size();i++){
		seg.init();
		for(int j=0;j<=d1.size();j++){
			seg.update(j,j+1,dp[i][j]);
		}
		int rest=vec[i].second-2;
		if(i==0 || i+1==vec.size()){
			rest++;
		}
		for(int j=0;j<=d1.size();j++){
			dp[i+1][j]=dp[i][j];
		}
		for(int j=0;j<d1.size();j++){
			seg.update(0,j+1,labs(d1[j]-vec[i].first));
			ll val=seg.query(max(0,j+1-rest),j+1);
			dp[i+1][j+1]=min(val,dp[i+1][j+1]);
		}
	}
	/*
	for(int i=0;i<=vec.size();i++){
		for(int j=0;j<=d1.size();j++){
			printf("%lld ",dp[i][j]);
		}
		printf("\n");
	}
	*/
	printf("%lld\n",dp[vec.size()][d1.size()]+vec[vec.size()-1].first-vec[0].first);
}

int main(void){
	while(1){
		scanf("%d",&n);
		if(n==0)break;
		solve();
	}
	return 0;
}