#include <bits/stdc++.h>
using namespace std;

#define V vector
#define pb push_back
#define fi first
#define se second
#define all0(x) (x).begin(), (x).end()
#define all1(x) (x).begin() + 1, (x).end()

typedef long long LL;
typedef pair<int, int> pi;

mt19937 mrand(chrono::steady_clock().now().time_since_epoch().count());

void solve() {
    int n;
    cin >> n;
    n++;
    V<int> uni_x(1), uni_y(1);
    V<int> x(n + 1), y(n + 1);
    for (int i = 2; i <= n; i++) cin >> x[i] >> y[i];
    for (int i = 1; i <= n; i++) {
        uni_x.pb(x[i]);
        uni_y.pb(y[i]);
    }
    sort(all1(uni_x));
    uni_x.erase(unique(all1(uni_x)), uni_x.end());
    sort(all1(uni_y));
    uni_y.erase(unique(all1(uni_y)), uni_y.end());
    for (int i = 1; i <= n; i++)
        x[i] = lower_bound(all1(uni_x), x[i]) - uni_x.begin();
    for (int i = 1; i <= n; i++)
        y[i] = lower_bound(all1(uni_y), y[i]) - uni_y.begin();
    int a = uni_x.size() - 1, b = uni_y.size() - 1;
    V<V<V<int>>> to(a + 1, V<V<int>>(b + 1, V<int>(n + 1, -1)));
    for (int i = 1; i <= a; i++) {
        for (int j = 1; j <= b; j++) {
            for (int k = n; k >= 1; k--) {
                if (x[k] < i || y[k] < j) {
                    continue;
                }
                to[i][j][k] = k;
                if (k != n)
                    to[i][j][k] = max(to[i][j][k], to[i][j][k + 1]);
            }
        }
    }
    const LL INFLL = 1e18;
    V<V<V<LL>>> dp(a + 1, V<V<LL>>(b + 1, V<LL>(n + 1, INFLL)));
    for (int task = n; task >= 1; task--) {
        for (int i = a; i >= 1; i--) {
            for (int j = b; j >= 1; j--) {
                if (x[task] == i && y[task] == j) {
                    dp[i][j][task] =
                        (task == to[i][j][task] ? 0 : dp[i][j][task + 1]);
                }
                if (i != a) {
                    int t = to[i + 1][j][task];
                    dp[i][j][task] = min(
                        dp[i][j][task],
                        dp[i + 1][j][task] +
                            (t == to[i][j][task] ? 0 : dp[i][j][t + 1]) +
                            uni_x[i + 1] - uni_x[i]);
                }
                if (j != b) {
                    int t = to[i][j + 1][task];
                    dp[i][j][task] = min(
                        dp[i][j][task],
                        dp[i][j + 1][task] +
                            (t == to[i][j][task] ? 0 : dp[i][j][t + 1]) +
                            uni_y[j + 1] - uni_y[j]);
                }
            }
        }
    }
    cout << dp[1][1][1] << "\n";
}
int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    solve();
}