#include <fstream>
#include <algorithm>

using namespace std;

ifstream fin("wanted.in");
ofstream fout("wanted.out");

#define MAXN 200

int dp[MAXN + 1][MAXN + 1][2];

struct myc {
    int x, y;
    inline bool operator < (const myc &u) const {
        return x < u.x;
    }
} v[MAXN + 1];

inline int drum(int i, int j, int p, int k) {
    if (p == 0) return v[k].x - v[i].x;
    else return v[j].x - v[k].x;
}

int main() {
    int n;
    fin >> n;

    for (int i = 1; i <= n; i++)
        fin >> v[i].x >> v[i].y;

    sort(v + 1, v + n + 1);

    for (int i = n; i > 0; i--) {
        dp[i][i][0] = dp[i][i][1] = v[i].y;
        for (int j = i + 1; j <= n; j++) {
            for (int p = 0; p < 2; p++) {
                dp[i][j][p] = min(drum(i, j, p, i) + 2 * v[i].y + v[i + 1].x - v[i].x + dp[i + 1][j][0],
                                  drum(i, j, p, j) + 2 * v[j].y + v[j].x - v[j - 1].x + dp[i][j - 1][1]);
                for (int k = i + 1; k < j; k++)
                    dp[i][j][p] = min(dp[i][j][p],
                                      drum(i, j, p, k) + 2 * v[k].y + max(v[k + 1].x - v[k].x + dp[k + 1][j][0], v[k].x - v[k - 1].x + dp[i][k - 1][1]));
            }
        }
    }

    int ans;
    if (n == 1) ans = v[1].y + abs(v[1].x);
    else {
        ans = min(abs(v[1].x) + 2 * v[1].y + v[2].x - v[1].x + dp[2][n][0],
                  abs(v[n].x) + 2 * v[n].y + v[n].x - v[n - 1].x + dp[1][n - 1][1]);
        for (int i = 2; i < n; i++)
            ans = min(ans, abs(v[i].x) + 2 * v[i].y + max(v[i + 1].x - v[i].x + dp[i + 1][n][0], v[i].x - v[i - 1].x + dp[1][i - 1][1]));
    }
    fout << ans;

    return 0;
}