Cloud Search (Cloud Search) Algoritme i C++- Forklaring, eksempel og kode

Cloud Search-algoritmen er en søgemetode, der involverer generering af et stort sæt af tilfældige løsninger, ofte omtalt som "skyen", og derefter søge efter de bedste løsninger inden for dette sæt. Denne tilgang bruges almindeligvis til at finde omtrentlige løsninger på komplekse problemer, når der ikke er nogen specifik vejledning tilgængelig.

Hvordan det virker

1. Cloud-initialisering: Opret et stort sæt af tilfældige løsninger(skyen).
2. Evaluering: Evaluer kvaliteten af ​​hver løsning i skyen baseret på den objektive funktion eller evalueringskriterier.
3. Udvælgelse: Vælg en delmængde af de bedste løsninger fra skyen baseret på sandsynligheder eller udvælgelseskriterier.
4. Forbedring: Forbedre kvaliteten af ​​løsninger i skyen ved at anvende transformationer eller optimeringer.
5. Iteration: Gentag trin 2 til 4, indtil et tilfredsstillende resultat er opnået eller et foruddefineret antal iterationer er nået.

Eksempel: Cloudsøgning efter problemet med den rejsende sælger

Overvej Traveling Salesman Problem(TSP), hvor målet er at finde den korteste Hamilton-cyklus, der besøger alle byer. Cloud Search-metoden kan generere et stort antal tilfældige Hamilton-cyklusser, og vælg derefter cyklussen med den laveste pris.

Kodeeksempel i 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;  
}  

I dette eksempel bruger vi Cloud Search-metoden til at løse TSP. Vi genererer et stort antal tilfældige Hamilton-cyklusser ved at blande byerne tilfældigt, beregne omkostningerne for hver cyklus og vælge den cyklus med den laveste pris.