#define NDEBUG   // NDEBUG definita nella versione che consegno
#include <cassert>
#include <iostream>
#include <fstream>

using namespace std;

const int MAX_N = 1000000;
const int MAX_Y = 2;

int n;
int S[MAX_Y][MAX_N];
int cost[MAX_Y][MAX_N];
int pairings[MAX_N];

int min(int a, int b) {
    if (a <= b) {
        return a;
    } else {
        return b;
    }
}

int absdiff(int a, int b) {
    int result = a - b;
    if (result < 0) {
        result = result * (-1);
    }
    return result;
}

#ifndef NDEBUG
void printCost(int initial) {
    for (int i = 0; i < MAX_Y; ++i) {
        for (int j = initial; j < n; ++j) {
            cout << cost[i][j] << ' ';
        }
        cout << endl;
    }
    cout << endl << endl;
}
#endif

int main() {
#ifdef NDEBUG
    ifstream fin("input.txt"); assert( fin );
    ofstream fout("output.txt");
#else
    istream &fin(cin);
    ostream &fout(cout);
#endif

    fin >> n;
    for (int i = 0; i < MAX_Y; ++i) {
        for (int j = 0; j < n; ++j) {
            fin >> S[i][j];
        }
    }

    /*
     * In base alla forma della matrice posso notare quanto segue:
     * - le uniche due disposizioni possibili a ogni passo sono (a) prendo la
     *   colonna verticalmente + ricorsione sul resto e (b) prendo questa
     *   colonna e una adiacente con due "tessere di domino" orizzontali e
     *   faccio la ricorsione sul resto;
     * - il costo minimo con due colonne è il min tra il costo che si ha
     *   prendendo le due colonne in verticale o in orizzontale;
     * - per un numero di colonne > 2 devo vedere min(costo che si ha prendendo
     *   questa colonna singolarmente + tutte le altre, costo che si ha
     *   prendendo questa colonna accoppiata con la prossima + quelle rimanenti
     *   dopo).
     * Per i pairing di costo minimo, a ogni passo il costo non può che
     * aumentare, quindi numero pairing nuovi = pairing vecchi, a meno che
     * non ci siano più pairing a costo identico.
     */
    cost[0][n - 1] = absdiff(S[0][n - 1], S[1][n - 1]);
    cost[0][n - 2] = cost[0][n - 1] + absdiff(S[0][n - 2], S[1][n - 2]);
    cost[1][n - 2] = absdiff(S[0][n - 1], S[0][n - 2]) + absdiff(S[1][n - 1], S[1][n - 2]);
#ifndef NDEBUG
    printCost(n - 2);
#endif
    pairings[n - 1] = 1;
    pairings[n - 2] = (cost[0][n - 2] == cost[1][n - 2] ? 2 : 1);

    for (int r = n - 3; r >= 0; --r) {
        cost[0][r] = cost[1][r + 1] + absdiff(S[0][r], S[1][r]);
        cost[1][r] = absdiff(S[0][r + 1], S[0][r]) + absdiff(S[1][r + 1], S[1][r]) + cost[0][r + 2];
#ifndef NDEBUG
        printCost(r);
#endif
        pairings[r] = (cost[0][r] == cost[1][r] ? 2 : 1);
    }
    // Prendo il min tra i due cost[0,1][0] e ho il minimo
    fout << min(cost[0][0], cost[1][0]) << endl;
    fout << pairings[0] << endl;
    return 0;
}