What???

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <typeinfo>
#include <vector>
#include <climits>

#define INF -1
#define ASCII_START 97
#define SIZE 5

using namespace std;

class Cell {
    vector<string> summa, new_summa;

public:

    void mult(string &str, Cell &other) {
        for (auto &str2 : other.summa) {
            new_summa.push_back(str + str2);
        }
    }

    void commit(string &row) {
        for (auto it = new_summa.begin();it != new_summa.end();it++) {
            if ((*it).find(row) != string::npos) {
                new_summa.erase(it);
                it--;
            }
        }
        summa = new_summa, new_summa.clear();
    }

    bool empty() {
        return summa.size() == 0;
    }

    int get_most_short(int m[][SIZE], int size, string &path) {
        int len = INT_MAX;
        for (auto &str : summa) {
            int tmp = 0;
            char prev = path[0];
            string buff(&prev, 1);
            for (char &ch : str) {
                tmp += m[prev - ASCII_START][ch - ASCII_START];
                prev = ch;
                buff += ch;
            }
            tmp += m[prev - ASCII_START][path[0] - ASCII_START]; // cycled path
            if (tmp < len) len = tmp, path.assign(buff);
        }
        return len;
    }

    void operator += (const string str) {
        summa.push_back(str);
    }
};

void mult(string[][SIZE], Cell[][SIZE], bool=false);

int main(int argc, char** argv) {

    int m[][SIZE] = {{INF, 10, 5, 8, 1},
            {8, INF, 15, 2, 14},
            {5, 14, INF, 1, INF},
            {4, 16, 10, INF, 2},
            {1, 4, 1, 1, INF}};

    string v[SIZE][SIZE];
    Cell p[SIZE][SIZE];
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            char ch = m[i][j] > 0 ? ASCII_START + j : '0';
            v[i][j].assign(string(&ch, 1));
        }
    }

    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            for (int k = 0; k < SIZE; k++) {
                if (not (v[i][k].empty() or v[i][k].compare("0") == 0) and m[k][j] != INF and i != j) {
                    p[i][j] +=  v[i][k];
                }
            }
        }
    }

    for (int i = 3;i <= SIZE;i++) {
        if (i == SIZE) {            // Якщо остання матриця P
            mult(v, p, true); // то рахуємо діагоналі
        } else mult(v, p);
        for (int j = 0;j < SIZE;j++) {
            for (int k = 0;k < SIZE;k++) {
                char ch(ASCII_START + j);
                string str(&ch, 1);
                p[j][k].commit(str);
            }
        }
    }

    string path("a");
    int len = p[0][0].get_most_short(m, SIZE, path);
    cout << endl << endl << "Shortest path: " << (path += "a") << " Length: " << len << endl << endl;

    return 0;
}

void mult(string v[][SIZE], Cell p[][SIZE], bool calc_diag) {
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            for (int k = 0; k < SIZE; k++) {
                if (not (v[i][k].empty() or v[i][k].compare("0") == 0) and not p[k][j].empty() and (i !=  j or calc_diag)) {
                    p[i][j].mult(v[i][k], p[k][j]);
                }
            }
        }
    }
}