Algartam Cuardach Néal (Cloud Search) i C++- Míniú, Sampla agus Cód

Is modh cuardaigh é an algartam Cloud Search a chuimsíonn sraith mhór réitigh randamach a ghiniúint, dá ngairtear an "scamall" go minic, agus ansin cuardach a dhéanamh ar na réitigh is fearr laistigh den tacar seo. Úsáidtear an cur chuige seo go coitianta chun neas-réitigh a fháil ar fhadhbanna casta nuair nach mbíonn treoir shonrach ar fáil.

Conas a oibríonn sé

1. Túsú scamall: Cruthaigh sraith mhór réitigh randamach(an scamall).
2. Measúnú: Déan cáilíocht gach réitigh sa scamall a mheas bunaithe ar an bhfeidhm oibiachtúil nó ar na critéir mheastóireachta.
3. Roghnú: Roghnaigh fo-thacar de na réitigh is fearr ón néal bunaithe ar dhóchúlachtaí nó ar chritéir roghnúcháin.
4. Feabhsú: Feabhas a chur ar chaighdeán na réitigh sa scamall trí chlaochlú nó leas iomlán a bhaint as.
5. Atriall: Déan céimeanna 2 go 4 arís go dtí go mbaintear amach toradh sásúil nó go mbaintear amach líon réamhshainithe atriallta.

Sampla: Cuardach Néal don Fhadhb Díoltóir Taistil

Smaoinigh ar Fhadhb an Díoltóra Taistil(TSP), áit a bhfuil sé mar sprioc an timthriall Hamilton is giorra a thugann cuairt ar gach cathair a aimsiú. Is féidir leis an modh Cloud Search líon mór timthriallta Hamiltonian randamach a ghiniúint, ansin roghnaigh an timthriall leis an gcostas is ísle.

Sampla Cód 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;  
}  

Sa sampla seo, úsáidimid an modh Cloud Search chun an TSP a réiteach. Gineann muid líon mór de thimthriallta randamacha Hamiltonian trí na cathracha a shuffadh go randamach, ansin ríomh an costas do gach timthriall agus roghnaigh an timthriall leis an gcostas is ísle.