#include<cstdlib>
#include<cstdio>
#include<string>
#include<algorithm>
#include<vector>
#include<fstream>
#include<iostream>
#include<cmath>

using namespace std;

string input = "";
char includedCharacters[26];
char missingCharacters[26];
int default_left = 12;
int default_right = 16;
int num_characters = 0;
int num_missing_characters = 0;
int includedCharacterPositions[26];
int missingCharacterPositions[26];

int populationSize = 200;
int geneticIterations = 4000;
int mutation_rate = 100;
int dist_matr[26][26]={0};
int keyX[26]={85,123,161,199,237,275,313,351,389,427,95,133,171,209,247,285,324,362,400,122,160,198,236,275,313,351};
int keyY[26]={140,140,140,140,140,140,140,140,140,140,179,179,179,179,179,179,179,179,179,219,219,219,219,219,219,219};
int n;
int tournamentSize = 5;

int myRandom(int x) {
    return rand()%x;
}

int sqr(int a) {
    return a*a;
}

void calculate_dist() {
    for (int i=0;i<26;i++)
        for(int j=0;j<26;j++)
            dist_matr[i][j] = (int) sqrt(sqr(keyX[i]-keyX[j]) + sqr(keyY[i]-keyY[j]));
}

void initialize() {
    bool* used = new bool[128];
    for (int i='a';i<='z';i++)
        used[i] = false;

    for (int i=0;i<n;i++)
        used[input[i]] = true;

    for (char c='a';c<='z';c++)
        if(used[c])
            includedCharacters[num_characters++] = c;
        else
            missingCharacters[num_missing_characters++] = c;

    int row1,row2,row3;

    if (num_characters % 3 == 0)
        row1 = row2 = row3 = num_characters /3;
    else if (num_characters % 3 == 1) {
        row1 = num_characters / 3 + 1;
        row2 = row3 = num_characters / 3;
    }
    else {
        row1 = row2 = num_characters / 3 + 1;
        row3 = num_characters / 3;
    }

    if (row3>7) {
        row2+=row3-7;
        row3=7;
    }

    if (row2>9) {
        row1+=row2-9;
        row2=9;
    }

    int k=0;
    int j=0;

    for(int i=0;i<row1;i++)
        includedCharacterPositions[j++] = i;
    for(int i=10;i<10+row2;i++)
        includedCharacterPositions[j++] = i;
    for(int i=19;i<19+row3;i++)
        includedCharacterPositions[j++] = i;

    for(int i=row1;i<10;i++)
        missingCharacterPositions[k++] = i;
    for(int i=10+row2;i<19;i++)
        missingCharacterPositions[k++] = i;
    for(int i=19+row3;i<26;i++)
        missingCharacterPositions[k++] = i;

    default_left = 10 + row2/3;
    default_right = 10 + 2*(row2/3);

}

class Solution {
    public:
    char* keyboard;
    int left;
    int right;
    int result;
    bool result_calculated = false;


    Solution() {
        keyboard = new char[26];
        random_shuffle(includedCharacters, includedCharacters + num_characters, myRandom);

        for (int i=0;i<num_characters;i++)
            keyboard[includedCharacterPositions[i]] = includedCharacters[i];

        for (int i=0;i<num_missing_characters;i++)
            keyboard[missingCharacterPositions[i]] = missingCharacters[i];


        left=default_left;
        right=default_right;
    }

    Solution(char* keyboard, int left, int right) {
        this->keyboard = keyboard;
        this->left = left;
        this->right = right;
    }

    Solution(Solution* other) {
        left = other->left;
        right = other->right;
        keyboard = new char[26];
        for (int i=0;i<26;++i)
            keyboard[i] = other->keyboard[i];
    }

    ~Solution() {
        delete keyboard;
    }

    void mutate() {
        if (rand()%mutation_rate != 0)
            return;

        int pos1 = rand()%num_characters;
        int pos2 = rand()%num_characters;

        swap(keyboard[includedCharacterPositions[pos1]], keyboard[includedCharacterPositions[pos2]]);

        result_calculated = false;
    }

    int getResult() {
        if (result_calculated)
            return result;

        int* pos_map = new int[128];
        for (int i=0;i<26;i++)
            pos_map[keyboard[i]] = i;

        if (dist_matr[default_left][pos_map[input[0]]] < dist_matr[default_right][pos_map[input[0]]]) {
            left = pos_map[input[0]];
            right = default_right;
        }
        else {
            left = default_left;
            right = pos_map[input[0]];
        }

        int cur_left = left, cur_right = right;

        result = 0;

        for (int i=0;i<n;i++) {
            if(keyX[pos_map[input[i]]] <= keyX[cur_left]) {
                result += dist_matr[cur_left][pos_map[input[i]]];
                cur_left = pos_map[input[i]];
                continue;
            }
            if(keyX[pos_map[input[i]]] >= keyX[cur_right]) {
                result += dist_matr[cur_right][pos_map[input[i]]];
                cur_right = pos_map[input[i]];
                continue;
            }
            if(dist_matr[cur_left][pos_map[input[i]]] <= dist_matr[cur_left][pos_map[input[i]]]) {
                result += dist_matr[cur_left][pos_map[input[i]]];
                cur_left = pos_map[input[i]];
                continue;
            }
            result += dist_matr[cur_right][pos_map[input[i]]];
            cur_right = pos_map[input[i]];
            continue;
        }

        delete pos_map;

        result_calculated = true;
        return result;
    }
};


class Population {
    public:

    vector<Solution*> solutions;

    Population(bool initialize) {
        if (initialize) {
            for (int i=0;i<populationSize;i++)
                solutions.push_back(new Solution());
        }
    }

    void evolve() {
        vector<Solution*> newPopulation;

        newPopulation.push_back(new Solution(getFittest()));

        for(int i=1;i<populationSize;i++) {
            Solution* parent1 = tournamentSelection();
            Solution* parent2 = tournamentSelection();
            Solution* child = crossOver(parent1, parent2);
            child->mutate();
            newPopulation.push_back(child);
        }

        for(int i=0;i<populationSize;i++)
            delete (solutions[i]);

        solutions.clear();
        solutions = newPopulation;
    }

    Solution* crossOver(Solution* parent1, Solution* parent2) {
        int startPos = rand()%num_characters;
        int endPos = rand()%num_characters;
        if (startPos > endPos)
            swap(startPos, endPos);

        char* keyboard = new char[26];

        bool* used = new bool[128];
        for (int i='a';i<='z';i++)
            used[i] = false;

        for (int i=startPos;i<endPos;i++) {
            keyboard[includedCharacterPositions[i]] = parent1->keyboard[includedCharacterPositions[i]];
            used[keyboard[includedCharacterPositions[i]]] = true;
        }

        int k=0;

        for (int i=0;i<startPos;i++) {
            while(used[parent2->keyboard[includedCharacterPositions[k]]])
                ++k;
            keyboard[includedCharacterPositions[i]] = parent2->keyboard[includedCharacterPositions[k]];
            ++k;
        }

        for (int i=endPos;i<num_characters;i++) {
            while(used[parent2->keyboard[includedCharacterPositions[k]]])
                ++k;
            keyboard[includedCharacterPositions[i]] = parent2->keyboard[includedCharacterPositions[k]];
            ++k;
        }

        for (int i=0;i<num_missing_characters;i++)
            keyboard[missingCharacterPositions[i]] = missingCharacters[i];

        delete used;

        return new Solution(keyboard, default_left, default_right);
    }

    Solution* getFittest() {
        Solution* winner = solutions[0];
        for (int i=1;i<populationSize;++i) {
             Solution* next = solutions[i];
             if (next->getResult() < winner->getResult())
                winner = next;
        }

        return winner;
    }

    Solution* tournamentSelection() {
        Solution* winner = solutions[rand()%populationSize];
        for (int i=1;i<tournamentSize;++i) {
             Solution* next = solutions[rand()%populationSize];
             if (next->getResult() < winner->getResult())
                winner = next;
        }

        return winner;
    }

};


int main() {
    srand(42);
    calculate_dist();

    ifstream fin;
    fin.open("keyboard.in");
    fin >> n;
    fin >> input;
    fin.close();

    initialize();
    geneticIterations = 4000/max(1,n/50);

    Population* pop = new Population(true);
    for (int i=0;i<geneticIterations;i++)
        pop->evolve();

    Solution* solution = pop->getFittest();
    cout << solution->getResult();
    ofstream fout;
    fout.open("keyboard.out");
    for (int i=0;i<26;i++)
        fout << solution->keyboard[i];
    fout << endl << solution->left+1 << " " << solution->right+1;
    fout.close();

    return 0;
}