Algoritmul de căutare în cloud (Cloud Search) în C++- Explicație, Exemplu și Cod

Algoritmul de căutare în cloud este o metodă de căutare care implică generarea unui set mare de soluții aleatorii, adesea denumite „nor”, ​​și apoi căutarea celor mai bune soluții din acest set. Această abordare este folosită în mod obișnuit pentru a găsi soluții aproximative pentru probleme complexe atunci când nu sunt disponibile îndrumări specifice.

Cum functioneaza

1. Inițializarea cloud: creați un set mare de soluții aleatorii(clorul).
2. Evaluare: Evaluați calitatea fiecărei soluții din cloud pe baza funcției obiective sau a criteriilor de evaluare.
3. Selecție: selectați un subset al celor mai bune soluții din cloud pe baza probabilităților sau a criteriilor de selecție.
4. Îmbunătățire: Îmbunătățiți calitatea soluțiilor din cloud prin aplicarea de transformări sau optimizări.
5. Iterație: Repetați pașii de la 2 la 4 până când se obține un rezultat satisfăcător sau se ajunge la un număr predefinit de iterații.

Exemplu: Căutare în cloud pentru problema vânzătorului ambulant

Luați în considerare problema vânzătorului ambulant(TSP), unde scopul este de a găsi cel mai scurt ciclu hamiltonian care vizitează toate orașele. Metoda Cloud Search poate genera un număr mare de cicluri hamiltoniene aleatoare, apoi selectați ciclul cu cel mai mic cost.

Exemplu de cod în C++

#include <iostream>  
#include <vector>  
#include <algorithm>  
#include <ctime>  
#include <cstdlib>  
  
struct City {  
    int x;  
    int y;  
};  
  
double calculateDistance(const City& city1, const City& city2) {  
    return std::sqrt((city1.x- city2.x)*(city1.x- city2.x) +(city1.y- city2.y)*(city1.y- city2.y));  
}  
  
double cloudSearchTSP(std::vector<City>& cities, int maxIterations) {  
    int numCities = cities.size();  
    double bestDistance = std::numeric_limits<double>::max();  
  
    srand(time(0));  
  
    for(int i = 0; i < maxIterations; ++i) {  
        std::random_shuffle(cities.begin(), cities.end());  
  
        double totalDistance = 0.0;  
        for(int j = 0; j < numCities- 1; ++j) {  
            totalDistance += calculateDistance(cities[j], cities[j + 1]);  
        }  
        totalDistance += calculateDistance(cities[numCities- 1], cities[0]);  
  
        bestDistance = std::min(bestDistance, totalDistance);  
    }  
  
    return bestDistance;  
}  
  
int main() {  
    std::vector<City> cities = {{0, 0}, {1, 2}, {3, 1}, {4, 3}, {2, 4}};  
    int maxIterations = 1000;  
    double shortestDistance = cloudSearchTSP(cities, maxIterations);  
  
    std::cout << "Shortest distance in TSP: " << shortestDistance << std::endl;  
  
    return 0;  
}  

În acest exemplu, folosim metoda Cloud Search pentru a rezolva TSP. Generăm un număr mare de cicluri hamiltoniene aleatoare prin amestecarea aleatorie a orașelor, apoi calculăm costul pentru fiecare ciclu și selectăm ciclul cu cel mai mic cost.