mainwindow.cpp

#include "mainwindow.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QHeaderView>
#include <QDebug>
#include <QButtonGroup>
#include <QMessageBox>
#include <QLabel>
#include <QMenu>
#include <QComboBox>
#include <QStackedWidget>
#include <QTextEdit>
#include <QGroupBox>
#include <QFormLayout>
#include <QInputDialog>
#include <QDialogButtonBox>
#include <set>
#include <QFileDialog>
#include <QTextStream>

MainWindow::MainWindow(QWidget* parent) : QMainWindow(parent) {
    setupUI();


    if (directedRadio->isChecked()) {
        currentGraph = new DirectedGraph(vertexCountSpinBox->value());
        currentGraphType = DIRECTED;

        if (negativeRadio->isChecked()){
            currentGraphWeights = true;
        }

    } else {
        currentGraph = new UndirectedGraph(vertexCountSpinBox->value());
        currentGraphType = UNDIRECTED;

        if (negativeRadio->isChecked()){
            currentGraphWeights = true;
        }
    }

    currentGraph->generateGraph(currentGraphWeights);
    graphWidget->setGraph(currentGraph);
    updateMatrices();
}

MainWindow::~MainWindow() {
    delete currentGraph;
}

void MainWindow::setupUI() {

    QWidget *centralWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(centralWidget);
    mainLayout->setContentsMargins(5, 5, 5, 5);
    setCentralWidget(centralWidget);


    setupControlPanel(mainLayout);


    setupMainWorkspace(mainLayout);
}

void MainWindow::setupControlPanel(QVBoxLayout* mainLayout) {

    QHBoxLayout* graphSettingsLayout = new QHBoxLayout();


    vertexCountSpinBox = new QSpinBox(this);
    vertexCountSpinBox->setRange(2, 20);
    vertexCountSpinBox->setValue(8);
    graphSettingsLayout->addWidget(new QLabel("Вершин:"));
    graphSettingsLayout->addWidget(vertexCountSpinBox);


    updateButton = new QPushButton("Обновить граф", this);
    connect(updateButton, &QPushButton::clicked, this, [this]() {
        GraphType newType = directedRadio->isChecked() ? DIRECTED : UNDIRECTED;
        updateGraphType(newType);
    });
    graphSettingsLayout->addWidget(updateButton);


    QButtonGroup* graphTypeGroup = new QButtonGroup(this);
    undirectedRadio = new QRadioButton("Неориентированный", this);
    directedRadio = new QRadioButton("Ориентированный", this);
    directedRadio->setChecked(true);
    graphTypeGroup->addButton(undirectedRadio);
    graphTypeGroup->addButton(directedRadio);
    graphSettingsLayout->addWidget(undirectedRadio);
    graphSettingsLayout->addWidget(directedRadio);


    QButtonGroup* weightTypeGroup = new QButtonGroup(this);
    positiveRadio = new QRadioButton("Положительные", this);
    negativeRadio = new QRadioButton("Отрицательные", this);
    positiveRadio->setChecked(true);
    weightTypeGroup->addButton(positiveRadio);
    weightTypeGroup->addButton(negativeRadio);
    graphSettingsLayout->addWidget(positiveRadio);
    graphSettingsLayout->addWidget(negativeRadio);


    startVertexSpinBox = new QSpinBox(this);
    startVertexSpinBox->setRange(0, vertexCountSpinBox->value() - 1);
    startVertexSpinBox->setValue(0);
    graphSettingsLayout->addWidget(new QLabel("Нач. вершина:"));
    graphSettingsLayout->addWidget(startVertexSpinBox);


    QHBoxLayout* algorithmLayout = new QHBoxLayout();


    QPushButton* traversalButton = new QPushButton("Обход графа", this);
    connect(traversalButton, &QPushButton::clicked, this, [this]() {
        showTraversalResults(startVertexSpinBox->value());
    });
    algorithmLayout->addWidget(traversalButton);


    QPushButton* shimbelButton = new QPushButton("Шимбелл", this);
    connect(shimbelButton, &QPushButton::clicked, this, &MainWindow::fillShimbel);
    algorithmLayout->addWidget(shimbelButton);


    QPushButton* pathsButton = new QPushButton("Маршруты", this);
    connect(pathsButton, &QPushButton::clicked, this, &MainWindow::findPathsBetweenVertices);
    algorithmLayout->addWidget(pathsButton);


    QPushButton* bellmanButton = new QPushButton("Беллман-Форд", this);
    connect(bellmanButton, &QPushButton::clicked, this, &MainWindow::findShortestPath);
    algorithmLayout->addWidget(bellmanButton);


    QPushButton*maxFlowButton = new QPushButton("Макс. поток", this);
    connect(maxFlowButton, &QPushButton::clicked, this, &MainWindow::findMaxFlow);
    algorithmLayout->addWidget(maxFlowButton);

    QPushButton* minCostFlowButton = new QPushButton("Поток мин. стоимости", this);
    connect(minCostFlowButton, &QPushButton::clicked, this, &MainWindow::findMinCostFlow);
    algorithmLayout->addWidget(minCostFlowButton);


    QHBoxLayout* algorithmLayout2 = new QHBoxLayout();

    QPushButton* spanningTreeButton = new QPushButton("Число остовов", this);
    connect(spanningTreeButton, &QPushButton::clicked, this, &MainWindow::countSpanningTrees);
    algorithmLayout2->addWidget(spanningTreeButton);

    QPushButton* mstButton = new QPushButton("MST (Краскал)", this);
    connect(mstButton, &QPushButton::clicked, this, &MainWindow::findMST);
    algorithmLayout2->addWidget(mstButton);

    QPushButton* pruferButton = new QPushButton("Код Прюфера", this);
    connect(pruferButton, &QPushButton::clicked, this, &MainWindow::runPrufer);
    algorithmLayout2->addWidget(pruferButton);

    QPushButton* coloringButton = new QPushButton("Раскраска", this);
    connect(coloringButton, &QPushButton::clicked, this, &MainWindow::runColoring);
    algorithmLayout2->addWidget(coloringButton);

    QPushButton* eulerButton = new QPushButton("Эйлер", this);
    connect(eulerButton, &QPushButton::clicked, this, &MainWindow::processEulerActions);
    algorithmLayout2->addWidget(eulerButton);

    revertEulerButton = new QPushButton("Отменить Эйлер", this);
    connect(revertEulerButton, &QPushButton::clicked, this, &MainWindow::revertEulerChanges);
    revertEulerButton->setEnabled(false);
    algorithmLayout2->addWidget(revertEulerButton);

    QPushButton* hamiltonButton = new QPushButton("Гамильтон/TSP", this);
    connect(hamiltonButton, &QPushButton::clicked, this, &MainWindow::processHamiltonActions);
    algorithmLayout2->addWidget(hamiltonButton);

    revertHamiltonButton = new QPushButton("Отменить Гамильтон", this);
    connect(revertHamiltonButton, &QPushButton::clicked, this, &MainWindow::revertHamiltonChanges);
    revertHamiltonButton->setEnabled(false);
    algorithmLayout2->addWidget(revertHamiltonButton);

    algorithmLayout->addStretch();
    algorithmLayout2->addStretch();

    mainLayout->addLayout(graphSettingsLayout);
    mainLayout->addLayout(algorithmLayout);
    mainLayout->addLayout(algorithmLayout2);
}

void MainWindow::setupMainWorkspace(QVBoxLayout* mainLayout) {
    QSplitter *mainSplitter = new QSplitter(Qt::Horizontal, this);
    mainSplitter->setHandleWidth(5);


    graphWidget = new GraphWidget(this);
    graphWidget->setMinimumSize(700, 700);
    graphWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    mainSplitter->addWidget(graphWidget);


    QWidget* rightPanel = new QWidget(this);
    rightPanel->setMinimumWidth(700);
    QVBoxLayout* rightLayout = new QVBoxLayout(rightPanel);
    rightLayout->setContentsMargins(0, 0, 0, 0);


    tablesCombo = new QComboBox(this);
    tablesCombo->addItem("Матрица смежности");
    tablesCombo->addItem("Матрица весов");
    tablesCombo->addItem("Шимбелл (мин/макс)");
    tablesCombo->addItem("Шимбелл (общее)");
    tablesCombo->addItem("Маршруты");
    tablesCombo->addItem("Беллмана-Форда");
    tablesCombo->addItem("Обход графа");
    tablesCombo->addItem("Пропускные способности / Стоимости");
    tablesCombo->addItem("Максимальный поток");
    tablesCombo->addItem("Поток мин. стоимости");
    tablesCombo->addItem("Число остовов");
    tablesCombo->addItem("MST (Краскал)");
    tablesCombo->addItem("Код Прюфера");
    tablesCombo->addItem("Раскраска");
    tablesCombo->addItem("Эйлеров Путь/Цикл");
    tablesCombo->addItem("Гамильтонов Цикл / TSP");
    rightLayout->addWidget(tablesCombo);


    resultsStack = new QStackedWidget(this);


    adjacencyMatrixTable = createMatrixWidget();
    resultsStack->addWidget(adjacencyMatrixTable);

    weightMatrixTable = createMatrixWidget();
    resultsStack->addWidget(weightMatrixTable);

    shimbelResultsTable = createMatrixWidget();
    resultsStack->addWidget(shimbelResultsTable);

    shimbelResultsTable2 = createMatrixWidget();
    resultsStack->addWidget(shimbelResultsTable2);

    findPathsTable = createMatrixWidget();
    resultsStack->addWidget(findPathsTable);

    bellFordTable = createMatrixWidget();
    resultsStack->addWidget(bellFordTable);

    traversalTab = createTraversalWidget();
    resultsStack->addWidget(traversalTab);

    capacityCostTab = new QWidget(this);
    QVBoxLayout* capCostLayout = new QVBoxLayout(capacityCostTab);
    capCostLayout->setContentsMargins(0, 5, 0, 5);
    capCostLayout->setSpacing(10);


    QGroupBox* capacityGroup = new QGroupBox("Матрица пропускных способностей (Capacity)", this);
    QVBoxLayout* capacityLayout = new QVBoxLayout(capacityGroup);
    capacityMatrixTable = createMatrixWidget();
    capacityLayout->addWidget(capacityMatrixTable);
    capCostLayout->addWidget(capacityGroup);


    QGroupBox* costGroup = new QGroupBox("Матрица стоимостей (Cost)", this);
    QVBoxLayout* costLayout = new QVBoxLayout(costGroup);
    costMatrixTable = createMatrixWidget();
    costLayout->addWidget(costMatrixTable);
    capCostLayout->addWidget(costGroup);

    capCostLayout->addStretch();
    resultsStack->addWidget(capacityCostTab);

    flowMatrixTable = createMatrixWidget();
    resultsStack->addWidget(flowMatrixTable);

    minCostFlowTable = createMatrixWidget();
    resultsStack->addWidget(minCostFlowTable);

    spanningTreeResultText = createResultTextWidget();
    resultsStack->addWidget(spanningTreeResultText);

    mstResultTable = createMatrixWidget();
    resultsStack->addWidget(mstResultTable);


    pruferTab = new QWidget(this);
    QVBoxLayout* pruferLayout = new QVBoxLayout(pruferTab);
    pruferLayout->setContentsMargins(5, 5, 5, 5);
    pruferLayout->addWidget(new QLabel("Код Прюфера:"));
    pruferCodeText = createResultTextWidget();
    pruferCodeText->setFixedHeight(100);
    pruferLayout->addWidget(pruferCodeText);
    pruferLayout->addWidget(new QLabel("Декодированные рёбра (восстановленное дерево):"));
    pruferDecodedTable = createMatrixWidget();
    pruferLayout->addWidget(pruferDecodedTable);
    resultsStack->addWidget(pruferTab);

    coloringResultTable = createMatrixWidget();
    resultsStack->addWidget(coloringResultTable);


    eulerTab = new QWidget(this);
    QVBoxLayout* eulerLayout = new QVBoxLayout(eulerTab);
    eulerResultText = createResultTextWidget();
    eulerLayout->addWidget(new QLabel("Результаты Эйлера:"));
    eulerLayout->addWidget(eulerResultText);
    resultsStack->addWidget(eulerTab);

    hamiltonTab = new QWidget(this);
    QVBoxLayout* hamiltonLayout = new QVBoxLayout(hamiltonTab);
    hamiltonResultText = createResultTextWidget();
    hamiltonLayout->addWidget(new QLabel("Результаты Гамильтона/TSP:"));
    hamiltonLayout->addWidget(hamiltonResultText);
    resultsStack->addWidget(hamiltonTab);

    rightLayout->addWidget(resultsStack);


    connect(tablesCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, &MainWindow::onTableSelected);

    mainSplitter->addWidget(rightPanel);
    mainSplitter->setSizes({800, 800});
    mainLayout->addWidget(mainSplitter);
}

void MainWindow::onTableSelected(int index) {
    resultsStack->setCurrentIndex(index);
}

void MainWindow::clearBackupAndHamiltonResults() {
     if (eulerResultText) eulerResultText->clear();
     if (hamiltonResultText) hamiltonResultText->clear();
     if (revertEulerButton) revertEulerButton->setEnabled(false);
     if (revertHamiltonButton) revertHamiltonButton->setEnabled(false);

     backupExists = false;
     originalMatrixDataBackup.clear();
     originalVertexCountBackup = 0;
     originalAllowsNegativeBackup = false;
}

void MainWindow::showTraversalResults(int startVertex) {
    if (!currentGraph) {
        QMessageBox::warning(this, "Ошибка", "Граф не создан");
        return;
    }

    try {

        tablesCombo->setCurrentIndex(6);
        resultsStack->setCurrentWidget(traversalTab);

        auto [bfsOrder, bfsIterations] = currentGraph->getBFSOrder(startVertex);
        QString bfsInfo = QString("BFS порядок (вершин: %1, итераций: %2):\n")
                          .arg(bfsOrder.size())
                          .arg(bfsIterations);
        bfsText->setPlainText(bfsInfo + vectorToString(bfsOrder));

        auto [dfsOrder, dfsIterations] = currentGraph->getDFSOrder(startVertex);
        QString dfsInfo = QString("DFS порядок (вершин: %1, итераций: %2):\n")
                          .arg(dfsOrder.size())
                          .arg(dfsIterations);
        dfsText->setPlainText(dfsInfo + vectorToString(dfsOrder));

    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка",
            QString("Ошибка при обходе графа: %1").arg(e.what()));

        bfsText->clear();
        dfsText->clear();
    }
}

QTableWidget* MainWindow::createMatrixWidget() {
    QTableWidget* table = new QTableWidget(this);
    table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    return table;
}

QTextEdit* MainWindow::createResultTextWidget() {
    QTextEdit* textEdit = new QTextEdit(this);
    textEdit->setReadOnly(true);
    textEdit->setFontPointSize(11);
    return textEdit;
}

QWidget* MainWindow::createTraversalWidget() {
    QWidget* tab = new QWidget();
    QVBoxLayout* layout = new QVBoxLayout(tab);

    bfsText = new QTextEdit();
    bfsText->setReadOnly(true);
    layout->addWidget(new QLabel("BFS порядок:"));
    layout->addWidget(bfsText);

    dfsText = new QTextEdit();
    dfsText->setReadOnly(true);
    layout->addWidget(new QLabel("DFS порядок:"));
    layout->addWidget(dfsText);

    return tab;
}

QString MainWindow::vectorToString(const std::vector<int>& vec) {
    QString result;
    for (size_t i = 0; i < vec.size(); ++i) {
        if (i != 0) result += " ";
        result += QString::number(vec[i]);
    }
    return result;
}

void MainWindow::updateGraphType(GraphType type) {
    delete currentGraph;
    currentGraphType = type;


    if (currentGraphType == DIRECTED) {
        directedRadio->setChecked(true);
    } else {
        undirectedRadio->setChecked(true);
    }


    if (currentGraphType == DIRECTED) {
        currentGraph = new DirectedGraph(vertexCountSpinBox->value());
    } else {
        currentGraph = new UndirectedGraph(vertexCountSpinBox->value());
    }

    currentGraphWeights = negativeRadio->isChecked();

    currentGraph->generateGraph(currentGraphWeights);
    graphWidget->setGraph(currentGraph);
    updateMatrices();
}

void MainWindow::updateMatrices() {
    if (!currentGraph) return;

    int size = currentGraph->getRows();


    adjacencyMatrixTable->setRowCount(size);
    adjacencyMatrixTable->setColumnCount(size);
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            QTableWidgetItem* item = new QTableWidgetItem(
                currentGraph->get(i, j) ? "1" : "0");
            item->setTextAlignment(Qt::AlignCenter);
            adjacencyMatrixTable->setItem(i, j, item);
        }
    }


    weightMatrixTable->setRowCount(size);
    weightMatrixTable->setColumnCount(size);
    for (int i = 0; i < size; ++i) {
        for (int j = 0; j < size; ++j) {
            QTableWidgetItem* item = new QTableWidgetItem(
                QString::number(currentGraph->get(i, j)));
            item->setTextAlignment(Qt::AlignCenter);
            weightMatrixTable->setItem(i, j, item);
        }
    }


    DirectedGraph* directedGraph = dynamic_cast<DirectedGraph*>(currentGraph);
    if (directedGraph) {

        std::vector<std::vector<int>> capMatrix = directedGraph->getCapacityMatrix();
        capacityMatrixTable->clear();
        capacityMatrixTable->setRowCount(size);
        capacityMatrixTable->setColumnCount(size);
        for (int i = 0; i < size; ++i) {
            for (int j = 0; j < size; ++j) {
                QTableWidgetItem* item = new QTableWidgetItem(QString::number(capMatrix[i][j]));
                item->setTextAlignment(Qt::AlignCenter);
                capacityMatrixTable->setItem(i, j, item);
            }
        }
        capacityMatrixTable->resizeColumnsToContents();


        std::vector<std::vector<int>> costMat = directedGraph->getCostMatrix();
        costMatrixTable->clear();
        costMatrixTable->setRowCount(size);
        costMatrixTable->setColumnCount(size);
        for (int i = 0; i < size; ++i) {
            for (int j = 0; j < size; ++j) {
                QTableWidgetItem* item = new QTableWidgetItem(QString::number(costMat[i][j]));
                item->setTextAlignment(Qt::AlignCenter);
                costMatrixTable->setItem(i, j, item);
            }
        }
        costMatrixTable->resizeColumnsToContents();
    } else {

        capacityMatrixTable->clearContents(); capacityMatrixTable->setRowCount(0); capacityMatrixTable->setColumnCount(0);
        costMatrixTable->clearContents(); costMatrixTable->setRowCount(0); costMatrixTable->setColumnCount(0);
    }
}

void MainWindow::updateMatricesForGraph(const Graph* graph) {
     if (!graph || !adjacencyMatrixTable || !weightMatrixTable || !capacityMatrixTable || !costMatrixTable) {
          qWarning() << "Cannot update matrices: graph or table widgets are null.";
          return;
     }

     int size = graph->getRows();
     auto formatItem = [](QTableWidgetItem* item){ if(item) item->setTextAlignment(Qt::AlignCenter); };
     QStringList headers;
     for(int i=0; i<size; ++i) headers << QString::number(i);


     adjacencyMatrixTable->clearContents();
     adjacencyMatrixTable->setRowCount(size); adjacencyMatrixTable->setColumnCount(size);
     adjacencyMatrixTable->setHorizontalHeaderLabels(headers); adjacencyMatrixTable->setVerticalHeaderLabels(headers);
     for (int i = 0; i < size; ++i) for (int j = 0; j < size; ++j) {
         QTableWidgetItem* item = new QTableWidgetItem(graph->get(i, j) != 0 ? "1" : "0");
         formatItem(item); adjacencyMatrixTable->setItem(i, j, item);
     }


     weightMatrixTable->clearContents();
     weightMatrixTable->setRowCount(size); weightMatrixTable->setColumnCount(size);
     weightMatrixTable->setHorizontalHeaderLabels(headers); weightMatrixTable->setVerticalHeaderLabels(headers);
     for (int i = 0; i < size; ++i) for (int j = 0; j < size; ++j) {
         QTableWidgetItem* item = new QTableWidgetItem(QString::number(graph->get(i, j)));
         formatItem(item); weightMatrixTable->setItem(i, j, item);
     }


     const DirectedGraph* directedGraph = dynamic_cast<const DirectedGraph*>(graph);
     capacityMatrixTable->clearContents(); capacityMatrixTable->setRowCount(0); capacityMatrixTable->setColumnCount(0);
     costMatrixTable->clearContents(); costMatrixTable->setRowCount(0); costMatrixTable->setColumnCount(0);
     if (directedGraph) {
         try {
             auto capMatrix = directedGraph->getCapacityMatrix();
             auto costMat = directedGraph->getCostMatrix();
             int flowSize = capMatrix.size();
             if(flowSize > 0 && costMat.size() == flowSize) {
                 capacityMatrixTable->setRowCount(flowSize); capacityMatrixTable->setColumnCount(flowSize);
                 costMatrixTable->setRowCount(flowSize); costMatrixTable->setColumnCount(flowSize);
                 capacityMatrixTable->setHorizontalHeaderLabels(headers); capacityMatrixTable->setVerticalHeaderLabels(headers);
                 costMatrixTable->setHorizontalHeaderLabels(headers); costMatrixTable->setVerticalHeaderLabels(headers);

                 for (int i = 0; i < flowSize; ++i) for (int j = 0; j < flowSize; ++j) {
                     QTableWidgetItem* capItem = new QTableWidgetItem(QString::number(capMatrix[i][j])); formatItem(capItem); capacityMatrixTable->setItem(i, j, capItem);
                     QTableWidgetItem* costItem = new QTableWidgetItem(QString::number(costMat[i][j])); formatItem(costItem); costMatrixTable->setItem(i, j, costItem);
                 }
             } else {
                  qWarning() << "Inconsistent sizes for capacity/cost matrices";
             }
         } catch (const std::exception& e) {
              qWarning() << "Error getting capacity/cost matrices:" << e.what();
         }
     }
}

void MainWindow::fillShimbel() {
    if (!currentGraph) {
        QMessageBox::warning(this, "Ошибка", "Граф не создан");
        return;
    }

    try {
        calculateShimbelWithSteps();
        calculateShimbel();
        tablesCombo->setCurrentIndex(2);
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при расчете Шимбелла: %1").arg(e.what()));
    }
}

void MainWindow::calculateShimbelWithSteps() {
    if (!currentGraph || !shimbelResultsTable) {
        QMessageBox::warning(this, "Ошибка", "Граф или таблица не инициализированы");
        return;
    }

    bool ok;
    int steps = QInputDialog::getInt(this, "Параметры Шимбелла",
                                   "Введите количество шагов (рёбер):",
                                   2, 0, 10, 1, &ok);
    if (!ok) return;

    try {
        auto result = currentGraph->calculateShimbel(steps);
        int n = currentGraph->getRows();

        shimbelResultsTable->clear();
        shimbelResultsTable->setRowCount(n * n);
        shimbelResultsTable->setColumnCount(6);
        shimbelResultsTable->setHorizontalHeaderLabels(
            {"Из", "В", "Длина", "Мин. стоимость", "Макс. стоимость", "Достижимо"});

        int row = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                QString min_val = result.min_paths[i][j] == INT_MAX ? "∞" : QString::number(result.min_paths[i][j]);
                QString max_val = result.max_paths[i][j] == INT_MIN ? "-∞" : QString::number(result.max_paths[i][j]);
                QString reachable = result.reachable[i][j] ? "Да" : "Нет";
                QString actualSteps = QString::number(steps);

                shimbelResultsTable->setItem(row, 0, new QTableWidgetItem(QString::number(i)));
                shimbelResultsTable->setItem(row, 1, new QTableWidgetItem(QString::number(j)));
                shimbelResultsTable->setItem(row, 2, new QTableWidgetItem(actualSteps));
                shimbelResultsTable->setItem(row, 3, new QTableWidgetItem(min_val));
                shimbelResultsTable->setItem(row, 4, new QTableWidgetItem(max_val));
                shimbelResultsTable->setItem(row, 5, new QTableWidgetItem(reachable));

                if (result.reachable[i][j]) {
                    for (int col = 0; col < 6; ++col) {
                        if (auto item = shimbelResultsTable->item(row, col)) {
                            item->setBackground(QColor(200, 255, 200));
                        }
                    }
                }
                row++;
            }
        }

        shimbelResultsTable->setRowCount(row + 1);
        QTableWidgetItem* summaryItem = new QTableWidgetItem(
            QString("Итого: %1 пар вершин, шагов: %2").arg(row).arg(steps));
        summaryItem->setBackground(QColor(230, 230, 250));
        shimbelResultsTable->setItem(row, 0, summaryItem);
        shimbelResultsTable->setSpan(row, 0, 1, 6);

        shimbelResultsTable->resizeColumnsToContents();
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при расчете Шимбелла: %1").arg(e.what()));
    }
}

void MainWindow::calculateShimbel() {
    if (!currentGraph || !shimbelResultsTable2) {
        QMessageBox::warning(this, "Ошибка", "Граф или таблица не инициализированы");
        return;
    }

    try {
        auto result = currentGraph->calculateShimbelGeneral();
        int n = currentGraph->getRows();

        shimbelResultsTable2->clear();
        shimbelResultsTable2->setRowCount(n * 2);
        shimbelResultsTable2->setColumnCount(n + 1);

        QStringList headers;
        headers << "Вершина";
        for (int i = 0; i < n; ++i) {
            headers << QString::number(i);
        }
        shimbelResultsTable2->setHorizontalHeaderLabels(headers);

        for (int i = 0; i < n; ++i) {
            shimbelResultsTable2->setItem(i, 0, new QTableWidgetItem("Min " + QString::number(i)));
            for (int j = 0; j < n; ++j) {
                QString value = result.min_paths[i][j] == INT_MAX ? "∞" : QString::number(result.min_paths[i][j]);
                QTableWidgetItem* item = new QTableWidgetItem(value);
                item->setTextAlignment(Qt::AlignCenter);
                shimbelResultsTable2->setItem(i, j + 1, item);
            }

            shimbelResultsTable2->setItem(n + i, 0, new QTableWidgetItem("Max " + QString::number(i)));
            for (int j = 0; j < n; ++j) {
                QString value = result.max_paths[i][j] == INT_MIN ? "-∞" : QString::number(result.max_paths[i][j]);
                QTableWidgetItem* item = new QTableWidgetItem(value);
                item->setTextAlignment(Qt::AlignCenter);
                shimbelResultsTable2->setItem(n + i, j + 1, item);
            }
        }

        shimbelResultsTable2->resizeColumnsToContents();
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при расчете общего Шимбелла: %1").arg(e.what()));
    }
}

void MainWindow::findPathsBetweenVertices() {
    if (!currentGraph || !findPathsTable) {
        QMessageBox::warning(this, "Ошибка", "Граф или таблица не инициализированы");
        return;
    }

    try {
        QDialog dialog(this);
        QFormLayout form(&dialog);

        int vertexCount = currentGraph->getRows();

        QSpinBox fromSpin, toSpin, stepsSpin;
        fromSpin.setRange(0, vertexCount-1);
        toSpin.setRange(0, vertexCount-1);
        stepsSpin.setRange(-1, 100);
        stepsSpin.setValue(-1);
        stepsSpin.setSpecialValueText("Без ограничений");

        form.addRow("Начальная вершина:", &fromSpin);
        form.addRow("Конечная вершина:", &toSpin);
        form.addRow("Макс. шагов (-1 - без ограничений):", &stepsSpin);

        QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
        form.addRow(&buttonBox);
        connect(&buttonBox, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
        connect(&buttonBox, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);

        if (dialog.exec() != QDialog::Accepted) return;

        int from = fromSpin.value();
        int to = toSpin.value();
        int maxSteps = stepsSpin.value();

        if (from == to) {
            QMessageBox::information(this, "Результат",
                                   QString("Начальная и конечная вершины совпадают (%1)").arg(from));
            return;
        }

        if (from > to && currentGraph->isDirected()) {
            QMessageBox::warning(this, "Ошибка",
                               "В ориентированном графе невозможно построить путь "
                               "от старшей вершины к младшей");
            return;
        }

        auto result = currentGraph->findPaths(from, to, maxSteps);

        findPathsTable->clearContents();
        findPathsTable->setRowCount(result.count + 1);
        findPathsTable->setColumnCount(2);
        findPathsTable->setHorizontalHeaderLabels({"№", "Маршрут"});

        QString countInfo;
        if (result.count == 0) {
            countInfo = QString("Пути из %1 в %2 не найдены").arg(from).arg(to);
            if (maxSteps > 0) countInfo += QString(" (макс. %1 шагов)").arg(maxSteps);
        } else {
            countInfo = QString("Найдено путей: %1").arg(result.count);
            if (maxSteps > 0) countInfo += QString(" (ограничение: %1 шагов)").arg(maxSteps);
        }

        QTableWidgetItem* countItem = new QTableWidgetItem(countInfo);
        countItem->setBackground(QColor(240, 240, 240));
        countItem->setFlags(countItem->flags() & ~Qt::ItemIsEditable);
        findPathsTable->setItem(0, 0, countItem);
        findPathsTable->setSpan(0, 0, 1, 2);

        for (int i = 0; i < result.count; ++i) {
            QString pathStr;
            for (int v : result.paths[i]) {
                pathStr += QString::number(v) + " → ";
            }
            pathStr.chop(3);

            findPathsTable->setItem(i + 1, 0, new QTableWidgetItem(QString::number(i + 1)));
            findPathsTable->setItem(i + 1, 1, new QTableWidgetItem(pathStr));
        }

        findPathsTable->resizeColumnsToContents();
        tablesCombo->setCurrentIndex(4);
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при поиске маршрутов: %1").arg(e.what()));
    }
}

void MainWindow::findShortestPath() {
    if (!currentGraph || !bellFordTable) {
        QMessageBox::warning(this, "Ошибка", "Граф или таблица не инициализированы");
        return;
    }

    try {
        bool ok;
        int from = QInputDialog::getInt(this, "Начальная вершина",
                                      "Введите начальную вершину:",
                                      0, 0, currentGraph->getRows()-1, 1, &ok);
        if (!ok) return;

        int to = QInputDialog::getInt(this, "Конечная вершина",
                                    "Введите конечную вершину:",
                                    0, 0, currentGraph->getRows()-1, 1, &ok);
        if (!ok) return;

        auto result = currentGraph->bellmanFord(from);


        bellFordTable->clear();
        bellFordTable->setRowCount(0);
        bellFordTable->setColumnCount(3);
        bellFordTable->setHorizontalHeaderLabels({"Вершина", "Расстояние", "Предшественник"});

        if (result.hasNegativeCycle) {
            bellFordTable->setRowCount(2);


            QTableWidgetItem* errorItem = new QTableWidgetItem("Ошибка цикл");
            errorItem->setBackground(QColor(255, 200, 200));
            bellFordTable->setItem(0, 0, errorItem);
            bellFordTable->setItem(0, 1, new QTableWidgetItem("Обнаружен цикл отрицательного веса"));
            bellFordTable->setSpan(0, 0, 1, 3);


            bellFordTable->setItem(1, 0, new QTableWidgetItem(QString("Итераций выполнено: %1").arg(result.iterations)));
            bellFordTable->setSpan(1, 0, 1, 3);

            tablesCombo->setCurrentIndex(5);
            return;
        }

        int n = currentGraph->getRows();
        bellFordTable->setRowCount(n + 3);


        for (int i = 0; i < n; ++i) {
            bellFordTable->setItem(i, 0, new QTableWidgetItem(QString::number(i)));


            QString distText = (result.distances[i] == INT_MAX) ? "∞" : QString::number(result.distances[i]);
            bellFordTable->setItem(i, 1, new QTableWidgetItem(distText));


            QString predText = (result.predecessors[i] == -1) ? "-" : QString::number(result.predecessors[i]);
            bellFordTable->setItem(i, 2, new QTableWidgetItem(predText));
        }


        auto path = currentGraph->getPath(from, to, result.predecessors, result.distances);
        int pathRow = n;

        if (path.empty()) {
            bellFordTable->setItem(pathRow, 0, new QTableWidgetItem("Путь не найден"));
            bellFordTable->setSpan(pathRow, 0, 1, 3);
        } else {

            QString pathStr;
            for (size_t i = 0; i < path.size(); ++i) {
                if (i != 0) pathStr += " → ";
                pathStr += QString::number(path[i]);
            }


            bellFordTable->setItem(pathRow, 0, new QTableWidgetItem("Маршрут: " + pathStr));
            bellFordTable->setSpan(pathRow, 0, 1, 3);


            bellFordTable->setItem(pathRow+1, 0,
                new QTableWidgetItem(QString("Длина пути: %1").arg(result.distances[to])));
            bellFordTable->setSpan(pathRow+1, 0, 1, 3);
        }


        auto highlightVertex = [&](int v, const QColor& color) {
            if (v >= 0 && v < n) {
                for (int col = 0; col < 3; ++col) {
                    if (auto item = bellFordTable->item(v, col)) {
                        item->setBackground(color);
                    }
                }
            }
        };


        for (int v : path) {
            highlightVertex(v, QColor(255, 255, 200));
        }
        highlightVertex(from, QColor(200, 255, 200));
        if (!path.empty()) {
            highlightVertex(to, QColor(255, 200, 200));
        }


        int iterRow = bellFordTable->rowCount() - 1;
        bellFordTable->setItem(iterRow, 0,
            new QTableWidgetItem(QString("Итераций выполнено: %1").arg(result.iterations)));
        bellFordTable->setSpan(iterRow, 0, 1, 3);

        bellFordTable->resizeColumnsToContents();
        tablesCombo->setCurrentIndex(5);
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка",
            QString("Ошибка при поиске кратчайшего пути: %1").arg(e.what()));
    }
}

void MainWindow::findMaxFlow() {
    DirectedGraph* directedGraph = dynamic_cast<DirectedGraph*>(currentGraph);
    if (!directedGraph) {
        QMessageBox::warning(this, "Ошибка", "Алгоритм максимального потока применим только к ориентированным графам.");

        flowMatrixTable->clear();
        flowMatrixTable->setRowCount(0);
        flowMatrixTable->setColumnCount(0);
        return;
    }


    int n = directedGraph->getRows();
    if (n < 2) {
         QMessageBox::warning(this, "Ошибка", "Для поиска потока требуется как минимум 2 вершины.");
         flowMatrixTable->clear();
         flowMatrixTable->setRowCount(0);
         flowMatrixTable->setColumnCount(0);
         return;
    }


    bool okSource, okSink;
    int source = QInputDialog::getInt(this,
                                    "Выбор истока",
                                    "Введите номер вершины-истока (source):",
                                    0,
                                    0,
                                    n - 1,
                                    1,
                                    &okSource);


    if (!okSource) {
        return;
    }

    int sink = QInputDialog::getInt(this,
                                  "Выбор стока",
                                  "Введите номер вершины-стока (sink):",
                                  n - 1,
                                  0,
                                  n - 1,
                                  1,
                                  &okSink);


    if (!okSink) {
        return;
    }


    if (source == sink) {
        QMessageBox::warning(this, "Ошибка", "Исток и сток не могут совпадать.");
        flowMatrixTable->clear();
        flowMatrixTable->setRowCount(0);
        flowMatrixTable->setColumnCount(0);
        return;
    }


    try {

        DirectedGraph::MaxFlowResult result = directedGraph->maxFlowFordFulkerson(source, sink);


        flowMatrixTable->clear();


        if (!result.success) {

            flowMatrixTable->setRowCount(1);
            flowMatrixTable->setColumnCount(1);
            flowMatrixTable->setHorizontalHeaderLabels({"Ошибка"});
            flowMatrixTable->setVerticalHeaderLabels({""});


            QTableWidgetItem* errorItem = new QTableWidgetItem(QString::fromStdString(result.message));
            errorItem->setBackground(QColor(255, 200, 200));
            errorItem->setTextAlignment(Qt::AlignCenter);
            flowMatrixTable->setItem(0, 0, errorItem);
            flowMatrixTable->resizeColumnsToContents();
        } else {

            int size = result.flowMatrix.size();


            flowMatrixTable->setRowCount(size + 2);
            flowMatrixTable->setColumnCount(size);


            QStringList headers;
            for(int i = 0; i < size; ++i) {
                headers << QString::number(i);
            }
            flowMatrixTable->setHorizontalHeaderLabels(headers);
            flowMatrixTable->setVerticalHeaderLabels(headers);


            std::vector<std::vector<int>> capMatrix = directedGraph->getCapacityMatrix();


            for (int i = 0; i < size; ++i) {
                for (int j = 0; j < size; ++j) {

                    QString cellText = QString("%1 / %2")
                                       .arg(result.flowMatrix[i][j])
                                       .arg(capMatrix[i][j]);

                    QTableWidgetItem* item = new QTableWidgetItem(cellText);
                    item->setTextAlignment(Qt::AlignCenter);


                    if (capMatrix[i][j] > 0) {
                        if (result.flowMatrix[i][j] > 0) {

                             item->setBackground(QColor(200, 255, 200));
                        }
                        if (result.flowMatrix[i][j] == capMatrix[i][j]) {

                            item->setBackground(QColor(150, 220, 150));
                        }
                    } else if (result.flowMatrix[i][j] != 0) {

                         item->setBackground(QColor(255, 255, 150));
                    }

                    flowMatrixTable->setItem(i, j, item);
                }
            }


            int summaryRow1 = size;
            int summaryRow2 = size + 1;


            QTableWidgetItem* flowValueItem = new QTableWidgetItem(
                QString("Максимальный поток из %1 в %2: %3")
                .arg(source).arg(sink).arg(result.maxFlowValue));
            flowValueItem->setBackground(QColor(230, 230, 250));
            flowMatrixTable->setItem(summaryRow1, 0, flowValueItem);

            flowMatrixTable->setSpan(summaryRow1, 0, 1, size);


            QTableWidgetItem* iterItem = new QTableWidgetItem(
                QString("Итераций (найдено увеличивающих путей): %1").arg(result.iterations));
            iterItem->setBackground(QColor(230, 230, 250));
            flowMatrixTable->setItem(summaryRow2, 0, iterItem);

            flowMatrixTable->setSpan(summaryRow2, 0, 1, size);


             if (auto header = flowMatrixTable->verticalHeader()) {

                 flowMatrixTable->setVerticalHeaderItem(summaryRow1, new QTableWidgetItem(""));
                 flowMatrixTable->setVerticalHeaderItem(summaryRow2, new QTableWidgetItem(""));
             }


            flowMatrixTable->resizeColumnsToContents();
        }



        tablesCombo->setCurrentIndex(8);

    } catch (const std::exception& e) {

        QMessageBox::critical(this, "Критическая ошибка",
            QString("Произошла ошибка при расчете максимального потока: %1").arg(e.what()));

        flowMatrixTable->clear();
        flowMatrixTable->setRowCount(0);
        flowMatrixTable->setColumnCount(0);
    } catch (...) {

         QMessageBox::critical(this, "Критическая ошибка",
            "Произошла неизвестная ошибка при расчете максимального потока.");
         flowMatrixTable->clear();
         flowMatrixTable->setRowCount(0);
         flowMatrixTable->setColumnCount(0);
    }
}

void MainWindow::findMinCostFlow() {

    DirectedGraph* directedGraph = dynamic_cast<DirectedGraph*>(currentGraph);
    if (!directedGraph) {
        QMessageBox::warning(this, "Ошибка", "Алгоритм потока минимальной стоимости применим только к ориентированным графам.");
        return;
    }
    int n = directedGraph->getRows();
    if (n < 2) {
        QMessageBox::warning(this, "Ошибка", "Требуется как минимум 2 вершины.");
        return;
    }


    bool okSource, okSink;
    int source = QInputDialog::getInt(this, "Выбор истока", "Введите номер вершины-истока:", 0, 0, n - 1, 1, &okSource);
    if (!okSource) return;
    int sink = QInputDialog::getInt(this, "Выбор стока", "Введите номер вершины-стока:", n - 1, 0, n - 1, 1, &okSink);
    if (!okSink) return;
    if (source == sink) {
        QMessageBox::warning(this, "Ошибка", "Исток и сток не могут совпадать.");
        return;
    }


    DirectedGraph::MaxFlowResult maxFlowResult;
    try {
         maxFlowResult = directedGraph->maxFlowFordFulkerson(source, sink);
         if (!maxFlowResult.success) {
             QMessageBox::critical(this, "Ошибка", QString("Не удалось вычислить максимальный поток: %1")
                                     .arg(QString::fromStdString(maxFlowResult.message)));
             return;
         }
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при вычислении максимального потока: %1").arg(e.what()));
        return;
    }

    if (maxFlowResult.maxFlowValue == 0) {
        QMessageBox::information(this, "Результат", "Максимальный поток равен 0. Поток минимальной стоимости также равен 0.");
        return;
    }

    int targetFlow = static_cast<int>(std::floor( (2.0 / 3.0) * static_cast<double>(maxFlowResult.maxFlowValue) ));

    if (targetFlow == 0 && maxFlowResult.maxFlowValue > 0) {

        minCostFlowTable->clear();
        minCostFlowTable->setRowCount(1);
        minCostFlowTable->setColumnCount(1);
        minCostFlowTable->setHorizontalHeaderLabels({"Информация"});
        QTableWidgetItem* infoItem = new QTableWidgetItem(
            QString("Максимальный поток в сети: %1. "
                    "Целевой поток (2/3 * max) рассчитан как %2. "
                    "Поток минимальной стоимости не вычисляется.")
            .arg(maxFlowResult.maxFlowValue)
            .arg(targetFlow)
        );
        infoItem->setBackground(QColor(230, 230, 250));
        minCostFlowTable->setItem(0, 0, infoItem);
        minCostFlowTable->resizeColumnsToContents();
        tablesCombo->setCurrentIndex(tablesCombo->findText("Поток мин. стоимости"));
        return;
    }



    try {
        DirectedGraph::MinCostFlowResult minCostResult = directedGraph->minCostFlow(source, sink, targetFlow);
        minCostFlowTable->clear();

        if (!minCostResult.success && !minCostResult.targetReached) {
            minCostFlowTable->setRowCount(1);
            minCostFlowTable->setColumnCount(1);
            minCostFlowTable->setHorizontalHeaderLabels({"Ошибка"});
            QTableWidgetItem* errorItem = new QTableWidgetItem(QString::fromStdString(minCostResult.message));
            errorItem->setBackground(QColor(255, 200, 200));
            minCostFlowTable->setItem(0, 0, errorItem);
            minCostFlowTable->resizeColumnsToContents();
        } else {
            int size = minCostResult.flowMatrix.size();
            minCostFlowTable->setRowCount(size + 3);
            minCostFlowTable->setColumnCount(size);
            QStringList headers;
            for(int i = 0; i < size; ++i) headers << QString::number(i);
            minCostFlowTable->setHorizontalHeaderLabels(headers);
            minCostFlowTable->setVerticalHeaderLabels(headers);

            std::vector<std::vector<int>> capMatrix = directedGraph->getCapacityMatrix();


            for (int i = 0; i < size; ++i) {
                for (int j = 0; j < size; ++j) {
                    QString cellText = QString("%1 / %2")
                                       .arg(minCostResult.flowMatrix[i][j])
                                       .arg(capMatrix[i][j]);
                    QTableWidgetItem* item = new QTableWidgetItem(cellText);
                    item->setTextAlignment(Qt::AlignCenter);

                    if (capMatrix[i][j] > 0) {
                        if (minCostResult.flowMatrix[i][j] > 0) item->setBackground(QColor(200, 255, 200));
                        if (minCostResult.flowMatrix[i][j] == capMatrix[i][j]) item->setBackground(QColor(150, 220, 150));
                    }
                    minCostFlowTable->setItem(i, j, item);
                }
            }


            int rowIdx = size;
            QTableWidgetItem* costItem = new QTableWidgetItem(QString("Минимальная стоимость: %1").arg(minCostResult.totalCost));
            costItem->setBackground(QColor(230, 230, 250));
            minCostFlowTable->setItem(rowIdx, 0, costItem);
            minCostFlowTable->setSpan(rowIdx++, 0, 1, size);

            QTableWidgetItem* flowAmountItem = new QTableWidgetItem(
                QString("Достигнутый поток: %1 (Целевой был: %2, Макс. поток в сети: %3)")
                .arg(minCostResult.flowAmount)
                .arg(minCostResult.targetFlowValue)
                .arg(maxFlowResult.maxFlowValue)
            );

            flowAmountItem->setBackground(QColor(230, 230, 250));
            minCostFlowTable->setItem(rowIdx, 0, flowAmountItem);
            minCostFlowTable->setSpan(rowIdx++, 0, 1, size);

            QTableWidgetItem* msgItem = new QTableWidgetItem(
                QString("Сообщение: %1 (Итераций: %2)")
                .arg(QString::fromStdString(minCostResult.message))
                .arg(minCostResult.iterations)
            );
            msgItem->setBackground(minCostResult.targetReached ? QColor(200, 255, 200) : QColor(255, 255, 150));
            minCostFlowTable->setItem(rowIdx, 0, msgItem);
            minCostFlowTable->setSpan(rowIdx++, 0, 1, size);


             if (auto header = minCostFlowTable->verticalHeader()) {
                 for(int r = size; r < rowIdx; ++r) {
                      minCostFlowTable->setVerticalHeaderItem(r, new QTableWidgetItem(""));
                 }
             }


            minCostFlowTable->resizeColumnsToContents();
        }


        tablesCombo->setCurrentIndex(9);

    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Критическая ошибка", QString("Ошибка при вычислении потока минимальной стоимости: %1").arg(e.what()));
        minCostFlowTable->clear();
        minCostFlowTable->setRowCount(0);
        minCostFlowTable->setColumnCount(0);
    }
}


void MainWindow::countSpanningTrees() {
    UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
        QMessageBox::warning(this, "Ошибка", "Теорема Кирхгофа применима только к неориентированным графам.");
        return;
    }
    if (!graph->isConnected()) {
         QMessageBox::warning(this, "Ошибка", "Теорема Кирхгофа применима только к связным графам.");
         return;
    }

    try {
        long long count = graph->countSpanningTreesKirchhoff();


         spanningTreeResultText->setPlainText(QString("Число остовных деревьев: %1").arg(count));
         tablesCombo->setCurrentIndex(10);
    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при подсчете остовных деревьев: %1").arg(e.what()));
         spanningTreeResultText->setPlainText("Ошибка при подсчете.");
         tablesCombo->setCurrentIndex(10);
    }
}


void MainWindow::findMST() {
    UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
        QMessageBox::warning(this, "Ошибка", "Алгоритм Краскала применим к неориентированным графам.");
        return;
    }

    try {
        UndirectedGraph::MSTResult mstResult = graph->kruskalMST();


        mstResultTable->clear();
        mstResultTable->setColumnCount(3);
        mstResultTable->setHorizontalHeaderLabels({"Вершина 1", "Вершина 2", "Вес"});
        mstResultTable->setRowCount(mstResult.edges.size() + 2);

        int row = 0;
        for(const auto& edge : mstResult.edges) {
            mstResultTable->setItem(row, 0, new QTableWidgetItem(QString::number(edge.u)));
            mstResultTable->setItem(row, 1, new QTableWidgetItem(QString::number(edge.v)));
            mstResultTable->setItem(row, 2, new QTableWidgetItem(QString::number(edge.weight)));
            row++;
        }


         QTableWidgetItem* weightItem = new QTableWidgetItem(QString("Общий вес MST: %1").arg(mstResult.totalWeight));
         weightItem->setBackground(QColor(230, 230, 250));
         mstResultTable->setItem(row, 0, weightItem);
         mstResultTable->setSpan(row++, 0, 1, 3);

         QTableWidgetItem* msgItem = new QTableWidgetItem(QString::fromStdString(mstResult.message));
         msgItem->setBackground(mstResult.success ? QColor(200, 255, 200) : QColor(255, 255, 150));
         mstResultTable->setItem(row, 0, msgItem);
         mstResultTable->setSpan(row++, 0, 1, 3);


         for(int r = mstResult.edges.size(); r < row; ++r) {
              if(auto header = mstResultTable->verticalHeader())
                 mstResultTable->setVerticalHeaderItem(r, new QTableWidgetItem(""));
         }


        mstResultTable->resizeColumnsToContents();
        tablesCombo->setCurrentIndex(11);

    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при построении MST: %1").arg(e.what()));
         mstResultTable->clear();
         mstResultTable->setRowCount(0);
         tablesCombo->setCurrentIndex(11);
    }
}


void MainWindow::runPrufer() {
    UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
        QMessageBox::warning(this, "Ошибка", "Код Прюфера строится для деревьев (обычно MST неориентированного графа).");
        if(pruferCodeText) pruferCodeText->clear();
        if(pruferDecodedTable) { pruferDecodedTable->clearContents(); pruferDecodedTable->setRowCount(0); }
        return;
    }

    if(pruferCodeText) pruferCodeText->clear();
    if(pruferDecodedTable) { pruferDecodedTable->clearContents(); pruferDecodedTable->setRowCount(0); }

    try {
        UndirectedGraph::MSTResult mstResult = graph->kruskalMST();
        if (!mstResult.success && graph->getRows() > 1) {
            QMessageBox::warning(this, "Предупреждение MST", QString("Не удалось построить MST для кодирования: %1").arg(QString::fromStdString(mstResult.message)));
            pruferCodeText->setPlainText("MST не построен. " + QString::fromStdString(mstResult.message));
            tablesCombo->setCurrentIndex(tablesCombo->findText("Код Прюфера"));
            return;
        }
        if (graph->getRows() > 0 && mstResult.edges.empty() && graph->getRows() > 1) {
             QMessageBox::information(this, "Информация MST", "MST не содержит ребер (возможно, граф несвязный или тривиальный). Код Прюфера будет построен для соответствующего дерева.");
        }

        UndirectedGraph::PruferResult pruferResult = UndirectedGraph::pruferEncodeDecode(mstResult.edges, graph->getRows());

        // --- Отображение кода Прюфера с весами ---
        QString detailedCodeOutputStr;
        if (pruferResult.encodeSuccess) {
            if (pruferResult.codeWithDetails.empty()) {
                detailedCodeOutputStr = "[Пустой код]";
            } else {
                for (size_t i = 0; i < pruferResult.codeWithDetails.size(); ++i) {
                    const auto& el = pruferResult.codeWithDetails[i];
                    // Формат: Сосед[вес ребра (Лист-Сосед)]
                    detailedCodeOutputStr += QString("%1[%2]") // Сосед[вес]
                                           .arg(el.neighborVertex)
                                           .arg(el.edgeWeight);
                    // Подсказка, какой лист был удален (для отладки/понимания)
                    // detailedCodeOutputStr += QString(" (лист %1)").arg(el.removedLeaf);
                    if (i < pruferResult.codeWithDetails.size() - 1) detailedCodeOutputStr += ", ";
                }
            }
        }

        QString fullMessage = QString::fromStdString(pruferResult.message);
        if (pruferResult.encodeSuccess) { // Добавляем код только если кодирование успешно
             if (!fullMessage.isEmpty() && fullMessage.back() != QChar('\n')) fullMessage += "\n";
             fullMessage = "Код Прюфера: " + detailedCodeOutputStr + "\n" + fullMessage;
        }
        pruferCodeText->setPlainText(fullMessage);


        // --- Отображение декодированных ребер ---
        if (pruferDecodedTable) {
            if (pruferResult.decodeSuccess) {
                pruferDecodedTable->setColumnCount(3);
                pruferDecodedTable->setHorizontalHeaderLabels({"Вершина 1 (дек.)", "Вершина 2 (дек.)", "Вес (дек.)"});
                if (pruferResult.decodedEdges.empty()) {
                     pruferDecodedTable->setRowCount(1);
                     pruferDecodedTable->setItem(0,0, new QTableWidgetItem("Декодированное дерево не содержит ребер"));
                     pruferDecodedTable->setSpan(0,0,1,3);
                } else {
                    pruferDecodedTable->setRowCount(pruferResult.decodedEdges.size());
                    int row = 0;
                    for(const auto& edge : pruferResult.decodedEdges) {
                        pruferDecodedTable->setItem(row, 0, new QTableWidgetItem(QString::number(edge.u)));
                        pruferDecodedTable->setItem(row, 1, new QTableWidgetItem(QString::number(edge.v)));
                        pruferDecodedTable->setItem(row, 2, new QTableWidgetItem(QString::number(edge.weight)));
                        row++;
                    }
                }
                pruferDecodedTable->resizeColumnsToContents();
            } else {
                 pruferDecodedTable->setRowCount(1); pruferDecodedTable->setColumnCount(1);
                 pruferDecodedTable->setHorizontalHeaderLabels({"Результат"});
                 pruferDecodedTable->setItem(0, 0, new QTableWidgetItem("Ошибка декодирования или декодирование не выполнялось."));
            }
        }
        tablesCombo->setCurrentIndex(tablesCombo->findText("Код Прюфера"));

    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка Прюфера", QString("Ошибка при работе с кодом Прюфера: %1").arg(e.what()));
        if(pruferCodeText) pruferCodeText->setPlainText("Критическая ошибка: " + QString(e.what()));
        tablesCombo->setCurrentIndex(tablesCombo->findText("Код Прюфера"));
    }
}


void MainWindow::runColoring() {
     UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
        QMessageBox::warning(this, "Ошибка", "Раскраска выполняется для неориентированных графов.");
        return;
    }

     UndirectedGraph* graphToColor = graph;
     std::unique_ptr<UndirectedGraph> mstGraph;

    try {
        UndirectedGraph::ColoringResult coloringResult = graphToColor->greedyColoring();


        coloringResultTable->clear();
         if (!coloringResult.success) {
              coloringResultTable->setRowCount(1);
              coloringResultTable->setColumnCount(1);
              coloringResultTable->setItem(0, 0, new QTableWidgetItem("Ошибка раскраски: " + QString::fromStdString(coloringResult.message)));
         } else {
            coloringResultTable->setColumnCount(2);
            coloringResultTable->setHorizontalHeaderLabels({"Вершина", "Цвет"});
            coloringResultTable->setRowCount(coloringResult.colors.size() + 1);

            int row = 0;
            for(size_t i = 0; i < coloringResult.colors.size(); ++i) {
                coloringResultTable->setItem(row, 0, new QTableWidgetItem(QString::number(i)));
                coloringResultTable->setItem(row, 1, new QTableWidgetItem(QString::number(coloringResult.colors[i])));
                row++;
            }

             QTableWidgetItem* countItem = new QTableWidgetItem(QString("Использовано цветов: %1").arg(coloringResult.numberOfColors));
             countItem->setBackground(QColor(230, 230, 250));
             coloringResultTable->setItem(row, 0, countItem);
             coloringResultTable->setSpan(row, 0, 1, 2);
              if(auto header = coloringResultTable->verticalHeader())
                 coloringResultTable->setVerticalHeaderItem(row, new QTableWidgetItem(""));


             coloringResultTable->resizeColumnsToContents();
         }

        tablesCombo->setCurrentIndex(13);

    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Ошибка", QString("Ошибка при раскраске графа: %1").arg(e.what()));
         coloringResultTable->clear();
         coloringResultTable->setRowCount(0);
         tablesCombo->setCurrentIndex(13);
    }
}

void MainWindow::clearEulerResultsAndBackup() {
     if (eulerResultText) eulerResultText->clear();
     if (revertEulerButton) revertEulerButton->setEnabled(false);
     backupExists = false;
     originalMatrixDataBackup.clear();
     originalVertexCountBackup = 0;
     originalAllowsNegativeBackup = false;
}

QString formatModificationLog(const UndirectedGraph::ModificationLog& log) {
    QString logStr;
    if (log.actions.empty()) {
        return logStr;
    }

    logStr += "Выполненные действия:\n";
    std::map<std::pair<int, int>, int> addedWeights;
    std::map<std::pair<int, int>, int> removedWeights;


    for(const auto& action : log.actions) {
        int u = std::min(action.u, action.v);
        int v = std::max(action.u, action.v);
        if (action.added) {
            addedWeights[{u,v}] = action.weight;
        } else {


            removedWeights.insert({ {u,v}, action.weight });


        }
    }


    if (!addedWeights.empty()) {
        logStr+="  Добавлено: ";
        for(const auto& pair_weight : addedWeights) {
            logStr += QString("(%1,%2")

                      .arg(pair_weight.first.first)
                      .arg(pair_weight.first.second)
                      + ") ";
        }
        logStr += "\n";
    }


    if (!removedWeights.empty()) {
        logStr+="  Удалено: ";
        for(const auto& pair_weight : removedWeights) {
            logStr += QString("(%1,%2")

                      .arg(pair_weight.first.first)
                      .arg(pair_weight.first.second)
                      + ") ";
        }
        logStr += "\n";
    }

    return logStr;
}

void MainWindow::processEulerActions() {
    clearBackupAndHamiltonResults();
    clearEulerResultsAndBackup();
    UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
        QMessageBox::warning(this, "Ошибка", "Операции Эйлера применимы к неориентированным графам.");
        tablesCombo->setCurrentIndex(tablesCombo->findText("Эйлеров Путь/Цикл"));
        return;
    }
    if (graph->getRows() < 3 && graph->getRows() > 0) {
         QMessageBox::information(this, "Информация", "Эйлеров цикл невозможен для графа с < 3 вершинами.");
         tablesCombo->setCurrentIndex(tablesCombo->findText("Эйлеров Путь/Цикл"));
         return;
    }

    QString outputLog = "";
    bool modificationAttemptedByUser = false;
    bool modificationSucceeded = false;
    bool searchPathRequested = false;

    try {

        outputLog += "INFO: Сохранение исходного состояния графа...\n";
        originalMatrixDataBackup = graph->getWeightMatrix();
        originalVertexCountBackup = graph->getRows();
        originalAllowsNegativeBackup = graph->allowNegativeWeights;
        backupExists = true;
        outputLog += "INFO: Исходное состояние сохранено.\n\n";


        outputLog += "--- Анализ Исходного Графа ---\n";
        UndirectedGraph::EulerStatus originalStatus = graph->checkEulerianProperties();
        outputLog += QString("Статус: %1 (%2)\n").arg(
            originalStatus.type == UndirectedGraph::EulerType::EULERIAN ? "Эйлеров" :
            originalStatus.type == UndirectedGraph::EulerType::SEMI_EULERIAN ? "Полуэйлеров" :
            originalStatus.type == UndirectedGraph::EulerType::NEITHER ? "Не эйлеров" : "Не связный",
            QString::fromStdString(originalStatus.message)
        );
        if(originalStatus.oddDegreeCount > 0) {
            outputLog += "Вершины неч. степени: " + vectorToString(originalStatus.oddDegreeVertices) + "\n";
        }
        outputLog += "\n";


        if (originalStatus.type == UndirectedGraph::EulerType::NOT_CONNECTED) {
            outputLog += "--- Модификация и Поиск Пути ---\n";
            outputLog += "Операции невозможны: граф не связный.\n";

            eulerResultText->setPlainText(outputLog);
            tablesCombo->setCurrentIndex(tablesCombo->findText("Эйлеров Путь/Цикл"));
            revertEulerButton->setEnabled(false);
            backupExists = false; originalMatrixDataBackup.clear();
            return;
        }


        QMessageBox::StandardButton reply = QMessageBox::No;

                if (originalStatus.type == UndirectedGraph::EulerType::EULERIAN) {
                    outputLog += "--- Модификация Графа ---\n";
                    outputLog += "Модификация не требуется.\n\n";
                    reply = QMessageBox::question(this, "Поиск Цикла", "Граф уже эйлеров. Найти Эйлеров цикл?", QMessageBox::Yes | QMessageBox::No);
                    if (reply == QMessageBox::Yes) searchPathRequested = true;
                }
                else {
                    QString questionText;
                    if (originalStatus.type == UndirectedGraph::EulerType::SEMI_EULERIAN) {
                         int u = originalStatus.oddDegreeVertices[0];
                         int v = originalStatus.oddDegreeVertices[1];
                         if (graph->get(u, v) == 0) {
                              questionText = QString("Граф полуэйлеров. Добавить ребро (%1, %2), чтобы сделать его эйлеровым и найти Эйлеров цикл?").arg(u).arg(v);
                         } else {
                              questionText = QString("Граф полуэйлеров. Ребро (%1, %2) уже существует. Попытаться сделать граф эйлеровым (через 'обходной путь') и найти цикл?").arg(u).arg(v);
                         }
                    } else {
                         questionText = "Граф не (полу)эйлеров. Попытаться модифицировать его (добавить/использовать 'обходные пути'), чтобы найти Эйлеров цикл?";
                    }

                    reply = QMessageBox::question(this, "Модификация / Поиск", questionText, QMessageBox::Yes | QMessageBox::No);
                    if (reply == QMessageBox::Yes) {
                        modificationAttemptedByUser = true;
                        searchPathRequested = true;
                    } else {


                        if (originalStatus.type == UndirectedGraph::EulerType::SEMI_EULERIAN) {
                            reply = QMessageBox::question(this, "Поиск Цепи", "Найти существующую Эйлерову цепь в исходном графе?", QMessageBox::Yes | QMessageBox::No);
                            if (reply == QMessageBox::Yes) searchPathRequested = true;
                        }
                    }
                }


                UndirectedGraph::ModificationLog modLog;
                if (modificationAttemptedByUser) {
                    outputLog += "\n--- Выполнение Модификации ---\n";
                    modificationSucceeded = graph->makeEulerian(modLog);
                    outputLog += QString("Результат модификации: %1\n").arg(QString::fromStdString(modLog.finalMessage));
                    outputLog += formatModificationLog(modLog);
                    outputLog += "\n";


                    updateMatricesForGraph(graph);
                    graphWidget->setGraph(graph);
                    outputLog += "INFO: Визуализация и матрицы обновлены.\n\n";

                    if (!modificationSucceeded) {
                        outputLog += "--- Поиск Пути/Цикла ---\n";
                        outputLog += "Поиск не будет выполнен, так как модификация не привела к эйлерову графу.\n";
                        searchPathRequested = false;
                    }
                } else if (originalStatus.type != UndirectedGraph::EulerType::EULERIAN && searchPathRequested) {

                    outputLog += "--- Модификация Графа ---\n";
                    outputLog += "Модификация не выполнялась (будет искаться путь в исходном полуэйлеровом графе).\n\n";
                } else if (originalStatus.type != UndirectedGraph::EulerType::EULERIAN && !searchPathRequested) {
                     outputLog += "--- Модификация и Поиск Пути ---\n";
                     outputLog += "Пользователь отказался от операций.\n";
                }



                if (searchPathRequested) {
                    outputLog += "--- Поиск Эйлерова Пути/Цикла ---\n";
                    UndirectedGraph::EulerStatus currentStatus = graph->checkEulerianProperties();
                    if (currentStatus.type == UndirectedGraph::EulerType::EULERIAN || currentStatus.type == UndirectedGraph::EulerType::SEMI_EULERIAN) {
                        UndirectedGraph::EulerPathResult pathResult = graph->findEulerPath();
                        outputLog += QString("Результат поиска: %1\n").arg(QString::fromStdString(pathResult.message));
                        if (pathResult.success && !pathResult.path.empty()) {
                             outputLog += QString("Найденный %1 (вершины): %2\n")
                                          .arg(currentStatus.type == UndirectedGraph::EulerType::EULERIAN ? "цикл" : "путь")
                                          .arg(vectorToString(pathResult.path));
                        } else if (pathResult.success && pathResult.path.size() <= 1){
                             outputLog += "Найденный путь (вершины): " + vectorToString(pathResult.path) + "\n";
                        }
                    } else {
                         outputLog += "Поиск невозможен, текущий граф не является (полу)эйлеровым после всех операций.\n";
                         outputLog += "Статус: " + QString::fromStdString(currentStatus.message) + "\n";
                    }
                }


                eulerResultText->setPlainText(outputLog);
                tablesCombo->setCurrentIndex(tablesCombo->findText("Эйлеров Путь/Цикл"));
                if (backupExists) {
                    revertEulerButton->setEnabled(true);
                }

    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Критическая ошибка", QString("Ошибка при обработке Эйлера: %1").arg(e.what()));
        eulerResultText->setPlainText("Критическая ошибка: " + QString(e.what()));
        if (backupExists) revertEulerButton->setEnabled(true);
    } catch (...) {
        QMessageBox::critical(this, "Критическая ошибка", "Неизвестная ошибка при обработке Эйлера.");
        eulerResultText->setPlainText("Неизвестная критическая ошибка.");
        if (backupExists) revertEulerButton->setEnabled(true);
    }
}

void MainWindow::revertEulerChanges() {
    if (!backupExists) {
        QMessageBox::information(this, "Информация", "Нет сохраненного состояния для восстановления.");
        return;
    }
    UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
         QMessageBox::warning(this, "Ошибка", "Текущий граф не является неориентированным.");
         clearEulerResultsAndBackup(); return;
    }
    if (graph->getRows() != originalVertexCountBackup) {
         QMessageBox::warning(this, "Ошибка", "Размер текущего графа не совпадает с сохраненным. Восстановление отменено.");
         clearEulerResultsAndBackup(); return;
    }
     if (originalMatrixDataBackup.size() != (size_t)originalVertexCountBackup || (originalVertexCountBackup > 0 && originalMatrixDataBackup[0].size() != (size_t)originalVertexCountBackup)) {
         QMessageBox::warning(this, "Ошибка", "Данные резервной копии повреждены или имеют неверный размер. Восстановление отменено.");
         clearEulerResultsAndBackup(); return;
     }


    try {
        qDebug() << "Reverting to original graph data...";
        graph->allowNegativeWeights = originalAllowsNegativeBackup;


        for (int i = 0; i < originalVertexCountBackup; ++i) {
            for (int j = 0; j < originalVertexCountBackup; ++j) {
                 graph->set(i, j, originalMatrixDataBackup[i][j]);
            }
        }

        qDebug() << "Graph data reverted. Updating UI.";
        updateMatricesForGraph(graph);
        graphWidget->setGraph(graph);
        clearEulerResultsAndBackup();
        QMessageBox::information(this, "Восстановление", "Исходное состояние графа восстановлено.");

    } catch (const std::exception& e) {
         QMessageBox::critical(this, "Ошибка восстановления", QString("Не удалось восстановить граф: %1").arg(e.what()));
         clearEulerResultsAndBackup();
    } catch (...) {
         QMessageBox::critical(this, "Ошибка восстановления", "Неизвестная ошибка при восстановлении графа.");
         clearEulerResultsAndBackup();
    }
}

void MainWindow::processHamiltonActions() {
    clearBackupAndHamiltonResults();
    UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
        QMessageBox::warning(this, "Ошибка", "Операции Гамильтона применимы к неориентированным графам.");
        tablesCombo->setCurrentIndex(tablesCombo->findText("Гамильтонов Цикл / TSP"));
        return;
    }
    if (graph->getRows() < 3 && graph->getRows() > 0) {
         QMessageBox::information(this, "Информация", "Гамильтонов цикл невозможен для графа с < 3 вершинами.");
         hamiltonResultText->setPlainText("Гамильтонов цикл невозможен (вершин < 3).");
         tablesCombo->setCurrentIndex(tablesCombo->findText("Гамильтонов Цикл / TSP"));
         return;
    }
     if (graph->getRows() == 0) {
         hamiltonResultText->setPlainText("Граф пуст.");
         tablesCombo->setCurrentIndex(tablesCombo->findText("Гамильтонов Цикл / TSP"));
         return;
     }


    QString outputLog = "";
    bool modificationAttempted = false;
    bool modificationSucceeded = false;

    try {

        outputLog += "INFO: Сохранение исходного состояния графа...\n";
        hamiltonOriginalMatrixDataBackup = graph->getWeightMatrix();
        hamiltonOriginalVertexCountBackup = graph->getRows();
        hamiltonOriginalAllowsNegativeBackup = graph->allowNegativeWeights;
        hamiltonBackupExists = true;
        outputLog += "INFO: Исходное состояние сохранено.\n\n";


        outputLog += "--- Поиск Гамильтоновых Циклов в Исходном Графе ---\n";
        UndirectedGraph::HamiltonStatus status = graph->findHamiltonianCyclesAndTSP();
        outputLog += QString::fromStdString(status.message) + "\n";


        if (!status.isHamiltonian) {
            QMessageBox::StandardButton reply;
            reply = QMessageBox::question(this, "Модификация Графа",
                                          "Гамильтоновых циклов не найдено. Хотите попытаться модифицировать граф (добавить ребра 0-1-...-0), чтобы он стал гамильтоновым, и найти циклы в нем?",
                                          QMessageBox::Yes | QMessageBox::No);
            if (reply == QMessageBox::Yes) {
                modificationAttempted = true;
                outputLog += "\n--- Попытка Модификации Графа до Гамильтонова (Упрощенная) ---\n";
                UndirectedGraph::ModificationLog modLog;
                modificationSucceeded = graph->makeHamiltonianApprox(modLog);
                outputLog += QString("Результат модификации: %1\n").arg(QString::fromStdString(modLog.finalMessage));
                outputLog += formatModificationLog(modLog);


                updateMatricesForGraph(graph);
                graphWidget->setGraph(graph);
                outputLog += "INFO: Визуализация и матрицы обновлены.\n\n";

                if (modificationSucceeded) {

                    outputLog += "--- Поиск Гамильтоновых Циклов в Модифицированном Графе ---\n";
                    status = graph->findHamiltonianCyclesAndTSP();
                    outputLog += QString::fromStdString(status.message) + "\n";
                } else {
                    outputLog += "Модификация не привела к гамильтонову графу.\n";
                }
            } else {
                outputLog += "Пользователь отказался от модификации.\n";
            }
        }


        outputLog += "\n--- Детали Найденных Гамильтоновых Циклов ---\n";
        if (status.isHamiltonian) {
            if (status.cycles.size() > 20) {
                outputLog += QString("Найдено %1 гамильтоновых циклов. Из-за большого количества, они не будут выведены на экран.\n").arg(status.cycles.size());
                QMessageBox::StandardButton saveReply = QMessageBox::question(this, "Сохранение циклов",
                                                                             QString("Найдено %1 гамильтоновых циклов. Хотите сохранить их в файл?").arg(status.cycles.size()),
                                                                             QMessageBox::Yes | QMessageBox::No);
                if (saveReply == QMessageBox::Yes) {
                    QString fileName = QFileDialog::getSaveFileName(this, "Сохранить гамильтоновы циклы", "", "Текстовые файлы (*.txt);;Все файлы (*)");
                    if (!fileName.isEmpty()) {
                        QFile file(fileName);
                        if (file.open(QIODevice::WriteOnly | QIODevice::Text)) {
                            QTextStream out(&file);
                            out << "Найдено гамильтоновых циклов: " << status.cycles.size() << "\n";
                            out << "Кратчайший цикл (TSP) имеет вес: " << status.shortestCycle.totalWeight << "\n";
                            out << "Путь кратчайшего цикла: " << vectorToString(status.shortestCycle.path) << "\n\n";
                            out << "Все гамильтоновы циклы:\n";
                            int count = 0;
                            for (const auto& cycle : status.cycles) {
                                out << ++count << ". Вес: " << cycle.totalWeight << ", Путь: " << vectorToString(cycle.path) << "\n";
                            }
                            file.close();
                            outputLog += "Циклы сохранены в файл: " + fileName + "\n";
                        } else {
                            outputLog += "Ошибка сохранения циклов в файл.\n";
                            QMessageBox::warning(this, "Ошибка", "Не удалось сохранить файл.");
                        }
                    } else {
                         outputLog += "Сохранение в файл отменено.\n";
                    }
                }
            } else {
                outputLog += QString("Всего найдено циклов: %1\n").arg(status.cycles.size());
                int count = 0;
                for (const auto& cycle : status.cycles) {
                    count++;
                    outputLog += QString("%1. Вес: %2, Путь: %3\n")
                                 .arg(count)
                                 .arg(cycle.totalWeight)
                                 .arg(vectorToString(cycle.path));
                }
            }
            if (status.shortestCycleFound) {
                outputLog += QString("\nЗадача Коммивояжера (TSP):\n  Кратчайший цикл имеет вес: %1\n  Путь: %2\n")
                             .arg(status.shortestCycle.totalWeight)
                             .arg(vectorToString(status.shortestCycle.path));
            }
        } else {
            outputLog += "Гамильтоновых циклов не найдено.\n";
        }


        hamiltonResultText->setPlainText(outputLog);
        tablesCombo->setCurrentIndex(tablesCombo->findText("Гамильтонов Цикл / TSP"));
        if (hamiltonBackupExists) {
            revertHamiltonButton->setEnabled(true);
        }

    } catch (const std::exception& e) {
        QMessageBox::critical(this, "Критическая ошибка", QString("Ошибка при обработке Гамильтона: %1").arg(e.what()));
        hamiltonResultText->setPlainText("Критическая ошибка: " + QString(e.what()));
        if (hamiltonBackupExists) revertHamiltonButton->setEnabled(true);
    } catch (...) {
        QMessageBox::critical(this, "Критическая ошибка", "Неизвестная ошибка при обработке Гамильтона.");
        hamiltonResultText->setPlainText("Неизвестная критическая ошибка.");
        if (hamiltonBackupExists) revertHamiltonButton->setEnabled(true);
    }
}

void MainWindow::revertHamiltonChanges() {
    if (!hamiltonBackupExists) {
        QMessageBox::information(this, "Информация", "Нет сохраненного состояния для отката операции Гамильтона.");
        return;
    }
    UndirectedGraph* graph = dynamic_cast<UndirectedGraph*>(currentGraph);
    if (!graph) {
         QMessageBox::warning(this, "Ошибка", "Текущий граф не является неориентированным.");
         clearBackupAndHamiltonResults(); return;
    }
    if (graph->getRows() != hamiltonOriginalVertexCountBackup) {
         QMessageBox::warning(this, "Ошибка", "Размер текущего графа не совпадает с сохраненным. Восстановление отменено.");
         clearBackupAndHamiltonResults(); return;
    }
     if (hamiltonOriginalMatrixDataBackup.size() != (size_t)hamiltonOriginalVertexCountBackup || (hamiltonOriginalVertexCountBackup > 0 && hamiltonOriginalMatrixDataBackup[0].size() != (size_t)hamiltonOriginalVertexCountBackup)) {
         QMessageBox::warning(this, "Ошибка", "Данные резервной копии повреждены или имеют неверный размер. Восстановление отменено.");
         clearBackupAndHamiltonResults(); return;
     }

    try {
        qDebug() << "Reverting Hamilton changes...";
        graph->allowNegativeWeights = hamiltonOriginalAllowsNegativeBackup;
        for (int i = 0; i < hamiltonOriginalVertexCountBackup; ++i) {
            for (int j = 0; j < hamiltonOriginalVertexCountBackup; ++j) {
                 graph->set(i, j, hamiltonOriginalMatrixDataBackup[i][j]);
            }
        }
        updateMatricesForGraph(graph);
        graphWidget->setGraph(graph);
        if(hamiltonResultText) hamiltonResultText->clear();
        revertHamiltonButton->setEnabled(false);
        hamiltonBackupExists = false;
        hamiltonOriginalMatrixDataBackup.clear();
        QMessageBox::information(this, "Восстановление", "Изменения операции Гамильтона отменены.");

    } catch (const std::exception& e) {
         QMessageBox::critical(this, "Ошибка восстановления", QString("Не удалось восстановить граф: %1").arg(e.what()));
         clearBackupAndHamiltonResults();
    } catch (...) {
         QMessageBox::critical(this, "Ошибка восстановления", "Неизвестная ошибка при восстановлении графа.");
         clearBackupAndHamiltonResults();
    }
}