全蚁算法（Ant Colony Optimization，ACO）原理和C++实现-CSDN博客

本文链接：https://blog.csdn.net/qq_36812406/article/details/147267441

全蚁算法（Ant Colony Optimization，ACO）是一种模拟蚂蚁觅食行为的优化算法，属于群体智能算法。其灵感来源于蚂蚁在寻找食物的过程中，会通过释放信息素（pheromone）来相互传递信息，从而优化路径选择。全蚁算法通常用于解决最优化问题，特别是组合优化问题，如旅行商问题（TSP）、最大独立集、调度问题等。

全蚁算法原理

全蚁算法的核心思想是通过模拟蚂蚁在环境中选择路径的过程，并利用蚂蚁之间的信息素相互作用来引导搜索过程。每个蚂蚁在搜索空间中移动，并根据当前路径的信息素浓度来选择下一个节点，优先选择信息素浓度较高的路径。随着算法迭代，信息素会逐渐浓缩在最优路径上，最终收敛到全局最优解。

主要步骤

初始化：
- 设置蚁群的数量、最大迭代次数、信息素蒸发系数等参数。
- 初始化信息素矩阵 $\tau_{ij} )$ ，通常在一开始设为常数。
蚂蚁搜索过程：
- 每只蚂蚁根据当前节点选择下一个节点，选择的概率由路径的质量和信息素浓度共同决定。路径选择的概率为：
  $P_{ij} = \frac{\tau_{ij}^{\alpha} \eta_{ij}^{\beta}}{\sum_{k \in N_i} \tau_{ik}^{\alpha} \eta_{ik}^{\beta}} ]$
  其中：
  - $\tau_{ij} )$ 是从节点 $(i)$ 到节点 $(j)$ 的信息素浓度。
  - $\eta_{ij} )$ 是启发式信息，通常是路径的质量度量（如距离、时间等的倒数）。
  - $\alpha )$ 和 $\beta )$ 分别控制信息素和启发式信息的影响程度。
  - $N_i )$ 是节点 $(i)$ 的邻居节点集合。
信息素更新：
- 每一轮迭代结束后，更新信息素。信息素更新包括信息素的蒸发和增加。
  - 信息素蒸发：
    $\tau_{ij}(t+1) = (1 - \rho) \tau_{ij}(t) ]$
    其中， $\rho )$ 是信息素蒸发系数（通常 $\rho < 1 )$ ）。
  - 信息素增加：根据信息素更新规则，最优路径的信息素将增加，以吸引更多蚂蚁选择最优路径：
    $\tau_{ij}(t+1) = \tau_{ij}(t) + \Delta \tau_{ij} ]$
    其中 $\Delta \tau_{ij} )$ 是与路径质量相关的信息素增量。
终止条件：
- 根据最大迭代次数、时间或最优解的变化进行终止。

推导

全蚁算法的核心是路径选择概率的定义。每只蚂蚁在选择路径时依据信息素和启发式信息进行权衡。设 $KaTeX parse error: Can't use function '\)' in math mode at position 5: ( i \̲)̲$ 和 $(j)$ 是两个节点，蚂蚁从节点 $(i)$ 移动到节点 $(j)$ 的概率可以表示为：
$P_{ij} = \frac{\tau_{ij}^{\alpha} \eta_{ij}^{\beta}}{\sum_{k \in N_i} \tau_{ik}^{\alpha} \eta_{ik}^{\beta}} ]$

$\tau_{ij}^{\alpha} )$ 控制信息素的影响（如果 $\alpha = 0 )$ ，则忽略信息素的影响）。
$\eta_{ij}^{\beta} )$ 控制启发式信息（如距离的倒数）的影响。

随着蚂蚁不断地在搜索空间中移动并更新信息素，最优路径的信息素浓度会逐渐增大，从而吸引更多的蚂蚁选择该路径。

C++ 代码实现

下面是一个简单的旅行商问题（TSP）的全蚁算法实现，其中使用的是常见的二次信息素更新方法。

#include <iostream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

class AntColony {
public:
    AntColony(int cities, int ants, double alpha, double beta, double rho, double Q);
    void solve();
    double getBestDistance() { return bestDistance; }

private:
    int numCities;           // 城市数
    int numAnts;             // 蚂蚁数
    double alpha, beta, rho, Q;  // 算法参数
    vector<vector<double>> dist; // 距离矩阵
    vector<vector<double>> pheromone; // 信息素矩阵
    vector<int> bestTour;   // 最优路径
    double bestDistance;    // 最优路径长度

    void initialize();
    void updatePheromone(const vector<int>& tour, double tourLength);
    vector<int> constructTour();
    double computeTourLength(const vector<int>& tour);
    void evaporatePheromone();
    void depositPheromone(const vector<int>& tour, double tourLength);
    int selectNextCity(int currentCity, vector<bool>& visited);
};

AntColony::AntColony(int cities, int ants, double alpha, double beta, double rho, double Q)
    : numCities(cities), numAnts(ants), alpha(alpha), beta(beta), rho(rho), Q(Q) {
    initialize();
}

void AntColony::initialize() {
    dist.resize(numCities, vector<double>(numCities));
    pheromone.resize(numCities, vector<double>(numCities, 1.0));  // 初始化信息素
    bestDistance = INFINITY;

    // 随机生成城市间的距离矩阵
    srand(time(0));
    for (int i = 0; i < numCities; i++) {
        for (int j = i + 1; j < numCities; j++) {
            dist[i][j] = dist[j][i] = rand() % 100 + 1;  // 随机生成 1 到 100 的距离
        }
    }
}

double AntColony::computeTourLength(const vector<int>& tour) {
    double length = 0;
    for (int i = 0; i < numCities - 1; i++) {
        length += dist[tour[i]][tour[i + 1]];
    }
    length += dist[tour[numCities - 1]][tour[0]];  // 完成回路
    return length;
}

void AntColony::evaporatePheromone() {
    for (int i = 0; i < numCities; i++) {
        for (int j = 0; j < numCities; j++) {
            pheromone[i][j] *= (1.0 - rho);
        }
    }
}

void AntColony::depositPheromone(const vector<int>& tour, double tourLength) {
    for (int i = 0; i < numCities - 1; i++) {
        int from = tour[i];
        int to = tour[i + 1];
        pheromone[from][to] += Q / tourLength;
        pheromone[to][from] += Q / tourLength;  // 因为路径是无向的
    }
    int from = tour[numCities - 1];
    int to = tour[0];
    pheromone[from][to] += Q / tourLength;
    pheromone[to][from] += Q / tourLength;
}

int AntColony::selectNextCity(int currentCity, vector<bool>& visited) {
    vector<double> probabilities(numCities, 0.0);
    double sum = 0.0;

    for (int i = 0; i < numCities; i++) {
        if (!visited[i]) {
            probabilities[i] = pow(pheromone[currentCity][i], alpha) * pow(1.0 / dist[currentCity][i], beta);
            sum += probabilities[i];
        }
    }

    for (int i = 0; i < numCities; i++) {
        probabilities[i] /= sum;
    }

    double randVal = (rand() % 10000) / 10000.0;
    sum = 0.0;
    for (int i = 0; i < numCities; i++) {
        if (!visited[i]) {
            sum += probabilities[i];
            if (sum >= randVal) {
                return i;
            }
        }
    }
    return -1;
}

vector<int> AntColony::constructTour() {
    vector<int> tour(numCities);
    vector<bool> visited(numCities, false);
    int currentCity = rand() % numCities;
    tour[0] = currentCity;
    visited[currentCity] = true;

    for (int i = 1; i < numCities; i++) {
        currentCity = selectNextCity(tour[i - 1], visited);
        tour[i] = currentCity

;
        visited[currentCity] = true;
    }

    return tour;
}

void AntColony::updatePheromone(const vector<int>& tour, double tourLength) {
    if (tourLength < bestDistance) {
        bestDistance = tourLength;
        bestTour = tour;
    }
    depositPheromone(tour, tourLength);
}

void AntColony::solve() {
    for (int iter = 0; iter < 1000; iter++) {
        vector<vector<int>> allTours(numAnts);
        for (int ant = 0; ant < numAnts; ant++) {
            allTours[ant] = constructTour();
            double tourLength = computeTourLength(allTours[ant]);
            updatePheromone(allTours[ant], tourLength);
        }
        evaporatePheromone();
    }
}

int main() {
    AntColony ac(10, 50, 1.0, 5.0, 0.1, 100.0);
    ac.solve();
    cout << "Best tour length: " << ac.getBestDistance() << endl;
    return 0;
}